Correggere o gestire
Chi ha scritto il valore che ha rotto la riga?
- 10 minuti di lettura
Sai leggere un traceback e sai come si chiamano gli errori (gli errori per nome). Resta una domanda, e viene prima di ogni altra: cosa faccio, adesso?
Python ti dice che cosa si è rotto e dove. Non ti dice se la colpa è del tuo codice o di quello che il codice ha ricevuto. Questo lo decidi tu, ed è la decisione più importante di tutto il libro.
Le strade sono due:
- correggere: l'errore è un tuo sbaglio. Cambi il codice, e l'errore sparisce per sempre;
- gestire: l'errore può succedere davvero, anche se il codice è perfetto. Scrivi il codice che decide cosa fare quando succede.
Il disegno
il programma si ferma con un errore
│
▼
chi ha prodotto il valore che ha rotto la riga?
│ │
▼ ▼
io, scrivendo il codice qualcuno o qualcosa di fuori:
(un nome, una chiave, una persona che digita,
un metodo, un conto) un file, un registro, la rete
│ │
▼ ▼
È UN BUG È UNA SITUAZIONE PREVISTA
si CORREGGE il codice si GESTISCE, con try/except
niente try, mai e si decide cosa direLa domanda non è «che errore è?». La domanda è «da dove viene il valore sbagliato?».
Due colonne
| È un bug: correggi | È una situazione prevista: gestisci |
|---|---|
| Un nome scritto male nel codice | Quello che scrive una persona sullo schermo |
| Una chiave sbagliata, scritta da te, in un dizionario che hai scritto tu | Il codice di un treno che non esiste |
| Un metodo che quel tipo di valore non ha | Un file che a volte non c'è |
| Un contatore che non hai mai aumentato | Una riga sporca in un registro che arriva da fuori |
A sinistra il valore sbagliato l'hai scritto tu: se lo riscrivi giusto, non succede più. A destra il valore sbagliato lo scrive qualcun altro, e non puoi riscriverlo: puoi solo farti trovare pronto.
Lo stesso nome, due giudizi
Il nome dell'errore non decide. Guarda due programmi che finiscono con lo stesso KeyError.
Il primo. Il turno di Lucia Ferri è un dizionario che hai scritto tu, e tu hai sbagliato a scrivere la chiave:
turno = {"corse": 12, "ritardi": 3}
print("Corse:", turno["corse"])
print("Ritardi:", turno["ritardo"])python riepilogo.pyCorse: 12
Traceback (most recent call last):
File "/home/lucia/linea-menta/riepilogo.py", line 4, in <module>
print("Ritardi:", turno["ritardo"])
~~~~~^^^^^^^^^^^
KeyError: 'ritardo'"ritardo" l'hai scritto tu, nel codice. È un bug: si corregge in "ritardi".
Il secondo. Alla biglietteria di Via Variabile il viaggiatore scrive il codice del treno sullo schermo:
orari = {"M12": "07:10", "M14": "07:25"}
digitato = "M99" # quello che ha scritto il viaggiatore
print("Parte alle", orari[digitato])python schermo.pyTraceback (most recent call last):
File "/home/lucia/linea-menta/schermo.py", line 4, in <module>
print("Parte alle", orari[digitato])
~~~~~^^^^^^^^^^
KeyError: 'M99'Stesso errore, stesse quadre. Ma "M99" non l'hai scritto tu: l'ha scritto una persona, e domani ne scriverà un'altra. Non puoi correggere le persone. È una situazione prevista: si gestisce.
Come si gestisce: l'idea in quattro righe
Gestire vuol dire scrivere il try e decidere cosa succede nell'except:
try:
print("Parte alle", orari[digitato])
except KeyError:
print("Il treno", digitato, "non esiste. Controlla il codice.")Il programma non si ferma più: dice alla persona cosa non va. Come si scrive bene un try (l'errore preciso, il try piccolo, raise) lo trovi in try, except, raise. Qui conta una cosa sola: quando metterlo.
Il try che nasconde un bug
Ora il pericolo. Il try ferma l'errore, e a un principiante sembra una cura per qualsiasi errore: «si rompe? ci metto un try». Con un bug è la cura sbagliata.
Riprendi il turno con la chiave scritta male, e proteggilo con un try:
turno = {"corse": 12, "ritardi": 3}
try:
minuti_di_ritardo = turno["ritardo"]
except KeyError:
minuti_di_ritardo = 0
print("Corse:", turno["corse"])
print("Minuti di ritardo:", minuti_di_ritardo)python turno_nascosto.pyCorse: 12
Minuti di ritardo: 0Nessun errore, nessun traceback. E il numero è sbagliato: i minuti di ritardo erano 3. Il programma ha detto una cosa falsa con la faccia tranquilla.
Un bug con un traceback è un bug fortunato: ti dice dove guardare. Un try messo sopra un bug lo rende invisibile, e un bug invisibile lo trovi quando qualcuno ha già letto il numero sbagliato. Ancora peggio con except: da solo, o con except: pass, che non dice nemmeno quale errore sta zittendo.
Tre domande, in ordine
Davanti a un errore, prima di toccare il codice:
- Cosa dice? L'ultima riga del traceback, come al solito.
- Chi ha prodotto il valore che ha rotto la riga? Risali con il traceback: dalla riga rotta, guarda da dove arriva ogni nome. Il codice che hai scritto tu, o qualcosa di fuori?
- Potrebbe essere diverso, domani, senza che io tocchi il codice? Sì: situazione prevista. No: bug.
Se il valore arriva da una funzione che un'altra funzione chiama, la domanda 2 si fa con il traceback in mano: l'ultima riga dice dove si è rotto, ma il valore sbagliato è stato prodotto più in alto, nel blocco da cui è partita la chiamata. Lo vedi negli esercizi spiegati.
Cosa può venire da fuori
Quasi tutto quello che non hai scritto tu nel codice. Le fonti più comuni:
| Fonte | Esempio sulla Linea Menta |
|---|---|
| Una persona che digita | il codice del treno sullo schermo della biglietteria, la quantità di biglietti |
| Un file | il registro dei tornelli che arriva ogni sera, un elenco di turni |
| Un registro sporco | righe con campi tagliati, ore scritte male, spazi in più |
| La rete (dalle API in poi) | la risposta di un altro servizio |
Per le fonti di tipo file, Moduli e file ha già l'open e il suo with: un file può mancare (FileNotFoundError, «quel file non c'è»), e questo è previsto.
Cosa non è fuori: i dizionari, le liste e i nomi che scrivi tu in cima al programma; i nomi dei metodi; i conti dei tuoi cicli. Per quelli, l'errore è sempre un tuo sbaglio.
Ricorda
- Due strade: l'errore è un tuo sbaglio (correggi) o è una situazione che può succedere (gestisci).
- La domanda è «chi ha prodotto il valore?», non «come si chiama l'errore?». Lo stesso
KeyErrorpuò essere l'una o l'altra cosa. - Un bug non si gestisce: un
trysopra un bug lo rende invisibile, e il programma racconta cose false senza dare errore. - Una situazione prevista non si corregge: non puoi correggere quello che scrivono le persone o quello che c'è (o non c'è) in un file.
- Per gestire serve un
try, ma come si scrive lo vedi nel capitolo dopo.