Modules et débogage Python, bases des tests

Un module contient du code Python qu’un autre programme peut réutiliser. La plupart des modules sont des fichiers .py. La bibliothèque standard est fournie avec Python ; le code tiers nécessite une installation séparée. Un paquet regroupe des modules apparentés, généralement dans un dossier.

Adapter l’appel à l’importation

Une importation crée des noms dans ton programme. La forme choisie détermine comment tu appelles le code importé.

La notation pointée permet de rechercher un nom dans un module ou un objet. Dans math.sqrt(16), Python trouve sqrt dans math et l’appelle avec 16. Le résultat est 4.0. La constante math.pi ne nécessite pas de parenthèses d’appel, car c’est une valeur, pas une fonction.

Après import math, sqrt(16) seul lève NameError : le programme possède un nom pour le module, mais aucun nom distinct pour sqrt. Après from math import sqrt seul, l’erreur inverse, math.sqrt(16), lève aussi NameError parce que math n’a pas été lié. Un alias remplace le nom habituel de la liaison importée : import statistics as stats crée stats, pas les deux noms.

Effectuer le même calcul de deux façons

Un triangle rectangle a des côtés de longueurs 3 et 4. Élève d’abord les côtés au carré et additionne-les, puis prends la racine carrée.

import math

length = math.sqrt(3**2 + 4**2)
print(length)  # 5.0

L’expression dans l’appel devient 9 + 16, puis 25 ; sqrt renvoie 5.0. Avec from math import sqrt, écris plutôt length = sqrt(3**2 + 4**2). Le préfixe du module rend visible l’origine d’une fonction et évite d’introduire ses autres noms dans l’espace de noms de ton programme. La liaison math elle-même peut toutefois remplacer une variable antérieure appelée math.

Garder des noms clairs

Évite from math import *. Cette importation générique introduit les noms publics dans ton programme sans les nommer individuellement. Par exemple, e = 5 suivi de cette importation fait passer e à 2.718281828459045. Une importation qui semble sans rapport peut donc modifier un calcul ultérieur. PEP 8 recommande les importations explicites et les place en haut du fichier, à raison d’un module par ligne : bibliothèque standard d’abord, paquets tiers ensuite, tes propres modules en dernier.

Python exécute le code de premier niveau d’un module lors de sa première importation pendant l’exécution d’un programme. Les importations suivantes réutilisent le module chargé ; elles ne le relancent pas.

Utiliser l’erreur pour choisir la correction

Dans la console interactive, exécute import math, puis dir(math) pour lister ses noms. Exécute help(math.sqrt) pour lire la documentation d’une fonction. La référence officielle de la bibliothèque Python explique ses arguments et son résultat.

La bibliothèque standard fournit des outils testés pour les calculs et les simulations. Le choix d’une fonction commence par le résultat recherché : un nombre entier, une mesure arrondie, un élément aléatoire ou une liste réorganisée.

L’arrondi a plusieurs sens

Après import math, math.sqrt(16) renvoie le flottant 4.0. math.pi et math.e fournissent les constantes 3.141592653589793 et 2.718281828459045. math.factorial(5) multiplie les nombres entiers de 1 à 5 et renvoie 120.

Pour 23 mètres carrés de mur et 10 mètres carrés par pot de peinture, la division donne 2.3 pots. Pour acheter des pots entiers, il faut utiliser math.ceil(23 / 10), qui renvoie 3. round(2.3) donne 2 et laisse trop peu de peinture.

La fonction native round() ne nécessite aucune importation. Pour un cercle de rayon 2, round(math.pi * 2 ** 2, 2) donne 12.57. L’arrondi modifie la précision d’un nombre ; c’est une opération différente de l’achat d’un nombre suffisant de pots entiers.

Vérifier les domaines de définition et les comparaisons de flottants

math.sqrt(-1) lève ValueError, car cette entrée n’a pas de racine carrée réelle. Les flottants calculés demandent aussi de l’attention : à cause du stockage binaire, 0.1 + 0.2 == 0.3 vaut False. math.isclose(0.1 + 0.2, 0.3) vaut True ; utilise cette fonction pour comparer approximativement des flottants calculés.

Choisir l’opération aléatoire

Le module random utilise un algorithme pour produire des résultats pseudo-aléatoires.

Garde random.shuffle(cards) sur sa propre ligne. Réaffecter son résultat à cards fait perdre la liaison à la liste en la remplaçant par None. Tirer des positions est aussi différent d’exiger des valeurs distinctes : random.sample([1, 1], 2) renvoie [1, 1].

Exécuter une simulation reproductible

import random

sevens = 0
for _ in range(1000):
    if random.randint(1, 6) + random.randint(1, 6) == 7:
        sevens += 1
print(sevens)

Six des 36 couples équiprobables ont une somme de 7 : le nombre obtenu est donc généralement proche de 167, mais il change d’une exécution à l’autre. Pour reproduire une séquence lors du débogage, appelle random.seed(42) avant de générer les valeurs, avec la même version de Python et la même séquence d’appels. Pour les mots de passe ou les jetons de sécurité, utilise secrets.

Trouver d’autres outils courants

statistics.mean([2, 4, 9]) renvoie 5 ; statistics.median([2, 4, 9]) renvoie 4. datetime.date.today() donne la date du jour. Après import sys, sys.argv contient le nom du script suivi de ses arguments : l’exécution de python greet.py Ada fournit ['greet.py', 'Ada'].

Une fonction devient plus facile à réutiliser lorsqu’elle se trouve dans un module consacré à une tâche précise. Un autre programme peut importer cette fonction et un test peut la vérifier sans demander à une personne d’exécuter toute l’application.

Séparer la fonction de son appelant

Enregistre ce code sous le nom geometry.py :

"""Calculations for simple shapes."""
import math

def circle_area(radius):
    """Return the area of a circle with the given radius."""
    return math.pi * radius ** 2

Dans le même dossier, enregistre cet appelant sous le nom main.py :

import geometry

print(geometry.circle_area(2))

Exécute python main.py. Python trouve geometry, crée sa fonction, puis l’appelant exécute cette fonction. Le résultat affiché est 12.566370614359172. Importe le module sans la terminaison .py. Un nom de module valide utilise des lettres, des chiffres et des tirets bas, avec un premier caractère valide ; my_tools.py fonctionne avec import my_tools, tandis que import my-tools est une syntaxe invalide.

Les chaînes au début du module et de la fonction sont des docstrings. Elles décrivent le rôle du code et apparaissent dans help(geometry) et help(geometry.circle_area).

Comprendre ce que l’importation exécute

Lors de la première importation, Python exécute dans l’ordre les instructions de premier niveau du module. Une instruction def crée une fonction ; elle n’exécute pas son corps. En revanche, un print(circle_area(2)) non protégé à la fin de geometry.py produirait un affichage pendant l’importation.

Cet effet de bord compte lorsqu’un module contient des invites de saisie ou une boucle de programme. Un test qui veut seulement utiliser circle_area ne devrait pas avoir à lancer le programme et à répondre à ses invites.

Protéger le lancement et garder la fonction accessible

Ajoute ceci sous la fonction réutilisable dans geometry.py :

def main():
    print(circle_area(2))

if __name__ == "__main__":
    main()

Python définit __name__ pour chaque module. Une exécution directe, python geometry.py, lui donne la valeur "__main__", ce qui rend la condition vraie et appelle main(). L’importation de geometry lui donne la valeur "geometry" : Python ignore donc l’appel. Les définitions placées au-dessus de la garde restent disponibles dans les deux cas.

Ne place pas circle_area elle-même dans la garde. Un programme qui importe le module a besoin de cette définition même lorsque la condition de lancement est fausse. La garde contrôle le moment où l’application démarre ; elle n’empêche pas Python de charger le module.

Savoir où Python cherche

Python vérifie les modules intégrés comme sys, puis parcourt dans l’ordre les dossiers de sys.path. Normalement, le dossier du script exécuté vient en premier dans ce chemin, suivi des dossiers de la bibliothèque standard et des paquets installés. Garder tes propres fichiers à côté du script exécuté est une organisation simple pour un projet de débutant. Une importation ordinaire ne peut pas trouver un module situé hors du chemin de recherche.

Cet ordre peut aussi masquer un module de bibliothèque. Si tu enregistres ton programme sous le nom random.py, son instruction import random peut charger ton fichier à la place du module de bibliothèque. Un appel ultérieur à random.randint(1, 6) lève alors AttributeError. Renomme le fichier, par exemple en dice.py ; Python 3.13 et les versions ultérieures peuvent inclure une indication de renommage dans l’erreur.

Un module chargé est réutilisé au cours d’une même exécution. Dans une console interactive, modifier le fichier et l’importer à nouveau conserve la version chargée. Redémarre la console avant de tester tes modifications.

Les paquets tiers ajoutent du code qui n’est pas fourni avec Python. PyPI, le Python Package Index accessible sur https://pypi.org, héberge ces projets. pip les télécharge et les installe pour une installation particulière de Python.

Utiliser le terminal, puis Python

Une commande de terminal et une instruction Python ne se saisissent pas au même endroit. L’invite >>> signifie que tu es dans la console interactive Python. Y saisir pip install requests donne SyntaxError ; Python ne peut pas l’interpréter comme une instruction.

Dans ton terminal, exécute :

python -m pip install cowsay

Puis place ceci dans un programme Python :

import cowsay

cowsay.cow("Hello, Ada")

Le programme affiche une vache dessinée avec des caractères à côté d’une bulle contenant le message. L’installation rend le paquet disponible ; l’importation crée la liaison correspondante dans le programme.

Associer pip à ton interpréteur

La forme -m pip demande au Python indiqué d’exécuter son propre pip. Utilise la commande qui lance tes programmes : souvent python3 sur macOS ou Linux, ou py sur Windows.

python3 -m pip install cowsay
python3 game.py

Les deux lignes utilisent la même commande Python. Si une installation réussit mais qu’un script lève encore ModuleNotFoundError, compare le Python utilisé pour l’installation avec celui utilisé pour exécuter le script. Un éditeur peut avoir sélectionné un interpréteur différent de celui de ton terminal. Utilise le pip de l’interpréteur sélectionné avant de modifier l’importation.

Examiner et entretenir une installation

Une version précise est utile lorsque tu as besoin du comportement propre à cette version. show aide à vérifier quel emplacement pip a réellement modifié.

Vérifier le nom dans la documentation

Le nom de distribution saisi pour pip peut différer du nom d’importation. Installe beautifulsoup4, puis utilise import bs4 ; installe Pillow, puis utilise import PIL. Installer à plusieurs reprises un nom d’importation n’est pas une correction utile lorsque la documentation indique une autre distribution.

La bibliothèque standard de Python, y compris math, random et unittest, est déjà fournie avec Python. Ces modules ne nécessitent pas d’installation avec pip.

Respecter une installation gérée

Certains systèmes d’exploitation et gestionnaires de paquets protègent leur Python avec une erreur externally-managed-environment. Cela signifie qu’une installation directe est bloquée pour préserver la cohérence de l’installation gérée. Utilise un environnement virtuel, avec un Python et un dossier de paquets distincts pour le projet. Ne force pas l’installation avec sudo pip install.

Tout le monde peut publier sur PyPI. Avant l’installation, vérifie l’orthographe exacte et lis la page et la documentation du projet. Des noms ressemblants peuvent être des tentatives de typosquatting. Privilégie les paquets établis et maintenus, et installe ceux dont ton programme a réellement besoin.

Une trace d’appels indique quels appels étaient actifs lorsqu’une exception non gérée a arrêté le programme. Elle fournit à la fois un point de départ pour la lecture et un chemin pour remonter jusqu’à la valeur qui a provoqué l’échec.

Commencer par la dernière ligne

Considère ce programme complet dans scores.py :

def average(values):
    return sum(values) / len(values)

def report(scores):
    avg = average(scores)
    print(f"Average: {avg:.1f}")

report([])

La dernière ligne de son rapport d’erreur est ZeroDivisionError: division by zero. Elle nomme le type d’exception et décrit l’opération qui a échoué. Commence par là, puis remonte jusqu’à l’emplacement du code juste au-dessus.

Voici une trace d’appels simplifiée, sans les marques d’expression :

Traceback (most recent call last):
  File "scores.py", line 8, in <module>
    report([])
  File "scores.py", line 5, in report
    avg = average(scores)
  File "scores.py", line 2, in average
    return sum(values) / len(values)
ZeroDivisionError: division by zero

Lire chaque cadre comme un appel actif

Un cadre d’exécution indique le fichier, le numéro de ligne et la fonction, suivis du code concerné. in <module> désigne le code de premier niveau. L’appel le plus ancien est en haut ; le plus récent est en bas. Lire en partant du bas inverse cet ordre et permet de se demander ce qui a échoué avant de chercher comment l’exécution en est arrivée là.

1. La ligne 2 divise par len(values). Pour que ce diviseur soit nul, values doit être vide.
2. La ligne 5 appelle average(scores) : examine donc les scores transmis par report.
3. La ligne 8 fournit [], la liste vide. Cela explique comment le diviseur nul est arrivé dans le calcul.

La ligne qui échoue et la cause sont liées, mais peuvent se trouver à des endroits différents. Remplacer la division sans décider de ce que doit signifier une liste vide masquerait une question de conception. L’appelant doit soit éviter une liste vide, soit définir le comportement de la fonction pour une entrée vide.

Utiliser les marques sans dépendre de leur forme exacte

Python 3.11 et les versions ultérieures peuvent ajouter les caractères ^ et ~ pour montrer la partie d’une expression qui a échoué. Ils sont utiles lorsqu’une ligne contient plusieurs opérations. Les marques exactes varient selon la version, mais les emplacements des appels et le message d’exception donnent toujours l’ordre de lecture.

Une trace d’appels peut contenir des cadres de la bibliothèque standard ou d’un paquet installé. Trouve le cadre le plus bas dans ton propre code et examine les arguments que tu y as fournis. Un cadre de bibliothèque indique un emplacement ; il ne prouve pas que la bibliothèque contient le bug.

Reconnaître un rapport d’erreur de syntaxe

Une erreur de syntaxe dans le script lancé empêche ce script de s’exécuter. Python indique un fichier, une ligne, une marque et un message sans l’en-tête habituel de trace d’appels. Par exemple, il manque les deux-points à if True ; total = sum([1, 2, 3] laisse une parenthèse ouverte.

L’emplacement marqué est celui où Python a constaté qu’il ne pouvait pas analyser le code. Lorsque cette ligne semble valide, vérifie si un guillemet ou une parenthèse n’a pas été laissé ouvert à la ligne précédente. Il n’y a pas de chaîne d’appels à l’exécution à suivre lorsque le script lancé ne s’est pas exécuté.

Une exécution ordinaire s’arrête à sa première exception non gérée. Corrige ce problème et relance le programme pour faire apparaître les éventuels problèmes ultérieurs.

Le nom d’une erreur réduit le champ de recherche et son message apporte des précisions sur les valeurs concernées. Un programme peut aussi être incorrect sans lever d’exception : vérifier sa sortie par rapport au résultat attendu reste donc nécessaire pour trouver les erreurs.

Distinguer trois types de problèmes

IndentationError est un type de SyntaxError. Le corps d’une fonction doit être indenté ; l’absence d’un bloc indenté arrête le code avant son exécution. Vérifie aussi les guillemets ou parenthèses non fermés et les mots-clés mal orthographiés.

Examiner les noms et les types

Une NameError signifie que le programme ne connaît pas un nom à cet endroit. Dans prnt("hi"), la fonction native voulue est print. Un nom peut aussi être utilisé avant son affectation, ou une importation peut manquer.

Une TypeError signifie qu’une opération a reçu un type inadapté ou qu’un appel a reçu un nombre incorrect d’arguments. "Age: " + 30 mélange une chaîne et un entier. Écris "Age: " + str(30) ou f"Age: {30}". Si area attend w et h, area(3) provoque aussi une TypeError, cette fois à cause d’un argument manquant.

Le message distingue ces causes. Dans can only concatenate str (not "int") to str, Python nomme les types concernés. Après age = input("Age: "), age est du texte. age + 1 échoue ; pour une saisie entière, int(age) + 1 effectue le calcul.

Une ValueError signifie que le type de l’entrée est accepté, mais que sa valeur ne convient pas. int("12.5") reçoit une chaîne, qui est un type d’entrée accepté, mais le texte ne représente pas un nombre entier sous la forme attendue. math.sqrt(-1) est un autre exemple de valeur inadaptée pour un calcul dans les nombres réels.

Vérifier les positions, les clés et les attributs

Les divisions par zéro échouent aussi avec // et %. L’accès à une position absente d’une liste diffère de l’accès à une clé absente d’un dictionnaire, même si les deux consistent à demander quelque chose qui manque.

Détecter un résultat qui semble plausible

def total_price(prices):
    total = 0
    for i in range(1, len(prices)):
        total += prices[i]
    return total

Pour [4, 6, 10], cette fonction renvoie 16 au lieu de 20. Il n’y a aucune exception : les indices 1 et 2 existent, donc chaque opération est autorisée. La boucle commence trop tard et ignore l’indice 0. L’erreur devient visible lorsque tu compares la sortie au total voulu.

Pour une exception inconnue, recherche son type et le message général dans la documentation officielle de Python. Retire tes propres chemins et valeurs d’entrée de la recherche ; ils expliquent rarement la règle générale.

Un bug est une différence entre le comportement prévu et le comportement obtenu. Le débogage permet d’en trouver la cause et de la corriger. Une séance de débogage utile transforme une observation en une explication vérifiable, puis modifie le code à partir des éléments obtenus.

Reproduire l’échec

Note une entrée précise et le résultat qu’elle produit. Pour la fonction de calcul des prix qui commence sa boucle à l’indice 1, utilise [4, 6, 10]. Le total attendu est 20 ; le total obtenu est 16. Ces valeurs concrètes te permettent de vérifier que chaque étape de la recherche concerne toujours le même bug.

La différence est 4, et le résultat obtenu est égal à 6 + 10. Une hypothèse précise est que le premier prix est ignoré. Cette hypothèse prédit un fait que tu peux examiner : la boucle ne passera jamais par l’indice 0.

Suivre six étapes

1. Reproduire : trouve une entrée qui montre le bug de façon fiable.
2. Indiquer les résultats attendu et obtenu : calcule le résultat attendu indépendamment.
3. Formuler une hypothèse : indique une cause possible et le comportement qu’elle prédit.
4. La tester : examine les valeurs avec des affichages, un tableau de suivi ou un débogueur.
5. Corriger la cause : effectue une modification ciblée.
6. Tester à nouveau : exécute le programme avec l’entrée qui échouait et les cas qui fonctionnaient auparavant.

Affiche l’indice dans la boucle. Pour cette entrée, les seuls indices sont 1 et 2, ce qui confirme la prédiction. Faire commencer range à 0 corrige le problème de l’élément ignoré. Parcourir directement les prix évite d’avoir à gérer un indice :

def total_price(prices):
    total = 0
    for price in prices:
        total += price
    return total

La fonction corrigée renvoie 20 pour [4, 6, 10], 5 pour [5] et 0 pour []. Le cas à un élément est utile, car la boucle erronée renvoyait auparavant 0 pour ce cas.

Ajouter 4 à chaque réponse corrigerait le total observé, mais laisserait la cause en place. Pour [5], ce correctif renverrait 4 ; le montant manquant dépend de l’entrée. Vérifie si une correction proposée explique tous les éléments observés avant de la conserver.

Réduire une recherche plus vaste

La méthode diviser pour régner consiste à vérifier les valeurs qui alimentent le résultat incorrect à un point intermédiaire de l’exécution. Si une valeur nécessaire est déjà incorrecte, examine le code antérieur qui l’a produite. Si les valeurs nécessaires sont encore correctes, suis leur traitement ultérieur. Recommence dans la partie restante.

Tu peux aussi appeler une fonction isolément ou retirer temporairement le code sans rapport. Un exemple minimal reproductible conserve le code le plus court et la plus petite entrée qui échouent encore. Pour un problème observé d’abord dans des centaines d’enregistrements, trouver un ou deux enregistrements qui le déclenchent facilite chaque vérification.

Vérifier la nature réelle des données

Un 5 affiché peut être la chaîne "5". "5" + "3" produit "53", tandis que l’addition numérique donne 8. Examine type(value) pour vérifier le type. Utilise repr(value) pour révéler les espaces et les caractères de saut de ligne qu’un affichage ordinaire peut masquer, comme dans ' Ada'.

Explique le code à voix haute, ligne par ligne, en précisant notamment ce que chaque boucle parcourt réellement et ce que chaque fonction renvoie. C’est le débogage du canard en plastique : expliquer une étape révèle souvent l’écart entre l’opération voulue et celle qui est écrite.

Corrige une cause à la fois pour pouvoir relier le résultat à la modification. Teste à nouveau les cas qui fonctionnaient auparavant ainsi que celui qui échouait.

La réponse finale d’un programme masque le chemin qui l’a produite. Des affichages temporaires, un tableau de suivi et un débogueur permettent de voir ce chemin et de vérifier une hypothèse précise sur l’endroit où il pose problème.

Afficher une valeur à un moment connu

Identifie les valeurs affichées pour le diagnostic afin que le sens de chaque nombre soit clair. Python 3.8 et les versions ultérieures prennent en charge cette forme de f-string :

print(f"{i=} {total=}")

Pour la boucle de calcul des prix erronée, place-la juste avant total += prices[i]. Avec les prix [4, 6, 10], elle affiche :

i=1 total=0
i=2 total=6

Ce sont les totaux avant chaque addition. Après le premier affichage, la boucle ajoute 6 ; après le second, elle ajoute 10. Un affichage après l’addition montrerait des totaux différents. Détermine quel moment répond à ta question avant d’interpréter la sortie.

Suivre le même code à la main

Un tableau de suivi consigne les variables étape par étape. Pour cette boucle :

Il n’y a aucune itération pour l’indice 0. Suis les valeurs réelles de début et de fin écrites dans le code, même si tu sais déjà ce que la boucle devrait faire. Un tableau aide à distinguer ce que tu attends de ce qui se passe.

Mettre en pause à un point d’arrêt

Un débogueur met un programme en cours d’exécution en pause pour te permettre d’examiner son état courant. Un point d’arrêt marque un endroit où faire une pause. Dans des éditeurs comme Thonny et VS Code, clique à côté d’un numéro de ligne et lance le mode débogage ; dans IDLE, fais un clic droit sur la ligne et choisis Set Breakpoint.

Une fois le programme en pause, choisis une commande de progression selon la question étudiée :

Si l’appelant transmet des arguments corrects mais reçoit une réponse incorrecte, entre dans la fonction avec le pas à pas détaillé. Si tu as seulement besoin de voir le résultat renvoyé, utilise le pas à pas principal sur son appel. Examine les valeurs avant et après la ligne qui pourrait créer l’erreur.

Utiliser le débogueur textuel de Python

Insère breakpoint() juste avant le code que tu veux examiner. Avec la configuration par défaut du débogueur, l’exécution du programme lance pdb à cet endroit. Saisis ces commandes à son invite (Pdb) :

• p total affiche total.
• n exécute la ligne suivante en pas à pas principal.
• s entre dans un appel de fonction.
• c poursuit l’exécution.
• q quitte la séance de débogage.

Ce sont des commandes du débogueur, pas des lignes à copier dans ton programme.

Distinguer l’affichage des résultats renvoyés

Une fonction peut afficher le bon nombre tout en renvoyant None parce qu’il lui manque return total. Examine la valeur reçue par l’appelant lorsque l’échec se produit après l’appel de fonction. Voir une sortie correcte dans la fonction ne prouve pas que l’appelant a reçu ce nombre.

Utilise les affichages pour obtenir rapidement des indices sur les itérations d’une boucle et le débogueur pour examiner un moment précis. Après avoir corrigé le bug, supprime les affichages temporaires et les appels à breakpoint() pour que le programme terminé s’exécute normalement.

Une assertion énonce ce qui doit être vrai si ton code fonctionne correctement. Elle peut arrêter un bug près de son origine ou comparer le résultat d’une fonction à la valeur attendue.

Écrire une condition et un message facultatif

assert letter_grade(90) == "A", "90 should be an A"

Python évalue la condition. Si letter_grade(90) renvoie "A", la condition est vraie et l’exécution se poursuit sans affichage. Si elle renvoie "B", Python lève AssertionError avec le message 90 should be an A. La trace d’appels indique la vérification qui a échoué.

Sans le message, assert letter_grade(90) == "A" vérifie tout de même le résultat. La dernière ligne de l’exception contient AssertionError, tandis que la trace d’appels montre l’expression. Un message utile indique quelle attente n’a pas été satisfaite ; il doit t’aider à repérer la règle vérifiée.

Arrêter rapidement une erreur interne

Supposons qu’un calcul interne nécessite une liste non vide :

def average(values):
    assert len(values) > 0, "values must not be empty"
    return sum(values) / len(values)

Une liste vide déclenche désormais l’assertion avant la division. La vérification documente l’hypothèse interne de la fonction et indique directement quand elle n’est pas respectée. Elle ne donne pas de moyenne à une liste vide et ne décide pas comment une application doit réagir à l’absence de données utilisateur.

Maintenir active la validation des entrées utilisateur

L’option -O de Python supprime les instructions assert. Un programme qui utilise une assertion pour rejeter une entrée externe peut donc se comporter différemment lorsqu’il est optimisé. Vérifie les saisies utilisateur et les autres données externes avec les instructions de contrôle habituelles :

def require_score(score):
    if score < 0 or score > 100:
        raise ValueError("score must be 0 to 100")
    return score

Ici, raise ValueError(...) signale une valeur inadaptée. L’instruction if s’exécute toujours avec -O. Choisis une assertion pour une hypothèse interne au programme et une vérification active pour des données externes qui peuvent être incorrectes.

Éviter une vérification qui ne peut jamais échouer

assert est une instruction, pas une fonction. Écris la condition et le message séparés par une virgule :

assert x > 10, "x too small"

Écrire assert (x > 10, "x too small") crée un tuple à deux éléments. Un tuple non vide est vrai même si son premier élément vaut False : l’assertion réussit donc. Python peut avertir que cette assertion est toujours vraie. Des parenthèses autour de la seule condition, comme dans assert (x > 10), ne créent pas ce tuple ; c’est la virgule dans les parenthèses qui pose problème.

Utilise == pour comparer. assert total = 20 est une syntaxe invalide, car = affecte une valeur.

Comparer les nombres avec la précision voulue

Pour un flottant calculé, vérifie que les valeurs sont proches :

import math

assert math.isclose(0.1 + 0.2, 0.3)

Une comparaison exacte échoue ici, car la somme stockée sous forme de flottant diffère légèrement de 0.3. Un test automatisé simple applique la même idée d’assertion à une fonction : assert total_price([4, 6, 10]) == 20. La valeur attendue vient de la règle de la fonction : la vérification peut donc révéler une implémentation incorrecte.

Un test unitaire vérifie une petite unité de code, généralement une fonction, avec une entrée choisie et un résultat attendu. Les tests automatisés rendent ces vérifications faciles à répéter après des modifications et aident à détecter les bugs qui réapparaissent dans un comportement auparavant correct.

Partir de la spécification

Supposons qu’une fonction de notation doive renvoyer "A" pour les notes d’au moins 90, "B" pour les notes d’au moins 80 mais inférieures à 90, et "C" en dessous de 80. La première condition erronée est score > 90.

Les tests doivent remplir plusieurs rôles :

• Les cas typiques vérifient des entrées ordinaires à l’intérieur de chaque intervalle, comme 95 et 85.
• Les cas aux limites vérifient les valeurs où une règle change, comme 90 et 89, ou 80 et 79.
• Les cas extrêmes vérifient des entrées comme zéro ou une collection vide lorsque les règles de la fonction les autorisent.

Détermine la réponse attendue à partir de ces règles. Copier la réponse du programme actuel dans un test peut conserver son erreur.

Placer les tests à côté du module

Enregistre les tests dans test_grade.py et la fonction dans grade.py. Le lancement de l’application dans grade.py doit être placé sous sa garde __main__, afin que l’importation de la fonction ne lance pas le programme.

from grade import letter_grade

def test_letter_grade():
    assert letter_grade(95) == "A"
    assert letter_grade(90) == "A"
    assert letter_grade(85) == "B"

Avec la règle erronée, la première assertion réussit. La deuxième échoue parce que 90 n’est pas supérieur à 90 ; l’exécution s’arrête là, avant la troisième assertion de cette fonction. Remplacer la première condition par score >= 90 corrige cette limite. Relance tous les tests pour vérifier le cas concerné et le comportement antérieur.

S’assurer que les tests s’exécutent réellement

Définir une fonction de test ne l’appelle pas. Sans outil d’exécution des tests, ajoute test_letter_grade() à la fin du fichier de test, puis exécute python test_grade.py. Pour utiliser pytest, installe-le avec python -m pip install pytest, puis exécute pytest test_grade.py dans le terminal. Il trouve les fonctions de test et indique leurs résultats. N’ajoute pas d’appels manuels lorsque tu confies leur exécution à un outil de test.

Un test qui se contente d’appeler letter_grade(90) ne comporte aucune comparaison. Il peut se terminer avec succès alors que la réponse renvoyée est incorrecte ; il n’échoue que si l’appel lève une exception inattendue. Une assertion relie l’appel au comportement attendu.

Tester les valeurs renvoyées et les propriétés des résultats aléatoires

Une fonction qui se contente d’afficher un total renvoie None. Une comparaison comme assert print_total([4, 6]) == 10 échoue donc même si l’écran affiche 10. Fais renvoyer sa réponse par la fonction de calcul, puis laisse main gérer l’affichage.

Les résultats aléatoires nécessitent une autre attente. On ne peut pas exiger qu’une fonction simulant un dé sans graine fixée renvoie exactement la même face à chaque appel. Vérifie que chacun des 100 appels renvoie une valeur autorisée de 1 à 6, ou initialise la graine avant une séquence reproductible. Un test des bornes réussi vérifie les bornes pour ces appels ; il ne prouve pas que toutes les faces sont équiprobables.

Lorsqu’un nouveau bug apparaît, ajoute un test qui échoue à cause de ce bug avant de corriger la fonction. Garde ce test de régression pour que les modifications ultérieures vérifient à nouveau le même comportement. Des tests réussis établissent ce qui s’est passé pour les cas testés ; d’autres entrées peuvent encore révéler un autre bug.

Python inclut unittest, un framework de test qui découvre les tests, les exécute et indique leurs résultats séparément. Il ne nécessite aucune installation avec pip. Sa structure de classe peut servir de modèle pendant que tu apprends à tester des fonctions.

Écrire des méthodes de test indépendantes

Pour une fonction dans grade.py, place ceci dans test_grade.py :

import unittest
from grade import letter_grade

class TestLetterGrade(unittest.TestCase):
    def test_top(self):
        self.assertEqual(letter_grade(95), "A")

    def test_boundary(self):
        self.assertEqual(letter_grade(90), "A")

    def test_low(self):
        self.assertEqual(letter_grade(50), "C")

if __name__ == "__main__":
    unittest.main()

TestLetterGrade hérite des outils de test de unittest.TestCase. Chaque test est une méthode dont le nom commence par test. self désigne l’objet test courant ; garde-le dans la liste des paramètres de chaque méthode et avant les appels aux méthodes d’assertion. Tu peux copier cette structure sans concevoir tes propres classes.

Par défaut, les tests s’exécutent par ordre alphabétique des noms de leurs méthodes : test_boundary vient donc avant test_low et test_top. Fais en sorte que chaque test fournisse ses propres entrées et fonctionne indépendamment des tests précédents.

Choisir une méthode d’assertion

Privilégie assertEqual(a, b) à assertTrue(a == b) pour comparer des valeurs : le rapport d’échec affiche les deux valeurs. Les méthodes de unittest conservent aussi leurs vérifications lorsque Python s’exécute avec -O.

Pour vérifier une exception attendue, encadre l’appel avec assertRaises :

def test_score_too_high(self):
    with self.assertRaises(ValueError):
        letter_grade(120)

Ce test exige que la règle de la fonction rejette cette note avec ValueError. Un retour sans exception fait échouer cette vérification ; une exception différente d’une exception d’assertion constitue une erreur.

Exécuter les tests et lire le rapport

Exécute python test_grade.py pour lancer son unittest.main() protégé par la garde. Ou exécute python -m unittest pour découvrir les fichiers test*.py du dossier courant. python -m unittest -v affiche les noms des tests individuellement et leurs résultats.

Dans le rapport court, . signifie réussite, F signifie qu’une assertion a échoué et E qu’une autre exception s’est produite. Pour une fonction de notation avec score > 90, les trois tests ci-dessus produisent F... Le rapport d’échec de test_boundary montre 'B' != 'A' : le résultat obtenu est "B", tandis que le résultat attendu est "A". Le récapitulatif indique trois tests et un échec.

Avant de modifier la fonction, vérifie l’attente du test par rapport aux règles de notation. Une attente incorrecte nécessite une correction du test. Si aucun test ne s’exécute, examine les noms des méthodes, la garde d’exécution directe et la commande de lancement. Évite aussi de nommer ton fichier unittest.py, car il masque le module standard.