Avant d'optimiser, trouve la ligne qui coûte vraiment. L'intuition se trompe souvent.
⏱️ Durée : environ 70 minutes · 🎓 Niveau : débutant · 🏅 Badge : Détective de performance
🎬 L'histoire
La génération du rapport mensuel prend 40 secondes. Kodi a une intuition : « C'est sûrement l'accès à la base de données. » Il passe deux jours à l'optimiser. Le gain : 1 seconde.
« Tu as optimisé au hasard, dit Sam. Un profileur t'aurait montré en trente secondes que 35 secondes se passent dans une fonction de mise en forme. »
Tu apprends à utiliser un profileur pour viser juste.
🎯 Ta mission
À la fin, je serai capable de :
- expliquer pourquoi l'intuition se trompe sur les lenteurs
- utiliser
cProfilepour classer les fonctions par temps - lire un rapport de profilage (appels, temps cumulé, temps propre)
- identifier le goulot d'étranglement
- appliquer la règle d'Amdahl de façon intuitive
🧩 Défi d'échauffement (5 XP)
Un trajet de 60 minutes se découpe ainsi : 5 min à pied, 10 min de métro, 40 min de bus, 5 min d'attente. Si tu fais deux fois plus vite le métro, de combien de minutes gagnes-tu ? Et si tu fais deux fois plus vite le bus ? Quelle partie faut-il améliorer en priorité ?
💡 Le concept
Le principe
Un profileur observe un programme pendant qu'il s'exécute et mesure combien de temps chaque fonction consomme.
cProfile en Python
import cProfile, pstats, io
def travail():
return sum(i * i for i in range(200000))
profil = cProfile.Profile()
profil.enable()
travail()
profil.disable()
sortie = io.StringIO()
pstats.Stats(profil, stream=sortie).sort_stats("cumulative").print_stats(5)
print(sortie.getvalue()[:600])
Lire le rapport
| Colonne | Signification |
|---|---|
ncalls | nombre d'appels |
tottime | temps passé dans la fonction elle-même (sans ses sous-appels) |
cumtime | temps total y compris les sous-appels |
percall | temps moyen par appel |
- Une fonction avec un grand
tottimeest un goulot : son code lui-même est lent. - Une fonction avec un grand
cumtimemais un petittottimedélègue : il faut descendre dans ses sous-appels.
La loi d'Amdahl (version intuitive)
Si une partie représente une fraction p du temps et que tu la rends s fois plus rapide, le gain global est limité :
temps après = (1 − p) + p / s
| Partie optimisée | Part du temps (p) | Accélération (s) | Temps total après |
|---|---|---|---|
| Métro | 10/60 ≈ 17 % | 2 | 54 min |
| Bus | 40/60 ≈ 67 % | 2 | 40 min |
Optimise ce qui pèse le plus.
Méthode
- Mesurer (profil) → trouver le goulot.
- Comprendre pourquoi il est lent (complexité, structure).
- Corriger une seule chose.
- Re-mesurer pour vérifier le gain.
- Recommencer tant que le gain compte.
🧠 Astuce : « Premature optimization is the root of all evil » (Donald Knuth). Optimise ce que les mesures désignent, pas ce que tu crois.
🔍 Exemple pas à pas
Problème : un rapport est lent. Qui est coupable ?
import cProfile, pstats, io
def charger(n):
return [(i, f"membre{i}") for i in range(n)]
def formater(lignes):
sortie = ""
for i, nom in lignes:
sortie += f"{i};{nom}\n" # concaténation répétée
return sortie
def statistiques(lignes):
return len(lignes)
def rapport(n):
lignes = charger(n)
texte = formater(lignes)
return statistiques(lignes), len(texte)
p = cProfile.Profile()
p.enable()
rapport(60000)
p.disable()
s = io.StringIO()
pstats.Stats(p, stream=s).sort_stats("tottime").print_stats(4)
print("\n".join(s.getvalue().splitlines()[:12]))
Lecture du résultat : formater pèse le plus lourd en temps propre. Correction (une seule chose) :
def formater_rapide(lignes):
return "".join(f"{i};{nom}\n" for i, nom in lignes)
Re-mesure : on vérifie le gain avec timeit.
import timeit
lignes = [(i, f"membre{i}") for i in range(60000)]
def formater(lignes):
sortie = ""
for i, nom in lignes:
sortie += f"{i};{nom}\n"
return sortie
def formater_rapide(lignes):
return "".join(f"{i};{nom}\n" for i, nom in lignes)
assert formater(lignes) == formater_rapide(lignes)
print(round(min(timeit.repeat(lambda: formater(lignes), number=3, repeat=3)), 4),
round(min(timeit.repeat(lambda: formater_rapide(lignes), number=3, repeat=3)), 4))
✍️ À toi, avec aide (10 XP)
Profile ce code et identifie le goulot :
def est_premier(n):
for d in range(2, n):
if n % d == 0:
return False
return n > 1
def compter_premiers(limite):
return sum(1 for n in range(limite) if est_premier(n))
Utilise cProfile sur compter_premiers(5000). Quelle fonction pèse le plus ? Propose une correction (une seule modification) et mesure le gain.
💡 Indice 1
Active le profileur autour de l'appel.
💡 Indice 2
Trie par tottime.
💡 Indice 3
Il suffit de tester les diviseurs jusqu'à la racine carrée de n.
✅ Réponse
import cProfile, pstats, io, time
def est_premier(n):
for d in range(2, n):
if n % d == 0:
return False
return n > 1
def est_premier_rapide(n):
if n < 2:
return False
d = 2
while d * d <= n:
if n % d == 0:
return False
d += 1
return True
def compter(f, limite):
return sum(1 for n in range(limite) if f(n))
p = cProfile.Profile(); p.enable()
compter(est_premier, 3000)
p.disable()
s = io.StringIO()
pstats.Stats(p, stream=s).sort_stats("tottime").print_stats(3)
print("\n".join(s.getvalue().splitlines()[:10]))
assert compter(est_premier, ) == compter(est_premier_rapide, )
f (est_premier, est_premier_rapide):
t = time.perf_counter(); compter(f, ); (f.__name__, (time.perf_counter() - t, ))
🚀 À toi, en solo (20 XP)
Voici un traitement en trois étapes dont tu ne connais pas la répartition des temps. Écris-le, profile-le, puis optimise uniquement l'étape qui domine. Montre le gain total et vérifie qu'il est cohérent avec la loi d'Amdahl.
def etape_a(n): return [i * 2 for i in range(n)]
def etape_b(liste): return [x for x in liste if x in liste[:200]]
def etape_c(liste): return sorted(liste, reverse=True)
def traitement(n):
a = etape_a(n)
b = etape_b(a)
return etape_c(b)
✅ Pistes de correction
import cProfile, pstats, io, time
def etape_a(n): return [i * 2 for i in range(n)]
def etape_b(liste):
return [x for x in liste if x in liste[:200]] # coûteux : copie + recherche linéaire
def etape_b_rapide(liste):
echantillon = set(liste[:200])
return [x for x in liste if x in echantillon]
def etape_c(liste): return sorted(liste, reverse=True)
def traitement(n, b=etape_b):
return etape_c(b(etape_a(n)))
p = cProfile.Profile(); p.enable()
traitement(5000)
p.disable()
s = io.StringIO()
pstats.Stats(p, stream=s).sort_stats("tottime").print_stats(3)
print("\n".join(s.getvalue().splitlines()[:9]))
traitement() == traitement(, etape_b_rapide)
b (etape_b, etape_b_rapide):
t = time.perf_counter(); traitement(, b); (b.__name__, (time.perf_counter() - t, ))
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Optimiser à l'intuition | Gain faible, temps perdu | Profiler d'abord |
| Profiler sur un trop petit cas | Le goulot réel n'apparaît pas | Profiler avec des données réalistes |
| Changer plusieurs choses à la fois | On ne sait pas ce qui a aidé | Un changement, une mesure |
Confondre tottime et cumtime | On optimise la mauvaise fonction | Lire les deux colonnes |
🐉 Mini-boss (40 XP)
Chasse au goulot. Voici un petit programme lent :
def compter_mots(texte):
mots = texte.split()
resultat = []
for mot in mots:
trouve = False
for entree in resultat:
if entree[0] == mot:
entree[1] += 1
trouve = True
if not trouve:
resultat.append([mot, 1])
return resultat
def top(resultat, k):
return sorted(resultat, key=lambda e: -e[1])[:k]
- Génère un texte de 20 000 mots (vocabulaire de 2 000 mots).
- Profile et nomme le goulot.
- Corrige en une modification, vérifie l'équivalence des résultats.
- Mesure le gain et compare à ce que prévoit Amdahl.
✅ Pistes de correction
import random, time
random.seed(0)
vocab = [f"mot{i}" for i in range(2000)]
texte = " ".join(random.choice(vocab) for _ in range(20000))
def compter_mots(texte):
resultat = []
for mot in texte.split():
trouve = False
for entree in resultat:
if entree[0] == mot:
entree[1] += 1
trouve = True
if not trouve:
resultat.append([mot, 1])
return resultat
def compter_mots_rapide(texte):
c = {}
for mot in texte.split():
c[mot] = c.get(mot, 0) + 1
return [[m, n] for m, n in c.items()]
a, b = compter_mots(texte), compter_mots_rapide(texte)
assert sorted(map(tuple, a)) == sorted((, b))
f (compter_mots, compter_mots_rapide):
t = time.perf_counter(); f(texte); (f.__name__, (time.perf_counter() - t, ))
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un profileur sert à :
- A. corriger automatiquement le code
- B. trouver où le temps est passé
- C. réduire la taille du fichier
2. tottime désigne :
- A. le temps total avec sous-appels
- B. le nombre d'appels
- C. le temps passé dans la fonction elle-même
3. Selon Amdahl, il faut optimiser en priorité :
- A. ce qui pèse le plus dans le temps total
- B. ce qui est le plus facile
- C. ce qui est le plus ancien
4. 🔁 Révision mission 08 : Si T(2n)/T(n) ≈ 4, la croissance est :
- A. linéaire
- B. quadratique
- C. constante
5. 🔁 Révision mission 07 : Un générateur permet de :
- A. trier plus vite
- B. accéder par indice
- C. produire des valeurs une à une sans tout stocker
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Quelle optimisation « à l'intuition » as-tu déjà faite ? Qu'a-t-elle donné ?
- Pourquoi le profilage évite-t-il des discussions sans fin dans une équipe ?
🎒 À retenir
- Profiler avant d'optimiser.
tottimepointe le goulot,cumtimeaide à descendre.- Amdahl : le gain global dépend de la part optimisée.
- Un changement, une mesure.
- Vérifier que le résultat reste identique.
flowchart LR
T(["Profilage : trouver où le temps passe"])
T --> R1["1. Profiler avant d'optimiser."]
T --> R2["2. tottime pointe le goulot, cumtime aide à descendre."]
T --> R3["3. Amdahl : le gain global dépend de la part optimisée."]
T --> R4["4. Un changement, une mesure."]
T --> R5["5. Vérifier que le résultat reste identique."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Détective de performance
← Mission 08 — Mesurer pour de vrai · Mission 10 — Optimiser avec preuves →
HEF-030 — Complexité

