Gérer les exceptions avec try...except...else...finally

Le bloc `try` : exécutez du code potentiellement problématique

Le bloc `try` vous permet d'encadrer le code susceptible de générer une exception. Vous placez les instructions que vous voulez "essayer" à l'intérieur du bloc `try`, en les indentant.

Si une exception se produit à l'intérieur du bloc `try`, l'exécution du bloc `try` est immédiatement interrompue, et Python recherche un bloc `except` correspondant au type de l'exception.

Si aucune exception ne se produit, le bloc `try` s'exécute jusqu'à la fin, et Python passe à la suite du programme (en ignorant les blocs `except`, `else` et `finally` s'ils existent).

Il est important de ne placer dans le bloc `try` que le code qui peut réellement générer une exception. Si vous mettez trop de code dans le bloc `try`, vous risquez de masquer des erreurs potentielles.

Nous verrons des exemples d'utilisation du bloc `try`.

Le bloc `except` : capturez et traitez les exceptions

Le bloc `except` suit immédiatement le bloc `try`. Il vous permet de capturer et de traiter une exception spécifique. Vous spécifiez le type d'exception que vous voulez capturer après le mot-clé `except`. Par exemple : `except ValueError:`.

Si une exception du type spécifié se produit à l'intérieur du bloc `try`, l'exécution passe au bloc `except` correspondant. Vous pouvez alors exécuter du code pour gérer l'exception, par exemple afficher un message d'erreur, enregistrer l'erreur dans un fichier, ou tenter de récupérer de l'erreur.

Vous pouvez avoir plusieurs blocs `except` pour gérer différents types d'exceptions. Python exécutera le premier bloc `except` dont le type correspond à l'exception levée.

Vous pouvez également utiliser un bloc `except` sans spécifier de type d'exception : `except:`. Cela capturera toutes les exceptions. Cependant, cette pratique est généralement déconseillée, car elle peut masquer des erreurs inattendues et rendre le débogage plus difficile. Il est préférable d'être aussi spécifique que possible dans la capture des exceptions.

Vous pouvez aussi utiliser `except (TypeError, ValueError) as e:` afin de capturer plusieurs types d'exceptions en même temps. La variable `e` contiendra l'objet de l'exception levée.

Nous verrons des exemples d'utilisation du bloc `except`, comment capturer différents types d'exceptions, et comment accéder à l'objet exception pour obtenir plus d'informations sur l'erreur.

Le bloc `else` : exécutez du code si aucune exception n'est levée

Le bloc `else` est optionnel. Il suit le(s) bloc(s) `except`. Le code à l'intérieur du bloc `else` est exécuté si aucune exception ne se produit à l'intérieur du bloc `try`.

Le bloc `else` est utile pour exécuter du code qui ne doit être exécuté que si le bloc `try` s'est déroulé sans erreur. Il permet de séparer clairement le code "normal" du code de gestion des erreurs.

Par exemple, imaginez que vous ayez un bloc `try` qui ouvre un fichier et lit son contenu. Vous pouvez utiliser un bloc `except` pour gérer l'exception `FileNotFoundError`, et un bloc `else` pour traiter le contenu du fichier (si le fichier a bien été ouvert).

Nous verrons des exemples d'utilisation du bloc `else`.

Le bloc `finally` : exécutez du code dans tous les cas

Le bloc `finally` est optionnel. Il suit le(s) bloc(s) `except` et le bloc `else` (s'il existe). Le code à l'intérieur du bloc `finally` est exécuté dans tous les cas, qu'une exception se soit produite ou non, et que l'exception ait été capturée ou non.

Le bloc `finally` est utile pour effectuer des actions de nettoyage, comme fermer un fichier, fermer une connexion réseau, ou libérer des ressources. Même si une exception se produit et que vous ne la gérez pas, le code dans le bloc `finally` sera exécuté avant que le programme ne se termine.

Par exemple : `try: f = open('mon_fichier.txt'); ... except FileNotFoundError: print('Fichier non trouvé') finally: if 'f' in locals() and not f.closed: f.close()`. Dans cet exemple, le fichier sera fermé même si une exception autre que `FileNotFoundError` se produit.

Nous verrons des exemples d'utilisation du bloc `finally`.

Gestionnaires de contexte et l'instruction `with` (approfondissement)

Les gestionnaires de contexte sont un moyen élégant et sûr de gérer les ressources en Python, comme les fichiers, les connexions réseau, ou les verrous. Ils vous permettent de vous assurer que les ressources sont correctement acquises et libérées, même en cas d'erreur.

Vous utilisez un gestionnaire de contexte avec l'instruction `with`. L'instruction `with` prend un objet qui implémente le protocole de gestion de contexte (les méthodes `__enter__` et `__exit__`). L'objet est "entré" au début du bloc `with`, et "sorti" à la fin du bloc `with`, même si une exception se produit.

La méthode `__enter__` est appelée au début du bloc `with`. Elle peut renvoyer un objet qui sera utilisé dans le bloc `with`. La méthode `__exit__` est appelée à la fin du bloc `with`. Elle prend en argument le type de l'exception, la valeur de l'exception, et le traceback, si une exception s'est produite. Si aucune exception ne s'est produite, ces arguments sont `None`.

L'exemple le plus courant d'utilisation de `with` est l'ouverture de fichiers : `with open('mon_fichier.txt') as f: ...`. Dans cet exemple, l'objet fichier implémente le protocole de gestion de contexte. La méthode `__enter__` ouvre le fichier et renvoie l'objet fichier. La méthode `__exit__` ferme le fichier, même si une exception se produit dans le bloc `with`.

Nous verrons comment utiliser l'instruction `with`, comment créer vos propres gestionnaires de contexte, et comment ils simplifient la gestion des ressources et améliorent la robustesse de votre code.