Comment détecter plusieurs exceptions en Python : un guide simple

La gestion des exceptions en Python est essentielle pour assurer la stabilité de vos applications. Elle permet d'éviter les plantages inattendus et offre une expérience utilisateur plus agréable. Cet article explore la manière de traiter simultanément plusieurs types d'exceptions au sein d'un même bloc `try/except` en Python.

Qu'est-ce qu'une exception en Python ?

En Python, les exceptions constituent un mécanisme de communication entre les différentes parties d'un programme. Ce mécanisme permet à une section du code de signaler qu'une erreur critique, qu'elle ne peut résoudre, s'est produite.

Ainsi, une exception est déclenchée. Une autre partie du programme, capable de gérer cette erreur, va alors intercepter l'exception et prendre les mesures appropriées.

Si les exceptions ne sont pas gérées, elles provoquent l'arrêt brutal du programme. La gestion des exceptions est donc cruciale pour rendre un programme plus robuste et éviter les interruptions.

Dans le cadre de cet article, il est supposé que vous avez déjà des notions de base sur la levée et la gestion des exceptions, abordées par exemple dans cet article : Introduction à Python Try/Except.

Pourquoi gérer plusieurs exceptions en Python ?

Cela réduit la duplication de code, car un seul bloc peut traiter plusieurs types d'exceptions. Le code devient plus clair, plus facile à modifier et à maintenir.
Cela contribue à l'écriture d'un code plus efficient, car la vérification du type d'erreur n'est effectuée qu'une seule fois.

Gestion de plusieurs exceptions

La gestion de plusieurs exceptions se réfère à la possibilité de capturer différents types d'exceptions dans un unique bloc `except`. En Python, vous pouvez bien sûr intercepter les exceptions individuellement avec des blocs `except` distincts.

Cependant, lorsque plusieurs exceptions nécessitent le même type de traitement, il est plus judicieux de les gérer ensemble dans un seul bloc. Cette section explique comment procéder avec des exemples concrets.

#1. Traitement d'exceptions distinctes dans des blocs séparés

Prenons l'exemple d'un programme qui effectue une division à partir de deux valeurs saisies par l'utilisateur. Nous nous attendons à ce que des exceptions de différents types puissent survenir, notamment lorsque l'utilisateur entre des données invalides. Plus précisément, nous voulons gérer les exceptions `ValueError` et `ZeroDivisionError`.

L'exception `ValueError` sera levée si l'entrée utilisateur ne peut être convertie en un entier. `ZeroDivisionError`, quant à elle, sera déclenchée si le deuxième nombre est zéro. Dans les deux cas, nous souhaitons afficher le même message d'erreur : « Vous avez saisi une valeur incorrecte ».

Voici le code correspondant :

try:
      dividend = int(input('Entrez le premier nombre: '))
      divisor = int(input('Entrez le deuxième nombre: '))
      quotient = dividend / divisor
      print(quotient)
  except ValueError as e:
      print("Vous avez saisi une valeur incorrecte")
  except ZeroDivisionError as e:
      print("Vous avez saisi une valeur incorrecte")
  except Exception as e:
      print("Une erreur s'est produite")

Si nous exécutons ce code et entrons un texte qui ne peut être transformé en entier, voici le résultat :

Si nous entrons 0 pour le second nombre, voici le résultat :

Bien que le code fonctionne, on constate une duplication entre les deux blocs `except`, car `ValueError` et `ZeroDivisionError` sont traitées de la même manière. Cela n'est pas idéal, car cela contrevient au principe DRY (Don't Repeat Yourself) de la programmation.

Il est donc plus judicieux de combiner les deux blocs en un seul, permettant d'intercepter les deux types d'exceptions simultanément, évitant ainsi les répétitions.

#2. Interception de plusieurs exceptions dans un seul bloc `except`

Pour intercepter plusieurs exceptions simultanément, on utilise un tuple listant les types d'erreurs à gérer. Voici un exemple où `ValueError` et `ZeroDivisionError` sont interceptées dans un même bloc `except`:

try:
      dividend = int(input('Entrez le premier nombre: '))
      divisor = int(input('Entrez le deuxième nombre: '))
      quotient = dividend / divisor
      print(quotient)
  except (ValueError, ZeroDivisionError) as e:
      print("Vous avez saisi une valeur incorrecte")
  except Exception as e:
      print("Une erreur s'est produite")

Cette approche est bien plus élégante que la précédente. C'est l'intérêt principal de la gestion de plusieurs exceptions. Le comportement du code est identique à celui de l'exemple précédent. Vous pouvez tester avec les mêmes entrées, vous obtiendrez les mêmes résultats :

#3. Identification de l'exception interceptée

Le code ci-dessus exécute le premier bloc `except` dès lors qu'une `ValueError` ou une `ZeroDivisionError` est détectée. Il peut arriver que vous souhaitiez exécuter un code spécifique pour l'un ou l'autre de ces types d'erreurs.

Dans ce cas, il est nécessaire d'identifier précisément l'exception qui a été levée afin d'exécuter le code adapté.

Pour identifier l'exception interceptée, vous pouvez utiliser une structure conditionnelle `if/else` à l'intérieur du bloc `except`. Voici un exemple :

try:
      dividend = int(input('Entrez le premier nombre: '))
      divisor = int(input('Entrez le deuxième nombre: '))
      quotient = dividend / divisor
      print(quotient)
  except (ValueError, ZeroDivisionError) as e:
      print("Vous avez saisi une valeur incorrecte")
      if isinstance(e, ValueError):
          print('Erreur de valeur')
      else:
          print('Erreur de division par zéro')
  except Exception as e:
      print("Une erreur s'est produite")

Dans ce bloc, en plus d'afficher le message d'erreur générique, nous vérifions le type d'exception et affichons un message additionnel. Si nous testons à nouveau le code, nous verrons apparaître les messages spécifiques en fonction de l'exception levée.

Quand utiliser la gestion de plusieurs exceptions ?

En général, la gestion de plusieurs exceptions est particulièrement utile lorsque vous souhaitez appliquer le même traitement à des exceptions de nature similaire qui peuvent être déclenchées. Cela comprend par exemple :

Les requêtes réseau échouées pour diverses raisons. Vous pouvez simplement informer l'utilisateur que le serveur est inaccessible.
Les tentatives de connexion à une base de données qui peuvent générer différents types d'erreurs. Bien que différentes, ces erreurs peuvent être gérées de la même manière.
Les opérations d'E/S sur les fichiers qui peuvent également générer des erreurs similaires comme des problèmes d'autorisation ou de disque plein.

Conclusion

Cet article a montré comment regrouper plusieurs blocs `except` en un seul en interceptant plusieurs exceptions simultanément. Cela permet de rendre votre code plus lisible et maintenable. Pour aller plus loin, n'hésitez pas à consulter d'autres articles sur les projets Python pour débutants à expérimenter.