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:
- Prevedi: leggi il codice e scrivi su un foglio cosa stampa, o quale errore si ferma. Prima di aprire la risposta.
- In italiano: cosa succede, a parole.
- Passo per passo: cosa fa Python, riga per riga.
- 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.
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"diventa12."boh"alza unValueError, l'except ValueErrorlo prende, e la funzione risponde0.Nonenon è un testo:int(None)alza unTypeError. UnTypeErrornon è unValueError, quindi l'exceptnon 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.
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:
def ritardo(testo):
try:
return int(testi)
except:
return 0
print(ritardo("12"))Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
0Niente 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».
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 illeggibiliLa 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'è:
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:
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 listAdesso 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.
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.
12In italiano.
- Parto da zero.
- Per ogni riga: la spezzo in codice e testo.
- Provo a leggere i minuti. Se non sono un numero, passo alla riga dopo senza sommare niente.
- Altrimenti sommo.
Passo per passo.
| Giro | riga | testo | int(testo) | Cosa fa | totale dopo il giro |
|---|---|---|---|---|---|
| prima | — | — | — | — | 0 |
| 1 | "M12;5" | "5" | 5 | somma | 5 |
| 2 | "M14;cinque" | "cinque" | ValueError | except, continue: salta la somma | 5 |
| 3 | "M16;7" | "7" | 7 | somma | 12 |
Il disegno.
Ora lo stesso programma con il try fuori dal ciclo:
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.
5Al 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.
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.
python d_stderr.pyM12 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?
python d_stderr.py > risultato.txtPrevedi 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.
python d_stderr.py 2> avvisi.txt
cat avvisi.txtM12 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.
# posti.py
def posti_liberi(capienza, saliti):
if saliti > capienza:
raise ValueError(f"Saliti più della capienza: {saliti} su {capienza}")
return capienza - saliti# 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 120L'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.
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.
# 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: 1Stessa 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.
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:
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.
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.
pytest -vtest_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.
def posti_liberi(capienza, saliti):
if saliti > capienza:
print(f"Saliti più della capienza: {saliti} su {capienza}")
return capienza - salitiPrevedi 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.01sDID 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.