À quoi sert le fichier __pycache__ dans le projet Python?

Aujourd'hui, j'ai écrit un code Python, qui contient deux fonctions que j'ai écrites moi-même, appelées is_python.py et rgb2gray.py. J'ai trouvé qu'après que la fonction principale les appelle et s'exécute, il y a un fichier nommé _ dans le répertoire principal du dossier. Le fichier _pycache__ contient deux fichiers nommés comme suit

is_rgb.cpython-36.pyc
rgb2gray.cpython-36.pyc

On constate que la fin de ces deux fichiers est .cpython-36.pyc, où cpython représente l'interpréteur Python implémenté en langage C, et -36 représente la version Python utilisée est 3.6

Parlons de ceci pyc: pyc est un fichier binaire obtenu en compilant le fichier py. Une fois que le fichier py devient un fichier pyc, la vitesse de chargement est améliorée et pyc est un bytecode multiplateforme, qui est exécuté par la machine virtuelle python , qui est similaire au concept de la machine virtuelle JAVA. Et si vous utilisez Python pour développer un logiciel commercial, vous devez le compiler en pyc, puis le publier pour éviter les fuites de code source. Hahaha, ça semble un peu trop loin, reparlons-en

Regardons d'abord un exemple pour comprendre ce qui se passe lorsque Python appelle un module

Le module appelé est nommé function.py:

"""
    文件名：function.py
"""


def function():
    print("被调用函数输出")


function()

Le fichier principal du programme est nommé main.py:

"""
    文件名：main.py
"""

import function

print("主函数输出")

Résultat d'exécution du programme principal:

被调用函数输出
主函数输出

Résultat d'exécution du module appelé:

被调用函数输出

C’est étonnant de constater que le programme principal exécute le module appelé du début à la fin.

Alors, comment le programme principal Python peut-il appeler le module simplement et ne pas l'exécuter en premier? - pour comprendre quelle propriété __name__! !

 En python, les modules sont des objets, chaque module a un attribut intégré __name__, et la valeur de __name__ dépend de la façon dont le module est appliqué

① Si vous importez un module, la valeur du module __name__ est généralement le nom du fichier du module, sans le chemin ni l'extension de fichier

② Si vous exécutez le module directement comme un programme standard, la valeur de __name__ sera une valeur par défaut spéciale "__main__"

Avec les connaissances ci-dessus, nous pouvons éviter d'exécuter le module du début à la fin lors de l'appel du module. Le code spécifique est le suivant

Le module appelé est nommé function.py:

"""
    文件名：function.py
"""


def function():
    print("被调用函数输出")


if __name__ == '__main__':
    function()

Le fichier principal du programme est nommé main.py:

"""
    文件名：main.py
"""
import function

print("主函数输出")

Le résultat de l'exécution de la fonction principale:

主函数输出

Résultat d'exécution du module appelé:

被调用函数输出

Cela dit, parlons un peu du langage informatique

① Langage compilé: la compilation fait référence à la "traduction" du code source du programme en code cible (langage machine) avant l'exécution du programme source de l'application, de sorte que le programme cible puisse être exécuté indépendamment de son environnement de langage, ce qui est plus pratique et efficace à utiliser . Cependant, une fois que le programme d'application doit être modifié, le code source doit d'abord être modifié, puis recompilé pour générer un nouveau fichier objet (* .OBJ) avant de pouvoir être exécuté. Il n'y a qu'un fichier objet et pas de code source, ce qui est très peu pratique à modifier. La plupart des langages de programmation de nos jours sont compilés. Le compilateur traduit le programme source en programme cible et l'enregistre dans un autre fichier. Le programme cible peut s'exécuter directement sur l'ordinateur sans le compilateur. La plupart des produits logiciels sont fournis aux utilisateurs sous la forme de programmes cibles, ce qui non seulement facilite le fonctionnement direct, mais rend également difficile pour les autres de détourner les technologies. C, C ++, Fortran et Pascal sont tous implémentés par compilation.

② Langage interprété: dans l'implémentation du langage interprété, le traducteur ne génère pas de code machine cible, mais génère un code intermédiaire facile à exécuter. Ce code intermédiaire est différent du code machine, et l'interprétation du code intermédiaire est prise en charge par un logiciel, Le matériel ne peut pas être utilisé directement et l'interpréteur logiciel conduit généralement à une efficacité d'exécution moindre. Un programme écrit dans un langage interprété est exécuté par un autre interpréteur capable de comprendre le code intermédiaire. Différente du compilateur, la tâche de l'interpréteur est d'interpréter les instructions du programme source en instructions machine exécutables une par une, sans qu'il soit nécessaire de traduire le programme source en code objet, puis de l'exécuter. L'avantage du programme d'interprétation est que lorsqu'une erreur de syntaxe se produit dans une instruction, elle peut immédiatement attirer l'attention du programmeur et le programmeur peut la corriger pendant le développement du programme. Pour la langue de base interprétée, un interpréteur spécial est nécessaire pour interpréter et exécuter le programme de base, et chaque langue n'est traduite que lorsqu'elle est exécutée. Cette langue interprétée est traduite à chaque exécution, elle est donc inefficace. Généralement, les langages dynamiques sont interprétés, tels que Tcl, Perl, Ruby, VBScript, JavaScript, etc.

③ Langage mixte (compilez d'abord puis interprétez) : Java est très spécial, et les programmes Java doivent également être compilés, mais il n'est pas directement compilé et appelé langage machine, mais est compilé en bytecode, puis les octets sont exécutés dans un manière sur le code de la machine virtuelle Java. Python adopte également un mode de compilation similaire à Java. Le programme Python est d'abord compilé dans le bytecode Python, puis un interpréteur spécial de bytecode Python est chargé d'interpréter et d'exécuter le bytecode.

Par conséquent, le programme Python n'a pas besoin d'être compilé en code binaire lorsqu'il est en cours d'exécution, mais le programme est exécuté directement à partir du code source

En termes simples, l' interpréteur Python convertit le code source en bytecode, puis l'interpréteur exécute le bytecode

Le travail spécifique de l'interprète:

1. Terminez le chargement et la liaison du module

2. Compilez le code source dans un objet PyCodeObject (c'est-à-dire bytecode) et écrivez-le dans la mémoire pour que le CPU le lise

3. Le processeur lit le bytecode en cours d'exécution dans la mémoire et écrit le bytecode sur le disque dur après la fin, c'est-à-dire copiez-le dans le fichier .pyc ou .pyo pour enregistrer les fichiers bytecode de tous les scripts du répertoire courant

Si le script est à nouveau exécuté par la suite, il vérifiera d'abord [s'il existe localement le fichier bytecode ci-dessus] et [si l'heure de modification du fichier bytecode est après le fichier source] , puis l'exécutera directement, sinon répétez ce qui précède 1 2 3 étapes.

Ensuite, quelques amis ont des questions, quelle est la signification du dossier __pycache__?

Parce que lorsque le code est exécuté pour la première fois, l'interpréteur Python a déjà mis le bytecode compilé dans le dossier __pycache__, donc si vous le réexécutez à l'avenir, si le module appelé n'a pas changé, ignorez l'étape de compilation., Accédez directement au dossier __pycache__ pour exécuter le fichier * .pyc correspondant, ce qui raccourcit considérablement le temps de préparation avant l'exécution du projet