Si Python est interprété, ce sont des fichiers .pyc?

https://stackoverflow.com/questions/2998215

24-10-2019
|

Question

J'ai été donné de comprendre que Python est un langage interprété ... Cependant, quand je regarde mon code source Python que je vois les fichiers .pyc, qui Windows identifie comme « Compilé Python Files ». D'où viennent ces en?

La solution

Ils contiennent octet code, qui est ce que l'interpréteur Python compile la source. Ce code est ensuite exécuté par la machine virtuelle Python.

documentation de Python explique la définition comme ceci:

Python est un langage interprété, comme opposition à une compilation, bien que le distinction peut être floue en raison de la présence du compilateur bytecode. Cela signifie que les fichiers source peuvent être exécuter directement sans explicitement la création d'un fichier exécutable qui est ensuite run.

Autres conseils

J'ai été donné de comprendre que Python est un langage interprété ...

Ce mème populaire est incorrect, ou plutôt, construit sur une mauvaise compréhension des niveaux de langue (naturel): une erreur similaire serait de dire « la Bible est un livre à couverture rigide ». Permettez-moi d'expliquer que ... simile

« La Bible » est « un livre » dans le sens d'être un classe (réels, objets physiques identifiés comme livres); les livres identifiés comme « exemplaires de la Bible » sont censés avoir quelque chose de fondamental en commun (le contenu, bien que même ceux-ci peuvent être dans des langues différentes, avec différentes traductions acceptables, des niveaux de bas de page et autres annotations) - cependant, ces livres sont parfaitement autorisé à varier dans une myriade d'aspects qui sont pas considéré comme fondamental - type de fixation, la couleur de la liaison, la police (s) utilisé dans l'impression, les illustrations le cas échéant, de larges marges inscriptibles ou non , des chiffres et des types de signets builtin, et ainsi de suite, et ainsi de suite.

Il est tout à fait possible que typique l'impression de la Bible serait en effet en couverture rigide contraignant - après tout, il est un livre qui est généralement destiné à être lu à plusieurs reprises, structurée à plusieurs endroits, fait un pied grâce à la recherche de pointeurs chapitre et verset données, etc, etc, et une bonne couverture rigide de liaison peut faire une copie donnée durer plus longtemps sous une telle utilisation. Cependant, ce sont banales questions (pratiques) qui ne peuvent pas être utilisées pour déterminer si un objet livre réel donné est une copie de la Bible ou non: de poche sont des impressions parfaitement possible

De même, Python est « une langue » au sens de la définition d'une classe de langue implémentations qui doivent tous être semblables à certains égards fondamentaux (syntaxe, la plupart sémantique sauf les parties de ceux où ils sont explicitement autorisés à différer) mais sont entièrement autorisés à différer dans à peu près tous les détails « de mise en œuvre » - y compris la façon dont ils traitent les fichiers source ils sont donnés, qu'ils compilent les sources à une faible formes de niveau (et, si oui, qui forment - et s'ils économisent ces formes compilées, sur le disque ou ailleurs)., comment ils exécutent ces formes, et ainsi de suite

La mise en œuvre classique, CPython, est souvent appelé simplement « Python » pour faire court - mais il est juste un de plusieurs implémentations de qualité de production, côte à côte avec IronPython Microsoft (qui compile des codes CLR, à savoir, « .NET » ), Jython (qui compile à codes JVM), PyPy (qui est écrit en Python lui-même et peut compiler à une grande variété de formes « back-end », y compris « juste à temps » généré langage machine). Ils sont tous Python (== « implémentations du langage Python »), tout comme de nombreux objets de livre superficiellement différentes peuvent tous être Bibles (== « copies de la Bible »).

Si vous êtes intéressé à CPython spécifiquement: il compile les fichiers source en une forme plus faible niveau spécifique à Python (connu sous le nom « bytecode »), le fait automatiquement en cas de besoin (quand il n'y a pas de fichier bytecode correspondant à une source fichier ou le fichier bytecode est plus ancienne que la source ou compilé par une autre version Python), enregistre généralement les fichiers bytecode sur le disque (pour éviter les recompiler à l'avenir). OTOH IronPython va généralement compiler des codes CLR (pour les enregistrer sur disque ou non, en fonction) et Jython aux codes JVM (les enregistrer sur le disque ou non - il utilisera l'extension .class si elle ne les sauver).

Ces formes de niveau inférieur sont alors exécutées par des « machines virtuelles » appropriées aussi appelées « interprètes » -. La machine virtuelle CPython, le moteur d'exécution .Net, la machine virtuelle Java (JVM) alias, selon le cas

Alors, dans ce sens (qu'est-ce que les implémentations typiques font), Python est un « langage interprété » si et seulement si C # et Java sont: tous ont une stratégie de mise en œuvre typique de la production bytecode d'abord, puis l'exécuter via un VM / interprète.

Il est plus probable l'accent est mis sur la façon dont « lourd », Lent, et cérémonie de haut le processus de compilation est. CPython est conçu pour compiler le plus vite possible, aussi légère que possible, avec aussi peu de cérémonie que possible - le compilateur fait très peu d'erreur de vérification et d'optimisation, il peut courir vite et en petites quantités de mémoire, qui à son tour laisse être exécuté automatiquement et de façon transparente en cas de besoin, sans que l'utilisateur même d'être conscient qu'il ya une compilation en cours, la plupart du temps. Java et C # acceptent généralement plus de travail lors de la compilation (et donc ne pas effectuer la compilation automatique) afin de vérifier plus à fond les erreurs et effectuer des optimisations. Il est un continuum d'échelles de gris, pas une situation noire ou blanche, et il serait tout à fait arbitraire de mettre un seuil à un niveau donné et dire que seulement au-dessus de ce niveau que vous appelez « compilation » -)

Il n'y a pas une telle chose comme un langage interprété. Que ce soit un interprète ou d'un compilateur utilisé est purement un trait de la mise en œuvre et n'a absolument rien à voir avec la langue.

Chaque langue peut être mis en œuvre soit par un interprète ou d'un compilateur. La grande majorité des langues ont au moins une mise en œuvre de chaque type. (Par exemple, il y a des interprètes pour C et C ++ et il y a des compilateurs pour JavaScript, PHP, Perl, Python et Ruby.) De plus, la majorité des implémentations de langage moderne se combinent en fait à la fois un interprète et un compilateur (ou même des compilateurs multiples).

Une langue est juste un ensemble de règles mathématiques abstraites. Un interprète est l'une des stratégies de mise en œuvre concrètes pour une langue. Les deux vivent sur les niveaux d'abstraction complètement différentes. Si l'anglais était une langue dactylographiée, le terme « langage interprété » serait une erreur de type. La déclaration « Python est un langage interprété » est non seulement fausse (parce qu'être faux impliquerait que la déclaration fait même sens, même si elle est fausse), il ne fait pas tout simplement sens , parce que une langue peut jamais être défini comme "interprété."

En particulier, si vous regardez les implémentations Python existant actuellement, ce sont les stratégies de mise en œuvre qu'ils utilisent:

IronPython: compiles à arbres DLR que le DLR compile ensuite à bytecode CIL. Qu'est-ce qui se passe au bytecode CIL dépend de qui CLI VES vous utilisez, mais Microsoft .NET, GNU Portable.NET et Novell Mono finira par le compiler en code machine natif.
Jython: Python interprète sourcecode jusqu'à ce qu'il identifie les chemins de code à chaud, qu'il compile ensuite à JVML bytecode. Qu'est-ce qui se passe à l'bytecode JVML dépend de laquelle JVM vous exécutez sur. Maxine compilera directement à un code natif optimisé jusqu'à ce qu'il identifie les chemins de code à chaud, qu'il recompile ensuite le code natif optimisé. HotSpot d'abord interpréter le bytecode JVML puis éventuellement compiler les chemins de code à chaud à code machine optimisé.
PyPy:. Compiles à PyPy bytecode, qui est ensuite interprété par la machine virtuelle PyPy jusqu'à ce qu'il identifie les chemins de code à chaud qui sont compilés puis en code natif, JVML bytecode ou CIL bytecode en fonction de la plate-forme que vous utilisez sur
CPython. Compiles à CPython bytecode qu'il a ensuite interprète
Stackless Python. Compiles à CPython bytecode qu'il a ensuite interprète
hirondel. Compiles à CPython bytecode qu'il a ensuite interprète jusqu'à ce qu'il identifie les chemins de code à chaud qui sont compilés puis LLVM IR que le compilateur LLVM compile ensuite le code machine natif
Cython: compile le code python à code portable de C, qui est ensuite compilé avec un compilateur C standard
Nuitka: compile le code Python au code dépend de la machine-C ++, qui est ensuite compilé avec un compilateur standard C

Vous remarquerez peut-être que chacune des mises en œuvre dans cette liste (et quelques autres que je ne l'ai pas mentionné, comme tinypy, Shedskin ou Psyco) a un compilateur. En fait, autant que je sache, il n'y a actuellement aucune implémentation Python qui est purement interprété, il n'y a pas de mise en œuvre prévue et il n'y a jamais eu une telle mise en œuvre.

Non seulement le terme « langage interprété » pas de sens, même si vous l'interpréter comme signifiant « langue mise en œuvre interprété », il est clairement pas vrai. Celui qui vous a dit que, de toute évidence ne sait pas ce qu'il parle.

En particulier, les fichiers .pyc que vous voyez sont mises en cache bytecode fichiers produits par CPython, Stackless Python ou hirondel.

Ils sont créés par l'interpréteur Python lorsqu'un fichier .py est importé, et ils contiennent le « bytecode compilé » du module / programme importé, l'idée étant que la « traduction » du code source en bytecode (qui doit seulement être fait une fois) peut être sautée sur imports suivantes si le .pyc est plus récent que le fichier correspondant .py, accélérant ainsi le démarrage un peu. Mais il est toujours interprété.

Pour accélérer le chargement des modules, Python met en cache le contenu compilé des modules .pyc.

CPython compile son code source dans « byte code », et pour des raisons de performance, il met en cache ce code octet sur le système de fichiers chaque fois que le fichier source a des changements. Cela rend le chargement de modules Python beaucoup plus rapide car la phase de compilation peut être contournée. Lorsque votre fichier source est foo.py, CPython met en cache le code d'octets dans un fichier foo.pyc juste à côté de la source.

Dans python3, la machine d'importation de Python est étendu écrire et rechercher des fichiers de cache de code d'octets dans un seul répertoire dans chaque répertoire de package Python. Ce répertoire sera appelé __pycache__.

Voici un organigramme décrivant la façon dont les modules sont chargés:

Pour plus d'informations:

ref: PEP3147
ref: « Compilé » fichiers Python

C'EST POUR DEBUTANTS,

Python compile automatiquement votre script code compilé, ainsi appelé code octet, avant de l'exécuter.

L'exécution d'un script n'est pas considéré comme une importation et pas .pyc sera créé.

Par exemple, si vous avez un fichier script abc.py que les importations d'un autre module xyz.py , lorsque vous exécutez abc.py , xyz.pyc seront créés depuis xyz est importé, mais aucun fichier abc.pyc sera créé depuis abc.py n'est pas importé.

Si vous devez créer un fichier .pyc pour un module qui est pas importé, vous pouvez utiliser les modules de py_compile et compileall.

Le module de py_compile peut compiler manuellement tous les modules. Une façon est d'utiliser la fonction py_compile.compile dans ce module interactif:

>>> import py_compile
>>> py_compile.compile('abc.py')

rédigera le .pyc au même endroit que abc.py (vous pouvez remplacer que le paramètre optionnel cfile).

Vous pouvez également compiler automatiquement tous les fichiers dans un répertoire ou des répertoires en utilisant le module compileall.

python -m compileall

Si le nom du répertoire (le répertoire courant dans cet exemple) est omis, le module tout de compiles trouvé sur sys.path

python (au moins la mise en œuvre la plus courante de celui-ci) suit un schéma de compilation de la source d'origine à des codes d'octet, alors l'interprétation des codes d'octet sur une machine virtuelle. Ce moyen (encore une fois, la plus mise en œuvre commune) est ni un interprète pur, ni un compilateur pur.

L'autre côté de ceci est, cependant, que le processus de compilation est la plupart du temps caché - les fichiers .pyc sont essentiellement traités comme un cache; ils accélérer les choses, mais vous ne doit normalement pas être au courant du tout. Il automatiquement Invalide et les rechargements (re-compile le code source) si nécessaire en fonction du temps fichier / timbres de date.

A propos de la seule fois que je l'ai vu un problème avec ce fut quand un puits fichier bytecode compilé a en quelque sorte un horodatage dans l'avenir, ce qui signifiait-il toujours plus récent que le fichier avait l'air source. Comme il avait l'air plus récent, le fichier source n'a jamais été recompilé, donc peu importe les changements que vous avez fait, ils ont été ignorés ...

fichier * .py Python est juste un fichier texte dans lequel vous écrivez quelques lignes de code. Lorsque vous essayez d'exécuter ce fichier en utilisant par exemple « filename.py python »

Cette commande appelle une machine virtuelle Python. Python machine virtuelle dispose de 2 composants: « compilateur » et « interprète ». Interprète ne peut pas lire directement le texte dans le fichier * .py, de sorte que ce texte est d'abord converti en un code binaire qui est destiné à la PVM (pas de matériel mais PVM) . PVM exécute ce code d'octets. * Fichier .pyc est également généré, dans le cadre de son fonctionnement qui effectue votre opération d'importation sur fichier shell ou dans un autre fichier.

Si ce fichier * .pyc est déjà généré alors à chaque fois suivante vous exécutez / exécuter votre fichier * .py, système charge directement votre fichier * .pyc que vous aurez pas besoin de compilation (Cela permettra d'économiser quelques cycles de la machine de processeur).

Une fois le fichier * .pyc est généré, il n'y a pas besoin de fichier * .py, à moins que vous le modifier.

Code python passe par 2 étapes. La première étape compile le code dans des fichiers .pyc qui est en fait un bytecode. Ensuite, ce fichier .pyc (bytecode) est interprété à l'aide interprète CPython. S'il vous plaît se référer à ce lien . Ici processus de compilation de code et l'exécution est expliquée en termes faciles.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow