Home-theater-designers
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.
MUO Video av dagen RULL FOR Å FORTSETTE MED INNHOLD
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.
kast vlc til chromecast windows 10
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 :
class MyCustomError(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:
if True:
raise MyCustomError("A Custom Error Was Raised!!!.")
Du kan også ta opp feilen uten å sende noen argumenter:
if True:
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.
telefonen vil ikke koble til datamaskinen
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 :
class BaseAPIException(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:
class APINotFoundError(BaseAPIException):
"""Raised when the requested resource is not found in the API."""
pass
class APIAuthenticationError(BaseAPIException):
"""Raised when there's an issue with authentication to the API."""
pass
class APIRateLimitExceeded(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.
def request_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 tilpassede unntak eller gjøre endringer etter hvert som API-en utvikler seg eller støter på nye feiltilfeller.
pc vil ikke koble til internett
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:
def request_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.