Réussir tes TP Python — 4 semaines pour rendre un TP d'analyse de données que tu comprends

La fonction : une tâche, un nom

Une fonction est un morceau de code auquel on donne un nom, pour s'en servir autant de fois qu'on veut. Tu en utilises déjà : print, input, round. Maintenant, tu écris les tiennes.

def cm_vers_mm(taille_cm):
    """Convertit une taille en centimètres en millimètres."""
    return taille_cm * 10


print(cm_vers_mm(2.5))
print(cm_vers_mm(12))

Affiche 25.0, puis 120.

• def définit la fonction : son nom, puis ses paramètres entre parenthèses, puis deux-points. Le corps est décalé de 4 espaces.
• La première ligne entre triples guillemets est la docstring : une phrase qui dit ce que fait la fonction.
• return renvoie une valeur à celui qui a appelé la fonction, et termine la fonction.
• cm_vers_mm(2.5) appelle la fonction : le paramètre taille_cm reçoit l'argument 2.5.
• Une fonction définie n'est exécutée que lorsqu'on l'appelle. On la nomme par un verbe ou une action (convertir, cm_vers_mm), en minuscules avec des _.

print ou return ? Ce n'est pas pareil :

def double_affiche(x):
    print(x * 2)


def double_renvoie(x):
    return x * 2


a = double_affiche(5)
b = double_renvoie(5)
print(a, b)

Affiche 10, puis None 10. double_affiche montre 10 à l'écran mais ne renvoie rien : sans return, une fonction renvoie None (« rien »). double_renvoie donne 10 au programme, qui peut le ranger, le calculer, le réutiliser. Dans un TP, les fonctions de calcul renvoient ; seul le programme principal affiche.

Une valeur par défaut.

def arrondir(valeur, chiffres=2):
    """Arrondit une valeur, à 2 chiffres après la virgule par défaut."""
    return round(valeur, chiffres)


print(arrondir(13.08333))
print(arrondir(13.08333, 1))

Affiche 13.08, puis 13.1. Si on ne donne pas chiffres, il vaut 2.

Où vivent les variables (la portée).

def calculer_total(a, b):
    total = a + b
    return total


resultat = calculer_total(3, 4)
print(resultat)
print(total)

Affiche 7, puis s'arrête : NameError: name 'total' is not defined. La variable total est locale : elle n'existe que pendant l'exécution de la fonction. Pour récupérer son contenu, on utilise ce que la fonction renvoie (resultat).

« Une tâche, une fonction, un test »

Rappel : définir une fonction, return (voir épisode 1).

1. Repérer les tâches dans le script : saisir une note valide, saisir un coefficient valide, choisir une mention.
2. Une fonction par tâche, nommée par une action, avec une docstring. Elle renvoie son résultat ; elle n'affiche que si c'est son rôle (une saisie).
3. Tester chaque fonction seule sur des cas connus. assert vérifie qu'une condition est vraie, et arrête le programme si elle est fausse.
4. Assembler : le programme principal enchaîne les appels.

def mention(moyenne):
    """Renvoie la mention correspondant à une moyenne sur 20."""
    if moyenne >= 16:
        return "Mention très bien"
    elif moyenne >= 14:
        return "Mention bien"
    elif moyenne >= 12:
        return "Mention assez bien"
    return "Pas de mention"


assert mention(16) == "Mention très bien"
assert mention(15.99) == "Mention bien"
assert mention(12) == "Mention assez bien"
assert mention(11.99) == "Pas de mention"
print("Tests de mention : OK")

Affiche Tests de mention : OK. On teste pile sur chaque seuil et juste en dessous. Chaque return termine la fonction : pas besoin d'else pour le dernier cas.

Si une vérification échoue, par exemple assert mention(14) == "Mention assez bien", Python s'arrête :

Soit la fonction est fausse, soit le test : ici, c'est le test (14 donne « bien »).

Le calculateur rangé (code à copier) :

def saisir_note():
    """Demande une note jusqu'à ce qu'elle soit entre 0 et 20, puis la renvoie."""
    note = float(input("  Note sur 20 (avec un point) : "))
    while note < 0 or note > 20:
        print("  Une note est comprise entre 0 et 20.")
        note = float(input("  Note sur 20 (avec un point) : "))
    return note


def saisir_coef():
    """Demande un coefficient jusqu'à ce qu'il soit positif, puis le renvoie."""
    coef = float(input("  Coefficient : "))
    while coef <= 0:
        print("  Un coefficient est un nombre positif.")
        coef = float(input("  Coefficient : "))
    return coef


def mention(moyenne):
    """Renvoie la mention correspondant à une moyenne sur 20."""
    if moyenne >= 16:
        return "Mention très bien"
    elif moyenne >= 14:
        return "Mention bien"
    elif moyenne >= 12:
        return "Mention assez bien"
    return "Pas de mention"


nb_matieres = int(input("Nombre de matières : "))
total = 0
somme_coefs = 0
for i in range(nb_matieres):
    print("Matière", i + 1)
    note = saisir_note()
    coef = saisir_coef()
    total = total + note * coef
    somme_coefs = somme_coefs + coef
moyenne = round(total / somme_coefs, 2)
print("Moyenne :", moyenne, "sur 20")
print(mention(moyenne))

Essai réel avec le cas de référence du Boost (12 coef 2, 15,5 coef 3, 8 coef 1) : Moyenne : 13.08 sur 20, puis Mention assez bien. Et avec une note de 25 puis 14, un coefficient de 0 puis 1 : les deux saisies refusées sont redemandées, puis Moyenne : 14.0 sur 20 et Mention bien.

Une fonction testée seule est une pièce sur laquelle on peut compter : si le calculateur se trompe, on sait que ce n'est pas mention. Le programme principal, lui, se lit comme une liste d'étapes : saisir, accumuler, calculer, afficher. Et le jour où le seuil d'une mention change, il y a un seul endroit à corriger.

Bon réflexe ou piège ?

Les chaînes de caractères et les f-strings

Une chaîne est une suite de caractères numérotés à partir de 0.

nom = " Lumière-Bleue "
print(len(nom))
propre = nom.strip().lower()
print(propre)
print(propre[0], propre[-5:], propre[:7])
print(propre.replace("-", " "))
print("bleue" in propre)
print(nom)

Affiche :

Une chaîne ne se modifie pas. La dernière ligne affiche toujours " Lumière-Bleue " : .strip() et .lower() fabriquent une nouvelle chaîne, qu'il faut ranger dans une variable (propre = …). Écrire nom.upper() seul ne change rien à nom.

La virgule décimale. Tu as vu au Boost que float("12,5") s'arrête sur une ValueError (voir Boost, épisode 5). Avec replace, tu peux la convertir : float("12,5".replace(",", ".")) donne 12.5.

Les f-strings. Une chaîne précédée de f remplace ce qui est entre accolades par sa valeur. Après :, on précise le format.

moyenne = 13.083333333333334
eclairage = "bleue"
print(f"Lumière {eclairage} : {moyenne:.2f} mm")
print(f"{'Éclairage':<10}{'Moyenne':>10}")
print(f"{'bleue':<10}{13.0833:>10.2f}")
print(f"{'rouge':<10}{9.5:>10.2f}")
print(f"{moyenne=}")

Affiche :

• :.2f : 2 chiffres après la virgule (un point, en Python) ;
• :<10 : aligné à gauche sur 10 caractères ; :>10 : à droite ; :>10.2f : les deux ;
• {moyenne=} affiche le nom et la valeur : très pratique pour déboguer (épisode 4).

round ou :.2f ? round(14.1, 2) renvoie le nombre 14.1 ; f"{14.1:.2f}" renvoie le texte "14.10". On calcule avec des nombres, et on formate seulement au moment d'afficher.

« Reproduire, afficher, réduire, corriger, retester »

Rappel : lire un message d'erreur en 3 questions (voir Boost, épisode 2). Ici, il n'y a pas de message : c'est un bug silencieux.

1. Reproduire avec un cas dont tu connais la réponse : mm_vers_cm(25) doit donner 2.5.
2. Afficher les valeurs intermédiaires avec un print de contrôle : print(f"CONTRÔLE {i=} {total=}").
3. Réduire : isoler la plus petite partie du code qui montre encore le bug (une seule fonction, un seul appel).
4. Suivre pas à pas avec un débogueur. Dans Thonny : Ctrl + F5 pour lancer en mode débogage, F6 pour un grand pas, F7 pour un petit pas, menu View → Variables pour voir les variables. VS Code a aussi un débogueur, avec des points d'arrêt.
5. Corriger une seule chose, puis retester tous les cas connus.

Trois bugs du TP (sorties réelles) :

def somme_jusqua(n):
    """Renvoie 1 + 2 + ... + n."""
    total = 0
    for i in range(1, n + 1):
        total = total + i
        return total


print(somme_jusqua(4))

Affiche 1. Avec un print(f"CONTRÔLE {i=} {total=}") dans la boucle, on ne voit qu'une ligne : CONTRÔLE i=1 total=1. La boucle ne fait qu'un tour : le return, décalé dans la boucle, termine la fonction dès le premier passage.

Les corrections : taille_mm / 10 ; int(code[1:]) (une tranche : tout après le J) ; return total décalé au niveau du for, après la boucle. Puis on vérifie tout :

assert mm_vers_cm(25) == 2.5
assert numero_jour("J7") == 7
assert numero_jour("J12") == 12
assert somme_jusqua(4) == 10
print("Les 3 fonctions corrigées passent leurs vérifications.")

Remarque : numero_jour("J7") donnait déjà 7 avec le bug. Un seul cas de test ne suffit pas : il faut aussi "J12".

Un bug silencieux, c'est un écart entre ce que tu crois que le programme fait et ce qu'il fait vraiment. Relire le code ne montre que ce que tu crois ; afficher les valeurs, ou les suivre au débogueur, montre ce qui se passe. Réduire le problème évite de chercher dans 200 lignes ce qui tient en 5. Et corriger une seule chose à la fois permet de savoir laquelle a réglé le problème.

Bon réflexe ou piège ?

« print de contrôle ou débogueur ? »

🎨 Carrousel récapitulatif — Semaine 1

La liste : plusieurs valeurs, un seul nom

Une liste range plusieurs valeurs dans l'ordre, entre crochets, séparées par des virgules. Comme une chaîne, elle est numérotée à partir de 0 ; contrairement à une chaîne, on peut la modifier.

mesures = [12.0, 14.5, 17.0, 19.5, 23.0]
print(mesures[0], mesures[-1], mesures[1:3], len(mesures))
print(sum(mesures), min(mesures), max(mesures))
print(sorted(mesures, reverse=True))
mesures.append(26.5)
mesures[0] = 12.5
print(mesures)

Affiche :

Parcourir une liste.

mesures = [12.0, 14.5, 17.0]
for mesure in mesures:
    print(mesure, "mm")
for i in range(len(mesures)):
    print("Jour", i + 1, ":", mesures[i], "mm")

La première boucle donne directement chaque valeur ; la deuxième donne les indices, utiles quand on a besoin de la position (le numéro du jour) ou de l'élément voisin. Par exemple, la croissance d'un jour à l'autre :

mesures = [12.0, 14.5, 17.0, 19.5, 23.0]
croissances = []
for i in range(1, len(mesures)):
    croissances.append(mesures[i] - mesures[i - 1])
print(croissances)

Affiche [2.5, 2.5, 2.5, 3.5]. La liste vide [] grandit à chaque tour avec append.

sorted ou .sort() ? sorted(mesures) renvoie une nouvelle liste triée et ne touche pas l'originale. mesures.sort() trie la liste elle-même et renvoie None : écrire triees = mesures.sort() range None dans triees.

Une liste passée à une fonction peut être modifiée par elle.

def ajouter_mesure(serie, valeur):
    """Ajoute une mesure à la fin de la série."""
    serie.append(valeur)


bleue = [12.0, 14.5]
ajouter_mesure(bleue, 17.0)
print(bleue)

Affiche [12.0, 14.5, 17.0]. La fonction reçoit la même liste, pas une copie. C'est différent d'un nombre (épisode 1) : append modifie la liste existante.

L'erreur classique : mesures[3] dans une liste de 3 éléments donne IndexError: list index out of range (« indice hors limites ») ; les indices vont de 0 à len(mesures) - 1.

« Une liste en entrée, une valeur en sortie »

Rappels : fonctions et return (voir épisode 1), vérifications avec assert (voir épisode 2), listes (voir épisode 6).

1. Décrire ce que renvoie la fonction, dans la docstring, y compris pour les cas limites.
2. Traiter les cas limites d'abord : liste vide, une seule valeur.
3. Ne pas modifier la liste reçue : on calcule, on ne trie pas en place, on n'ajoute rien.
4. Vérifier sur un cas calculé à la main, sur une liste d'un élément et sur une liste vide.

def resume(mesures):
    """Renvoie [effectif, moyenne, minimum, maximum, étendue] d'une série, ou None si elle est vide."""
    if len(mesures) == 0:
        return None
    effectif = len(mesures)
    moyenne = sum(mesures) / effectif
    minimum = min(mesures)
    maximum = max(mesures)
    return [effectif, moyenne, minimum, maximum, maximum - minimum]


print(resume([12, 14, 16]))
print(resume([5.0]))
print(resume([]))
assert resume([12, 14, 16]) == [3, 14.0, 12, 16, 4]
assert resume([]) is None
print("Vérifications : OK")

Sortie réelle :

Sans le test du début, une liste vide provoque ZeroDivisionError: division by zero (diviser par len([]), qui vaut 0), et max([]) s'arrête sur ValueError: max() iterable argument is empty. La fonction choisit de renvoyer None : à celui qui l'appelle de décider quoi faire d'une série vide. On teste None avec is None.

Cette fonction renvoie cinq valeurs dans une liste ; demain, tu verras une façon plus adaptée de renvoyer plusieurs valeurs : le tuple.

Les vraies données ont des trous : une plantule morte, un jour sans mesure, un fichier vide. Une fonction qui marche « sur l'exemple » mais s'arrête sur une série vide fera planter tout le TP le jour du rendu. En traitant les cas limites en premier et en les vérifiant, tu sais exactement ce que fait ta fonction dans tous les cas, et ton binôme aussi : c'est écrit dans la docstring.

Bon réflexe ou piège ?

Trois nouvelles structures

Le dictionnaire : des valeurs rangées sous des clés.

mesures = {
    "bleue": [12.0, 14.5, 17.0, 19.5, 23.0],
    "rouge": [11.0, 12.5, 13.0, 15.5, 16.0],
}
mesures["blanche"] = [12.5, 15.0, 18.5, 21.0, 25.0]
print(list(mesures))
print(mesures["rouge"][-1])
print("verte" in mesures, mesures.get("verte"))
for eclairage, serie in mesures.items():
    print(eclairage, len(serie), max(serie))

Affiche :

• Un dictionnaire associe des clés (ici les noms d'éclairage) à des valeurs (ici des listes). Les clés sont uniques.
• mesures["rouge"] lit une valeur ; mesures["blanche"] = … ajoute ou remplace.
• "verte" in mesures teste si une clé existe ; mesures.get("verte") renvoie None au lieu de s'arrêter. Lire une clé absente directement, mesures["verte"], provoque KeyError: 'verte'.
• .items() donne les paires (clé, valeur) dans une boucle ; les clés gardent l'ordre d'insertion.
• Un dictionnaire de listes range toutes les séries du TP sous un seul nom : ajouter un éclairage, c'est ajouter une clé.

Le tuple : des valeurs groupées qui ne changent pas.

def min_max(serie):
    """Renvoie le minimum et le maximum d'une série non vide."""
    return min(serie), max(serie)


bas, haut = min_max([12.0, 14.5, 17.0])
print(bas, haut)
resultat = min_max([11.0, 16.0])
print(resultat, type(resultat))
resultat[0] = 0

Affiche 12.0 17.0, puis (11.0, 16.0) <class 'tuple'>, puis s'arrête : TypeError: 'tuple' object does not support item assignment. Un tuple s'écrit entre parenthèses (ou simplement avec des virgules) ; on ne peut pas le modifier. C'est la façon habituelle de renvoyer plusieurs valeurs : return a, b renvoie un tuple, et bas, haut = … le déballe dans deux variables.

L'ensemble : des valeurs distinctes.

jours = ["J1", "J2", "J2", "J3", "J1"]
distincts = set(jours)
print(len(jours), len(distincts))
print("J4" in distincts)
print(sorted(distincts))
lot_a = {"bleue", "rouge"}
lot_b = {"rouge", "blanche"}
print(sorted(lot_a & lot_b), sorted(lot_a | lot_b))
print(type({}), type(set()))

Affiche :

Un ensemble (set) ne garde chaque valeur qu'une fois, et n'a pas d'ordre (on trie avec sorted pour l'afficher). & donne les éléments communs, | la réunion. Attention : {} crée un dictionnaire vide ; un ensemble vide s'écrit set().

« Relire comme si c'était le code d'un autre »

Rappels : docstrings et nommage des fonctions (voir épisode 1).

1. Des noms qui disent ce qu'ils contiennent : tailles_bleue plutôt que l2, moyenne_bleue plutôt que tmp. Fonctions nommées par une action.
2. Une docstring par fonction : ce qu'elle fait, ce qu'elle renvoie, ses cas limites.
3. Des commentaires qui expliquent pourquoi, pas ce que dit déjà le code (# on exclut le jour 0 : graines non germées, et non # on ajoute 1).
4. Des constantes en majuscules, en haut du fichier, pour les valeurs fixées : NB_DECIMALES = 1.
5. Les règles de la PEP 8, le guide de style officiel : 4 espaces par niveau ; lignes de 79 caractères au plus ; deux lignes vides avant et après chaque fonction ; noms de fonctions et de variables en minuscules avec des _ ; une espace autour de = et des opérateurs.
6. Vérifier que le résultat n'a pas changé : même sortie avant et après la réécriture.

Avant :

def f(l):
    t=0
    for x in l:t=t+x
    return t/len(l)
l2=[12.0,14.5,17.0,19.5,23.0]
tmp=f(l2)
print(round(tmp,1))

Après :

NB_DECIMALES = 1


def moyenne(mesures):
    """Renvoie la moyenne d'une série de mesures non vide."""
    total = 0
    for mesure in mesures:
        total = total + mesure
    return total / len(mesures)


tailles_bleue = [12.0, 14.5, 17.0, 19.5, 23.0]
moyenne_bleue = moyenne(tailles_bleue)
print(round(moyenne_bleue, NB_DECIMALES))

Les deux versions affichent 17.2 (sorties vérifiées). Le comportement est identique ; seule la lecture a changé.

Un code est lu bien plus souvent qu'il n'est écrit : par toi dans trois semaines, par ton binôme, par ton correcteur. Chaque nom clair épargne une question ; chaque docstring épargne une lecture ligne à ligne. Et des règles communes, comme celles de la PEP 8, font que tous les codes Python se ressemblent : on se concentre sur ce qu'ils font, pas sur leur présentation.

Bon réflexe ou piège ?

« Liste, dictionnaire, tuple ou ensemble ? »

🎨 Carrousel récapitulatif — Semaine 2

Les modules fournis avec Python

Python est livré avec une bibliothèque standard : des centaines de modules prêts à l'emploi. On les importe en haut du fichier.

import math
import statistics
from datetime import date

mesures = [12.0, 14.5, 17.0, 19.5, 23.0]
print(statistics.mean(mesures), statistics.median(mesures))
print(round(statistics.stdev(mesures), 2), round(statistics.pstdev(mesures), 2))
print(math.sqrt(16), round(math.pi, 4))
print(date(2026, 10, 30).strftime("%d/%m/%Y"))

Affiche :

Trois façons d'importer.

Quatre modules utiles en TP.

• math : sqrt (racine carrée), pi, log, exp…
• statistics : mean (moyenne), median (médiane), stdev (écart type d'un échantillon), pstdev (écart type d'une population entière).
• random : random(), randint(a, b), choice(liste) ; random.seed(42) fixe le point de départ du tirage, pour reproduire exactement les mêmes tirages (utile pour un TP qu'on doit pouvoir relancer).
• datetime : date.today() (la date du jour), strftime("%d/%m/%Y") pour l'écrire à la française.

Le mystère de Yanis. Sa fonction divisait la somme des carrés des écarts par l'effectif n : c'est l'écart type de population (pstdev, 3,83). Le sujet demande celui d'un échantillon (stdev, 4,28), qui divise par n − 1. Les deux formules existent ; le module les nomme clairement, et sa documentation dit laquelle est laquelle.

Rappel : ne nomme jamais un de tes fichiers comme un module (statistics.py, random.py) : import chargerait ton fichier à la place du vrai module.

« Chercher, lire la fiche, essayer l'exemple, adapter »

Rappel : importer un module (voir épisode 11).

1. Chercher dans la documentation officielle, en français : docs.python.org/fr, rubrique « Référence de la bibliothèque », puis le module. Choisis ta version de Python dans le menu en haut de la page.
2. Lire la fiche d'une fonction : son nom et ses paramètres (stdev(data, xbar=None)), ce qu'elle renvoie, ses cas limites (« au moins deux valeurs », exceptions).
3. Essayer l'exemple tel quel, dans la console, avant de l'adapter.
4. Adapter à tes données, puis vérifier sur un cas connu.
5. Dans la console, help(statistics.stdev) affiche la documentation de la fonction ; statistics.stdev.__doc__ aussi.

Exemple réel : print(statistics.stdev.__doc__.splitlines()[0]) affiche Return the square root of the sample variance. (« Renvoie la racine carrée de la variance d'échantillon. ») : la confirmation que stdev est bien l'écart type d'échantillon.

Quelques formats de date (strftime) : %d jour, %m mois, %Y année sur 4 chiffres, %H:%M heures et minutes. date(2026, 10, 30).strftime("%d/%m/%Y") donne 30/10/2026.

La documentation officielle correspond exactement à ta version de Python : elle ne peut pas proposer une fonction qui n'existe pas, ni une formule ancienne. Les réponses de forums sont utiles pour des idées, mais elles datent, se contredisent, et répondent souvent à une autre question. Essayer l'exemple tel quel, avant de l'adapter, sépare deux problèmes : « la fonction marche-t-elle ? » et « l'ai-je bien utilisée ? ».

Bon réflexe ou piège ?

Les fichiers

Le fichier du TP (15 lignes de mesures, données inventées) commence ainsi :

Un CSV (comma-separated values) est un tableau écrit en texte, une ligne par enregistrement. Les tableurs réglés en français séparent les colonnes par des points-virgules, parce que la virgule sert de séparateur décimal.

1. Le chemin : pathlib.

from pathlib import Path

DOSSIER = Path(__file__).parent
chemin = DOSSIER / "croissance.csv"
print(chemin.name, chemin.exists())

Affiche croissance.csv True. Path(__file__).parent est le dossier du script ; l'opérateur / assemble les morceaux d'un chemin, sous Windows comme sous macOS ou Linux. (__file__ n'existe pas dans une console ou un notebook : on écrit alors Path("croissance.csv"), relatif au dossier de travail.)

2. Lire un CSV avec csv.DictReader.

import csv

mesures = {}
with open(chemin, encoding="utf-8") as fichier:
    lecteur = csv.DictReader(fichier, delimiter=";")
    for ligne in lecteur:
        eclairage = ligne["eclairage"]
        taille = float(ligne["taille_mm"].replace(",", "."))
        if eclairage not in mesures:
            mesures[eclairage] = []
        mesures[eclairage].append(taille)
print(mesures)

Affiche le dictionnaire de listes de la semaine 2 : {'bleue': [12.0, 14.5, 17.0, 19.5, 23.0], 'rouge': [11.0, 12.5, 13.0, 15.5, 16.0], 'blanche': [12.5, 15.0, 18.5, 21.0, 25.0]}.

• with open(…) as fichier: ouvre le fichier et le referme automatiquement à la fin du bloc, même en cas d'erreur.
• encoding="utf-8" précise l'encodage (la façon dont les caractères, accents compris, sont écrits en octets). Depuis Python 3.15, UTF-8 est l'encodage par défaut ; l'écrire reste utile, car beaucoup d'ordinateurs ont encore une version plus ancienne.
• DictReader lit la première ligne comme en-tête : chaque ligne devient un dictionnaire (ligne["taille_mm"]). Tout est lu comme texte : on convertit, après avoir remplacé la virgule décimale.
• csv.reader (sans Dict) donne des listes : ['jour', 'eclairage', 'taille_mm'], puis ['J1', 'bleue', '12,0'].
• Avec le mauvais séparateur (delimiter=","), on obtient ['J1;bleue;12', '0'] : la ligne est coupée à la virgule décimale.

3. Écrire et relire un JSON. Le JSON est un format texte pour des données structurées (dictionnaires, listes, nombres, textes), lisible par presque tous les langages.

import json

resume = {"bleue": {"n": 5, "moyenne": 17.2}, "rouge": {"n": 5, "moyenne": 13.6}}
with open(DOSSIER / "resume_essai.json", "w", encoding="utf-8") as fichier:
    json.dump(resume, fichier, ensure_ascii=False, indent=2)
with open(DOSSIER / "resume_essai.json", encoding="utf-8") as fichier:
    relu = json.load(fichier)
print(relu["rouge"]["moyenne"], relu == resume)

Affiche 13.6 True. Le mode "w" (write) crée le fichier, ou l'écrase s'il existe ; indent=2 le rend lisible ; ensure_ascii=False garde les accents tels quels.

4. Si le fichier n'existe pas : open(Path("croissanse.csv")) (une faute de frappe) s'arrête sur FileNotFoundError: [Errno 2] No such file or directory: 'croissanse.csv'. chemin.exists() permet de vérifier avant.

« Un projet, un environnement »

Un paquet est une bibliothèque qu'on installe depuis PyPI, l'index officiel des paquets Python, avec l'outil pip. Un environnement virtuel est un dossier qui contient un Python et des paquets propres à un projet.

1. Créer l'environnement, dans le dossier du TP : python -m venv .venv (sous Windows, py -m venv .venv fonctionne aussi).
2. L'activer :

Le nom de l'environnement s'affiche alors devant l'invite. deactivate en sort.

1. Installer dans l'environnement actif : python -m pip install pandas matplotlib. Vérifie le nom exact du paquet sur pypi.org avant d'installer.
2. Lister et décrire : python -m pip list montre ce qui est installé ; python -m pip freeze > requirements.txt écrit la liste exacte des versions dans un fichier.
3. Réinstaller ailleurs (chez ton binôme, sur l'ordinateur de l'enseignante) : créer un environnement, l'activer, puis python -m pip install -r requirements.txt.

Le requirements.txt réel obtenu le 30/10/2026 après python -m pip install pandas matplotlib (Python 3.15) :

Deux paquets demandés, treize installés : pandas et matplotlib s'appuient sur d'autres paquets (les dépendances), installés automatiquement.

Dans Thonny : menu Outils → Gérer les paquets (Tools → Manage packages) pour chercher et installer un paquet sans ligne de commande.

Sans rien installer : Basthon fournit déjà numpy, pandas et matplotlib dans le navigateur, et permet d'importer un fichier CSV. Capytale peut aussi les proposer, selon l'activité créée par ton professeur.

Chaque projet garde ses propres versions : le TP de biologie peut utiliser pandas 3.1 sans gêner un autre projet. Casser un environnement ne casse ni Python ni le reste de l'ordinateur : on supprime le dossier .venv et on le recrée à partir de requirements.txt. Et ce fichier permet à ton enseignante de reproduire exactement ton environnement pour relancer ton TP.

Bon réflexe ou piège ?

« Bibliothèque standard ou paquet à installer ? »

🎨 Carrousel récapitulatif — Semaine 3

pandas et matplotlib

pandas range des données dans un DataFrame : un tableau avec des lignes numérotées (l'index) et des colonnes nommées, chacune avec son type. matplotlib trace des graphiques. Les deux sont installés dans l'environnement du TP (épisode 14).

Lire le CSV du TP.

import pandas as pd

df = pd.read_csv("croissance.csv", sep=";", decimal=",")
print(df.shape)
print(df.head(4))
print(df.dtypes)

Affiche :

sep=";" donne le séparateur, decimal="," la virgule décimale : taille_mm est directement un nombre à virgule (float64), sans replace (comparer avec épisode 13). shape donne (lignes, colonnes) ; head(4) les 4 premières lignes. pd est l'alias habituel de pandas (voir épisode 11). Depuis pandas 3.0, les colonnes de texte ont le type str ; dans une version plus ancienne, tu verras object.

Sélectionner et filtrer.

print(df["taille_mm"].max())
rouge = df[df["eclairage"] == "rouge"]
print(rouge)
print(df[df["taille_mm"] > 20])

Affiche :

df["taille_mm"] est une colonne ; df[["jour", "taille_mm"]] (doubles crochets) en garde plusieurs. df[condition] garde les lignes où la condition est vraie : c'est un filtre. Les lignes gardent leur numéro d'origine.

Grouper et résumer.

moyennes = df.groupby("eclairage")["taille_mm"].mean()
print(moyennes)
print(df.groupby("eclairage", sort=False)["taille_mm"].describe().round(2))

Affiche :

groupby découpe le tableau par éclairage, applique le calcul à chaque groupe, puis rassemble les résultats. Par défaut, les groupes sont triés par ordre alphabétique ; sort=False garde l'ordre du fichier. describe donne l'effectif, la moyenne, l'écart type (std, d'échantillon : les mêmes 4,28 qu'avec statistics.stdev), le minimum, les quartiles (25 %, 50 % = la médiane, 75 %) et le maximum. Tu retrouves exactement le résumé de la semaine 3 : c'est ton cas connu pour vérifier pandas.

Tracer une courbe.

import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv("croissance.csv", sep=";", decimal=",")
for eclairage, groupe in df.groupby("eclairage", sort=False):
    plt.plot(groupe["jour"], groupe["taille_mm"], marker="o", label=eclairage)
plt.title("Croissance des plantules selon l'éclairage")
plt.xlabel("Jour de mesure")
plt.ylabel("Taille (mm)")
plt.legend()
plt.savefig("croissance.png")
print("Figure enregistrée : croissance.png")

Affiche Figure enregistrée : croissance.png, et le fichier image apparaît dans le dossier. Parcourir un groupby donne des couples (nom du groupe, sous-tableau). plt.plot(x, y) trace une courbe ; plt.bar(x, hauteurs) un diagramme en barres ; label + plt.legend() affichent la légende ; plt.savefig enregistre l'image (plt.show() l'afficherait dans une fenêtre).

Lire un graphique d'un œil critique. Avant de croire un graphique : de quoi parle-t-il (titre) ? Quelles grandeurs et quelles unités (axes) ? Où commence l'axe vertical ? Les courbes ou les barres sont-elles identifiées (légende) ? Demain, tu appliques ces questions à tes propres figures.

Autres outils. Polars est une autre bibliothèque de tableaux de données ; les notebooks (Jupyter) mélangent code, résultats et texte. Ce livre s'en tient à pandas et à des scripts.

« Une question, une figure »

1. Écrire la question à laquelle la figure répond, en une phrase. Elle deviendra le titre, ou presque.
2. Choisir le type : une évolution dans le temps → une courbe ; une comparaison entre catégories → des barres ; jamais un camembert pour une évolution.
3. Étiqueter : un titre, chaque axe avec sa grandeur et son unité, une légende dès qu'il y a plusieurs séries, une couleur par série.
4. Vérifier l'échelle : un diagramme en barres part de zéro (plt.ylim(0, …)), sinon les différences paraissent plus grandes qu'elles ne sont. Une courbe peut ne pas partir de zéro, si l'axe est bien gradué.
5. Enregistrer dans un dossier figures/, en PNG, avec une résolution suffisante (dpi=200) et sans marges inutiles (bbox_inches="tight"). plt.figure() commence une nouvelle figure, plt.close() la ferme.

La figure fautive de Yanis (le code qui l'a produite) :

import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv("croissance.csv", sep=";", decimal=",")
finales = df[df["jour"] == "J5"]
plt.bar(finales["eclairage"], finales["taille_mm"])
plt.ylim(15, 26)
plt.savefig("mauvais.png")
print("rouge / blanche, vraies tailles :", round(16.0 / 25.0, 2))

Affiche rouge / blanche, vraies tailles : 0.64. Sur l'image, la barre rouge ne monte que de 1 mm au-dessus du bas de l'axe, contre 10 mm pour la blanche : elle paraît dix fois plus petite.

Les deux figures du TP — figures_tp.py, dans le dossier du TP :

"""Trace les deux figures du compte rendu dans le dossier figures/."""

from pathlib import Path

import matplotlib.pyplot as plt
import pandas as pd

DOSSIER = Path(__file__).parent
FIGURES = DOSSIER / "figures"
FIGURES.mkdir(exist_ok=True)
COULEURS = {"bleue": "tab:blue", "rouge": "tab:red", "blanche": "tab:gray"}

df = pd.read_csv(DOSSIER / "croissance.csv", sep=";", decimal=",")

# Figure 1 — Question : comment la taille évolue-t-elle, jour après jour, sous chaque éclairage ?
plt.figure()
for eclairage, groupe in df.groupby("eclairage", sort=False):
    plt.plot(groupe["jour"], groupe["taille_mm"], marker="o",
             color=COULEURS[eclairage], label=f"lumière {eclairage}")
plt.title("Croissance des plantules selon l'éclairage (J1 à J5)")
plt.xlabel("Jour de mesure")
plt.ylabel("Taille (mm)")
plt.legend()
plt.savefig(FIGURES / "evolution.png", dpi=200, bbox_inches="tight")
plt.close()

# Figure 2 — Question : quel éclairage donne les plus grandes plantules au jour 5 ?
finales = df[df["jour"] == "J5"]
plt.figure()
plt.bar(finales["eclairage"], finales["taille_mm"],
        color=[COULEURS[e] for e in finales["eclairage"]])
plt.title("Taille des plantules au jour 5, par éclairage")
plt.xlabel("Éclairage")
plt.ylabel("Taille au jour 5 (mm)")
plt.ylim(0, 30)
plt.savefig(FIGURES / "taille_j5.png", dpi=200, bbox_inches="tight")
plt.close()

print(finales)
for fichier in sorted(FIGURES.iterdir()):
    print("Enregistrée :", fichier.name)

Sortie réelle :

Les couleurs reprennent celles des éclairages (gris pour le blanc, qui serait invisible sur fond blanc). FIGURES.mkdir(exist_ok=True) crée le dossier s'il n'existe pas encore ; iterdir() en parcourt le contenu. Le tableau affiché sert de cas connu : les hauteurs des barres doivent être 23, 16 et 25.

Une figure qui part d'une question se lit en quelques secondes : le titre dit ce qu'elle montre, les axes disent avec quelles grandeurs, la légende dit qui est qui. L'axe à zéro pour les barres protège ton lecteur… et ta conclusion : la longueur d'une barre est proportionnelle à la valeur. Enregistrer par le code, dans figures/, permet de régénérer toutes les figures en une commande quand une mesure change.

Bon réflexe ou piège ?

Git, dépôts et commits

Git est un logiciel de gestion de versions : il garde l'historique de tes fichiers. Un dépôt est un dossier suivi par Git (il contient un dossier caché .git). Un commit est une photo de tes fichiers à un instant, avec un message qui dit ce qui a changé. Git s'installe depuis son site officiel (git-scm.com) ; dans Thonny ou VS Code, il s'utilise aussi depuis le terminal.

Le cycle en trois zones. Tu modifies un fichier dans ton dossier de travail ; git add le place dans l'index (ce qui partira dans le prochain commit) ; git commit enregistre la photo dans l'historique.

La démonstration réelle (dossier du TP, identité inventée) :

git init crée le dépôt (-b main nomme la ligne principale de l'historique main, comme sur les services en ligne). git config donne le nom et l'adresse inscrits dans chaque commit : sur un dépôt public, tout le monde les voit ; choisis ce que tu acceptes de montrer. git status dit où en est chaque fichier : ici, tous sont « non suivis » (untracked). Selon la langue de ton système, Git peut afficher ces messages en français.

Ce qu'on ne versionne pas : .gitignore. Un fichier texte .gitignore liste ce que Git doit ignorer :

L'environnement virtuel se recrée avec requirements.txt (épisode 14) ; __pycache__ est fabriqué par Python. Jamais de mot de passe, de clé, ni de données personnelles dans un dépôt : même effacés plus tard, ils restent dans l'historique.

?? = non suivi ; A = ajouté à l'index ; .venv/ et __pycache__/ ont disparu de la liste. 8079c3c est le début de l'identifiant du commit ; chez toi, il sera différent.

Voir ce qui a changé, puis l'historique. Yanis modifie la dernière ligne de son script :

M = modifié ; git diff montre les lignes retirées (-) et ajoutées (+) depuis le dernier commit ; git log liste les commits, du plus récent au plus ancien (git log -1 détaille le dernier : auteur, date, message).

Un bon message de commit dit ce que fait le changement, en une phrase courte : « Corrige l'écart type (stdev au lieu de pstdev) » plutôt que « modif » ou « ça marche enfin ». Un commit = un changement qui a un sens, testé.

Le dépôt distant. Un dépôt distant est une copie de ton dépôt sur un service en ligne : GitHub, GitLab ou Codeberg, par exemple. Git n'est pas GitHub : Git est le logiciel, sur ton ordinateur ; ces services hébergent des dépôts. Démonstration réelle, avec un dépôt distant simulé dans un dossier voisin (sur un service, tu remplaces ../distant.git par l'adresse donnée par le service) :

git remote add enregistre l'adresse du dépôt distant sous le nom origin ; git push y envoie tes commits ; git clone crée une copie complète, avec tout l'historique : c'est ce que fera ton enseignante. Ensuite, après chaque commit, un simple git push suffit. La première fois, le service te demande de te connecter : suis sa page d'aide.

Avant de créer un compte. GitHub demande d'avoir au moins 13 ans (et plus si la loi de ton pays l'exige) ; les conditions d'utilisation de Codeberg ne fixent pas d'âge minimum ; lis celles de GitLab avant de t'inscrire. Si tu es mineur, crée ton compte avec un adulte ; ton enseignant ou ton établissement peut aussi te fournir un espace. Choisis un dépôt privé tant que ton TP n'est pas rendu, sauf consigne contraire : un dépôt public est visible de tous, copie comprise.

« Avant, demander, relire, tester, déclarer »

1. Avant : vérifie que tu as le droit. Les règles de ton cours d'abord : l'IA est-elle autorisée pour ce TP, et pour quoi faire ? Les conditions d'âge du service ensuite :

Tu n'as pas l'âge requis, ou pas l'accord nécessaire ? Fais l'exercice avec la réponse d'assistant fournie ci-dessous : la méthode est la même. Au lycée, on ne doit pas te demander de créer un compte personnel sur un service d'IA grand public.

1. Demander : le contexte (Python, pandas, ton fichier), le but, les contraintes (« ne modifie pas le fichier de mesures »), un exemple d'entrée et de sortie attendue. Jamais de données personnelles, ni de sujet d'examen confidentiel, ni ton code entier si une fonction suffit. Demander une explication (« pourquoi ma barre est-elle décalée ? ») apprend plus que demander la solution.
2. Relire : chaque ligne doit être comprise ; chasse ce que tu n'as pas demandé, surtout ce qui écrit, supprime ou envoie quelque chose (un fichier, Internet). Une ligne inconnue ? Cherche-la dans la documentation (épisode 12), ou ne la garde pas.
3. Tester : sur un cas connu (les hauteurs 23, 16, 25), sur une copie des données, et vérifie que rien d'autre n'a changé.
4. Déclarer : ce que tu as demandé, ce que tu as gardé, ce que tu as modifié.

La réponse d'assistant fournie par le livre (inventée pour l'exercice, typique de ce qu'on obtient) :

import pandas as pd
import matplotlib.pyplot as plt


def tracer_barres(fichier):
    df = pd.read_csv(fichier, sep=";", decimal=",")
    df = df.dropna()
    df.to_csv(fichier, index=False)
    finales = df[df["jour"] == "J5"]
    plt.bar(finales["eclairage"], finales["taille_mm"])
    plt.savefig("barres.png")


tracer_barres("croissance.csv")

Lancée sur une copie du dossier, elle n'affiche rien, produit une belle figure… et réécrit le fichier de mesures. Avant, puis après :

Le script de la semaine 3 s'arrête alors :

À la relecture : df.to_csv(fichier, index=False) écrit dans le fichier de mesures, avec la virgule comme séparateur ; personne ne l'a demandé. dropna() supprime les lignes incomplètes (NA : valeur manquante) sans le dire. Il manque aussi le titre, les axes, les unités, la docstring.

La version relue, corrigée et testée :

from pathlib import Path

import matplotlib.pyplot as plt
import pandas as pd


def tracer_barres(fichier, image):
    """Trace la taille au jour 5 par éclairage et l'enregistre ; ne modifie pas le fichier de mesures."""
    df = pd.read_csv(fichier, sep=";", decimal=",")
    finales = df[df["jour"] == "J5"]
    plt.figure()
    plt.bar(finales["eclairage"], finales["taille_mm"])
    plt.title("Taille des plantules au jour 5, par éclairage")
    plt.xlabel("Éclairage")
    plt.ylabel("Taille au jour 5 (mm)")
    plt.ylim(0, 30)
    plt.savefig(image, dpi=200, bbox_inches="tight")
    plt.close()
    return list(finales["taille_mm"])


avant = Path("croissance.csv").read_text(encoding="utf-8")
hauteurs = tracer_barres("croissance.csv", "barres.png")
print(hauteurs)
assert hauteurs == [23.0, 16.0, 25.0]
assert Path("croissance.csv").read_text(encoding="utf-8") == avant
print("Tests : hauteurs justes, fichier de mesures intact")

Sortie réelle :

La fonction renvoie les hauteurs tracées : on peut les tester. Le second test vérifie que le fichier n'a pas changé (read_text lit tout le fichier d'un coup).

La déclaration d'aide, à mettre dans le compte rendu, sous forme de tableau :

La règle d'or du Boost reste vraie : un code que tu ne comprends pas, tu ne le lances pas, et tu ne le rends pas. Un assistant d'IA écrit un code plausible, pas un code vérifié : il peut ajouter ce que tu n'as pas demandé, ou se tromper avec assurance. Relire et tester font de toi l'auteur responsable de ce que tu rends. Et la déclaration protège ton intégrité : dans de nombreux établissements, utiliser une IA sans autorisation ni déclaration pour un travail noté est considéré comme une fraude.

Bon réflexe ou piège ?