Tester un algorithme sur des valeurs simples

Ce qu'il faut comprendre

Quand tu écris un algorithme en Python (ou ailleurs), tu dois vérifier qu'il fait bien ce que tu attends. Tester sur des valeurs simples, c'est choisir quelques entrées faciles à calculer de tête, pour voir si le résultat est correct. Par exemple, si ton algorithme calcule le double d'un nombre, tu testes avec 0, 1, 2, -3 : tu sais que les résultats doivent être 0, 2, 4, -6. Si ça marche, tu peux avoir confiance. Sinon, tu repères vite l'erreur.

Tester sur des valeurs simples, c'est aussi utile pour comprendre comment un algorithme se comporte dans des cas particuliers : valeur nulle, valeur négative, valeur limite, etc. Cela t'aide à détecter des bugs avant de passer à des données complexes.

Les notions essentielles

Variable : une boîte qui stocke une valeur (nombre, texte, booléen). En Python, on écrit x = 5.
Condition : une instruction qui exécute du code seulement si une condition est vraie. Exemple : if x > 0:.
Boucle : une structure qui répète des instructions. Deux types :
- for : quand on connaît le nombre de répétitions.
- while : tant qu'une condition est vraie.
Fonction : un bloc de code réutilisable qui prend des paramètres et renvoie un résultat. Définition : def ma_fonction(param):.
Simulation : exécuter un algorithme avec des valeurs choisies pour observer son comportement.
Tableur : outil (comme Excel ou LibreOffice Calc) qui peut aussi servir à tester des algorithmes simples, en reproduisant les calculs dans des cellules.

Méthode

Pour tester un algorithme sur des valeurs simples, suis ces étapes :

Lis l'algorithme attentivement. Comprends ce qu'il fait.
Choisis des valeurs de test :
- Une valeur neutre (0 pour les nombres, chaîne vide pour du texte).
- Une valeur positive simple (1, 2, 10).
- Une valeur négative simple (-1, -5).
- Une valeur qui pourrait poser problème (par exemple, une division par zéro, une valeur hors limites).
Exécute l'algorithme à la main (ou avec Python) pour chaque valeur. Note le résultat attendu et le résultat obtenu.
Compare : si ça correspond, le test est réussi. Sinon, cherche l'erreur.
Utilise un tableur si l'algorithme est simple : tu peux recopier les formules dans des cellules et tester plusieurs valeurs rapidement.

Exemple corrigé

Algorithme : une fonction Python qui calcule la valeur absolue d'un nombre.

def valeur_absolue(x):
    if x >= 0:
        return x
    else:
        return -x

Test sur des valeurs simples :

| Valeur de x | Résultat attendu | Résultat obtenu | Test réussi ? | |-------------|------------------|-----------------|---------------| | 0 | 0 | 0 | Oui | | 5 | 5 | 5 | Oui | | -3 | 3 | 3 | Oui | | -0.5 | 0.5 | 0.5 | Oui |

Tous les tests passent, l'algorithme est correct.

Autre exemple : un algorithme qui calcule la moyenne de deux nombres.

def moyenne(a, b):
    return (a + b) / 2

Test :

a=0, b=0 → attendu 0, obtenu 0 → OK.
a=2, b=4 → attendu 3, obtenu 3 → OK.
a=-1, b=1 → attendu 0, obtenu 0 → OK.
a=10, b=20 → attendu 15, obtenu 15 → OK.

Avec un tableur : tu peux écrire dans une cellule =(A1+B1)/2 et tester différentes valeurs dans A1 et B1.

Erreurs fréquentes

Ne tester qu'un seul cas : par exemple, tester seulement avec des nombres positifs pour une fonction qui doit gérer aussi les négatifs. Solution : teste toujours plusieurs cas, y compris les cas limites.
Confondre test et preuve : réussir quelques tests ne garantit pas que l'algorithme est parfait. Il peut y avoir des bugs qui ne se déclenchent qu'avec certaines valeurs. Solution : teste un maximum de cas différents.
Oublier les valeurs particulières : 0, 1, -1, les grands nombres, les nombres décimaux. Solution : fais une liste de valeurs à tester.
Ne pas vérifier le type de retour : par exemple, une fonction qui doit renvoyer un entier renvoie un flottant. Solution : vérifie aussi le type avec type().
Erreur de calcul manuel : quand tu testes à la main, tu peux te tromper. Solution : refais le calcul ou utilise une calculatrice.

À retenir

Tester un algorithme sur des valeurs simples permet de vérifier rapidement son bon fonctionnement.
Choisis des valeurs variées : neutre, positive, négative, limites.
Exécute l'algorithme à la main ou avec Python, et compare avec le résultat attendu.
Un tableur peut t'aider à automatiser les tests pour des algorithmes simples.
Réussir des tests ne prouve pas que l'algorithme est correct à 100 %, mais c'est une bonne première étape.

Pour s'entraîner

Pour t'entraîner, rends-toi sur AlloSeconde : tu y trouveras des exercices interactifs, des quiz et des fiches pour maîtriser le test d'algorithmes sur des valeurs simples. N'hésite pas à pratiquer avec Python ou un tableur chez toi !