Jak vytvořit vlastní výjimky v Pythonu

Vestavěné třídy výjimek Pythonu neřeší určité chybové situace, které mohou ve vašem kódu nastat. V takových případech budete muset vytvořit vlastní výjimky, abyste tyto chyby efektivně řešili.

V Pythonu můžete definovat vlastní výjimky a vyvolat je, když nastanou konkrétní chybové situace. Pomocí vlastních výjimek můžete spravovat konkrétní informativní chyby, což zlepšuje čitelnost a udržovatelnost kódu.

Proč potřebujete vlastní výjimky?

Během vývoje aplikace mohou nastat různé chybové scénáře kvůli změnám v kódu, integraci s jinými balíčky nebo knihovnami a interakcí s externími aplikacemi. Je velmi důležité tyto chyby zvládnout, abyste se z nich mohli zotavit nebo se selháním vypořádat s grácií.

Python nabízí řadu vestavěná výjimka třídy, které pokrývají chyby jako např ValueError, TypeError, FileNotFoundError, a více. I když tyto vestavěné výjimky plní svůj účel dobře, mohou jen někdy přesně reprezentovat chyby, které se mohou ve vaší aplikaci vyskytnout.

Vytvořením vlastních výjimek je můžete přizpůsobit tak, aby vyhovovaly požadavkům vaší aplikace, a poskytnout informace vývojářům, kteří používají váš kód.

Jak definovat vlastní výjimky

Chcete-li vytvořit vlastní výjimky, definovat třídu Pythonu která dědí z Třída výjimek. The Výjimka třída nabízí základní funkce, které budete potřebovat ke zpracování výjimek, a můžete ji přizpůsobit tak, aby přidávala funkce na základě vašich konkrétních potřeb.

Když vytváříte vlastní třídy výjimek, udržujte je jednoduché a zároveň zahrňte nezbytné atributy pro ukládání informací o chybách. Obslužné rutiny výjimek pak mohou přistupovat k těmto atributům a správně zpracovávat chyby.

Zde je vlastní třída výjimky, MyCustomError:

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

Tato třída přijímá volitelný argument zprávy během inicializace. Používá se super() metoda pro volání konstruktoru báze Výjimka třídy, která je nezbytná pro zpracování výjimek.

Jak zvýšit vlastní výjimky

Chcete-li vyvolat chybu, použijte vyzdvihnout klíčové slovo následované instancí vaší vlastní třídy výjimek, které mu předá chybovou zprávu jako argument:

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

Chybu můžete také vyvolat bez předávání jakýchkoli argumentů:

ifTrue:
raise MyCustomError # shorthand

Oba formáty jsou vhodné pro vytváření vlastních chyb.

Jak zacházet s vlastními výjimkami

Zpracování vlastních výjimek se řídí stejným přístupem jako zpracování vestavěných výjimek. Použití Snaž se, až na, a Konečně blokuje, aby zachytil vlastní výjimky a podnikl příslušné kroky.

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

Tímto způsobem můžete zpracovat všechny formy vyvolaných vlastních výjimek.

Pokud dojde k výjimce během provádění a Snaž se blok, odpovídající až na blok může chytit a zvládnout to. Není-li vhodné až na blok pro zpracování výjimky, libovolná Konečně blok se provede a poté znovu vyvolání výjimky. Použijte a Konečně blokovat primárně za účelem provádění úloh čištění, které musí běžet za všech okolností, bez ohledu na to, zda dojde k výjimce či nikoli.

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

V tomto příkladu a Přerušení klávesnice nastane výjimka, ale až na blokovat pouze rukojeti MyCustomError výjimky. V tomto případě je Konečně blok se spustí a poté se neošetřená výjimka znovu vyvolá.

Dědění vlastních tříd chyb

Založeno na koncept objektově orientovaného programování (OOP), můžete také dědit z vlastních tříd výjimek, stejně jako běžné třídy. Děděním z vlastní třídy výjimky můžete vytvořit třídy chyb, které výjimce poskytují konkrétnější kontext. Tento přístup vám umožňuje zpracovávat chyby na různých úrovních kódu a poskytuje lepší pochopení toho, co chybu způsobilo.

Řekněme, že vyvíjíte webovou aplikaci, která spolupracuje s externím rozhraním API. Toto rozhraní API může mít různé scénáře chyb. Tyto chyby budete chtít řešit konzistentně a jasně v celém kódu. Chcete-li toho dosáhnout, vytvořte vlastní třídu výjimky, BaseAPIEException:

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

Jakmile budete mít tuto základní vlastní třídu výjimek, můžete vytvořit podřízené třídy výjimek, které z ní dědí:

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

Zvyšte a zachyťte tyto vlastní výjimky při volání rozhraní API ve vaší webové aplikaci. Zacházejte s nimi odpovídajícím způsobem pomocí příslušné logiky ve vašem kódu.

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

Poslední klauzule kromě kontroluje nadřazenou třídu a funguje jako záchytný program pro všechny další chyby související s API.

Když zdědíte vlastní třídy výjimek, můžete efektivně zpracovávat chyby v rozhraní API. Tento přístup vám umožňuje oddělit zpracování chyb od podrobností implementace API, usnadňuje přidávání vlastních výjimek nebo provádění změn, když se rozhraní API vyvíjí nebo narazí na novou chybu případy.

Balení vlastních výjimek

Zabalit výjimky znamená zachytit výjimku, zapouzdřit ji do vlastní výjimky a poté tuto vlastní výjimku vyvolat, přičemž se jako její příčina odkazuje na původní výjimku. Tato technika pomáhá poskytnout kontext chybovým zprávám a udržuje podrobnosti implementace skryté před volajícím kódem.

Zvažte scénář, kdy vaše webová aplikace interaguje s rozhraním API. Pokud API vyvolá a LookupError, můžete to chytit a poté zvýšit zvyk Chyba APINotFoundError výjimka, která odkazuje na LookupError jako její příčinu:

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

Použijte a z klauzule s vyzdvihnout příkaz odkazovat na původní výjimku ve vaší vlastní výjimce.

Když dojde k vlastní výjimce, zahrnuje původní výjimku jako a __způsobit__ atribut poskytující propojení mezi vlastní výjimkou a originálem. To vám umožní sledovat původ výjimky.

Zabalením výjimek můžete poskytnout smysluplnější kontext a odeslat uživatelům vhodnější chybové zprávy, aniž byste odhalili podrobnosti o interní implementaci vašeho kódu nebo rozhraní API. Umožňuje vám také spravovat a řešit typy chyb strukturovaným a jednotným způsobem.

Přizpůsobení chování třídy v Pythonu

Zděděním základní třídy výjimek, kterou poskytuje Python, můžete vytvořit jednoduché a užitečné výjimky, které můžete vyvolat, když se ve vašem kódu vyskytnou konkrétní chyby. Můžete také implementovat vlastní chování pro své třídy výjimek s pomocí magických nebo dunderových metod.