Modules, fichiers et données

math.floor(-2.5) vaut $-3$ : le plancher descend, même pour les négatifs. round(2.5) vaut $2$ et round(3.5) vaut $4$ : Python arrondit les demi-entiers au pair le plus proche (arrondi du banquier), pas systématiquement au-dessus — c'est précisément l'ambiguïté de l'exercice 4 du chapitre 1, tranchée autrement que ce qu'on attend ! random.randint(0, 1) renvoie $0$ ou $1$ : les deux bornes sont incluses, contrairement à range. "3" 2 vaut "33" : répétition de chaîne, pas multiplication. (Cinq fonctions, trois surprises : la documentation et l'essai en console ne sont pas optionnels.)*

def nb_donnees(nom_fichier: str) -> int:
    c = 0
    with open(nom_fichier, "r") as f:
        for ligne in f:
            ligne = ligne.strip()
            if ligne != "" and not ligne.startswith("#"):
                c += 1
    return c

L'ordre des deux tests compte : ligne.startswith("#") sur la ligne déjà débarrassée de ses blancs traite aussi les commentaires indentés. Coût : un parcours du fichier, $O(n)$ lignes. (Le motif « filtrer puis compter » est le squelette de la plupart des lectures de fichiers ; les lignes de commentaire en tête de fichier sont une convention très répandue dans les données scientifiques.)

import random
random.seed(0)

def au_moins_un_six() -> bool:
    for _ in range(4):
        if random.randint(1, 6) == 6:
            return True
    return False

n = 100_000
succes = sum(1 for _ in range(n) if au_moins_un_six())
frequence = succes / n
exacte = 1 - (5 / 6) ** 4          # 0.5177...
print(frequence, exacte)            # par exemple 0.5181 contre 0.5177
assert abs(frequence - exacte) < 0.01

La fréquence observée approche la probabilité exacte à mieux que $10^{-2}$ — la loi des grands nombres, rencontrée ici expérimentalement avant d'être un théorème du cours de mathématiques. La graine figée rend le test reproductible : sans elle, l'assertion pourrait (très rarement) échouer par pur hasard. (La simulation est l'outil de contrôle des probabilités : quand le calcul exact est hors de portée, elle donne l'ordre de grandeur ; quand il est connu, elle le vérifie.)

def lire_releves_robuste(nom_fichier: str) -> tuple:
    releves, ignorees = [], 0
    with open(nom_fichier, "r") as f:
        for ligne in f:
            ligne = ligne.strip()
            if ligne == "":
                continue
            champs = ligne.split(";")
            if len(champs) != 2 or champs[1] == "NA":
                ignorees += 1
                continue
            releves.append((champs[0], float(champs[1])))
    return (releves, ignorees)

Compter les rejets est une exigence de validation : si $40\%$ des lignes sont écartées, la moyenne calculée sur le reste ne décrit plus la série — et sans le compteur, personne ne le saurait. Un programme qui ignore silencieusement des données produit des résultats faux avec l'air d'être justes : c'est l'erreur de logique du chapitre 1, version données. (Le test len(champs) != 2 attrape au passage les lignes mal formées — une robustesse qui ne coûte qu'une ligne.)

def variance_un_passage(t: list) -> float:
    """Précondition : t non vide."""
    s, s2 = 0.0, 0.0
    for x in t:
        s += x
        s2 += x * x
    n = len(t)
    return s2 / n - (s / n) ** 2

t = [2, 4, 6, 8]
assert abs(variance_un_passage(t) - ecart_type(t) ** 2) < 1e-12

Un seul parcours au lieu de deux — précieux si les données arrivent en flux et ne tiennent pas en mémoire. Le talon d'Achille : quand la moyenne est grande devant l'écart-type (mesures autour de $10^8$ à $\pm 1$), $\overline{x^2}$ et ${\bar{x}}^2$ sont deux nombres immenses et presque égaux ; leur différence perd presque tous ses chiffres significatifs (annulation catastrophique), au point de pouvoir sortir négative. La version en deux passages, qui soustrait la moyenne avant d'élever au carré, n'a pas ce défaut. (Deux formules mathématiquement égales ne sont pas numériquement équivalentes — première rencontre avec une réalité du calcul flottant qui reviendra souvent.)

La classe d'une valeur $x$ s'obtient sans boucle, par une division :

def histogramme(t: list, a: float, b: float, k: int) -> list:
    """Effectifs des k classes [a + i*h, a + (i+1)*h[, h = (b-a)/k.
    Les valeurs hors de [a, b[ sont ignorées. Précondition : a < b, k >= 1."""
    effectifs = [0] * k
    h = (b - a) / k
    for x in t:
        if a <= x < b:
            i = int((x - a) // h)
            if i == k:            # garde-fou flottant (x très proche de b)
                i = k - 1
            effectifs[i] += 1
    return effectifs

assert histogramme([1, 2, 2, 7, 9], 0, 10, 5) == [1, 2, 0, 1, 1]
assert histogramme([10], 0, 10, 5) == [0, 0, 0, 0, 0]    # b est EXCLU

Une valeur frontière entre deux classes ($x=a+ih$ exactement) tombe dans la classe de droite — conséquence directe du // — et la spécification le dit. Le garde-fou sur $i=k$ pare aux arrondis flottants quand $x$ frôle $b$. Coût : $O(n+k)$. (Calculer l'indice de classe par division plutôt qu'en testant les $k$ classes une à une : c'est le passage de $O(nk)$ à $O(n+k)$ — le réflexe d'accès direct du chapitre 2, version numérique.)

On accumule par clé le couple (somme, effectif) — jamais la liste complète des montants, inutilement coûteuse :

def moyennes_par_produit(nom_fichier: str) -> dict:
    sommes, effectifs = {}, {}
    with open(nom_fichier, "r") as f:
        for ligne in f:
            ligne = ligne.strip()
            if ligne == "":
                continue
            produit, montant = ligne.split(";")
            sommes[produit] = sommes.get(produit, 0.0) + float(montant)
            effectifs[produit] = effectifs.get(produit, 0) + 1
    return {p: sommes[p] / effectifs[p] for p in sommes}

moyennes = moyennes_par_produit("ventes.csv")
classement = sorted(moyennes, key=lambda p: moyennes[p], reverse=True)
for p in classement:
    print(p, round(moyennes[p], 2))

Coût : un parcours du fichier en $O(n)$, puis un tri des $k$ produits en $O(k\log k)$ — avec $k$ en général très inférieur à $n$. (L'idiome sorted(d, key=...), avec sa fonction lambda — hors annexe du programme, fourni avec sa documentation —, trie les clés d'un dictionnaire selon un critère calculé : avec reverse=True, le classement tombe en une ligne. La double accumulation somme/effectif est la version « flux » de la moyenne — exactement l'exercice 24 du chapitre 2, ici branché sur un vrai fichier.)

La probabilité qu'un point uniforme du carré tombe dans le quart de disque est le rapport des aires : $\frac{\pi /4}{1}=\frac{\pi }{4}$. La fréquence observée $f_n$ estime donc $\pi /4$, et $4f_n$ estime $\pi$ :

import random
random.seed(2)

def estime_pi(n: int) -> float:
    dans_le_disque = 0
    for _ in range(n):
        x, y = random.random(), random.random()
        if x * x + y * y <= 1:
            dans_le_disque += 1
    return 4 * dans_le_disque / n

import math
for n in (100, 10_000, 1_000_000):
    e = estime_pi(n)
    print(n, e, abs(e - math.pi))
# erreurs typiques :  0.1 ;  0.01 ;  0.001

L'erreur observée est divisée par $\sim 10$ quand $n$ est multiplié par $100$ : elle décroît comme $1/\sqrt{n}$ — c'est la signature des méthodes de Monte-Carlo, que le cours de probabilités justifiera (écart-type d'une moyenne empirique). Conséquence pratique : chaque décimale supplémentaire de $\pi$ coûte cent fois plus de tirages — Monte-Carlo est robuste et simple, mais lentement convergent. (Retenir le trio : justification de l'estimateur par un argument d'aires, graine figée pour la reproductibilité, étude expérimentale de l'erreur en fonction de $n$.)

import matplotlib.pyplot as plt

def rapport_stations(nom_fichier: str) -> dict:
    """Renvoie {station: (nb, moyenne, maximum)}.
    Précondition : chaque ligne non vide contient au moins une mesure."""
    rapport = {}
    with open(nom_fichier, "r") as f:
        for ligne in f:
            ligne = ligne.strip()
            if ligne == "":
                continue
            champs = ligne.split(";")
            nom = champs[0]
            mesures = [float(c) for c in champs[1:]]
            rapport[nom] = (len(mesures),
                            sum(mesures) / len(mesures),
                            max(mesures))
    return rapport

rapport = rapport_stations("stations.csv")
noms = list(rapport)
plt.bar(noms, [rapport[n][1] for n in noms])
plt.ylabel("température moyenne")
plt.title("Moyenne par station")
plt.show()

La compréhension [float(c) for c in champs[1:]] convertit toutes les mesures d'un coup — la tranche champs[1:] écarte le nom. La précondition « au moins une mesure » protège la division et le max ; une version robuste compterait les stations sans mesure comme l'exercice 4 comptait ses rejets. (Format à largeur variable : on ne code jamais « la colonne 3 » en dur, on découpe puis on raisonne sur ce qui reste — le programme survit alors aux fichiers réels.)

def controle(t: list) -> None:
    """Auto-contrôle des statistiques. Précondition : t non vide."""
    mini, maxi = min(t), max(t)
    m, s, med = moyenne(t), ecart_type(t), mediane(t)
    assert mini <= med <= maxi, "médiane hors bornes"
    assert mini <= m <= maxi, "moyenne hors bornes"
    assert s >= 0, "écart-type négatif"
    constantes = all(x == t[0] for x in t)
    assert (s == 0) == constantes, "écart-type nul incohérent"

La forme assert condition, message (hors annexe du programme, fournie avec sa documentation) nomme la garde qui échoue. Ce que chaque garde attrape : une médiane hors bornes trahit un tri oublié ou un mauvais indice central ; une moyenne hors bornes signale presque toujours une erreur de lecture (une chaîne non convertie, un séparateur décimal « virgule » lu comme deux champs) ; un écart-type négatif est impossible en deux passages mais peut sortir de la formule en un passage par annulation catastrophique (exercice 5) — ce garde-fou détecte donc un problème numérique ; enfin l'équivalence $\sigma =0⟺$ série constante attrape les données dupliquées par une boucle de lecture défectueuse. (Ces propriétés sont des invariants mathématiques de la spécification, pas des choix d'implémentation : elles valent pour toute chaîne de traitement correcte, et leur coût — quelques parcours linéaires — est négligeable. Instrumenter ainsi un programme de données est la traduction concrète de la compétence « justifier et critiquer une solution ».)