Hvordan lage tilpassede unntak i Python

Pythons innebygde unntaksklasser adresserer ikke visse feilsituasjoner som kan oppstå i koden din. I slike tilfeller må du opprette tilpassede unntak for å håndtere disse feilene effektivt.

I Python kan du definere tilpassede unntak og øke dem når spesifikke feilsituasjoner oppstår. Du kan administrere spesifikke, informative feil med tilpassede unntak, og forbedre kodens lesbarhet og vedlikeholdsvennlighet.

Hvorfor trenger du tilpassede unntak?

Under utviklingen av en applikasjon kan det oppstå ulike feilscenarier på grunn av endringer i koden, integrasjon med andre pakker eller biblioteker, og interaksjoner med eksterne apper. Det er avgjørende å håndtere disse feilene for å komme seg fra dem eller håndtere feil på en elegant måte.

Python tilbyr en rekke innebygd unntak klasser som dekker feil som f.eks ValueError, TypeError, FileNotFoundError, og mer. Selv om disse innebygde unntakene tjener sin hensikt godt, kan de bare noen ganger representere feilene som kan oppstå i applikasjonen din nøyaktig.

Ved å lage tilpassede unntak kan du skreddersy dem spesifikt for å passe kravene til applikasjonen din og gi informasjon til utviklere som bruker koden din.

Hvordan definere egendefinerte unntak

For å lage tilpassede unntak, definer en Python-klasse som arver fra Unntaksklasse. De Unntak klasse tilbyr grunnleggende funksjonalitet du trenger for å håndtere unntak, og du kan tilpasse den for å legge til funksjoner basert på dine spesifikke behov.

Når du oppretter tilpassede unntaksklasser, hold dem enkle samtidig som du inkluderer nødvendige attributter for lagring av feilinformasjon. Unntaksbehandlere kan deretter få tilgang til disse attributtene for å håndtere feil på riktig måte.

Her er en tilpasset unntaksklasse, MyCustomError:

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

Denne klassen godtar et valgfritt meldingsargument under initialisering. Den bruker super() metode for å kalle konstruktøren av basen Unntak klasse, som er avgjørende for unntakshåndtering.

Slik øker du tilpassede unntak

For å få opp en feil, bruk heve nøkkelord etterfulgt av en forekomst av den egendefinerte unntaksklassen din, og sender det en feilmelding som et argument:

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

Du kan også ta opp feilen uten å sende noen argumenter:

ifTrue:
raise MyCustomError # shorthand

Begge formatene er egnet for å øke egendefinerte feil.

Hvordan håndtere tilpassede unntak

Håndtering av tilpassede unntak følger samme tilnærming som håndtere innebygde unntak. Bruk prøve, unntatt, og endelig blokkerer for å fange opp tilpassede unntak og iverksette passende tiltak.

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

På denne måten kan du håndtere alle former for egendefinerte unntak.

Hvis det oppstår et unntak under utførelsen av en prøve blokk, en tilsvarende unntatt blokken kan fange og håndtere den. Hvis det ikke er passende unntatt blokk for å håndtere unntaket, evt endelig blokk vil utføres, etterfulgt av at unntaket heves igjen. Bruk en endelig blokkere først og fremst for å utføre oppryddingsoppgaver som må kjøres under alle omstendigheter, enten det oppstår unntak eller ikke.

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

I denne prøven, a Tastaturavbrudd unntak forekommer, men unntatt blokker kun håndtak MyCustomError unntak. I dette tilfellet endelig blokken kjører, og så øker det ubehandlede unntaket igjen.

Arver egendefinerte feilklasser

Basert på konseptet objektorientert programmering (OOP), du kan også arve fra egendefinerte unntaksklasser, akkurat som vanlige klasser. Ved å arve fra en tilpasset unntaksklasse kan du opprette feilklasser som gir mer spesifikk kontekst til et unntak. Denne tilnærmingen lar deg håndtere feil på forskjellige nivåer i koden din og gir en bedre forståelse av hva som forårsaket feilen.

La oss si at du utvikler en nettapplikasjon som samhandler med en ekstern API. Denne API-en kan ha forskjellige feilscenarier. Du vil håndtere disse feilene konsekvent og tydelig gjennom hele koden. For å oppnå dette, opprette en tilpasset unntaksklasse, BaseAPIEunntak:

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

Når du har denne grunnleggende tilpassede unntaksklassen, kan du opprette underordnede unntaksklasser som arver fra den:

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

Opprett og fang disse tilpassede unntakene når du ringer til API-en i nettapplikasjonen din. Håndter dem deretter ved å bruke riktig logikk i koden din.

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

Den siste unntatt-klausulen sjekker mot den overordnede klassen og fungerer som en oppsamlingsboks for andre API-relaterte feil.

Når du arver tilpassede unntaksklasser, kan du effektivt håndtere feil i API-en. Denne tilnærmingen lar deg skille feilhåndteringen fra API-ens implementeringsdetaljer, noe som gjør det enklere å legge til egendefinerte unntak eller gjøre endringer ettersom API-en utvikler seg eller støter på nye feil saker.

Innpakning av tilpassede unntak

Å pakke inn unntak betyr å fange et unntak, kapsle det inn i et tilpasset unntak, og deretter heve det tilpassede unntaket mens du refererer til det opprinnelige unntaket som årsaken. Denne teknikken bidrar til å gi kontekst til feilmeldinger og holder implementeringsdetaljer skjult fra anropskoden.

Tenk på scenariet der nettappen din samhandler med et API. Hvis API-en øker en Oppslagsfeil, kan du fange den, og deretter heve en skikk APINotFoundError unntak som refererer til LookupError som årsak:

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

Bruk en fra klausul med heve uttalelse for å referere til det opprinnelige unntaket i det tilpassede unntaket.

Når det tilpassede unntaket oppstår, inkluderer det det opprinnelige unntaket som en __årsaken__ attributt, som gir en kobling mellom det tilpassede unntaket og originalen. Dette lar deg spore opprinnelsen til et unntak.

Ved å pakke inn unntak kan du gi mer meningsfull kontekst og sende mer passende feilmeldinger til brukere, uten å avsløre interne implementeringsdetaljer for koden din eller API. Den lar deg også administrere og adressere typer feil på en strukturert og enhetlig måte.

Tilpasse klasseatferd i Python

Ved å arve grunnunntaksklassen som Python gir, kan du lage enkle og nyttige unntak som du kan øke når spesifikke feil oppstår i koden din. Du kan også implementere tilpasset oppførsel for unntaksklassene dine ved hjelp av magi eller dunder-metoder.