Voici le fichier de code complet : Code

1. Code source

Lorsque vous écrivez un script Python, il s’agit d’un texte lisible par l’homme. Ce code source est le point de départ de tout.

Votre code source Python, écrit dans un fichier .py, est lisible par l'homme. Ce code définit ce que fait votre programme, en spécifiant des variables, des fonctions, des boucles, etc.

2. Compilation en Bytecode (compilateur)

Lorsque vous exécutez un programme Python, la première étape consiste à compiler le code source en bytecode. Ceci est fait par l'interpréteur Python?:

• Vérification de la syntaxe?: garantit qu'il n'y a pas d'erreurs de syntaxe.
• Compilation?: traduit le code source de haut niveau en bytecode, une représentation de niveau inférieur indépendante de la plate-forme. Ce bytecode réside généralement dans les fichiers .pyc du répertoire __pycache__.
  • Compilateur?: Python utilise un interpréteur, mais il compile d'abord votre code source dans une forme de niveau inférieur appelée bytecode.
• Tokenisation?: décompose votre code en petits morceaux appelés jetons (comme des mots-clés, des opérateurs, des identifiants).
• Parsing?: analyse les jetons pour s'assurer qu'ils suivent les règles de syntaxe de Python.
• Control Flow Graph (CFG)?: Représente tous les chemins qui pourraient être parcourus par un programme lors de son exécution.
• Génération de bytecode?: convertit les jetons analysés en bytecode, un ensemble d'instructions pour la machine virtuelle Python (PVM).

Plongeons-nous en profondeur dans ce sujet.

Compilateur Python?: Même si Python est connu comme un langage interprété, il comporte une étape de compilation. Voici la répartition?:

Tokenisation?:

• Décompose votre code en petits morceaux appelés jetons (comme des mots-clés, des opérateurs, des identifiants).

1. Code source?: commence par votre code écrit.
2. Tokenizer (Lexer)?: cela divise le code source en morceaux plus petits appelés jetons, comme des mots-clés (pour, si), des opérateurs (, -), des identifiants (noms de variables) et des littéraux (comme des nombres ou des cha?nes). .
3. Parsing?: analyse les jetons pour s'assurer qu'ils suivent les règles de syntaxe de Python.
4. Analyse syntaxique?: l'analyseur prend ces jetons et les vérifie par rapport aux règles de grammaire de Python.
5. Parse Tree?: Construit une structure arborescente à partir des jetons, représentant la structure grammaticale du code.
6. Analyse sémantique?: garantit que le code a du sens en termes de types de données, de portée et d'autres règles spécifiques au contexte.
7. Control Flow Graph (CFG)?: Représente tous les chemins qui pourraient être parcourus par un programme lors de son exécution.
   • Graphique de flux de contr?le?: représente tous les chemins possibles qui pourraient être empruntés dans le code pendant l'exécution.
   • N?uds et bords?: chaque n?ud représente un bloc de code de base, et les bords représentent le flux de contr?le d'un bloc à un autre.
8. Génération de bytecode?: convertit les jetons analysés en bytecode, un ensemble d'instructions pour la machine virtuelle Python (PVM).
   • Le bytecode est une représentation plus compacte et de niveau inférieur de votre code source, optimisée pour l'exécution. Il est indépendant de la plate-forme, ce qui signifie qu’il peut être exécuté sur n’importe quel système doté d’un PVM compatible.
   • Bytecode?: le code analysé est converti en bytecode, une représentation de niveau inférieur indépendante de la plate-forme.
   • Jeu d'instructions?: Ce bytecode est un ensemble d'instructions que la machine virtuelle Python (PVM) peut exécuter. Le bytecode est stocké dans les fichiers .pyc dans le répertoire __pycache__ pour accélérer les exécutions futures.

3. Chargement du bytecode (code d'octet)

Après compilation, la Machine Virtuelle Python charge le bytecode?:

• Lecture depuis le cache?: Si le bytecode a été préalablement compilé et n'a pas changé, il est lu depuis le cache (__pycache__). Cela accélère l'exécution en sautant l'étape de compilation.
  • Le bytecode est chargé en mémoire, prêt à être exécuté. Le bytecode est ensuite exécuté par le PVM, interprétant les instructions pour effectuer les taches du programme.

4. Exécution par PVM (PVM)

Le PVM interprète et exécute désormais le bytecode?:

• Exécution d'instruction?: Le PVM lit chaque instruction de bytecode et l'exécute. Chaque instruction correspond à une opération spécifique, comme charger une valeur, effectuer des opérations arithmétiques ou appeler une fonction.
• Gestion de la mémoire?: gère l'allocation et la désallocation de mémoire pour les variables et les objets.

Gestion de la mémoire en Python?:

1. Comptage de références?: Python garde une trace du nombre de références à un objet en mémoire. Lorsque le nombre de références tombe à zéro, la mémoire occupée par l'objet peut être récupérée.
2. Allocation d'objets?: les objets Python (comme les entiers, les cha?nes, les listes) sont créés en mémoire lorsque le code est exécuté.
3. Garbage Collection?: Python dispose d'un garbage collector qui aide à gérer la mémoire en désallouant la mémoire qui n'est plus utilisée (c'est-à-dire les objets avec un nombre de références de zéro).
4. Memory Pooling?: Python utilise des pools de mémoire pour allouer plus efficacement les petits objets. Cette mise en commun permet de réduire les frais généraux liés à l'allocation et à la désallocation fréquentes de petits morceaux de mémoire.
5. Optimisation de la mémoire?: Python applique diverses optimisations pour minimiser l'utilisation de la mémoire, telles que?:
   • Le PVM effectue diverses optimisations d'exécution pour améliorer l'efficacité, telles que la compilation juste à temps (JIT) dans certaines implémentations (comme PyPy).
   • Réutilisation de petits entiers et de cha?nes internées.
   • Gérer efficacement les structures de données (par exemple, tuples, listes, dictionnaires).

Exemples?:

• Bytecode Caching?: Le PVM met en cache le bytecode compilé pour éviter de recompiler le code source à chaque fois. Cela accélère les exécutions suivantes.
• Constant Folding?: cela implique de simplifier les expressions constantes au moment de la compilation plut?t qu'au moment de l'exécution. Par exemple, 3 * 2 peut être précalculé à 6.

En résumé?: le PVM est comme un chef d'orchestre, transformant de manière transparente le bytecode en actions que votre ordinateur peut exécuter. Ce qui est bien, c'est que le code Python, grace au PVM, est portable et peut s'exécuter sur différentes plateformes sans modification.

Comment pouvons-nous voir le bytecode généré ou non??

Lorsque vous importez un module Python, Python compile le code source en bytecode et le stocke dans le répertoire __pycache__. Cela permet d'accélérer les importations futures en évitant d'avoir à recompiler le module à chaque importation.

Voici le processus?:

• Première importation?: Lorsque vous importez pour la première fois un module, Python compile le fichier .py en bytecode.
• Répertoire pycache?: Le bytecode est stocké dans le répertoire __pycache__, nommé quelque chose comme module_name.cpython-312.pyc. #312 est la version Python.
• Importations ultérieures?: lors des importations ultérieures, Python vérifie le répertoire __pycache__ pour le bytecode compilé et l'utilise si le code source n'a pas changé, accélérant ainsi le processus d'importation.

Exemple:

Nous avons byte.py. Lorsque nous importons du code depuis hello_world.py après l'exécution de byte.py, nous pouvons voir qu'il y aura un répertoire __pycache__ dans ce dossier particulier, et nous pouvons voir les fichiers .pyc?:

from hello_world import greet

greet("Byte code")

En utilisant py_compile

module py_compile, qui vous permet de compiler des fichiers sources Python en fichiers bytecode. C'est un moyen pratique d'accélérer l'exécution du script pour les exécutions futures.

En octet.py

import py_compile

py_compile.compile('hello_world.py')

• Le module py_compile compile hello_world.py en bytecode.
• Le bytecode résultant est stocké dans le répertoire pycache, créant un fichier nommé hello_world.cpython-38.pyc (ou similaire, selon votre version de Python).

Génération de bytecode?:

• L'ensemble du script est exécuté pour générer le bytecode. Cela signifie que tout code de niveau supérieur (comme print("Hello, World!") et print("c")) s'exécutera pendant le processus de compilation.

Bytecode résultant?:

• Le bytecode contient toutes les fonctions, classes et instructions exécutables que Python utilise pour accélérer les futures importations du script.

module dis

Le module dis en Python est utilisé pour désassembler le bytecode sous une forme plus lisible. Cela peut vous aider à comprendre ce que fait votre code Python sous le capot. C’est particulièrement utile pour déboguer ou découvrir les composants internes de Python.

• Dans internal.py nous avons

from hello_world import greet

greet("Byte code")

sortir

import py_compile

py_compile.compile('hello_world.py')

• Le programme commence par importer le module dis, un outil puissant pour analyser le bytecode CPython. CPython est l'implémentation par défaut de Python et le bytecode est un langage intermédiaire pour l'interpréteur Python.
• Ensuite, j'ai défini une fonction simple appelée greet. Cette fonction prend un nom de paramètre et imprime un message d'accueil. Bien que la fonction elle-même soit assez simple, ce qui se passe sous le capot en Python est plus complexe qu'il n'y para?t à première vue.
• La fonction disassemble_function utilise dis.dis() pour démonter la fonction greet. dis.dis() traduit les fonctions Python en bytecode de bas niveau que la machine virtuelle de Python exécute réellement. Ce bytecode est l’interprétation par Python de notre fonction greet et constitue un pas de plus vers le code machine.
• Lorsque le script appelle disassemble_function(), la sortie de la console présente le bytecode de notre fonction greet.

Voici ce que nous dit le bytecode?:

• LOAD_GLOBAL(0)?: Cet opcode est utilisé pour charger la variable globale, qui, dans ce cas, est la fonction d'impression.
• LOAD_CONST(1)?: ceci charge la valeur constante ??Bonjour??, sur la pile.
• LOAD_FAST(0)?: cet opcode charge le nom de la variable locale sur la pile.
• FORMAT_VALUE(0)?: ceci formate notre cha?ne de nom, la préparant à être insérée dans la cha?ne qui est sur le point d'être construite.
• BUILD_STRING(2)?: cela prend les deux premières valeurs de la pile (??Bonjour?? et nom) et construit la cha?ne finale.
• CALL_FUNCTION(1)?: Cette ligne appelle la fonction (fonction d'impression globale que nous avons chargée sur la pile), avec le nombre d'arguments entre parenthèses (nous avons un argument, notre cha?ne formatée).
• POP_TOP?: ceci supprime le haut de la pile (le résultat de l'appel précédent, puisque print renvoie Aucun).
• LOAD_CONST(0)?: ne charge aucun.
• RETURN_VALUE?: Il s'agit de la valeur de retour de la fonction greet, qui, puisqu'il n'y a pas d'instruction de retour explicite, est None.
• Essentiellement, le bytecode montre les opérations individuelles que Python effectue pour exécuter notre fonction d'accueil. Comprendre ces instructions est crucial pour que les développeurs comprennent comment Python exécute le code, optimise les fonctions et gère les ressources – tout cela se passe de manière transparente sous le capot lorsque nous exécutons notre code Python.

N'est-ce pas une délicieuse plongée dans la salle des machines Python?? Continuez à coder et continuez à explorer les profondeurs de la salle des machines de ce langage??!

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!