La mémoire est limitée, et la créer, la copier et la libérer coûte du temps. Savoir où elle part, c'est éviter pannes et lenteurs.
⏱️ Durée : environ 100 minutes · 🎓 Niveau : avancé · 🏅 Badge : Économe de mémoire
🎬 L'histoire
Le traitement nocturne des certificats de HashBox lit un fichier d'inscriptions de 2 Go. Il fonctionne pendant des mois, puis un soir il est tué par le système : « out of memory ». Personne n'a changé le code. Le fichier a simplement doublé.
« Le code chargeait tout en mémoire, dit Sam. Tant que ça tenait, ça marchait. Il existe des façons de traiter des données plus grosses que la mémoire : flux, générateurs, structures compactes. Et d'autres fois, la mémoire n'est pas trop petite, elle fuit : un cache qui ne se vide jamais. »
Tu apprends à mesurer la mémoire avec tracemalloc, à comparer des structures de données, à utiliser des flux plutôt que des listes complètes, à repérer des fuites, et à borner un cache.
🎯 Ta mission
À la fin, je serai capable de :
- mesurer la mémoire d'un programme avec
tracemallocetsys.getsizeof - comparer le coût mémoire de structures (liste, tuple, dict, classe,
__slots__,array) - traiter de gros volumes avec des générateurs et des flux
- détecter une fuite mémoire en comparant des instantanés
- borner un cache (LRU) pour qu'il ne croisse pas sans limite
🧩 Défi d'échauffement (5 XP)
Tu déménages. Tu peux tout mettre dans un seul gros camion, ou faire des allers-retours en voiture avec quelques cartons. Quand le camion est trop petit, tu es bloqué ; avec des allers-retours, tu es lent mais tu peux déménager n'importe quelle quantité. Fais le parallèle avec lire un fichier de 2 Go en entier ou ligne par ligne.
💡 Le concept
Où part la mémoire ?
Chaque objet Python a un en-tête (compteur de références, type) en plus de ses données. Quelques ordres de grandeur (CPython 64 bits) :
| Objet | Taille approximative |
|---|---|
int (petit) | 28 octets |
str d'un caractère | ~50 octets |
list vide | 56 octets (+ 8 par élément) |
tuple de 3 éléments | 64 octets |
dict vide | 64 octets, ~230 avec quelques éléments |
| Instance de classe simple | ~48 octets + son dictionnaire d'attributs (~100+ octets) |
Une liste d'un million d'entiers occupe plus de 36 Mo (8 par pointeur + 28 par entier), alors qu'un tableau compact de 4 octets par entier en prendrait 4 Mo.
Mesurer
sys.getsizeof(objet): taille de l'objet seul (pas de ce qu'il contient).tracemalloc: trace chaque allocation Python ; on prend un instantané (take_snapshot), on lit le courant et le pic (get_traced_memory), on compare deux instantanés pour voir ce qui a augmenté.memory_profiler,resource.getrusage(pic de mémoire du processus).
Structures plus compactes
| Besoin | Option | Gain |
|---|---|---|
| Beaucoup de nombres | array.array('i'), NumPy | ×5 à ×10 |
| Beaucoup d'objets identiques | classe avec __slots__ (pas de dictionnaire par instance) | ~×2 à ×3 |
| Enregistrements immuables | tuple, NamedTuple | plus petits que dict |
| Chaînes répétées | internement (sys.intern), ou stocker un indice dans une table | selon répétition |
| Booléens en masse | bytearray, champs de bits | ×8 ou plus |
| Texte volumineux | , (sans copie) |
Flux et générateurs
Charger tout en mémoire : lignes = fichier.readlines() → O(taille). Traiter ligne par ligne : for ligne in fichier → O(1) en mémoire. Un générateur produit les éléments un par un ; il remplace la liste complète quand on ne parcourt qu'une fois.
total = sum(int(l) for l in fichier) # mémoire constante
total = sum([int(l) for l in fichier]) # construit toute la liste d'abord
Copies et vues
Découper (tranche = donnees[a:b]) copie. Pour de grosses données binaires, memoryview donne une vue sans copie. Les copies inutiles coûtent à la fois de la mémoire et du temps.
Ramasse-miettes et fuites
CPython libère un objet quand son compteur de références tombe à zéro ; un ramasse-miettes détecte aussi les cycles. Une « fuite » en Python est presque toujours un objet encore référencé sans qu'on s'en serve :
- cache ou dictionnaire global qui ne se vide jamais ;
- liste de journaux/historique qui grandit ;
- écouteurs enregistrés jamais retirés ;
- références dans les exceptions et les fermetures.
Diagnostic : comparer deux instantanés tracemalloc pris à des moments différents ; les lignes qui grossissent sont les suspectes.
Borner les structures
Toute structure qui croît avec le temps doit avoir une limite explicite : taille maximale, durée de vie (TTL), politique d'éviction (LRU : on retire l'élément le moins récemment utilisé). functools.lru_cache(maxsize=...) le fait pour une fonction.
Mémoire et performance
Moins de mémoire utilisée = meilleure utilisation des caches du processeur = souvent plus rapide. Mais attention aux compromis : un index en mémoire accélère les recherches mais consomme de la RAM.
🧠 Astuce : demande-toi toujours « combien de données au pire ? ». Si la réponse est « ça dépend de l'entrée », fais un flux plutôt qu'une liste.
🔍 Exemple pas à pas
Problème : mesurer la mémoire de plusieurs structures avec tracemalloc, traiter 1 million de lignes en flux, détecter une fuite par instantanés, et la corriger avec un cache LRU borné.
import array, collections, sys, tracemalloc
def pic_memoire(fonction):
tracemalloc.start()
try:
resultat = fonction()
courant, pic = tracemalloc.get_traced_memory()
finally:
tracemalloc.stop()
return pic, resultat
# ---------------- 1. liste contre générateur ----------------
N = 500000
def avec_liste(): return sum([i * 2 for i in range(N)])
def avec_generateur(): return sum(i * 2 for i in range(N))
pic_l, r1 = pic_memoire(avec_liste)
pic_g, r2 = pic_memoire(avec_generateur)
print(f"liste : pic {pic_l / 1e6:6.2f} Mo | générateur : pic {pic_g / 1e6:6.3f} Mo (rapport x{pic_l / pic_g:.0f})")
assert r1 == r2 and pic_l > 100 * pic_g
# ---------------- 2. coût d'un million d'entiers ----------------
def liste_ints(): return list(range(1_000_000))
def tableau_ints(): array.array(, ())
pic_li, _ = pic_memoire(liste_ints)
pic_ta, _ = pic_memoire(tableau_ints)
()
pic_li > * pic_ta
:
(): .membre, .cours, .montant = membre, cours, montant
:
__slots__ = (, , )
(): .membre, .cours, .montant = membre, cours, montant
():
: [fabrique(i % , i % , i % ) i (n)]
mesures = {
: pic_memoire(construire( a, b, c: {: a, : b, : c}))[],
: pic_memoire(construire(Insc))[],
: pic_memoire(construire(InscSlots))[],
: pic_memoire(construire( a, b, c: (a, b, c)))[],
}
nom, pic (mesures.items(), key= kv: kv[]):
()
(mesures[], mesures[]) < mesures[] < mesures[]
HISTORIQUE = []
():
HISTORIQUE.append({: i, : + * })
i
tracemalloc.start()
i (): traiter_requete(i)
avant = tracemalloc.take_snapshot()
i (, ): traiter_requete(i)
apres = tracemalloc.take_snapshot()
croissance = apres.compare_to(avant, )
suspecte = croissance[]
()
tracemalloc.stop()
suspecte.size_diff > (HISTORIQUE) ==
:
():
.taille_max, .donnees = taille_max, collections.OrderedDict()
():
cle .donnees:
.donnees.move_to_end(cle); .donnees[cle]
():
.donnees[cle] = valeur; .donnees.move_to_end(cle)
(.donnees) > .taille_max:
.donnees.popitem(last=)
cache = LRU()
():
cache.ecrire(i, {: i, : + * }); i
tailles = []
etape ():
i (etape * , (etape + ) * ): traiter_requete_v2(i)
tailles.append((cache.donnees))
(, tailles)
tailles == [] *
():
i (n):
():
((l.split()[]) l lignes(n))
p_petit, t1 = pic_memoire(: total_en_flux())
p_grand, t2 = pic_memoire(: total_en_flux())
()
p_grand < * p_petit +
Lecture :
- Le générateur consomme une fraction infime de la mémoire de la liste (le rapport est de plusieurs centaines).
- Un
array('i')stocke un million d'entiers en ~4 Mo contre ~36 Mo pour la liste (huit fois plus). - Pour 100 000 enregistrements :
__slots__ettuple(≈ 90 octets chacun) < classe ordinaire (≈ 125) <dict(≈ 215), soit un facteur proche de 2,5 entre les deux extrêmes. - La comparaison d'instantanés désigne la ligne qui fuit (ici
HISTORIQUE.append). La correction par un cache LRU borné garde la taille stable. - Le flux traite 100 fois plus de données avec une mémoire quasi inchangée.
✍️ À toi, avec aide (10 XP)
Estime et vérifie la mémoire pour stocker 2 millions de relevés de température (un réel par relevé) :
- dans une liste de
float; - dans un
array('d'); - dans un
bytearrayde relevés convertis en entiers 16 bits (précision 0,01 °C) viastructouarray('h').
Donne la mémoire théorique de chaque option, vérifie-la avec tracemalloc, et dis laquelle choisir si la précision de 0,01 °C suffit.
💡 Indice 1
Un float Python occupe 24 octets + 8 octets de pointeur dans la liste.
💡 Indice 2
array('d') : 8 octets par valeur ; array('h') : 2 octets.
💡 Indice 3
Mesure le pic avec la fonction pic_memoire.
✅ Réponse
import array, tracemalloc, random
rng = random.Random(1)
N = 2_000_000
def pic(f):
tracemalloc.start(); r = f(); courant, p = tracemalloc.get_traced_memory(); tracemalloc.stop(); return courant, r
valeurs = [rng.uniform(-20, 40) for _ in range(N)]
m_liste, _ = pic(lambda: list(valeurs)) # copie des pointeurs seulement (les float existent déjà)
m_double, _ = pic(lambda: array.array("d", valeurs))
m_court, _ = pic(lambda: array.array("h", (round(v * 100) for v in valeurs)))
liste_totale = 8 * N + 24 * N # pointeurs + objets float
print(f"liste de float : ~{liste_totale / 1e6:.0f} Mo (théorique) | array('d') : {m_double / 1e6:.1f} Mo | array('h') : {m_court / 1e6:.1f} Mo")
assert abs(m_double - 8 * N) < 0.01 * 8 * N and abs(m_court - * N) < * * N
🚀 À toi, en solo (20 XP)
Traiter un gros fichier sans le charger. Écris analyser(chemin) pour un fichier CSV de plusieurs millions de lignes membre;cours;montant qui calcule, en une seule passe et en mémoire bornée :
- le nombre de lignes et le montant total ;
- les 5 membres au montant total le plus élevé (en ne gardant en mémoire qu'une structure bornée : un tas de taille 5 et un dictionnaire par membre — explique pourquoi, avec 100 000 membres, cela reste raisonnable, et ce que tu ferais s'il y en avait 100 millions) ;
- le nombre de membres distincts avec un ensemble approximatif économe (filtre de Bloom ou compteur HyperLogLog simplifié) et son erreur ;
- teste sur un fichier généré (500 000 lignes) ; mesure le pic de mémoire avec
tracemallocet vérifie qu'il reste très inférieur à celui d'une version qui charge tout.
✅ Pistes de correction
import heapq, math, os, random, tempfile, tracemalloc, hashlib
from collections import defaultdict
def generer(chemin, n=500000, graine=1):
rng = random.Random(graine)
with open(chemin, "w") as f:
for _ in range(n):
f.write(f"m{int(rng.paretovariate(1.2)) % 20000};HEF-{rng.randrange(90):03d};{rng.randrange(1, 200)}\n")
class Compteur_distincts:
# estimation de cardinalité de type « probabilistic counting » (registres de rang maximal, HyperLogLog simplifié)
def __init__(self, p=10):
self.p, self.m = p, 1 << p
self.registres = [0] * self.m
def ajouter(self, x):
h = int(hashlib.blake2b(x.encode(), digest_size=8).hexdigest(), 16)
i, reste = h >> ( - .p), h & (( << ( - .p)) - )
rang = ( - .p) - reste.bit_length() +
.registres[i] = (.registres[i], rang)
():
alpha = / ( + / .m)
e = alpha * .m * .m / ( ** -r r .registres)
zeros = .registres.count()
.m * math.log(.m / zeros) e <= * .m zeros e
():
lignes, total, par_membre, distincts = , , defaultdict(), Compteur_distincts()
(chemin) f:
ligne f:
membre, _, montant = ligne.rstrip().split()
lignes += ; total += (montant); par_membre[membre] += (montant); distincts.ajouter(membre)
top5 = heapq.nlargest(, par_membre.items(), key= kv: kv[])
lignes, total, top5, distincts.estimation(), (par_membre)
():
contenu = [l.rstrip().split() l (chemin)]
(contenu), ((c[]) c contenu)
tempfile.TemporaryDirectory() d:
chemin = os.path.join(d, ); generer(chemin)
tracemalloc.start(); r = analyser(chemin); _, pic_flux = tracemalloc.get_traced_memory(); tracemalloc.stop()
tracemalloc.start(); analyser_tout_charger(chemin); _, pic_tout = tracemalloc.get_traced_memory(); tracemalloc.stop()
lignes, total, top5, estime, exact = r
()
()
()
lignes == pic_flux < pic_tout / (estime - exact) / exact <
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Charger tout un fichier en mémoire | Ça tient aujourd'hui, pas demain | Flux ligne par ligne, générateurs |
| Caches et historiques non bornés | Fuite mémoire lente puis arrêt brutal | Taille max, TTL, éviction LRU |
| Copier des données sans nécessité | Mémoire et temps gaspillés | Vues (memoryview), tranches avec prudence |
| Ne pas mesurer | On optimise la mauvaise structure | tracemalloc, instantanés comparés |
🐉 Mini-boss (40 XP)
Budget mémoire du traitement des certificats. Un traitement lit un fichier de 5 millions d'inscriptions (génère-le à échelle réduite, 500 000 lignes) et doit produire des statistiques par cours, par mois et par membre, avec un budget de 50 Mo de pic.
- écris la version naïve (tout charger) et mesure son pic ;
- identifie les trois plus gros consommateurs avec des instantanés
tracemalloc; - réécris en flux avec des structures compactes (
__slots__ou tuples,array, internement des chaînes répétées) ; - borne tout cache et expose la taille de chaque structure ;
- prouve l'équivalence des résultats avec la version naïve ;
- tableau : version, pic mémoire, temps, facteur de réduction ;
- extrapole : à 5 millions de lignes, la version finale respecte-t-elle le budget ? Justifie.
✅ Pistes de correction
Un bon travail : mesure du pic (naïf), comparaison de snapshots désignant les listes complètes, les dictionnaires par enregistrement, les chaînes dupliquées; version finale avec lecture en flux, sys.intern pour les codes de cours, array pour les montants, cache LRU; résultats identiques; tableau des facteurs; extrapolation par régression linéaire entre deux tailles (la mémoire de la version finale doit rester presque constante sauf pour le dictionnaire des membres, dont on calcule la taille en fonction du nombre de membres distincts).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Pour traiter un fichier plus gros que la mémoire, on utilise :
- A. un flux ou un générateur, ligne par ligne
- B. une liste de toutes les lignes
- C. un second écran
2. Une fuite mémoire en Python correspond le plus souvent à :
- A. un manque de RAM sur la machine
- B. des objets encore référencés (cache, historique) qu'on n'utilise plus
- C. une erreur de syntaxe
3. __slots__ permet de :
- A. accélérer le réseau
- B. chiffrer les attributs
- C. réduire la mémoire des instances en évitant un dictionnaire par objet
4. 🔁 Révision mission 03 : Dans un profil, tottime mesure :
- A. le temps passé dans la fonction elle-même, sans ses sous-appels
- B. le temps total du programme
- C. le nombre d'appels
5. 🔁 Révision mission 03 : La première étape d'une optimisation est de :
- A. réécrire le code en C
- B. profiler pour identifier le point chaud
- C. ajouter du cache partout
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Quelle structure de ton code grossit avec le temps sans jamais être vidée ?
- Si tes données doublaient demain, qu'est-ce qui casserait en premier côté mémoire ?
🎒 À retenir
- Mesurer :
tracemalloc(courant, pic, instantanés),getsizeof(objet seul). - Structures compactes :
array,__slots__, tuples. - Flux et générateurs : mémoire constante.
- Fuite = référence oubliée ; comparer deux instantanés.
- Borner tout ce qui croît : taille max, TTL, LRU.
flowchart LR
T(["Mémoire et allocations"])
T --> R1["1. Mesurer : tracemalloc courant, pic, instantanés, getsizeof objet seul."]
T --> R2["2. Structures compactes : array, slots, tuples."]
T --> R3["3. Flux et générateurs : mémoire constante."]
T --> R4["4. Fuite = référence oubliée ; comparer deux instantanés."]
T --> R5["5. Borner tout ce qui croît : taille max, TTL, LRU."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Économe de mémoire
← Mission 03 — Profilage CPU · Mission 05 — I/O et stockage →
HEF-130 — Performance

