0Pricing
Python Academy · Leçon

Profilage mémoire avec tracemalloc

Suivez les allocations mémoire et trouvez les fuites avec tracemalloc.

Profilage mémoire avec tracemalloc est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Qu’est-ce que tracemalloc ?

tracemalloc est un module de la bibliothèque standard qui suit les allocations mémoire de Python par fichier et par ligne.

import tracemalloc

tracemalloc.start()

x = [i for i in range(100_000)]

current, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()

print(f"Current: {current/1024:.1f} KB")
print(f"Peak:    {peak/1024:.1f} KB")

Prendre des instantanés

Un instantané capture toutes les allocations actuelles à un moment donné. Comparez deux instantanés pour trouver ce qui a été alloué entre ces deux moments.

import tracemalloc

tracemalloc.start()

snap1 = tracemalloc.take_snapshot()

data = [{"key": str(i)} for i in range(10_000)]

snap2 = tracemalloc.take_snapshot()

stats = snap2.compare_to(snap1, "lineno")
for stat in stats[:5]:
    print(stat)

Filtrer les instantanés

Filtrez les statistiques pour n’afficher que le code de votre application, en excluant la bibliothèque standard.

import tracemalloc

tracemalloc.start()
leak_function()
snap = tracemalloc.take_snapshot()

filters = [tracemalloc.Filter(True, "*/myapp/*")]
stats = snap.filter_traces(filters).statistics("lineno")
for stat in stats[:10]:
    print(stat)

Principaux allocateurs

Utilisez snapshot.statistics("lineno") ou "traceback" pour voir les principaux consommateurs de mémoire, par ligne ou selon la trace complète des appels.

import tracemalloc

tracemalloc.start(nframe=10)   # track 10 frames deep

big_list = [i**2 for i in range(500_000)]

snap = tracemalloc.take_snapshot()
for stat in snap.statistics("traceback")[:3]:
    print(stat)
    for line in stat.traceback.format():
        print("  ", line)

Trouver les fuites mémoire

Prenez deux instantanés autour d’une fuite suspectée, puis comparez-les. Une augmentation des statistiques entre les instantanés indique une fuite.

import tracemalloc

tracemalloc.start()
snap_before = tracemalloc.take_snapshot()

for _ in range(100):
    suspected_leaky_function()

snap_after = tracemalloc.take_snapshot()
diff = snap_after.compare_to(snap_before, "lineno")
for stat in diff[:5]:
    print(stat)

get_traced_memory()

tracemalloc.get_traced_memory() renvoie les octets (current, peak) : c’est utile pour effectuer des vérifications légères avant et après une opération.

import tracemalloc

tracemalloc.start()
before, _ = tracemalloc.get_traced_memory()

do_something()

after, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()

print(f"Delta: {(after-before)/1024:.1f} KB, Peak: {peak/1024:.1f} KB")

memory_profiler

memory_profiler fournit l’utilisation de la mémoire ligne par ligne, comme line_profiler pour le CPU.

# pip install memory_profiler
from memory_profiler import profile

@profile
def build_data():
    data = [i**2 for i in range(100_000)]
    filtered = [x for x in data if x % 2 == 0]
    return filtered

build_data()
# python -m memory_profiler script.py

memray

memray (développé par Bloomberg) est un profileur mémoire Python rapide qui produit des graphiques en flammes.

# pip install memray
# python -m memray run script.py
# python -m memray flamegraph memray-script.py.bin

# Generates an interactive HTML flamegraph
# showing allocations by call stack

Réduire l’utilisation de la mémoire

Techniques courantes : utilisez des générateurs plutôt que des listes, __slots__, le module array pour les données numériques et les tableaux numpy, et évitez de conserver de gros objets en vie dans des fermetures.

# Instead of:
data = [process(x) for x in huge_list]   # all in memory

# Use a generator:
def gen_data(lst):
    for x in lst:
        yield process(x)

for item in gen_data(huge_list):
    consume(item)   # one at a time

sys.getsizeof()

sys.getsizeof(obj) renvoie la mémoire utilisée par un objet en octets (de façon superficielle : les objets référencés ne sont pas inclus).

import sys

print(sys.getsizeof([]))          # 56
print(sys.getsizeof([1,2,3]))     # 88
print(sys.getsizeof("hello"))     # 54
print(sys.getsizeof({}))          # 64

# For deep size, use recursive measurement:
def deep_size(obj):
    return sys.getsizeof(obj) + sum(
        sys.getsizeof(v) for v in vars(obj).values()
        if hasattr(obj, "__dict__")
    )

Profilage en production

Exécutez tracemalloc avec un nombre limité de nframes en production afin de réduire la surcharge au minimum. Enregistrez les instantanés dans un fichier pour les analyser hors ligne.

import tracemalloc, pickle

tracemalloc.start(nframe=5)   # low overhead

# ... serve some requests ...

snap = tracemalloc.take_snapshot()
with open("snap.pkl","wb") as f:
    pickle.dump(snap, f)
# Analyse later offline

Vérification rapide

Que représentent les deux valeurs renvoyées par tracemalloc.get_traced_memory() ?

Récapitulatif

Utilisez tracemalloc.start() et des instantanés pour trouver les fuites mémoire. Comparez les instantanés avec compare_to(). Utilisez memory_profiler pour mesurer l’utilisation ligne par ligne et memray pour produire des graphiques en flammes. Réduisez l’utilisation de la mémoire avec des générateurs, __slots__ et des tableaux NumPy.

Questions Fréquemment Posées

La leçon « Profilage mémoire avec tracemalloc » est-elle gratuite ?

Oui — le texte complet de « Profilage mémoire avec tracemalloc » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Profilage mémoire avec tracemalloc » ?

Suivez les allocations mémoire et trouvez les fuites avec tracemalloc. Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Profilage mémoire avec tracemalloc » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Comptage des références dans CPython
  2. Ramasse-miettes et références cycliques
  3. Profilage avec cProfile et line_profiler
  4. Profilage mémoire avec tracemalloc
← Retour à Python Academy