Gestione degli errori su Python

Gestione degli errori su Python#

La gestione degli errori è un aspetto fondamentale della programmazione. Gli errori possono verificarsi per molte ragioni, come input non validi, divisioni per zero, o tentativi di accesso a file inesistenti. Python fornisce strumenti per gestire questi errori in modo da evitare che il programma si blocchi inaspettatamente e per facilitare il debugging.

Lettura e comprensione degli errori#

Quando si verifica un errore in Python, il programma genera un messaggio di errore chiamato traceback. Questo messaggio include informazioni dettagliate sul tipo di errore e dove si è verificato nel codice. Imparare a leggere i tracebacks è essenziale per identificare la causa degli errori.

def divisione(a, b):
    return a / b

# Questo genera un errore perché stiamo tentando di dividere per zero
divisione(10, 0)

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[1], line 5
      2     return a / b
      4 # Questo genera un errore perché stiamo tentando di dividere per zero
----> 5 divisione(10, 0)

Cell In[1], line 2, in divisione(a, b)
      1 def divisione(a, b):
----> 2     return a / b

ZeroDivisionError: division by zero

Vediamo come interpretare questo traceback:

  • Traceback (most recent call last): indica che l’errore si è verificato nell’ultima operazione eseguita.

  • Cell In[..], line 5: mostra la linea di codice in cui l’errore è stato sollevato.

  • Cell In[..], line 2: mostra che l’errore si è verificato nella funzione divisione, alla riga 2.

  • ZeroDivisionError: division by zero: questo è il tipo di errore specifico (in questo caso un ZeroDivisionError), e la spiegazione dell’errore (“division by zero”).

Vediamo ora quali sono i tipi di errore più comuni in Python, e cosa li causa:

  1. SyntaxError: si verifica quando il codice contiene errori di sintassi. Questo può accadere, ad esempio, se dimentichi una parentesi o un due punti.

if 10 > 5
    print("Errore di sintassi")

  Cell In[2], line 1
    if 10 > 5
             ^
SyntaxError: expected ':'

  1. TypeError: si verifica quando tenti di eseguire un’operazione su tipi di dati non compatibili.

print("10" + 5)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[3], line 1
----> 1 print("10" + 5)

TypeError: can only concatenate str (not "int") to str

  1. NameError: si verifica quando tenti di usare una variabile o funzione che non è stata definita.

print(x)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[4], line 1
----> 1 print(x)

NameError: name 'x' is not defined

  1. IndexError: si verifica quando tenti di accedere a un elemento di una lista usando un indice fuori dai limiti.

lista = [1, 2, 3]
print(lista[5])

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[5], line 2
      1 lista = [1, 2, 3]
----> 2 print(lista[5])

IndexError: list index out of range

  1. KeyError: si verifica quando tenti di accedere a una chiave inesistente in un dizionario.

dizionario = {"nome": "Luca"}
print(dizionario["età"])

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[6], line 2
      1 dizionario = {"nome": "Luca"}
----> 2 print(dizionario["età"])

KeyError: 'età'

  1. ValueError: si verifica quando una funzione riceve un argomento valido per tipo, ma non per valore.

int("abc")

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[7], line 1
----> 1 int("abc")

ValueError: invalid literal for int() with base 10: 'abc'

Gestire gli errori con try e except#

Per prevenire l’interruzione del codice a causa di un errore, Python consente di gestire le eccezioni usando i blocchi try e except. Il codice che potrebbe causare un errore viene inserito all’interno del blocco try, e se si verifica un errore, il programma passa al blocco except.

Warning

Attenzione a non abusare della funzionalità di try e except, poiché tali funzioni possono rendere difficile debuggare il programma, se usate in maniera poco controllata.

Vediamone un esempio:

def divisione(a, b):
    try:
        risultato = a / b
    except ZeroDivisionError:
        print("Errore: divisione per zero non consentita!")
        risultato = None
    return risultato

print(divisione(10, 0))  # Genera errore 10 / 0

Errore: divisione per zero non consentita!
None

In questo esempio, se si verifica un errore di divisione per zero (ZeroDivisionError), il programma non si blocca ma stampa un messaggio di errore e restituisce None.

Contents