python try except python handling exception with examples
Questo tutorial spiega la gestione delle eccezioni in Python utilizzando il blocco Try Except con l'aiuto di esempi di programmazione:
Due tipi di errore possono causare l'arresto improvviso di un programma Python, ad es. Errori di sintassi , e Eccezioni . In questo tutorial, discuteremo del secondo tipo di errore (eccezioni) in diversi argomenti importanti.
Trarremo molto vantaggio dalla gestione delle eccezioni nella nostra applicazione come:
- Creazione di un'applicazione robusta.
- Creazione di un codice pulito e privo di errori.
=> Visita qui per l'esclusiva serie di tutorial di formazione su Python
Cosa imparerai:
- Python prova tranne
- Eccezioni comuni di Python
- Conclusione
Python prova tranne
Una buona notizia è che Python ha un buon numero di eccezioni integrate per rilevare gli errori nel nostro codice. Inoltre, ci dà l'opportunità di creare eccezioni personalizzate quando nessuna delle eccezioni integrate soddisfa le nostre esigenze.
Che cos'è un'eccezione
Allora cos'è un'eccezione in Python? Bene, in termini semplici, ogni volta che l'interprete Python cerca di eseguire codice non valido, solleva un'eccezione, e nei casi in cui tale eccezione non viene gestita, interrompe il normale flusso delle istruzioni del programma e stampa un traceback.
Creiamo un codice non valido e vediamo come risponderà l'interprete Python.
Apri una shell Python ed esegui il codice seguente.
>>> 50/0
Questo è uno degli errori più comuni nella programmazione. Il codice sopra cerca di dividere il numero cinquanta di 0 (zero). L'interprete Python vede questa come un'operazione non valida e solleva un file ZeroDivisionError , interrompe il programma e stampa un traceback.
Possiamo vederlo chiaramente ZeroDivisionError è l'eccezione sollevata. È davvero il modo in cui Python ci dice che non è bello dividere un numero per zero. Sebbene in altri linguaggi come JavaScript, questo non è un errore; e Python proibisce severamente questa pratica.
Inoltre, è importante sapere che questo è solo un oggetto eccezione e Python ha molti di questi oggetti integrati. Dai un'occhiata a questo ufficiale di Python documentazione per vedere tutte le eccezioni integrate in Python.
Capire il Traceback
Prima di iniziare a gestire le eccezioni, penso che aiuterà a capire cosa succederà esattamente se le eccezioni non vengono gestite e come Python fa del suo meglio per informarci del nostro errore.
Ogni volta che Python incontra un errore, solleva un'eccezione. Se questa eccezione non viene gestita, produce alcune informazioni chiamate Traceback. Quindi, quali informazioni contiene questo traceback?
Contiene:
- Il messaggio di errore che ci dice quale eccezione è stata sollevata e cosa è successo prima che questa eccezione venisse sollevata.
- I vari numeri di riga del codice che hanno causato questo errore. Un errore può essere causato da una sequenza di chiamate di funzione chiamata a stack di chiamate di cui parleremo più avanti qui.
Sebbene sia un po 'confuso, promettiamo che il prossimo esempio porterà più luce alla nostra comprensione.
Ricordiamo il traceback che è stato stampato dividendo 50 per 0 sopra, possiamo vedere che il traceback contiene le seguenti informazioni:
- File '': questo ci dice che questo codice è stato eseguito da un terminale della console.
- riga 1: questo ci dice che l'errore si è verificato in questo numero di riga.
- ZeroDivisionError: divisione per zero: Ci dice quale eccezione è stata sollevata e cosa l'ha causata.
Proviamo un altro esempio e forse vediamo come a stack di chiamate sembra. Apri un editor, inserisci il codice di seguito e salva con nome tracebackExp .py
def stack1(numb): # 1 div = 0 # 2 stack2(numb, div) # 3 def stack2(numb, div): # 5 compute = numb/div # 6 print(compute) # 7 if __name__ == '__main__': # 9 numb = 5 # 10 stack1(numb) # 11
Apri un terminale nella directory in cui si trova questo file ed esegui.
python tracebackExp.py
Vedrai il seguente traceback:
Il traceback di cui sopra può sembrare confuso ma in realtà non lo è. Pythonistas ha trovato il modo migliore per leggere il traceback, che è dal file dal basso verso l'alto . Quindi, usiamo questa saggezza per cercare di capire cosa ha da offrire questo traceback.
- Nella parte inferiore, otteniamo l'eccezione che è stata sollevata e il motivo per cui è stata sollevata.
- Salendo, otteniamo il nome del file tracebackExp .py dove si è verificato questo errore, il calcolo che ha causato questo errore compute = numb / div, la funzione stack2 e la riga del numero di collegamento 6 in cui è stato eseguito questo calcolo.
- Salendo, vediamo che la nostra funzione stack2 è stata chiamata nella funzione stack1 nella riga numero 3.
- Spostandoci all'inizio, vediamo che la funzione stack1 è stata chiamata nella riga numero 11.< modulo > ci dice che è il file che viene eseguito.
Eccezioni comuni di Python
La libreria Python definisce un sacco di eccezioni integrate. Puoi controllare la documentazione di Python o chiamare il file built-in Locale () funziona come di seguito:
>>> dir(locals()['__builtins__'])
Non cercheremo di affrontare tutte queste eccezioni, ma vedremo alcune eccezioni comuni che probabilmente incontrerai.
# 1) TypeError
Viene generato quando un'operazione o una funzione viene applicata a un oggetto di tipo inappropriato.
Esempio 1
Considera il programma seguente. Prende un dividendo e un divisore, quindi calcola e stampa il risultato della divisione del dividendo per il divisore.
def compute_division(): dividend = int(input('Enter the dividend: ')) # cast string to int divisor = input('Enter the divisor: ') # no casting # Compute division result = dividend/divisor # print result print('The result of {}/{} is: {}'.format(dividend, divisor, result)) if __name__ == '__main__': result = compute_division()
Chiediamo il valore del dividendo e del divisore all'utente, ma dimentichiamo di convertire il valore della stringa del divisore in un numero intero. Quindi, finiamo con il tipo di dividendo intero ( int ) e il tipo di divisore è stringa ( p ). Quindi otteniamo il file TypeError poiché l'operatore di divisione (/) non opera sulle stringhe.
Potrebbe interessarti sapere che, a differenza di Python, Javascript ha Type Coercion che fondamentalmente converte uno dei tipi di operando in un valore equivalente del tipo dell'altro operando quando gli operandi sono di tipi diversi.
# 2) ValueError
Viene generato quando un'operazione o una funzione riceve un argomento che ha il tipo corretto ma un valore inappropriato.
Esempio 2
Considera il nostro programma in Esempio 1 sopra.
Se l'utente inserisce un valore alfanumerico per il dividendo come '3a', il nostro programma solleverà l'eccezione ValueError. Questo perché, sebbene Python int () metodo accetta qualsiasi numero o stringa e restituisce un oggetto intero, il valore della stringa non deve contenere lettere o alcun valore non numerico.
# 3) AttributeError
Questa eccezione viene sollevata durante l'assegnazione o il riferimento a un attributo che non esiste.
Esempio 3
Considera il programma di seguito. Prende un numero e calcola la sua radice quadrata usando il Modulo matematico Python
import math # import math library to gain access to its code def compute_square_root(number): # compute the square root using the math library result = math.sqr(number) return result if __name__ == '__main__': # get input to compute from user number = int(input('Compute Square root of: ')) # call function to compute square root
Quando un utente inserisce un numero, il nostro programma cerca di utilizzare una funzione del modulo matematico per calcolare la sua radice quadrata, ma solo che qui abbiamo commesso un errore. Invece di sqrt, abbiamo erroneamente digitato sqr che non esiste nel modulo di matematica.
Quindi, stavamo cercando di fare riferimento a un attributo sqr che non esiste e ha portato all'eccezione AttributeError che è stata sollevata. La maggior parte di noi commette spesso questo tipo di errore. Così non sei solo.
Gestione delle eccezioni con Try Except
Come programmatore, una cosa su cui la maggior parte di noi dedica il proprio tempo è scrivere un codice robusto e resiliente. Codice che non si rompe a causa di alcuni errori. In Python, possiamo ottenere ciò racchiudendo le nostre dichiarazioni all'interno di un file provare - tranne dichiarazione.
Istruzione Try-Except di Python
L'istruzione try-tranne ha la seguente struttura:
try: #your code goes here except '''Specify exception type(s) here''': #handle exception here
Racchiuderemo il codice in tracebackExp .py all'interno di un'istruzione try-tranne.
def stack1(numb): # 1 div = 0 # 2 stack2(numb, div) # 3 def stack2(numb, div): # 5 try: # 6 compute = numb/div # 7 print(compute) # 8 except ZeroDivisionError as zde: # 9 print(zde) # 10 if __name__ == '__main__': # 12 numb = 5 # 13 stack1(numb) # 14 print('program continuous') # 15
L'esecuzione di questo codice produrrà l'output
Ecco come funziona l'istruzione try-tranne. Python esegue il codice nel blocco try linea 7-8 . Se non viene trovato alcun codice non valido, il codice nel blocco ad eccezione linea 10 viene saltato e l'esecuzione continua.
Ma, se viene trovato un codice non valido, l'esecuzione si interrompe immediatamente nel blocco try e controlla se l'eccezione sollevata corrisponde a quella che abbiamo fornito nell'istruzione tranne linea 9 . Se corrisponde, il blocco eccetto viene eseguito e continua. In caso contrario, il programma verrà interrotto.
Il try-block di solito contiene il codice che può sollevare un'eccezione mentre il tranne-block cattura e gestisce l'eccezione.
Gestione di più eccezioni con Except
Possiamo gestire più eccezioni con un singolo 'tranne' o più 'eccezioni'. Tutto dipende da come vuoi gestire ogni eccezione.
# 1) Gestione di più eccezioni con un'unica eccezione
try: #your code goes here except(Exception1[, Exception2[,...ExceptionN]]]): #handle exception here
Questo metodo viene utilizzato quando sospettiamo che il nostro codice possa sollevare eccezioni diverse e vogliamo intraprendere la stessa azione in ogni caso. Quindi, se l'interprete Python trova una corrispondenza, verrà eseguito il codice scritto nel blocco eccetto.
Consideriamo l'esempio di codice Python di seguito
def get_fraction(value, idx): arr = [4,5,2,0] # a list of numbers idx_value = arr[idx] # if idx is > arr length, IndexError will be raised value/idx_value # if idx_value == 0, ZeroDivisionError will be raised if __name__ =='__main__': # set 'value' and 'idx' value = 54 idx = 3 # call function in a try-except statement. try: result = get_fraction(value, idx) print('Fraction is ', result) except (IndexError, ZeroDivisionError) as ex: print(ex)
Abbiamo due possibili eccezioni che potrebbero essere sollevate qui, ZeroDivisionError e IndexError . Se una qualsiasi di queste eccezioni viene sollevata, verrà eseguito il blocco tranne.
Nel codice sopra, idx = 3, quindi idx_ valore diventa 0 e valore / idx_ valore solleverà ZeroDivisionError
# 2) Gestione di più eccezioni con più eccezioni
try: #your code goes here except Exception1: #handle exception1 here except Exception2: #handle exception2 here except ExceptionN: #handle exceptionN here
Se preferiamo gestire ogni eccezione separatamente, è così che puoi farlo.
Considera il codice Python di esempio di seguito
def get_fraction(value, idx): arr = [4,5,2,0] # a list of numbers idx_value = arr[idx] # if idx is > arr length, IndexError will be raised value/idx_value # if idx_value == 0, ZeroDivisionError will be raised if __name__ =='__main__': # set 'value' and 'idx' value = 54 idx = 5 # call function in a try-excepts statement. try: result = get_fraction(value, idx) print('Fraction is ', result) except IndexError: print('idx of {} is out of range'.format(idx)) except ZeroDivisionError: print('arr[{}] is 0. Hence, can't divide by zero'.format(idx)) except Exception as ex: print(ex) print('Not sure what happened so not safe to continue, app will be interrupted') raise ex
Notiamo qui che l'eccezione è stata utilizzata nell'ultima istruzione ad eccezione. Questo perché l'oggetto eccezione Exception corrisponde a qualsiasi eccezione. Per questo motivo, dovrebbe essere sempre l'ultimo, poiché Python interromperà il controllo degli altri gestori di eccezioni una volta che uno corrisponde.
Nel codice sopra, idx = 5 , quindi arr [idx] solleverà IndexError perché idx è maggiore della lunghezza dell'elenco arr
Inoltre, non è sicuro quale eccezione sia stata sollevata dalla tua applicazione non è mai sicuro continuare l'esecuzione. Ecco perché abbiamo il tipo Eccezione per rilevare eventuali eccezioni impreviste. Quindi, informiamo l'utente e interrompiamo l'applicazione sollevando la stessa eccezione.
Istruzione Try Else
Questo è un caratteristica opzionale della gestione delle eccezioni e consente di aggiungere il codice che si desidera eseguire quando non si sono verificati errori. Se si verifica un errore, questo altro blocco non verrà eseguito.
Considera l'esempio di codice Python qui sotto, apri il tuo editor e salva il codice come elseTry.py
def fraction_of_one(divisor): value = 1/divisor # if divisor is zero, ZeroDivisionError will be raised return value if __name__ == '__main__': while True: try: # Get input from the user. # if input is not a valid argument for int(), ValueError will be raised divisor = int(input('Enter a divisor: ')) # call our function to compute the fraction value = fraction_of_one(divisor) except (ValueError, ZeroDivisionError): print('Input can't be zero and should be a valid literal for int(). Please, try again!') else: print('Value: ', value) break
Otteniamo input dall'utente e lo usiamo per dividere 1. Abbiamo due possibili eccezioni qui, un input utente non valido che causerà ValueError e a zero (0) che causerà ZeroDivisionError . La nostra istruzione tranne gestisce questi errori.
Ora vogliamo stampare il valore di valore . Il nostro blocco else si assicura che venga stampato solo se il nostro blocco try viene eseguito senza errori. Questo è importante perché se si verifica un errore nel nostro blocco try, il file valore sarà indefinito. Quindi, accedervi solleverà un altro errore.
Esegui il codice sopra con Python elseTry.py
L'output sopra mostra che per il primo input, abbiamo digitato 0 e premuto INVIO. Poiché il nostro divisore ha ricevuto 0, 1 / divisor sollevato zeroDivisionError . Il nostro secondo input era k, che non è valido per int (), da qui l'eccezione ValueError viene sollevato.
Ma il nostro ultimo input è stato 9, il che è valido e, di conseguenza, abbiamo ottenuto il valore ' valore 'Stampato come 0,1111111111111111
Prova finalmente la dichiarazione
Anche questo è un file caratteristica opzionale di gestione delle eccezioni e verrà sempre eseguito indipendentemente da ciò che accade nei gestori di eccezioni.
Questo è:
- Indica se si verifica o meno un'eccezione
- Anche se viene chiamato un 'ritorno' negli altri blocchi.
- Anche se lo script viene chiuso negli altri blocchi
Quindi, se abbiamo un codice che vogliamo eseguire in tutte le situazioni, finalmente-block è il nostro ragazzo. Questo blocco viene utilizzato principalmente per le pulizie come la chiusura dei file.
Considera il codice Python di esempio di seguito
def readFile(file_path): try: openFile = open(file_path,'r') # Open a file as read-only print(openFile.readline()) # Read first line of file content except FileNotFoundError as ex: print(ex) finally: print('Cleaning...') openFile.close() if __name__ == '__main__': filePath = './text.txt' readFile(filePath)
Questo codice tenta di aprire e leggere il file text.txt nella sua directory corrente. Se il file esiste, il nostro programma stamperà la prima riga del file, quindi verrà eseguito il nostro blocco finale e chiuderà il file.
Supponiamo di avere un file chiamato text.txt nella directory in cui si trova questo file di programma e che contiene Hello. Se eseguiamo il programma, avremo l'output
Questo esempio è stato scelto intenzionalmente perché volevo che affrontassimo un piccolo problema che potrebbe verificarsi durante la chiusura dei file nel blocco finale.
Se il file non esiste, l'eccezione FileNotFoundError verrà sollevato e la variabile apri il file non sarà definito e non sarà un oggetto file. Quindi, provare a chiuderlo nel blocco alla fine solleverà un'eccezione UnboundLocalError che è una sottoclasse di NameError .
Questo in pratica dice che stiamo cercando di fare riferimento alla variabile apri il file prima che sia stato assegnato.
Un piccolo trucco qui è usare i gestori di eccezioni all'interno del blocco finale.
def readFile(file_path): try: openFile = open(file_path,'r') # Open a file as read-only print(openFile.readline()) # Read first line of file content except FileNotFoundError as ex: print(ex) finally: try: print('Cleaning...') openFile.close() except: # catches all exceptions pass # Ignore this error because we don't care. if __name__ == '__main__': filePath = './text.txt' readFile(filePath)
Se il nostro blocco try solleva FileNotFoundError, avremo il seguente output
Solleva eccezione
Una buona notizia sulle eccezioni di Python è che possiamo sollevarle intenzionalmente. Le eccezioni vengono sollevate con dichiarazione di rilancio .
L'istruzione raise ha la seguente sintassi:
raise [ExceptionName[(*args: Object)]]
Apri un terminale e solleva qualsiasi oggetto eccezione dal file Eccezioni integrate in Python. Per esempio, se alziamo ZeroDivisionError:
>>> raise ZeroDivisionError('Can't divide by zero')
Otterremo il traceback:
Allora, perché è importante sollevare eccezioni?
- Quando si lavora con eccezioni personalizzate.
- Durante i controlli di sanità mentale.
Classi di eccezione personalizzate
Un'eccezione personalizzata è quella che crei per gestire gli errori specifici delle tue necessità. Il trucco è che definiamo una classe che deriva dall'oggetto Eccezione , quindi usiamo l'istruzione raise per aumentare la nostra classe di eccezioni.
Supponiamo di voler controllare l'input dell'utente e assicurarci che il valore di input non sia negativo (controllo di integrità). Ovviamente, potremmo sollevare l'eccezione ValueError di Python ma ci piacerebbe personalizzare l'errore dandogli un nome specifico e autoesplicativo come InputIsNegativeError . Ma questa eccezione non è un'eccezione incorporata in Python.
Quindi prima creiamo la nostra classe base che deriverà da Exception.
class CustomError(Exception): 'Base class exception for all exceptions of this module' pass
Quindi creiamo la nostra classe di eccezione che erediterà la classe base e gestirà il nostro errore specifico.
class InputIsNegativeError(CustomError): '''Raised when User enters a negative value''' pass
Proviamo questo
try: value = int(input()) if value <0: raise InputIsNegativeError # Raise exception if value is negative except InputIsNegativeError: # catch and handle exception print('Input value shouldn't be negative')
Il codice sopra richiesto per l'input dell'utente e controlla se è negativo. Se true, solleva la nostra eccezione personalizzata InputIsNegativeError che viene successivamente catturata nell'istruzione tranne.
Di seguito il codice completo:
class CustomError(Exception): 'Base class exception for all exceptions of this module' pass class InputIsNegativeError(CustomError): '''Raised when User enters a negative value''' pass if __name__ == '__main__': try: value = int(input('Input a number: ')) if value <0: raise InputIsNegativeError # Raise exception if value is negative except InputIsNegativeError: # catch and handle exception print('Input value shouldn't be negative')
Se il valore di input è un numero negativo come -1, avremo l'output:
come scrivere casi di test automatizzati
Controlla il Documento Python per maggiori dettagli sulle eccezioni personalizzate di Python.
Domande frequenti
D # 1) In che modo Python gestisce un'eccezione?
Risposta: Python gestisce le eccezioni usando il dichiarazione di prova . Il codice che può sollevare un'eccezione viene inserito ed eseguito nel file prova a bloccare mentre il tranne il blocco contiene il codice che gestirà le eccezioni, se presenti.
D # 2) Cosa sta sollevando un'eccezione in Python?
Risposta: Ogni volta che l'interprete Python incontra un codice non valido, solleva un'eccezione, che è il modo in cui Python ci dice che è successo qualcosa di inaspettato. Possiamo anche sollevare intenzionalmente eccezioni usando il dichiarazione di rilancio .
D # 3) In che modo Python gestisce più eccezioni?
Risposta: Python gestisce più eccezioni utilizzando un singolo blocco tranne o più blocchi tranne.
Per un singolo blocco, le eccezioni vengono passate come una tupla: tranne (Eccezione1, Eccezione2, .., EccezioneN) e Python verifica una corrispondenza da destra a sinistra. In questo caso, viene eseguita la stessa azione per ciascuna eccezione.
Un altro modo per catturare tutte le eccezioni è omettere il nome dell'eccezione dopo la parola chiave tranne.
except: # handle all exceptions here
Il secondo modo è usare un blocco eccetto per ogni eccezione:
except Exception1: # code to handle Exception1 goes here except Exception2: # code to handle Exception2 goes here except ExceptionN: # code to handle ExceptionN goes here
In questo modo, puoi eseguire azioni separate per ciascuna eccezione.
D # 4) Perché la gestione delle eccezioni è importante in Python?
Risposta: Il vantaggio di gestire le eccezioni in Python è che possiamo creare applicazioni robuste, pulite e prive di errori. Non vogliamo che il nostro codice di produzione si blocchi a causa di alcuni errori, quindi gestiamo gli errori e manteniamo la nostra applicazione attiva e funzionante.
Q # 5) Come ignori un'eccezione in Python?
Risposta: Per ignorare un'eccezione in Python, usa il passaggio parola chiave nel blocco di eccezione. Supponiamo di voler ignorare l'eccezione ValueError. Lo faremo in questo modo:
except ValueError: pass
A meno che tu non sappia cosa stai facendo, è una cattiva pratica ignorare le eccezioni. Almeno, informa l'utente di tutti i potenziali errori.
Conclusione
In questo tutorial, abbiamo trattato: Python Exceptions, Traceback; come gestire le eccezioni con Provare / Tranne / Altro / Infine blocchi, come Aumentare Eccezioni e infine come creare le nostre eccezioni personalizzate.
Grazie per aver letto!
=> Visita qui per imparare Python da zero.
Lettura consigliata
- Tutorial Python per principianti (formazione pratica GRATUITA su Python)
- Dichiarazioni di controllo Python (Python Continue, Break and Pass)
- Tutorial Python DateTime con esempi
- Funzioni stringa Python
- Variabili Python
- Esercitazione sulla gestione delle eccezioni C # con esempi di codice
- Guida completa alla gestione delle eccezioni PL SQL con esempi
- Eccezioni Java e gestione delle eccezioni con esempi