Débogage efficace avec l’instruction Python Assert

Êtes-vous un développeur de logiciels ? Si c’est le cas, vous savez sans doute que le débogage est une aptitude incontournable, quel que soit le langage de programmation que vous employez. Dans cet article, nous allons explorer comment utiliser l’instruction `assert` en Python pour un débogage plus efficace.

Lorsque vous travaillez sur un projet, vous structurez votre code en différents modules, qu’il s’agisse de fonctions, de définitions de classes ou d’autres éléments. Il est fort probable que vous rencontriez des erreurs ou des comportements inattendus dus à des anomalies dans votre implémentation. Les assertions se révèlent très utiles pour identifier et corriger ces problèmes.

Ce tutoriel vous guidera à travers la syntaxe de l’instruction `assert`, accompagnée d’exemples de code concrets pour illustrer son fonctionnement. Nous aborderons également les erreurs d’assertion et la manière dont vous pouvez les exploiter pour débusquer les erreurs de votre code pendant la phase de développement.

Alors, commençons sans plus tarder !

Comment exploiter l’instruction `assert` en Python

Nous allons commencer par examiner la syntaxe de l’instruction `assert`, avant de nous plonger dans quelques exemples pratiques.

Syntaxe de l’instruction `assert`

Voici la syntaxe de base pour utiliser l’instruction `assert` en Python :

assert expression, message

Où :

• `expression` est une expression Python valide qui sera évaluée. Elle peut prendre la forme d’une condition sur la valeur d’une variable, la valeur booléenne d’une variable, la valeur de retour d’une fonction, etc.
• Si `expression` est évaluée à `True`, l’instruction `assert` ne génère aucune erreur et n’a pas d’effet. Cela signifie que le programme fonctionne comme prévu.
• Si `expression` est évaluée à `False`, une exception `AssertionError` est levée.
• `message` est une chaîne de caractères optionnelle. Vous pouvez spécifier un message qui sera affiché dans la trace chaque fois qu’une exception `AssertionError` est déclenchée.

Maintenant, passons à l’étude de quelques exemples où l’instruction `assert` peut nous aider à créer un code plus propre et sans erreurs.

Vous trouverez les exemples de code utilisés dans ce tutoriel sur ce gist GitHub.

Exemples d’utilisation de l’instruction `assert` en Python

Prenons l’exemple suivant : Imaginons que vous ayez une variable `remise` dans votre code. Vous souhaitez que sa valeur soit toujours inférieure ou égale à `remise_max`.

Pour vérifier que vous n’avez pas accidentellement attribué une valeur incorrecte à la variable `remise`, vous pouvez utiliser une assertion. L’expression à évaluer sera : `remise <= remise_max`.

>>> remise_max = 50
>>> remise = 20
>>> assert remise <= remise_max

Ici, la valeur de `remise` (20) est bien inférieure à `remise_max` (50). Par conséquent, l’instruction `assert` ne produit pas d’erreur.

L’exception `AssertionError`

Si la variable `remise` est définie avec une valeur supérieure à `remise_max`, une exception `AssertionError` sera levée.

>>> remise = 75
>>> assert remise <= remise_max
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

Comme nous l’avons mentionné, l’instruction `assert` vous permet également de spécifier un message facultatif.

Utilisons un message qui fournira des informations de diagnostic plus détaillées. Ajoutons une chaîne f-string en Python qui contient les valeurs de `remise` et `remise_max` :

>>> assert remise <= remise_max, f"La remise doit être au plus {remise_max} ; la remise obtenue est de {remise}"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: La remise doit être au plus 50 ; la remise obtenue est de 75

Comme le montre la sortie ci-dessus, l’exception `AssertionError` inclut maintenant les valeurs des variables `remise` et `remise_max`, ce qui facilite le débogage.

Déboguer et tester les fonctions Python avec `assert`

Lors de la définition de fonctions, il peut arriver d’introduire involontairement des bugs (erreurs logiques) qui empêchent votre fonction de se comporter comme prévu.

Prenons un exemple : Imaginons un examen où les élèves ont la possibilité de répondre à une question bonus. Tout étudiant qui tente la question bonus recevra 10 points supplémentaires à son score d’examen. 😄

Considérez la fonction `obtenir_score_final` suivante :

• Elle prend en paramètres un score actuel, un score et un booléen `bonus`.
• Si un élève a répondu à la question bonus, le booléen `bonus` est vrai et l’élève reçoit 10 points de plus que son score actuel.
• La fonction retourne ensuite le score final.

def obtenir_score_final(score, bonus):
    if bonus:
        score += 10
    return score

Effectuons quelques appels à la fonction. Nous constatons que pour des scores de 34 et 40 avec un bonus défini sur `True` et `False`, les scores finaux sont respectivement de 44 et 40.

print(obtenir_score_final(34, True))
# 44
print(obtenir_score_final(40, False))
# 40

Cependant, le nombre maximal de points à l’examen est de, disons, 50. Donc, si un étudiant obtient 49 et a également répondu à la question bonus, la fonction `obtenir_score_final` calculera le score final avec plaisir à 59.

print(obtenir_score_final(49, True))
# 59

Techniquement, c’est possible. Mais supposons qu’un étudiant ne puisse pas obtenir plus de points que le maximum possible à l’examen. 🙂

Déclarons donc une variable `score_max`. Et stockons le score retourné par la fonction dans la variable `score_final`.

Puis, nous ajoutons une assertion qui vérifie si le `score_final` est inférieur ou égal à `score_max`.

def obtenir_score_final(score, bonus):
    if bonus:
        score += 10
    return score

score_final = obtenir_score_final(47, True)
score_max = 50

assert score_final <= score_max

Nous obtenons maintenant une exception `AssertionError` pour l’appel à la fonction `obtenir_score_final(47, True)` :

Traceback (most recent call last):
  File "main.py", line 17, in <module>
    assert score_final <= score_max
AssertionError

Ajoutons maintenant une f-string descriptive à l’instruction `assert` de Python :

assert score_final <= score_max, f"Le score final doit être au plus {score_max} ; obtenu : {score_final}"

Traceback (most recent call last):
  File "main.py", line 17, in <module>
    assert score_final <= score_max, f"Le score final doit être au plus {score_max} ; obtenu : {score_final}"
AssertionError: Le score final doit être au plus 50 ; obtenu : 57

Modification de la fonction

Retournons en arrière et modifions la définition de la fonction `obtenir_score_final` pour corriger ce comportement inattendu :

• La fonction `obtenir_score_final` prend maintenant également `score_max` en paramètre.
• Nous vérifions si `bonus` est vrai. Si c’est le cas, nous ajoutons 10 points à la variable `score`.
• Ensuite, nous vérifions si `score` est supérieur à `score_max`. Si c’est le cas, nous retournons `score_max`.
• Sinon, nous retournons le score.

Nous nous sommes assurés que le score final est toujours inférieur ou égal à `score_max`.

def obtenir_score_final(score, bonus, score_max):
    if bonus:
        score += 10
    if score > score_max:
        return score_max
    return score

Pour vous entraîner, écrivez quelques assertions pour confirmer que la fonction fonctionne maintenant comme prévu.

Remarque importante sur l’exception `AssertionError`

Bien qu’une exception `AssertionError` soit levée lorsque l’expression est évaluée à `False`, il est important de ne pas traiter ces erreurs comme des exceptions que l’on doit gérer. Cela signifie que vous ne devriez pas faire quelque chose comme ceci :

try:
    <faire ceci>
except AssertionError:
    <faire cela>

Dans l’exemple précédent sur `obtenir_score_final`, nous avons utilisé l’assertion pour vérifier si `score_final` était inférieur à `score_max`. Puis, nous avons modifié la définition de la fonction pour qu’il n’y ait plus d’erreurs d’assertion.

C’est précisément le rôle des assertions. Il s’agit de vérifications de cohérence dans le code, qui aident à écrire un code plus propre. La gestion des exceptions, quant à elle, consiste à anticiper et à gérer les erreurs inattendues pendant l’exécution, par exemple des types et des valeurs d’entrée non valides.

En résumé, vous devez utiliser l’instruction `assert` de Python pour un débogage efficace et ne pas traiter les erreurs `AssertionError` comme des exceptions à gérer.

Conclusion

Ce tutoriel vous a aidé à comprendre comment utiliser l’instruction `assert` en Python. Voici un résumé de ce que vous avez appris :

• Les instructions `assert` en Python (assertions) prennent la forme `assert expression`. Cela vérifie si l’expression est vraie. Si ce n’est pas le cas, une exception `AssertionError` est levée.
• Vous pouvez également utiliser l’assertion avec la syntaxe `assert expression, message`. Cela affichera la chaîne de message chaque fois qu’une exception `AssertionError` se produit.
• N’oubliez pas de ne pas implémenter la gestion des exceptions pour gérer les erreurs d’assertion. Et utilisez les assertions comme un outil de débogage pratique pour vérifier l’intégrité de votre code.

En tant que développeur, les assertions vous aident à déboguer. Pour garantir que tous les éléments individuels (modules) de votre projet fonctionnent comme prévu, il peut être intéressant d’apprendre à écrire des tests unitaires en Python.

Pour aller plus loin, consultez cette liste de projets Python pour débutants sur lesquels vous pourrez vous exercer.