Vai al contenuto
code-to-code

Apro l'indice…

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

Errori e debugger4. try, except, raisep. 77

try, except, raise, esercizi spiegati

Sette esempi, una mossa alla volta

  • 25 minuti di lettura

Sette esempi, uno per ogni mossa della teoria. Lo stesso ritmo di sempre:

  1. Prevedi: leggi il codice e scrivi su un foglio cosa stampa, o quale errore si ferma. Prima di aprire la risposta.
  2. In italiano: cosa succede, a parole.
  3. Passo per passo: cosa fa Python, riga per riga.
  4. Cosa portiamo a casa: la cosa da ricordare.

Gli esempi sono i programmi del tablet di Lucia Ferri, la capotreno: scrive a mano ritardi, minuti e codici, e i programmi della centrale li leggono. Provali anche tu: salva il codice in un file (per esempio prova.py) e lancialo con python prova.py. Gli output che vedi qui sono usciti davvero da questi programmi.


A · Il ritardo scritto a mano

Lucia scrive i minuti di ritardo sul tablet. A volte scrive «boh». Il programma deve andare avanti con zero minuti.

Python
def ritardo(testo):
    try:
        return int(testo)
    except ValueError:
        return 0


print(ritardo("12"))
print(ritardo("boh"))
print(ritardo(None))
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
12
0
Traceback (most recent call last):
  File "/home/lucia/linea-menta/a_preciso.py", line 10, in <module>
    print(ritardo(None))
          ^^^^^^^^^^^^^
  File "/home/lucia/linea-menta/a_preciso.py", line 3, in ritardo
    return int(testo)
           ^^^^^^^^^^
TypeError: int() argument must be a string, a bytes-like object or a real number, not 'NoneType'
  • "12" diventa 12. "boh" alza un ValueError, l'except ValueError lo prende, e la funzione risponde 0.
  • None non è un testo: int(None) alza un TypeError. Un TypeError non è un ValueError, quindi l'except non lo prende e il programma si ferma, come deve.

In italiano. Provo a trasformare il testo in numero. Se il testo non è un numero, rispondo zero. Se non è nemmeno un testo, qualcosa nel programma è andato storto prima: fermati e dillo.

Il disegno.

inizio ritardo(testo) se int(testo) non riesce sì: se è un ValueError sì: restituisci 0 no: errore TypeError, non lo prende restituisci int(testo)ritardo(testo)int(testo) nonriesceè un ValueErrorTypeError, non lo prenderestituisci 0restituisci int(testo)nosìnosì
Chi prende l'errore

Perché None deve fermarsi. Un «boh» scritto a mano è una situazione prevista: succede davvero. Un None vuol dire che il tablet non ha mandato niente, o che il programma ha perso un valore per strada: è un bug, e un bug va visto.

Vediamo cosa succede con except: da solo, e con un refuso nel try:

Python
def ritardo(testo):
    try:
        return int(testi)
    except:
        return 0


print(ritardo("12"))
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
0

Niente errore, e il ritardo di «12» è sparito. Il programma ha cercato testi (che non esiste), ha avuto un NameError, e l'except: senza nome l'ha preso come se fosse un testo sbagliato.

Cosa portiamo a casa. except ValueError prende solo gli errori che ti aspetti. Con except: il refuso passa inosservato, e il risultato è sbagliato senza che nessuno lo sappia.


B · Il try piccolo

Lucia registra il ritardo di un treno e lo toglie dalla lista dei treni «da controllare».

Python
da_controllare = ["M12", "M14", "M16"]


def registra(codice, testo_minuti):
    try:
        minuti = int(testo_minuti)
        da_controllare.remove(codice)
    except ValueError:
        print("Minuti illeggibili")
        return
    print(f"{codice}: {minuti} minuti registrati")


registra("M12", "5")
registra("M14", "boh")
registra("M99", "7")
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
M12: 5 minuti registrati
Minuti illeggibili
Minuti illeggibili

La terza riga è una bugia. "7" è un numero perfetto: quello che non va è che M99 non è nella lista, e list.remove alza anche lui un ValueError. Nel try ci sono due righe che possono alzare ValueError, e l'except le tratta allo stesso modo.

Il disegno. La lista prima della terza chiamata, quando M99 non c'è:

da_controllare = ["M14", "M16"] codice = "M99"da_controllarecodicelist"M14"0"M16"1str"M99"
Prima di registra("M99", "7")

In italiano. Provo a leggere i minuti e a togliere il treno dalla lista. Se uno dei due va male, dico che i minuti sono illeggibili. Ma non è detto che siano loro.

La correzione. Nel try solo la riga che può fallire per il motivo che gestisco:

Python
def registra(codice, testo_minuti):
    try:
        minuti = int(testo_minuti)
    except ValueError:
        print("Minuti illeggibili")
        return
    da_controllare.remove(codice)
    print(f"{codice}: {minuti} minuti registrati")

Con le stesse tre chiamate:

M12: 5 minuti registrati
Minuti illeggibili
Traceback (most recent call last):
  File "/home/lucia/linea-menta/b_piccolo.py", line 16, in <module>
    registra("M99", "7")
  File "/home/lucia/linea-menta/b_piccolo.py", line 10, in registra
    da_controllare.remove(codice)
ValueError: list.remove(x): x not in list

Adesso M99 non si nasconde: il programma si ferma e il traceback indica la riga giusta, la 10. Un codice che non c'è nella lista è un altro guaio, e non è «minuti illeggibili».

Cosa portiamo a casa. Il try è una lente stretta: una riga, un errore. Quello che sta fuori continua a fermare il programma quando deve.


C · continue nel ciclo

La centrale ha tre righe «codice;minuti». Una è scritta male. Si sommano i minuti delle altre.

Python
righe = ["M12;5", "M14;cinque", "M16;7"]

totale = 0
for riga in righe:
    codice, testo = riga.split(";")
    try:
        minuti = int(testo)
    except ValueError:
        continue
    totale = totale + minuti

print(totale)
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
12

In italiano.

  1. Parto da zero.
  2. Per ogni riga: la spezzo in codice e testo.
  3. Provo a leggere i minuti. Se non sono un numero, passo alla riga dopo senza sommare niente.
  4. Altrimenti sommo.

Passo per passo.

Girorigatestoint(testo)Cosa fatotale dopo il giro
prima————0
1"M12;5""5"5somma5
2"M14;cinque""cinque"ValueErrorexcept, continue: salta la somma5
3"M16;7""7"7somma12

Il disegno.

inizio totale = 0 per ogni riga in righe passo codice, testo = riga.split(";") passo minuti = int(testo) se int(testo) è riuscito sì: totale = totale + minuti mostra print(totale)totale = 0per ogni riga in righecodice, testo =riga.split(";")minuti = int(testo)int(testo) èriuscitototale = totale + minutimostra print(totale)nosìfiniti
Il try dentro il ciclo

Ora lo stesso programma con il try fuori dal ciclo:

Python
totale = 0
try:
    for riga in righe:
        codice, testo = riga.split(";")
        totale = totale + int(testo)
except ValueError:
    pass

print(totale)
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
5

Al giro 2 l'errore esce dal ciclo intero, non solo dal giro: M16 non viene mai letto. Il risultato è sbagliato e non c'è nessun errore a dirtelo.

Cosa portiamo a casa. Il try va dentro il ciclo, così l'errore chiude un giro e non tutto il ciclo. continue dice: questo giro finisce qui.


D · Gli avvisi su stderr

Saltare una riga in silenzio è un guaio. Aggiungiamo l'avviso, con il numero della riga, e un risultato che si possa salvare.

Python
import sys

righe = ["M12;5", "M14;cinque", "M16;7", "M18"]

for numero, riga in enumerate(righe, 1):
    try:
        codice, testo = riga.split(";")
        minuti = int(testo)
    except ValueError:
        print(f"Riga {numero} scartata: {riga!r}", file=sys.stderr)
        continue
    print(codice, minuti)

Lancialo nel terminale, e poi con il risultato mandato in un file.

Terminale
python d_stderr.py
M12 5
Riga 2 scartata: 'M14;cinque'
M16 7
Riga 4 scartata: 'M18'

Adesso, prima di leggere oltre, prevedi: cosa vedi sullo schermo con questo comando?

Terminale
python d_stderr.py > risultato.txt
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Riga 2 scartata: 'M14;cinque'
Riga 4 scartata: 'M18'

Il > porta in risultato.txt solo stdout, cioè le due righe con print(codice, minuti). Gli avvisi viaggiano su stderr, e sullo schermo restano. In risultato.txt ci sono M12 5 e M16 7, puliti.

E con 2>, il contrario: gli avvisi nel file, il risultato sullo schermo.

Terminale
python d_stderr.py 2> avvisi.txt
cat avvisi.txt
M12 5
M16 7
Riga 2 scartata: 'M14;cinque'
Riga 4 scartata: 'M18'

Le prime due righe sono arrivate dallo schermo (il risultato), le ultime due dal file (cat avvisi.txt).

In italiano. Per ogni riga: provo a spezzarla e a leggere i minuti. Se non va, scrivo un avviso sul canale degli avvisi, e passo alla prossima. Se va, scrivo il risultato sul canale normale.

La riga 4, M18, non ha il punto e virgola: split dà un solo pezzo, e codice, testo = … alza un ValueError (non ci sono due valori da mettere in due nomi). Sta nel try perché è una riga che può fallire per lo stesso motivo del int: i dati sono scritti male.

Cosa portiamo a casa. Il risultato su stdout, gli avvisi su stderr. Così chi lancia il programma può tenere il risultato, e leggere gli avvisi a parte quando gli serve. Il canale è lo stesso di Moduli e file.


E · raise dentro, try fuori

Il capotreno segna quanti sono saliti. Se sono più dei posti, qualcosa non torna: il contapersone ha sbagliato, o il capotreno ha digitato male.

Python
# posti.py
def posti_liberi(capienza, saliti):
    if saliti > capienza:
        raise ValueError(f"Saliti più della capienza: {saliti} su {capienza}")
    return capienza - saliti
Python
# e_dentro.py
from posti import posti_liberi

print(posti_liberi(120, 80))
print(posti_liberi(120, 135))
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
40
Traceback (most recent call last):
  File "/home/lucia/linea-menta/e_dentro.py", line 4, in <module>
    print(posti_liberi(120, 135))
          ^^^^^^^^^^^^^^^^^^^^^^
  File "/home/lucia/linea-menta/posti.py", line 3, in posti_liberi
    raise ValueError(f"Saliti più della capienza: {saliti} su {capienza}")
ValueError: Saliti più della capienza: 135 su 120

L'ultima riga è il messaggio che abbiamo scritto noi, con i due numeri dentro. Il blocco in basso (posti.py, riga 3) è la riga con il raise: è lì che la funzione ha deciso che non andava.

In italiano. Se i saliti sono più della capienza, alzo io un ValueError con i due numeri. Altrimenti restituisco i posti liberi.

Il disegno.

inizio posti_liberi(capienza, saliti) se saliti > capienza sì: errore ValueError con i due numeri restituisci capienza - salitiposti_liberi(capienza,saliti)saliti > capienzaValueError con i due numerirestituisci capienza -salitinosì
La funzione che alza l'errore

Ora vediamo chi usa la funzione. Il tablet vuole mostrare il messaggio a Lucia. La centrale, che legge tre corse, vuole contare le anomalie e andare avanti.

Python
# e_fuori.py
from posti import posti_liberi

try:
    print(posti_liberi(120, 135))
except ValueError as errore:
    print("Tablet:", errore)

corse = [("M12", 120, 80), ("M14", 120, 135), ("M16", 90, 40)]
anomalie = 0
for codice, capienza, saliti in corse:
    try:
        liberi = posti_liberi(capienza, saliti)
    except ValueError:
        anomalie = anomalie + 1
        continue
    print(codice, liberi)
print("Anomalie:", anomalie)
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Tablet: Saliti più della capienza: 135 su 120
M12 40
M16 50
Anomalie: 1

Stessa funzione, due modi di usarla: il tablet stampa il messaggio, la centrale conta e salta.

Cosa portiamo a casa. La funzione decide quando è un errore (raise), e dice quale valore ha causato il guaio. Chi la chiama decide cosa farne (try fuori). Se la funzione stampasse l'errore e basta, il tablet e la centrale non potrebbero scegliere.


F · Trasformare un errore

Le stazioni si scrivono con una sigla: PC, LL. Se Lucia scrive una sigla che non c'è, il dizionario dà un KeyError, ma KeyError: 'XX' non dice cosa non va.

Python
SIGLE = {"PC": "Porta Codice", "LL": "Largo Lista"}


def stazione(sigla):
    try:
        return SIGLE[sigla]
    except KeyError:
        raise ValueError(f"Sigla sconosciuta: {sigla!r}")


print(stazione("LL"))
print(stazione("XX"))
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Largo Lista
Traceback (most recent call last):
  File "/home/lucia/linea-menta/f_trasforma.py", line 6, in stazione
    return SIGLE[sigla]
           ~~~~~^^^^^^^
KeyError: 'XX'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "/home/lucia/linea-menta/f_trasforma.py", line 12, in <module>
    print(stazione("XX"))
          ^^^^^^^^^^^^^^
  File "/home/lucia/linea-menta/f_trasforma.py", line 8, in stazione
    raise ValueError(f"Sigla sconosciuta: {sigla!r}")
ValueError: Sigla sconosciuta: 'XX'

Due traceback in fila, come hai visto in Leggere un traceback. Vale l'ultimo: ValueError: Sigla sconosciuta: 'XX', che dice davvero cosa non va. Il primo (KeyError) resta come storia di come ci siamo arrivati.

In italiano. Cerco la sigla nel dizionario. Se non c'è, dico con parole mie che la sigla è sconosciuta, e quale.

Quando l'errore originale ha un messaggio che può servire, lo prendi con as errore:

Python
def ora_in_minuti(testo):
    try:
        ore, minuti = testo.split(":")
        return int(ore) * 60 + int(minuti)
    except ValueError as errore:
        raise ValueError(f"Ora non leggibile: {testo!r} ({errore})")


for testo in ["23:14", "23.14", "23:2x"]:
    try:
        print(ora_in_minuti(testo))
    except ValueError as errore:
        print(errore)
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
1394
Ora non leggibile: '23.14' (not enough values to unpack (expected 2, got 1))
Ora non leggibile: '23:2x' (invalid literal for int() with base 10: '2x')

Il messaggio nuovo comincia con cosa, il testo che è arrivato, e poi tra parentesi il perché di Python. Quel messaggio in inglese da solo non diceva quale ora aveva sbagliato.

Cosa portiamo a casa. except per prendere, raise per alzare un errore tuo, con il valore dentro il messaggio. as errore se vuoi portarti dietro anche il messaggio vecchio.


G · pytest.raises

Come si prova che posti_liberi alza davvero l'errore? Con un test che si aspetta l'errore.

Python
import pytest

from posti import posti_liberi


def test_posti_liberi_normale():
    assert posti_liberi(120, 80) == 40


def test_troppi_saliti_e_un_errore():
    with pytest.raises(ValueError, match="Saliti più della capienza: 135 su 120"):
        posti_liberi(120, 135)

Il primo test è come tutti gli altri. Il secondo dice: dentro il with mi aspetto un ValueError, e il suo messaggio deve contenere questo testo.

Terminale
pytest -v
test_posti.py::test_posti_liberi_normale PASSED                                              [ 50%]
test_posti.py::test_troppi_saliti_e_un_errore PASSED                                         [100%]

======================================== 2 passed in 0.00s =========================================

Adesso prevedi: la funzione, invece di fare raise, stampa il messaggio e va avanti.

Python
def posti_liberi(capienza, saliti):
    if saliti > capienza:
        print(f"Saliti più della capienza: {saliti} su {capienza}")
    return capienza - saliti
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
.F                                                                                           [100%]
============================================= FAILURES =============================================
__________________________________ test_troppi_saliti_e_un_errore __________________________________

    def test_troppi_saliti_e_un_errore():
>       with pytest.raises(ValueError, match="Saliti più della capienza: 135 su 120"):
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E       Failed: DID NOT RAISE ValueError

test_posti.py:11: Failed
--------------------------------------- Captured stdout call ---------------------------------------
Saliti più della capienza: 135 su 120
===================================== short test summary info ======================================
FAILED test_posti.py::test_troppi_saliti_e_un_errore - Failed: DID NOT RAISE ValueError
1 failed, 1 passed in 0.01s

DID NOT RAISE ValueError: la funzione ha stampato il messaggio (lo vedi sotto, in «Captured stdout»), ma non ha alzato niente. Per il test, e per chi chiama la funzione, un print non è un errore.

E se la funzione alza l'errore ma con un messaggio senza i numeri (raise ValueError("Saliti più della capienza"))?

E       AssertionError: Regex pattern did not match.
E         Expected regex: 'Saliti più della capienza: 135 su 120'
E         Actual message: 'Saliti più della capienza'

Tre righe da leggere: cosa il test cercava (Expected), cosa ha trovato (Actual), e il tipo di errore (AssertionError, perché è il test che si lamenta, non la funzione).

Cosa portiamo a casa. pytest.raises è un test per l'errore: passa solo se l'errore c'è, del tipo giusto e con il messaggio giusto. Senza raise, DID NOT RAISE.


Pronto? Le stesse sette mosse ti aspettano nella palestra: sette funzioni da completare, con i test.