Créer ses propres types d'exceptions

Pourquoi créer ses propres exceptions ? Spécificité et clarté

Python fournit de nombreuses exceptions intégrées (`TypeError`, `ValueError`, `IndexError`, etc.), mais il est parfois utile de créer ses propres types d'exceptions, pour plusieurs raisons :

• Spécificité : Vous pouvez créer des exceptions qui correspondent précisément aux types d'erreurs spécifiques que votre code peut rencontrer. Cela rend le code plus clair et plus facile à comprendre.
• Contrôle : Vous pouvez définir des attributs et des méthodes spécifiques à vos exceptions, pour fournir des informations supplémentaires sur l'erreur ou pour gérer l'erreur de manière particulière.
• Organisation : Vous pouvez organiser vos exceptions en une hiérarchie, en créant des classes d'exceptions qui héritent d'autres classes d'exceptions.
• Compatibilité : Si vous créez une bibliothèque ou un module destiné à être utilisé par d'autres développeurs, il est important de définir vos propres exceptions pour éviter les conflits de noms avec les exceptions d'autres bibliothèques.

En créant vos propres exceptions, vous rendez votre code plus expressif, plus facile à déboguer et plus facile à utiliser pour les autres développeurs.

Comment créer une exception personnalisée : hériter de Exception

Pour créer une exception personnalisée, vous devez définir une nouvelle classe qui *hérite* de la classe `Exception`, ou d'une de ses sous-classes (comme `ValueError`, `TypeError`, etc.).

Syntaxe de base :

class MonExceptionPersonnalisee(Exception):
    pass  # Le corps de la classe peut être vide (pour l'instant)

Exemple :

class SoldeInsuffisantError(Exception):
    pass

class CompteBancaire:
    def __init__(self, solde):
        self.solde = solde

    def retirer(self, montant):
        if montant > self.solde:
            raise SoldeInsuffisantError("Solde insuffisant pour effectuer le retrait.")
        self.solde -= montant

# Utilisation
compte = CompteBancaire(100)

try:
    compte.retirer(150)
except SoldeInsuffisantError as e:
    print("Erreur :", e)

Dans cet exemple :

• `SoldeInsuffisantError` est une exception personnalisée. Elle hérite de `Exception`.
• La classe `SoldeInsuffisantError` est vide pour l'instant (elle ne fait qu'hériter du comportement de `Exception`).
• La méthode `retirer` de la classe `CompteBancaire` lève une `SoldeInsuffisantError` si le montant à retirer est supérieur au solde.
• Le bloc `try...except` capture l'exception et affiche un message d'erreur.

Vous pouvez créer des exceptions personnalisées pour n'importe quel type d'erreur spécifique à votre application.

Ajouter des attributs et des méthodes à vos exceptions

Vous pouvez ajouter des attributs et des méthodes à vos exceptions personnalisées, comme à n'importe quelle autre classe. Cela vous permet de stocker des informations supplémentaires sur l'erreur et de fournir des méthodes pour accéder à ces informations ou pour effectuer des actions spécifiques.

Exemple (en reprenant l'exemple précédent) :

class SoldeInsuffisantError(Exception):
    def __init__(self, solde, montant_demande):
        super().__init__(f"Solde insuffisant : solde = {solde}, montant demandé = {montant_demande}")
        self.solde = solde
        self.montant_demande = montant_demande

class CompteBancaire:
    def __init__(self, solde):
        self.solde = solde

    def retirer(self, montant):
        if montant > self.solde:
            raise SoldeInsuffisantError(self.solde, montant)
        self.solde -= montant

# Utilisation
compte = CompteBancaire(100)
try:
    compte.retirer(150)
except SoldeInsuffisantError as e:
    print("Erreur :", e)
    print("Solde disponible :", e.solde)
    print("Montant demandé :", e.montant_demande)

Dans cet exemple :

• La classe `SoldeInsuffisantError` a maintenant un constructeur qui prend le solde et le montant demandé en arguments.
• Le constructeur appelle le constructeur de la classe mère (`Exception`) avec un message d'erreur personnalisé.
• Le constructeur initialise également les attributs `solde` et `montant_demande` de l'objet exception.
• Dans le bloc `except`, on peut accéder à ces attributs pour afficher des informations plus détaillées sur l'erreur.

Vous pouvez ajouter n'importe quels attributs et méthodes pertinents à vos exceptions personnalisées.

Créer une hiérarchie d'exceptions

Vous pouvez organiser vos exceptions personnalisées en une hiérarchie, en créant des classes d'exceptions qui héritent d'autres classes d'exceptions.

Cela permet de créer des exceptions plus spécifiques qui héritent du comportement d'exceptions plus générales.

Exemple :

class ErreurValidation(Exception):
    """Exception de base pour les erreurs de validation."""
    pass

class ErreurFormat(ErreurValidation):
    """Exception pour les erreurs de format."""
    pass

class ErreurValeur(ErreurValidation):
    """Exception pour les valeurs invalides."""
    pass

class ErreurLongueur(ErreurValeur):
  """Exception pour les valeurs de longueur incorrecte."""
  pass

def valider_mot_de_passe(mot_de_passe):
    if not isinstance(mot_de_passe, str):
        raise TypeError("Le mot de passe doit être une chaîne de caractères.")
    if len(mot_de_passe) < 8:
        raise ErreurLongueur("Le mot de passe doit contenir au moins 8 caractères.")
    if not any(c.isdigit() for c in mot_de_passe):
        raise ErreurFormat("Le mot de passe doit contenir au moins un chiffre.")

# Utilisation:
try:
  valider_mot_de_passe('123')
except ErreurLongueur as e:
  print(e)
except ErreurFormat as e:
  print(e)
except ErreurValidation as e:
  print(e)

Dans cet exemple:

• `ErreurValidation` est une exception de base pour toutes les erreurs de validation.
• `ErreurFormat` et `ErreurValeur` sont des sous-classes de `ErreurValidation`, plus spécifiques.
• `ErreurLongueur` est une sous-classe de `ErreurValeur`, encore plus spécifique.

Cela vous permet de capturer les exceptions à différents niveaux de granularité. Par exemple, vous pouvez capturer `ErreurLongueur` spécifiquement, ou capturer `ErreurValidation` pour gérer toutes les erreurs de validation de la même manière.

Bonnes pratiques

Voici quelques bonnes pratiques pour créer et utiliser vos propres exceptions :

• Héritez de `Exception` (ou d'une sous-classe appropriée) : C'est la convention en Python.
• Choisissez des noms descriptifs : Le nom de l'exception doit indiquer clairement le type d'erreur. Il est courant de suffixer le nom de l'exception par `Error`.
• Documentez vos exceptions : Utilisez des docstrings pour expliquer quand et pourquoi l'exception est levée.
• Fournissez des informations utiles : Si possible, incluez des informations supplémentaires dans l'exception (par exemple, la valeur invalide, le nom du fichier manquant, etc.) pour faciliter le débogage.
• Créez une hiérarchie d'exceptions si nécessaire : Pour organiser vos exceptions et permettre une gestion plus fine des erreurs.
• Ne levez pas d'exceptions génériques (`Exception`) : Créez des exceptions spécifiques pour chaque type d'erreur.