Comment vérifier si une exception a été levée en Python

Introduction

Dans ce labo (atelier), vous apprendrez à vérifier si une exception a été levée en Python. Ce labo se concentre sur la compréhension des exceptions et l'utilisation des blocs try-except pour les intercepter et les gérer, afin d'éviter les plantages du programme.

Vous commencerez par créer un script Python qui lève une exception ZeroDivisionError. Ensuite, vous apprendrez à utiliser un bloc try-except pour intercepter cette exception et la gérer de manière élégante, permettant ainsi à votre programme de continuer à fonctionner.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/ErrorandExceptionHandlingGroup(["Error and Exception Handling"]) python/ErrorandExceptionHandlingGroup -.-> python/catching_exceptions("Catching Exceptions") python/ErrorandExceptionHandlingGroup -.-> python/raising_exceptions("Raising Exceptions") subgraph Lab Skills python/catching_exceptions -.-> lab-559611{{"Comment vérifier si une exception a été levée en Python"}} python/raising_exceptions -.-> lab-559611{{"Comment vérifier si une exception a été levée en Python"}} end

Comprendre les exceptions

Dans cette étape, vous apprendrez à propos des exceptions en Python. Les exceptions sont des événements qui se produisent lors de l'exécution d'un programme et qui perturbent le flux normal des instructions. Comprendre les exceptions est essentiel pour écrire un code Python robuste et fiable.

Lorsqu'une erreur se produit en Python, une exception est levée. Si l'exception n'est pas gérée, le programme se terminera et affichera un message d'erreur. Cependant, en utilisant des blocs try-except, vous pouvez intercepter et gérer les exceptions, empêchant ainsi votre programme de planter.

Commençons par un exemple simple qui lève une exception :

Ouvrez l'éditeur VS Code dans l'environnement LabEx.
Créez un nouveau fichier nommé division.py dans le répertoire ~/project.
```
~/project/division.py
```
Ajoutez le code suivant au fichier division.py :
```
numerator = 10
denominator = 0
result = numerator / denominator
print(result)
```
Ce code tente de diviser 10 par 0, ce qui est une opération invalide et qui lèvera une exception ZeroDivisionError.
Exécutez le script en utilisant la commande suivante dans le terminal :
```
python division.py
```
Vous verrez une sortie similaire à celle-ci :
```
Traceback (most recent call last):
  File "/home/labex/project/division.py", line 3, in <module>
    result = numerator / denominator
ZeroDivisionError: division by zero
```
La traceback montre qu'une ZeroDivisionError s'est produite à la ligne 3 du fichier division.py. Le programme s'est terminé car l'exception n'a pas été gérée.

Maintenant, voyons comment gérer cette exception en utilisant un bloc try-except.

Utiliser try-except pour intercepter

Dans cette étape, vous apprendrez à utiliser les blocs try-except pour intercepter et gérer les exceptions en Python. Cela permet à votre programme de continuer à fonctionner même lorsqu'il se produit des erreurs.

La structure de base d'un bloc try-except est la suivante :

try:
    ## Code that might raise an exception
except ExceptionType:
    ## Code to handle the exception

Le code à l'intérieur du bloc try est exécuté. Si une exception de type ExceptionType se produit, le code à l'intérieur du bloc except est exécuté. Si aucune exception ne se produit, le bloc except est ignoré.

Modifions le fichier division.py de l'étape précédente pour gérer l'exception ZeroDivisionError :

Ouvrez le fichier division.py dans l'éditeur VS Code.
Modifiez le code pour inclure un bloc try-except :
```
try:
    numerator = 10
    denominator = 0
    result = numerator / denominator
    print(result)
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
```
Dans ce code, le bloc try contient l'opération de division qui peut lever une ZeroDivisionError. Le bloc except intercepte la ZeroDivisionError et affiche un message d'erreur.
Exécutez le script en utilisant la commande suivante dans le terminal :
```
python division.py
```
Vous verrez la sortie suivante :
```
Error: Cannot divide by zero.
```
Au lieu de planter, le programme gère maintenant de manière élégante la ZeroDivisionError et affiche un message informatif.

Cela démontre comment les blocs try-except peuvent être utilisés pour empêcher votre programme de planter en raison d'exceptions.

Inspecter le type d'exception

Dans cette étape, vous apprendrez à inspecter le type d'exception et à accéder au message d'exception à l'intérieur du bloc except. Cela vous permet de gérer différents types d'exceptions de différentes manières et de fournir des messages d'erreur plus informatifs.

Lorsqu'une exception est interceptée, vous pouvez l'affecter à une variable dans la clause except en utilisant le mot-clé as :

try:
    ## Code that might raise an exception
except ExceptionType as e:
    ## Code to handle the exception
    ## 'e' is the exception object

La variable e contiendra alors l'objet d'exception, que vous pouvez utiliser pour accéder à des informations sur l'exception, telles que son type et son message.

Modifions le fichier division.py pour inspecter le type d'exception et afficher le message d'exception :

Ouvrez le fichier division.py dans l'éditeur VS Code.
Modifiez le code pour inspecter le type d'exception et afficher le message :
```
try:
    numerator = 10
    denominator = 0
    result = numerator / denominator
    print(result)
except ZeroDivisionError as e:
    print(f"Error: {type(e).__name__} - {e}")
```
Dans ce code, nous interceptionnons la ZeroDivisionError et l'affectons à la variable e. Nous utilisons ensuite type(e).__name__ pour obtenir le nom du type d'exception et e pour obtenir le message d'exception. Nous affichons les deux dans une chaîne formatée.
Exécutez le script en utilisant la commande suivante dans le terminal :
```
python division.py
```
Vous verrez la sortie suivante :
```
Error: ZeroDivisionError - division by zero
```
La sortie inclut maintenant le type d'exception (ZeroDivisionError) et le message d'exception (division by zero).

Cela vous permet de fournir des informations plus détaillées sur l'erreur qui s'est produite, facilitant ainsi le débogage de votre code. Vous pouvez également utiliser ces informations pour gérer différents types d'exceptions de différentes manières, fournissant une gestion d'erreur plus spécifique pour chaque cas.

Résumé

Dans ce laboratoire (lab), vous avez appris à connaître les exceptions en Python, qui sont des événements qui perturbent le flux normal d'un programme. Lorsqu'une erreur se produit, une exception est levée, et si elle n'est pas gérée, le programme se termine.

Vous avez également appris à utiliser les blocs try-except pour intercepter et gérer les exceptions, évitant ainsi les plantages du programme. Le laboratoire a démontré une ZeroDivisionError et comment utiliser try-except pour la gérer.