Hur man skapar anpassade undantag i Python

Pythons inbyggda undantagsklasser adresserar inte vissa felsituationer som kan uppstå i din kod. I sådana fall måste du skapa anpassade undantag för att hantera dessa fel effektivt.

I Python kan du definiera anpassade undantag och höja dem när specifika felsituationer uppstår. Du kan hantera specifika, informativa fel med anpassade undantag, vilket förbättrar din kods läsbarhet och underhållsbarhet.

Varför behöver du anpassade undantag?

Under utvecklingen av en applikation kan olika felscenarier uppstå på grund av ändringar i koden, integration med andra paket eller bibliotek och interaktioner med externa appar. Det är avgörande att hantera dessa fel för att återhämta sig från dem eller hantera fel på ett elegant sätt.

Python erbjuder en rad inbyggt undantag klasser som täcker fel som t.ex ValueError, Skrivfel, FileNotFoundError, och mer. Även om dessa inbyggda undantag tjänar sitt syfte väl, kanske de bara ibland exakt representerar de fel som kan uppstå i din applikation.

Genom att skapa anpassade undantag kan du skräddarsy dem specifikt för att passa kraven i din applikation och ge information till utvecklare som använder din kod.

Hur man definierar anpassade undantag

För att skapa anpassade undantag, definiera en Python-klass som ärver från Undantagsklass. De Undantag class erbjuder basfunktioner som du behöver för att hantera undantag, och du kan anpassa den för att lägga till funktioner baserat på dina specifika behov.

När du skapar anpassade undantagsklasser, håll dem enkla samtidigt som du inkluderar nödvändiga attribut för att lagra felinformation. Undantagshanterare kan sedan komma åt dessa attribut för att hantera fel på lämpligt sätt.

Här är en anpassad undantagsklass, MyCustomError:

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

Den här klassen accepterar ett valfritt meddelandeargument under initiering. Den använder super() metod för att anropa basens konstruktor Undantag klass, vilket är väsentligt för undantagshantering.

Hur man höjer anpassade undantag

För att skapa ett fel, använd höja nyckelord följt av en instans av din anpassade undantagsklass och skickar ett felmeddelande till det som ett argument:

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

Du kan också ta upp felet utan att skicka några argument:

ifTrue:
raise MyCustomError # shorthand

Båda formaten är lämpliga för att ta upp anpassade fel.

Hur man hanterar anpassade undantag

Hantering av anpassade undantag följer samma tillvägagångssätt som hantera inbyggda undantag. Använda sig av Prova, bortsett från, och till sist block för att fånga anpassade undantag och vidta lämpliga åtgärder.

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å så sätt kan du hantera alla former av anpassade undantag.

Om ett undantag inträffar under utförandet av en Prova block, ett motsvarande bortsett från blocket kan fånga och hantera det. Om det inte är lämpligt bortsett från blockera för att hantera undantaget, någon till sist blocket kommer att köras, följt av att undantaget höjs igen. Använda en till sist blockera i första hand för att utföra saneringsuppgifter som måste köras under alla omständigheter, oavsett om ett undantag inträffar eller inte.

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

I detta prov, a Tangentbordsavbrott undantag förekommer, men bortsett från blockera endast handtag MyCustomError undantag. I det här fallet till sist blocket körs, och sedan höjs det obehandlade undantaget igen.

Ärver anpassade felklasser

Baserat på begreppet objektorienterad programmering (OOP), du kan också ärva från anpassade undantagsklasser, precis som vanliga klasser. Genom att ärva från en anpassad undantagsklass kan du skapa felklasser som ger ett undantag mer specifikt sammanhang. Detta tillvägagångssätt låter dig hantera fel på olika nivåer i din kod och ger en bättre förståelse för vad som orsakade felet.

Säg att du utvecklar en webbapplikation som interagerar med ett externt API. Detta API kan ha olika felscenarier. Du vill hantera dessa fel konsekvent och tydligt genom hela din kod. För att uppnå detta, skapa en anpassad undantagsklass, BaseAPIEundantag:

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

När du har den här grundläggande anpassade undantagsklassen kan du skapa underordnade undantagsklasser som ärver från 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

Höj och fånga dessa anpassade undantag när du ringer till API: t i din webbapplikation. Hantera dem därefter med hjälp av lämplig logik i din kod.

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 sista except-satsen kontrollerar mot den överordnade klassen och fungerar som en catch-all för alla andra API-relaterade fel.

När du ärver anpassade undantagsklasser kan du effektivt hantera fel inom API: et. Detta tillvägagångssätt låter dig separera din felhantering från API: s implementeringsdetaljer, vilket gör det lättare att lägga till anpassade undantag eller göra ändringar när API: et utvecklas eller stöter på nya fel fall.

Inslagning av anpassade undantag

Att radbryta undantag betyder att fånga ett undantag, kapsla in det i ett anpassat undantag och sedan ta upp det anpassade undantaget samtidigt som man hänvisar till det ursprungliga undantaget som dess orsak. Denna teknik hjälper till att ge sammanhang till felmeddelanden och håller implementeringsdetaljer dolda från anropskoden.

Tänk på scenariot där din webbapp interagerar med ett API. Om API: et höjer en LookupError, du kan fånga det och sedan höja en sed APINotFoundError undantag som refererar till LookupError som dess orsak:

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

Använda en från klausul med höja uttalande för att referera till det ursprungliga undantaget inom ditt anpassade undantag.

När det anpassade undantaget inträffar inkluderar det det ursprungliga undantaget som ett __orsak__ attribut, vilket ger en länk mellan det anpassade undantaget och originalet. Detta låter dig spåra ursprunget till ett undantag.

Genom att slå in undantag kan du ge ett mer meningsfullt sammanhang och skicka lämpligare felmeddelanden till användarna, utan att avslöja interna implementeringsdetaljer för din kod eller API. Det låter dig också hantera och åtgärda typer av fel på ett strukturerat och enhetligt sätt.

Anpassa klassbeteende i Python

Genom att ärva basundantagsklassen som Python tillhandahåller kan du skapa enkla och användbara undantag som du kan ta fram när specifika fel uppstår i din kod. Du kan också implementera anpassat beteende för dina undantagsklasser med hjälp av magi eller dunder-metoder.