Lire, tester et corriger un programme

2. Reconnaître les patrons en lecture

Un examinateur te montre un bout de code et demande : « que calcule cette fonction ? ». Plutôt que de tracer intégralement, on gagne un temps fou en reconnaissant le patron : une variable accumulée dans une boucle trahit presque toujours un max, un min, une somme, un comptage ou une recherche. Voici comment les repérer. (Pour écrire ces algorithmes toi-même, va voir la fiche dédiée « Patrons d'algorithmes classiques sur les listes ».)

Que calcule cette fonction ? Lis-la avant de dérouler la réponse.

def f(t):
    r = t[0]
    for x in t:
        if x < r:
            r = x
    return r

Deuxième extrait :

def g(t):
    s = 0
    for x in t:
        s = s + x
    return s / len(t)

Troisième extrait — attention au repère du comptage :

def h(t):
    c = 0
    for x in t:
        if x % 2 == 0:
            c = c + 1
    return c

Dernier extrait — un retour anticipé dans la boucle :

def cherche(t, v):
    for i in range(len(t)):
        if t[i] == v:
            return i
    return -1

3. Tester : assert et jeux de tests

Un programme « qui a l'air juste » n'est pas un programme juste. On le teste : on lui donne des entrées dont on connaît la réponse, et on vérifie qu'il la produit. L'outil de base est l'instruction assert.

def somme(t):
    s = 0
    for x in t:
        s = s + x
    return s

assert somme([1, 2, 3]) == 6     # cas normal
assert somme([5]) == 5           # cas limite : un seul élément
assert somme([]) == 0            # cas limite : liste vide
print("Tous les tests passent")

4. Déboguer : trouver l'erreur

Quand Python affiche du rouge, ne panique pas : le message te dit quel type d'erreur et à quelle ligne. Apprendre à le lire, c'est déjà régler la moitié des bugs.

4.1 Lire le message d'erreur

Trois erreurs reviennent tout le temps. Il faut les reconnaître d'un coup d'œil.

print(resultat)
# NameError: name 'resultat' is not defined

t = [1, 2, 3]
print(t[3])
# IndexError: list index out of range

print("3" + 3)
# TypeError: can only concatenate str (not "int") to str

4.2 Déboguer avec print

Le code ne plante pas mais donne un mauvais résultat ? Insère des print pour voir les valeurs pendant l'exécution, au lieu de les imaginer.

def somme_positifs(t):
    s = 0
    for x in t:
        if x > 0:
            s = s + x
        print("x =", x, "| s =", s)   # espion temporaire
    return s

somme_positifs([3, -1, 4])

4.3 La dichotomie sur le code

Sur un programme long, on ne relit pas tout : on coupe en deux. On place un print au milieu pour vérifier que les valeurs y sont encore correctes. Si oui, le bug est dans la seconde moitié ; sinon, dans la première. On recommence sur la moitié fautive. En quelques coupes, on encercle la ligne coupable — la même idée que la recherche par dichotomie.

5. Lire une fonction qu'on n'a pas écrite

Face à une fonction inconnue, on ne lit pas au hasard : on suit une checklist qui donne du sens au code en moins d'une minute.

Applique la méthode à cette fonction au nom volontairement muet :

def mystere(t):
    r = []
    for x in t:
        if x not in r:
            r.append(x)
    return r

Entrées : une liste t. Sortie : une nouvelle liste r (elle démarre vide et on lui ajoute des éléments). Traçons sur [1, 2, 2, 3, 1] :

Verdict : mystere supprime les doublons en conservant l'ordre de première apparition. Le test x not in r n'ajoute un élément que s'il est nouveau. Le petit exemple a tout révélé — bien plus vite qu'en fixant le code.

6. Exercices d'application

À faire de tête, table de trace à l'appui, avant d'ouvrir le corrigé.

t = [5, 1, 8, 3]
m = t[0]
for x in t:
    if x < m:
        m = x
print(m)

def q(t):
    c = 0
    for x in t:
        if x > 0:
            c = c + 1
    return c

7. Erreurs classiques (les pièges qui coûtent des points)

Ces erreurs ne viennent pas d'un manque de connaissances mais d'un manque de méthode. Les connaître, c'est déjà les éviter.

7. Pour aller plus loin

Lire, tracer et tester sont des réflexes transversaux : tu les réinvestis dans presque tous les chapitres d'informatique. Voici les suites naturelles.

• Patrons d'algorithmes classiques sur les listes — pour écrire toi-même les algos max, min, somme, comptage et recherche que cette fiche apprend à reconnaître.
• Recherche par dichotomie — l'algorithme phare pour lequel la table de trace est indispensable, et où le débogage des bornes est un art.
• Correction et terminaison d'un algorithme — pour prouver rigoureusement qu'un programme fait ce qu'on croit et s'arrête, au-delà des simples tests.