Python : modules, fichiers et tests

1) import capteur exécute le fichier du module, puis définit un seul nom dans le programme : capteur, qui désigne le module. Ses deux fonctions s'atteignent comme des attributs, capteur.lire_serie et capteur.moyenne_glissante. La ligne d'appel est donc correcte, et serie reçoit la liste des mesures du fichier serie.txt.
2) from capteur import moyenne_glissante exécute le même fichier, mais ne définit qu'un nom : moyenne_glissante. Le nom capteur reste inconnu du programme, et l'appel lève

NameError: name 'capteur' is not defined

La ligne correcte est lisse = moyenne_glissante(serie, 3), sans préfixe.
3) import capteur as cp définit un seul nom, cp. Le module a bien été chargé, mais il ne s'appelle pas capteur dans ce programme : l'appel lève la même NameError qu'au 2). La ligne correcte est serie = cp.lire_serie("serie.txt").
4) from capteur import lire_serie as lire définit un seul nom, lire. L'appel serie = lire("serie.txt") est donc correct. En revanche moyenne_glissante n'a jamais été importée, et la ligne suivante lève

NameError: name 'moyenne_glissante' is not defined

Une importation ne donne accès qu'aux noms qu'elle nomme : ni from ... import ni as ne rendent disponible le nom du module.
5) La forme par défaut est import module, qui garde le préfixe sur chaque appel. Les importations occupent les premières lignes du fichier, une par ligne, avant toute autre instruction.

# extrait
import math
import random

import capteur

serie = capteur.lire_serie("serie.txt")
lisse = capteur.moyenne_glissante(serie, 3)
norme = math.sqrt(sum(valeur ** 2 for valeur in lisse))
temoin = random.choice(serie)

Les quatre appels capteur.lire_serie, capteur.moyenne_glissante, math.sqrt et random.choice disent chacun d'où vient la fonction, et la ligne blanche sépare les modules de la bibliothèque standard du module personnel.
À retenir : une importation exécute le fichier du module, puis lie exactement un nom, celui que l'on voit à droite du import.

1) L'entrée est un nom de fichier, la précondition est le format annoncé par l'énoncé, et la sortie est la liste des flottants. La fonction ouvre dans un bloc with, parcourt le flux ligne à ligne, nettoie, écarte le vide, convertit, accumule et renvoie.

def lire_tensions(nom_fichier):
    """Renvoie la liste des tensions écrites dans un fichier texte.

    Entrées : nom_fichier, chaîne nommant un fichier existant qui contient une
    tension par ligne ; les espaces de bord et les lignes blanches sont admis.
    Sortie : la liste des flottants lus, dans l'ordre du fichier.
    """
    tensions = []
    with open(nom_fichier, "r", encoding="utf-8") as entree:
        for ligne in entree:
            ligne = ligne.strip()
            if ligne != "":
                tensions.append(float(ligne))
    return tensions

Le strip retire le retour à la ligne et les espaces de bord ; le test ligne != "" écarte les lignes blanches, qui feraient échouer float sur une chaîne vide ; la conversion a lieu au moment de la lecture, de sorte que la liste renvoyée ne contient que des nombres.
2) Sur un fichier vide, la boucle ne fait aucun tour et la fonction renvoie []. Sur un fichier qui ne contient qu'une ligne blanche, la boucle fait un tour, le test l'écarte, et la fonction renvoie encore []. Sur la ligne -3.5 sans retour à la ligne final, le parcours donne quand même cette dernière ligne, et la fonction renvoie [-3.5] : strip retire les espaces des deux bords.
3) La fonction ne renvoie rien, son effet est le fichier ; sa spécification doit annoncer l'écrasement.

def ecrire_resume(nom_fichier, tensions):
    """Écrit dans un fichier texte le résumé d'une liste de tensions.

    Entrées : nom_fichier, chaîne nommant le fichier à créer ou à écraser ;
    tensions, liste non vide de flottants.
    Sortie : rien ; le fichier contient l'effectif, le maximum, le minimum,
    puis une tension par ligne.
    """
    assert len(tensions) > 0, "ecrire_resume : la liste est vide"
    with open(nom_fichier, "w", encoding="utf-8") as sortie:
        sortie.write("mesures : " + str(len(tensions)) + "\n")
        sortie.write("maximum : " + str(max(tensions)) + "\n")
        sortie.write("minimum : " + str(min(tensions)) + "\n")
        for tension in tensions:
            sortie.write(str(tension) + "\n")

Chaque donnée passe par str, car write n'accepte que des chaînes, et chaque ligne se termine par un "\n" écrit à la main, car write n'en ajoute aucun.
4) En fabriquant d'abord le fichier de l'énoncé, puis en relisant tel quel le fichier produit :

with open("mesures.txt", "w", encoding="utf-8") as sortie:
    sortie.write(" 12.25\n8\n   \n16.5\n")

tensions = lire_tensions("mesures.txt")
ecrire_resume("resume.txt", tensions)
with open("resume.txt", "r", encoding="utf-8") as entree:
    print(entree.read(), end="")

Le fichier resume.txt contient donc :

mesures : 3
maximum : 16.5
minimum : 8.0
12.25
8.0
16.5

Les trois tensions sont écrites 12.25, 8.0 et 16.5 : str d'un flottant garde le point décimal et le zéro final, alors que l'énoncé écrivait 8 tout court. Le fichier produit n'est donc pas caractère pour caractère celui de départ, bien que les nombres soient les mêmes.
Reste à montrer la liste lue, le fichier relu avec repr, qui montre les caractères invisibles, et le cas du fichier vide :

print(tensions)
with open("resume.txt", "r", encoding="utf-8") as entree:
    print(repr(entree.read()))

with open("vide.txt", "w", encoding="utf-8") as sortie:
    sortie.write("")
print(lire_tensions("vide.txt"))

Cette suite affiche :

[12.25, 8.0, 16.5]
'mesures : 3\nmaximum : 16.5\nminimum : 8.0\n12.25\n8.0\n16.5\n'
[]

À retenir : lire, c'est ouvrir, parcourir, nettoyer, écarter le vide, convertir, accumuler, renvoyer ; écrire, c'est convertir par str et terminer chaque ligne soi-même.

1) On ouvre avec newline="", comme chaque fois qu'un flux est confié au module csv, on construit le lecteur avec le séparateur réellement employé, on consomme l'en-tête, puis on convertit champ par champ. Les temps portent une virgule décimale, que float refuse : on la remplace par un point.

import csv


def lire_course(nom_fichier):
    """Renvoie les enregistrements d'un fichier CSV de temps d'étape.

    Entrées : nom_fichier, chaîne nommant un fichier CSV à séparateur point-virgule,
    de colonnes coureur;etape;temps, avec une ligne d'en-tête et des temps écrits
    à la française.
    Sortie : la liste des triplets (coureur, etape, temps), l'étape étant un entier
    et le temps un flottant.
    """
    releve = []
    with open(nom_fichier, "r", encoding="utf-8", newline="") as entree:
        lecteur = csv.reader(entree, delimiter=";")
        next(lecteur)
        for champs in lecteur:
            releve.append((champs[0], int(champs[1]), float(champs[2].replace(",", "."))))
    return releve

2) Le regroupement se fait sur un dictionnaire indexé par le coureur, la méthode get fournissant le total nul tant que le coureur n'a pas été rencontré.

def temps_totaux(releve):
    """Renvoie le temps total de chaque coureur.

    Entrées : releve, liste de triplets (coureur, etape, temps), le temps étant
    un flottant positif.
    Sortie : le dictionnaire qui associe à chaque coureur du relevé la somme
    de ses temps.
    """
    totaux = {}
    for coureur, _, temps in releve:
        totaux[coureur] = totaux.get(coureur, 0.0) + temps
    return totaux

3) L'écriture passe par csv.writer, qui convertit les nombres et insère les séparateurs. L'en-tête vient en premier, et sorted(totaux) donne les clés par ordre alphabétique.

def ecrire_bilan(nom_fichier, totaux):
    """Écrit le bilan par coureur dans un fichier CSV.

    Entrées : nom_fichier, chaîne nommant le fichier à créer ou à écraser ;
    totaux, dictionnaire dont les clés sont des coureurs et les valeurs des flottants.
    Sortie : rien ; le fichier contient une ligne d'en-tête puis une ligne
    par coureur, par ordre alphabétique.
    """
    with open(nom_fichier, "w", encoding="utf-8", newline="") as sortie:
        redacteur = csv.writer(sortie, delimiter=";")
        redacteur.writerow(["coureur", "total"])
        for coureur in sorted(totaux):
            redacteur.writerow([coureur, totaux[coureur]])

4) Les totaux valent $12{,}25 + 11{,}75 = 24$ pour Nour et $13{,}5 + 14{,}25 = 27{,}75$ pour Ines. En fabriquant d'abord le fichier de l'énoncé, puis en relisant le fichier produit :

with open("course.csv", "w", encoding="utf-8", newline="") as sortie:
    sortie.write("coureur;etape;temps\nNour;1;12,25\nInes;1;13,5\nNour;2;11,75\nInes;2;14,25\n")

releve = lire_course("course.csv")
totaux = temps_totaux(releve)
ecrire_bilan("bilan_course.csv", totaux)
with open("bilan_course.csv", "r", encoding="utf-8") as entree:
    print(entree.read(), end="")

Le fichier bilan_course.csv contient donc :

coureur;total
Ines;27.75
Nour;24.0

Les nombres y sont écrits avec un point décimal : le module a converti les flottants par leur écriture Python, sans revenir à la virgule française du fichier de départ, si bien qu'un tableur réglé en français y lira du texte et non des nombres. Ce n'est pas cela qui empêche lire_course de relire ce fichier : la conversion float(champs[2].replace(",", ".")) traverse sans dommage un champ déjà écrit avec un point, et float("27.75".replace(",", ".")) vaut bien 27.75. Ce qui l'en empêche est la forme du tableau : le bilan n'a que deux colonnes, coureur;total, là où lire_course en attend trois. Le lecteur y prendrait le total pour un numéro d'étape, et int s'arrêterait sur ValueError: invalid literal for int() with base 10: '27.75'.
5) Sans next(lecteur), la boucle traite l'en-tête comme un enregistrement. Le premier champ converti est l'étape, et l'exécution s'arrête aussitôt. On le vérifie en reprenant la fonction privée de cette ligne, et en interceptant l'erreur pour la lire :

def lire_course_sans_next(nom_fichier):
    """Reprend lire_course sans next(lecteur), pour voir où elle s'arrête.

    Entrées : nom_fichier, chaîne nommant le fichier CSV de l'énoncé.
    Sortie : la liste des triplets, si tant est que la lecture aboutisse.
    """
    releve = []
    with open(nom_fichier, "r", encoding="utf-8", newline="") as entree:
        lecteur = csv.reader(entree, delimiter=";")
        for champs in lecteur:
            releve.append((champs[0], int(champs[1]), float(champs[2].replace(",", "."))))
    return releve


try:
    lire_course_sans_next("course.csv")
except ValueError as erreur:
    print("ValueError:", erreur)

Le message est :

ValueError: invalid literal for int() with base 10: 'etape'

L'erreur est immédiate ici parce que l'en-tête contient des mots là où le programme attend des nombres. Elle serait bien plus discrète sur un fichier dont l'en-tête serait numérique : le relevé compterait alors un enregistrement de trop, sans le moindre message.
Contrôle du relevé lu et des totaux :

print(releve)
print(totaux)

Ces deux lignes affichent :

[('Nour', 1, 12.25), ('Ines', 1, 13.5), ('Nour', 2, 11.75), ('Ines', 2, 14.25)]
{'Nour': 24.0, 'Ines': 27.75}

À retenir : newline="" à l'ouverture, le bon delimiter, l'en-tête consommé par next, chaque champ numérique converti sur-le-champ, et la forme du tableau écrit comparée à celle qu'attend le programme qui le relira.

1) et 2) Le fichier porte le nom du module, en minuscules et sans accent, et ce n'est celui d'aucun module de la bibliothèque standard. Il s'ouvre par une docstring, contient les deux fonctions spécifiées et le jeu de tests, et ne laisse au niveau principal que la garde du programme principal.

"""Dépouillement d'un scrutin à un tour."""


def depouiller(bulletins):
    """Renvoie le nombre de voix de chaque nom présent dans les bulletins.

    Entrées : bulletins, liste de chaînes, éventuellement vide.
    Sortie : le dictionnaire qui associe à chaque nom apparaissant dans
    bulletins son nombre d'occurrences.
    """
    comptes = {}
    for nom in bulletins:
        comptes[nom] = comptes.get(nom, 0) + 1
    return comptes


def gagnant(comptes):
    """Renvoie le nom strictement en tête d'un dépouillement.

    Entrées : comptes, dictionnaire non vide dont les clés sont des chaînes
    et les valeurs des entiers naturels.
    Sortie : le nom dont le nombre de voix est strictement supérieur à celui
    de tous les autres, et None si deux noms au moins sont en tête.
    """
    assert len(comptes) > 0, "gagnant : le depouillement est vide"
    meilleur = max(comptes.values())
    en_tete = [nom for nom in comptes if comptes[nom] == meilleur]
    if len(en_tete) > 1:
        return None
    return en_tete[0]


def tester_gagnant():
    """Éprouve la fonction gagnant sur son jeu de tests.

    Entrées : aucune.
    Sortie : rien ; l'exécution s'interrompt sur une AssertionError au premier
    test qui échoue, et se tait si tous passent.
    """
    assert gagnant({"Nour": 5, "Ines": 3}) == "Nour", "cas usuel : deux noms"
    assert gagnant({"Nour": 2, "Ines": 4, "Malo": 3}) == "Ines", "cas usuel : trois noms"
    assert gagnant({"Nour": 7}) == "Nour", "cas limite : un seul nom"
    assert gagnant({"Nour": 4, "Ines": 4}) is None, "cas limite : egalite en tete"
    assert gagnant({"Nour": 0, "Ines": 0, "Malo": 1}) == "Malo", "cas limite : des zeros"


if __name__ == "__main__":
    print(depouiller(["Nour", "Ines", "Nour"]))
    tester_gagnant()
    print("tests de gagnant : tous passes")

Le jeu de tests suit la spécification. Les deux premières assertions sont des cas usuels, dont la réponse se lit sur le dictionnaire. Les trois autres sont les bords du domaine : un seul nom, l'égalité en tête qui doit donner None, et des effectifs nuls, qui vérifient que la fonction compare bien les voix au lieu de supposer un candidat majoritaire. Le dictionnaire vide ne figure pas dans le jeu : il est hors du domaine, et c'est la précondition qui le refuse. La comparaison à None s'écrit avec is, car on teste un objet unique et non une égalité de valeurs. Les messages sont écrits sans accent, pour que le texte de l'AssertionError s'affiche à l'identique sur toutes les consoles.
3) Lancé directement, le fichier affiche :

{'Nour': 2, 'Ines': 1}
tests de gagnant : tous passes

Importé, il n'affiche rien : la variable __name__ vaut alors "scrutin" et non "__main__", donc le bloc de la garde n'est pas exécuté. Le programme qui l'importe n'affiche donc que ses propres lignes, celles des deux appels qu'il fait au module. Les voici, obtenues en appelant ici les mêmes fonctions :

bulletins = ["Malo", "Nour", "Malo", "Ines", "Malo", "Nour"]
comptes = depouiller(bulletins)
print(comptes)
print(gagnant(comptes))

{'Malo': 3, 'Nour': 2, 'Ines': 1}
Malo

Sans cette garde, les deux lignes d'essai du module se seraient mêlées à l'affichage du programme appelant, à chaque importation.
4) La version fautive renvoie toujours un nom, même quand deux candidats sont à égalité en tête : max prend le premier maximum rencontré et ne signale rien. Les quatre autres assertions passent encore, et c'est la quatrième qui tombe.

def gagnant(comptes):
    assert len(comptes) > 0, "gagnant : le depouillement est vide"
    return max(comptes, key=comptes.get)


try:
    tester_gagnant()
except AssertionError as erreur:
    print("AssertionError :", erreur)

Ce programme affiche :

AssertionError : cas limite : egalite en tete

Le message nomme le cas, ce qui dirige droit vers la faute. Un jeu de tests que l'on n'aurait jamais vu échouer n'aurait rien prouvé du tout : il pourrait ne contenir que des cas que toute fonction passe, ou comparer la fonction à elle-même. L'avoir vu tomber sur une version volontairement fautive est ce qui autorise à croire son silence.
À retenir : docstring en tête, fonctions spécifiées, jeu de tests nommant chaque cas, rien au niveau principal hors de la garde, et un jeu de tests éprouvé au moins une fois.

1) Un dé équilibré à six faces donne un entier de 1 à 6, chaque face ayant la probabilité $\frac{1}{6}$. La fonction random.randint(a, b) tire uniformément un entier de l'ensemble $\{a, a+1, \dots, b\}$, les deux bornes comprises : les bornes sont donc $1$ et $6$. Les deux dés étant indépendants, on tire deux fois.

import random


def somme_de_deux_des():
    """Renvoie la somme de deux dés équilibrés à six faces, lancés une fois.

    Entrées : aucune.
    Sortie : un entier de 2 à 12, somme de deux tirages uniformes et
    indépendants dans {1, ..., 6}.
    """
    return random.randint(1, 6) + random.randint(1, 6)

Écrire random.randrange(1, 6) aurait exclu la face 6, comme le fait range.
2) La fonction compte les succès et divise par l'effectif.

def frequence(cible, nombre_de_lancers):
    """Renvoie la fréquence d'apparition d'une somme sur une série de lancers.

    Entrées : cible, entier ; nombre_de_lancers, entier strictement positif.
    Sortie : le flottant égal au nombre de lancers dont la somme vaut cible,
    divisé par le nombre de lancers.
    """
    assert nombre_de_lancers > 0, "frequence : aucun lancer"
    succes = 0
    for _ in range(nombre_de_lancers):
        if somme_de_deux_des() == cible:
            succes += 1
    return succes / nombre_de_lancers

3) Les $36$ couples de faces sont équiprobables. La somme vaut $7$ pour les six couples $(1,6), (2,5), (3,4), (4,3), (5,2), (6,1)$, et elle vaut $2$, comme elle vaut $12$, pour un seul couple. En notant $S$ la somme obtenue, on a donc $\mathbb{P}(S = 7) = \frac{6}{36} = \frac{1}{6} \approx 0{,}1667$, tandis que $\mathbb{P}(S = 2) = \mathbb{P}(S = 12) = \frac{1}{36} \approx 0{,}0278$.
Les trois fréquences observées, $0{,}1642$, $0{,}0281$ et $0{,}0255$, en sont proches : l'écart est au plus de $0{,}0025$, soit moins de deux fois l'écart type $\sqrt{\frac{p(1-p)}{n}}$ d'une fréquence sur $n = 10000$ tirages, qui vaut environ $0{,}0037$ pour $p = \frac{1}{6}$ et $0{,}0016$ pour $p = \frac{1}{36}$. C'est le contrôle d'ordre de grandeur : une fréquence nulle, ou double de la valeur attendue, aurait dénoncé une erreur de bornes et non de la malchance.
L'appel random.seed(2026) garantit que la suite des tirages sera exactement la même à chaque exécution du programme, donc que ces trois nombres seront reproduits à l'identique et qu'un échec pourra être rejoué. Il ne garantit rien sur leur justesse : une simulation fausse donne, elle aussi, toujours les mêmes nombres.
4) Sa ligne tire un entier uniformément dans $\{2, 3, \dots, 12\}$ : elle simule un dé à onze faces, où chaque somme a la probabilité $\frac{1}{11} \approx 0{,}0909$. C'est bien ce que montrent ses relevés, $\frac{965}{10000} = 0{,}0965$ et $\frac{891}{10000} = 0{,}0891$, tous deux voisins de $0{,}0909$.
Or la somme de deux dés n'est pas uniforme : $7$ est six fois plus probable que $2$. Sa simulation sous-estime donc le $7$ d'un facteur proche de $2$ et surestime le $2$ d'un facteur proche de $3$. Connaître l'ensemble des valeurs possibles d'une variable aléatoire ne dit rien de sa loi.
5) Les indices valides d'une liste de longueur $n$ vont de $0$ à $n - 1$ :

# extrait
i = random.randrange(len(resultats))
j = random.randint(0, len(resultats) - 1)
valeur = random.choice(resultats)

L'appel random.randint(0, len(resultats)) serait faux, puisque randint comprend ses deux bornes : il donnerait l'indice $10000$, qui lève une IndexError environ une fois sur dix mille, donc rarement assez pour que l'on s'en aperçoive pendant les essais.
Contrôle complet, graine comprise :

random.seed(2026)
print(frequence(7, 10000))
print(frequence(2, 10000))
print(frequence(12, 10000))

Ce programme affiche :

0.1642
0.0281
0.0255

À retenir : randint comprend ses deux bornes, la graine rend la simulation rejouable sans la rendre juste, et une fréquence se compare toujours à la probabilité calculée à la main.

1) Soit $T = \{(e_1, a_1), \dots, (e_k, a_k)\}$ un jeu de tests fini, avec $k \in \mathbb{N}$, que $f$ passe entièrement : pour tout $i \in \{1, \dots, k\}$, on a $f(e_i) = a_i$.
Posons $E = \{e_1, \dots, e_k\}$, l'ensemble des entrées testées. C'est une partie finie de $D$, de cardinal au plus $k$.
Montrons que $D$ n'est pas inclus dans $E$. Si l'on avait $D \subset E$, alors $D$ serait fini, comme partie d'un ensemble fini, ce qui contredit l'hypothèse selon laquelle $D$ est infini. Il existe donc un élément $x_0 \in D$ tel que $x_0 \notin E$.
L'ensemble $A$ contient au moins deux éléments : il contient donc un élément $b$ différent de $f(x_0)$.
Définissons l'application $g : D \to A$ par $g(x) = f(x)$ pour tout $x \in D \setminus \{x_0\}$, et $g(x_0) = b$. Cette définition est licite : elle attribue à chaque élément de $D$ une image et une seule, dans $A$.
Soit $i \in \{1, \dots, k\}$. Comme $e_i \in E$ et $x_0 \notin E$, on a $e_i \neq x_0$, donc $g(e_i) = f(e_i) = a_i$ : l'application $g$ passe le test $(e_i, a_i)$. Ceci valant pour tout $i \in \{1, \dots, k\}$, l'application $g$ passe le jeu de tests $T$ tout entier.
Enfin $g(x_0) = b \neq f(x_0)$, donc $g \neq f$ : l'application $g$ n'est pas conforme à la spécification.
2) Supposons qu'un jeu de tests fini $T$ suffise à démontrer la conformité, c'est-à-dire que toute application qui passe $T$ soit égale à $f$. L'application $g$ construite au 1) passe $T$ et diffère de $f$ : c'est contradictoire. Aucun jeu de tests fini ne démontre donc la conformité d'une fonction sur un domaine infini.
Ce qu'un jeu de tests établit tout de même est l'énoncé contraire : si $g$ échoue au test $(e_i, a_i)$, alors $g(e_i) \neq a_i = f(e_i)$, donc $g \neq f$, et la fonction est fausse, sans appel. Un jeu de tests réfute, il ne démontre pas. Pour démontrer, il faut une preuve portant sur toutes les entrées à la fois : invariant de boucle, variant, récurrence sur la structure des données, ce qui relève du thème Algorithmes élémentaires et preuve de programmes, et, pour la récurrence elle-même, du bloc Fondamental.
3) La spécification est ici l'application qui, à l'entier naturel $n$, associe $\sum_{k=1}^{n} k^2$, somme vide et donc nulle pour $n = 0$. Le domaine $\mathbb{N}$ est infini et l'ensemble d'arrivée $\mathbb{N}$ contient au moins deux éléments : la démonstration du 1) s'applique.

def somme_des_carres(n):
    """Renvoie la somme des carrés des entiers de 1 à n.

    Entrées : n, entier naturel.
    Sortie : l'entier égal à 1^2 + 2^2 + ... + n^2, nul pour n = 0.
    """
    total = 0
    for k in range(1, n + 1):
        total += k * k
    return total


def tester_somme_des_carres(fonction):
    """Éprouve une fonction candidate sur le jeu de tests de somme_des_carres.

    Entrées : fonction, une fonction d'un entier naturel dans les entiers.
    Sortie : rien ; l'exécution s'interrompt sur une AssertionError au premier
    test qui échoue, et se tait si tous passent.
    """
    assert fonction(0) == 0, "cas limite : n = 0, somme vide"
    assert fonction(1) == 1, "cas limite : n = 1"
    assert fonction(2) == 5, "cas usuel : n = 2"
    assert fonction(3) == 14, "cas usuel : n = 3"
    assert fonction(10) == 385, "cas usuel : n = 10"
    assert fonction(100) == 338350, "oracle : formule n(n+1)(2n+1)/6"

Le dernier cas vient d'un oracle indépendant de la fonction testée, la formule $\sum_{k=1}^{n} k^2 = \frac{n(n+1)(2n+1)}{6}$, qui donne pour $n = 100$ la valeur $\frac{100 \times 101 \times 201}{6} = 338350$.
La construction du 1) se transcrit en choisissant pour $x_0$ un entier qu'aucun test n'atteint, par exemple $2026$, et pour $b$ la valeur $0$, différente de $f(2026)$.

def somme_des_carres_fausse(n):
    """Renvoie la somme des carrés des entiers de 1 à n, sauf pour n = 2026."""
    if n == 2026:
        return 0
    return somme_des_carres(n)


tester_somme_des_carres(somme_des_carres)
tester_somme_des_carres(somme_des_carres_fausse)
print("les deux fonctions passent le meme jeu de tests")
print(somme_des_carres(2026), somme_des_carres_fausse(2026))

Ce programme affiche :

les deux fonctions passent le meme jeu de tests
2774077201 0

Les deux fonctions sont indiscernables par ce jeu de tests, et l'une des deux est fausse. Ajouter le cas $n = 2026$ ne réglerait rien : la même construction, appliquée au nouveau jeu de tests, fabriquerait aussitôt une autre fonction fausse qui le passe.
À retenir : un jeu de tests qui passe ne prouve rien ; un jeu de tests qui tombe prouve qu'il faut corriger.

1) L'erreur est de parcourir deux fois le même flux ouvert. La ligne fautive est la seconde boucle, for ligne in entree:, celle qui calcule total.
La lecture d'un flux est séquentielle : un curseur avance dans le fichier au fur et à mesure et ne revient pas en arrière de lui-même. La première boucle consomme les quatre lignes et laisse le curseur en fin de fichier. Quand la seconde boucle demande la ligne suivante, il n'y en a plus : elle ne fait aucun tour, total garde sa valeur initiale, et la fonction renvoie le quotient $\frac{0}{4}$, c'est-à-dire 0.0.
2) Aucune exception n'est levée parce qu'aucune opération interdite n'a été tentée. Parcourir un flux épuisé est légitime : cela donne zéro tour de boucle, exactement comme le parcours d'une liste vide. Le flux, lui, n'est fermé qu'à la sortie du bloc with, donc après les deux boucles. Le résultat 0.0 est un flottant parfaitement ordinaire, que rien ne distingue d'un vrai débit moyen nul.
Si le fichier avait été vide, la première boucle aurait laissé effectif à $0$, et la dernière ligne aurait levé une erreur. On le vérifie en reprenant la fonction de l'énoncé et en interceptant cette erreur pour la lire :

def debit_moyen_fautif(nom_fichier):
    """Reprend la fonction fautive de l'énoncé, pour la voir échouer.

    Entrées : nom_fichier, chaîne nommant un fichier de débits, un par ligne.
    Sortie : le quotient total / effectif, que le second parcours fausse.
    """
    with open(nom_fichier, "r", encoding="utf-8") as entree:
        effectif = 0
        for ligne in entree:
            effectif += 1
        total = 0.0
        for ligne in entree:
            total += float(ligne)
    return total / effectif


with open("vide.txt", "w", encoding="utf-8") as sortie:
    sortie.write("")
try:
    debit_moyen_fautif("vide.txt")
except ZeroDivisionError as erreur:
    print("ZeroDivisionError:", erreur)

Le message est :

ZeroDivisionError: float division by zero

C'est le seul cas où cette fonction se plaint : elle est muette précisément quand elle se trompe.
3) On ne lit le fichier qu'une fois, et l'on garde les données dans une liste, qui, elle, se parcourt autant de fois qu'on veut.

def debit_moyen(nom_fichier):
    """Renvoie le débit moyen relevé dans un fichier texte.

    Entrées : nom_fichier, chaîne nommant un fichier existant qui contient
    un débit par ligne et au moins un débit ; les lignes blanches sont admises.
    Sortie : le flottant égal à la moyenne arithmétique des débits lus.
    """
    debits = []
    with open(nom_fichier, "r", encoding="utf-8") as entree:
        for ligne in entree:
            ligne = ligne.strip()
            if ligne != "":
                debits.append(float(ligne))
    assert len(debits) > 0, "debit_moyen : le fichier ne contient aucun debit"
    return sum(debits) / len(debits)

La précondition « au moins un débit » est maintenant écrite, et vérifiée après la lecture, puisque c'est le contenu du fichier, et non son nom, qui la porte. Le fichier n'est ouvert qu'une fois, ce qui règle la faute du départ ; si un second parcours était nécessaire, il faudrait rouvrir le fichier, ou travailler sur la liste renvoyée.
4) Le résultat attendu vient d'un calcul fait à la main : $\frac{14{,}5 + 9{,}25 + 11{,}75 + 13{,}5}{4} = \frac{49}{4} = 12{,}25$. Les quatre débits et leur somme s'écrivent exactement en binaire, mais la comparaison à une tolérance reste la bonne habitude sur des flottants.

with open("debit.txt", "w", encoding="utf-8") as sortie:
    sortie.write("14.5\n9.25\n11.75\n13.5\n")

try:
    assert abs(debit_moyen_fautif("debit.txt") - 12.25) < 1e-9, "cas usuel : quatre debits"
except AssertionError as erreur:
    print("AssertionError :", erreur)

assert abs(debit_moyen("debit.txt") - 12.25) < 1e-9, "cas usuel : quatre debits"
print(debit_moyen("debit.txt"))

Les deux versions passées à la même assertion affichent :

AssertionError : cas usuel : quatre debits
12.25

Sur la version fautive, l'assertion tombe aussitôt et son message nomme le cas ; sur la version corrigée, elle se tait, et c'est le débit moyen qui s'affiche.
Un affichage, lui, n'aurait rien trahi : print(debit_moyen_fautif("debit.txt")) aurait montré 0.0, et il aurait fallu refaire le calcul de tête, à chaque exécution, pour s'apercevoir que ce n'est pas la moyenne de quatre nombres tous compris entre $9$ et $15$. Un test compare, un affichage demande un lecteur.
À retenir : un flux ne se lit qu'une fois, et une fonction de lecture renvoie une liste, sur laquelle on repasse autant de fois qu'on veut.

1) En exécutant le programme de l'énoncé, puis en relisant le fichier produit :

import csv

lignes = [["titre", "auteur"], ["Analyse ; tome 1", "Nour"], ["Algebre", "Ines"]]
with open("catalogue.csv", "w", encoding="utf-8", newline="") as sortie:
    redacteur = csv.writer(sortie, delimiter=";")
    redacteur.writerows(lignes)

with open("catalogue.csv", "r", encoding="utf-8") as entree:
    print(entree.read(), end="")

Le fichier contient les trois lignes :

titre;auteur
"Analyse ; tome 1";Nour
Algebre;Ines

Le module a ajouté une paire de guillemets autour du champ Analyse ; tome 1, et seulement autour de celui-là. C'est la convention du format : un champ qui contient le séparateur est protégé par des guillemets, de sorte que le point-virgule intérieur ne compte pas comme une frontière de champ. Les deux autres lignes ne contiennent aucun caractère à protéger et sont écrites telles quelles.
Chaque enregistrement est par ailleurs terminé par les deux caractères \r\n, que le module écrit lui-même sur toutes les machines. C'est pour cela que le flux est ouvert avec newline="" : sous Windows, un flux de texte ouvert sans cet argument traduirait en outre chaque \n en \r\n, ajoutant un \r de trop, et le fichier compterait une ligne vide sur deux ; ailleurs, la fin de ligne s'écrivant \n, cette traduction n'a pas lieu et la faute dort jusqu'au premier passage sur une machine Windows.
2) Le découpage naïf coupe le titre en deux et garde les guillemets, puisqu'il ne connaît que le caractère ; :

with open("catalogue.csv", "r", encoding="utf-8", newline="") as entree:
    deuxieme = entree.readlines()[1]
print("split :", deuxieme.strip().split(";"))

with open("catalogue.csv", "r", encoding="utf-8", newline="") as entree:
    print("csv   :", list(csv.reader(entree, delimiter=";"))[1])

split : ['"Analyse ', ' tome 1"', 'Nour']
csv   : ['Analyse ; tome 1', 'Nour']

Le premier donne trois champs, dont aucun n'est le titre ; le second en donne deux, et rend le titre intact. Conclusion : dès qu'un fichier est au format CSV, on le lit avec le module csv, en lecture comme en écriture. Un split ne convient qu'à un format dont on a vérifié soi-même qu'aucun champ ne peut contenir le séparateur.
3) Les deux fonctions prennent le séparateur en paramètre, ce qui permettra de les fausser au 4).

import csv
import random

ALPHABET = "ab ;\"'"


def ecrire_table(nom_fichier, table, separateur=";"):
    """Écrit une table de chaînes dans un fichier CSV.

    Entrées : nom_fichier, chaîne nommant le fichier à créer ou à écraser ;
    table, liste d'enregistrements, chaque enregistrement étant une liste
    de chaînes ; separateur, le caractère qui sépare les champs.
    Sortie : rien ; le fichier contient un enregistrement par ligne.
    """
    with open(nom_fichier, "w", encoding="utf-8", newline="") as sortie:
        redacteur = csv.writer(sortie, delimiter=separateur)
        redacteur.writerows(table)


def lire_table(nom_fichier, separateur=";"):
    """Renvoie la table des enregistrements d'un fichier CSV.

    Entrées : nom_fichier, chaîne nommant un fichier CSV existant ;
    separateur, le caractère qui sépare les champs.
    Sortie : la liste des enregistrements, chacun étant la liste de ses champs,
    tous de type chaîne.
    """
    with open(nom_fichier, "r", encoding="utf-8", newline="") as entree:
        return [champs for champs in csv.reader(entree, delimiter=separateur)]

Le test tire d'abord la forme de la table, puis chaque champ, caractère par caractère. La propriété éprouvée s'énonce en une phrase : pour toute table de chaînes, écrire puis relire redonne la table de départ.

def table_au_hasard():
    """Renvoie une table de chaînes tirée au hasard sur l'alphabet du test.

    Entrées : aucune.
    Sortie : une liste de 0 à 5 enregistrements, chacun formé de 1 à 4 champs
    de longueur au plus 5, tirés sur ALPHABET.
    """
    table = []
    for _ in range(random.randint(0, 5)):
        enregistrement = []
        for _ in range(random.randint(1, 4)):
            longueur = random.randint(0, 5)
            enregistrement.append("".join(random.choice(ALPHABET) for _ in range(longueur)))
        table.append(enregistrement)
    return table


def tester_aller_retour(separateur_ecriture=";", separateur_lecture=";"):
    """Éprouve le couple ecrire_table et lire_table par des allers-retours.

    Entrées : les deux séparateurs employés, à l'écriture et à la lecture.
    Sortie : rien ; l'exécution s'interrompt sur une AssertionError au premier
    écart entre la table écrite et la table relue, et se tait si tout passe.
    """
    random.seed(2026)
    cas = [[], [[""]], [["", ""]]]
    for _ in range(200):
        cas.append(table_au_hasard())
    for attendu in cas:
        ecrire_table("essai_catalogue.csv", attendu, separateur_ecriture)
        obtenu = lire_table("essai_catalogue.csv", separateur_lecture)
        assert obtenu == attendu, (attendu, obtenu)

La graine fixée rend l'échec rejouable, et le message d'assertion porte les deux tables : le contre-exemple est sous les yeux sans avoir à le chercher. Les trois cas ajoutés à la main sont ceux que le tirage donne rarement, et ce sont précisément les plus fragiles : un champ vide unique s'écrit "" dans le fichier, faute de quoi la ligne serait vide et l'enregistrement disparaîtrait à la relecture.
4) Avec delimiter="," à l'écriture et delimiter=";" à la lecture, c'est le troisième cas ajouté à la main qui tombe le premier, avant même le premier tirage au hasard : la table [["", ""]] s'écrit , avec une virgule pour séparateur, et la relecture au point-virgule y voit un unique champ, la chaîne ,.

tester_aller_retour()
print("aller-retour : 203 tables verifiees, cas limites compris")

try:
    tester_aller_retour(",", ";")
except AssertionError as erreur:
    print("AssertionError :", erreur)

tester_aller_retour(",", ",")
print("erreur des deux cotes : 203 tables verifiees, et le test se tait")

Ce programme affiche :

aller-retour : 203 tables verifiees, cas limites compris
AssertionError : ([['', '']], [[',']])
erreur des deux cotes : 203 tables verifiees, et le test se tait

La troisième ligne est la leçon de l'exercice. Avec la virgule des deux côtés, les 203 cas passent, alors que le fichier produit n'est pas celui que l'énoncé demandait et qu'aucun autre programme ne le relira correctement. Un test d'aller-retour contrôle le couple, pas chacune des deux fonctions : deux fonctions fausses de la même manière se donnent raison l'une à l'autre. Il faut lui adjoindre un test de la lecture seule, sur un fichier écrit à la main dont on connaît le contenu.
5) La propriété n'est vraie que sur les tables dont tous les champs sont des chaînes. Le format CSV est un format texte : le module convertit les nombres à l'écriture et ne les reconnaît pas à la relecture, qui rend toujours des chaînes.

ecrire_table("essai_catalogue.csv", [["note"], [12.5]])
print(lire_table("essai_catalogue.csv"))

Ce programme affiche :

[['note'], ['12.5']]

La table relue diffère de la table écrite, sans qu'aucune des deux fonctions soit en cause : c'est la propriété qui était mal bornée. Tirer les champs sur un alphabet de caractères, comme au 3), évite ce piège par construction, et la spécification de lire_table annonce d'ailleurs que tous les champs renvoyés sont des chaînes.
À retenir : le module csv protège les champs qui contiennent le séparateur, un test d'aller-retour ne contrôle que le couple, et une propriété testée au hasard doit d'abord être bornée au domaine où elle est vraie.