So erstellen Sie benutzerdefinierte Ausnahmen in Python

Die in Python integrierten Ausnahmeklassen behandeln bestimmte Fehlersituationen, die in Ihrem Code auftreten können, nicht. In solchen Fällen müssen Sie benutzerdefinierte Ausnahmen erstellen, um diese Fehler effektiv zu behandeln.

In Python können Sie benutzerdefinierte Ausnahmen definieren und diese auslösen, wenn bestimmte Fehlersituationen auftreten. Sie können spezifische, informative Fehler mit benutzerdefinierten Ausnahmen verwalten und so die Lesbarkeit und Wartbarkeit Ihres Codes verbessern.

Warum benötigen Sie benutzerdefinierte Ausnahmen?

Bei der Entwicklung einer Anwendung können durch Änderungen im Code, Integration mit anderen Paketen oder Bibliotheken sowie Interaktionen mit externen Apps verschiedene Fehlerszenarien auftreten. Es ist von entscheidender Bedeutung, diese Fehler zu behandeln, um sie zu beheben oder Fehler ordnungsgemäß zu behandeln.

Python bietet eine Reihe von integrierte Ausnahme Klassen, die Fehler abdecken, wie z Wertfehler, TypeError, FileNotFoundError, und mehr. Obwohl diese integrierten Ausnahmen ihren Zweck gut erfüllen, stellen sie möglicherweise nur manchmal genau die Fehler dar, die in Ihrer Anwendung auftreten können.

Durch das Erstellen benutzerdefinierter Ausnahmen können Sie diese speziell an die Anforderungen Ihrer Anwendung anpassen und Informationen für Entwickler bereitstellen, die Ihren Code verwenden.

So definieren Sie benutzerdefinierte Ausnahmen

Um benutzerdefinierte Ausnahmen zu erstellen, Definieren Sie eine Python-Klasse das erbt von der Ausnahmeklasse. Der Ausnahme Die Klasse bietet Basisfunktionen, die Sie zur Behandlung von Ausnahmen benötigen, und Sie können sie anpassen, um Funktionen basierend auf Ihren spezifischen Anforderungen hinzuzufügen.

Halten Sie beim Erstellen benutzerdefinierter Ausnahmeklassen diese einfach und schließen Sie gleichzeitig die erforderlichen Attribute zum Speichern von Fehlerinformationen ein. Ausnahmehandler können dann auf diese Attribute zugreifen, um Fehler entsprechend zu behandeln.

Hier ist eine benutzerdefinierte Ausnahmeklasse: MyCustomError:

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

Diese Klasse akzeptiert während der Initialisierung ein optionales Nachrichtenargument. Es nutzt die super() Methode zum Aufrufen des Konstruktors der Basis Ausnahme Klasse, die für die Ausnahmebehandlung unerlässlich ist.

So lösen Sie benutzerdefinierte Ausnahmen aus

Um einen Fehler auszulösen, verwenden Sie die erheben Schlüsselwort, gefolgt von einer Instanz Ihrer benutzerdefinierten Ausnahmeklasse, und übergeben Sie ihr eine Fehlermeldung als Argument:

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

Sie können den Fehler auch ohne Übergabe von Argumenten auslösen:

ifTrue:
raise MyCustomError # shorthand

Beide Formate eignen sich zum Auslösen benutzerdefinierter Fehler.

So behandeln Sie benutzerdefinierte Ausnahmen

Die Behandlung benutzerdefinierter Ausnahmen folgt dem gleichen Ansatz wie Behandlung integrierter Ausnahmen. Verwenden versuchen, außer, Und Endlich Blöcke, um benutzerdefinierte Ausnahmen abzufangen und entsprechende Maßnahmen zu ergreifen.

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")

Auf diese Weise können Sie alle Formen benutzerdefinierter Ausnahmen behandeln.

Wenn während der Ausführung von a eine Ausnahme auftritt versuchen Block, ein entsprechender außer Block kann es fangen und handhaben. Wenn es kein passendes gibt außer Block zur Behandlung der Ausnahme, beliebig Endlich Der Block wird ausgeführt, woraufhin die Ausnahme erneut ausgelöst wird. Benutze einen Endlich Der Block dient in erster Linie dazu, Bereinigungsaufgaben auszuführen, die unter allen Umständen ausgeführt werden müssen, unabhängig davon, ob eine Ausnahme auftritt oder nicht.

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

In diesem Beispiel a KeyboardInterrupt Ausnahme tritt auf, aber die außer Blockieren Sie nur Handles MyCustomError Ausnahmen. In diesem Fall ist die Endlich Der Block wird ausgeführt, und dann wird die nicht behandelte Ausnahme erneut ausgelöst.

Benutzerdefinierte Fehlerklassen erben

Basierend auf Konzept der objektorientierten Programmierung (OOP) können Sie wie reguläre Klassen auch von benutzerdefinierten Ausnahmeklassen erben. Durch das Erben von einer benutzerdefinierten Ausnahmeklasse können Sie Fehlerklassen erstellen, die einen spezifischeren Kontext für eine Ausnahme bereitstellen. Mit diesem Ansatz können Sie Fehler auf verschiedenen Ebenen Ihres Codes behandeln und besser verstehen, was den Fehler verursacht hat.

Angenommen, Sie entwickeln eine Webanwendung, die mit einer externen API interagiert. Diese API kann unterschiedliche Fehlerszenarien aufweisen. Sie möchten diese Fehler im gesamten Code konsistent und klar behandeln. Um dies zu erreichen, erstellen Sie eine benutzerdefinierte Ausnahmeklasse. BaseAPIException:

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

Sobald Sie über diese benutzerdefinierte Basisausnahmeklasse verfügen, können Sie untergeordnete Ausnahmeklassen erstellen, die davon erben:

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

Lösen Sie diese benutzerdefinierten Ausnahmen aus und fangen Sie sie ab, wenn Sie die API in Ihrer Webanwendung aufrufen. Behandeln Sie sie entsprechend mit der entsprechenden Logik in Ihrem 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}")

Die letzte Ausnahmeklausel prüft die übergeordnete Klasse und dient als Auffanglösung für alle anderen API-bezogenen Fehler.

Wenn Sie benutzerdefinierte Ausnahmeklassen erben, können Sie Fehler innerhalb der API effektiv behandeln. Mit diesem Ansatz können Sie Ihre Fehlerbehandlung von den Implementierungsdetails der API trennen. Dies erleichtert das Hinzufügen benutzerdefinierter Ausnahmen oder das Vornehmen von Änderungen, wenn sich die API weiterentwickelt oder auf neue Fehler stößt Fälle.

Benutzerdefinierte Ausnahmen umschließen

Ausnahmen einzuschließen bedeutet, eine Ausnahme abzufangen, sie in einer benutzerdefinierten Ausnahme zu kapseln und dann diese benutzerdefinierte Ausnahme auszulösen, wobei die ursprüngliche Ausnahme als Ursache angegeben wird. Diese Technik trägt dazu bei, Fehlermeldungen einen Kontext zu geben und hält Implementierungsdetails vor dem aufrufenden Code verborgen.

Stellen Sie sich das Szenario vor, in dem Ihre Web-App mit einer API interagiert. Wenn die API eine auslöst LookupError, Sie können es fangen und dann einen Brauch auslösen APINotFoundError Ausnahme, die auf den LookupError als Ursache verweist:

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__}")

Benutze einen aus Klausel mit der erheben -Anweisung, um auf die ursprüngliche Ausnahme innerhalb Ihrer benutzerdefinierten Ausnahme zu verweisen.

Wenn die benutzerdefinierte Ausnahme auftritt, schließt sie die ursprüngliche Ausnahme als ein __Ursache__ Attribut, das eine Verbindung zwischen der benutzerdefinierten Ausnahme und dem Original herstellt. Dadurch können Sie den Ursprung einer Ausnahme nachvollziehen.

Durch das Einschließen von Ausnahmen können Sie aussagekräftigeren Kontext bereitstellen und passendere Fehlermeldungen an Benutzer senden, ohne interne Implementierungsdetails Ihres Codes oder der API preiszugeben. Darüber hinaus können Sie Fehlerarten strukturiert und einheitlich verwalten und beheben.

Anpassen des Klassenverhaltens in Python

Indem Sie die von Python bereitgestellte Basisausnahmeklasse erben, können Sie einfache und nützliche Ausnahmen erstellen, die Sie auslösen können, wenn bestimmte Fehler in Ihrem Code auftreten. Sie können mithilfe von Magic- oder Dunder-Methoden auch benutzerdefiniertes Verhalten für Ihre Ausnahmeklassen implementieren.