Le bytecode Python - Historique des versions

Marzin : correction ortho

2026-05-12T06:29:31Z

correction ortho

Perivolas le 8 mai 2026 à 17:12

2026-05-08T17:12:14Z

← Version précédente		Version du 8 mai 2026 à 17:12
Ligne 280 :		Ligne 280 :

	<h2>Gestion des closures</h2>		<h2>Gestion des closures</h2>
	La gestion des closures est la dernière ~~fonctionalité~~ que nous avons pu implémenter à notre interpréteur python.		La gestion des closures est la dernière fonctionnalité que nous avons pu partiellement implémenter à notre interpréteur python.
	<h3>Définition et explications</h3>		<h3>Définition et explications</h3>
	Une closure (ou cloture en français) est une fonction qui capture des variables de son environnement lexical (une fonction définie dans une autre fonction qui utilise des variables de cette fonction externe).</br>		Une closure (ou cloture en français) est une fonction qui capture des variables de son environnement lexical (une fonction définie dans une autre fonction qui utilise des variables de cette fonction externe).</br>

Perivolas le 8 mai 2026 à 17:11

2026-05-08T17:11:13Z

← Version précédente		Version du 8 mai 2026 à 17:11
Ligne 242 :		Ligne 242 :
	<li><strong>LOAD_CONST</strong> : Push une constante sur la pile </li>		<li><strong>LOAD_CONST</strong> : Push une constante sur la pile </li>
	<li><strong>STORE_FAST</strong> : Dépile et stock la valeur dans une variable locale </li>		<li><strong>STORE_FAST</strong> : Dépile et stock la valeur dans une variable locale </li>
	<li><strong>BINARY_OP PLUS / MINUS / STAR / SLASH / PERCENT </strong> : Dépile les deux derniers elements de la pile, et leur applique l'opération entrée en paramètres : <ul><li>PLUS --> Addition</li><li>MINUS --> Soustraction</li><li>STAR --> Multiplication</li><li>SLASH --> Division</li><li>PERCENT --> Modulo</li></ul>		<li><strong>BINARY_OP PLUS / MINUS / STAR / SLASH / PERCENT </strong> : Dépile les deux derniers elements de la pile, leur applique l'opération entrée en paramètres, puis empile le résultat : <ul><li>PLUS --> Addition</li><li>MINUS --> Soustraction</li><li>STAR --> Multiplication</li><li>SLASH --> Division</li><li>PERCENT --> Modulo</li></ul>
	<li><strong>COMPARE_OP EQEQ / LT / GT / LE / GE / NOTEQ </strong> : Opérateurs de comparaison logiques. Dépile les deux derniers elements et les compare : <ul><li>EQEQ --> égal (==)</li><li>LT (Lower Than) --> Strictement inférieur (<) </li><li>GT (Greater Than) --> Strictement superieur (>) </li><li>LE (Lower Equal) --> Inférieur ou égal (<=) </li><li>GE (Greater Equal) --> Supperieur ou égal (>=) </li><li>NOTEQ (NOT Equal) --> Différent de (!=) </li></ul>		<li><strong>COMPARE_OP EQEQ / LT / GT / LE / GE / NOTEQ </strong> : Opérateurs de comparaison logiques. Dépile les deux derniers elements et les compare : <ul><li>EQEQ --> égal (==)</li><li>LT (Lower Than) --> Strictement inférieur (<) </li><li>GT (Greater Than) --> Strictement superieur (>) </li><li>LE (Lower Equal) --> Inférieur ou égal (<=) </li><li>GE (Greater Equal) --> Supperieur ou égal (>=) </li><li>NOTEQ (NOT Equal) --> Différent de (!=) </li></ul>
	<li><strong>POP_JUMP_IF_FALSE n / POP_JUMP_IF_TRUE</strong> : Dépile, et effectue un saut (principe de JUMP comme en assembleur) à l'instruction à l'indice n de la liste si la valeur qu'il vient de dépiler est vraie (TRUE) ou fausse (FALSE).</li>		<li><strong>POP_JUMP_IF_FALSE n / POP_JUMP_IF_TRUE</strong> : Dépile, et effectue un saut (principe de JUMP comme en assembleur) à l'instruction à l'indice n de la liste si la valeur qu'il vient de dépiler est vraie (TRUE) ou fausse (FALSE).</li>

Perivolas le 8 mai 2026 à 17:09

2026-05-08T17:09:57Z

← Version précédente		Version du 8 mai 2026 à 17:09
Ligne 216 :		Ligne 216 :
	</ul>		</ul>
	<h1>Partie machine virtuelle</h1>		<h1>Partie machine virtuelle</h1>
	Comme énoncé précédemment, la ~~macine~~ virtuelle de l'interprèteur python prend en entrée du ~~bytecode~~, et l'execute. </br>		Comme énoncé précédemment, la machine virtuelle de l'interprèteur python prend en entrée un code objet, et l'execute. </br>
	<h2>Fonctionnement global</h2>		<h2>Fonctionnement global</h2>
	La machine virtuelle est basée sur une structure de pile Last In First Out (LIFO) pour les instructions. Elle utilise 2 piles différentes, qui ont chacune un rôle bien défini :		La machine virtuelle est basée sur une structure de pile Last In First Out (LIFO) pour les instructions. Elle utilise 2 piles différentes, qui ont chacune un rôle bien défini :

Perivolas le 8 mai 2026 à 16:30

2026-05-08T16:30:23Z

Voir les modifications

Perivolas le 6 mai 2026 à 08:48

2026-05-06T08:48:21Z

← Version précédente		Version du 6 mai 2026 à 08:48
Ligne 109 :		Ligne 109 :
	<h1>Conclusion</h1>		<h1>Conclusion</h1>

	A travers ce projet, nous avons pu comprendre comment fonctionne Cpython, de la compilation à l'execution, le tout en recréant un interpréteur de zéro. Au delà de ça, ce projet nous a permis de savoir ce qui se passe réellement derrière les programmes python que nous utilisons tout le temps. Celà nous donne aussi une idée sur le fonctionnement dans les grandes lignes certains compilateurs, et même de pousser nos recherches sur certaines optimisations qu'ils font comme la compilation <it>Just in time</it>. Ce projet était donc très enrichissant, et très interessant.		A travers ce projet, nous avons pu comprendre comment fonctionne Cpython, de la compilation à l'execution, le tout en recréant un interpréteur de zéro. Au delà de ça, ce projet nous a permis de savoir ce qui se passe réellement derrière les programmes python que nous utilisons tout le temps. Celà nous donne aussi une idée sur le fonctionnement dans les grandes lignes certains compilateurs, et même de pousser nos recherches sur certaines optimisations qu'ils font comme la compilation <i>Just in time</i>. Ce projet était donc très enrichissant, et très interessant.

Perivolas le 6 mai 2026 à 08:25

2026-05-06T08:25:26Z

← Version précédente		Version du 6 mai 2026 à 08:25
Ligne 30 :		Ligne 30 :
	<h2>Lexer</h2>		<h2>Lexer</h2>
	...		...
	<h2>Parser</h2>		<h2>Parser et AST</h2>
	...		...
	<h2>~~Arbre de syntaxe et~~ compilation</h2>		<h2>compilation</h2>
	...		...
	<h1>Partie machine virtuelle</h1>		<h1>Partie machine virtuelle</h1>

Marzin : Fin wiki

2026-05-05T14:25:55Z

Fin wiki

@@ Ligne 88 : / Ligne 88 : @@
 Quand l'instruction RETURN_VALUE est atteinte, on dépile la dernière valeur, on se replace dans la frame initiale, puis on empile dans la stack initiale la valeur du return.
-<h2>Gestion des boucles</h2>
+<h2>Gestion des boucles et des conditions</h2>
 <h3>Fonctionnement</h3>

Marzin : fin fonctions

2026-05-03T14:28:35Z

fin fonctions

← Version précédente		Version du 3 mai 2026 à 14:28
Ligne 37 :		Ligne 37 :
	Comme énoncé précédemment, la macine virtuelle de l'interprèteur python prend en entrée du bytecode, et l'execute. </br>		Comme énoncé précédemment, la macine virtuelle de l'interprèteur python prend en entrée du bytecode, et l'execute. </br>
	<h2>Fonctionnement global</h2>		<h2>Fonctionnement global</h2>
	La machine virtuelle est basée sur une structure de pile Last In First Out (~~FIFO~~) pour les instructions. Elle utilise 2 piles différentes, qui ont chacune un rôle bien défini :		La machine virtuelle est basée sur une structure de pile Last In First Out (LIFO) pour les instructions. Elle utilise 2 piles différentes, qui ont chacune un rôle bien défini :
	<ul><li>Data stack : La pile où python stocke toutes les données avec lesquelles il travaille, comme les variables, les fonctions etc... (c'est la pile utilisée par la plupart des fonctions)</li>		<ul><li>Data stack : La pile où python stocke toutes les données avec lesquelles il travaille, comme les variables, les fonctions etc... (c'est la pile utilisée par la plupart des fonctions)</li>
	<li>Block stack : Utilisée dans les exception, ou pour certaines fonctions.</li></ul>		<li>Block stack : Utilisée dans les exception, ou pour certaines fonctions.</li></ul>
	Dans le cadre de notre projet, nous avons choisi de fonctionner avec une seule pile pour simplifier son fonctionnement.</br>		Dans le cadre de notre projet, nous avons choisi de fonctionner avec une seule pile pour simplifier son fonctionnement, contrairement à Cpython (la machine virtuelle python) qui en utilise deux .</br>
	Notre VM (Virtual Machine) possède donc une pile nomée 'call stack' (ou pile d'execution) qui est utilisée pour à la fois stocker les données, mais également les frames des fonctions (notion qui sera expliquée plus bas).</br>		Notre VM (Virtual Machine) possède donc une pile nomée 'call stack' (ou pile d'execution) qui est utilisée pour à la fois stocker les données, mais également les frames des fonctions (notion qui sera expliquée plus bas).</br>
	La VM prend en entrée une liste d'instructions bytecode, d'une classe bytecode que nous avons décidé de créer. Elle execute ensuite instruction par instruction jusqu'à arriver à la fin du programme.</br>		La VM prend en entrée une liste d'instructions bytecode, d'une classe bytecode que nous avons décidé de créer. Elle execute ensuite instruction par instruction jusqu'à arriver à la fin du programme.</br>
Ligne 82 :		Ligne 82 :
	<h3>En bytecode</h3>		<h3>En bytecode</h3>
	Ces étapes se traduisent par une suite de plusieurs instructions bien précises : </br>		Ces étapes se traduisent par une suite de plusieurs instructions bien précises : </br>
	<h4>Création</h4>
	<ol><li>Première étape : l'ajout de l'objet fonction sur la stack : STORE_NAME n (avec l'objet de la fonction au nom de n dans les variables de la frame)</li>		<ol><li>Première étape : l'ajout de l'objet fonction sur la stack : STORE_NAME n (avec l'objet de la fonction au nom de n dans les variables de la frame)</li>
	<li>Ensuite, on crée la frame de la fonction avec MAKE_FUNCTION </li>		<li>Ensuite, on crée la frame de la fonction avec MAKE_FUNCTION </li>
	<li>Puis vient l'appel avec l'instruction CALL</li></ol>		<li>Puis vient l'appel avec l'instruction CALL : On sauvegarde l'état de la frame actuelle, on l'empile sur le call stack, puis on se place dans la frame de la fonction. </li></ol>
			A partir de ce moment précis, la suite d'instruction de bytecode que l'on execute n'est plus la suite de base, mais bien celle de la fonction. Cette dernière se termine par l'instruction RETURN_VALUE. </br>
			Quand l'instruction RETURN_VALUE est atteinte, on dépile la dernière valeur, on se replace dans la frame initiale, puis on empile dans la stack initiale la valeur du return.

			<h2>Gestion des boucles</h2>
			<h3>Fonctionnement</h3>

Marzin : bytecode fonctions

2026-05-02T16:07:39Z

bytecode fonctions

← Version précédente		Version du 2 mai 2026 à 16:07
Ligne 81 :		Ligne 81 :
	[mettre un schéma]		[mettre un schéma]
	<h3>En bytecode</h3>		<h3>En bytecode</h3>
			Ces étapes se traduisent par une suite de plusieurs instructions bien précises : </br>
			<h4>Création</h4>
			<ol><li>Première étape : l'ajout de l'objet fonction sur la stack : STORE_NAME n (avec l'objet de la fonction au nom de n dans les variables de la frame)</li>
			<li>Ensuite, on crée la frame de la fonction avec MAKE_FUNCTION </li>
			<li>Puis vient l'appel avec l'instruction CALL</li></ol>

← Version précédente		Version du 12 mai 2026 à 06:29
Ligne 3 :		Ligne 3 :

	<h1>Introduction </h1>		<h1>Introduction </h1>
	Python est un langage de programmation multiparadigme (à la fois impératif, fonctionnel et orienté objet) créé en 1991. A la ~~difference~~ des langages compilés comme le C, le C++ ou le Rust, le python lui est un langage interprété (nous verrons la différence juste après). Il a la particularité dans son execution, de transformer le code en un code intermédiaire simplifié appelé Bytecode. Ce projet porte sur l'étude du fonctionnement d'un ~~interprèteur~~ python, et plus particulièrement du Bytecode.		Python est un langage de programmation multiparadigme (à la fois impératif, fonctionnel et orienté objet) créé en 1991. A la différence des langages compilés comme le C, le C++ ou le Rust, le python lui est un langage interprété (nous verrons la différence juste après). Il a la particularité dans son execution, de transformer le code en un code intermédiaire simplifié appelé Bytecode. Ce projet porte sur l'étude du fonctionnement d'un interpréteur python, et plus particulièrement du Bytecode.

	<h1 id='compilation'>Langage compilé VS interprété</h1>		<h1 id='compilation'>Langage compilé VS interprété</h1>
	Un langage compilé est un langage qui necessite de passer par un compilateur (un programme qui transforme un code source en un code objet) pour transformer le code de base en instructions de bas niveau proche de l'assembleur ~~éxecutable~~ par la machine. En C par exemple, on doit compiler un programme C pour le transformer en .exe avant de pouvoir le lancer. Le compilateur analyse syntaxiquement tout le code, puis le transforme, ce qui fait que les erreurs sont ~~detectées~~ plus tôt. Les langages compilés ont la particularité d'être très rapides et performants, un programme déjà compilé étant très facilement ~~executable~~. Néanmoins, celà rend le débug ainsi que les test plus complexes. </br>		Un langage compilé est un langage qui necessite de passer par un compilateur (un programme qui transforme un code source en un code objet) pour transformer le code de base en instructions de bas niveau proche de l'assembleur exécutable par la machine. En C par exemple, on doit compiler un programme C pour le transformer en .exe avant de pouvoir le lancer. Le compilateur analyse syntaxiquement tout le code, puis le transforme, ce qui fait que les erreurs sont détectées plus tôt. Les langages compilés ont la particularité d'être très rapides et performants, un programme déjà compilé étant très facilement exécutable. Néanmoins, celà rend le débug ainsi que les test plus complexes. </br>
	Un langage interprété a lui besoin d'un interpréteur (ou interprète) pour fonctionner. Il récupère un code source, le traîte, le transforme et l'execute ~~dirrectement~~ dans une machine virtuelle. Les langages interprétés sont donc par conséquent plus lents que les langages compilés, mais il permettent une plus grande flexibilité. La plupart des ~~interpreteurs~~ traîtent et executent le code instruction par instruction. Or, ce n'est pas totalement le cas de l'~~interprèteur~~ python.		Un langage interprété a lui besoin d'un interpréteur (ou interprète) pour fonctionner. Il récupère un code source, le traîte, le transforme et l'execute directement dans une machine virtuelle. Les langages interprétés sont donc par conséquent plus lents que les langages compilés, mais il permettent une plus grande flexibilité. La plupart des interpréteurs traîtent et executent le code instruction par instruction. Or, ce n'est pas totalement le cas de l'interpréteur python.

	<h1>Spécificité de Python</h1>		<h1>Spécificité de Python</h1>
	L'interpréteur python a un fonctionnement bien particulier. En effet, il est un hybride entre ~~interprète~~ et compilateur. </br>		L'interpréteur python a un fonctionnement bien particulier. En effet, il est un hybride entre interpréteur et compilateur. </br>
	Le code source python est d'abord analysé syntaxiquement et ~~cémantiquement~~ en entiereté par un lexer et un parser (expliqué plus en détails plus bas), puis est compilé en code objet intermédiaire, le bytecode. Ce bytecode est ensuite executé instruction par instruction par la machine virtuelle python. </br>		Le code source python est d'abord analysé syntaxiquement et sémantiquement en entiereté par un lexer et un parser (expliqué plus en détails plus bas), puis est compilé en code objet intermédiaire, le bytecode. Ce bytecode est ensuite executé instruction par instruction par la machine virtuelle python. </br>
	La syntaxe du bytecode est plutôt claire et s'apparente à de l'assembleur siplifié. Chaque ~~instructions~~ du code source python (affectation, calcul, definition de fonction ...) a sa propre représentation bien précise en bytecode. </br>		La syntaxe du bytecode est plutôt claire et s'apparente à de l'assembleur siplifié. Chaque instruction du code source python (affectation, calcul, definition de fonction ...) a sa propre représentation bien précise en bytecode. </br>
	Voici un exemple de bytecode pour l'instruction <strong> a = 10 :</strong> </br>		Voici un exemple de bytecode pour l'instruction <strong> a = 10 :</strong> </br>
	[[Fichier:Bytecode1.png]]		[[Fichier:Bytecode1.png]]

	<h1>Description du projet</h1>		<h1>Description du projet</h1>
	Dans le cadre de nos recherches sur le sujet, nous avons décidé pour comprendre comment fonctionne l'~~interprèteur~~ python d'en recoder une version simplifiée. Le code que nous avons réalisé prend en entrée un code source python basique, le transforme en code intermédiaire inspiré du vrai bytecode de Python3, et l'execute dans une machine virtuelle. Nous avons donc trouvé pertinnent de découper ce projet en deux parties distinctes : la partie <strong>Compilation</strong> et la partie <strong> Machine virtuelle et execution </strong> </br>		Dans le cadre de nos recherches sur le sujet, nous avons décidé pour comprendre comment fonctionne l'interpréteur python d'en recoder une version simplifiée. Le code que nous avons réalisé prend en entrée un code source python basique, le transforme en code intermédiaire inspiré du vrai bytecode de Python3, et l'execute dans une machine virtuelle. Nous avons donc trouvé pertinnent de découper ce projet en deux parties distinctes : la partie <strong>Compilation</strong> et la partie <strong> Machine virtuelle et execution </strong> </br>
	Ce code prend en compte quelques fonctionnalités de base de python telles que :		Ce code prend en compte quelques fonctionnalités de base de python telles que :
	<ul><li>L'affectation de variable</li>		<ul><li>L'affectation de variable</li>
Ligne 78 :		Ligne 78 :
	C’est également à cette étape que l’indentation devient explicite. En Python, l’indentation a une importance syntaxique très forte puisqu’elle permet de délimiter les blocs de code (conditions, boucles, fonctions, etc.).</br>		C’est également à cette étape que l’indentation devient explicite. En Python, l’indentation a une importance syntaxique très forte puisqu’elle permet de délimiter les blocs de code (conditions, boucles, fonctions, etc.).</br>

	Le lexer détecte donc les changements d’indentation et génère des tokens spéciaux représentant l’entrée ou la sortie d’un bloc. ~~Cela~~ permet ensuite au parser de comprendre précisément la structure du programme.		Le lexer détecte donc les changements d’indentation et génère des tokens spéciaux représentant l’entrée ou la sortie d’un bloc. Celà permet ensuite au parser de comprendre précisément la structure du programme.

	<h2>Parser</h2>		<h2>Parser</h2>
Ligne 124 :		Ligne 124 :
	L’AST est une étape extrêmement importante dans la compilation. À ce stade, on ne manipule plus simplement une suite linéaire de tokens, mais une véritable représentation logique et structurée du programme.</br>		L’AST est une étape extrêmement importante dans la compilation. À ce stade, on ne manipule plus simplement une suite linéaire de tokens, mais une véritable représentation logique et structurée du programme.</br>

	~~Cela~~ permet ensuite à la phase de compilation de parcourir facilement l’AST pour générer le bytecode correspondant.		Celà permet ensuite à la phase de compilation de parcourir facilement l’AST pour générer le bytecode correspondant.

	<h2>Compilation</h2>		<h2>Compilation</h2>
Ligne 216 :		Ligne 216 :
	</ul>		</ul>
	<h1>Partie machine virtuelle</h1>		<h1>Partie machine virtuelle</h1>
	Comme énoncé précédemment, la machine virtuelle de l'~~interprèteur~~ python prend en entrée un code objet, et l'execute. </br>		Comme énoncé précédemment, la machine virtuelle de l'interpréteur python prend en entrée un code objet, et l'execute. </br>
	<h2>Fonctionnement global</h2>		<h2>Fonctionnement global</h2>
	La machine virtuelle est basée sur une structure de pile Last In First Out (LIFO) pour les instructions. Elle utilise 2 piles différentes, qui ont chacune un rôle bien défini :		La machine virtuelle est basée sur une structure de pile Last In First Out (LIFO) pour les instructions. Elle utilise 2 piles différentes, qui ont chacune un rôle bien défini :
Ligne 243 :		Ligne 243 :
	<li><strong>STORE_FAST</strong> : Dépile et stock la valeur dans une variable locale </li>		<li><strong>STORE_FAST</strong> : Dépile et stock la valeur dans une variable locale </li>
	<li><strong>BINARY_OP PLUS / MINUS / STAR / SLASH / PERCENT </strong> : Dépile les deux derniers elements de la pile, leur applique l'opération entrée en paramètres, puis empile le résultat : <ul><li>PLUS --> Addition</li><li>MINUS --> Soustraction</li><li>STAR --> Multiplication</li><li>SLASH --> Division</li><li>PERCENT --> Modulo</li></ul>		<li><strong>BINARY_OP PLUS / MINUS / STAR / SLASH / PERCENT </strong> : Dépile les deux derniers elements de la pile, leur applique l'opération entrée en paramètres, puis empile le résultat : <ul><li>PLUS --> Addition</li><li>MINUS --> Soustraction</li><li>STAR --> Multiplication</li><li>SLASH --> Division</li><li>PERCENT --> Modulo</li></ul>
	<li><strong>COMPARE_OP EQEQ / LT / GT / LE / GE / NOTEQ </strong> : Opérateurs de comparaison logiques. Dépile les deux derniers elements et les compare : <ul><li>EQEQ --> égal (==)</li><li>LT (Lower Than) --> Strictement inférieur (<) </li><li>GT (Greater Than) --> Strictement ~~superieur~~ (>) </li><li>LE (Lower Equal) --> Inférieur ou égal (<=) </li><li>GE (Greater Equal) --> ~~Supperieur~~ ou égal (>=) </li><li>NOTEQ (NOT Equal) --> Différent de (!=) </li></ul>		<li><strong>COMPARE_OP EQEQ / LT / GT / LE / GE / NOTEQ </strong> : Opérateurs de comparaison logiques. Dépile les deux derniers elements et les compare : <ul><li>EQEQ --> égal (==)</li><li>LT (Lower Than) --> Strictement inférieur (<) </li><li>GT (Greater Than) --> Strictement supérieur (>) </li><li>LE (Lower Equal) --> Inférieur ou égal (<=) </li><li>GE (Greater Equal) --> Supérieur ou égal (>=) </li><li>NOTEQ (NOT Equal) --> Différent de (!=) </li></ul>
	<li><strong>POP_JUMP_IF_FALSE n / POP_JUMP_IF_TRUE</strong> : Dépile, et effectue un saut (principe de JUMP comme en assembleur) à l'instruction à l'indice n de la liste si la valeur qu'il vient de dépiler est vraie (TRUE) ou fausse (FALSE).</li>		<li><strong>POP_JUMP_IF_FALSE n / POP_JUMP_IF_TRUE</strong> : Dépile, et effectue un saut (principe de JUMP comme en assembleur) à l'instruction à l'indice n de la liste si la valeur qu'il vient de dépiler est vraie (TRUE) ou fausse (FALSE).</li>
	<li><strong>JUMP_ABSOLUTE n </strong> : Effectue un saut à l'instruction d'indice n </li>		<li><strong>JUMP_ABSOLUTE n </strong> : Effectue un saut à l'instruction d'indice n </li>
Ligne 295 :		Ligne 295 :
	<h1>Informations supplémentaires</h1>		<h1>Informations supplémentaires</h1>
	<strong> Lien du dépot github du projet :</strong> https://github.com/Marzzzbeats/Visi201</br></br>		<strong> Lien du dépot github du projet :</strong> https://github.com/Marzzzbeats/Visi201</br></br>
	<strong> Sources : </strong><ul><li>Documentation python</li><li>Wikipédia : (Python, Cpython, Compilateur, ~~Interpreteur~~, Bytecode)</li>		<strong> Sources : </strong><ul><li>Documentation python</li><li>Wikipédia : (Python, Cpython, Compilateur, Interpréteur, Bytecode)</li>