Vai al contenuto
code-to-code

Apro l'indice…

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

Errori e debugger4. try, except, raisep. 73

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

Python
testo = "dodici"
try:
    minuti = int(testo)
except ValueError:
    minuti = 0
print(minuti)       # → 0

Python 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 qui

Un 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.

Python
def ritardo(testo):
    try:
        return int(testi)      # refuso: la variabile si chiama testo
    except:
        return 0

print(ritardo("12"))           # → 0

Ha 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.

Python
try:
    minuti = int(testo)          # solo la riga che può dare ValueError
except ValueError:
    minuti = 0
da_controllare.remove(codice)    # fuori: se fallisce, è un altro guaio

3 · 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).

Python
totale = 0
for testo in ["5", "boh", "7"]:
    try:
        minuti = int(testo)
    except ValueError:
        continue
    totale = totale + minuti
print(totale)                    # → 12

Con 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.

Python
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.

Python
def posti_liberi(capienza, saliti):
    if saliti > capienza:
        raise ValueError(f"Saliti più della capienza: {saliti} su {capienza}")
    return capienza - saliti

Chi 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 fare

6 · 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.

Python
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:

Python
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.

Python
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

MossaSi scriveQuando
L'errore precisoexcept ValueError:Sempre. Mai except: da solo
Il try piccolouna riga nel tryIl resto va fuori
continuetry dentro il ciclo, continue nell'exceptUna riga rotta non deve fermare le altre
stderrprint(…, file=sys.stderr)Ogni volta che salti qualcosa
raise dentroraise ValueError(f"… {valore!r}")La funzione sa che qualcosa non va
try fuoritry e except intorno alla chiamataChi usa la funzione decide cosa farne
Trasformareexcept KeyError: poi raise ValueError(…)L'errore c'è, ma non spiega
Il testwith pytest.raises(ValueError, match="…"):Il valore giusto è un errore

Ricorda

  • except con il nome dell'errore. Mai except: da solo.
  • Nel try una riga sola: quella che può fallire.
  • Nel ciclo, try dentro e continue: 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 con try.
  • Un errore poco chiaro si trasforma: except, poi raise con il valore nel messaggio.