Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

Prontuario Python9. Gli errori

Gli errori

Leggere un traceback, try ed except, raise, assert e gli errori che incontri più spesso

Un errore non è un fallimento: è Python che ti dice cosa non va e dove. Nella prima parte della pagina c'è come si legge e come si gestisce un errore; nella seconda, gli errori più frequenti, uno per voce, con un esempio che li fa nascere davvero. Nel codice, # → dice cosa vale quella riga, cosa stampa, o quale errore dà.

Se hai un errore davanti adesso, cercalo nel Pronto soccorso. La spiegazione lunga è nel libro degli errori: Il traceback, Gli errori per nome, try, except e raise.

Leggere un traceback

Quando un programma si ferma per un errore, Python stampa un traceback: la strada che ha fatto fino al punto del guaio. Si legge dal basso. Questo è tabellone.py:

Python
def media_ritardi(ritardi):
    totale = sum(ritardi)
    return totale / len(ritardi)


ritardi_mattina = [3, 0, 12, 5]
ritardi_sera = []
print(media_ritardi(ritardi_mattina))  # → 5.0
print(media_ritardi(ritardi_sera))  # → ZeroDivisionError: division by zero

E questo è quello che stampa la riga 9:

Traceback (most recent call last):
  File "/home/lucia/corso/tabellone.py", line 9, in <module>
    print(media_ritardi(ritardi_sera))
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/lucia/corso/tabellone.py", line 3, in media_ritardi
    return totale / len(ritardi)
           ~~~~~~~^~~~~~~~~~~~~~
ZeroDivisionError: division by zero
  1. L'ultima riga è il nome dell'errore (ZeroDivisionError) e il messaggio (division by zero). Il nome ti dice che tipo di guaio è: cercalo più sotto in questa pagina.
  2. Subito sopra c'è il punto esatto: il file, la riga 3, la funzione media_ritardi, la riga di codice e i segni ~~~^~~~ sotto il pezzo che ha sbagliato.
  3. Ancora sopra c'è chi ha chiamato quella funzione: la riga 9, in <module>, cioè il programma principale.

La riga che ha sbagliato non è sempre quella da correggere: qui la divisione è giusta, il guaio è la lista vuota che arriva dalla riga 9. Se nel traceback ci sono percorsi che non sono tuoi (con dentro lib/python3.12), sono codice di Python o di una libreria: risali fino al primo File che è un tuo file.

try ed except

Prova un pezzo di codice; se arriva **quell'**errore, invece di fermarti fai un'altra cosa.

Python
testo = "dodici"
try:
    minuti = int(testo)
except ValueError:
    print("Non è un numero:", testo)
    minuti = 0
# → Non è un numero: dodici

minuti  # → 0

Se nel try va tutto bene, l'except viene saltato. L'uso più comune: chiedere di nuovo finché la risposta non è buona.

Python
while True:
    try:
        minuti = int(input("Minuti di ritardo: "))
        break
    except ValueError:
        print("Scrivi un numero, per esempio 5.")
# → Minuti di ritardo: dodici
# → Scrivi un numero, per esempio 5.
# → Minuti di ritardo: 12

minuti  # → 12

Nel try metti solo le righe che possono sbagliare, non mezzo programma. E prima di scriverlo chiediti se l'errore va gestito o corretto: un errore di battitura si corregge, non si nasconde. Ne parla Correggere o gestire.

except con il nome giusto

Dopo except scrivi quale errore ti aspetti. Se possono arrivarne due, li metti tra parentesi.

Python
ritardi = {"T-07": "3", "T-12": "boh"}


def minuti_di(treno):
    try:
        return int(ritardi[treno])
    except (KeyError, ValueError):
        return 0


minuti_di("T-07")  # → 3
minuti_di("T-12")  # → 0
minuti_di("T-99")  # → 0
Python
ritardi = {"T-07": 3, "T-12": 0}

try:
    minuti = ritardi["T-07"] + ritado_extra
except:
    minuti = 0

minuti  # → 0

Sembra tutto a posto: 0 minuti. Invece c'è un errore di battitura (ritado_extra), e l'except: nudo l'ha nascosto. Con il nome giusto viene fuori subito:

Python
ritardi = {"T-07": 3, "T-12": 0}

try:
    minuti = ritardi["T-07"] + ritado_extra
except KeyError:
    minuti = 0
# → NameError: name 'ritado_extra' is not defined

as e

Con as e dai un nome all'errore che hai preso. Stampato, e dà il messaggio; type(e).__name__ dà il nome dell'errore.

Python
try:
    int("dodici")
except ValueError as e:
    print("Errore:", e)
# → Errore: invalid literal for int() with base 10: 'dodici'

try:
    open("orari.txt", encoding="utf-8")
except FileNotFoundError as e:
    print(type(e).__name__, "-", e)
# → FileNotFoundError - [Errno 2] No such file or directory: 'orari.txt'

Serve quando vuoi mostrare o salvare il messaggio vero, invece di inventarne uno.

else e finally

else parte solo se nel try non c'è stato nessun errore. finally parte sempre, errore o no.

Python
def leggi_ritardo(testo):
    try:
        minuti = int(testo)
    except ValueError:
        print("non è un numero")
    else:
        print("ritardo di", minuti, "minuti")
    finally:
        print("controllo finito")


leggi_ritardo("5")
# → ritardo di 5 minuti
# → controllo finito
leggi_ritardo("cinque")
# → non è un numero
# → controllo finito

Nell'else va quello che deve succedere solo se è andato tutto bene; così il try resta corto. finally si usa per chiudere o salvare qualcosa in ogni caso. Con i file di solito non serve: with li chiude da solo.

raise

Solleva un errore tu, quando un valore non ha senso. Meglio fermarsi subito con un messaggio chiaro che andare avanti con un dato sbagliato.

Python
def imposta_ritardo(minuti):
    if minuti < 0:
        raise ValueError(f"ritardo negativo: {minuti}")
    return minuti


imposta_ritardo(4)  # → 4
imposta_ritardo(-2)  # → ValueError: ritardo negativo: -2

Scegli l'errore che descrive il problema: ValueError per un valore sbagliato, TypeError per un tipo sbagliato. Chi chiama la funzione può prenderlo con try ed except, come tutti gli altri.

NameError

Python non conosce quel nome. Di solito c'è un errore di battitura, oppure usi una variabile prima di crearla, oppure mancano le virgolette intorno a una stringa.

Python
fermata = "Largo Lista"
print(fermta)  # → NameError: name 'fermta' is not defined
print(Lucia)  # → NameError: name 'Lucia' is not defined
print("Lucia")  # → Lucia

TypeError

Un'operazione con un tipo che non va bene: sommi un numero a una stringa, chiedi la lunghezza di un numero, chiami una funzione con il numero sbagliato di argomenti.

Python
"Ritardo: " + 5  # → TypeError: can only concatenate str (not "int") to str
"Ritardo: " + str(5)  # → 'Ritardo: 5'
len(5)  # → TypeError: object of type 'int' has no len()
None + 1  # → TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'


def prezzo_corsa(zone):
    return 1.5 * zone


prezzo_corsa()  # → TypeError: prezzo_corsa() missing 1 required positional argument: 'zone'
prezzo_corsa(2, 3)  # → TypeError: prezzo_corsa() takes 1 positional argument but 2 were given

Leggi il messaggio: dice quali tipi si sono incontrati ('NoneType' and 'int') o quanti argomenti mancano. Un None dove ti aspettavi un numero viene quasi sempre da una funzione senza return.

ValueError

Il tipo è giusto, ma il valore no: una stringa che non si trasforma in numero, un elemento che nella lista non c'è, più pezzi del previsto.

Python
int("5 minuti")  # → ValueError: invalid literal for int() with base 10: '5 minuti'

fermate = ["Porta Codice", "Largo Lista"]
fermate.index("Piazza Query")  # → ValueError: 'Piazza Query' is not in list

fermata, ora = "Porta Codice 06:10".split()  # → ValueError: too many values to unpack (expected 2)

Nell'ultimo, split() divide anche lo spazio tra «Porta» e «Codice»: i pezzi sono tre, le etichette due.

KeyError

Nel dizionario non c'è quella chiave. Il messaggio è la chiave stessa, tra apici.

Python
ore = {"Lucia": 31, "Sergio": 38}
ore["Marta"]  # → KeyError: 'Marta'
ore["lucia"]  # → KeyError: 'lucia'
"Marta" in ore  # → False
ore.get("Marta", 0)  # → 0

Le maiuscole contano: 'lucia' non è 'Lucia'. Se la chiave può mancare, controlla prima con in oppure usa get. Più esempi nella pagina Dizionari.

IndexError

Chiedi una posizione che nella lista (o nella stringa) non c'è. Si conta da 0: tre elementi hanno gli indici 0, 1 e 2.

Python
fermate = ["Porta Codice", "Via Variabile", "Largo Lista"]
fermate[3]  # → IndexError: list index out of range
fermate[len(fermate) - 1]  # → 'Largo Lista'
fermate[-1]  # → 'Largo Lista'
[][0]  # → IndexError: list index out of range
"Ivo"[5]  # → IndexError: string index out of range

Una lista vuota non ha nemmeno l'elemento 0: se può essere vuota, controlla prima con if fermate:.

AttributeError

Quel valore non ha l'attributo o il metodo che chiedi. Spesso è il metodo di un altro tipo, o un None arrivato al posto di un valore.

Python
fermate = ["Porta Codice", "Largo Lista"]
fermate.add("Ponte Ciclo")  # → AttributeError: 'list' object has no attribute 'add'
fermate.append("Ponte Ciclo")


def annuncio(fermata):
    print("Prossima fermata:", fermata)


testo = annuncio("Ponte Ciclo")
# → Prossima fermata: Ponte Ciclo
testo.upper()  # → AttributeError: 'NoneType' object has no attribute 'upper'

Le liste hanno append, gli insiemi add. Quando nel messaggio c'è 'NoneType', hai un None dove ti aspettavi altro: qui annuncio stampa ma non ha return, e consegna None.

ZeroDivisionError

Una divisione per zero. Quasi sempre è una media fatta su una lista vuota.

Python
20 / 0  # → ZeroDivisionError: division by zero

ritardi = []
sum(ritardi) / len(ritardi)  # → ZeroDivisionError: division by zero

if ritardi:
    media = sum(ritardi) / len(ritardi)
else:
    media = 0

media  # → 0

FileNotFoundError

Il file non c'è dove Python lo cerca: nella cartella da cui hai lanciato il programma, che non è per forza quella dove sta il file .py.

Python
open("orari.txt", encoding="utf-8")  # → FileNotFoundError: [Errno 2] No such file or directory: 'orari.txt'

try:
    with open("orari.txt", encoding="utf-8") as f:
        righe = f.readlines()
except FileNotFoundError:
    righe = []

righe  # → []

Controlla nel terminale con pwd (dove sei) e ls (cosa c'è). Per partire sempre dalla cartella del programma c'è Path(__file__).parent, nella voce pathlib e Path.

ModuleNotFoundError

Python non trova il modulo che importi. O il nome è scritto male, o è una libreria da installare con pip che nel Python acceso non c'è.

Python
import ramdom  # → ModuleNotFoundError: No module named 'ramdom'
import random

Se il modulo che manca è una libreria come pytest, fastapi o pydantic, quasi sempre il venv è spento, o è acceso quello di un altro progetto. La cura è nel Pronto soccorso, alla voce del venv.

SyntaxError e IndentationError

Questi arrivano prima che il programma parta: Python legge tutto il file, trova una riga che non sa leggere e non esegue niente, nemmeno le righe giuste sopra. Il messaggio è corto: il file, la riga, un segno sotto il punto, cosa non va. IndentationError è un SyntaxError che riguarda i rientri.

I due punti mancanti in fondo a un if, un for, un def:

  File "/home/lucia/corso/annunci.py", line 2
    if ritardo > 5
                  ^
SyntaxError: expected ':'

Una parentesi aperta e mai chiusa:

  File "/home/lucia/corso/annunci.py", line 1
    fermate = ["Porta Codice", "Largo Lista"
              ^
SyntaxError: '[' was never closed

Un = (assegna) dove serviva == (confronta):

  File "/home/lucia/corso/annunci.py", line 2
    if ritardo = 7:
       ^^^^^^^^^^^
SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?

Le virgolette aperte e non chiuse:

  File "/home/lucia/corso/annunci.py", line 1
    print("Largo Lista)
          ^
SyntaxError: unterminated string literal (detected at line 1)

Il blocco dopo un if senza rientro:

  File "/home/lucia/corso/annunci.py", line 3
    print("in ritardo")
    ^^^^^
IndentationError: expected an indented block after 'if' statement on line 2

Un rientro che non c'entra, o che non torna allineato con le righe sopra:

  File "/home/lucia/corso/annunci.py", line 2
    print(ritardo)
IndentationError: unexpected indent
  File "/home/lucia/corso/annunci.py", line 3
    print("fine")
                 ^
IndentationError: unindent does not match any outer indentation level

Se la riga indicata ti sembra giusta, guarda quella sopra: spesso il guaio comincia lì. I rientri si fanno sempre con 4 spazi, mai mescolati con i tab.

assert

Controlla che una cosa sia vera. Se lo è, non succede niente; se non lo è, il programma si ferma con AssertionError e, se l'hai scritto, il tuo messaggio.

Python
ritardo = 5
assert ritardo >= 0
assert ritardo >= 0, "il ritardo non può essere negativo"

ritardo = -3
assert ritardo >= 0, "il ritardo non può essere negativo"  # → AssertionError: il ritardo non può essere negativo
assert ritardo >= 0  # → AssertionError

assert è il mattone dei test con pytest: assert prezzo_corsa(2) == 3.0. Per controllare i dati che arrivano dall'utente, invece, usa if e raise.

Un errore tutto tuo

Puoi creare un errore con il nome giusto per il tuo programma: una classe che parte da Exception. Poi lo sollevi con raise e lo prendi con except, come quelli di Python.

Python
class TrenoInRitardo(Exception):
    pass


def controlla(treno, minuti):
    if minuti > 10:
        raise TrenoInRitardo(f"{treno} ha {minuti} minuti di ritardo")
    return "in orario"


controlla("T-07", 3)  # → 'in orario'

try:
    controlla("T-12", 15)
except TrenoInRitardo as e:
    print("Avviso:", e)
# → Avviso: T-12 ha 15 minuti di ritardo

(Exception) vuol dire che TrenoInRitardo è un errore come gli altri; pass perché non serve aggiungere niente. Se nessuno lo prende, il programma si ferma e l'ultima riga del traceback è:

TrenoInRitardo: T-12 ha 15 minuti di ritardo

Le classi, e cosa vuol dire quel (Exception), sono nella pagina Le classi.