try, except, raise
Gestire l'errore che ti aspetti, e solo quello
- 10 minuti di lettura
In Correggere o gestire hai imparato a chiederti, davanti a un errore: l'ho scritto io sbagliato, o può succedere davvero? Se è un bug, si corregge. Se può succedere davvero (un testo scritto a mano, una riga rotta in un registro, un codice che non esiste), si gestisce.
Questo capitolo è il come. Tre parole: try (prova), except (se va male, fai questo), raise (alza tu l'errore). E una regola sopra tutte: gestisci l'errore che ti aspetti, e solo quello.
La forma
testo = "dodici"
try:
minuti = int(testo)
except ValueError:
minuti = 0
print(minuti) # → 0Python esegue il blocco try. Se una riga lì dentro alza un ValueError, salta al blocco except e poi va avanti. Se non succede niente, il blocco except si salta.
try:
minuti = int(testo)
│
┌─────────┴──────────┐
va bene alza ValueError
│ │
│ except ValueError:
│ minuti = 0
└─────────┬──────────┘
▼
si riparte da quiUn errore di un altro nome (TypeError, NameError…) non passa dall'except ValueError: il programma si ferma come sempre, con il suo traceback. È voluto, ed è la prima delle sette mosse.
Le sette mosse
1 · L'errore preciso
Dopo except scrivi il nome dell'errore che ti aspetti. Mai except: da solo, mai except Exception:: prendono tutto, anche i tuoi refusi.
def ritardo(testo):
try:
return int(testi) # refuso: la variabile si chiama testo
except:
return 0
print(ritardo("12")) # → 0Ha risposto 0 invece di 12, senza nessun errore. Il NameError c'era, ma l'except: l'ha mangiato. Con except ValueError il refuso avrebbe fermato il programma, e tu l'avresti trovato in dieci secondi.
2 · Il try piccolo
Nel try va una riga sola: quella che può fallire per il motivo che gestisci. Tutto il resto sta fuori. Se nel try ci sono due righe che possono alzare lo stesso errore, l'except non sa più quale delle due è stata, e potresti dire una bugia.
try:
minuti = int(testo) # solo la riga che può dare ValueError
except ValueError:
minuti = 0
da_controllare.remove(codice) # fuori: se fallisce, è un altro guaio3 · continue nel ciclo
Hai una lista di righe, una è rotta. Non vuoi fermarti, e non vuoi buttare le altre: la salti. Il try sta dentro il ciclo, e nell'except c'è continue (vai al giro dopo).
totale = 0
for testo in ["5", "boh", "7"]:
try:
minuti = int(testo)
except ValueError:
continue
totale = totale + minuti
print(totale) # → 12Con il try fuori dal ciclo, alla prima riga rotta il ciclo finirebbe lì: il 7 non lo leggeresti mai.
4 · Gli avvisi su stderr
Saltare una riga in silenzio è un altro modo di nascondere un guaio. Si salta, e si dice. Ma non sullo stesso canale del risultato: gli avvisi vanno su stderr, il risultato su stdout. Il canale lo hai incontrato in Moduli e file.
import sys
print(f"Riga {numero} scartata: {riga!r}", file=sys.stderr)Così il risultato resta pulito (si può mandare in un file con >), e gli avvisi si vedono lo stesso o si salvano a parte (con 2>).
5 · raise dentro, try fuori
Una funzione può decidere da sola che qualcosa non va e alzare lei l'errore, con raise. Il messaggio dice cosa è successo e con quale valore.
def posti_liberi(capienza, saliti):
if saliti > capienza:
raise ValueError(f"Saliti più della capienza: {saliti} su {capienza}")
return capienza - salitiChi scrive la funzione decide quando è un errore. Chi la usa decide cosa farne: la ferma (non mette nessun try), la salta (try e continue), la mostra all'utente. Lo stesso errore, tre scelte diverse, e la funzione non ne sa niente.
la funzione chi la chiama
se c'è qualcosa che non va: try:
raise ValueError("…") ───────▶ liberi = posti_liberi(120, 135)
except ValueError:
… decide lui cosa fare6 · Trasformare un errore
A volte l'errore che arriva è quello giusto, ma il messaggio non dice niente: KeyError: 'XX' non dice che XX doveva essere la sigla di una stazione. Lo prendi con except e ne alzi uno tuo, più chiaro.
try:
return SIGLE[sigla]
except KeyError:
raise ValueError(f"Sigla sconosciuta: {sigla!r}")Se ti serve anche il messaggio dell'errore originale, lo prendi con as errore e lo metti nel tuo:
except ValueError as errore:
raise ValueError(f"Ora non leggibile: {testo!r} ({errore})")Nel traceback compariranno due errori in fila, con la scritta During handling of the above exception, another exception occurred: si legge come hai imparato in Leggere un traceback. Vale l'ultimo, ma il primo dice da dove è partito.
7 · pytest.raises
Un test normale controlla che la funzione restituisca il valore giusto. Quando il valore giusto è «un errore», il test dice: mi aspetto questo errore, con questo messaggio.
import pytest
def test_troppi_saliti_e_un_errore():
with pytest.raises(ValueError, match="Saliti più della capienza: 135 su 120"):
posti_liberi(120, 135)Il test passa solo se dentro il with esce un ValueError e il suo messaggio contiene quel testo. Se la funzione restituisce un valore, o stampa e basta, o alza un altro errore, il test è rosso. match è un'espressione regolare: se il messaggio ha (, ), ., ?, + o *, scrivi match=re.escape("…") (con import re). Il resto dei test è in Scrivere un test.
Le sette mosse in una tabella
| Mossa | Si scrive | Quando |
|---|---|---|
| L'errore preciso | except ValueError: | Sempre. Mai except: da solo |
| Il try piccolo | una riga nel try | Il resto va fuori |
continue | try dentro il ciclo, continue nell'except | Una riga rotta non deve fermare le altre |
| stderr | print(…, file=sys.stderr) | Ogni volta che salti qualcosa |
raise dentro | raise ValueError(f"… {valore!r}") | La funzione sa che qualcosa non va |
try fuori | try e except intorno alla chiamata | Chi usa la funzione decide cosa farne |
| Trasformare | except KeyError: poi raise ValueError(…) | L'errore c'è, ma non spiega |
| Il test | with pytest.raises(ValueError, match="…"): | Il valore giusto è un errore |
Ricorda
exceptcon il nome dell'errore. Maiexcept:da solo.- Nel
tryuna riga sola: quella che può fallire. - Nel ciclo,
trydentro econtinue: la riga rotta si salta, le altre restano. - Saltare si dice, su stderr: il risultato su stdout resta pulito.
- Chi scrive la funzione fa
raise; chi la usa decide contry. - Un errore poco chiaro si trasforma:
except, poiraisecon il valore nel messaggio.