Profilage avec cProfile et line_profiler
Trouvez les points chauds du CPU avec cProfile et un profilage ligne par ligne.
Profilage avec cProfile et line_profiler est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.
Pourquoi effectuer un profilage ?
Le profilage identifie les fonctions qui consomment le plus de temps et oriente les efforts d’optimisation. Profilez toujours avant d’optimiser : ne devinez jamais.
import cProfile
def slow():
total = 0
for i in range(1_000_000):
total += i
return total
cProfile.run("slow()")Exécuter cProfile depuis la CLI
Profilez un script entier sans le modifier : python -m cProfile -s cumtime script.py. Triez selon cumtime, tottime ou calls.
# python -m cProfile -s cumtime my_script.py
#
# ncalls tottime percall cumtime percall filename:lineno(function)
# 1000 0.500 0.001 2.100 0.002 utils.py:10(process)cProfile dans le code
Créez un objet cProfile.Profile, activez-le ou désactivez-le, puis affichez les statistiques avec pstats.
import cProfile, pstats, io
pr = cProfile.Profile()
pr.enable()
# ... code to profile ...
pr.disable()
stream = io.StringIO()
ps = pstats.Stats(pr, stream=stream).sort_stats("cumulative")
ps.print_stats(10) # top 10
print(stream.getvalue())Filtrage avec pstats
Filtrez la sortie du profileur selon un module précis ou un motif correspondant au nom d’une fonction à l’aide de print_stats(pattern).
import cProfile, pstats
cProfile.run("my_function()", "profile.out")
stats = pstats.Stats("profile.out")
stats.sort_stats("tottime")
stats.print_stats("mymodule") # only mymodule functionsline_profiler
line_profiler affiche le temps d’exécution ligne par ligne, et pas seulement fonction par fonction : c’est essentiel pour trouver la ligne la plus lente au sein d’une fonction.
# pip install line_profiler
# Decorate target function:
from line_profiler import profile
@profile
def process(data):
result = []
for item in data: # <- which line is slow?
result.append(item*2)
return result
# Run: kernprof -l -v script.pyCLI kernprof
kernprof -l script.py exécute le script avec le profilage ligne par ligne activé : -v affiche immédiatement le rapport.
# kernprof -l -v script.py
#
# Line # Hits Time Per Hit % Time Line Contents
# ======================================================
# 4 1 2.0 2.0 1.0 result = []
# 5 1000 120.0 0.1 60.0 for item in data:
# 6 1000 80.0 0.1 39.0 result.append(item*2)Profilage dans Jupyter
Jupyter fournit les commandes magiques %prun (cProfile) et %lprun (line_profiler).
# In a Jupyter cell:
# %prun -s cumulative my_function(data)
# %load_ext line_profiler
# %lprun -f my_function my_function(data)Identifier les points chauds
Concentrez-vous sur les fonctions dont le temps cumulé est le plus élevé (toute la chaîne) et celles dont le temps total est le plus élevé (la fonction elle-même, sans les fonctions appelées).
# cumtime = total time including callees (find root cause)
# tottime = time in function itself (find where work happens)
#
# Optimise the function with highest tottime firstÉviter l’optimisation prématurée
Profilez d’abord, puis optimisez le goulot d’étranglement mesuré. Les accélérations courantes en Python consistent à utiliser les fonctions intégrées, déplacer les boucles vers NumPy, mettre en cache les recherches répétées ou appeler du code C avec ctypes/cffi.
# Before optimising:
# profile shows: process_row() 95% of time
# Speedup: vectorise with NumPy
import numpy as np
arr = np.array(data)
result = arr * 2 # 100x faster than Python looppy-spy : profileur par échantillonnage
py-spy profile les processus en cours d’exécution sans modifier le code : attachez-le à un PID actif.
# pip install py-spy
# Profile for 30 s and show flamegraph:
# py-spy top --pid 12345
# py-spy record -o profile.svg --pid 12345 --duration 30Évaluer les performances avec timeit
Utilisez timeit pour mesurer de petites expressions précises.
import timeit
result = timeit.timeit(
"[x*2 for x in range(1000)]",
number=10_000
)
print(f"{result:.3f} s for 10k runs")Vérification rapide
Que montre tottime dans un rapport cProfile ?
Récapitulatif
Utilisez cProfile pour trouver les fonctions lentes et line_profiler pour trouver la ligne lente. Profilez avec -s cumtime pour trouver les causes profondes. N’optimisez que les points chauds avérés : utilisez la vectorisation NumPy, la mise en cache ou des extensions C pour obtenir les gains les plus importants.
Apprends Python avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 76
- Leçons
- 320
Questions Fréquemment Posées
La leçon « Profilage avec cProfile et line_profiler » est-elle gratuite ?
Oui — le texte complet de « Profilage avec cProfile et line_profiler » 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 avec cProfile et line_profiler » ?
Trouvez les points chauds du CPU avec cProfile et un profilage ligne par ligne. 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 3 sur 4.
Combien de temps prend la leçon « Profilage avec cProfile et line_profiler » ?
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
- Comptage des références dans CPython
- Ramasse-miettes et références cycliques
- Profilage avec cProfile et line_profiler
- Profilage mémoire avec tracemalloc