Entre ton fichier de code et les instructions du CPU, il se passe beaucoup de choses. Regardons sous le capot.
⏱️ Durée : environ 75 minutes · 🎓 Niveau : débutant · 🏅 Badge : Anatomiste de processus
🎬 L'histoire
Kodi lance un script Python qui plante avec RecursionError. Un autre programme, écrit en C par un collègue, plante avec segmentation fault. Même idée (trop d'appels), deux erreurs différentes.
« Pour comprendre, il faut voir un programme comme la machine le voit, dit Sam : du code, des données, une pile, un tas. »
Tu apprends comment un programme est organisé en mémoire pendant qu'il tourne.
🎯 Ta mission
À la fin, je serai capable de :
- décrire le chemin du code source à l'exécution (compilation, interprétation, chargement)
- décrire la disposition mémoire : code, données, tas, pile
- expliquer ce qu'est un cadre de pile (stack frame)
- expliquer le dépassement de pile et la récursion
- lire le bytecode Python avec le module
dis
🧩 Défi d'échauffement (5 XP)
Tu lis une recette à voix haute à quelqu'un qui cuisine. La recette dit : « Pour la sauce, voir la recette de la page 12 ». Il faut interrompre la recette en cours, aller faire la sauce, puis revenir exactement où tu en étais. Comment retenir où tu en étais, si la sauce elle-même renvoie à une autre recette ? Que se passe-t-il si les renvois s'enchaînent sans fin ?
💡 Le concept
Du code à l'exécution
| Étape | Rôle |
|---|---|
| Écriture | code source (texte) |
| Compilation | traduction du code source en langage machine (C, Rust, Go) ou en bytecode (Java, Python) |
| Édition de liens | assemblage des morceaux et des bibliothèques |
| Chargement | le système d'exploitation copie le programme en mémoire et lance le processus |
| Exécution | le CPU exécute (ou une machine virtuelle interprète) |
Compilé : traduit à l'avance en code machine (rapide). Interprété : lu et exécuté par un autre programme (flexible, plus lent). Python compile vers du bytecode exécuté par une machine virtuelle.
La mémoire d'un processus
adresses hautes ┌──────────────┐
│ Pile │ ← appels de fonctions, variables locales (croît vers le bas)
│ ↓ │
│ │
│ ↑ │
│ Tas │ ← objets alloués dynamiquement (croît vers le haut)
├──────────────┤
│ Données │ ← variables globales
├──────────────┤
adresses basses │ Code │ ← instructions du programme
└──────────────┘
La pile d'appels
Chaque appel de fonction crée un cadre de pile (stack frame) qui contient :
- les paramètres ;
- les variables locales ;
- l'adresse de retour (où reprendre après la fonction).
Quand la fonction se termine, son cadre est dépilé et l'exécution reprend à l'adresse de retour.
def c():
return 1
def b():
return c() + 1
def a():
return b() + 1
print(a()) # 3 : pile pendant l'appel de c : a, b, c
Dépassement de pile
La pile a une taille limitée. Une récursion trop profonde la remplit :
- en C :
segmentation fault(accès hors de la zone autorisée) ; - en Python :
RecursionError(une limite logicielle protège la machine).
import sys
print(sys.getrecursionlimit()) # 1000 par défaut en général
La pile et le tas
| Pile | Tas | |
|---|---|---|
| Contenu | variables locales, appels | objets de durée variable |
| Gestion | automatique (entrée/sortie de fonction) | allocation à la demande |
| Vitesse | très rapide | plus lente |
| Risque | dépassement | fuites, fragmentation |
En Python, presque tout est un objet sur le tas ; les variables sont des références.
Voir le bytecode
import dis
def somme(a, b):
return a + b
dis.dis(somme)
Le résultat liste des instructions de la machine virtuelle (LOAD_FAST, BINARY_OP ou BINARY_ADD, RETURN_VALUE…), qui ressemblent à notre mini-processeur.
🧠 Astuce : quand ta récursion est « trop profonde », pense à la pile : chaque appel y laisse un cadre jusqu'à sa fin.
🔍 Exemple pas à pas
Problème : voir la pile d'appels grandir, puis provoquer un dépassement contrôlé.
import sys
profondeur_max = 0
def descendre(n):
global profondeur_max
profondeur_max = max(profondeur_max, n)
return descendre(n + 1)
try:
descendre(0)
except RecursionError:
print("dépassement de pile à une profondeur de", profondeur_max)
print("limite configurée :", sys.getrecursionlimit())
Lecture : la profondeur atteinte est proche de la limite (un peu en dessous, car le programme principal utilise déjà quelques cadres). Chaque appel consomme de la pile ; la limite protège la machine.
Version itérative (sans pile d'appels) :
def compter_iteratif(n):
total = 0
for i in range(n + 1):
total += i
return total
def compter_recursif(n):
return 0 if n == 0 else n + compter_recursif(n - 1)
print(compter_iteratif(10000)) # 50005000
try:
print(compter_recursif(10000))
except RecursionError:
print("la version récursive dépasse la pile")
Leçon : une boucle utilise un cadre de pile constant ; une récursion en utilise un par niveau.
✍️ À toi, avec aide (10 XP)
Examine le bytecode de cette fonction avec dis :
def carre_plus_un(x):
return x * x + 1
- Combien d'instructions de calcul vois-tu ?
- Retrouve la correspondance avec notre mini-processeur (LOAD, MUL, ADD…).
- Que contient une pile de machine virtuelle à chaque instant ?
💡 Indice 1
Importe dis et appelle dis.dis(carre_plus_un).
💡 Indice 2
Cherche des instructions contenant LOAD, MULTIPLY ou BINARY_OP, ADD, RETURN.
💡 Indice 3
La machine virtuelle Python est une machine à pile : les opérandes sont empilés puis consommés.
✅ Réponse
import dis
def carre_plus_un(x):
return x * x + 1
dis.dis(carre_plus_un)
On observe en gros : charger x (deux fois), multiplier, charger la constante 1, additionner, retourner. Deux opérations de calcul (la multiplication et l'addition). La pile de la machine virtuelle contient les opérandes en attente : après LOAD x, LOAD x elle contient deux valeurs ; MULTIPLY les remplace par leur produit ; etc. Le nom exact des instructions dépend de la version de Python.
🚀 À toi, en solo (20 XP)
Simule la pile d'appels. Écris un petit interpréteur qui exécute factorielle(4) en gérant lui-même une pile de cadres (liste de dictionnaires {"fonction": …, "n": …, "retour": …}).
À chaque empilement/dépilement, affiche l'état de la pile. Vérifie que la profondeur maximale est n + 1 et que le résultat est 24.
✅ Pistes de correction
def factorielle_avec_pile(n):
pile = []
max_profondeur = 0
# descente : on empile un cadre par valeur
for k in range(n, -1, -1):
pile.append({"fonction": "fact", "n": k})
max_profondeur = max(max_profondeur, len(pile))
print("empile ", [c["n"] for c in pile])
# remontée : on dépile et on combine
resultat = 1 # fact(0) = 1
pile.pop()
print("dépile ", [c["n"] for c in pile], "→ fact(0) = 1")
while pile:
cadre = pile.pop()
resultat = cadre["n"] * resultat
print("dépile ", [c["n"] for c in pile], "→ fact(%d) = %d" % (cadre["n"], resultat))
return resultat, max_profondeur
r, p = factorielle_avec_pile(4)
assert r == 24 and p == 5
(r, p)
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Récursion sans limite | Dépassement de pile | Prévoir un cas de base et une profondeur raisonnable, ou utiliser une boucle |
| Confondre pile et tas | Mauvais modèle mental de la mémoire | Pile = appels et locales ; tas = objets |
| Croire qu'un langage est « soit compilé soit interprété » | La réalité est un spectre (bytecode, JIT) | Voir la chaîne complète |
| Oublier que les variables Python sont des références | Modifications inattendues d'objets partagés | Distinguer objet et nom |
🐉 Mini-boss (40 XP)
Autopsie d'un processus Python.
- Écris un programme qui crée une liste de 1 million d'entiers, une fonction récursive de profondeur 500, et un dictionnaire de 100 000 entrées.
- Mesure avec
tracemallocla mémoire utilisée sur le tas par chaque structure. - Utilise
sys.getsizeofetidpour montrer que deux variables peuvent désigner le même objet. - Utilise
dispour comparer le bytecode d'une boucleforet d'une compréhension de liste. - Rédige un schéma de la mémoire au moment de l'appel le plus profond (pile et tas).
✅ Pistes de correction
import sys, tracemalloc, dis
def mesurer(f):
tracemalloc.start()
objet = f()
courant, pic = tracemalloc.get_traced_memory()
tracemalloc.stop()
return objet, courant // 1024
liste, ko1 = mesurer(lambda: list(range(1_000_000)))
dico, ko2 = mesurer(lambda: {i: i for i in range(100_000)})
print("liste :", ko1, "Ko ; dictionnaire :", ko2, "Ko")
a = [1, 2, 3]
b = a
print(a is b, id(a) == id(b)) # même objet
c = list(a)
print(a is c) # copie : autre objet
def boucle(n):
r = []
for i in range(n):
r.append(i * 2)
return r
def comprehension(n):
return [i * 2 for i (n)]
dis.dis(boucle)
dis.dis(comprehension)
():
n == + profond(n - )
(profond())
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un cadre de pile contient notamment :
- A. le code source
- B. les fichiers ouverts
- C. les variables locales et l'adresse de retour
2. Un RecursionError en Python signale :
- A. une pile d'appels trop profonde
- B. un fichier manquant
- C. une erreur de syntaxe
3. En mémoire, les objets de taille variable créés pendant l'exécution se trouvent surtout :
- A. dans les registres
- B. sur le tas
- C. dans le code
4. 🔁 Révision mission 07 : Une interruption est :
- A. une panne
- B. un type de mémoire
- C. un signal d'un périphérique vers le CPU
5. 🔁 Révision mission 06 : Un tampon (buffer) sert à :
- A. regrouper des données avant de les envoyer
- B. effacer des fichiers
- C. chiffrer les données
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Quelle situation de ta vie ressemble à une « pile d'appels » (tâches interrompues par d'autres tâches) ?
- Comment le fait de savoir ce qu'est la pile t'aide-t-il à lire un message d'erreur ?
🎒 À retenir
- Un processus = code, données, tas, pile.
- Chaque appel de fonction crée un cadre de pile.
- Trop d'appels imbriqués → dépassement de pile.
- Python compile vers du bytecode exécuté par une machine virtuelle.
- Boucle = pile constante ; récursion = une trame par niveau.
flowchart LR
T(["Un programme en cours d'exécution"])
T --> R1["1. Un processus = code, données, tas, pile."]
T --> R2["2. Chaque appel de fonction crée un cadre de pile."]
T --> R3["3. Trop d'appels imbriqués → dépassement de pile."]
T --> R4["4. Python compile vers du bytecode exécuté par une machine virtuelle."]
T --> R5["5. Boucle = pile constante ; récursion = une trame par niveau."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Anatomiste de processus
← Mission 07 — Bus, interruptions et périphériques · Mission 09 — Performance et limites physiques →
HEF-040 — Architecture des ordinateurs

