Python 3 - Gestione delle eccezioni

Python fornisce due funzionalità molto importanti per gestire qualsiasi errore imprevisto nei tuoi programmi Python e per aggiungere funzionalità di debug in essi:

• Exception Handling- Questo sarà trattato in questo tutorial. Ecco un elenco delle eccezioni standard disponibili in Python - Eccezioni standard .

• Assertions- Questo sarebbe trattato in Asserzioni nel tutorial di Python 3 .

Eccezioni standard

Di seguito è riportato un elenco delle eccezioni standard disponibili in Python. -

Sr.No.	Nome e descrizione dell'eccezione
1	Exception Classe base per tutte le eccezioni
2	StopIteration Generato quando il metodo next () di un iteratore non punta a nessun oggetto.
3	SystemExit Generato dalla funzione sys.exit ().
4	StandardError Classe base per tutte le eccezioni incorporate tranne StopIteration e SystemExit.
5	ArithmeticError Classe di base per tutti gli errori che si verificano per il calcolo numerico.
6	OverflowError Generato quando un calcolo supera il limite massimo per un tipo numerico.
7	FloatingPointError Generato quando un calcolo in virgola mobile fallisce.
8	ZeroDivisonError Generato quando si verifica la divisione o il modulo per zero per tutti i tipi numerici.
9	AssertionError Generato in caso di fallimento dell'istruzione Assert.
10	AttributeError Generato in caso di errore nel riferimento o nell'assegnazione dell'attributo.
11	EOFError Sollevato quando non c'è alcun input dalla funzione raw_input () o input () e viene raggiunta la fine del file.
12	ImportError Generato quando un'istruzione import fallisce.
13	KeyboardInterrupt Generato quando l'utente interrompe l'esecuzione del programma, di solito premendo Ctrl + c.
14	LookupError Classe base per tutti gli errori di ricerca.
15	IndexError Generato quando un indice non viene trovato in una sequenza.
16	KeyError Generato quando la chiave specificata non viene trovata nel dizionario.
17	NameError Generato quando un identificatore non viene trovato nello spazio dei nomi locale o globale.
18	UnboundLocalError Generato quando si tenta di accedere a una variabile locale in una funzione o in un metodo ma non è stato assegnato alcun valore.
19	EnvironmentError Classe base per tutte le eccezioni che si verificano al di fuori dell'ambiente Python.
20	IOError Generato quando un'operazione di input / output fallisce, come l'istruzione print o la funzione open () quando si tenta di aprire un file che non esiste.
21	OSError Generato per errori relativi al sistema operativo.
22	SyntaxError Generato quando si verifica un errore nella sintassi di Python.
23	IndentationError Generato quando il rientro non è specificato correttamente.
24	SystemError Sollevato quando l'interprete trova un problema interno, ma quando si verifica questo errore l'interprete Python non esce.
25	SystemExit Generato quando l'interprete Python viene chiuso usando la funzione sys.exit (). Se non viene gestito nel codice, fa uscire l'interprete.
26	TypeError Generato quando viene tentata un'operazione o una funzione non valida per il tipo di dati specificato.
27	ValueError Generato quando la funzione incorporata per un tipo di dati ha il tipo di argomenti valido, ma gli argomenti hanno valori non validi specificati.
28	RuntimeError Generato quando un errore generato non rientra in nessuna categoria.
29	NotImplementedError Generato quando un metodo astratto che deve essere implementato in una classe ereditata non è effettivamente implementato.

Asserzioni in Python

Un'asserzione è un controllo di integrità che puoi attivare o disattivare quando hai finito di testare il programma.

• Il modo più semplice per pensare a un'affermazione è paragonarla a un file raise-ifdichiarazione (o per essere più precisi, un'istruzione raise-if-not). Viene verificata un'espressione e se il risultato è falso, viene sollevata un'eccezione.

• Le asserzioni vengono eseguite dall'istruzione assert, la nuova parola chiave di Python, introdotta nella versione 1.5.

• I programmatori spesso inseriscono asserzioni all'inizio di una funzione per verificare l'input valido e dopo una chiamata di funzione per verificare l'output valido.

La dichiarazione di asserzione

Quando incontra un'istruzione assert, Python valuta l'espressione di accompagnamento, che si spera sia vera. Se l'espressione è falsa, Python solleva un'eccezione AssertionError .

La sintassi per assert è:

assert Expression[, Arguments]

Se l'asserzione fallisce, Python usa ArgumentExpression come argomento per AssertionError. Le eccezioni di AssertionError possono essere rilevate e gestite come qualsiasi altra eccezione, utilizzando l'istruzione try-tranne. Se non vengono gestiti, termineranno il programma e produrranno un traceback.

Esempio

Ecco una funzione che converte una data temperatura da gradi Kelvin a gradi Fahrenheit. Poiché 0 ° K è freddo quanto lo è, la funzione si interrompe se rileva una temperatura negativa -

#!/usr/bin/python3

def KelvinToFahrenheit(Temperature):
   assert (Temperature >= 0),"Colder than absolute zero!"
   return ((Temperature-273)*1.8)+32

print (KelvinToFahrenheit(273))
print (int(KelvinToFahrenheit(505.78)))
print (KelvinToFahrenheit(-5))

Quando il codice sopra viene eseguito, produce il seguente risultato:

32.0
451
Traceback (most recent call last):
File "test.py", line 9, in <module>
print KelvinToFahrenheit(-5)
File "test.py", line 4, in KelvinToFahrenheit
assert (Temperature >= 0),"Colder than absolute zero!"
AssertionError: Colder than absolute zero!

Cos'è l'eccezione?

Un'eccezione è un evento, che si verifica durante l'esecuzione di un programma che interrompe il normale flusso delle istruzioni del programma. In generale, quando uno script Python incontra una situazione che non può affrontare, solleva un'eccezione. Un'eccezione è un oggetto Python che rappresenta un errore.

Quando uno script Python solleva un'eccezione, deve gestire l'eccezione immediatamente altrimenti termina e si chiude.

Gestire un'eccezione

Se hai del codice sospetto che potrebbe sollevare un'eccezione, puoi difendere il tuo programma inserendo il codice sospetto in un filetry:bloccare. Dopo il try: block, includi un fileexcept: istruzione, seguita da un blocco di codice che gestisce il problema nel modo più elegante possibile.

Sintassi

Ecco la semplice sintassi di try .... tranne ... else blocks -

try:
   You do your operations here
   ......................
except ExceptionI:
   If there is ExceptionI, then execute this block.
except ExceptionII:
   If there is ExceptionII, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

Ecco alcuni punti importanti sulla sintassi sopra menzionata:

• Una singola istruzione try può avere più istruzioni tranne. Ciò è utile quando il blocco try contiene istruzioni che possono generare diversi tipi di eccezioni.

• È inoltre possibile fornire una clausola tranne generica, che gestisce qualsiasi eccezione.

• Dopo le clausole tranne, puoi includere una clausola else. Il codice nel blocco else viene eseguito se il codice nel blocco try: non solleva un'eccezione.

• Il blocco else è un buon posto per il codice che non ha bisogno della protezione try: block.

Esempio

Questo esempio apre un file, scrive il contenuto nel file, e ne esce con garbo perché non c'è alcun problema -

#!/usr/bin/python3

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print ("Error: can\'t find file or read data")
else:
   print ("Written content in the file successfully")
   fh.close()

Questo produce il seguente risultato:

Written content in the file successfully

Esempio

Questo esempio tenta di aprire un file in cui non si dispone dell'autorizzazione di scrittura, quindi solleva un'eccezione:

#!/usr/bin/python3

try:
   fh = open("testfile", "r")
   fh.write("This is my test file for exception handling!!")
except IOError:
   print ("Error: can\'t find file or read data")
else:
   print ("Written content in the file successfully")

Questo produce il seguente risultato:

Error: can't find file or read data

La clausola tranne senza eccezioni

È inoltre possibile utilizzare l'istruzione tranne senza eccezioni definite come segue:

try:
   You do your operations here
   ......................
except:
   If there is any exception, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

Questo tipo di a try-exceptdichiarazione cattura tutte le eccezioni che si verificano. Tuttavia, l'utilizzo di questo tipo di istruzione try-tranne non è considerato una buona pratica di programmazione, perché rileva tutte le eccezioni ma non obbliga il programmatore a identificare la causa principale del problema che può verificarsi.

La clausola tranne con più eccezioni

È inoltre possibile utilizzare la stessa istruzione tranne per gestire più eccezioni come segue:

try:
   You do your operations here
   ......................
except(Exception1[, Exception2[,...ExceptionN]]]):
   If there is any exception from the given exception list, 
   then execute this block.
   ......................
else:
   If there is no exception then execute this block.

La clausola di prova finale

Puoi usare un file finally: blocco insieme a un file try:bloccare. Ilfinally:block è un posto dove mettere qualsiasi codice che deve essere eseguito, indipendentemente dal fatto che il try-block abbia sollevato un'eccezione o meno. La sintassi dell'istruzione try-latest è questa:

try:
   You do your operations here;
   ......................
   Due to any exception, this may be skipped.
finally:
   This would always be executed.
   ......................

Note- È possibile fornire clausole tranne una o più clausole, ma non entrambe. Non puoi usare anche la clausola else insieme a una clausola finalmente.

Esempio

#!/usr/bin/python3

try:
   fh = open("testfile", "w")
   fh.write("This is my test file for exception handling!!")
finally:
   print ("Error: can\'t find file or read data")
   fh.close()

Se non si dispone dell'autorizzazione per aprire il file in modalità di scrittura, questo produrrà il seguente risultato:

Error: can't find file or read data

Lo stesso esempio può essere scritto in modo più pulito come segue:

#!/usr/bin/python3

try:
   fh = open("testfile", "w")
   try:
      fh.write("This is my test file for exception handling!!")
   finally:
      print ("Going to close the file")
      fh.close()
except IOError:
   print ("Error: can\'t find file or read data")

Questo produce il seguente risultato:

Going to close the file

Quando viene generata un'eccezione nel blocco try , l'esecuzione passa immediatamente al blocco finalmente . Dopo che tutte le istruzioni nel blocco finalmente sono state eseguite, l'eccezione viene sollevata di nuovo e viene gestita nelle istruzioni tranne se presente nel successivo livello superiore dell'istruzione try-tranne .

Argomento di un'eccezione

Un'eccezione può avere un argomento , che è un valore che fornisce ulteriori informazioni sul problema. Il contenuto dell'argomento varia in base all'eccezione. Catturi l'argomento di un'eccezione fornendo una variabile nella clausola tranne come segue:

try:
   You do your operations here
   ......................
except ExceptionType as Argument:
   You can print value of Argument here...

Se scrivi il codice per gestire una singola eccezione, puoi fare in modo che una variabile segua il nome dell'eccezione nell'istruzione tranne. Se stai intercettando più eccezioni, puoi fare in modo che una variabile segua la tupla dell'eccezione.

Questa variabile riceve il valore dell'eccezione che contiene principalmente la causa dell'eccezione. La variabile può ricevere un valore singolo o più valori sotto forma di tupla. Questa tupla di solito contiene la stringa di errore, il numero di errore e una posizione dell'errore.

Esempio

Di seguito è riportato un esempio per una singola eccezione:

#!/usr/bin/python3

# Define a function here.
def temp_convert(var):
   try:
      return int(var)
   except ValueError as Argument:
      print ("The argument does not contain numbers\n", Argument)

# Call above function here.
temp_convert("xyz")

Questo produce il seguente risultato:

The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'

Sollevare un'eccezione

Puoi sollevare eccezioni in diversi modi usando l'istruzione raise. La sintassi generale perraise l'affermazione è la seguente:

Sintassi

raise [Exception [, args [, traceback]]]

In questo caso, Exception è il tipo di eccezione (ad esempio, NameError) e l' argomento è un valore per l'argomento dell'eccezione. L'argomento è facoltativo; se non fornito, l'argomento dell'eccezione è Nessuno.

L'argomento finale, traceback, è anch'esso opzionale (e usato raramente nella pratica) e, se presente, è l'oggetto traceback usato per l'eccezione.

Esempio

Un'eccezione può essere una stringa, una classe o un oggetto. La maggior parte delle eccezioni sollevate dal core di Python sono classi, con un argomento che è un'istanza della classe. La definizione di nuove eccezioni è abbastanza semplice e può essere eseguita come segue:

def functionName( level ):
   if level <1:
      raise Exception(level)
      # The code below to this would not be executed
      # if we raise the exception
   return level

Note- Per catturare un'eccezione, una clausola "tranne" deve fare riferimento alla stessa eccezione generata come oggetto classe o come stringa semplice. Ad esempio, per catturare l'eccezione di cui sopra, dobbiamo scrivere la clausola tranne come segue:

try:
   Business Logic here...
except Exception as e:
   Exception handling here using e.args...
else:
   Rest of the code here...

L'esempio seguente illustra l'uso della generazione di un'eccezione:

#!/usr/bin/python3

def functionName( level ):
   if level <1:
      raise Exception(level)
      # The code below to this would not be executed
      # if we raise the exception
   return level

try:
   l = functionName(-10)
   print ("level = ",l)
except Exception as e:
   print ("error in level argument",e.args[0])

Questo produrrà il seguente risultato

error in level argument -10

Eccezioni definite dall'utente

Python consente anche di creare le proprie eccezioni derivando le classi dalle eccezioni incorporate standard.

Ecco un esempio relativo a RuntimeError . Qui viene creata una classe sottoclasse da RuntimeError . Ciò è utile quando è necessario visualizzare informazioni più specifiche quando viene rilevata un'eccezione.

Nel blocco try, l'eccezione definita dall'utente viene sollevata e catturata nel blocco tranne. La variabile e viene utilizzata per creare un'istanza della classe Networkerror .

class Networkerror(RuntimeError):
   def __init__(self, arg):
      self.args = arg

Quindi, una volta definita la classe sopra, puoi sollevare l'eccezione come segue:

try:
   raise Networkerror("Bad hostname")
except Networkerror,e:
   print e.args