Mon projet portfolio — 4 mois pour concevoir, tester, publier et présenter un vrai projet Python

Les compréhensions

Une compréhension construit une nouvelle collection à partir d'une séquence, en une seule expression. C'est exactement la boucle for + append du Pro (Pro, épisode 6), écrite autrement.

La boucle que tu sais écrire :

brut = ["8,0", "14,5", "22,0", "n.m.", "40,0"]
tailles = []
for texte in brut:
    if texte != "n.m.":
        tailles.append(float(texte.replace(",", ".")))
print(tailles)

La même, en compréhension :

brut = ["8,0", "14,5", "22,0", "n.m.", "40,0"]
tailles = [float(texte.replace(",", ".")) for texte in brut if texte != "n.m."]
print(tailles)

Les deux affichent [8.0, 14.5, 22.0, 40.0]. Lis la compréhension dans cet ordre : pour chaque texte dans brut, si texte != "n.m.", garde float(texte.replace(",", ".")). Les morceaux sont ceux de la boucle, dans le même ordre, sauf l'expression gardée, qui passe devant.

Les trois formes.

releves = [(1, 8.0), (2, 14.5), (3, 22.0), (4, 31.5)]
carres = [semaine ** 2 for semaine, hauteur in releves]
par_semaine = {semaine: hauteur for semaine, hauteur in releves}
dates = ["2026-03-30", "2026-04-06", "2026-04-13", "2026-05-04"]
mois = {date[:7] for date in dates}
print(carres)
print(par_semaine)
print(sorted(mois))
print([h for s, h in releves if h > 20])

Affiche :

Le déballage des tuples (for semaine, hauteur in releves) fonctionne comme dans une boucle.

Deux pièges.

• Si l'expression gardée est un tuple, il faut des parenthèses : [semaine, hauteur * 10 for semaine, hauteur in releves] s'arrête sur SyntaxError: did you forget parentheses around the comprehension target? (« as-tu oublié les parenthèses autour de la cible de la compréhension ? ») ; on écrit [(semaine, hauteur * 10) for …].
• Une compréhension sert à construire une collection, pas à faire quelque chose. [print(t) for t in tailles] affiche bien les valeurs… et construit pour rien la liste [None, None, None] (ce que renvoie print). Pour afficher, écrire, modifier : une boucle.

Quand garder la boucle. Dès qu'il y a un affichage, une écriture dans un fichier, plusieurs étapes, ou une compréhension dans une compréhension : la boucle est plus lisible (Pro, épisode 9). Une compréhension se relit en une phrase ; si la phrase est trop longue, c'est le signe.

« Une transformation, un filtre, une ligne »

1. Décrire en français ce que tu construis : « la liste des hauteurs valides de la parcelle A ».
2. Compréhension si tu transformes et/ou filtres une séquence pour obtenir une nouvelle collection, et que la phrase tient en une ligne.
3. Boucle dès qu'il y a un affichage, une écriture, un compteur, plusieurs étapes, ou une compréhension dans une autre.
4. Vérifier que le résultat est le même qu'avec la boucle, sur un cas connu.

Le cahier du jardin (mesures-jardin.csv, fourni avec le livre, données inventées) commence ainsi :

import csv
from pathlib import Path

DOSSIER = Path(__file__).parent
with open(DOSSIER / "mesures-jardin.csv", encoding="utf-8") as fichier:
    lignes = list(csv.DictReader(fichier, delimiter=";"))

valides = [ligne for ligne in lignes if ligne["hauteur_mm"] not in ("", "n.m.")]
print(len(lignes), "lignes,", len(valides), "valides")

hauteurs_a = {int(l["semaine"]): float(l["hauteur_mm"].replace(",", "."))
              for l in valides if l["parcelle"] == "A"}
print(hauteurs_a)

semaines_mesurees = {int(l["semaine"]) for l in valides if l["parcelle"] == "B"}
manquantes = set(range(1, 13)) - semaines_mesurees
print("Semaines sans mesure pour B :", sorted(manquantes))

print("Cases à vérifier :")
for ligne in lignes:
    if ligne["hauteur_mm"] in ("", "n.m."):
        print(f"  semaine {ligne['semaine']}, parcelle {ligne['parcelle']} : {ligne['hauteur_mm']!r}")

Sortie réelle :

Trois compréhensions (filtrer, construire un dictionnaire, construire un ensemble), et une boucle pour l'affichage. set(range(1, 13)) - semaines_mesurees est la différence de deux ensembles : les éléments du premier qui ne sont pas dans le second. !r dans une f-string affiche la valeur avec ses guillemets : une case vide se voit (''). La lecture du CSV reprend le Pro (Pro, épisode 13).

Une compréhension dit ce que l'on construit ; une boucle dit ce que l'on fait. Les séparer rend chaque ligne lisible d'un coup d'œil : quand Awa lit valides = [… if …], elle sait qu'aucune donnée n'est modifiée, aucun fichier écrit. Et la vérification sur un cas connu garantit que la réécriture n'a rien changé au résultat.

Bon réflexe ou piège ?

Chercher et trier

1. La recherche séquentielle. On regarde chaque élément, dans l'ordre, et on s'arrête dès qu'on trouve.

from datetime import date, timedelta


def chercher(liste, cible):
    """Renvoie la position de cible dans liste, ou None si elle n'y est pas."""
    for position in range(len(liste)):
        if liste[position] == cible:
            return position
    return None


debut = date(2021, 6, 16)
dates = [debut + timedelta(days=k) for k in range(1826)]
print(len(dates), dates[0], dates[-1])
print(chercher(dates, date(2026, 4, 20)))
print(chercher(dates, date(2030, 1, 1)))

Affiche 1826 2021-06-16 2026-06-15, puis 1769, puis None. timedelta(days=k) est une durée de k jours ; ajoutée à une date, elle donne une autre date (le module datetime, Pro, épisode 11). La liste des dates est une compréhension (épisode 1). Pour trouver le 20 avril 2026, la boucle a fait 1 770 comparaisons ; pour une date absente, 1 826.

2. Trier : le tri par insertion, à la main. Comme des cartes qu'on range une à une : on prend l'élément suivant et on le fait glisser vers la gauche jusqu'à sa place.

def tri_insertion(liste):
    """Renvoie une copie triée de liste (tri par insertion)."""
    valeurs = list(liste)
    for i in range(1, len(valeurs)):
        courant = valeurs[i]
        j = i - 1
        while j >= 0 and valeurs[j] > courant:
            valeurs[j + 1] = valeurs[j]
            j = j - 1
        valeurs[j + 1] = courant
        print(f"après le tour {i} : {valeurs}")
    return valeurs


print(tri_insertion([31.5, 8.0, 22.0, 14.5, 40.0]))

Affiche :

Au tour 4, 40.0 est déjà à sa place : la boucle while ne fait rien. Sur une liste presque triée, le tri par insertion travaille donc très peu.

3. Trier avec Python : sorted et la clé. Dans ton code, tu utiliseras sorted (Pro, épisode 6). Le paramètre key reçoit une fonction appliquée à chaque élément : on trie selon ce qu'elle renvoie.

releves = [("2026-04-06", "A", 14.5), ("2026-04-06", "B", 12.0),
           ("2026-03-30", "A", 8.0), ("2026-03-30", "B", 7.5)]


def hauteur(releve):
    """Renvoie la hauteur d'un relevé (date, parcelle, hauteur)."""
    return releve[2]


print(sorted(releves))
print(sorted(releves, key=hauteur, reverse=True))
par_parcelle = sorted(releves, key=lambda releve: releve[1])
print(par_parcelle)

Affiche :

• Sans clé, les tuples se comparent élément par élément : d'abord la date (des textes au format AAAA-MM-JJ se trient comme des dates), puis la parcelle.
• key=hauteur trie selon la hauteur ; reverse=True, de la plus grande à la plus petite.
• lambda releve: releve[1] est une fonction anonyme d'une ligne : elle fait la même chose qu'un def qui renvoie releve[1]. Utile pour une clé courte ; dès que c'est plus long, un def avec un nom et une docstring.
• Le tri est stable : dans la troisième ligne, les deux relevés de A gardent leur ordre de départ (le 6 avril, puis le 30 mars).

4. La recherche dichotomique. Dans une liste triée, on regarde l'élément du milieu : s'il est trop petit, la cible ne peut être qu'à droite ; trop grand, à gauche. À chaque tour, on élimine la moitié de ce qui reste.

from bisect import bisect_left
from datetime import date, timedelta


def chercher_dicho(liste_triee, cible):
    """Renvoie la position de cible dans une liste TRIÉE, ou None (recherche dichotomique)."""
    gauche, droite = 0, len(liste_triee) - 1
    while gauche <= droite:
        milieu = (gauche + droite) // 2
        if liste_triee[milieu] == cible:
            return milieu
        elif liste_triee[milieu] < cible:
            gauche = milieu + 1
        else:
            droite = milieu - 1
    return None


debut = date(2021, 6, 16)
dates = [debut + timedelta(days=k) for k in range(1826)]
print(chercher_dicho(dates, date(2026, 4, 20)))
print(chercher_dicho(dates, date(2030, 1, 1)))
i = bisect_left(dates, date(2026, 4, 20))
print(i, dates[i])
print(chercher_dicho([5, 1, 4, 2, 3], 2))

Affiche 1769, None, 1769 2026-04-20, puis None.

• L'invariant : si la cible est dans la liste, elle est entre gauche et droite (inclus). La terminaison : à chaque tour, l'écart droite - gauche diminue ; quand il devient négatif, la boucle s'arrête.
• Le module bisect de la bibliothèque standard fait la dichotomie pour toi : bisect_left(liste, x) renvoie la position où insérer x pour garder la liste triée ; si x est présent, c'est sa position.
• La liste doit être triée. Dans [5, 1, 4, 2, 3], le 2 est bien là, mais la dichotomie part du mauvais côté et répond None, sans aucun message d'erreur.

« Instrumenter avant de croire »

1. Choisir ce qu'on compte : le nombre de comparaisons (ou de tours de boucle), qui ne dépend pas de la vitesse de l'ordinateur.
2. Ajouter un compteur dans une copie de la fonction, et le renvoyer avec le résultat (un tuple, Pro, épisode 8).
3. Mesurer sur plusieurs tailles (10, 100, 1 826) et plusieurs cas : le meilleur, le pire, l'absent.
4. Conclure à partir du tableau, pas d'une impression.

from datetime import date, timedelta


def chercher_compte(liste, cible):
    """Recherche séquentielle ; renvoie (position ou None, nombre de comparaisons)."""
    comparaisons = 0
    for position in range(len(liste)):
        comparaisons = comparaisons + 1
        if liste[position] == cible:
            return position, comparaisons
    return None, comparaisons


def chercher_dicho_compte(liste_triee, cible):
    """Recherche dichotomique ; renvoie (position ou None, nombre de tours de boucle)."""
    gauche, droite = 0, len(liste_triee) - 1
    tours = 0
    while gauche <= droite:
        tours = tours + 1
        milieu = (gauche + droite) // 2
        if liste_triee[milieu] == cible:
            return milieu, tours
        elif liste_triee[milieu] < cible:
            gauche = milieu + 1
        else:
            droite = milieu - 1
    return None, tours


debut = date(2021, 6, 16)
for n in (10, 100, 1826):
    dates = [debut + timedelta(days=k) for k in range(n)]
    for nom, cible in (("première", dates[0]), ("dernière", dates[-1]), ("absente", date(2030, 1, 1))):
        _, seq = chercher_compte(dates, cible)
        _, dic = chercher_dicho_compte(dates, cible)
        print(f"n={n:>4}  {nom:<9} séquentielle : {seq:>4}   dichotomie : {dic:>2}")

Sortie réelle :

_ est un nom de variable conventionnel pour une valeur qu'on n'utilise pas (ici la position). Le tableau dit tout : quand n est multiplié par 10, la recherche séquentielle fait 10 fois plus de comparaisons dans le pire cas ; la dichotomie, environ 3 tours de plus. Et pour la toute première date, la recherche séquentielle gagne (1 contre 10) : la dichotomie n'est pas meilleure dans tous les cas, elle l'est dans le pire cas et sur de grandes listes.

Compter les comparaisons plutôt que les secondes donne un résultat qui ne dépend ni de l'ordinateur, ni des autres programmes ouverts : le même chez toi, chez Awa et chez le recruteur. Mesurer plusieurs tailles montre comment le travail grandit avec les données, ce qui compte bien plus que le temps sur un seul exemple. Tu viens de mesurer ce que l'épisode 7 appellera la complexité.

Bon réflexe ou piège ?

La récursivité

Une fonction récursive est une fonction qui s'appelle elle-même, sur un problème plus petit. Elle a toujours deux parties :

• le cas de base : un problème si petit qu'on connaît la réponse directement ;
• le cas récursif : on réduit le problème, on s'appelle sur la partie réduite, et on combine.

La somme d'une liste. La somme de [3, 5, 2], c'est 3 + la somme de [5, 2]. Et la somme d'une liste vide, c'est 0.

def somme(liste):
    """Renvoie la somme des éléments de liste (version récursive)."""
    if len(liste) == 0:
        return 0
    return liste[0] + somme(liste[1:])


def maximum(liste):
    """Renvoie le plus grand élément d'une liste non vide (version récursive)."""
    if len(liste) == 1:
        return liste[0]
    reste = maximum(liste[1:])
    if liste[0] > reste:
        return liste[0]
    return reste


print(somme([3, 5, 2]))
print(somme([]))
print(maximum([31.5, 8.0, 74.5, 22.0]))

Affiche 10, 0, puis 74.5. liste[1:] est une tranche : tout sauf le premier élément (Pro, épisode 3).

La pile d'appels. Chaque appel a ses propres variables locales (Pro, épisode 1) et attend le résultat de l'appel suivant. Une version bavarde le montre :

def somme(liste, profondeur=0):
    """Version bavarde de somme : affiche chaque appel et chaque retour."""
    marge = "    " * profondeur
    print(f"{marge}somme({liste})")
    if len(liste) == 0:
        print(f"{marge}→ renvoie 0 (cas de base)")
        return 0
    resultat = liste[0] + somme(liste[1:], profondeur + 1)
    print(f"{marge}→ renvoie {resultat}")
    return resultat


somme([3, 5, 2])

Affiche :

Les appels s'empilent (vers la droite), jusqu'au cas de base ; puis ils se dépilent, chacun ajoutant son élément au résultat reçu : 0, puis 2, puis 7, puis 10. Le dernier appel commencé est le premier terminé.

La dichotomie, en récursif. Chercher dans une moitié, c'est le même problème en plus petit (épisode 3) :

def chercher_rec(liste_triee, cible, gauche, droite):
    """Recherche dichotomique récursive entre les positions gauche et droite (incluses)."""
    if gauche > droite:
        return None
    milieu = (gauche + droite) // 2
    if liste_triee[milieu] == cible:
        return milieu
    if liste_triee[milieu] < cible:
        return chercher_rec(liste_triee, cible, milieu + 1, droite)
    return chercher_rec(liste_triee, cible, gauche, milieu - 1)


semaines = [1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12]
print(chercher_rec(semaines, 9, 0, len(semaines) - 1))
print(chercher_rec(semaines, 7, 0, len(semaines) - 1))

Affiche 7 (la semaine 9 est à la position 7), puis None (la semaine 7 manque). Deux cas de base : la zone est vide (gauche > droite), ou la cible est au milieu.

La limite. Python limite le nombre d'appels empilés :

import sys


def somme(liste):
    """Renvoie la somme des éléments de liste (version récursive)."""
    if len(liste) == 0:
        return 0
    return liste[0] + somme(liste[1:])


print(sys.getrecursionlimit())
print(somme(list(range(900))))
print(somme(list(range(2000))))

Affiche 1000, puis 404550, puis s'arrête :

RecursionError : « profondeur maximale de récursion dépassée ». La limite par défaut vaut 1 000 appels (sortie réelle sous Python 3.12 et 3.15). Python la lit en 3 lignes, puis résume : « la ligne précédente s'est répétée 996 fois de plus ».

L'oubli du cas de base donne la même erreur :

def compte_a_rebours(n):
    print(n)
    compte_a_rebours(n - 1)


compte_a_rebours(3)

Affiche 3, 2, 1, 0, -1… et ainsi de suite près de mille fois, puis RecursionError. Il manquait if n == 0: return.

Quand préférer une boucle ? Pour parcourir une liste, la boucle est plus simple et n'a pas de limite. La récursivité brille quand le problème est imbriqué : des dossiers dans des dossiers, des données dans des données. C'est le cas du jardin (épisode 6).

« D'abord le cas de base, puis un niveau, puis la confiance »

1. Le cas de base : un fichier. S'il finit par .csv, il compte pour 1 ; sinon, 0.
2. Le cas récursif : un dossier. On additionne ce que donne la fonction sur chacun de ses éléments.
3. Tester sur un seul niveau (un dossier qui ne contient que des fichiers), puis sur toute l'arborescence.
4. Faire confiance à l'appel récursif : si la fonction marche pour un dossier plus petit, elle marche pour le grand.

Créer l'arborescence d'exemple (sur ton ordinateur, dans un dossier d'entraînement) :

"""Crée l'arborescence d'exemple du jardin dans le dossier jardin-exemple (à côté de ce script)."""
from pathlib import Path

RACINE = Path(__file__).parent / "jardin-exemple"
for annee in ("2025", "2026"):
    for parcelle in ("A", "B"):
        dossier = RACINE / annee / parcelle
        dossier.mkdir(parents=True, exist_ok=True)
        for mois in ("04", "05", "06"):
            (dossier / f"{annee}-{mois}.csv").write_text("semaine;hauteur_mm\n", encoding="utf-8")
(RACINE / "2026" / "A" / "photos").mkdir(exist_ok=True)
(RACINE / "2026" / "A" / "photos" / "radis.jpg").write_text("", encoding="utf-8")
(RACINE / "LISEZMOI.txt").write_text("Cahier du jardin partagé\n", encoding="utf-8")
print("Arborescence créée :", RACINE.name)

Affiche Arborescence créée : jardin-exemple. mkdir(parents=True, exist_ok=True) crée aussi les dossiers parents manquants, sans erreur s'ils existent déjà ; write_text crée un petit fichier.

Compter les fichiers .csv :

from pathlib import Path


def compter_csv(dossier):
    """Renvoie le nombre de fichiers .csv dans dossier et tous ses sous-dossiers."""
    total = 0
    for chemin in dossier.iterdir():
        if chemin.is_dir():
            total = total + compter_csv(chemin)
        elif chemin.suffix == ".csv":
            total = total + 1
    return total


RACINE = Path(__file__).parent / "jardin-exemple"
print(compter_csv(RACINE / "2026" / "B"))
print(compter_csv(RACINE))
print(len(list(RACINE.rglob("*.csv"))))

Sortie réelle :

• is_dir() dit si un chemin est un dossier ; suffix donne l'extension (".csv", ".jpg") ; iterdir() parcourt le contenu d'un dossier (Pro, épisode 17).
• Le premier appel teste un seul niveau (2026/B : 3 fichiers) ; le second, toute l'arborescence : 2 années × 2 parcelles × 3 mois = 12. La photo et le LISEZMOI.txt ne comptent pas.
• Ici, le cas de base est caché dans la boucle : un dossier vide, ou qui ne contient que des fichiers, ne provoque aucun appel récursif.
• rglob("*.csv") (recursive glob) fait le même parcours pour toi : il renvoie tous les chemins qui correspondent au motif, dans tous les sous-dossiers. Dans ton projet, tu l'utiliseras ; écrire compter_csv t'apprend ce qu'il fait.

La récursivité épouse la forme du problème : un dossier contient des fichiers et des dossiers, qui contiennent des fichiers et des dossiers… Peu importe le nombre de niveaux, la même fonction s'applique à chaque niveau. Tester d'abord un seul niveau vérifie le cas de base et l'addition ; la confiance dans l'appel récursif fait le reste. Comparer avec rglob, un outil de la bibliothèque standard, donne un cas connu pour vérifier.

Bon réflexe ou piège ?

La complexité

La complexité d'un algorithme décrit comment le nombre d'opérations grandit quand la taille n des données grandit. On la note avec un O (« grand O ») : on garde l'ordre de grandeur et on oublie les détails.

Deux façons de trouver les doublons.

def doublons_liste(valeurs):
    """Renvoie (doublons, comparaisons) en comparant chaque valeur à toutes les suivantes."""
    trouves = set()
    comparaisons = 0
    for i in range(len(valeurs)):
        for j in range(i + 1, len(valeurs)):
            comparaisons = comparaisons + 1
            if valeurs[i] == valeurs[j]:
                trouves.add(valeurs[i])
    return trouves, comparaisons


def doublons_ensemble(valeurs):
    """Renvoie (doublons, tests) avec un ensemble des valeurs déjà vues."""
    vues = set()
    trouves = set()
    tests = 0
    for valeur in valeurs:
        tests = tests + 1
        if valeur in vues:
            trouves.add(valeur)
        vues.add(valeur)
    return trouves, tests


releves = ["2026-04-06", "2026-04-13", "2026-04-06", "2026-04-20", "2026-04-13"]
trouves, comparaisons = doublons_liste(releves)
print(sorted(trouves), comparaisons)
trouves, tests = doublons_ensemble(releves)
print(sorted(trouves), tests)
for n in (1_000, 2_000, 4_000):
    valeurs = list(range(n))
    print(f"n={n:>5}  double boucle : {doublons_liste(valeurs)[1]:>9} comparaisons   ensemble : {doublons_ensemble(valeurs)[1]:>5} tests")

Sortie réelle :

Les deux trouvent les mêmes doublons. Mais quand n double, la double boucle fait 4 fois plus de comparaisons : n(n − 1)/2, de l'ordre de n², noté O(n²) ; la version avec ensemble fait 2 fois plus de tests : O(n). Pourquoi l'ensemble est-il si efficace ? Parce que valeur in vues sur un ensemble coûte en moyenne O(1) : un temps qui ne dépend pas de sa taille ; sur une liste, in parcourt tout : O(n) (Pro, épisode 8). 1_000 s'écrit aussi 1000 : le _ sert seulement à lire les grands nombres.

Les ordres de grandeur à connaître.

import math

print(f"{'n':>7} {'log2 n':>7} {'n':>9} {'n log2 n':>12} {'n²':>16}")
for n in (10, 100, 1_000, 1_826, 100_000):
    print(f"{n:>7} {math.log2(n):>7.1f} {n:>9} {n * math.log2(n):>12.0f} {n * n:>16}")

Affiche :

Pour 100 000 éléments, un algorithme en n² fait dix milliards d'opérations ; en n log n, moins de deux millions.

Mesurer, pour vérifier. Le temps dépend de la machine, mais sa croissance suit la complexité. time.perf_counter() donne un instant précis ; la différence entre deux instants, une durée :

import time


def doublons_liste(valeurs):
    """Renvoie l'ensemble des valeurs présentes plusieurs fois (double boucle)."""
    trouves = set()
    for i in range(len(valeurs)):
        for j in range(i + 1, len(valeurs)):
            if valeurs[i] == valeurs[j]:
                trouves.add(valeurs[i])
    return trouves


def doublons_ensemble(valeurs):
    """Renvoie l'ensemble des valeurs présentes plusieurs fois (ensemble des valeurs vues)."""
    vues, trouves = set(), set()
    for valeur in valeurs:
        if valeur in vues:
            trouves.add(valeur)
        vues.add(valeur)
    return trouves


for n in (1_000, 2_000, 4_000):
    valeurs = list(range(n))
    debut = time.perf_counter()
    doublons_liste(valeurs)
    t_liste = time.perf_counter() - debut
    debut = time.perf_counter()
    doublons_ensemble(valeurs)
    t_ens = time.perf_counter() - debut
    print(f"n={n:>5}  double boucle : {t_liste:.3f} s   ensemble : {t_ens:.5f} s")

Une sortie réelle (sur l'ordinateur de test, sous Python 3.15) :

Chez toi, les chiffres seront différents ; mais la double boucle prendra toujours environ 4 fois plus de temps quand n double. Pour comparer deux petits morceaux de code, le module timeit répète la mesure et garde le meilleur temps : min(timeit.repeat("99_999 in valeurs_liste", globals=globals(), number=1_000, repeat=5)). Sur l'ordinateur de test, tester 99_999 in … 1 000 fois a pris environ 0,5 à 0,7 s avec une liste de 100 000 éléments, et quelques cent-millièmes de seconde avec un ensemble.

« Quel algorithme, quelle structure ? »

🎨 Carrousel récapitulatif — Arc 1

Les exceptions

Une exception est un signal que Python lève quand une instruction ne peut pas s'exécuter : ValueError, KeyError, FileNotFoundError… Si personne ne l'intercepte, le programme s'arrête et affiche la trace (que tu sais lire, Boost, épisode 2).

Sans protection :

textes = ["8,0", "14,5", "n.m.", "31,5"]
for texte in textes:
    print(float(texte.replace(",", ".")))

try, except, else, finally.

def essayer(texte):
    """Montre quels blocs s'exécutent selon la hauteur lue."""
    try:
        hauteur = float(texte.replace(",", "."))
    except ValueError:
        print(f"{texte!r} : illisible")
    else:
        print(f"{texte!r} : {hauteur} mm")
    finally:
        print("   (ligne traitée)")


for texte in ["12.5", "12,5", "", "n.m."]:
    essayer(texte)

• try : le code qui peut échouer, et seulement lui.
• except ValueError : ce qu'on fait si cette exception survient ; les autres continuent leur chemin.
• else : ce qui ne s'exécute que si try a réussi. On y met la suite, plutôt que dans try, pour ne pas intercepter par erreur une exception levée par cette suite.
• finally : ce qui s'exécute dans tous les cas (libérer une ressource, écrire une trace). Pour un fichier, with le fait déjà (Pro, épisode 13).

Lever une exception claire : raise. Une fonction qui reçoit une valeur impossible ne doit pas renvoyer n'importe quoi : elle lève une exception avec un message utile.

VALEURS_ABSENTES = ("", "n.m.")


def lire_taille(texte):
    """Convertit une hauteur écrite « 12,5 » ou « 12.5 » en nombre ; lève ValueError sinon."""
    texte = texte.strip()
    if texte in VALEURS_ABSENTES:
        raise ValueError(f"hauteur absente : {texte!r}")
    try:
        return float(texte.replace(",", "."))
    except ValueError:
        raise ValueError(f"hauteur illisible : {texte!r}") from None


for texte in ["12,5", " 40.0 ", "n.m.", "douze"]:
    try:
        print(lire_taille(texte))
    except ValueError as erreur:
        print("Écartée :", erreur)
print(lire_taille("n.m."))

• raise ValueError("…") lève l'exception avec son message ; except ValueError as erreur récupère l'objet, dont le texte est le message.
• raise … from None remplace l'exception d'origine (le message anglais de float) par la nôtre, sans afficher les deux.
• La fonction lève ; c'est l'appelant qui décide quoi faire : ici, écarter la ligne et le dire. La dernière ligne, sans try, montre que l'erreur reste visible si personne ne la traite.

Le piège : intercepter trop large.

def lire(texte):
    try:
        return flaot(texte.replace(",", "."))
    except:
        return 0.0


print(lire("12,5"))
print(lire("40,0"))

Tout renvoie 0 : flaot est une faute de frappe (NameError), mais le except: nu intercepte tout, y compris cette erreur de programmation. Le bug devient silencieux, et le jardin ne pousse plus. On intercepte toujours une exception précise (except ValueError:), là où l'on sait quoi en faire.

Le cas laissé en suspens au Pro. L'écart type d'échantillon demande au moins deux valeurs (Pro, épisode 11) :

import statistics

print(round(statistics.stdev([12.0, 14.5, 17.0]), 2))
try:
    print(statistics.stdev([12.0]))
except statistics.StatisticsError as erreur:
    print("Impossible :", erreur)
print(statistics.stdev([12.0]))

Affiche 2.5, puis Impossible : stdev requires at least two data points (« l'écart type demande au moins deux valeurs »), puis, sans try, s'arrête sur :

statistics.StatisticsError est une exception propre au module statistics : on l'intercepte par son nom complet.

Vérifier avant, ou essayer puis intercepter ? Pour un fichier, tu as appris à vérifier avant (chemin.exists(), Pro, épisode 13). Pour une conversion, essayer puis intercepter est plus simple : il y a trop de façons d'écrire un nombre faux pour toutes les tester avant.

« Attraper au plus près, signaler toujours »

1. La fonction qui sait convertir lève (lire_taille, épisode 9) : elle ne sait pas ce qu'il faut faire d'une case vide.
2. La fonction qui parcourt le fichier attrape, ligne par ligne : elle sait qu'il faut écarter la ligne et continuer.
3. Chaque ligne écartée est signalée : son numéro dans le fichier et la raison.
4. On vérifie sur un petit fichier construit pour l'occasion (une ligne valide, une invalide).

lecture.py, premier module de « Pousse » :

"""Lecture du cahier du jardin : conversion des hauteurs et rapport des lignes écartées."""

import csv
from pathlib import Path

from modele import Mesure

VALEURS_ABSENTES = ("", "n.m.")


def lire_taille(texte: str) -> float:
    """Convertit une hauteur écrite « 12,5 » ou « 12.5 » en nombre ; lève ValueError sinon."""
    texte = texte.strip()
    if texte in VALEURS_ABSENTES:
        raise ValueError(f"hauteur absente : {texte!r}")
    try:
        return float(texte.replace(",", "."))
    except ValueError:
        raise ValueError(f"hauteur illisible : {texte!r}") from None


def lire_cahier(chemin: Path) -> tuple[list[Mesure], list[str]]:
    """Lit le cahier ; renvoie (mesures valides, rapport des lignes écartées)."""
    mesures: list[Mesure] = []
    rapport: list[str] = []
    with open(chemin, encoding="utf-8") as fichier:
        for numero, ligne in enumerate(csv.DictReader(fichier, delimiter=";"), start=2):
            try:
                hauteur = lire_taille(ligne["hauteur_mm"])
                mesure = Mesure(int(ligne["semaine"]), ligne["date"], ligne["parcelle"], hauteur)
            except ValueError as erreur:
                rapport.append(f"ligne {numero} : {erreur}")
            else:
                mesures.append(mesure)
    return mesures, rapport

• Mesure vient du module modele (épisode 11) : pour l'instant, retiens qu'elle range les quatre champs d'une ligne.
• enumerate(…, start=2) numérote les éléments d'une séquence : à chaque tour, il donne le couple (numéro, élément). On commence à 2, car la ligne 1 du fichier est l'en-tête.
• int(ligne["semaine"]) peut aussi lever une ValueError (une semaine « 7b ») : elle est interceptée par le même except.
• Les écritures texte: str, -> float ou mesures: list[Mesure] sont des annotations de type : elles disent ce qu'on attend, sans rien changer à l'exécution. Elles sont expliquées à l'épisode 15 ; pour l'instant, lis-les comme des commentaires.

Avec le programme rapport.py (épisode 16), sur le cahier du jardin :

Les lignes 14 et 17 du fichier sont bien les cases « n.m. » de la parcelle A (semaine 7) et vide de la parcelle B (semaine 8), repérées à l'épisode 2.

Chaque fonction fait ce qu'elle sait faire : lire_taille connaît les formats d'un nombre, lire_cahier connaît la structure du fichier. L'exception transporte l'information de l'une à l'autre, message compris. Le rapport rend l'écart visible : le jour où une ligne disparaît de l'analyse, on sait laquelle et pourquoi. C'est ce que demandera un encadrant de laboratoire : « Combien de mesures avez-vous exclues, et pourquoi ? »

Bon réflexe ou piège ?

Classes et objets

Une classe est un modèle ; un objet (ou instance) est un exemplaire construit sur ce modèle. Chaque objet a ses attributs (ses données) et partage les méthodes (les fonctions) de sa classe.

Une classe à la main.

class Mesure:
    """Une mesure du cahier du jardin."""

    def __init__(self, semaine, date, parcelle, hauteur):
        self.semaine = semaine
        self.date = date
        self.parcelle = parcelle
        self.hauteur = hauteur


m = Mesure(1, "2026-03-30", "A", 8.0)
print(m.parcelle, m.hauteur)
m.hauteur = 8.5
print(m.hauteur)
print(m)

• class Mesure: définit la classe (nom en CamelCase, PEP 8, Pro, épisode 9).
• __init__ est appelée à la création de chaque objet ; self désigne l'objet en train d'être construit (le nom self est une convention, très fortement suivie).
• m.hauteur lit un attribut ; m.hauteur = 8.5 le modifie.
• L'affichage par défaut est inutile : <__main__.Mesure object at 0x…> (l'adresse change à chaque exécution).

Une classe de données : @dataclass. Pour une classe qui sert surtout à ranger des données, le module dataclasses écrit __init__, l'affichage et la comparaison à ta place :

from dataclasses import dataclass


@dataclass
class Mesure:
    """Une mesure du cahier : semaine, date (AAAA-MM-JJ), parcelle, hauteur en mm."""

    semaine: int
    date: str
    parcelle: str
    hauteur: float


m = Mesure(1, "2026-03-30", "A", 8.0)
print(m)
print(m == Mesure(1, "2026-03-30", "A", 8.0))
print(Mesure(1, "2026-03-30", "A", "huit"))

• semaine: int déclare un champ : son nom et le type attendu.
• print(m) affiche enfin les champs ; == compare champ par champ.
• La dernière ligne montre que Python ne vérifie pas les types : "huit" est accepté sans broncher. L'épisode 15 donnera un outil pour l'attraper.

Des méthodes : une parcelle qui gère ses mesures.

from dataclasses import dataclass


@dataclass
class Mesure:
    """Une mesure du cahier : semaine, date (AAAA-MM-JJ), parcelle, hauteur en mm."""

    semaine: int
    date: str
    parcelle: str
    hauteur: float


class Parcelle:
    """Une parcelle du jardin et ses mesures."""

    def __init__(self, nom, paillee):
        self.nom = nom
        self.paillee = paillee
        self.mesures = []

    def __repr__(self):
        return f"Parcelle({self.nom!r}, paillee={self.paillee}, mesures={len(self.mesures)})"

    def ajouter(self, mesure):
        """Ajoute une mesure de cette parcelle ; lève ValueError si elle vient d'une autre parcelle."""
        if mesure.parcelle != self.nom:
            raise ValueError(f"mesure de la parcelle {mesure.parcelle!r} ajoutée à {self.nom!r}")
        self.mesures.append(mesure)

    def hauteur_finale(self):
        """Renvoie la hauteur de la dernière semaine mesurée, ou None sans mesure."""
        if len(self.mesures) == 0:
            return None
        return max(self.mesures, key=lambda m: m.semaine).hauteur


a = Parcelle("A", paillee=True)
b = Parcelle("B", paillee=False)
a.ajouter(Mesure(2, "2026-04-06", "A", 14.5))
a.ajouter(Mesure(1, "2026-03-30", "A", 8.0))
print(a, b)
print(a.hauteur_finale(), b.hauteur_finale())
a.ajouter(Mesure(1, "2026-03-30", "B", 7.5))

• self.mesures = [] est créé dans __init__ : chaque parcelle a sa propre liste.
• __repr__ choisit l'affichage d'un objet ; il est utilisé par print et dans les listes.
• ajouter protège la parcelle : une mesure d'une autre parcelle lève une ValueError (épisode 9).
• hauteur_finale utilise max avec une clé (épisode 3) : peu importe l'ordre d'ajout, c'est la semaine la plus tardive qui compte.

Le piège de la liste partagée. Une valeur par défaut modifiable dans une dataclass est refusée :

from dataclasses import dataclass


@dataclass
class Parcelle:
    nom: str
    mesures: list = []

Affiche (dernière ligne de la trace) :

« Valeur par défaut modifiable de type liste non autorisée pour le champ mesures : utilise default_factory ». Une même liste serait partagée par toutes les parcelles. On écrit mesures: list = field(default_factory=list) (avec from dataclasses import field), ou on crée la liste dans __init__, comme Parcelle.

Classe ou fonction ? Une classe quand des données et les opérations qui les concernent vont ensemble (une parcelle et ses mesures) ; une simple fonction quand on transforme des données sans état à garder (lire_taille).

« Des noms aux classes, des verbes aux méthodes »

1. Écrire la description du problème en quelques phrases.
2. Souligner les noms : jardin, parcelle, mesure, hauteur, semaine. Ceux qui ont plusieurs informations deviennent des classes ; les autres, des attributs.
3. Souligner les verbes : ajouter une parcelle, recevoir une mesure, connaître la hauteur finale. Ils deviennent des méthodes de la classe qui possède les données.
4. Garder en fonction ce qui ne possède aucune donnée (lire un fichier, comparer).
5. Essayer le modèle dans un petit script avant de l'utiliser partout.

modele.py (version de cet épisode) :

"""Modèle du jardin : mesures, parcelles et jardin."""

from dataclasses import dataclass


@dataclass
class Mesure:
    """Une mesure du cahier : semaine, date (AAAA-MM-JJ), parcelle, hauteur en mm."""

    semaine: int
    date: str
    parcelle: str
    hauteur: float


class Parcelle:
    """Une parcelle du jardin et ses mesures."""

    def __init__(self, nom: str, paillee: bool) -> None:
        self.nom = nom
        self.paillee = paillee
        self.mesures: list[Mesure] = []

    def __repr__(self) -> str:
        return f"Parcelle({self.nom!r}, paillee={self.paillee}, mesures={len(self.mesures)})"

    def ajouter(self, mesure: Mesure) -> None:
        """Ajoute une mesure de cette parcelle ; lève ValueError si elle vient d'une autre parcelle."""
        if mesure.parcelle != self.nom:
            raise ValueError(f"mesure de la parcelle {mesure.parcelle!r} ajoutée à {self.nom!r}")
        self.mesures.append(mesure)

    def hauteur_finale(self) -> float | None:
        """Renvoie la hauteur de la dernière semaine mesurée, ou None sans mesure."""
        if len(self.mesures) == 0:
            return None
        return max(self.mesures, key=lambda m: m.semaine).hauteur


class Jardin:
    """Le jardin : ses parcelles, rangées par nom."""

    def __init__(self) -> None:
        self.parcelles: dict[str, Parcelle] = {}

    def ajouter_parcelle(self, nom: str, paillee: bool) -> None:
        """Crée une parcelle vide."""
        self.parcelles[nom] = Parcelle(nom, paillee)

    def ajouter_mesure(self, mesure: Mesure) -> None:
        """Range une mesure dans sa parcelle ; lève ValueError si la parcelle est inconnue."""
        if mesure.parcelle not in self.parcelles:
            raise ValueError(f"parcelle inconnue : {mesure.parcelle!r}")
        self.parcelles[mesure.parcelle].ajouter(mesure)

Un essai :

from modele import Jardin, Mesure

jardin = Jardin()
jardin.ajouter_parcelle("A", paillee=True)
jardin.ajouter_parcelle("B", paillee=False)
jardin.ajouter_mesure(Mesure(1, "2026-03-30", "A", 8.0))
jardin.ajouter_mesure(Mesure(1, "2026-03-30", "B", 7.5))
jardin.ajouter_mesure(Mesure(2, "2026-04-06", "A", 14.5))
for nom, parcelle in jardin.parcelles.items():
    print(nom, parcelle, parcelle.hauteur_finale())
jardin.ajouter_mesure(Mesure(1, "2026-03-30", "C", 5.0))

Sortie réelle :

• Le jardin range ses parcelles dans un dictionnaire (Pro, épisode 8) : on retrouve une parcelle par son nom.
• ajouter_mesure délègue à la parcelle : chaque objet fait ce qui le concerne.
• Une mesure d'une parcelle inconnue lève une ValueError claire, au lieu d'une KeyError obscure.

Un modèle qui suit la description du problème se relit comme elle : un encadrant qui n'a jamais vu ton code comprend jardin.parcelles["A"].hauteur_finale(). Chaque classe protège ses données (une parcelle refuse la mesure d'une autre), et chaque règle n'est écrite qu'à un seul endroit. L'essai dans un petit script vérifie le modèle avant de le brancher sur 300 lignes de cahier.

Bon réflexe ou piège ?

Les tests automatisés avec pytest

Un test automatisé est une fonction qui vérifie un comportement attendu. pytest les trouve, les lance tous en une commande, et explique précisément ceux qui échouent.

Installer et lancer. Dans l'environnement du projet (Pro, épisode 14) : python -m pip install pytest, puis, dans le dossier pousse : python -m pytest. pytest cherche les fichiers test_*.py et, dedans, les fonctions test_*.

test_lecture.py :

import pytest

from lecture import lire_cahier, lire_taille


def test_virgule_et_point():
    assert lire_taille("12,5") == 12.5
    assert lire_taille(" 40.0 ") == 40.0


@pytest.mark.parametrize("texte", ["", "n.m.", "  "])
def test_hauteur_absente(texte):
    with pytest.raises(ValueError, match="absente"):
        lire_taille(texte)


def test_hauteur_illisible():
    with pytest.raises(ValueError, match="illisible"):
        lire_taille("douze")


def test_cahier_avec_lignes_ecartees(tmp_path):
    cahier = tmp_path / "cahier.csv"
    cahier.write_text("semaine;date;parcelle;hauteur_mm\n"
                      "1;2026-03-30;A;8,0\n"
                      "2;2026-04-06;A;n.m.\n"
                      "3;2026-04-13;A;22,0\n", encoding="utf-8")
    mesures, ecartees = lire_cahier(cahier)
    assert [m.hauteur for m in mesures] == [8.0, 22.0]
    assert ecartees == ["ligne 3 : hauteur absente : 'n.m.'"]

• Un test = une fonction test_… avec un ou plusieurs assert.
• pytest.raises(ValueError, match="absente") vérifie qu'une exception est levée, et que son message contient « absente ». Sans exception, le test échoue.
• @pytest.mark.parametrize lance le même test avec plusieurs valeurs : ici trois.
• tmp_path : pytest donne au test un dossier temporaire, neuf, rien qu'à lui. On y écrit un petit cahier : les vrais fichiers ne sont jamais touchés (règle des copies).

test_modele.py (extrait) utilise pytest.approx pour comparer des nombres à virgule sans être piégé par les arrondis (Boost, épisode 1) : assert parcelle.croissance_hebdo() == pytest.approx([6.5, 8.5]).

Le rapport, quand tout va bien (python -m pytest, sortie réelle ; la durée varie) :

Un point par test réussi : 13 tests, en quelques centièmes de seconde.

Le rapport, quand un bug se glisse. Yanis décale par erreur la numérotation des lignes (start=1 au lieu de start=2) :

Le F désigne le test qui échoue ; le > montre la ligne fautive ; les lignes E comparent l'obtenu (ligne 2) et l'attendu (ligne 3). Le bug est trouvé avant d'être publié.

Un test qui passe ne prouve pas que le code est juste : il prouve que le code fait ce que ce test vérifie. D'où l'importance de choisir ses cas : le cas connu, les cas limites (vide, une seule valeur), les exceptions.

« Rouge, vert, propre »

1. Écrire le test du comportement voulu, avec un cas calculé à la main (Boost, épisode 4) : mesures 8,0 (semaine 1), 14,5 (semaine 2), 31,5 (semaine 4) → croissances 6,5 puis (31,5 − 14,5) / 2 = 8,5 mm par semaine.
2. Rouge : lancer le test, le voir échouer, pour la bonne raison.
3. Vert : écrire le minimum de code pour le faire passer.
4. Propre : relire, renommer, simplifier, en gardant tous les tests au vert.

Le test, écrit avant la méthode (test_modele.py) :

def test_croissance_avec_semaine_manquante():
    parcelle = Parcelle("A", paillee=True)
    for semaine, hauteur in [(1, 8.0), (2, 14.5), (4, 31.5)]:
        parcelle.ajouter(Mesure(semaine, "", "A", hauteur))
    assert parcelle.croissance_hebdo() == pytest.approx([6.5, 8.5])

Rouge, étape 1 : la méthode n'existe pas encore (python -m pytest test_modele.py -k croissance, où -k choisit les tests dont le nom contient « croissance ») :

L'échec est le bon : AttributeError: 'Parcelle' object has no attribute 'croissance_hebdo'.

Rouge, étape 2 : une première version, qui soustrait deux hauteurs successives… et oublie l'écart entre les semaines :

        return [tries[i + 1].hauteur - tries[i].hauteur for i in range(len(tries) - 1)]

Le test la refuse : assert [6.5, 17.0] == approx([6.5 ±....5 ± 8.5e-06]), avec le tableau « Obtained 17.0, Expected 8.5 ». Sans le test écrit avant, 17 mm par semaine serait passé inaperçu.

Vert, étape 3 : on divise par l'écart entre les semaines :

    def croissance_hebdo(self) -> list[float]:
        """Renvoie la croissance en mm par semaine entre deux mesures successives."""
        tries = sorted(self.mesures, key=lambda m: m.semaine)
        return [(tries[i + 1].hauteur - tries[i].hauteur) / (tries[i + 1].semaine - tries[i].semaine)
                for i in range(len(tries) - 1)]

Propre : la compréhension (épisode 1) est découpée sur deux lignes pour rester lisible ; le test test_parcelle_vide vérifie aussi qu'une parcelle sans mesure renvoie [].

Écrire le test d'abord oblige à décider ce qu'on veut avant de penser à comment le faire : c'est là que Yanis a dû trancher le cas de la semaine manquante. Voir le test échouer prouve qu'il teste vraiment quelque chose (un test qui passe avant d'avoir écrit le code ne teste rien). Et chaque modification ultérieure se fait sous la protection des tests : on peut nettoyer sans peur.

Bon réflexe ou piège ?

Les annotations de type

Une annotation de type indique le type attendu d'un paramètre, d'une valeur renvoyée ou d'une variable. Python ne la vérifie pas à l'exécution ; un vérificateur de types comme mypy lit le code, sans le lancer, et signale les incohérences.

Sans annotations, l'erreur arrive tard.

def moyenne(valeurs):
    return sum(valeurs) / len(valeurs)


print(moyenne([8.0, 14.5]))
print(moyenne("8,0"))

Affiche 11.25, puis s'arrête sur TypeError: unsupported operand type(s) for +: 'int' and 'str' (« types non pris en charge pour + : int et str »), dans sum, loin de l'appel fautif. Et mypy ne dit rien : Success: no issues found in 1 source file, car une fonction sans annotations n'est pas vérifiée.

Avec annotations, mypy l'attrape avant.

def moyenne(valeurs: list[float]) -> float:
    """Renvoie la moyenne d'une liste non vide."""
    return sum(valeurs) / len(valeurs)


hauteurs: dict[str, list[float]] = {"A": [8.0, 14.5], "B": [7.5]}
print(moyenne(hauteurs["A"]))
print(moyenne("8,0"))

python -m mypy e15_apres.py (sans lancer le programme) :

« L'argument 1 de moyenne a un type incompatible : str ; attendu : list[float] ».

Sur « Pousse ». Les modules sont annotés depuis l'épisode 10. L'erreur d'Awa, dans un petit script placé dans le dossier du projet :

from analyse import croissance_moyenne
from modele import Mesure, Parcelle

parcelle = Parcelle("A", paillee=True)
parcelle.ajouter(Mesure(1, "2026-03-30", "A", "8,0"))
print(parcelle.mesures)
print(round(croissance_moyenne(parcelle), 1))

À l'exécution :

La hauteur '8,0' est entrée sans erreur ; le plantage vient plus tard, avec un message sur NoneType et __round__. mypy, lui, voit les deux problèmes avant :

• Ligne 5 : la hauteur doit être un float, pas un str.
• Ligne 7 : croissance_moyenne peut renvoyer None (avec moins de deux mesures) ; round ne sait pas arrondir None. Le libellé _SupportsRound2[float] désigne, en jargon de mypy, « quelque chose qu'on peut arrondir ». La correction : tester None avant d'arrondir.

Installer et lancer : dans l'environnement du projet, python -m pip install mypy, puis python -m mypy lecture.py modele.py analyse.py. On annote d'abord les fonctions que d'autres appellent ; une fonction non annotée n'est pas vérifiée par défaut.

« Exception, test ou annotation ? »

🎨 Carrousel récapitulatif — Arc 2

Modules, paquets et pyproject.toml

Un module est un fichier .py ; un paquet est un dossier de modules qui contient un fichier __init__.py. Quand Python lit import pousse.modele, il cherche un paquet pousse dans les dossiers de son chemin d'import : le dossier du script lancé, puis les paquets installés dans l'environnement. D'où le mystère de Yanis : ses imports dépendaient du dossier d'où il lançait le programme.

La solution : un paquet installé. La disposition recommandée range le code dans src/ :

pyproject.toml, au format TOML (des sections entre crochets, des lignes clé = valeur) :

[build-system]
requires = ["setuptools >= 77.0.3"]
build-backend = "setuptools.build_meta"

[project]
name = "pousse"
version = "0.1.0"
description = "Analyse du cahier de mesures d'un jardin partagé, croisé avec la météo."
requires-python = ">= 3.12"
dependencies = ["requests", "flask", "matplotlib"]

[project.optional-dependencies]
dev = ["pytest", "mypy"]

[tool.setuptools.package-data]
pousse = ["templates/*.html"]

• [build-system] dit quel outil sait construire le paquet (ici setuptools) ; pip l'installe tout seul.
• [project] : le nom, la version, la version minimale de Python, et les dépendances (installées automatiquement avec le paquet, comme dans requirements.txt, Pro, épisode 14). Les paquets requests, flask et matplotlib serviront aux épisodes 19 et 23.
• [project.optional-dependencies] : des dépendances en option, ici les outils de développement : python -m pip install -e ".[dev]" les ajoute.
• [tool.setuptools.package-data] : les fichiers non Python à emporter avec le paquet (les pages HTML de l'épisode 23).

__init__.py marque le dossier comme paquet ; il peut ne contenir qu'une docstring :

"""Pousse : analyse du cahier de mesures d'un jardin partagé, croisé avec la météo."""

Imports absolus. Dans les modules, on écrit le chemin complet depuis le paquet : from pousse.modele import Mesure (et non plus from modele import Mesure). Les tests aussi : from pousse.lecture import lire_taille.

__main__.py et if __name__ == "__main__" :

"""Point d'entrée : python -m pousse [chemin du cahier]."""

import sys
from pathlib import Path

from pousse.analyse import comparer
from pousse.lecture import lire_cahier
from pousse.modele import Jardin


def main() -> None:
    """Lit le cahier, range les mesures dans le jardin et affiche la comparaison."""
    chemin = Path("donnees/mesures-jardin.csv")
    if len(sys.argv) > 1:
        chemin = Path(sys.argv[1])
    mesures, ecartees = lire_cahier(chemin)
    jardin = Jardin()
    jardin.ajouter_parcelle("A", paillee=True)
    jardin.ajouter_parcelle("B", paillee=False)
    for mesure in mesures:
        jardin.ajouter_mesure(mesure)
    for ligne in comparer(jardin):
        print(ligne)
    print(f"{len(ecartees)} lignes écartées.")


if __name__ == "__main__":
    main()

• python -m pousse exécute le fichier __main__.py du paquet.
• sys.argv est la liste des mots de la commande : sys.argv[1] est le premier argument donné après le nom du programme.
• __name__ vaut "__main__" quand le fichier est lancé, et le nom du module quand il est importé. Le bloc if __name__ == "__main__": ne s'exécute donc qu'au lancement : on peut importer main (pour la tester) sans lancer le programme. C'est le cas laissé en suspens au Pro.

Installer en mode modifiable. Dans l'environnement du projet, depuis le dossier qui contient pyproject.toml :

Avant cette commande, les tests ne trouvent pas le paquet :

Après (dernière ligne de la sortie de pip) :

Puis python -m pousse, depuis le dossier du projet :

Avec -e (editable, modifiable), pip n'a pas copié le code : il a ajouté src/ au chemin d'import de l'environnement. Tes modifications sont prises en compte sans réinstaller ; il ne faut réinstaller que si tu changes pyproject.toml (une dépendance, la version).

Les gestionnaires récents. Des outils comme uv ou Poetry gèrent environnement, dépendances et pyproject.toml en une commande ; ce livre s'en tient à venv et pip, fournis avec Python.

« Déplacer, réinstaller, retester »

1. Partir du vert : python -m pytest passe avant de commencer ; commit (Pro, épisode 18).
2. Créer la structure vide : src/pousse/__init__.py, tests/, pyproject.toml ; python -m pip install -e . ; commit.
3. Déplacer un module à la fois, avec ses imports devenus absolus, et le test qui le concerne ; relancer python -m pytest ; commit.
4. Ajouter le point d'entrée __main__.py ; vérifier python -m pousse ; commit.
5. Vérifier depuis un dossier neuf : un clone, un environnement neuf, pip install -e ".[dev]", pytest (Pro, épisode 18).

Résultat attendu après la dernière étape (python -m pytest, sortie réelle) :

24 tests : ceux de l'arc 2, et ceux des modules des épisodes 19 à 23. Après chaque déplacement, seuls les tests du module déplacé peuvent changer : s'ils deviennent rouges, l'erreur est dans le déplacement qu'on vient de faire.

Une restructuration ne change pas ce que fait le code : les tests doivent rester verts du début à la fin. En avançant d'un module à la fois, chaque rouge pointe vers la dernière modification ; en committant à chaque étape, on peut toujours revenir au dernier état vert. Le test du dossier neuf vérifie ce que ton ordinateur cache : un fichier oublié, une dépendance absente de pyproject.toml.

Bon réflexe ou piège ?

Les API web

Une API web (interface de programmation) est un service qu'un programme interroge par Internet. Ton programme est le client ; il envoie une requête HTTP à un serveur, qui renvoie une réponse : un code de statut et un contenu, souvent en JSON (Pro, épisode 13).

L'API météo de « Pousse » : Open-Meteo. Son archive historique répond à l'adresse https://archive-api.open-meteo.com/v1/archive. Une requête GET lui passe des paramètres après un ? : latitude, longitude, start_date, end_date (au format AAAA-MM-JJ), les variables quotidiennes voulues (daily) et le fuseau horaire (timezone, obligatoire pour des données quotidiennes). La réponse est un dictionnaire JSON ; sa partie daily contient une liste time (les jours) et une liste par variable, dans le même ordre ; daily_units donne les unités.

Le module meteo.py de « Pousse » utilise la bibliothèque requests (une dépendance de pyproject.toml, épisode 17) :

"""Météo du jardin : appel de l'API Open-Meteo (archive historique), cache dans un fichier, lecture."""

import json
from pathlib import Path

import requests

URL_ARCHIVE = "https://archive-api.open-meteo.com/v1/archive"
LATITUDE, LONGITUDE = 45.76, 4.84  # le centre de Lyon : un lieu public, jamais une adresse personnelle


def telecharger_meteo(debut: str, fin: str, url: str = URL_ARCHIVE) -> dict:
    """Demande à l'API la température moyenne et la pluie de chaque jour entre debut et fin (AAAA-MM-JJ)."""
    parametres: dict[str, str | float] = {
        "latitude": LATITUDE,
        "longitude": LONGITUDE,
        "start_date": debut,
        "end_date": fin,
        "daily": "temperature_2m_mean,precipitation_sum",
        "timezone": "Europe/Paris",
    }
    reponse = requests.get(url, params=parametres, timeout=10)
    reponse.raise_for_status()
    return reponse.json()


def enregistrer_cache(donnees: dict, chemin: Path) -> None:
    """Enregistre la réponse de l'API dans un fichier JSON."""
    with open(chemin, "w", encoding="utf-8") as fichier:
        json.dump(donnees, fichier, ensure_ascii=False, indent=1)


def lire_cache(chemin: Path) -> dict:
    """Relit une réponse enregistrée."""
    with open(chemin, encoding="utf-8") as fichier:
        return json.load(fichier)


def temperatures(donnees: dict) -> dict[str, float]:
    """Renvoie {date: température moyenne} ; les jours sans valeur (None) sont ignorés."""
    jours = donnees["daily"]["time"]
    valeurs = donnees["daily"]["temperature_2m_mean"]
    return {jours[i]: valeurs[i] for i in range(len(jours)) if valeurs[i] is not None}


def obtenir_meteo(debut: str, fin: str, cache: Path, url: str = URL_ARCHIVE) -> dict:
    """Lit le cache s'il existe ; sinon appelle l'API une fois et enregistre la réponse."""
    if cache.exists():
        return lire_cache(cache)
    donnees = telecharger_meteo(debut, fin, url)
    enregistrer_cache(donnees, cache)
    return donnees

• requests.get(url, params=…, timeout=10) construit l'adresse avec ses paramètres et envoie la requête ; timeout=10 abandonne au bout de 10 secondes sans réponse, au lieu d'attendre indéfiniment.
• raise_for_status() lève une exception requests.HTTPError si le code de statut signale une erreur (épisode 9).
• reponse.json() transforme le JSON reçu en dictionnaire Python.
• temperatures ignore les jours sans valeur : l'API peut renvoyer null (devenu None).
• Le lieu est une ville (le centre de Lyon), jamais une adresse personnelle : on n'envoie aucune donnée personnelle à un service extérieur.

Les codes de statut à connaître.

Un essai. Le programme essai_meteo.py affiche les clés de la réponse, ses unités et les trois premiers jours, puis provoque deux erreurs : des dates inversées (400) et un serveur injoignable.

"""Appelle l'API (ou le faux serveur local donné en argument) et affiche les premiers jours."""
import sys

import requests

from pousse.meteo import URL_ARCHIVE, telecharger_meteo, temperatures

url = URL_ARCHIVE
if len(sys.argv) > 1:
    url = sys.argv[1]
donnees = telecharger_meteo("2026-03-24", "2026-06-15", url)
print(sorted(donnees))
print(donnees["daily_units"])
temp = temperatures(donnees)
print(len(temp), "jours ;", list(temp.items())[:3])
try:
    telecharger_meteo("2026-06-15", "2026-03-24", url)
except requests.HTTPError as erreur:
    print("Erreur HTTP :", erreur.response.status_code, erreur.response.json()["reason"])
try:
    telecharger_meteo("2026-03-24", "2026-06-15", "http://127.0.0.1:9")
except requests.ConnectionError:
    print("Pas de réseau : la météo n'a pas pu être téléchargée.")

Sortie réelle, obtenue contre un serveur d'essai local qui renvoie une réponse au format documenté par Open-Meteo, avec des valeurs inventées (l'environnement de rédaction de ce livre ne peut pas joindre l'API) :

requests.ConnectionError est levée quand le serveur ne répond pas du tout (pas de réseau, mauvaise adresse). Chez toi, lancé sans argument, le programme interroge la vraie API : les clés et les unités seront les mêmes, les températures seront les vraies.

Les conditions d'usage. Open-Meteo est gratuit, sans compte ni clé, pour un usage non commercial, dans la limite de 10 000 appels par jour ; ses données sont sous licence CC BY 4.0 : on peut les réutiliser en citant la source (« Météo : Open-Meteo.com », avec la référence demandée sur son site). « Pousse » respecte les deux : un seul appel par saison grâce au cache (épisode 20), et l'attribution sur chaque page de l'application (épisode 23).

Sans installation : urllib.request, dans la bibliothèque standard, sait aussi envoyer une requête ; requests est plus simple à lire et gère mieux les erreurs.

« Appeler une fois, enregistrer, lire partout »

1. Séparer l'appel réseau (telecharger_meteo) de la lecture des données (temperatures) : la lecture se teste sans réseau.
2. Enregistrer la réponse dans un fichier cache (enregistrer_cache) et la relire ensuite (lire_cache).
3. Une seule porte d'entrée, obtenir_meteo : si le cache existe, on le lit ; sinon, on appelle l'API une fois et on enregistre (le code est dans meteo.py, épisode 19).
4. Tester sur une réponse enregistrée, jamais sur le réseau : un test qui dépend du réseau échoue dans le train, et il interroge l'API à chaque lancement.
5. Prévoir l'échec : sans cache et sans réseau, un message clair (ConnectionError interceptée, épisode 9).

Les tests de meteo.py :

from pathlib import Path

from pousse.meteo import enregistrer_cache, lire_cache, obtenir_meteo, temperatures

REPONSE = Path(__file__).parent / "reponse-exemple-meteo.json"


def test_temperatures_ignore_les_jours_sans_valeur():
    donnees = lire_cache(REPONSE)
    temp = temperatures(donnees)
    assert len(donnees["daily"]["time"]) == 84
    assert len(temp) == 83
    assert "2026-04-03" not in temp


def test_cache_aller_retour(tmp_path):
    donnees = {"daily": {"time": ["2026-04-06"], "temperature_2m_mean": [11.5]}}
    cache = tmp_path / "meteo.json"
    enregistrer_cache(donnees, cache)
    assert lire_cache(cache) == donnees


def test_obtenir_meteo_utilise_le_cache_sans_reseau(tmp_path):
    cache = tmp_path / "meteo.json"
    enregistrer_cache(lire_cache(REPONSE), cache)
    donnees = obtenir_meteo("2026-03-24", "2026-06-15", cache, url="http://adresse-invalide.example")
    assert donnees["timezone"] == "Europe/Paris"

• Le premier lit la réponse d'exemple enregistrée dans tests/ : 84 jours, dont un sans température (le 3 avril, null dans l'exemple) ; il en reste 83.
• Le troisième passe une adresse invalide : s'il appelait le réseau, il échouerait ; il passe, donc le cache a bien été lu.

Le cache, en vrai (essai_cache.py, avec le serveur d'essai local) :

"""Premier appel : téléchargement et cache ; second appel : lecture du cache, même sans serveur."""
import sys
from pathlib import Path

from pousse.meteo import URL_ARCHIVE, obtenir_meteo, temperatures

url = URL_ARCHIVE
if len(sys.argv) > 1:
    url = sys.argv[1]
cache = Path("meteo-cache.json")
donnees = obtenir_meteo("2026-03-24", "2026-06-15", cache, url)
print("1er appel :", len(temperatures(donnees)), "jours ; cache créé :", cache.exists())
donnees = obtenir_meteo("2026-03-24", "2026-06-15", cache, url="http://127.0.0.1:9")
print("2e appel (serveur injoignable) :", len(temperatures(donnees)), "jours, lus dans le cache")

Au second appel, le serveur est injoignable : les données viennent du fichier. Pour rafraîchir le cache, on supprime le fichier.

Des données du passé ne changent pas : les télécharger une fois suffit. Le cache rend le programme rapide, utilisable sans réseau et respectueux de l'API (une requête par saison au lieu de vingt par jour). Séparer l'appel de la lecture rend presque tout le code testable sans réseau : seul telecharger_meteo en a besoin, et il est trop simple pour cacher une logique compliquée.

Bon réflexe ou piège ?

SQLite et le langage SQL

Une base de données range des données dans des tables : des lignes (une mesure) et des colonnes (semaine, parcelle, hauteur). On l'interroge avec SQL, un langage de requêtes. SQLite est une base complète dans un seul fichier, sans serveur ; le module sqlite3 est fourni avec Python.

"""Découverte de SQLite : créer une table, insérer, interroger."""
import sqlite3

connexion = sqlite3.connect(":memory:")
connexion.execute("CREATE TABLE mesures (semaine INTEGER, parcelle TEXT, hauteur REAL)")
releves = [(1, "A", 8.0), (1, "B", 7.5), (2, "A", 14.5), (2, "B", 12.0), (3, "A", 22.0), (3, "B", 18.5)]
with connexion:
    connexion.executemany("INSERT INTO mesures VALUES (?, ?, ?)", releves)

print(connexion.execute("SELECT * FROM mesures WHERE parcelle = ? ORDER BY hauteur DESC", ("A",)).fetchall())
print(connexion.execute("SELECT parcelle, COUNT(*), ROUND(AVG(hauteur), 2) FROM mesures GROUP BY parcelle").fetchall())
connexion.execute("CREATE TABLE parcelles (nom TEXT PRIMARY KEY, paillee INTEGER)")
with connexion:
    connexion.executemany("INSERT INTO parcelles VALUES (?, ?)", [("A", 1), ("B", 0)])
requete = """
    SELECT m.semaine, m.parcelle, m.hauteur
    FROM mesures AS m JOIN parcelles AS p ON m.parcelle = p.nom
    WHERE p.paillee = 1 AND m.hauteur > ?
"""
print(connexion.execute(requete, (10,)).fetchall())
connexion.close()

Sortie réelle :

• sqlite3.connect(":memory:") crée une base en mémoire (pour un essai) ; avec un chemin de fichier, la base est enregistrée sur le disque.
• CREATE TABLE crée une table et ses colonnes, avec leur type (INTEGER, TEXT, REAL).
• INSERT INTO … VALUES (?, ?, ?) : chaque ? est un paramètre, remplacé par une valeur du tuple. On n'écrit jamais une valeur dans la requête avec une f-string : un texte malveillant pourrait modifier la requête elle-même (l'injection SQL, épisode 25). executemany insère toute une liste.
• with connexion: ouvre une transaction : à la fin du bloc, les modifications sont validées (commit) ; en cas d'exception, elles sont toutes annulées. Le bloc ne ferme pas la connexion : connexion.close().
• SELECT … WHERE … ORDER BY … DESC : les lignes qui vérifient la condition, triées (ici par hauteur décroissante).
• GROUP BY parcelle avec COUNT(*) et AVG(hauteur) : un résumé par groupe, comme groupby de pandas (Pro, épisode 16).
• JOIN … ON : on associe les lignes de deux tables qui ont une valeur commune (la parcelle).
• fetchall() renvoie les lignes sous forme de liste de tuples.

Le module stockage.py de « Pousse ».

"""Stockage du jardin dans une base SQLite : mesures et météo."""

import sqlite3
from pathlib import Path

from pousse.modele import Mesure

SCHEMA = """
CREATE TABLE IF NOT EXISTS mesures (
    semaine INTEGER NOT NULL,
    date TEXT NOT NULL,
    parcelle TEXT NOT NULL,
    hauteur REAL NOT NULL,
    PRIMARY KEY (date, parcelle)
);
CREATE TABLE IF NOT EXISTS meteo (
    date TEXT PRIMARY KEY,
    temperature REAL NOT NULL
);
"""


def ouvrir(chemin: Path) -> sqlite3.Connection:
    """Ouvre (ou crée) la base et ses tables."""
    connexion = sqlite3.connect(chemin)
    connexion.executescript(SCHEMA)
    return connexion


def enregistrer_mesures(connexion: sqlite3.Connection, mesures: list[Mesure]) -> None:
    """Ajoute des mesures ; une mesure déjà présente (même date, même parcelle) est remplacée."""
    with connexion:
        connexion.executemany(
            "INSERT OR REPLACE INTO mesures VALUES (?, ?, ?, ?)",
            [(m.semaine, m.date, m.parcelle, m.hauteur) for m in mesures],
        )


def enregistrer_meteo(connexion: sqlite3.Connection, temperatures: dict[str, float]) -> None:
    """Ajoute les températures moyennes quotidiennes."""
    with connexion:
        connexion.executemany(
            "INSERT OR REPLACE INTO meteo VALUES (?, ?)",
            list(temperatures.items()),
        )


def mesures_de(connexion: sqlite3.Connection, parcelle: str) -> list[tuple[int, str, float]]:
    """Renvoie les (semaine, date, hauteur) d'une parcelle, dans l'ordre des semaines."""
    curseur = connexion.execute(
        "SELECT semaine, date, hauteur FROM mesures WHERE parcelle = ? ORDER BY semaine",
        (parcelle,),
    )
    return curseur.fetchall()


def hauteur_et_temperature(connexion: sqlite3.Connection) -> list[tuple[int, str, float, float]]:
    """Pour chaque mesure : semaine, parcelle, hauteur et température moyenne des 7 jours précédents."""
    curseur = connexion.execute(
        """
        SELECT m.semaine, m.parcelle, m.hauteur, ROUND(AVG(t.temperature), 1)
        FROM mesures AS m
        JOIN meteo AS t ON t.date BETWEEN date(m.date, '-6 days') AND m.date
        GROUP BY m.semaine, m.parcelle
        ORDER BY m.semaine, m.parcelle
        """
    )
    return curseur.fetchall()

• PRIMARY KEY (date, parcelle) : une clé primaire ; deux lignes ne peuvent pas avoir la même date pour la même parcelle. INSERT OR REPLACE remplace alors l'ancienne mesure au lieu de la dupliquer.
• NOT NULL refuse une valeur manquante.
• executescript exécute plusieurs instructions d'un coup (la création des tables) ; IF NOT EXISTS évite une erreur quand la table existe déjà.
• date(m.date, '-6 days') est une fonction de date de SQLite : six jours avant la mesure. La dernière requête calcule, pour chaque mesure, la température moyenne des sept jours qui la précèdent (épisode 22).

« La question en français, puis en SQL, puis à la main »

1. Écrire la question en français, avec ce qu'on veut par ligne de résultat : « pour chaque mesure : sa semaine, sa parcelle, sa hauteur, la moyenne des températures des 7 jours qui finissent le jour de la mesure ».
2. La traduire en SQL, clause par clause : FROM (les tables), JOIN … ON (la condition qui associe), GROUP BY (une ligne par quoi ?), SELECT (quelles colonnes), ORDER BY.
3. Compter les lignes attendues avant de lancer : ici, une par mesure, soit 22. Les 1 826 lignes de Yanis venaient d'un JOIN sans condition : chaque mesure associée à chacun des 83 jours de météo (22 × 83).
4. Vérifier à la main sur une petite base de test.
5. Ranger la requête dans une fonction de stockage.py, avec son test.

La fonction hauteur_et_temperature (dans stockage.py, épisode 21) et son test, sur une base temporaire dont on connaît la réponse :

from pousse.modele import Mesure
from pousse.stockage import enregistrer_mesures, enregistrer_meteo, hauteur_et_temperature, mesures_de, ouvrir


def test_mesures_triees_et_remplacees(tmp_path):
    connexion = ouvrir(tmp_path / "essai.db")
    enregistrer_mesures(connexion, [Mesure(2, "2026-04-06", "A", 14.5), Mesure(1, "2026-03-30", "A", 8.0)])
    enregistrer_mesures(connexion, [Mesure(2, "2026-04-06", "A", 15.0)])
    assert mesures_de(connexion, "A") == [(1, "2026-03-30", 8.0), (2, "2026-04-06", 15.0)]
    assert mesures_de(connexion, "B") == []


def test_temperature_des_sept_jours_precedents(tmp_path):
    connexion = ouvrir(tmp_path / "essai.db")
    enregistrer_mesures(connexion, [Mesure(2, "2026-04-06", "A", 14.5)])
    enregistrer_meteo(connexion, {"2026-03-30": 99.0, "2026-03-31": 10.0, "2026-04-06": 12.0})
    assert hauteur_et_temperature(connexion) == [(2, "A", 14.5, 11.0)]


def test_une_entree_piegee_reste_une_simple_valeur(tmp_path):
    connexion = ouvrir(tmp_path / "essai.db")
    enregistrer_mesures(connexion, [Mesure(1, "2026-03-30", "A", 8.0)])
    assert mesures_de(connexion, "A' OR '1'='1") == []

Dans le deuxième test, la mesure du 6 avril est associée aux jours du 31 mars au 6 avril : 10,0 et 12,0 °C, moyenne 11,0. La température du 30 mars (99,0, volontairement absurde) est hors de la fenêtre : si elle était comptée, le test le dirait. Le troisième test glisse une entrée piégée (A' OR '1'='1) : grâce au paramètre ?, elle est traitée comme un nom de parcelle, qui n'existe pas (voir épisode 25).

Sur les vraies données (charger_base.py, avec la météo en cache de l'épisode 20) :

"""Charge le cahier du jardin et la météo (cache) dans pousse.db, puis croise hauteur et température."""
from pathlib import Path

from pousse.lecture import lire_cahier
from pousse.meteo import lire_cache, temperatures
from pousse.stockage import enregistrer_mesures, enregistrer_meteo, hauteur_et_temperature, ouvrir

mesures, ecartees = lire_cahier(Path("donnees/mesures-jardin.csv"))
connexion = ouvrir(Path("pousse.db"))
enregistrer_mesures(connexion, mesures)
enregistrer_meteo(connexion, temperatures(lire_cache(Path("meteo-cache.json"))))
print("Mesures :", connexion.execute("SELECT COUNT(*) FROM mesures").fetchone()[0],
      "· jours de météo :", connexion.execute("SELECT COUNT(*) FROM meteo").fetchone()[0])
print("semaine  parcelle  hauteur  température (7 j)")
for semaine, parcelle, hauteur, temperature in hauteur_et_temperature(connexion)[:6]:
    print(f"{semaine:>7}  {parcelle:^8}  {hauteur:>7}  {temperature:>6} °C")
connexion.close()

Sortie réelle (les températures viennent de la réponse d'exemple, valeurs inventées) :

22 mesures, 83 jours de météo, et une ligne par mesure : la requête a le bon nombre de lignes.

Écrire la question en français oblige à dire ce qu'est une ligne du résultat : c'est presque toujours là que se cache l'erreur (un JOIN sans condition, un GROUP BY oublié). Compter les lignes attendues est une vérification gratuite. Et une base de test minuscule, construite pour l'occasion, donne un cas calculé à la main (Boost, épisode 4), avec un piège pour vérifier que la fenêtre de sept jours est la bonne.

Bon réflexe ou piège ?

Une application web avec Flask

Une application web est un programme qui répond à des requêtes HTTP (épisode 19) en renvoyant des pages HTML. Ton navigateur est le client ; l'application, lancée sur ton ordinateur, est le serveur. Flask est une bibliothèque légère pour en écrire une (une dépendance de pyproject.toml).

app.py :

"""Application web locale de Pousse (Flask) : tableau, figure et ajout d'une mesure."""

from io import BytesIO
from pathlib import Path

from flask import Flask, Response, abort, redirect, render_template, request, url_for
from flask.typing import ResponseReturnValue
from matplotlib.figure import Figure

from pousse.lecture import lire_taille
from pousse.modele import Mesure
from pousse.stockage import enregistrer_mesures, mesures_de, ouvrir

PARCELLES = {"A": "paillée", "B": "nue"}

app = Flask(__name__)
app.config["BASE"] = Path("pousse.db")


@app.get("/")
def accueil() -> str:
    """Page d'accueil : la figure et le nombre de mesures de chaque parcelle."""
    connexion = ouvrir(app.config["BASE"])
    tableau = {nom: mesures_de(connexion, nom) for nom in PARCELLES}
    connexion.close()
    return render_template("accueil.html", tableau=tableau, parcelles=PARCELLES)


@app.get("/parcelle/<nom>")
def parcelle(nom: str) -> str:
    """Tableau des mesures d'une parcelle ; erreur 404 si elle n'existe pas."""
    if nom not in PARCELLES:
        abort(404)
    connexion = ouvrir(app.config["BASE"])
    lignes = mesures_de(connexion, nom)
    connexion.close()
    return render_template("parcelle.html", nom=nom, etat=PARCELLES[nom], lignes=lignes)


@app.get("/figure.png")
def figure() -> Response:
    """La figure des hauteurs, produite à chaque demande (sans pyplot)."""
    connexion = ouvrir(app.config["BASE"])
    fig = Figure(figsize=(6, 4))
    ax = fig.subplots()
    for nom, etat in PARCELLES.items():
        lignes = mesures_de(connexion, nom)
        ax.plot([s for s, d, h in lignes], [h for s, d, h in lignes], marker="o", label=f"parcelle {nom} ({etat})")
    connexion.close()
    ax.set_title("Hauteur des radis du jardin partagé")
    ax.set_xlabel("Semaine")
    ax.set_ylabel("Hauteur (mm)")
    ax.legend()
    tampon = BytesIO()
    fig.savefig(tampon, format="png")
    return Response(tampon.getvalue(), mimetype="image/png")


@app.route("/ajouter", methods=["GET", "POST"])
def ajouter() -> ResponseReturnValue:
    """Formulaire d'ajout d'une mesure ; refuse une saisie invalide avec un message (code 400)."""
    if request.method == "GET":
        return render_template("ajouter.html", erreur=None)
    try:
        mesure = Mesure(
            semaine=int(request.form["semaine"]),
            date=request.form["date"],
            parcelle=request.form["parcelle"],
            hauteur=lire_taille(request.form["hauteur"]),
        )
        if mesure.parcelle not in PARCELLES:
            raise ValueError(f"parcelle inconnue : {mesure.parcelle!r}")
    except ValueError as erreur:
        return render_template("ajouter.html", erreur=str(erreur)), 400
    connexion = ouvrir(app.config["BASE"])
    enregistrer_mesures(connexion, [mesure])
    connexion.close()
    return redirect(url_for("accueil"))

• app = Flask(__name__) crée l'application ; app.config["BASE"] range un réglage : le chemin de la base (les tests le remplacent par une base temporaire).
• Une route associe une adresse à une fonction : @app.get("/") est un décorateur (comme @dataclass, épisode 11) qui inscrit accueil comme réponse à GET /. <nom> dans l'adresse devient un paramètre de la fonction.
• abort(404) répond « page introuvable » ; redirect(url_for("accueil")) renvoie vers l'accueil après un ajout réussi.
• render_template("accueil.html", …) remplit un gabarit HTML du dossier templates/ avec des valeurs.
• Le formulaire (POST /ajouter) est une entrée non fiable : chaque champ est converti et vérifié (int, lire_taille, parcelle connue) ; une saisie invalide est refusée avec un message et le code 400 (épisode 9).
• La figure est produite à la demande avec Figure (sans pyplot, comme le recommande matplotlib dans un serveur web) et envoyée en PNG depuis la mémoire (BytesIO).

Le gabarit de l'accueil :

<!doctype html>
<html lang="fr">
<head><meta charset="utf-8"><title>Pousse — le jardin partagé</title></head>
<body>
  <h1>Pousse — le jardin partagé</h1>
  <p><img src="{{ url_for('figure') }}" alt="Hauteur des radis par semaine et par parcelle"></p>
  {% for nom, lignes in tableau.items() %}
    <h2><a href="{{ url_for('parcelle', nom=nom) }}">Parcelle {{ nom }}</a> ({{ parcelles[nom] }}) : {{ lignes|length }} mesures</h2>
  {% endfor %}
  <p><a href="{{ url_for('ajouter') }}">Ajouter une mesure</a></p>
  <p><small>Données du jardin inventées. Météo : Open-Meteo.com (CC BY 4.0).</small></p>
</body>
</html>

{{ … }} insère une valeur, {% for … %} répète un morceau de page. Jinja, le moteur de gabarits de Flask, échappe automatiquement les valeurs : un texte comme <b>grand</b> s'affiche tel quel, sans devenir du HTML. La dernière ligne cite la source des données météo (licence CC BY 4.0, épisode 19).

Lancer l'application (dans l'environnement du projet, depuis son dossier) :

Le journal du serveur (extrait réel) :

Tu ouvres http://127.0.0.1:5050 dans ton navigateur : 127.0.0.1 désigne ton propre ordinateur ; personne d'autre n'y a accès. L'avertissement le rappelle : ce serveur de développement n'est pas fait pour être mis en ligne.

Ce que l'application renvoie (essai_app.py, qui joue le rôle du navigateur) :

"""Interroge l'application lancée en local (flask --app pousse.app run) et affiche ses réponses."""
import requests

BASE = "http://127.0.0.1:5050"
reponse = requests.get(BASE + "/", timeout=5)
print(reponse.status_code, reponse.headers["Content-Type"])
for ligne in reponse.text.splitlines():
    if "<h2>" in ligne or "<img" in ligne:
        print("  " + ligne.strip())
print(requests.get(BASE + "/parcelle/Z", timeout=5).status_code)
reponse = requests.post(BASE + "/ajouter", timeout=5, allow_redirects=False,
                        data={"semaine": "13", "date": "2026-06-22", "parcelle": "A", "hauteur": "<b>grand</b>"})
print(reponse.status_code, [l.strip() for l in reponse.text.splitlines() if "refusée" in l])
reponse = requests.get(BASE + "/figure.png", timeout=5)
print(reponse.status_code, reponse.headers["Content-Type"], len(reponse.content) > 10_000)

La saisie <b>grand</b> est refusée, et le message l'affiche échappée (<b>) : elle ne peut pas injecter de HTML dans la page.

Le mode debug. flask --app pousse.app run --debug recharge l'application à chaque modification et affiche un débogueur dans le navigateur en cas d'erreur. Ce débogueur permet d'exécuter du Python depuis le navigateur : il est réservé à ton ordinateur, jamais sur un serveur accessible par d'autres (épisode 25).

« Où ranger ce code ? »

🎨 Carrousel récapitulatif — Arc 3

Les quatre familles de risques

1. Les entrées non fiables : l'injection SQL. Tout ce qui vient de l'extérieur (un formulaire, une adresse, un fichier) peut contenir n'importe quoi. Une requête construite avec une f-string laisse la saisie modifier la requête elle-même :

"""Une requête construite avec une f-string, puis la même avec un paramètre : sur une base d'essai."""
import sqlite3

connexion = sqlite3.connect(":memory:")
connexion.execute("CREATE TABLE mesures (semaine INTEGER, parcelle TEXT, hauteur REAL)")
with connexion:
    connexion.executemany("INSERT INTO mesures VALUES (?, ?, ?)",
                          [(1, "A", 8.0), (1, "B", 7.5), (1, "privee", 99.0)])


def mesures_de_piege(nom):
    requete = f"SELECT * FROM mesures WHERE parcelle = '{nom}'"
    print("   requête envoyée :", requete)
    return connexion.execute(requete).fetchall()


def mesures_de(nom):
    return connexion.execute("SELECT * FROM mesures WHERE parcelle = ?", (nom,)).fetchall()


saisie = "A' OR '1'='1"
print("f-string :", mesures_de_piege(saisie))
print("paramètre :", mesures_de(saisie))
print("paramètre, saisie normale :", mesures_de("A"))

Sortie réelle :

La saisie A' OR '1'='1 ferme les guillemets et ajoute une condition toujours vraie : la f-string renvoie toutes les lignes, y compris une parcelle qui ne devait pas être visible. Avec le paramètre ?, la même saisie est traitée comme une simple valeur : aucune parcelle ne porte ce nom (épisode 21).

2. Les entrées non fiables : le HTML. Afficher une saisie sans l'échapper permet d'injecter du HTML, ou un script, dans la page :

"""Le même message d'erreur affiché avec et sans échappement, dans un gabarit Jinja (moteur de Flask)."""
from jinja2 import Environment

env = Environment(autoescape=True)
saisie = "<script>alert('jardin')</script>"
sur = env.from_string("<p>Mesure refusée : {{ erreur }}</p>")
piege = env.from_string("<p>Mesure refusée : {{ erreur|safe }}</p>")
print(sur.render(erreur=saisie))
print(piege.render(erreur=saisie))

Sortie réelle :

Jinja échappe automatiquement (première ligne). Le filtre |safe désactive l'échappement : le script arrive tel quel dans la page, et le navigateur l'exécuterait. On ne met jamais |safe sur une donnée saisie par quelqu'un. Et jamais eval ou exec sur une entrée : ce serait exécuter le code d'un inconnu.

3. Les secrets. Un mot de passe, une clé d'API, une clé secrète d'application ne s'écrivent jamais dans le code. On les lit dans une variable d'environnement, définie sur l'ordinateur et jamais versionnée : os.environ["POUSSE_SECRET_KEY"], ou dans un fichier .env listé dans .gitignore (Pro, épisode 18). Et un secret commité un jour reste dans l'historique, même effacé ensuite (démonstration réelle à l'épisode 26) : il faut alors le considérer comme connu de tous, et le changer. « Pousse » n'utilise aucun secret : la meilleure clé est celle qu'on n'a pas besoin d'avoir.

4. La configuration et les dépendances. Le mode debug de Flask permet d'exécuter du Python depuis le navigateur : jamais ailleurs que sur ton ordinateur, et jamais avec --host=0.0.0.0 (épisode 23). Les dépendances sont du code écrit par d'autres : on vérifie leur nom avant de les installer (Pro, épisode 14), on garde leurs versions dans pyproject.toml ou requirements.txt, on les met à jour, et on vérifie qu'elles n'ont pas de vulnérabilité connue (épisode 26).

Et les données personnelles. « Pousse » n'en collecte aucune : pas de compte, pas de nom, une ville et non une adresse. Si un projet devait en traiter, ce serait une autre affaire : informer, minimiser, protéger (règles de la CNIL).

« Secrets, entrées, dépendances, données »

1. Secrets : chercher dans la version actuelle (git grep -n "secret\|password\|key") et dans l'historique (git log -p -S "mot cherché").
2. Entrées : lister tout ce qui vient de l'extérieur (formulaire, adresse, fichier lu, réponse d'API) ; pour chacune, vérifier la conversion, la validation, les paramètres SQL et l'échappement.
3. Dépendances : pip-audit compare les versions installées (ou listées) aux bases de vulnérabilités connues.
4. Données : lister ce que le projet stocke ou envoie ; aucune donnée personnelle, une source et une licence pour chaque jeu de données.
5. Noter l'audit : la date, les commandes, ce qui a été corrigé, dans un fichier du dépôt.

Un secret effacé reste dans l'historique (démonstration réelle, dossier jetable, identité inventée) : une clé commitée, puis remplacée par une variable d'environnement dans le commit suivant.

git grep ne cherche que dans la version actuelle : rien. git log -p -S cherche dans tout l'historique : la clé apparaît dans les deux commits (ajoutée +, puis retirée -). Quiconque clone le dépôt peut la lire. Il faut la changer.

Vérifier les dépendances : pip-audit. Installé dans l'environnement du projet (python -m pip install pip-audit), il interroge la base de vulnérabilités des paquets Python. Sur une liste de vieilles versions :

Chaque ligne donne le paquet, sa version, l'identifiant de la vulnérabilité et la version qui la corrige (le rapport cite certaines lignes deux fois). Sur les dépendances de « Pousse », aux versions de cet automne :

Ce résultat vaut pour un jour donné : de nouvelles vulnérabilités sont découvertes chaque mois. On relance l'audit avant chaque publication. (--no-deps --disable-pip demande de vérifier la liste telle quelle, sans installer ; la commande python -m pip_audit, sans option, audite l'environnement actif.)

Une méthode par catégorie transforme une inquiétude vague en une liste de vérifications précises, chacune avec son outil. Les recherches automatiques (git log -S, pip-audit) voient ce qu'un œil fatigué manque : un secret enfoui dans un vieux commit, une vulnérabilité publiée la semaine dernière. Et noter l'audit permet de le refaire à l'identique avant la prochaine publication.

Bon réflexe ou piège ?

La documentation d'un projet

Le README est la page d'accueil du dépôt : les services d'hébergement l'affichent sous la liste des fichiers. Il répond, dans l'ordre, aux questions d'un visiteur : qu'est-ce que c'est ? Comment l'installer ? Comment l'utiliser ? Comment le tester ? D'où viennent les données, et quelles sont les limites ? Qui l'a fait, et sous quelle licence ?

Le README de « Pousse » (README.md) :

# Pousse

Pousse analyse le cahier de mesures d'un jardin partagé (la hauteur des radis de deux parcelles, l'une paillée, l'autre nue) et le croise avec la météo de la ville. Il affiche le résultat dans une petite application web qui tourne sur ton ordinateur.

![Hauteur des radis par semaine et par parcelle](docs/figure.png)

## Ce que fait Pousse

- lit le cahier de mesures (`donnees/mesures-jardin.csv`) et signale les lignes écartées ;
- calcule la hauteur finale et la croissance moyenne de chaque parcelle ;
- récupère la température moyenne quotidienne par l'API Open-Meteo, une seule fois, puis la garde en cache ;
- range mesures et météo dans une base SQLite et croise chaque mesure avec la température des 7 jours précédents ;
- affiche une page web locale : la figure, le tableau de chaque parcelle, un formulaire d'ajout.

## Installation

Avec Python 3.12 ou plus récent :

python -m venv .venv source .venv/bin/activate # sous Windows : .venv\Scripts\activate python -m pip install -e ".[dev]"

python -m pousse # résumé dans le terminal python essais/essai_cache.py # télécharge la météo une fois (cache : meteo-cache.json) python essais/charger_base.py # remplit la base pousse.db flask --app pousse.app run --port 5050 # puis ouvrir http://127.0.0.1:5050

python -m pytest python -m mypy src tests

Markdown en cinq éléments (le format .md, affiché mis en forme par les services d'hébergement) :

Les docstrings documentent le code lui-même (Pro, épisode 1) ; le README documente le projet ; un guide d'utilisation plus long irait dans un dossier docs/.

La licence. Sans licence, personne n'a le droit de réutiliser ton code, même s'il est public. Une licence dit ce que les autres peuvent en faire. La licence MIT, courte et permissive, autorise tout usage (y compris commercial), la modification et la redistribution, à une condition : conserver l'avis de droit d'auteur et le texte de la licence ; elle exclut toute garantie. Le fichier LICENSE de « Pousse » contient le texte officiel de la MIT, avec Copyright (c) 2026 Yanis. D'autres licences imposent que les versions modifiées restent libres : le site choosealicense.com aide à choisir.

La licence des données n'est pas celle du code : la météo d'Open-Meteo est sous CC BY 4.0, d'où la mention de la source dans le README et dans l'application (épisode 19).

Les limites, écrites noir sur blanc. Une section « Données et limites » honnête rassure plus qu'elle n'inquiète : le jeu de données est inventé, deux parcelles ne prouvent rien, l'application n'est pas faite pour être mise en ligne.

« Le test du clone neuf »

1. Un dossier vide, sur un autre ordinateur ou dans un autre compte : pas de fichier oublié, pas d'environnement déjà prêt.
2. Suivre le README à la lettre, commande par commande : git clone, environnement, installation, tests, lancement.
3. Noter chaque blocage (commande absente, étape implicite, fichier manquant) sans le corriger sur place.
4. Corriger le README ou le dépôt, commit, et recommencer jusqu'à zéro blocage.
5. Publier : rendre le dépôt public (ou privé et partagé avec l'encadrante) ; pour un mineur, avec un adulte (Pro, épisode 18).

Le .gitignore final de « Pousse » :

La base pousse.db et le cache météo se recréent avec les commandes du README ; .env contiendrait d'éventuels secrets ; *.egg-info/ est produit par l'installation.

Le test du clone neuf, en vrai (dépôt local, nouvel environnement, installation depuis PyPI ; identité inventée) :

30 fichiers suivis, une installation en une commande, 24 tests au vert, le programme qui affiche le résumé, et git status vide : rien de ce qui a été produit pendant l'essai ne risque d'être commité par erreur.

Ton ordinateur te ment par omission : l'environnement est déjà prêt, la base existe, une variable traîne. Un dossier vide et un lecteur qui ne pose pas de questions révèlent tout ce que le README suppose sans le dire. Chaque blocage corrigé, c'est un recruteur qui n'abandonnera pas à la troisième commande.

Bon réflexe ou piège ?

Apprendre seul, et le montrer

1. Apprendre seul : une méthode. Personne ne connaît tout ; ce qu'on attend d'un stagiaire, c'est de savoir apprendre vite et proprement.

• La documentation officielle d'abord, celle de ta version (Pro, épisode 12) : le tutoriel pour démarrer, la référence pour les détails.
• Les notes de version (What's New, changelog) disent ce qui a changé. Exemple : celles de Python 3.15 annoncent notamment un type intégré frozendict (PEP 814), un dictionnaire qu'on ne peut plus modifier. Un code qui l'utilise suppose donc Python 3.15 :

import sys

print(sys.version_info[:2])
parcelles = frozendict({"A": "paillée", "B": "nue"})
print(parcelles["A"])

Sous Python 3.15 (sortie réelle) :

Sous Python 3.12 (sortie réelle) :

Lire les notes de version évite de chercher pendant une heure pourquoi un exemple trouvé en ligne « ne marche pas chez toi ». « Pousse » demande Python 3.12 ou plus (requires-python) : il n'utilise donc pas frozendict.

• L'exemple minimal : réduire un problème au plus petit code qui le montre (Pro, épisode 4) ; souvent, on trouve la réponse en le construisant.
• Les forums : chercher d'abord si la question a déjà été posée ; sinon, poser une question avec l'exemple minimal, ce qu'on attendait, ce qu'on obtient, ce qu'on a essayé, en respectant les règles du forum.
• L'IA en tuteur, pas en auteur : lui demander d'expliquer un message d'erreur, de te poser des questions sur une notion, de comparer deux approches ; relire, tester, déclarer (Pro, épisode 19), dans le respect des conditions d'âge et des règles de ton établissement.

2. L'entretien technique de stage. Il vérifie trois choses : que tu as vraiment fait ce que tu présentes, que tu sais expliquer tes choix, et comment tu raisonnes devant un problème nouveau.

• Présenter son projet en 5 minutes : le problème, la démonstration, deux choix techniques expliqués, une limite, une suite possible.
• Expliquer un choix : « pourquoi SQLite ? », « pourquoi une dichotomie ? » (épisodes 3 et 21) ; donner la raison et l'alternative écartée.
• Raisonner à voix haute devant un petit problème : reformuler, prendre un exemple, proposer une idée simple, coder, tester, estimer le coût (épisode 7).
• Dire « je ne sais pas », puis : « voici comment je chercherais » (la méthode ci-dessus). C'est une réponse honnête et appréciée ; inventer, non.
• Préparer ses questions pour la fin de l'entretien : sur l'équipe, les données, les outils.

Ce livre ne promet pas de stage : il t'aide à arriver préparé, avec un projet que tu comprends de bout en bout.

« Présenter, expliquer, résoudre à voix haute »

1. Présenter (5 min) : le problème, la démonstration de l'application, deux choix techniques, une limite, une suite.
2. Répondre aux questions (5 min) : la raison du choix, l'alternative écartée ; « je ne sais pas, voici comment je chercherais ».
3. Résoudre à voix haute (10 à 20 min) :

• reformuler l'énoncé et ce qu'on renvoie (« une longueur, un entier ») ;
• un exemple à la main : [7, 8, 5, 9] avec un seuil de 6 → 2 ;
• les cas limites : liste vide, aucune valeur au-dessus du seuil ;
• une idée simple : parcourir en comptant la série en cours, la remettre à zéro quand elle s'interrompt, garder la meilleure ;
• coder, puis tester sur l'exemple et les cas limites ;
• estimer le coût : un seul parcours, O(n).

La solution d'Yanis, telle qu'il l'a écrite et testée pendant l'entretien blanc :

def plus_longue_serie(croissances, seuil):
    """Renvoie la longueur de la plus longue suite de valeurs consécutives strictement supérieures à seuil."""
    meilleure = 0
    courante = 0
    for valeur in croissances:
        if valeur > seuil:
            courante = courante + 1
            meilleure = max(meilleure, courante)
        else:
            courante = 0
    return meilleure


assert plus_longue_serie([], 6.0) == 0
assert plus_longue_serie([5.0, 4.0], 6.0) == 0
assert plus_longue_serie([7.0, 8.0, 5.0, 9.0], 6.0) == 2
assert plus_longue_serie([7.0, 8.0, 9.0], 6.0) == 3
croissances_a = [6.5, 7.5, 9.5, 8.5, 7.5, 6.5, 5.5, 4.5, 2.5, 1.5]
print(plus_longue_serie(croissances_a, 6.0))
print(plus_longue_serie(croissances_a, 8.0))

Sortie réelle :

Les assert passent (aucun message) ; les croissances de la parcelle A (épisode 14) donnent une série de 6 semaines au-dessus de 6 mm, et de 2 au-dessus de 8 mm. Coût : un seul parcours de la liste, O(n), et deux variables en mémoire.

Un entretien technique évalue un raisonnement plus qu'un résultat : penser à voix haute le rend visible. La méthode (reformuler, exemple, cas limites, idée simple, code, test, coût) évite les deux pièges du stress : se taire et coder trop vite. Et l'entretien blanc, chronométré, avec quelqu'un qui joue le jeu, transforme l'inconnu en situation déjà vécue.

Bon réflexe ou piège ?

Expliquer et aider

1. Expliquer un programme. Du plus général au plus précis :

• le quoi : ce que fait le programme, en une phrase, sans mot technique (« Pousse compare la croissance de deux parcelles de radis selon la météo ») ;
• la démonstration : montrer avant d'expliquer ;
• le comment : les grandes pièces et leurs liens, avec un schéma (les six modules de « Pousse » et leurs flèches : lecture → modele → analyse ; meteo et stockage ; app qui appelle les autres) ;
• un détail choisi : un seul morceau de code, expliqué à fond (la requête des sept jours, épisode 22) ;
• adapter les mots au public : une encadrante de laboratoire, un camarade de L1, un parent.

2. Aider sans faire à la place : le tutorat. Le but n'est pas que le programme marche, mais que l'étudiant sache le réparer la prochaine fois.

• Faire reformuler : « Qu'est-ce que la fonction devrait renvoyer ? Qu'est-ce qu'elle renvoie ? »
• Demander ce qui a été essayé, et montrer la méthode plutôt que la réponse : lire l'erreur en 3 questions (Boost, épisode 2), afficher les valeurs, réduire (Pro, épisode 4).
• Donner un indice gradué : d'abord une question (« Combien de tours fait ta boucle ? »), puis un indice (« Ajoute un print dans la boucle »), et seulement en dernier recours la réponse, expliquée.
• Laisser le clavier : c'est l'étudiant qui tape ; le tuteur parle et montre du doigt.
• Respecter l'intégrité : aider à comprendre, jamais faire le TP de quelqu'un d'autre ; renvoyer vers l'enseignant ce qui relève de l'évaluation.
• Encourager : un bug n'est pas un échec, c'est l'ordinaire de la programmation.

Le premier créneau d'Yanis, refait avec la méthode : « Qu'est-ce que tu attends pour somme_jusqua(4) ? — 10. — Et tu obtiens ? — 1. — Combien de tours fait ta boucle, à ton avis ? — Quatre. — Ajoute un print(i) dans la boucle et relance. » L'étudiant voit un seul 1. Silence. « Ah. Le return est dans la boucle. » Il le décale lui-même. C'est le bug de l'épisode 4 du Pro (Pro, épisode 4) : Yanis l'a reconnu ; l'étudiant, lui, l'a trouvé.