Aangepaste uitzonderingen maken in Python

De ingebouwde uitzonderingsklassen van Python bieden geen oplossing voor bepaalde foutsituaties die zich in uw code kunnen voordoen. In dergelijke gevallen moet u aangepaste uitzonderingen maken om deze fouten effectief af te handelen.

In Python kunt u aangepaste uitzonderingen definiëren en deze verhogen wanneer specifieke foutsituaties optreden. U kunt specifieke, informatieve fouten beheren met aangepaste uitzonderingen, waardoor de leesbaarheid en onderhoudbaarheid van uw code wordt verbeterd.

Waarom heeft u aangepaste uitzonderingen nodig?

Tijdens de ontwikkeling van een applicatie kunnen er verschillende foutscenario’s ontstaan ​​als gevolg van wijzigingen in de code, integratie met andere pakketten of bibliotheken en interacties met externe apps. Het is van cruciaal belang om met deze fouten om te gaan, zodat u ervan kunt herstellen of fouten op een goede manier kunt afhandelen.

Python biedt een scala aan ingebouwde uitzondering klassen die fouten dekken, zoals Waardefout, Typefout, FileNotFoundFout, en meer. Hoewel deze ingebouwde uitzonderingen hun doel goed dienen, geven ze soms slechts een nauwkeurige weergave van de fouten die in uw toepassing kunnen optreden.

Door aangepaste uitzonderingen te maken, kunt u deze specifiek afstemmen op de vereisten van uw toepassing en informatie verstrekken aan ontwikkelaars die uw code gebruiken.

Aangepaste uitzonderingen definiëren

Om aangepaste uitzonderingen te maken, definieer een Python-klasse dat erft van de Uitzonderingsklasse. De Uitzondering class biedt basisfunctionaliteit die u nodig hebt om uitzonderingen af ​​te handelen, en u kunt deze aanpassen om functies toe te voegen op basis van uw specifieke behoeften.

Wanneer u aangepaste uitzonderingsklassen maakt, houd deze dan eenvoudig en voeg de noodzakelijke attributen toe voor het opslaan van foutinformatie. Uitzonderingshandlers hebben vervolgens toegang tot deze kenmerken om fouten op de juiste manier af te handelen.

Hier is een aangepaste uitzonderingsklasse, MijnAangepastFout:

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

Deze klasse accepteert een optioneel berichtargument tijdens initialisatie. Het maakt gebruik van de super() methode om de constructor van de basis aan te roepen Uitzondering klasse, die essentieel is voor de afhandeling van uitzonderingen.

Aangepaste uitzonderingen verhogen

Om een ​​fout te melden, gebruikt u de salarisverhoging trefwoord gevolgd door een exemplaar van uw aangepaste uitzonderingsklasse, waarbij u een foutmelding als argument doorgeeft:

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

U kunt de fout ook verhogen zonder argumenten door te geven:

ifTrue:
raise MyCustomError # shorthand

Beide formaten zijn geschikt voor het genereren van aangepaste fouten.

Hoe om te gaan met aangepaste uitzonderingen

Het afhandelen van aangepaste uitzonderingen volgt dezelfde aanpak als omgaan met ingebouwde uitzonderingen. Gebruik poging, behalve, En Eindelijk blokken om aangepaste uitzonderingen op te vangen en passende actie te ondernemen.

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

Op deze manier kunt u alle vormen van aangepaste uitzonderingen afhandelen.

Als er zich een uitzondering voordoet tijdens de uitvoering van a poging blok, een corresponderend behalve blok kan het opvangen en hanteren. Als er geen passend is behalve blok om de uitzondering af te handelen, any Eindelijk blok zal worden uitgevoerd, gevolgd door het opnieuw verhogen van de uitzondering. Gebruik een Eindelijk blokkeren voornamelijk om opruimtaken uit te voeren die onder alle omstandigheden moeten worden uitgevoerd, ongeacht of er een uitzondering optreedt of niet.

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

In dit voorbeeld is een ToetsenbordOnderbreken uitzondering doet zich voor, maar de behalve Blok alleen handvatten MijnAangepastFout uitzonderingen. In dit geval is de Eindelijk blok wordt uitgevoerd en vervolgens wordt de onverwerkte uitzondering opnieuw gegenereerd.

Aangepaste foutklassen overnemen

Gebaseerd op de concept van objectgeoriënteerd programmeren (OOP), kun je ook overerven van aangepaste uitzonderingsklassen, net als gewone klassen. Door te erven van een aangepaste uitzonderingsklasse, kunt u foutklassen maken die een specifiekere context voor een uitzondering bieden. Met deze aanpak kunt u fouten op verschillende niveaus in uw code afhandelen en krijgt u een beter inzicht in de oorzaak van de fout.

Stel dat u een webapplicatie ontwikkelt die samenwerkt met een externe API. Deze API kan verschillende foutscenario's hebben. U wilt deze fouten consistent en duidelijk in uw hele code afhandelen. Om dit te bereiken, maakt u een aangepaste uitzonderingsklasse, BaseAPIException:

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

Zodra u over deze aangepaste basisuitzonderingsklasse beschikt, kunt u onderliggende uitzonderingsklassen maken die hiervan overnemen:

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

Maak gebruik van deze aangepaste uitzonderingen wanneer u de API binnen uw webtoepassing aanroept. Behandel ze dienovereenkomstig met behulp van de juiste logica in uw 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}")

De laatste uitzonderingsclausule controleert de bovenliggende klasse en fungeert als verzamelpunt voor alle andere API-gerelateerde fouten.

Wanneer u aangepaste uitzonderingsklassen overneemt, kunt u fouten binnen de API effectief afhandelen. Met deze aanpak kunt u uw foutafhandeling scheiden van de implementatiedetails van de API. waardoor het gemakkelijker wordt om aangepaste uitzonderingen toe te voegen of wijzigingen aan te brengen naarmate de API evolueert of nieuwe fouten tegenkomt gevallen.

Aangepaste uitzonderingen inpakken

Het inpakken van uitzonderingen betekent dat u een uitzondering opvangt, deze inkapselt in een aangepaste uitzondering en vervolgens die aangepaste uitzondering verhoogt, terwijl u de oorspronkelijke uitzondering als oorzaak ervan vermeldt. Deze techniek helpt bij het bieden van context aan foutmeldingen en houdt implementatiedetails verborgen voor de aanroepende code.

Overweeg het scenario waarin uw web-app communiceert met een API. Als de API een Opzoekfout, je kunt het vangen en vervolgens een gewoonte maken APINotFoundFout uitzondering die verwijst naar de LookupError als oorzaak:

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

Gebruik een van clausule met de salarisverhoging -instructie om te verwijzen naar de oorspronkelijke uitzondering binnen uw aangepaste uitzondering.

Wanneer de aangepaste uitzondering optreedt, wordt de oorspronkelijke uitzondering opgenomen als __oorzaak__ attribuut, dat een link biedt tussen de aangepaste uitzondering en het origineel. Hiermee kunt u de oorsprong van een uitzondering traceren.

Door uitzonderingen in te sluiten, kunt u betekenisvollere context bieden en passendere foutmeldingen naar gebruikers sturen, zonder interne implementatiedetails van uw code of de API prijs te geven. Ook kunt u hiermee soorten fouten op een gestructureerde en uniforme manier beheren en aanpakken.

Klassengedrag aanpassen in Python

Door de basisuitzonderingsklasse over te nemen die Python biedt, kunt u eenvoudige en nuttige uitzonderingen maken die u kunt genereren wanneer er specifieke fouten in uw code optreden. U kunt ook aangepast gedrag voor uw uitzonderingsklassen implementeren met behulp van magische of dunder-methoden.