L'écriture d'un code de gestion des exceptions efficace est essentielle pour créer des applications robustes et maintenables.
Vous trouverez ci-dessous quelques bonnes pratiques pour écrire du code de gestion des exceptions en Python :

1. Attrapez uniquement ce que vous pouvez gérer

Soyez précis :

• Détectez les exceptions spécifiques plutôt que d'utiliser une clause except large.
• Cela garantit que seules les exceptions que vous attendez et que vous savez gérer sont interceptées.

try:
    # Code that might raise an exception
except ValueError as e:
    print(f"Value error occurred: {e}")

2. Évitez Bare sauf : Clauses

Détecter les exceptions spécifiques :

• Évitez d'utiliser except : sans spécifier de type d'exception.
• Cela peut détecter des erreurs inattendues et rendre le débogage difficile.

try:
    # Code that might raise an exception
except Exception as e:  # Catch all exceptions if necessary
    print(f"An error occurred: {e}")

3. Utilisez les blocs try-sauf-else-finally

• essayez : placez ici le code qui pourrait déclencher une exception.
• except : Gérer les exceptions dans ce bloc.
• else : exécute ce bloc si aucune exception n'a été déclenchée dans le bloc try.
• enfin : exécutez ce bloc, qu'une exception ait été levée ou non, souvent utilisée pour le nettoyage.

try:
    # Code that might raise an exception
except ValueError as e:
    print(f"Value error: {e}")
else:
    print("No exceptions occurred.")
finally:
    print("This will always be executed.")

4. Journaliser les exceptions

• Utilisez le module de journalisation pour enregistrer les exceptions.
• La journalisation permet de diagnostiquer les problèmes de production sans révéler les erreurs aux utilisateurs finaux.

import logging

logging.basicConfig(level=logging.ERROR)

try:
    # Code that might raise an exception
except Exception as e:
    logging.error(f"An error occurred: {e}")

5. Relancer les exceptions si nécessaire

• Si vous détectez une exception mais que vous ne parvenez pas à la gérer entièrement, envisagez de la relancer afin qu'elle puisse être gérée ailleurs.

try:
    # Code that might raise an exception
except ValueError as e:
    logging.error(f"Value error: {e}")
    raise  # Re-raise the exception

6. Utilisez les gestionnaires de contexte pour la gestion des ressources

• Utilisez des gestionnaires de contexte (avec instruction) pour gérer des ressources telles que des fichiers, des sockets ou des connexions à une base de données.
• Cela garantit que les ressources sont correctement libérées même si une exception est levée.

with open('file.txt', 'r') as file:
    content = file.read()

7. Dégradation gracieuse

 - Au lieu de permettre à votre application de planter, fournissez des mécanismes de secours ou des messages d'erreur conviviaux.

• Par exemple, si un fichier de configuration est manquant, vous pouvez utiliser les paramètres par défaut à la place.

try:
    with open('config.json', 'r') as file:
        config = json.load(file)
except FileNotFoundError:
    print("Config file not found, using defaults.")
    config = {"default": "value"}

8. Évitez d’avaler des exceptions

• Ne détectez pas les exceptions sans prendre aucune mesure.
• Ignorer les exceptions peut masquer des bugs et rendre l'application se comporter de manière imprévisible.

try:
    # Code that might raise an exception
except Exception as e:
    pass  # Bad practice - you're ignoring the error

9. Documenter les exceptions

• Utilisez des docstrings pour documenter les exceptions que vos fonctions peuvent déclencher.
• Cela aide les autres développeurs à comprendre à quelles exceptions s'attendre et comment les gérer.

def divide(a, b):
    """
    Divides two numbers.

    :param a: Numerator.
    :param b: Denominator.
    :return: The result of the division.
    :raises ZeroDivisionError: If the denominator is zero.
    """
    if b == 0:
        raise ZeroDivisionError("Cannot divide by zero.")
    return a / b

10. Utilisez des exceptions personnalisées lorsque cela est approprié

• Créez des exceptions personnalisées pour représenter des conditions d'erreur spécifiques dans votre application.
• Cela peut rendre votre code plus lisible et plus facile à maintenir.

class InvalidInputError(Exception):
    """Exception raised for invalid inputs."""
    pass

def process_input(value):
    if not isinstance(value, int):
        raise InvalidInputError("Input must be an integer.")
    return value * 2

11. Testez la gestion des exceptions

• Écrivez des tests pour vous assurer que votre gestion des exceptions fonctionne comme prévu.
• Utilisez des frameworks comme unittest ou pytest pour tester les cas normaux et exceptionnels.

def test_divide():
    assert divide(10, 2) == 5
    with pytest.raises(ZeroDivisionError):
        divide(10, 0)

12. Évitez d’abuser des exceptions

Utiliser des exceptions pour les cas exceptionnels :

• Les exceptions doivent être utilisées pour des conditions inattendues, et non comme un mécanisme de flux de contrôle régulier.
• Par exemple, évitez d'utiliser des exceptions pour gérer des conditions prévisibles comme la fin d'une boucle.

# Bad practice: using exceptions for control flow
try:
    while True:
        value = next(iterator)
except StopIteration:
    pass  # End of iteration

13. Exceptions de chaîne pour le contexte

• Python vous permet d'enchaîner des exceptions pour préserver le contexte d'origine lors du déclenchement d'une nouvelle exception.
• Utilisez from pour lier les exceptions associées.

try:
    result = process_input(input_value)
except InvalidInputError as e:
    raise ValueError("Failed to process input") from e

En suivant ces bonnes pratiques, vous pouvez écrire un code de gestion des exceptions plus robuste, plus maintenable et plus lisible qui gère efficacement les erreurs et améliore la fiabilité de votre application.

Ressources

• Documentation officielle de Python sur la gestion des exceptions
• Documentation du module de journalisation de Python
• PEP 8 - Guide de style pour le code Python (pour les pratiques générales de codage, y compris les exceptions)
• Real Python - Gestion des exceptions