Débogage efficace avec l’instruction Python Assert

Êtes-vous un programmeur? Si tel est le cas, le débogage est une compétence essentielle, quel que soit le langage dans lequel vous codez. Dans cet article, vous apprendrez à utiliser l’instruction assert en Python pour un débogage efficace.

Lorsque vous travaillez sur un projet, vous définissez plusieurs modules. Cela inclut les fonctions, les définitions de classe, etc. Et vous rencontrerez probablement des erreurs ou des résultats inattendus à cause d’un bogue dans l’implémentation. Les déclarations d’assertion sont utiles pour déboguer ce code.

Dans ce tutoriel, nous allons apprendre la syntaxe pour utiliser l’instruction assert suivie d’exemples de code pour la voir en action. Nous verrons également quelles sont les erreurs d’assertion et comment nous pouvons les utiliser pour corriger les erreurs dans le code pendant le développement.

Commençons!

Comment utiliser l’instruction Assert en Python

Nous allons apprendre la syntaxe pour utiliser l’instruction assert, puis procéder au codage de quelques exemples.

Syntaxe de l’instruction Assert

Commençons par la syntaxe pour utiliser l’instruction assert en Python :

assert expression, message

Ici,

• expression est une expression Python valide à évaluer. Cela peut être une condition sur la valeur de la variable, la valeur de vérité de la variable, la valeur de retour d’une fonction, etc.
• Tant que l’expression est évaluée à True, l’instruction assert ne renvoie pas d’erreur et ne renvoie rien. Cela indique que le programme fonctionne comme prévu.
• Si l’expression n’est plus True, une exception AssertionError est déclenchée.
• message est une chaîne facultative. Vous pouvez spécifier un message qui s’affiche dans la trace chaque fois qu’une exception AssertionError est déclenchée.

Ensuite, passons au code de quelques exemples où l’instruction assert peut nous aider à écrire du code plus propre et sans bogue.

Vous pouvez trouver les exemples de code utilisés dans ce didacticiel dans ce gist GitHub.

Exemples d’instructions Assert de Python

Prenons l’exemple suivant. Supposons que vous ayez une variable de remise dans votre code. Mais vous aimeriez que sa valeur soit toujours inférieure ou égale à max_discount.

Pour vérifier que vous n’avez pas accidentellement défini la variable discount sur une valeur, vous pouvez ajouter une assertion. L’expression à évaluer est : discount <= max_discount.

>>> max_discount = 50
>>> discount = 20
>>> assert discount <= max_discount

Ici, la remise (20) est inférieure à max_discount (50). Ainsi, l’instruction assert ne génère aucune erreur.

L’exception AssertionError

Si la variable discount est définie sur une valeur supérieure à max_discount, une exception AssertionError est déclenchée.

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

Nous savons que l’instruction assert nous permet également de spécifier une chaîne de message facultative.

Utilisons également une chaîne de message qui donne des informations de diagnostic plus descriptives. À l’instruction assert, ajoutons une f-string Python qui contient également les valeurs de discount et max_discount.

>>> assert discount <= max_discount, f"discount should be at most {max_discount}; got discount = {discount}"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: discount should be at most 50; got discount = 75

Comme indiqué dans la cellule de sortie ci-dessus, l’exception AssertionError inclut désormais les valeurs des variables discount et max_discount.

Débogage et test des fonctions Python avec Assert

Lors de la définition des fonctions, vous pouvez parfois introduire par inadvertance des bogues (erreurs logiques) qui empêcheront votre fonction de fonctionner comme prévu.

Prenons un exemple. Supposons qu’il y ait un test dans une classe et que les élèves aient la possibilité de répondre à une question bonus. Tout étudiant qui tente la question bonus obtiendra 10 points supplémentaires au test. 😄

Considérez la fonction suivante get_final_score :

• Il prend en compte un score actuel, un score et un bonus booléen.
• Si un élève a répondu à la question bonus, le bonus booléen est vrai et il obtient 10 points de plus que son score actuel.
• La fonction renvoie ensuite le score final.

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

Faisons quelques appels à la fonction. Nous voyons que pour les scores de 34 et 40 avec un bonus défini sur Vrai et Faux, les scores finaux sont respectivement de 44 et 40.

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

Cependant, le maximum de points au test est, disons, de 50. Donc, si un étudiant obtient 49 et a également répondu à la question bonus, la fonction get_final_score calculera avec plaisir le score final à 59.

print(get_final_score(49,True))
# 59

Techniquement, c’est possible. Mais supposons qu’un étudiant ne peut pas marquer plus que le maximum de points possibles pour le test. 🙂

Initialisons donc une variable max_score. Et capturez le score renvoyé par la fonction dans la variable final_score.

Ensuite, nous ajoutons une assertion qui vérifie si le final_score est inférieur au max_score.

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

final_score = get_final_score(47,True)
max_score = 50

assert final_score <= max_score

Nous obtenons maintenant une exception AssertionError pour l’appel de fonction get_final_score(47,True) :

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

Nous ajoutons maintenant une chaîne f descriptive à l’instruction assert Python :

assert final_score <= max_score,f"final_score should be at most {max_score}; got {final_score}"

Traceback (most recent call last):
  File "main.py", line 17, in <module>
    assert final_score <= max_score,f"final_score should be at most {max_score}; got {final_score}"
AssertionError: final_score should be at most 50; got 57

Modification de la fonction

Revenons en arrière et modifions la définition de la fonction get_final_score pour corriger le comportement inattendu :

• La fonction get_final_score prend également max_score en paramètre.
• Nous vérifions si le bonus est Vrai. Si True, nous ajoutons 10 points à la variable score.
• Ensuite, nous vérifions si score est supérieur à max_score. Si c’est le cas, nous retournons max_score.
• Sinon, nous rendons le score.

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

def get_final_score(score,bonus,max_score):
    if bonus:
        score += 10
    if score > max_score:
        return max_score
    return score

Comme exercice rapide, écrivez quelques assertions pour confirmer que la fonction fonctionne maintenant comme prévu.

Remarque sur l’exception AssertionError

Bien qu’une exception AssertionError se produise lorsque l’expression est évaluée à False, nous devons nous rappeler de ne pas gérer ces erreurs comme des exceptions. Cela signifie que nous ne devrions pas faire quelque chose comme ça :

try:
    <doing this>
except AssertionError:
    <do this>

Dans l’exemple précédent sur get_final_score, nous avons utilisé l’assertion pour vérifier si final_score est inférieur à max_score. Ensuite, nous avons modifié la définition de la fonction de sorte qu’il n’y ait pas d’erreurs d’assertion.

C’est à ça que servent les affirmations. Ce sont des vérifications de cohérence pour le code et aident à écrire un code plus propre. La gestion des exceptions, quant à elle, consiste à anticiper et à gérer les erreurs inattendues lors de l’exécution. Ceux-ci incluent souvent des types et des valeurs d’entrée non valides.

Pour résumer, vous devez utiliser l’instruction Python assert pour un débogage efficace et ne pas gérer les AssertionErrors comme des exceptions.

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 Python assert (assertions) prennent la forme assert expression. Ceci vérifie si l’expression est vraie. S’il n’est pas évalué à True, une exception AssertionError est déclenchée.
• Vous pouvez également utiliser l’assertion avec la syntaxe assert expression, message. Cela imprimera 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 outil de débogage utile pour vérifier l’intégrité de votre code.

En tant que développeur, les assertions vous aident à déboguer. Pour vous assurer que tous les composants individuels (modules) du projet fonctionnent comme prévu, vous pouvez apprendre à écrire des tests unitaires en Python.

Ensuite, consultez cette liste de projets Python pour débutants sur lesquels vous pouvez travailler.