Comment vérifier si une exception est d'un certain type en Python

Introduction

Dans ce labo (lab), vous apprendrez à vérifier si une exception est d'un certain type en Python, une compétence essentielle pour une gestion efficace des erreurs. Le labo se concentre sur la compréhension de la hiérarchie des exceptions et sur l'utilisation de cette connaissance pour identifier des types d'exceptions spécifiques.

Le labo vous guide dans l'exploration de la hiérarchie des exceptions Python, en commençant par la classe de base BaseException et ses sous-classes telles que Exception. Vous créerez un script Python, exception_hierarchy.py, pour afficher la hiérarchie des exceptions, vous permettant de visualiser les relations entre différentes classes d'exceptions. Cette compréhension sera ensuite appliquée dans les étapes suivantes pour vérifier les types d'exceptions à l'aide de isinstance() et de comparaisons directes de classes.

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") python/ErrorandExceptionHandlingGroup -.-> python/custom_exceptions("Custom Exceptions") subgraph Lab Skills python/catching_exceptions -.-> lab-559609{{"Comment vérifier si une exception est d'un certain type en Python"}} python/raising_exceptions -.-> lab-559609{{"Comment vérifier si une exception est d'un certain type en Python"}} python/custom_exceptions -.-> lab-559609{{"Comment vérifier si une exception est d'un certain type en Python"}} end

Comprendre la hiérarchie des exceptions

Dans cette étape, vous allez apprendre à connaître la hiérarchie des exceptions en Python. Comprendre cette hiérarchie est essentiel pour une gestion efficace des erreurs. Les exceptions en Python sont organisées en une structure arborescente, avec une classe de base en haut et des classes d'exceptions plus spécifiques qui en héritent.

La classe de base de toutes les exceptions est BaseException. Les classes qui héritent directement de BaseException sont Exception, GeneratorExit, KeyboardInterrupt et SystemExit. La classe Exception est la superclasse de la plupart des exceptions intégrées qui indiquent les erreurs que votre programme pourrait rencontrer.

Créons un script Python pour explorer cette hiérarchie.

Ouvrez votre éditeur VS Code.
Créez un nouveau fichier nommé exception_hierarchy.py dans le répertoire ~/project.
```
~/project/exception_hierarchy.py
```

Ajoutez le code suivant au fichier exception_hierarchy.py :

def print_exception_hierarchy(exception_class, indent=0):
    """Affiche la hiérarchie des exceptions à partir d'une classe d'exception donnée."""
    print('  ' * indent + str(exception_class))
    for subclass in exception_class.__subclasses__():
        print_exception_hierarchy(subclass, indent + 1)

print("Exception Hierarchy:")
print_exception_hierarchy(Exception)

Ce script définit une fonction récursive print_exception_hierarchy qui affiche la hiérarchie des exceptions à partir de la classe Exception.

Exécutez le script en utilisant la commande suivante dans le terminal :

python exception_hierarchy.py

Cela affichera une structure arborescente de la hiérarchie des exceptions dans le terminal.

Exemple de sortie :

Exception Hierarchy:
<class 'Exception'>
  <class 'ArithmeticError'>
    <class 'FloatingPointError'>
    <class 'OverflowError'>
    <class 'ZeroDivisionError'>
      <class 'decimal.DivisionByZero'>
  <class 'AssertionError'>
  <class 'AttributeError'>
  <class 'BufferError'>
  <class 'EOFError'>
  <class 'ImportError'>
    <class 'ModuleNotFoundError'>
    <class 'ZipImportError'>
  <class 'LookupError'>
    <class 'IndexError'>
    <class 'KeyError'>
      <class 'tracemalloc.DomainKey'>
  <class 'MemoryError'>
  <class 'NameError'>
    <class 'UnboundLocalError'>
  <class 'OSError'>
    <class 'BlockingIOError'>
    <class 'ChildProcessError'>
    <class 'ConnectionError'>
      <class 'BrokenPipeError'>
      <class 'ConnectionAbortedError'>
      <class 'ConnectionRefusedError'>
      <class 'ConnectionResetError'>
    <class 'FileExistsError'>
    <class 'FileNotFoundError'>
    <class 'InterruptedError'>
      <class 'InterruptedSystemCall'>
    <class 'IsADirectoryError'>
    <class 'NotADirectoryError'>
    <class 'PermissionError'>
    <class 'ProcessLookupError'>
    <class 'TimeoutError'>
    <class 'UnsupportedOperation'>
    <class 'itertools.Incomplete'>
    <class 'signal.ItimerError'>
  <class 'ReferenceError'>
  <class 'RuntimeError'>
    <class 'NotImplementedError'>
      <class 'asyncio.exceptions.IncompleteReadError'>
      <class 'zlib.error'>
    <class '_frozen_importlib._DeadlockError'>
    <class 'RecursionError'>
  <class 'StopAsyncIteration'>
  <class 'StopIteration'>
  <class 'SyntaxError'>
    <class 'IndentationError'>
      <class 'TabError'>
  <class 'SystemError'>
  <class 'TypeError'>
  <class 'ValueError'>
    <class 'UnicodeError'>
      <class 'UnicodeDecodeError'>
      <class 'UnicodeEncodeError'>
      <class 'UnicodeTranslateError'>
  <class 'Warning'>
    <class 'BytesWarning'>
    <class 'DeprecationWarning'>
    <class 'EncodingWarning'>
    <class 'FutureWarning'>
    <class 'ImportWarning'>
    <class 'PendingDeprecationWarning'>
    <class 'ResourceWarning'>
    <class 'RuntimeWarning'>
    <class 'SyntaxWarning'>
    <class 'UnicodeWarning'>
    <class 'UserWarning'>

Cette sortie montre la hiérarchie des exceptions, avec Exception comme classe de base et diverses sous-classes représentant des types spécifiques d'erreurs. Comprendre cette hiérarchie vous aide à capturer les exceptions au niveau de granularité approprié. Par exemple, vous pouvez capturer une exception spécifique comme ZeroDivisionError ou une exception plus générale comme ArithmeticError (qui est la classe parente de ZeroDivisionError).

Utiliser `isinstance()` sur les exceptions

Dans cette étape, vous apprendrez à utiliser la fonction isinstance() pour vérifier si une exception est une instance d'une classe particulière ou d'un tuple de classes. Cela est utile pour gérer différents types d'exceptions de manière flexible.

La fonction isinstance() prend deux arguments : un objet et un classinfo. Elle retourne True si l'objet est une instance de classinfo ou d'une de ses sous-classes. Sinon, elle retourne False.

Créons un script Python pour démontrer l'utilisation de isinstance() avec les exceptions.

Ouvrez votre éditeur VS Code.
Créez un nouveau fichier nommé isinstance_exception.py dans le répertoire ~/project.
```
~/project/isinstance_exception.py
```

Ajoutez le code suivant au fichier isinstance_exception.py :

try:
    result = 10 / 0
except Exception as e:
    if isinstance(e, ZeroDivisionError):
        print("Caught a ZeroDivisionError!")
    elif isinstance(e, ArithmeticError):
        print("Caught an ArithmeticError!")
    else:
        print("Caught some other exception!")

print("Program continues...")

Dans ce script, nous essayons de diviser 10 par 0, ce qui lèvera une ZeroDivisionError. Nous capturons ensuite l'exception et utilisons isinstance() pour vérifier si elle est une instance de ZeroDivisionError ou ArithmeticError.

Exécutez le script en utilisant la commande suivante dans le terminal :
```
python isinstance_exception.py
```
Cela affichera "Caught a ZeroDivisionError!" dans le terminal.

Exemple de sortie :
```
Caught a ZeroDivisionError!
Program continues...
```
La sortie montre que la fonction isinstance() a correctement identifié l'exception comme une instance de ZeroDivisionError. Étant donné que ZeroDivisionError est une sous-classe de ArithmeticError, la première condition if est satisfaite et le message correspondant est affiché.

Maintenant, modifions le script pour capturer une exception plus générale.

Modifiez le fichier isinstance_exception.py comme suit :

try:
    result = int("abc")
except Exception as e:
    if isinstance(e, ZeroDivisionError):
        print("Caught a ZeroDivisionError!")
    elif isinstance(e, ValueError):
        print("Caught a ValueError!")
    elif isinstance(e, ArithmeticError):
        print("Caught an ArithmeticError!")
    else:
        print("Caught some other exception!")

print("Program continues...")

Dans ce script modifié, nous essayons de convertir la chaîne de caractères "abc" en entier, ce qui lèvera une ValueError.

Exécutez le script à nouveau en utilisant la même commande :
```
python isinstance_exception.py
```
Cela affichera "Caught a ValueError!" dans le terminal.

Exemple de sortie :
```
Caught a ValueError!
Program continues...
```
Cette sortie montre que isinstance() peut être utilisé pour différencier entre différents types d'exceptions et les gérer en conséquence.

Vérifier avec les classes d'exceptions

Dans cette étape, vous apprendrez à vérifier directement pour des classes d'exceptions spécifiques dans vos blocs except. C'est une méthode plus directe et souvent plus claire pour gérer les exceptions par rapport à l'utilisation de isinstance().

Lorsque vous utilisez except ExceptionType as e:, vous indiquez à Python de capturer uniquement les exceptions de type ExceptionType ou d'une de ses sous-classes.

Créons un script Python pour démontrer ceci.

Ouvrez votre éditeur VS Code.
Créez un nouveau fichier nommé exception_classes.py dans le répertoire ~/project.
```
~/project/exception_classes.py
```

Ajoutez le code suivant au fichier exception_classes.py :

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print("Caught a ZeroDivisionError:", e)
except ArithmeticError as e:
    print("Caught an ArithmeticError:", e)
except Exception as e:
    print("Caught some other exception:", e)

print("Program continues...")

Dans ce script, nous essayons de diviser 10 par 0, ce qui lèvera une ZeroDivisionError. Nous avons trois blocs except : un pour ZeroDivisionError, un pour ArithmeticError et un pour Exception.

Exécutez le script en utilisant la commande suivante dans le terminal :
```
python exception_classes.py
```
Cela affichera "Caught a ZeroDivisionError: division by zero" dans le terminal.

Exemple de sortie :
```
Caught a ZeroDivisionError: division by zero
Program continues...
```
La sortie montre que la ZeroDivisionError a été capturée par le premier bloc except.

Maintenant, modifions le script pour lever une autre exception.

Modifiez le fichier exception_classes.py comme suit :

try:
    result = int("abc")
except ZeroDivisionError as e:
    print("Caught a ZeroDivisionError:", e)
except ValueError as e:
    print("Caught a ValueError:", e)
except ArithmeticError as e:
    print("Caught an ArithmeticError:", e)
except Exception as e:
    print("Caught some other exception:", e)

print("Program continues...")

Dans ce script modifié, nous essayons de convertir la chaîne de caractères "abc" en entier, ce qui lèvera une ValueError.

Exécutez le script à nouveau en utilisant la même commande :
```
python exception_classes.py
```
Cela affichera "Caught a ValueError: invalid literal for int() with base 10: 'abc'" dans le terminal.

Exemple de sortie :
```
Caught a ValueError: invalid literal for int() with base 10: 'abc'
Program continues...
```
Cette sortie montre que la ValueError a été capturée par le deuxième bloc except.

En spécifiant directement la classe d'exception dans le bloc except, vous pouvez gérer différents types d'exceptions de manière claire et organisée. Cette approche est généralement préférée à l'utilisation de isinstance() pour une gestion simple des exceptions.

Résumé

Dans ce laboratoire, vous avez exploré la hiérarchie des exceptions en Python, qui est essentielle pour une gestion efficace des erreurs. Vous avez appris que les exceptions sont organisées en une structure arborescente avec BaseException comme classe de base et Exception comme superclasse pour la plupart des exceptions intégrées.

Vous avez créé un script Python, exception_hierarchy.py, pour afficher la hiérarchie des exceptions à partir de la classe Exception. En exécutant le script, vous avez observé la structure arborescente des exceptions et leurs relations, ce qui vous a permis de mieux comprendre comment les exceptions sont organisées en Python.