Crea eccezioni personalizzate in Python

1. Crea una classe di eccezione personalizzata in Python
2. Esegui la gestione delle eccezioni usando il blocco try...except in Python

Questo tutorial dimostrerà che puoi creare classi di eccezioni personalizzate in Python. Qui mostreremo come eseguire correttamente la gestione delle eccezioni, definire classi di eccezioni personalizzate e sovrascrivere le eccezioni integrate esistenti.

Le eccezioni sono un tipo di evento che si verifica ogni volta che qualcosa all’interno di un programma non va come previsto o interrompe il flusso del caso d’uso previsto del programma. Senza la gestione delle eccezioni, il programma cesserà di essere eseguito completamente e l’eccezione dovrebbe essere corretta o gestita.

Crea una classe di eccezione personalizzata in Python

La creazione di una classe di eccezione in Python viene eseguita allo stesso modo di una classe normale. La differenza principale è che devi includere la classe di base Exception di Python per informare il compilatore che la classe che stai creando è una classe di eccezione.

Testiamo questo metodo per creare una classe di eccezione chiamata DemoException e usiamo la parola chiave del flusso di controllo segnaposto pass inside come segnaposto.

class DemoException(Exception):
    pass

Esegui l’aumento delle eccezioni usando la parola chiave raise in Python

Per testare la classe DemoException e vedere cosa mostra quando viene effettivamente attivata, eseguire l’innalzamento delle eccezioni. Sollevamento di eccezioni è sinonimo di lancio di eccezioni in altri linguaggi di programmazione.

Utilizzando la parola chiave raise, attiva un’eccezione utilizzando la classe di eccezione data e genera un messaggio di eccezione.

class DemoException(Exception):
    pass


raise DemoException

Produzione:

Traceback (most recent call last):
  File "/Users/demo/python/demo_exception.py", line 4, in <module>
    raise DemoException
__main__.DemoException

Un’eccezione standard apparirà nel terminale se non è stato dichiarato alcun messaggio di eccezione personalizzato.

Dichiara un messaggio di eccezione personalizzato in Python

Per dichiarare un messaggio di eccezione personalizzato per DemoException, sovrascrivere il metodo __init__() della classe di eccezione e includere il messaggio che dovrebbe essere emesso per l’eccezione nei parametri, insieme al parametro autoreferenziale obbligatorio self.

Ad esempio, sovrascriviamo il metodo __init__() e creiamo un messaggio personalizzato per la classe DemoException:

class DemoException(Exception):
    def __init__(self, message):
        super().__init__(message)

Prendi nota che per integrare correttamente il messaggio nella tua eccezione, chiama la classe di base Exception, il metodo __init__() e includi il message come argomento.

Chiamiamo di nuovo la classe di eccezione usando la parola chiave raise, e ora, passandoci un messaggio personalizzato:

class DemoException(Exception):
    def __init__(self, message):
        super().__init__(message)


message = "Exception Triggered! Something went wrong."
raise DemoException(message)

L’output dovrebbe essere simile a questo:

Traceback (most recent call last):
  File "/Users/demo/python/helloworld.py", line 6, in <module>
    raise DemoException(message)
__main__.DemoException: Exception Triggered! Something went wrong.

Ora abbiamo creato e attivato con successo una classe di eccezione con un messaggio di errore personalizzato.

Per le situazioni reali che possono attivare un’eccezione, come gestiamo e solleviamo queste eccezioni? È possibile risolvere questo problema in modo ordinato implementando la gestione delle eccezioni utilizzando il blocco try...except.

Esegui la gestione delle eccezioni usando il blocco try...except in Python

Il blocco try...except è molto simile al blocco try-catch in altri linguaggi come Java.

Il blocco try...except ha 2 blocchi principali e 2 blocchi opzionali:

• try (richiesto) - Il blocco principale responsabile dell’incapsulamento del blocco di codice in cui potrebbe essere attivata l’eccezione. Il blocco try interrompe l’intero processo al suo interno ogni volta che viene attivata un’eccezione.
• except (richiesto) - Il programma a blocchi procede ogni volta che viene attivata un’eccezione specificata. Questo blocco contiene tipicamente un messaggio di errore descrittivo per il chiamante o solo una semplice istruzione print(). Potrebbe esserci più di un blocco except in un singolo blocco try, ognuno dei quali cattura eccezioni diverse.
• else (opzionale) - Questo blocco opzionale è il punto in cui il programma procederà se il blocco try non ha attivato alcuna eccezione.
• finally (opzionale) - Questo blocco opzionale viene eseguito una volta che è stato eseguito tutto dai precedenti 3 blocchi, indipendentemente dal fatto che venga attivata o meno un’eccezione.

Usiamo l’esempio precedente usando la classe DemoException per provare un semplice blocco try...except.

Per prima cosa, inserisci la parola chiave raise in una funzione e inseriscila nel blocco try...except.

La funzione che creeremo per questo esempio è una funzione che accetta un numero e genera un’eccezione se invia 0. Se invia qualsiasi altro numero, il codice procederà come previsto. Controlla l’esempio qui sotto:

class DemoException(Exception):
    def __init__(self, message):
        super().__init__(message)


message = "Exception Triggered! Something went wrong."


def triggerException(num):
    if num == 0:
        raise DemoException(message)
    else:
        print(num)


try:
    triggerException(0)
    print("Code has successfully been executed.")
except DemoException:
    print("Error: Number should not be 0.")

Poiché triggerException() ha passato 0 come argomento, il codice dovrebbe attivare DemoException. Qui dovremmo aspettarci che il messaggio della parola chiave raise venga sovrascritto con tutto ciò che è all’interno del blocco except come output.

Notare che la riga print() dopo la chiamata alla funzione triggerException() non è stata emessa. È perché la funzione ha sollevato un’eccezione; quindi, ha immediatamente interrotto tutti i processi all’interno del blocco try e ha proceduto direttamente al blocco except.

Produzione:

Error: Number should not be 0.

Ora proviamo a passare un numero valido come 20, per esempio.

try:
    triggerException(20)
    print("Code has successfully been executed.")
except DemoException:
    print("Error: Number should not be 0.")

Produzione:

20
Code has successfully been executed.

Proviamo a concatenare i blocchi except e creiamo un’altra eccezione. Chiamiamo la nuova eccezione NumberFormatException, che si attiva se l’input dato non è un numero. Per questa classe di eccezione, dichiariamo il messaggio all’interno della classe.

class NumberFormatException(Exception, value):
    message = f"{value} is not a number"

    def __init__(self):
        super().__init__(message)

Ora, modifica il codice sopra per gestire la nuova classe di eccezione NumberFormatException:

class DemoException(Exception):
    def __init__(self, message):
        super().__init__(message)


class NumberFormatException(Exception):
    def __init__(self, message, value):
        message = f"{value} is not a number"
        super().__init__(message)


message = "Exception occured."


def triggerException(num):
    if not num.isdigit():
        raise NumberFormatException(message, num)
    elif num == 0:
        raise DemoException(message)
    else:
        print(num)


num = "sample string"
try:
    triggerException(num)
    print("Code has successfully been executed.")
except DemoException:
    print("Error: Number should not be 0.")
except NumberFormatException:
    print(num + " is not a number.")

In questo codice, il valore di num che è stato passato a triggerException() è una stringa 'sample string', quindi dovrebbe essere attivata la NumberFormatException.

Produzione:

sample string is not a number.

In sintesi, creare eccezioni personalizzate in Python è semplice come creare una nuova classe, ma con la classe Exception come argomento aggiuntivo nella definizione della classe. La parola chiave raise viene utilizzata per attivare eccezioni data la classe di eccezione. I blocchi try...except sono usati per avvolgere una o più eccezioni all’interno di un blocco di codice e modificare ciò che il codice fa quando gestisce quell’eccezione e non solo chiudendo completamente il programma.