Erreurs, tests
et débogage.

• Trouver la ligne fautive et le type d’erreur en trois secondes.
• Rendre un programme robuste face aux saisies et fichiers invalides.
• Écrire des tests qui vous préviennent avant l’utilisateur.
• Déboguer méthodiquement, sans « essayer au hasard ».

La troisième. Python ne peut pas savoir que vous vouliez <= et non <. La sonde Mars Climate Orbiter a été perdue en 1999 parce qu’un logiciel calculait en livres-force et l’autre en newtons : aucun message d’erreur, 300 millions de dollars. Seuls des tests détectent les erreurs de logique.

Copier le type d’erreur et son message dans un moteur de recherche est un réflexe d’ingénieur, pas une honte. Mais avant : relisez la ligne indiquée. Neuf fois sur dix, l’erreur est visible une fois qu’on sait quel type chercher.

Un except: nu attrape tout, y compris les erreurs que vous n’aviez pas prévues, y compris une faute de frappe dans votre propre code : le programme continue silencieusement avec un état incohérent. C’est pire qu’un plantage. Attrapez ce que vous savez gérer, laissez passer le reste.

On avait écrit la saisie robuste avec isdigit(). Cette version accepte aussi les négatifs (« -5 » n’est pas digit mais est un entier) et sépare clairement « pas un entier » de « hors bornes ». Le return dans la boucle infinie est la sortie normale. Cette fonction se réutilise partout : c’est la brique « saisie fiable ».

Une fonction qui reçoit une valeur absurde ne doit pas « faire de son mieux » : elle doit refuser, avec raise et un message clair. C’est l’appelant qui décide quoi faire. as e récupère l’objet erreur pour lire son message. On peut définir ses propres types d’erreur (séance 16). finally sert à libérer une ressource (fermer un port série, couper un moteur) quoi qu’il arrive : essentiel en robotique.

Le cas normal, les bords (0, 360, liste vide, un seul élément), les valeurs négatives, les flottants avec tolérance, et le cas qui doit échouer. Une fonction avec ses tests est une fonction dont on peut changer l’implémentation sans peur : relancez les tests, s’ils passent c’est bon. Dans un vrai projet on utilise le module pytest qui trouve et exécute automatiquement toutes les fonctions test_….

assert condition, "message" affiche le message si la condition est fausse. Le motif try / except / else / assert False vérifie qu’une erreur a bien été levée : refuser les mauvaises valeurs fait partie du contrat de la fonction, donc ça se teste.

Indice 1 : affichez debut et fenetre à chaque tour. Indice 2 : que vaut valeurs[-2:1] ? Indice 3 : au début, la fenêtre a moins de taille éléments.

def moyenne_mobile(valeurs, taille):
    resultat = []
    for i in range(len(valeurs)):
        debut = max(0, i - taille + 1)      # bug 1 : +1 ; bug 2 : jamais négatif
        fenetre = valeurs[debut:i + 1]
        resultat.append(sum(fenetre) / len(fenetre))   # bug 3 : diviser par la vraie taille
    return resultat

La moyenne mobile lisse les mesures bruitées d’un capteur : vous l’utiliserez sur le robot. Un indice négatif dans une tranche compte depuis la fin : [-2:1] est vide, d’où une moyenne de 0 sans aucune erreur. Typique de la famille « logique ».

def diviser(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return None

def lire_nombres(chemin):
    nombres = []
    try:
        with open(chemin, encoding="utf-8") as f:
            for ligne in f:
                try:
                    nombres.append(float(ligne))
                except ValueError:
                    pass
    except FileNotFoundError:
        pass
    return nombres

Attendu : None 2.0 puis [12.5, 7.0, 3.25] []. float(" 3.25 \n") fonctionne : la conversion ignore les espaces autour. Pour diviser, on aurait aussi pu écrire if b == 0: return None : quand le test est simple, il est préférable à un try.

EN_METRES = {"mm": 0.001, "cm": 0.01, "m": 1, "km": 1000}

def convertir(valeur, de, vers):
    if de not in EN_METRES or vers not in EN_METRES:
        raise ValueError(f"unité inconnue : {de} ou {vers}")
    return valeur * EN_METRES[de] / EN_METRES[vers]

def test_convertir():
    assert convertir(1, "m", "cm") == 100
    assert convertir(2500, "m", "km") == 2.5
    assert convertir(5, "km", "mm") == 5_000_000
    assert abs(convertir(convertir(3.7, "m", "cm"), "cm", "m") - 3.7) < 1e-12
    assert convertir(0, "mm", "km") == 0
    try:
        convertir(1, "m", "pouces")
    except ValueError:
        pass
    else:
        assert False, "unité inconnue acceptée"
    print("convertir : OK")

Un dictionnaire de facteurs vers une unité pivot remplace 16 if. Ajouter une unité = ajouter une ligne. C’est le genre de conception qu’on attend d’un bon programmeur.

Avec [1, 3, 5, 7, 9] et cible 4 : bas=0, haut=4 → milieu 2 (5 > 4) haut=2 → milieu 1 (3 < 4) bas=1 → milieu 1 (3 < 4) bas=1… pour toujours. Quand haut = bas + 1, milieu = bas et l’intervalle ne rétrécit plus. Correction : bas = milieu + 1 et haut = milieu - 1 — on exclut le milieu déjà examiné, ce qui garantit que l’intervalle rétrécit strictement à chaque tour (c’est l’argument de terminaison qu’on attend en concours).

def dichotomie(liste, cible):
    bas, haut = 0, len(liste) - 1
    while bas <= haut:
        milieu = (bas + haut) // 2
        if liste[milieu] < cible:
            bas = milieu + 1
        elif liste[milieu] > cible:
            haut = milieu - 1
        else:
            return milieu
    return -1

def test_dichotomie():
    l = [1, 3, 5, 7, 9]
    assert dichotomie(l, 1) == 0 and dichotomie(l, 9) == 4 and dichotomie(l, 5) == 2
    assert dichotomie(l, 4) == -1 and dichotomie(l, 100) == -1
    assert dichotomie([], 3) == -1
    assert dichotomie([3], 3) == 0 and dichotomie([3], 4) == -1
    print("dichotomie : OK")

Le bug Java (2006) : (bas + haut) / 2 débordait pour des tableaux de plus d’un milliard d’éléments, car les entiers y sont limités à 32 bits. Python n’a pas cette limite (séance 02), mais le C sur Arduino, si : un int y fait 16 bits, et 30 000 + 30 000 devient négatif. Vous y serez confronté en séance 22.