Comment créer des exceptions personnalisées en Python

Les classes d'exceptions intégrées de Python ne résolvent pas certaines situations d'erreur pouvant survenir dans votre code. Dans de tels cas, vous devrez créer des exceptions personnalisées pour gérer efficacement ces erreurs.

En Python, vous pouvez définir des exceptions personnalisées et les déclencher lorsque des situations d'erreur spécifiques se produisent. Vous pouvez gérer des erreurs spécifiques et informatives avec des exceptions personnalisées, améliorant ainsi la lisibilité et la maintenabilité de votre code.

Pourquoi avez-vous besoin d’exceptions personnalisées?

Lors du développement d'une application, divers scénarios d'erreur peuvent survenir en raison de modifications du code, de l'intégration avec d'autres packages ou bibliothèques et des interactions avec des applications externes. Il est crucial de gérer ces erreurs pour s’en remettre ou gérer les échecs avec élégance.

Python propose une gamme de exception intégrée classes qui couvrent des erreurs telles que ValeurErreur, Erreur-type, ErreurFichierNotFound, et plus. Bien que ces exceptions intégrées remplissent bien leur fonction, elles ne représentent parfois avec précision les erreurs pouvant survenir dans votre application.

En créant des exceptions personnalisées, vous pouvez les adapter spécifiquement aux exigences de votre application et fournir des informations aux développeurs qui utilisent votre code.

Comment définir des exceptions personnalisées

Pour créer des exceptions personnalisées, définir une classe Python qui hérite du Classe d'exceptions. Le Exception La classe offre les fonctionnalités de base dont vous aurez besoin pour gérer les exceptions et vous pouvez la personnaliser pour ajouter des fonctionnalités en fonction de vos besoins spécifiques.

Lors de la création de classes d'exceptions personnalisées, restez simples tout en incluant les attributs nécessaires au stockage des informations sur les erreurs. Les gestionnaires d'exceptions peuvent ensuite accéder à ces attributs pour gérer les erreurs de manière appropriée.

Voici une classe d'exception personnalisée, MonErreurPersonnelle:

classMyCustomError(Exception):
def__init__(self, message=None):
 self.message = message
 super().__init__(message)

Cette classe accepte un argument de message facultatif lors de l'initialisation. Il utilise le super() méthode pour appeler le constructeur de la base Exception classe, ce qui est essentiel pour la gestion des exceptions.

Comment déclencher des exceptions personnalisées

Pour générer une erreur, utilisez le augmenter mot-clé suivi d'une instance de votre classe d'exception personnalisée, en lui transmettant un message d'erreur en argument :

ifTrue:
raise MyCustomError("A Custom Error Was Raised...")

Vous pouvez également générer l'erreur sans passer d'argument :

ifTrue:
raise MyCustomError # shorthand

Les deux formats conviennent pour générer des erreurs personnalisées.

Comment gérer les exceptions personnalisées

La gestion des exceptions personnalisées suit la même approche que gestion des exceptions intégrées. Utiliser essayer, sauf, et enfin bloque pour intercepter les exceptions personnalisées et prendre les mesures appropriées.

try:
 print("Hello, You're learning how to MakeUseOf Custom Errors")
raise MyCustomError("Opps, Something Went Wrong...")
except MyCustomError as err:
 print(f"Error: {err}")
finally:
 print("Done Handling Custom Error")

De cette façon, vous pouvez gérer toutes les formes d’exceptions personnalisées générées.

Si une exception survient lors de l'exécution d'un essayer bloc, un correspondant sauf le bloc peut l’attraper et le gérer. S'il n'y a pas de sauf bloc pour gérer l'exception, n'importe quel enfin Le bloc s'exécutera, suivi de la levée de l'exception. Utiliser un enfin bloquez principalement pour effectuer des tâches de nettoyage qui doivent être exécutées en toutes circonstances, qu'une exception se produise ou non.

try:
raise KeyboardInterrupt
except MyCustomError as err:
 print(f"Error: {err}")
finally:
 print("Did not Handle the KeyboardInterrupt Error. \
Can Only Handle MyCustomError")

Dans cet échantillon, un Interruption du clavier une exception se produit, mais le sauf bloquer uniquement les poignées MonErreurPersonnelle des exceptions. Dans ce cas, le enfin le bloc s'exécute, puis l'exception non gérée est à nouveau générée.

Héritage des classes d'erreur personnalisées

Basé sur concept de programmation orientée objet (POO), vous pouvez également hériter de classes d'exception personnalisées, tout comme les classes normales. En héritant d'une classe d'exception personnalisée, vous pouvez créer des classes d'erreur qui fournissent un contexte plus spécifique à une exception. Cette approche vous permet de gérer les erreurs à différents niveaux de votre code et permet de mieux comprendre la cause de l'erreur.

Supposons que vous développiez une application Web qui interagit avec une API externe. Cette API peut avoir différents scénarios d'erreur. Vous souhaiterez gérer ces erreurs de manière cohérente et claire tout au long de votre code. Pour y parvenir, créez une classe d'exception personnalisée, BaseAPIException:

classBaseAPIException(Exception):
Base class for API-related exceptions.
def__init__(self, message):
 super().__init__(message)
 self.message = message

Une fois que vous disposez de cette classe d’exceptions personnalisée de base, vous pouvez créer des classes d’exceptions enfants qui en héritent :

classAPINotFoundError(BaseAPIException):
Raised when the requested resource is not found in the API.
pass
classAPIAuthenticationError(BaseAPIException):
Raised when there's an issue with authentication to the API.
pass
classAPIRateLimitExceeded(BaseAPIException):
Raised when the rate limit for API requests is exceeded.
pass

Déclenchez et interceptez ces exceptions personnalisées lorsque vous effectuez des appels à l'API dans votre application Web. Gérez-les en conséquence en utilisant la logique appropriée dans votre code.

defrequest_api():
try:
# Simulate an API error for demonstration purposes
raise APINotFoundError("Requested resource not found.")
except APINotFoundError as err:
# Log or handle the 'Not Found' error case
 print(f"API Not Found Error: {err}")
except APIAuthenticationError:
# Take appropriate actions for authentication error
 print(f"API Authentication Error: {err}")
except APIRateLimitExceeded:
# Handle the rate limit exceeded scenario
 print(f"API Rate Limit Exceeded: {err}")
except BaseAPIException:
# Handle other unknown API exceptions
 print(f"Unknown API Exception: {err}")

La dernière clause except vérifie la classe parent et agit comme un fourre-tout pour toute autre erreur liée à l'API.

Lorsque vous héritez de classes d'exceptions personnalisées, vous pouvez gérer efficacement les erreurs au sein de l'API. Cette approche vous permet de séparer votre gestion des erreurs des détails d'implémentation de l'API, ce qui facilite l'ajout d'exceptions personnalisées ou la réalisation de modifications à mesure que l'API évolue ou rencontre une nouvelle erreur cas.

Encapsulation des exceptions personnalisées

Encapsuler des exceptions signifie intercepter une exception, l'encapsuler dans une exception personnalisée, puis déclencher cette exception personnalisée tout en faisant référence à l'exception d'origine comme cause. Cette technique permet de fournir un contexte aux messages d'erreur et de garder les détails d'implémentation cachés du code appelant.

Considérez le scénario dans lequel votre application Web interagit avec une API. Si l'API génère un Erreur de recherche, vous pouvez l'attraper, puis créer une coutume APINotFoundError exception qui fait référence à LookupError comme cause :

defrequest_api():
try:
# Simulate an API error for demonstration purposes
# Assuming the external API raised a LookupError
raise LookupError("Sorry, You Encountered A LookUpError !!!")
except LookupError as original_exception:
try:
# Wrap the original exception with a custom exception
raise APINotFoundError \
 ("Requested resource not found.") from original_exception
except APINotFoundError as wrapped_exception:
# Handle the wrapped exception here 
 print(f"Caught wrapped API exception: {wrapped_exception}")
# or re-raise it if necessary
raise
try:
 request_api()
except APINotFoundError as err:
 print(f"Caught API exception: {err.__cause__}")

Utiliser un depuis clause avec le augmenter instruction pour référencer l’exception d’origine dans votre exception personnalisée.

Lorsque l'exception personnalisée se produit, elle inclut l'exception d'origine en tant que __cause__ attribut, fournissant un lien entre l’exception personnalisée et l’original. Cela vous permet de retracer l'origine d'une exception.

En encapsulant les exceptions, vous pouvez fournir un contexte plus significatif et envoyer des messages d'erreur plus appropriés aux utilisateurs, sans révéler les détails d'implémentation internes de votre code ou de l'API. Il vous permet également de gérer et de traiter les types d'erreurs de manière structurée et uniforme.

Personnalisation du comportement des classes en Python

En héritant de la classe d'exceptions de base fournie par Python, vous pouvez créer des exceptions simples et utiles que vous pouvez déclencher lorsque des erreurs spécifiques se produisent dans votre code. Vous pouvez également implémenter un comportement personnalisé pour vos classes d'exceptions à l'aide de méthodes magiques ou dunder.