Hur man skapar anpassade undantag i Python

Pythons inbyggda undantagsklasser hanterar inte vissa felsituationer som kan uppstå i din kod. I sådana fall måste du skapa egna undantag för att hantera dessa fel på ett effektivt sätt.

I programmeringsspråk som Python är det möjligt att skapa skräddarsydda undantagsklasser som kan aktiveras vid vissa felscenarier. Genom att använda dessa anpassade undantagstyper kan man effektivt ta itu med mer exakta och detaljerade problem i sin kodbas, vilket i slutändan främjar både tydlighet och enkelt underhåll när det gäller kodorganisation och läsbarhet.

Varför behöver du anpassade undantag?

Under utvecklingen av ett program kan oförutsedda komplikationer uppstå till följd av ändringar i källkoden, gränssnitt med ytterligare moduler eller bibliotek, eller samarbete med fjärranslutna applikationer. En effektiv hantering av sådana oegentligheter är nödvändig för att säkerställa att systemet antingen kan återhämta sig från dessa bakslag eller utföra avslutningsprocedurer på ett korrekt sätt.

Python erbjuder en rad inbyggda undantag klasser som täcker fel som ValueError , TypeError , FileNotFoundError , och mer. Även om dessa inbyggda undantag fyller sitt syfte väl, kan de bara ibland representera de fel som kan uppstå i ditt program på ett korrekt sätt.

Genom att skräddarsy anpassade undantag kan man på ett mer exakt sätt tillgodose specifika behov i ett program, vilket ger värdefulla insikter för utvecklare som kan stöta på sådan kod.

Så här definierar du anpassade undantag

Om du vill skapa anpassade undantag definierar du en Python-klass som ärver från Exception-klassen . Klassen Exception erbjuder basfunktionalitet 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 man utvecklar personliga undantagskategorier är det viktigt att behålla enkelheten samtidigt som man införlivar viktiga funktioner för att bevara detaljer om misstag. Undantagshanterare kan sedan använda dessa egenskaper för att hantera misstag på ett effektivt sätt.

Här är en anpassad undantagsklass,MyCustomError:

 class MyCustomError(Exception):
    def __init__(self, message=None):
        self.message = message
        super().__init__(message)

Under initialiseringsprocessen tillåter den här klassen en villkorlig inkludering av en meddelandeparameter. Genom att använda nyckelordet “super” anropas konstruktören för den ursprungliga klassen Exception, som är en central komponent i protokoll för undantagshantering.

Hur man tar upp anpassade undantag

För att få fram ett hinder och skapa en instans av vår skräddarsydda undantagskategori kan du använda nyckelordet “raise” tillsammans med ett exempel på din skräddarsydda undantagstyp och ge det ett meddelande som sammanfattar problemets natur:

 if True:
    raise MyCustomError("A Custom Error Was Raised!!!.")

Man kan också välja att ta fram ett undantag utan att ange några argument,

 if True:
    raise MyCustomError # shorthand

Båda formaten är lika lämpliga för att skapa anpassade felmeddelanden.

Hur man hanterar anpassade undantag

När man arbetar med anpassade undantag är det viktigt att använda en liknande strategi som när man hanterar standardundantag. Det innebär att man använder try-except-finally-block för att fånga upp dessa exceptionella omständigheter och vidta lämpliga åtgärder. På så sätt kan vi effektivt hantera och återhämta oss från oväntade händelser som kan uppstå under exekveringen av vår kod.

 try:
    print("Hello, You're learning how to All Things N Custom Errors")
    raise MyCustomError("Opps, Something Went Wrong!!!.")
except MyCustomError as err:
    print(f"Error: {err}")
finally:
    print("Done Handling Custom Error")

På detta sätt är man rustad för att hantera alla tänkbara typer av exceptionella undantag som kan uppstå.

Om ett undantag uppstår under exekveringen av ett try-block, kan motsvarande except-block fånga upp och hantera det. Men om det inte finns något lämpligt except-block som kan hantera undantaget, kommer alla finally-block som finns att exekveras, vilket leder till att undantaget uppstår ännu en gång. Det primära syftet med att använda ett finally-block bör vara att utföra rensningsoperationer som är obligatoriska, 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 fall sker ett avbrott i tangentbordet, men det omfattande “except”-avsnittet är begränsat till att hantera instanser av “MyCustomError”. När “finally”-klausulen exekveras återupplivas följaktligen det tidigare okvitterade undantaget.

Ärva anpassade felklasser

Principen för objektorienterad programmering (OOP) gör det möjligt att utöka arv inte bara till standarddatatyper utan även till anpassade undantagskategorier, ungefär som med typiska klasser. Genom denna teknik är det möjligt att skapa undantagsklasser som ger ökad tydlighet när det gäller omständigheterna bakom ett fel. Denna metod gör det möjligt att hantera misstag i olika faser av programmet och resulterar i en ökad förståelse för orsaken till problemet.

För att säkerställa en konsekvent hantering av olika felscenarier i en extern API-integration i en webbapplikation är det lämpligt att fastställa en standardiserad metod genom att skapa en specifik undantagsklass som kallas BaseAPIException.

 class BaseAPIException(Exception):
    """Base class for API-related exceptions."""
    def __init__(self, message):
        super().__init__(message)
        self.message = message

För att utöka funktionaliteten hos en anpassad undantagsklass kan man skapa underklasser som är härledda från den överordnade klassen. Denna process gör det möjligt att skapa specialiserade undantag som delar gemensamma attribut och beteenden med sin överordnade klass samtidigt som de också har unika egenskaper som är skräddarsydda för specifika situationer.

 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

När du implementerar din webbapplikation är det viktigt att hantera eventuella fel som kan uppstå under API-anrop genom att skapa och fånga upp specifika anpassade undantag. På så sätt kan du effektivt hantera dessa situationer med väldefinierad programmeringslogik som är skräddarsydd för varje situation.

 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 ultimata except klausulen ansvarar för att fånga upp alla undantag som kan uppstå inom moderklassen och fungerar som en heltäckande felhanterare för oförutsedda problem relaterade till API (Application Programming Interface).

När man ärver anpassade undantagsklasser kan man effektivt hantera fel inom ett API. Denna metod gör det möjligt att separera felhanteringen från API-implementeringen, vilket gör det lättare att lägga till unika undantag eller ändringar när API:et utvecklas eller konfronteras med nya felscenarier.

Förpackning av anpassade undantag

Förpackning av undantag innebär att ett undantag fångas upp, förpackas i ett anpassat undantag och att detta nya undantag tas upp tillsammans med det ursprungliga undantagets identifiering som dess underliggande orsak. Detta tillvägagångssätt används för att ge felmeddelanden ett sammanhang och dölja implementeringsdetaljer från den anropande koden.

Om en webbapplikation kommunicerar med ett API och stöter på ett LookupError , är det möjligt att fånga upp detta fel med hjälp av undantagshantering. Därefter kan man skapa ett anpassat APINotFoundError undantag som fungerar som en härledd klass från den ursprungliga Exception klassen i Python. Detta nya undantag kan innehålla det ursprungliga LookupError som sin underliggande orsaksfaktor, vilket ger ytterligare sammanhang för det specifika problemet i fråga.

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

Använd en “from”-klausul tillsammans med “raise”-satsen för att hänvisa till det ursprungliga undantaget i ditt skräddarsydda undantag.

Det anpassade undantaget innehåller det ursprungliga undantaget som sin underliggande orsak, vilket ger det ett orsakssamband som kan spåras tillbaka till källan till problemet. Genom att granska detta attribut kan man se varifrån eventuella avvikelser eller anomalier under körningen kommer.

Genom att omsluta undantag kan man ge mer innehållsrik kontext och samtidigt skicka mer relevanta felmeddelanden till slutanvändarna, utan att avslöja de komplicerade funktionerna i ens kod eller API. Dessutom underlättar det organisering och lösning av olika typer av fel på ett ordnat och konsekvent sätt.

Anpassa klassbeteende i Python

Genom att ärva den basklass för undantag som Python tillhandahåller kan man utveckla grundläggande men effektiva undantag som ska aktiveras när särskilda fel inträffar i koden. Genom att implementera magiska eller “dunder”-metoder kan man dessutom skapa skräddarsydda beteenden för sina undantagsklasser.