Comment vérifier si une fonction lève une exception en Python

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une fonction lève une exception en Python. Le laboratoire commence par explorer les exceptions et comment elles peuvent se produire dans les fonctions. Vous allez créer une simple fonction Python qui peut lever une ZeroDivisionError et observer la trace d'erreur (traceback) lorsque l'exception se produit.

Ensuite, vous allez implémenter un bloc try-except pour gérer l'exception de manière élégante. Enfin, vous apprendrez à utiliser pytest.raises pour tester si une fonction lève une exception spécifique (introduction optionnelle).

Skills Graph

Explorer les exceptions dans les fonctions

Dans cette étape, vous allez apprendre à propos des exceptions et comment elles peuvent se produire dans les fonctions en Python. Comprendre les exceptions est essentiel pour écrire un code robuste et fiable. Les exceptions sont des événements qui interrompent le flux normal d'exécution d'un programme. Elles peuvent se produire pour diverses raisons, telles qu'une entrée invalide, un fichier introuvable ou des erreurs réseau.

Commençons par créer une simple fonction Python qui peut lever une exception. Ouvrez l'éditeur VS Code dans l'environnement LabEx et créez un nouveau fichier nommé exceptions_example.py dans le répertoire ~/project.

## ~/project/exceptions_example.py
def divide(x, y):
    return x / y

print(divide(10, 2))
print(divide(5, 0))

Dans ce code :

• Nous définissons une fonction appelée divide qui prend deux arguments, x et y, et renvoie le résultat de la division de x par y.
• Nous appelons d'abord la fonction divide avec les arguments 10 et 2, ce qui entraînera l'affichage de 5.0 dans la console.
• Ensuite, nous appelons la fonction divide avec les arguments 5 et 0. Cela provoquera une ZeroDivisionError car la division par zéro n'est pas autorisée.

Maintenant, exécutons ce script. Ouvrez le terminal dans VS Code (vous le trouverez sous "View" -> "Terminal") et exécutez la commande suivante :

python ~/project/exceptions_example.py

Vous verrez une sortie similaire à celle-ci :

5.0
Traceback (most recent call last):
  File "/home/labex/project/exceptions_example.py", line 4, in <module>
    print(divide(5, 0))
  File "/home/labex/project/exceptions_example.py", line 2, in divide
    return x / y
ZeroDivisionError: division by zero

Comme vous pouvez le voir, la première instruction print s'est exécutée avec succès, et le résultat 5.0 a été affiché. Cependant, lorsque la fonction divide a été appelée avec y = 0, une ZeroDivisionError s'est produite, et le programme s'est terminé. La trace d'erreur (traceback) montre la séquence d'appels de fonctions qui a conduit à l'exception, ce qui peut être utile pour le débogage.

Cet exemple montre comment les exceptions peuvent se produire dans les fonctions et comment elles peuvent interrompre le flux normal d'un programme. Dans l'étape suivante, vous apprendrez à gérer les exceptions à l'aide de blocs try et except.

Implémenter un bloc try-except

Dans l'étape précédente, vous avez vu comment les exceptions peuvent faire terminer brutalement un programme. Pour gérer les exceptions de manière élégante et éviter les plantages du programme, vous pouvez utiliser des blocs try et except.

Un bloc try vous permet d'enfermer une section de code qui peut lever une exception. Si une exception se produit dans le bloc try, le programme saute au bloc except correspondant, où vous pouvez gérer l'exception.

Modifions le fichier exceptions_example.py pour inclure un bloc try-except afin de gérer la ZeroDivisionError. Ouvrez le fichier exceptions_example.py dans l'éditeur VS Code et modifiez-le comme suit :

## ~/project/exceptions_example.py
def divide(x, y):
    try:
        result = x / y
        return result
    except ZeroDivisionError:
        return "Cannot divide by zero!"

print(divide(10, 2))
print(divide(5, 0))
print(divide(8, 4))

Dans ce code modifié :

• Nous avons ajouté un bloc try autour de l'opération x / y. Cela signifie que si une ZeroDivisionError se produit lors de la division, le programme saute au bloc except.
• La ligne except ZeroDivisionError: précise que nous voulons gérer les exceptions de type ZeroDivisionError.
• À l'intérieur du bloc except, nous renvoyons la chaîne de caractères "Cannot divide by zero!". Cette chaîne sera affichée dans la console au lieu de faire planter le programme.

Maintenant, exécutons le script modifié. Ouvrez le terminal dans VS Code et exécutez la commande suivante :

python ~/project/exceptions_example.py

Vous verrez une sortie similaire à celle-ci :

5.0
Cannot divide by zero!
2.0

Comme vous pouvez le voir, le programme ne plante plus lorsqu'il effectue une division par zéro. Au lieu de cela, le bloc except intercepte la ZeroDivisionError, et le message "Cannot divide by zero!" est affiché. Le programme continue ensuite son exécution, et la dernière instruction print est également exécutée avec succès.

Les blocs try-except peuvent également être utilisés pour gérer d'autres types d'exceptions. Par exemple, vous pouvez utiliser un bloc try-except pour gérer les exceptions TypeError qui peuvent se produire si vous essayez d'effectuer une opération sur des types de données incompatibles. Vous pouvez également avoir plusieurs blocs except pour gérer différents types d'exceptions.

Dans l'étape suivante, vous apprendrez à utiliser pytest pour tester les exceptions.

Tester avec pytest.raises (Introduction optionnelle)

Dans cette étape optionnelle, vous aurez une brève introduction à l'utilisation de pytest pour tester les exceptions. pytest est un framework de test populaire pour Python qui simplifie le processus d'écriture et d'exécution de tests.

Tout d'abord, installons pytest. Ouvrez le terminal dans VS Code et exécutez la commande suivante :

pip install pytest

Cette commande téléchargera et installera pytest et ses dépendances.

Maintenant, créons un fichier de test pour notre fonction divide. Créez un nouveau fichier nommé test_exceptions.py dans le répertoire ~/project.

## ~/project/test_exceptions.py
import pytest
from exceptions_example import divide

def test_divide_by_zero():
    with pytest.raises(ZeroDivisionError):
        divide(5, 0)

def test_divide_valid():
    assert divide(10, 2) == 5

Dans ce code :

• Nous importons le module pytest et la fonction divide depuis notre fichier exceptions_example.py.
• Nous définissons une fonction de test appelée test_divide_by_zero. Cette fonction utilise pytest.raises pour affirmer que l'appel de divide(5, 0) lèvera une ZeroDivisionError. Le bloc with pytest.raises(ZeroDivisionError): garantit que le test ne réussira que si une ZeroDivisionError est levée à l'intérieur du bloc.
• Nous définissons une autre fonction de test appelée test_divide_valid. Cette fonction affirme que l'appel de divide(10, 2) renvoie la valeur 5.

Pour exécuter les tests, ouvrez le terminal dans VS Code et exécutez la commande suivante :

pytest ~/project/test_exceptions.py

Vous devriez voir une sortie similaire à celle-ci :

============================= test session starts ==============================
platform linux -- Python 3.10.12, pytest-7.4.4, pluggy-1.3.0
rootdir: /home/labex/project
collected 2 items

test_exceptions.py ..                                                      [100%]

============================== 2 passed in 0.01s ===============================

La sortie montre que deux tests ont été collectés et que tous les tests ont réussi. Cela indique que notre fonction divide se comporte comme prévu : elle lève une ZeroDivisionError lors d'une division par zéro et renvoie le bon résultat lors d'une division par un nombre non nul.

C'est un exemple très basique d'utilisation de pytest pour tester les exceptions. pytest a de nombreuses autres fonctionnalités qui peuvent vous aider à écrire des tests plus complets et efficaces.

Résumé

Dans ce laboratoire (lab), vous avez commencé par explorer les exceptions dans les fonctions Python, en comprenant que les exceptions sont des événements qui perturbent le flux normal d'un programme. Vous avez créé une fonction divide qui lève une ZeroDivisionError lors d'une division par zéro. L'exécution du script montre comment l'exception met fin au programme et fournit une trace d'erreur (traceback) pour le débogage.

Le laboratoire souligne l'importance de comprendre les exceptions pour écrire un code robuste, en présentant un exemple simple d'une fonction susceptible de lever une exception et de comment observer l'erreur résultante et la trace d'erreur lorsque l'exception se produit.