Trace d'exécution, jeux d'essai et débogage

La trace d'exécution d'un algorithme est le tableau qui note, instruction après instruction ou tour de boucle après tour de boucle, la valeur de chaque variable ; le jeu d'essai est la liste des cas de test, avec pour chacun le résultat attendu. Ce chapitre montre comment faire une trace à la main, comment retrouver le rôle d'un algorithme inconnu, comment tester un programme Python et comment chercher une erreur méthodiquement.

Pourquoi faire une trace ?

Faire la trace, c'est jouer le rôle de la machine : exécuter l'algorithme à la main, sans rien sauter, en notant ce que contient chaque variable. C'est l'exercice le plus fréquent d'algorithmique, pour trois raisons :

• c'est la seule façon de comprendre un algorithme que tu n'as pas écrit, et le programme du BTS demande de savoir « reconstituer le rôle d'un algorithme » ;
• c'est la meilleure façon de vérifier le tien avant de le taper, puisqu'une partie de l'épreuve se fait sur table ;
• c'est la meilleure façon de trouver une erreur : on voit le tour où une variable prend une valeur inattendue.

La méthode du tableau de trace

1. Une colonne par variable qui change, plus une colonne pour le tour de boucle ou l'instruction, et éventuellement une pour la condition testée.
2. Une première ligne « avant » avec les valeurs initiales. Une variable pas encore affectée vaut ?.
3. Une ligne par tour (ou par instruction s'il n'y a pas de boucle). Recopie ce qui ne change pas, recalcule ce qui change, et note le calcul entre parenthèses si besoin.
4. Teste la condition de boucle avant d'écrire une nouvelle ligne : c'est ce qui évite le tour de trop.
5. Conclus par une phrase : « l'algorithme affiche… », puis, si c'est demandé, « il calcule… ».

Exemple 1 : une boucle et une condition

tab ← [12, 7, 18, 4, 11]
res ← 0
Pour i de 0 à 4 Faire
    Si tab[i] MOD 2 = 0 Alors
        res ← res + tab[i]
    FinSi
FinPour
Afficher(res)

L'algorithme affiche 34. Reformulé : il calcule la somme des éléments pairs du tableau (12 + 18 + 4). C'est cette phrase de conclusion que le correcteur attend quand on te demande « que fait cet algorithme ? » : pas « il affiche 34 », qui ne vaut que pour ces données.

Exemple 2 : un TantQue à deux variables

// Entrées : a et b, entiers, a ≥ 0 et b > 0
q ← 0
r ← a
TantQue r ≥ b Faire
    r ← r - b
    q ← q + 1
FinTantQue
Afficher(q, r)

Avec a = 17 et b = 5 :

L'algorithme affiche 3 et 2. On retrouve 17 = 5 × 3 + 2 : il calcule le quotient et le reste de la division euclidienne de a par b par soustractions successives, c'est-à-dire a DIV b et a MOD b. La dernière ligne, « fin », note le test qui fait sortir de la boucle : c'est elle qui prouve que tu n'as pas fait un tour de trop.

Exemple 3 : retrouver le rôle d'un algorithme

Fonction Mystere(n : entier) : entier
    m ← 0
    TantQue n > 0 Faire
        m ← m × 10 + n MOD 10
        n ← n DIV 10
    FinTantQue
    Retourner m
FinFonction

Trace de Mystere(1234) :

La fonction renvoie 4321. Un deuxième essai, Mystere(560), renvoie 65 (le zéro de tête disparaît). Elle renvoie l'entier écrit à l'envers : à chaque tour, n MOD 10 détache le dernier chiffre de n, m × 10 + … l'ajoute à droite de m, et n DIV 10 le retire de n.

La trace sur machine

Une fois l'algorithme programmé, la machine peut faire la trace pour toi. Trois techniques, de la plus simple à la plus puissante :

Les affichages de suivi. Ajoute un print dans la boucle, qui montre les variables à chaque tour. On l'enlève une fois le problème trouvé.

n = 1234
m = 0
while n > 0:
    m = m * 10 + n % 10
    n = n // 10
    print("m =", m, "n =", n)   # suivi, à retirer ensuite
print(m)

m = 4 n = 123
m = 43 n = 12
m = 432 n = 1
m = 4321 n = 0
4321

Le débogueur. Thonny, VS Code et la plupart des environnements ont un mode pas à pas : tu exécutes le programme une instruction à la fois, et un panneau affiche la valeur de chaque variable. Dans Thonny, lance le programme en mode débogage (l'icône en forme d'insecte), puis avance pas à pas ; dans VS Code, clique dans la marge pour poser un point d'arrêt sur une ligne, puis lance le débogage. Le programme s'arrête sur cette ligne et tu inspectes l'état.

Python Tutor. Ce site exécute un programme court et dessine, à chaque étape, les variables et les listes avec des flèches. C'est l'outil idéal pour comprendre les copies de listes (chapitre 7) et les appels de fonctions.

Le programme du BTS évoque précisément ces outils : selon le langage, on peut montrer les fonctions de suivi des variables et le débogage pas à pas.

Construire un jeu d'essai

Un jeu d'essai (ou jeu de test) est un ensemble de cas de test : pour chacun, les données d'entrée et le résultat attendu, calculé à la main avant d'exécuter. On compare ensuite avec le résultat obtenu. Un test dont on n'a pas prévu le résultat ne prouve rien : on finit toujours par trouver « logique » ce que la machine affiche.

Un bon jeu d'essai couvre trois familles de cas :

Exemple : jeu d'essai de la fonction qui renvoie le maximum d'une liste de notes.

Les tests 5 et 6 ont trouvé deux défauts : le maximum était initialisé à 0 au lieu du premier élément (chapitre 7), et le cas de la liste vide n'était pas prévu. C'est exactement le rôle d'un jeu d'essai : les cas normaux passent presque toujours, les erreurs se cachent aux limites.

Automatiser les tests avec assert

L'instruction assert condition ne fait rien si la condition est vraie, et arrête le programme avec une AssertionError si elle est fausse. On s'en sert pour transformer un jeu d'essai en tests qui se relancent en une seconde après chaque modification. La fonction maximum utilise def et return, détaillés au chapitre 6.

def maximum(notes):
    plus_grande = notes[0]
    for note in notes:
        if note > plus_grande:
            plus_grande = note
    return plus_grande

assert maximum([12, 15, 9]) == 15
assert maximum([18, 3, 7]) == 18
assert maximum([4, 6, 20]) == 20
assert maximum([11]) == 11
assert maximum([-3, -8]) == -3
print("Tous les tests passent")

Tous les tests passent

En SLAM, tu utiliseras des outils de tests unitaires (comme unittest ou pytest en Python, xUnit en C#, PHPUnit en PHP), qui reposent sur la même idée : une entrée, un résultat attendu, une comparaison automatique. Le cours sur les tests montre comment écrire un bon test unitaire.

Les erreurs que Python te signale

Quand Python rencontre une erreur, il affiche un message appelé traceback. Lis-le par la fin : la dernière ligne donne le type et la description de l'erreur, la ligne au-dessus indique le numéro de ligne fautif.

Traceback (most recent call last):
  File "moyenne.py", line 4, in <module>
    moyenne = total / nb
              ~~~~~~^~~~
ZeroDivisionError: division by zero

Une erreur de syntaxe empêche le programme de démarrer. Les autres apparaissent à l'exécution, parfois seulement pour certaines données : d'où l'importance des cas limites.

Quand une erreur est prévisible (un utilisateur qui tape une lettre au lieu d'un nombre), on peut l'intercepter avec try et except :

while True:
    saisie = input("Nombre de postes ? ")
    try:
        nb = int(saisie)
        break
    except ValueError:
        print(saisie, "n'est pas un entier, recommence.")
print("Nombre de postes :", nb)

Les effets indésirables à connaître

Le programme cite une liste de pièges « aux conséquences spectaculaires ». Tu les as presque tous rencontrés :

Déboguer avec méthode

Un programme qui donne un mauvais résultat sans message d'erreur est le cas le plus difficile. Modifier le code au hasard aggrave souvent les choses. Suis plutôt ces étapes :

1. Reproduire : trouve une entrée précise qui donne un résultat faux, et calcule à la main le résultat attendu.
2. Localiser : fais la trace (à la main, avec des print ou le débogueur) et repère la première ligne où une variable prend une valeur différente de celle que tu attendais.
3. Expliquer : formule la cause en une phrase (« le compteur est initialisé dans la boucle »). Si tu ne sais pas l'expliquer, tu n'as pas encore trouvé.
4. Corriger cette cause, et seulement elle.
5. Retester tout le jeu d'essai, pas seulement le cas qui échouait : une correction peut en casser un autre.

Le programme demande justement de travailler sur des « algorithmes délibérément erronés dont les défauts sont repérés puis débogués ». C'est une question classique d'entretien : « votre programme renvoie 0 pour cette liste, comment le corrigez-vous ? ». La réponse attendue suit ces cinq étapes.

Exercices

n ← 5
s ← 0
Pour i de 1 à n Faire
    s ← s + 2 × i - 1
FinPour
Afficher(s)

r ← 0
Pour i de 1 à longueur(t) - 1 Faire
    Si t[i] < t[i - 1] Alors
        r ← r + 1
    FinSi
FinPour
Afficher(r)

notes = [8, 12, 15, 10]
somme = 0
nb = 0
for note in notes:
    if note > 10:
        somme = somme + note
    nb = nb + 1
print(round(somme / nb, 2))

notes = [8, 12, 15, 10]
somme = 0
nb = 0
for note in notes:
    if note >= 10:
        somme = somme + note
        nb = nb + 1
if nb > 0:
    print(round(somme / nb, 2))
else:
    print("Aucune note supérieure ou égale à 10")

serveurs = ["web01", "web02", "bdd01"]
for i in range(1, len(serveurs) + 1):
    print(i, serveurs[i])

serveurs = ["web01", "web02", "bdd01"]
for i in range(len(serveurs)):
    print(i + 1, serveurs[i])

def est_bissextile(annee):
    return (annee % 4 == 0 and annee % 100 != 0) or annee % 400 == 0

assert est_bissextile(2026) == False
assert est_bissextile(2024) == True
assert est_bissextile(2100) == False
assert est_bissextile(2000) == True
assert est_bissextile(1900) == False
print("Tests réussis")