Qu'est-ce qu'une erreur logique ?

Trois notes, 80, 90 et 100, ont une moyenne de 90. Ce programme s'exécute sans la moindre plainte et affiche autre chose :

scores = [80, 90, 100]
average = scores[0] + scores[1] + scores[2] / 3
print("Average:", average)

Average: 203.33333333333334

Python a fait exactement ce que dit la ligne. La division passe avant l'addition, donc seule la dernière note a été divisée par 3, et le résultat est 80 + 90 + 33,33. Le programmeur voulait écrire (scores[0] + scores[1] + scores[2]) / 3. Ajoute les parenthèses et le programme affiche Average: 90.0.

Pourquoi aucun message d'erreur n'apparaît

Un ordinateur vérifie si le code est valide, pas s'il est correct. Le parseur vérifie la grammaire, ce qui attrape une erreur de syntaxe. Le runtime vérifie chaque opération, ce qui attrape une erreur d'exécution comme une division par zéro. Additionner trois nombres et diviser l'un d'eux par 3 est une grammaire valide et une opération légale, donc les deux vérifications passent.

Seule la personne qui a écrit le programme sait qu'il devait calculer une moyenne. Cette intention n'existe nulle part dans le code, donc aucun outil ne peut comparer le résultat avec elle. Une erreur logique, c'est l'écart entre ce que tu as dit à l'ordinateur de faire et ce que tu voulais qu'il fasse.

Causes courantes des erreurs logiques

La plupart des erreurs logiques viennent d'une courte liste de schémas.

• Les erreurs de décalage d'un (off-by-one). Une boucle tourne une fois de trop ou une fois de moins. range(1, 5) produit 1, 2, 3 et 4, car la borne de fin est exclue. Voir l'itération.
• La priorité des opérateurs. a + b / 2 ne divise que b, comme dans la moyenne ci-dessus.
• La mauvaise comparaison. < là où il fallait <=, ou and là où il fallait or. Les conditions sont des expressions booléennes, et un seul mauvais opérateur inverse le résultat pour certaines entrées.
• Des conditions dans le mauvais ordre. Dans une chaîne if et elif, la première condition vraie l'emporte, donc un test large placé en premier masque les tests plus précis en dessous.
• La mauvaise variable. Mettre à jour total dans une boucle mais afficher subtotal.
• Des suppositions sur les nombres. 0.1 + 0.2 == 0.3 vaut False en Python, Java et JavaScript, car les nombres à virgule flottante sont des approximations. 7 // 2 vaut 3, pas 3,5.

Voici l'erreur d'ordre des conditions. Une note de 95 devrait donner un A :

def grade(score):
    if score >= 60:
        return "D"
    elif score >= 90:
        return "A"
    else:
        return "F"

print(grade(95))
print(grade(72))
print(grade(40))

D
D
F

95 est supérieur ou égal à 60, donc la première branche l'emporte et le elif n'est jamais atteint. Place le seuil le plus élevé en premier et chaque résultat devient juste.

Les types d'erreurs en programmation

Les erreurs de programmation sont généralement classées en trois types, selon le moment où elles apparaissent et ce qui les signale.

Certains manuels listent plus de types, et la plupart entrent dans ces trois-là. Une erreur de type que le compilateur Java rejette, comme incompatible types: String cannot be converted to int, est détectée à la compilation comme une erreur de syntaxe, et certains livres l'appellent erreur sémantique. Une erreur d'édition de liens se produit à la dernière étape de la construction d'un programme C ou C++, quand une fonction a été déclarée mais que son code est introuvable. Les erreurs arithmétiques, de ressources et de fichiers, comme diviser par zéro, manquer de mémoire ou ouvrir un fichier absent, sont toutes des erreurs d'exécution. Le terme « erreur sémantique » est aussi employé par certains cours comme autre nom de l'erreur logique, alors vérifie quel sens utilise ton manuel.

Comment trouver une erreur logique

1. Teste avec une réponse que tu connais déjà. Calcule le bon résultat à la main pour une petite entrée, puis compare. Trois notes sont plus faciles à vérifier que trois mille.
2. Affiche les valeurs intermédiaires. Afficher score et la branche prise, ou le compteur de boucle à chaque passage, montre l'étape exacte où la réalité s'écarte de ton plan.
3. Avance pas à pas avec un débogueur. Poser un point d'arrêt et exécuter une ligne à la fois fait la même chose sans modifier le code.
4. Teste les limites. Essaie 0, 1, la plus grande valeur, une liste vide, et le seuil exact (60 et 90 dans l'exemple des notes).
5. Explique le code à voix haute. Décrire chaque ligne à quelqu'un d'autre, ou à un canard en plastique, t'oblige à dire ce que fait la ligne plutôt que ce que tu supposes qu'elle fait.

Un assert transforme une réponse connue en vérification automatique. Il ne fait rien quand la condition est vraie et arrête le programme quand elle est fausse :

def grade(score):
    if score >= 60:
        return "D"
    elif score >= 90:
        return "A"
    else:
        return "F"

assert grade(40) == "F"
assert grade(95) == "A", "95 should be an A"
print("all tests passed")

Traceback (most recent call last):
  File "main.py", line 10, in <module>
    assert grade(95) == "A", "95 should be an A"
           ^^^^^^^^^^^^^^^^
AssertionError: 95 should be an A

Un test qui échoue transforme une erreur logique silencieuse en erreur bruyante, avec un numéro de ligne. C'est toute l'idée des tests unitaires.

Les erreurs logiques dans d'autres langages

Les schémas sont les mêmes partout, mais chaque langage a ses propres pièges. En JavaScript, "5" + 3 est la chaîne "53", alors que "5" - 3 est le nombre 2, donc une valeur lue sous forme de texte depuis un formulaire peut s'additionner de travers sans aucune erreur. En C, if (x = 5) affecte 5 à x et est toujours vrai. Clang le signale par défaut (using the result of an assignment as a condition without parentheses), mais le code compile et s'exécute quand même, alors prends les avertissements du compilateur aussi au sérieux que les erreurs.

Pour aller plus loin

Compare cette page avec celles sur l'erreur de syntaxe et l'erreur d'exécution pour voir comment chaque type est signalé. Les boucles sont le terrain des erreurs de décalage d'un, donc la page sur l'itération et le guide Python sur les boucles for sont de bonnes lectures pour la suite. Pour t'entraîner à trouver des résultats faux dans de vrais exercices, essaie le cours Python.