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

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une exception a été capturée en Python en utilisant différentes techniques. Le laboratoire se concentre sur la gestion des exceptions, un aspect crucial de l'écriture de code Python robuste et fiable.

Le laboratoire vous guide dans la compréhension du flux de gestion des exceptions en utilisant des blocs try...except pour gérer gracieusement les erreurs telles que ZeroDivisionError. Vous apprendrez à définir un indicateur (flag) dans le bloc except pour indiquer qu'une exception a été capturée. Enfin, le laboratoire présentera le concept d'utilisation de gestionnaires de contexte (context managers) pour une gestion plus contrôlée des exceptions.

Apprendre le flux de gestion des exceptions

Dans cette étape, vous allez apprendre à gérer les exceptions en Python. La gestion des exceptions est une partie cruciale de l'écriture de code robuste et fiable. Elle vous permet de gérer gracieusement les erreurs qui pourraient survenir lors de l'exécution de votre programme, évitant ainsi son plantage et offrant une expérience plus conviviale pour l'utilisateur.

Commençons par un exemple simple. Imaginez que vous souhaitiez diviser deux nombres, mais que le deuxième nombre pourrait être zéro. La division par zéro est une opération indéfinie et lèvera une ZeroDivisionError en Python.

Ouvrez l'éditeur VS Code dans l'environnement LabEx.
Créez un nouveau fichier nommé division.py dans le répertoire ~/project.
```
touch ~/project/division.py
```

Modifiez le fichier division.py et ajoutez le code suivant :

## division.py
numerator = 10
denominator = 0

result = numerator / denominator

print(result)

Exécutez le script en utilisant la commande python :
```
python ~/project/division.py
```

Vous verrez un message d'erreur similaire à celui-ci :

Traceback (most recent call last):
  File "/home/labex/project/division.py", line 4, in <module>
    result = numerator / denominator
ZeroDivisionError: division by zero

Ce message d'erreur indique qu'une ZeroDivisionError s'est produite car nous avons essayé de diviser par zéro. Sans gestion des exceptions, le programme se termine brusquement.

Maintenant, utilisons la gestion des exceptions pour gérer cette erreur de manière gracieuse.

Modifiez le fichier division.py pour inclure un bloc try...except :
```
## division.py
numerator = 10
denominator = 0

try:
    result = numerator / denominator
    print(result)
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
```
Dans ce code, le bloc try contient le code qui peut lever une exception. Si une ZeroDivisionError se produit dans le bloc try, le code dans le bloc except sera exécuté.
Exécutez le script à nouveau :
```
python ~/project/division.py
```

Maintenant, au lieu de planter, le programme affichera :

Error: Cannot divide by zero.

Cela démontre la structure de base de la gestion des exceptions :

Le bloc try englobe le code qui peut lever une exception.
Le bloc except spécifie le type d'exception à capturer et le code à exécuter si cette exception se produit.

Vous pouvez également capturer plusieurs types d'exceptions en utilisant plusieurs blocs except :

## division.py
numerator = 10
denominator = "abc"

try:
    result = numerator / int(denominator)
    print(result)
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
except ValueError:
    print("Error: Invalid input. Please enter a number.")

Dans cet exemple, nous avons ajouté un gestionnaire d'exception ValueError. Si le denominator ne peut pas être converti en entier (par exemple, s'il s'agit d'une chaîne de caractères comme "abc"), une ValueError sera levée et le bloc except correspondant sera exécuté.

Exécutez le script :

python ~/project/division.py

Sortie :

Error: Invalid input. Please enter a number.

La gestion des exceptions vous permet d'écrire des programmes plus robustes et conviviaux en anticipant et en gérant les erreurs potentielles.

Définir un indicateur (flag) dans le bloc except

Dans cette étape, vous apprendrez à utiliser un indicateur (flag) dans un bloc except pour contrôler le flux de votre programme en fonction de l'occurrence ou non d'une exception. Cette technique est utile lorsque vous devez effectuer des actions différentes en fonction du résultat du bloc try.

En vous appuyant sur l'exemple précédent, disons que vous souhaitez calculer le nombre inverse (réciproque) d'un nombre, mais seulement si la division a réussi. Vous pouvez utiliser un indicateur pour indiquer si la division a été un succès, puis calculer le nombre inverse en conséquence.

Ouvrez l'éditeur VS Code dans l'environnement LabEx.

Modifiez le fichier division.py dans le répertoire ~/project pour inclure un indicateur :

## division.py
numerator = 10
denominator = 2
success = True  ## Initialisez l'indicateur à True

try:
    result = numerator / denominator
    print("Result of division:", result)
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
    success = False  ## Définissez l'indicateur à False si une erreur se produit
except ValueError:
    print("Error: Invalid input. Please enter a number.")
    success = False ## Définissez l'indicateur à False si une erreur se produit
else:
    print("No exception occurred.")

if success:
    try:
        reciprocal = 1 / result
        print("Reciprocal:", reciprocal)
    except ZeroDivisionError:
        print("Cannot calculate reciprocal of zero.")
else:
    print("Reciprocal calculation skipped due to error.")

Dans ce code :

Nous initialisons un indicateur nommé success à True avant le bloc try.
Si une ZeroDivisionError ou une ValueError se produit, nous définissons l'indicateur success à False dans le bloc except correspondant.
Après le bloc try...except, nous vérifions la valeur de l'indicateur success. S'il est toujours True, cela signifie qu'aucune exception ne s'est produite, et nous pouvons calculer en toute sécurité le nombre inverse. Sinon, nous sautons le calcul du nombre inverse.
Nous avons également ajouté un bloc else, qui sera exécuté si aucune exception ne se produit dans le bloc try.

Exécutez le script avec un dénominateur valide :

python ~/project/division.py

Sortie :

Result of division: 5.0
No exception occurred.
Reciprocal: 0.2

Maintenant, changez le denominator en 0 et exécutez le script à nouveau :

## division.py
numerator = 10
denominator = 0 ## Changez le dénominateur en 0
success = True

try:
    result = numerator / denominator
    print("Result of division:", result)
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
    success = False
except ValueError:
    print("Error: Invalid input. Please enter a number.")
    success = False
else:
    print("No exception occurred.")

if success:
    try:
        reciprocal = 1 / result
        print("Reciprocal:", reciprocal)
    except ZeroDivisionError:
        print("Cannot calculate reciprocal of zero.")
else:
    print("Reciprocal calculation skipped due to error.")

Exécutez le script :

python ~/project/division.py

Sortie :

Error: Cannot divide by zero.
Reciprocal calculation skipped due to error.

Cela démontre comment vous pouvez utiliser un indicateur dans le bloc except pour contrôler le flux de votre programme et effectuer des actions différentes en fonction de l'occurrence ou non d'une exception.

Utiliser des gestionnaires de contexte pour le contrôle

Dans cette étape, vous apprendrez à utiliser les gestionnaires de contexte (context managers) en Python pour simplifier la gestion des exceptions et garantir que les ressources sont correctement gérées, même si des exceptions se produisent. Les gestionnaires de contexte sont particulièrement utiles lorsqu'il s'agit de travailler avec des fichiers, des connexions réseau et d'autres ressources qui doivent être explicitement fermées ou libérées.

Un gestionnaire de contexte est un objet qui définit les méthodes __enter__ et __exit__. L'instruction with est utilisée pour exécuter un bloc de code dans le contexte d'un gestionnaire de contexte. La méthode __enter__ est appelée lorsque le bloc with est entré, et la méthode __exit__ est appelée lorsque le bloc with est quitté, qu'une exception se soit produite ou non.

Commençons par un exemple simple de lecture d'un fichier à l'aide d'un gestionnaire de contexte.

Ouvrez l'éditeur VS Code dans l'environnement LabEx.
Créez un nouveau fichier nommé file_handling.py dans le répertoire ~/project.
```
touch ~/project/file_handling.py
```
Modifiez le fichier file_handling.py et ajoutez le code suivant :
```
## file_handling.py

filename = "my_file.txt"

try:
    with open(filename, "w") as f:
        f.write("Hello, LabEx!\n")
        f.write("This is a test file.\n")
except IOError as e:
    print(f"An I/O error occurred: {e}")

try:
    with open(filename, "r") as f:
        content = f.read()
        print("File content:")
        print(content)
except FileNotFoundError:
    print(f"The file '{filename}' was not found.")
except IOError as e:
    print(f"An I/O error occurred: {e}")
```
Dans ce code :
- Nous utilisons l'instruction with open(filename, "w") as f: pour ouvrir le fichier my_file.txt en mode écriture ("w"). La fonction open() retourne un objet fichier, qui est assigné à la variable f.
- L'instruction with garantit que le fichier est automatiquement fermé lorsque le bloc est quitté, même si une exception se produit.
- Nous écrivons deux lignes de texte dans le fichier à l'aide de la méthode f.write().
- Nous utilisons ensuite l'instruction with open(filename, "r") as f: pour ouvrir le même fichier en mode lecture ("r").
- Nous lisons tout le contenu du fichier à l'aide de la méthode f.read() et l'affichons dans la console.
- Nous enveloppons les opérations sur le fichier dans des blocs try...except pour gérer les exceptions potentielles FileNotFoundError et IOError.
Exécutez le script :
```
python ~/project/file_handling.py
```
Sortie :
```
File content:
Hello, LabEx!
This is a test file.
```
Si le fichier my_file.txt n'existe pas, le script le créera et écrira le contenu spécifié. Si le fichier existe déjà, son contenu sera écrasé. L'instruction with garantit que le fichier est correctement fermé dans tous les cas.

Considérons un autre exemple où une exception pourrait se produire lors du traitement du fichier :

## file_handling.py
filename = "my_file.txt"

try:
    with open(filename, "r") as f:
        for line in f:
            ## Simulate an error during processing
            if "test" in line:
                raise ValueError("Simulated error during processing")
            print("Line:", line.strip())
except FileNotFoundError:
    print(f"The file '{filename}' was not found.")
except ValueError as e:
    print(f"A value error occurred: {e}")
except IOError as e:
    print(f"An I/O error occurred: {e}")

Dans cet exemple, nous simulons une erreur en levant une ValueError si la ligne contient le mot "test". Même si cette erreur se produit, l'instruction with garantit que le fichier est correctement fermé.

Exécutez le script :

python ~/project/file_handling.py

Sortie :

Line: Hello, LabEx!
A value error occurred: Simulated error during processing

Les gestionnaires de contexte offrent un moyen propre et fiable de gérer les ressources et de gérer les exceptions en Python. Ils garantissent que les ressources sont correctement libérées, même si des erreurs se produisent, rendant votre code plus robuste et plus facile à maintenir.

Résumé

Dans ce laboratoire (lab), vous commencez par apprendre la gestion des exceptions en Python, une technique essentielle pour écrire un code robuste. Vous commencez par un exemple simple de division qui lève une ZeroDivisionError lorsqu'on divise par zéro, ce qui entraîne la terminaison du programme. Vous implémentez ensuite un bloc try...except pour gérer gracieusement la ZeroDivisionError, empêchant le programme de planter et affichant à la place un message d'erreur informatif.