Come creare eccezioni personalizzate in Python

Le classi di eccezioni integrate di Python non risolvono determinate situazioni di errore che potrebbero verificarsi nel codice. In questi casi, dovrai creare eccezioni personalizzate per gestire questi errori in modo efficace.

In Python, puoi definire eccezioni personalizzate e sollevarle quando si verificano situazioni di errore specifiche. Puoi gestire errori informativi specifici con eccezioni personalizzate, migliorando la leggibilità e la manutenibilità del tuo codice.

Perché hai bisogno di eccezioni personalizzate?

Durante lo sviluppo di un'applicazione possono verificarsi diversi scenari di errore dovuti a modifiche del codice, integrazione con altri pacchetti o librerie e interazioni con app esterne. È fondamentale gestire questi errori per risolverli o gestire gli errori con garbo.

Python offre una gamma di eccezione incorporata

classi che coprono errori come ValoreErrore, TypeError, ErroreFileNotFounde altro ancora. Sebbene queste eccezioni integrate servano bene al loro scopo, solo a volte possono rappresentare accuratamente gli errori che possono verificarsi nella tua applicazione.

Creando eccezioni personalizzate, puoi personalizzarle in modo specifico per soddisfare i requisiti della tua applicazione e fornire informazioni agli sviluppatori che utilizzano il tuo codice.

Come definire eccezioni personalizzate

Per creare eccezioni personalizzate, definire una classe Python che eredita da Classe di eccezione. IL Eccezione La classe offre le funzionalità di base necessarie per gestire le eccezioni e puoi personalizzarla per aggiungere funzionalità in base alle tue esigenze specifiche.

Quando crei classi di eccezioni personalizzate, mantienile semplici includendo gli attributi necessari per archiviare le informazioni sugli errori. I gestori delle eccezioni possono quindi accedere a questi attributi per gestire gli errori in modo appropriato.

Ecco una classe di eccezione personalizzata, MyCustomError:

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

Questa classe accetta un argomento del messaggio facoltativo durante l'inizializzazione. Utilizza il super() metodo per chiamare il costruttore della base Eccezione classe, che è essenziale per la gestione delle eccezioni.

Come sollevare eccezioni personalizzate

Per generare un errore, utilizzare il file aumentare parola chiave seguita da un'istanza della classe di eccezione personalizzata, passandole un messaggio di errore come argomento:

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

Puoi anche sollevare l'errore senza passare alcun argomento:

ifTrue:
raise MyCustomError # shorthand

Entrambi i formati sono adatti per generare errori personalizzati.

Come gestire le eccezioni personalizzate

La gestione delle eccezioni personalizzate segue lo stesso approccio di gestire le eccezioni integrate. Utilizzo Tentativo, tranne, E Finalmente blocchi per rilevare eccezioni personalizzate e intraprendere le azioni appropriate.

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

In questo modo, puoi gestire tutte le forme di eccezioni personalizzate sollevate.

Se si verifica un'eccezione durante l'esecuzione di a Tentativo blocco, un corrispondente tranne il blocco può catturarlo e gestirlo. Se non c'è nulla di appropriato tranne blocco per gestire l'eccezione, any Finalmente verrà eseguito il blocco, seguito dall'eccezione sollevata nuovamente. Usare un Finalmente bloccare principalmente per eseguire attività di pulizia che devono essere eseguite in qualsiasi circostanza, indipendentemente dal fatto che si verifichi o meno un'eccezione.

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

In questo esempio, a Interruzione tastiera si verifica un'eccezione, ma il tranne bloccare solo le maniglie MyCustomError eccezioni. In questo caso, il Finalmente il blocco viene eseguito, quindi l'eccezione non gestita viene sollevata di nuovo.

Ereditarietà delle classi di errore personalizzate

Basato sul concetto di programmazione orientata agli oggetti (OOP), puoi anche ereditare da classi di eccezioni personalizzate, proprio come le classi normali. Ereditando da una classe di eccezioni personalizzata, puoi creare classi di errore che forniscono un contesto più specifico a un'eccezione. Questo approccio consente di gestire gli errori a diversi livelli nel codice e fornisce una migliore comprensione della causa dell'errore.

Supponiamo che tu stia sviluppando un'applicazione Web che interagisce con un'API esterna. Questa API potrebbe presentare diversi scenari di errore. Ti consigliamo di gestire questi errori in modo coerente e chiaro in tutto il codice. Per raggiungere questo obiettivo, crea una classe di eccezioni personalizzata, BaseAPIException:

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

Una volta ottenuta questa classe di eccezioni personalizzata di base, puoi creare classi di eccezioni secondarie che ereditano da essa:

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

Genera e rileva queste eccezioni personalizzate quando effettui chiamate all'API all'interno della tua applicazione web. Gestiscili di conseguenza utilizzando la logica appropriata nel codice.

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

La clausola finale tranne verifica la classe genitore e funge da catch-all per qualsiasi altro errore relativo all'API.

Quando erediti classi di eccezioni personalizzate, puoi gestire in modo efficace gli errori all'interno dell'API. Questo approccio ti consente di separare la gestione degli errori dai dettagli di implementazione dell'API, rendendo più semplice aggiungere eccezioni personalizzate o apportare modifiche man mano che l'API si evolve o rileva nuovi errori casi.

Wrapping delle eccezioni personalizzate

Racchiudere le eccezioni significa catturare un'eccezione, incapsularla all'interno di un'eccezione personalizzata e quindi sollevare l'eccezione personalizzata facendo riferimento all'eccezione originale come causa. Questa tecnica aiuta a fornire il contesto ai messaggi di errore e mantiene i dettagli di implementazione nascosti al codice chiamante.

Considera lo scenario in cui la tua app Web interagisce con un'API. Se l'API solleva a Errore di ricerca, puoi prenderlo, quindi creare un'abitudine APINotFoundErrore eccezione che fa riferimento a LookupError come causa:

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

Usare un da clausola con il aumentare per fare riferimento all'eccezione originale all'interno dell'eccezione personalizzata.

Quando si verifica l'eccezione personalizzata, include l'eccezione originale come a __causa__ attributo, fornendo un collegamento tra l'eccezione personalizzata e l'originale. Ciò consente di risalire all'origine di un'eccezione.

Inserendo le eccezioni, puoi fornire un contesto più significativo e inviare messaggi di errore più appropriati agli utenti, senza rivelare i dettagli di implementazione interna del tuo codice o dell'API. Consente inoltre di gestire e affrontare le tipologie di errori in modo strutturato e uniforme.

Personalizzazione del comportamento della classe in Python

Ereditando la classe di eccezione di base fornita da Python, puoi creare eccezioni semplici e utili che puoi sollevare quando si verificano errori specifici nel tuo codice. Puoi anche implementare un comportamento personalizzato per le tue classi di eccezioni con l'aiuto di metodi magic o dunder.