Python Compilation/Interprétation

J'essaie de comprendre le python compilateur/interpréteur de processus plus clairement. Malheureusement, je n'ai pas pris une classe en interprètes et je n'ai pas beaucoup lu sur eux.

Fondamentalement, ce que je comprends est que, actuellement, le code Python de .py fichiers est d'abord compilé en bytecode python (qui je suppose sont la .pyc fichiers je vois de temps en temps?). Ensuite, le pseudo-code est compilé en code machine, une langue que le processeur comprend en fait.
Très jolie, j'ai lu ce fil Pourquoi python compiler le source en bytecode avant d'interpréter?

Quelqu'un pourrait me donner une bonne explication de l'ensemble du processus en gardant à l'esprit que ma connaissance de compilateurs/interpréteurs est presque inexistante? Ou, si cela n'est pas possible, peut-être me donner quelques ressources qui donnent un rapide aperçu des compilateurs/interpréteurs?

Grâce

  • Vous n'avez pas "interpréter en code machine" — c'est ce que les compilateurs n'. L'interpréteur Python juste exécute le bytecode. (Et c'est .pyc pour bytecode.)
  • Sur une note de côté, vous pourriez trouver utile de savoir que la dernière date de modification de l'original .py fichier est codé dans le .pyc fichier. Cela permet de Python afin de déterminer si une nouvelle .pyc fichier doit être créé ou non. Le but de .pyc fichiers est, bien sûr, afin d'éviter l'analyse de l'ensemble du script à chaque fois que le script est invoqué. Un programme en Python fera pas courir plus vite si l' .pyc est utilisé. Seulement le temps de chargement des changements.
InformationsquelleAutor NickHalden | 2010-07-21
  1. 50

    Le bytecode n'est pas réellement interprété en code machine, sauf si vous utilisez exotique de mise en œuvre tels que pypy.

    Autre que cela, vous avez la description correcte. Le bytecode est chargé dans l'exécution Python et interprété par une machine virtuelle, qui est un morceau de code qui lit chaque instruction dans le bytecode et exécute toutes les opérations indiquées. Vous pouvez voir ce bytecode avec le dis module, comme suit:

    >>> def fib(n): return n if n < 2 else fib(n - 2) + fib(n - 1)
... 
>>> fib(10)
55
>>> import dis
>>> dis.dis(fib)
  1           0 LOAD_FAST                0 (n)
              3 LOAD_CONST               1 (2)
              6 COMPARE_OP               0 (<)
              9 JUMP_IF_FALSE            5 (to 17)
             12 POP_TOP             
             13 LOAD_FAST                0 (n)
             16 RETURN_VALUE        
        >>   17 POP_TOP             
             18 LOAD_GLOBAL              0 (fib)
             21 LOAD_FAST                0 (n)
             24 LOAD_CONST               1 (2)
             27 BINARY_SUBTRACT     
             28 CALL_FUNCTION            1
             31 LOAD_GLOBAL              0 (fib)
             34 LOAD_FAST                0 (n)
             37 LOAD_CONST               2 (1)
             40 BINARY_SUBTRACT     
             41 CALL_FUNCTION            1
             44 BINARY_ADD          
             45 RETURN_VALUE        
>>>

    Explication détaillée

    Il est très important de comprendre que le code ci-dessus n'est jamais exécutée par votre CPU; ce n'est jamais transformée en quelque chose qui est (au moins, pas sur l'officiel C mise en œuvre de Python). Le PROCESSEUR exécute le code de la machine virtuelle, qui effectue le travail indiqué par les instructions bytecode. Lorsque l'interprète veut exécuter le fib fonction, il lit les instructions une à une, et ne de ce qu'ils disent de faire. Il ressemble à la première instruction, LOAD_FAST 0, et donc attrape paramètre 0 (le n passé à fib) à partir de la mesure des paramètres sont détenus et le pousse sur l'interprète de la pile (Python interprète est une pile de la machine). À la lecture de l'instruction suivante, LOAD_CONST 1, il s'empare de la constante de numéro 1 à partir d'un ensemble de constantes détenue par la fonction, qui se trouve être le numéro 2 dans ce cas, et pousse que sur la pile. Vous pouvez réellement voir ces constantes:

    >>> fib.func_code.co_consts
(None, 2, 1)

    La prochaine instruction, COMPARE_OP 0, raconte l'interprète de pop les deux de plus en haut de la pile des éléments et effectuer une comparaison de l'inégalité entre eux, poussant le résultat Booléen de retour sur la pile. La quatrième instruction détermine, en fonction de la valeur de type Boolean, que ce soit pour avancer de cinq instructions ou continuer avec la prochaine instruction. Tout ce que verbiage explique le if n < 2 partie de l'expression conditionnelle dans fib. Il sera très instructif de l'exercice pour vous de démêler le sens et le comportement du reste de la fib bytecode. Le seul, je ne suis pas sûr à ce sujet est POP_TOP; je devine JUMP_IF_FALSE est défini à quitter son argument Booléen sur la pile plutôt que de les voir apparaître et il a donc ête explicitement.

    Encore plus instructif est d'inspecter les premières bytecode pour fib ainsi:

    >>> code = fib.func_code.co_code
>>> code
'|\x00\x00d\x01\x00j\x00\x00o\x05\x00\x01|\x00\x00S\x01t\x00\x00|\x00\x00d\x01\x00\x18\x83\x01\x00t\x00\x00|\x00\x00d\x02\x00\x18\x83\x01\x00\x17S'
>>> import opcode
>>> op = code[0]
>>> op
'|'
>>> op = ord(op)
>>> op
124
>>> opcode.opname[op]
'LOAD_FAST'
>>>

    Donc vous pouvez voir que le premier octet de la bytecode est le LOAD_FAST instruction. La prochaine paire d'octets, '\x00\x00' (le nombre 0 à 16 bits) est l'argument de LOAD_FAST, et indique à l'interpréteur de bytecode à la charge de paramètre 0 sur la pile.

    • Donc, si ce n'est pas transformé en code machine... comment est-il finalement exécuté par mon x86 procesor? J'étais sous l'impression que tout ce qui se passe sur mon ordinateur pourrait éventuellement être décomposé en 1 et de 0 qui sont lus par mon processeur ou de quelque autre matériel.
    • Je l'ai étendu ma réponse à l'adresse de votre commentaire.
    • Ok, donc la partie qui est encore à souffler mon esprit, c'est que mon processeur ne pas comprendre la LOAD_FAST opcode correct? C'est du bytecode pour le python de la machine virtuelle. Donc, en quelque sorte la machine virtuelle a été écrit dans une langue qui pourrait être assemblés en x86. Assurez-vous. Cependant, comment est la machine virtuelle de réellement faire les opérations, il interprète à partir de l'octet de code sur mon matériel? Prenons un exemple. Mon script fait un peu de calcul et qu'il doit envoyer le résultat sur le bus de ma carte graphique. Le python de la machine virtuelle ne peut pas faire que suis-je droit? En quelque sorte, la physique proc est en train de faire quelque chose?
    • L'interprète/VM est en C. Il est (pour schématiser un peu), une boucle qui utilise le courant de l'octet de choisir l'un des nombreux cas dans un immense instruction switch. Quelque part au milieu de l'interrupteur, il y a un case LOAD_FAST: suivie par le code qui lit les deux octets suivant, regarde le paramètre spécifié dans certains "paramètres" de la collection, et il pousse sur une pile d'objets. Pour interagir avec le monde extérieur, Python permet de faire des appels à des modules d'extension, qui agissent comme des code Python et les objets, mais en réalité le code compilé et peut ainsi parler de cartes graphiques, etc., directement, au nom de votre script(s).
    • Pour être un peu plus explicite quant à votre dernière question: il n'y a pas de Python opcode pour "parler de la carte graphique". Il y a un opcode pour "appeler cette fonction dans ce module", et si le module est un graphique de programmation module d'extension, l'interprète d'appel de la bibliothèque de point d'entrée pour la fonction demandée, en lui passant des paramètres. La bibliothèque C (en supposant que c'est C) taquine les paramètres, en les convertissant à partir d'objets Python en C les valeurs et les structures, et transmet l'appel sur un véritable bibliothèque graphique, qui a ensuite plonks un triangle coloré sur votre écran, ou quoi que ce soit.
    • Wow, merci Marcelo! C'est exactement ce que je cherchais. L'esprit de me dire comment/où avez-vous entendu cela? Également, vous assurer que la bibliothèque C est où les paramètres sont "décortiquée'? Cela semble contre-intuitif pour moi. Pourquoi ne pas l'interpréteur python qui comprend bytecode python (et donc je suppose comprend des objets python) taquiner les paramètres et juste envoyer C des variables comme paramètres?
    • La curiosité ... presque trois décennies d'elle (pas tous, il en Python, bien sûr). L'interpréteur Python ne sait pas sur le C types de données requis par l'arbitraire C des bibliothèques. Donc, essentiellement, il adopte sa propre représentation interne de l'Python-paramètres de l'objet, à la bibliothèque, qui fait ce qu'il veut avec eux. À lire ici pour un avant-goût de la façon dont cela fonctionne.
    • Salut Marcelo, malgré la lecture de vos commentaires et de vos post, je suis toujours confus sur la façon Python de byte code des instructions exécutées par le PROCESSEUR. La machine virtuelle peut lire Python de byte code et exécuter les instructions, mais en fin de compte pour la machine virtuelle pour exécuter les instructions, ils doivent envoyer ces instructions pour le PROCESSEUR (à droite?). Ainsi n'est-il pas une étape de la compilation de ces instructions dans CPU instructions lisibles? Je vous remercie.
    • La VM est lui-même un morceau de code natif — écrit en C et compilé en code machine — qui fait tout le boulot. Il marche sur le bytecode et effectue les opérations qu'il trouve en elle. Revoir la LOAD_FAST exemple que j'ai donné précédemment, le code peut être trouvé à l'adresse github.com/python/cpython/blob/3.6/Python/ceval.c#L1274. Il est assez bruyant, mais le courage de elle est GETLOCAL(oparg), qui récupère le paramètre correspondant à l'opcode de l'argument dans un local de la variable C, et PUSH(value), ce qui pousse le paramètre sur la pile de Python. C'est, essentiellement, LOAD_FAST.
    • Je vous remercie pour votre réponse. J'avais pris un coup d'oeil à certains des bytecode et Disponible code, mais je n'ai que l'expérience avec Python, et aucun avec C c'est pour ça que je vais avoir beaucoup de problèmes. "La VM est lui-même un morceau de code natif — écrit en C et compilé en code machine — qui fait tout le boulot" -- voulez-vous dire toutes les VM commutateur cas sont précompilés pour un langage machine? Ainsi, lorsque la VM choisit un commutateur cas, et l'exécute, il communique directement avec le PROCESSEUR de la mémoire? Donc pas besoin de C pour compiler une fois de plus.
    • Jusqu'à présent, je comprends que le bytecode est traduit dans les cases de switch, qui la machine virtuelle s'exécute. Essentiellement, le commutateur cas sont des représentations de la pseudo-code binaire des instructions, mais juste écrit en C. Mais depuis que je ne comprends pas C, (reste encore beaucoup à apprendre à propos de Python malheureusement), je ne comprends pas ce qui se passe lorsque vous exécutez du code C dans les commutateurs. J'ai lu que C le premier code doit être compilé en code machine avant de se faire exécuter. C'est que ce que nous faisons ici, lorsque nous exécutons un commutateur cas?
    • Ou tout Est pré-compilé en code machine, afin d'apporter des exécutions de commutateur de cas donnent des résultats tout de suite. Merci beaucoup pour votre patience.
    • Disponible jamais traduit du bytecode dans les cases de switch. Le code C je lien est le code qui sera compilé en code machine. Que le code machine est un PROCESSEUR prêt pour la représentation de la C code. Vous devriez penser à du code C et le code de l'ordinateur comme étant des représentations différentes de la même chose. C est une forme lisible par l'homme, alors que le code machine est une forme lisible par machine. Un point essentiel à comprendre est que le programme C (dans son compilé en code machine) est la seule chose que le CPU considère comme code.
    • ... Le bytecode Python, en revanche, est considérée par le PROCESSEUR juste des données. Le code C interprète que les données que l'exécution d'un code, d'où le nom de l'interpréteur.
    • Il peut aider à penser de la bytecode Python comme une recette de cuisine, et le code C comme cuisine robot qui lit et suit des recettes pour cuire les aliments. Le robot lui-même a du code à l'intérieur, ce qui pourrait bien être le code en C, et les recettes sont juste les données lues par le robot yeux afin de savoir comment exécuter un particulier de la cuisson de la procédure. À un niveau, la recette est code — un ensemble d'instructions à suivre. À un autre niveau, c'est juste des données à nourrir le cerveau du robot. hth
    • Ah, désolé "traduire" était un mauvais choix de mot. J'ai voulu utiliser les interpréter. Donc finalement, le code C est arriver compilé en code machine! C'est là que la confusion était issu de. Maintenant, que je sache, le code Python peut interpréter ligne par ligne-quand j'utilise l'interpréteur je peux exécuter des lignes en temps réel, mais nous ne pouvons pas le faire avec le C droit? D'après ce que je comprends est que C est de compiler l'ensemble du code en langage machine d'un seul coup. Il a à interpréter l'intégralité du byte-code (dernières lignes et les nouvelles lignes), avant de le compiler en code machine.
    • Donc, chaque fois que nous exécuter du code Python via l'interprète, nous forçant C à recompiler l'ensemble du bytecode une fois de plus (les nouvelles lignes ainsi que les anciens lignes)?
    • Le code C est compilé une fois de faire de l'interpréteur Python (python.exe sur Windows, il suffit de python sur la plupart des autres plates-formes). C'est la "cuisson" du robot. Vous pouvez ensuite exécuter l'interprète, en lui passant le code Python pour exécuter. L'interpréteur lit le code et "compile" il en bytecode, qui l'interprète. Il le fait à chaque fois que vous lancez le morceau de code.
    • Il s'agit d'une optimisation pour les modules importés. Après la compilation d'un importés .py fichier, l'interprète met en cache le bytecode comme une .pyc fichier côtés de l'importation .py fichier. Chaque fois qu'un module est importé, l'interprète vérifie d'abord si il y a un correspondant .pyc fichier est plus récent que le .py fichier. Si il y est, il charge le .pyc fichier directement au lieu de recompiler le .py fichier.
    • Si Le code C n'est besoin d'être compilé une seule fois (pour exécuter l'interpréteur), nous pouvons exécuter le code autant de fois par le biais de l'interprète -- l'interprète semble être essentiellement un PROCESSEUR virtuel spécialement conçu pour lire bytecode Python. Je suppose que c'est pourquoi il est appelé une machine virtuelle. Je pense que je l'ai eu. Merci beaucoup pour votre patience. Ces détails sont difficiles à trouver sur le web, de façon que les débutants peuvent comprendre. Encore une fois merci beaucoup.
    • C'est sur place! Ravi de vous aider.
    • Salut, @MarceloCantos merci pour votre explication! Et si le co_code de la fonction fib est '|\x00\x00d\x01\x00j\x00\x00o\x05\x00\x01|\x00\x00S\x01t\x00\x00|\x00\x00d\x01\x00\x18\x83\x01\x00t\x00\x00|\x00\x00d\x02\x00\x18\x83\x01\x00\x17S' l'interpréteur Python pas besoin de module d'importation opcode puis traduire comme | à LOAD_FAST puis faire un peu de l'opération, non? Il vient de faire l'opération quand il lire |, le module opcode est juste d'aider les gens à unstanding co_code de la fonction, non?
    • c'est le droit.
    • Merci pour votre réponse, et j'ai posé une question concernant le lien est stackoverflow.com/questions/55843979/... . Espérons que vous répondrez quand vous avez le temps. Merci à l'avance.

    InformationsquelleAutor Marcelo Cantos
  2. 2

    Pour compléter la grande Marcelo Cantos de réponse, voici une petite colonne par colonne, en résumé pour expliquer la sortie de démonté le bytecode.

    Par exemple, compte tenu de cette fonction:

    def f(num):
    if num == 42:
        return True
    return False

    Cela peut être démonté en (Python 3.6):

    (1)|(2)|(3)|(4)|          (5)         |(6)|  (7)
--- | --- | --- | --- | ---------------------- | --- | -------
  2|   |   |  0|LOAD_FAST             |  0|(num)
   |-->|   |  2|LOAD_CONST            |  1|(42)
   |   |   |  4|COMPARE_OP            |  2|(==)
   |   |   |  6|POP_JUMP_IF_FALSE     | 12|
   |   |   |   |                      |   |
  3|   |   |  8|LOAD_CONST            |  2|(True)
   |   |   | 10|RETURN_VALUE          |   |
   |   |   |   |                      |   |
  4|   |>> | 12|LOAD_CONST            |  3|(False)
   |   |   | 14|RETURN_VALUE          |   |

    Chaque colonne a un but précis:

    1. Le correspondant numéro de ligne dans le code source
    2. Éventuellement indique le instruction en cours exécuté (lorsque le bytecode vient d'un objet frame par exemple)
    3. Une étiquette qui indique une possible JUMP à partir d'une instruction antérieure à cette
    4. La adresse dans le pseudo-code qui correspond à l'octet index (ceux qui sont des multiples de 2 parce que Python 3.6 utilisation de 2 octets pour chaque instruction, bien qu'il puisse varier dans les versions précédentes)
    5. L'instruction nom (aussi appelé nomop), chacun s'est brièvement expliqué dans le dis module et leur mise en œuvre peut être trouvé dans ceval.c (le cœur de la boucle de Disponible)
    6. La argument (le cas échéant) de l'instruction qui est utilisé en interne par Python pour aller chercher des constantes ou des variables, de gérer la pile, le saut d'une instruction spécifique, etc.
    7. La homme-friendly interprétation de l'instruction argument
    • Comment lire la vitesse de mise en œuvre à partir d'elle? Il n'y a pas de timing.
    • Qu'entendez-vous par "vitesse de mise en œuvre"? C'est juste compilé en bytecode et pas (encore) d'exécution, de sorte que le timing n'est pas pertinent ici.
    • très bon tutoriel de votre réponse
    InformationsquelleAutor Delgan