try, except, raise, le soluzioni
Il ragionamento, il codice, le trappole
Per ogni esercizio, sempre lo stesso ordine: in italiano → il codice → le trappole. Per i più difficili, anche il passo per passo.
La tua soluzione è diversa ma i test sono verdi? Probabilmente va bene: spesso ci sono più strade giuste. Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: alcune passano quasi tutti i test e cadono su quello che conta.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
La palestra
1 · Il ritardo scritto a mano
In italiano. Provo a trasformare il testo in numero. Se non è un numero, zero. L'unico errore che mi aspetto è ValueError: None deve fermare il programma.
def ritardo_dal_tablet(testo: str) -> int:
try:
return int(testo)
except ValueError:
return 0Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
except: da solo | Prende tutto, anche il TypeError di int(None): la funzione risponde 0 e il bug è sparito | test_un_none_e_un_bug_e_ferma_il_programma |
except Exception: | Sembra più «per bene», ma TypeError è un Exception come gli altri: stesso guaio | test_un_none_e_un_bug_e_ferma_il_programma |
Gli altri quattro test sono verdi con tutte e due: solo il test del None vede la differenza. È per questo che nel capitolo c'è un None apposta.
2 · Il binario scritto a mano
In italiano.
- Provo a trasformare il testo in numero. Se non ci riesco, rispondo
None. - Fuori dal
try, cerco la posizione del binario nella lista. Se il binario non c'è,indexalza il suoValueErrore nessuno lo ferma.
def posizione_binario(binari: list[int], testo: str) -> int | None:
try:
numero = int(testo)
except ValueError:
return None
return binari.index(numero)Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
try: con return binari.index(int(testo)) e except ValueError: return None | Una sola riga nel try, ma due cose che possono alzare ValueError. Il binario 9 non esiste, e la funzione risponde None, come se fosse stato scritto male | test_un_binario_che_non_esiste_non_si_nasconde |
Gli altri quattro test passano: il binario che c'è, gli spazi, «tre», il campo vuoto. Solo il quinto sa che None per «tre» e None per «9» sono due cose diverse.
3 · Il totale della sera
In italiano.
- Parto da zero.
- Per ogni testo: provo a leggerlo come numero.
- Se non lo è, passo al testo dopo.
- Altrimenti lo sommo.
def somma_ritardi(testi: list[str]) -> int:
totale = 0
for testo in testi:
try:
minuti = int(testo)
except ValueError:
continue
totale = totale + minuti
return totaleLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Il try fuori dal ciclo, con except ValueError: pass | Alla prima riga rotta l'errore esce dal ciclo intero: le righe dopo non si leggono mai | test_una_riga_rotta_in_mezzo_non_ferma_il_ciclo, test_una_riga_rotta_all_inizio |
try dentro il ciclo, ma except ValueError: return totale | Si ferma alla prima riga rotta: return esce dalla funzione, continue solo dal giro | test_una_riga_rotta_in_mezzo_non_ferma_il_ciclo, test_una_riga_rotta_all_inizio |
Il test con la riga rotta in fondo passa con tutte e due: quando la riga rotta è l'ultima, non ci sono righe dopo da perdere. Un test fatto solo così non vedrebbe la trappola.
4 · Gli avvisi della centrale
In italiano.
- Parto da un dizionario vuoto.
- Per ogni riga, con il suo numero (da 1): provo a spezzarla in codice e testo, e a leggere i minuti.
- Se uno dei due fallisce, scrivo l'avviso su stderr e passo alla riga dopo.
- Altrimenti metto il treno nel dizionario.
def ritardi_per_treno(righe: list[str]) -> dict[str, int]:
ritardi = {}
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
ritardi[codice] = minuti
return ritardiIl disegno.
Passo per passo, con ["M12,5", "M14,cinque", "M16"].
numero | riga | Nel try | Cosa fa | ritardi dopo |
|---|---|---|---|---|
| 1 | "M12,5" | split dà M12 e 5; int dà 5 | niente errore: salva | {"M12": 5} |
| 2 | "M14,cinque" | split va bene; int("cinque") alza ValueError | stderr: Riga 2 scartata: 'M14,cinque', continue | {"M12": 5} |
| 3 | "M16" | split dà un solo pezzo: codice, testo = … alza ValueError | stderr: Riga 3 scartata: 'M16', continue | {"M12": 5} |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
print(f"Riga …") senza file=sys.stderr | L'avviso va su stdout, mescolato al resto: chi salva il risultato con > si ritrova gli avvisi dentro | test_gli_avvisi_vanno_su_stderr_con_numero_e_testo, test_niente_su_stdout, test_una_riga_senza_virgola_si_scarta_e_si_avvisa |
enumerate(righe) senza l'1 | I numeri partono da 0: la riga 2 diventa «Riga 1». Per le persone la prima riga è la numero 1 | test_gli_avvisi_vanno_su_stderr_con_numero_e_testo, test_una_riga_senza_virgola_si_scarta_e_si_avvisa |
Il try intorno a tutto il ciclo | Alla prima riga rotta il ciclo finisce: M16 non entra nel dizionario | test_il_risultato_salta_le_righe_rotte |
5 · Dentro e fuori dal tornello
In italiano. Se l'uscita è prima dell'entrata, alzo un ValueError con i due numeri. Altrimenti restituisco la differenza.
def durata_sosta(entrata: int, uscita: int) -> int:
if uscita < entrata:
raise ValueError(f"Uscita prima dell'entrata: entrata {entrata}, uscita {uscita}")
return uscita - entrataLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
print(f"Uscita prima dell'entrata: …") e poi return uscita - entrata | Il messaggio compare sullo schermo, ma la funzione restituisce -15, un numero finto. Chi la usa non sa che è un errore | test_uscita_prima_dell_entrata_e_un_errore_con_i_valori, test_il_messaggio_dice_i_valori_arrivati, test_non_restituisce_un_numero_finto |
return None | Nessun errore, nessun numero: un valore che sembra «niente», e chi lo usa dopo ci fa un'addizione e si becca un TypeError lontano da qui | gli stessi tre |
raise ValueError("Uscita prima dell'entrata") | L'errore c'è, ma senza i valori: chi legge il traceback non sa quali ore erano | test_uscita_prima_dell_entrata_e_un_errore_con_i_valori, test_il_messaggio_dice_i_valori_arrivati |
6 · Il conto del turno
In italiano.
- Totale e scartati partono da zero.
- Per ogni coppia (entrata, uscita): provo a chiamare
durata_passaggio. - Se alza
ValueError, aggiungo uno agli scartati e passo al prossimo. - Altrimenti sommo i minuti.
- Alla fine restituisco la coppia (totale, scartati).
def sosta_totale(passaggi: list[tuple[int, int]]) -> tuple[int, int]:
totale = 0
scartati = 0
for entrata, uscita in passaggi:
try:
minuti = durata_passaggio(entrata, uscita)
except ValueError:
scartati = scartati + 1
continue
totale = totale + minuti
return totale, scartatiPasso per passo, con [(10, 25), (50, 40), (60, 61)].
| Giro | entrata, uscita | durata_passaggio | totale | scartati |
|---|---|---|---|---|
| prima | — | — | 0 | 0 |
| 1 | 10, 25 | 15 | 15 | 0 |
| 2 | 50, 40 | alza ValueError | 15 | 1 |
| 3 | 60, 61 | 1 | 16 | 1 |
La funzione durata_passaggio non è cambiata: alza, e basta. È sosta_totale che decide.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Nessun try | Al primo passaggio sbagliato il ValueError esce da sosta_totale e ferma il conto | test_un_passaggio_sbagliato_si_scarta_e_si_conta, test_il_passaggio_sbagliato_all_inizio_non_ferma_il_conto |
Il try intorno a tutto il ciclo | Si conta uno scarto, ma il ciclo finisce lì: i passaggi dopo non si sommano | gli stessi due |
Cambiare durata_passaggio perché restituisca 0 invece di alzare | Adesso il passaggio sbagliato vale 0 minuti e nessuno sa che c'era: lo scarto non si può più contare. Hai tolto alla funzione il suo mestiere | test_un_passaggio_sbagliato_si_scarta_e_si_conta, test_il_passaggio_sbagliato_all_inizio_non_ferma_il_conto, test_durata_passaggio_continua_a_fermarsi_da_sola |
La terza è la più subdola: sembra una soluzione furba («gestisco l'errore dove nasce»). Ma chi nasconde l'errore alla fonte toglie a tutti gli altri la scelta.
7 · La riga del capotreno
In italiano.
- Spezzo la riga in campi.
- Prendo treno, sigla e ora: se manca un campo, l'indice sbagliato alza
IndexError, e io alzo unValueErrorcon la riga. - Cerco la sigla nelle stazioni: se non c'è,
KeyError, e io alzo unValueErrorcon la sigla. - Leggo l'ora: se è illeggibile,
ValueError, e io ne alzo uno nuovo con l'ora e il messaggio vecchio.
def leggi_fermata(riga: str) -> dict:
campi = riga.split(";")
try:
treno = campi[0]
sigla = campi[1]
ora = campi[2]
except IndexError:
raise ValueError(f"Riga incompleta: {riga!r}")
try:
stazione = STAZIONI[sigla]
except KeyError:
raise ValueError(f"Sigla sconosciuta: {sigla!r}")
try:
minuto = da_ora_a_minuti(ora)
except ValueError as errore:
raise ValueError(f"Ora non leggibile: {ora!r} ({errore})")
return {"treno": treno, "stazione": stazione, "minuto": minuto}Il disegno.
Passo per passo, con tre righe.
| Riga | Cosa succede | Risultato |
|---|---|---|
"M12;LL;23:14" | Tre campi. STAZIONI["LL"] dà Largo Lista. da_ora_a_minuti("23:14") dà 1394 | il dizionario |
"M12;LL" | campi[2] non esiste: IndexError, preso dal primo except | ValueError: Riga incompleta: 'M12;LL' |
"M12;LL;23.14" | I tre campi ci sono, la sigla anche. da_ora_a_minuti("23.14") alza un ValueError (non c'è il due punti): preso con as errore | ValueError: Ora non leggibile: '23.14' (not enough values to unpack (expected 2, got 1)) |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Nessun try per la riga e per la sigla | Escono IndexError e KeyError, con i loro messaggi poco chiari: il test si aspetta un ValueError | test_una_riga_incompleta_diventa_un_value_error_con_il_testo, test_una_riga_vuota_e_incompleta, test_una_sigla_inventata_diventa_un_value_error_con_la_sigla |
Un try solo per tutto, e raise ValueError("Riga non valida") | Il tipo è giusto, ma il messaggio non dice cosa non va né quale testo è arrivato | tutti e cinque i test dei guasti: i tre sopra, test_un_ora_illeggibile_diventa_un_value_error_con_il_testo e test_il_messaggio_dell_errore_originale_resta_visibile |
except ValueError: senza as errore, e il messaggio con solo l'ora | Il messaggio c'è, con il valore. Ma il motivo di Python (not enough values…, invalid literal…) si perde | test_il_messaggio_dell_errore_originale_resta_visibile |
Il registro sporco
Tutte le funzioni stanno in storia/tornelli.py.
Livello 1 · L'ora
In italiano. L'ora ha due pezzi di cifre divisi da due punti. Se non è così, è un errore. Se lo è, ma le ore superano 23 o i minuti 59, è un errore. Altrimenti, i minuti dalla mezzanotte.
def leggi_ora(testo: str) -> int:
pezzi = testo.split(":")
if len(pezzi) != 2 or not pezzi[0].isdigit() or not pezzi[1].isdigit():
raise ValueError(f"Ora non valida: {testo!r}")
ore_intere = int(pezzi[0])
minuti = int(pezzi[1])
if ore_intere > 23 or minuti > 59:
raise ValueError(f"Ora non valida: {testo!r}")
return ore_intere * 60 + minutiIl controllo con isdigit() viene prima dell'int(): così l'errore lo alzi tu, con il tuo messaggio.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
ore_intere, minuti = testo.split(":") e subito int(…) | Con 23.2x non c'è il due punti: esce l'errore di Python («not enough values to unpack»), non il tuo. Il messaggio non dice quale ora era | test_livello_1_un_ora_rotta_e_un_value_error_con_il_testo, test_livello_2_ora_illeggibile_con_la_riga, test_livello_3_gli_scarti_dicono_numero_riga_e_motivo |
| Solo il controllo della forma, senza i limiti | 24:00 e 23:60 passano per ore vere | test_livello_1_un_ora_rotta_e_un_value_error_con_il_testo |
La prima trappola fa cadere anche i test dei livelli 2 e 3, perché sono costruiti sopra l'ora.
Livello 2 · La riga
In italiano.
- Spezzo la riga e pulisco ogni campo dagli spazi.
- Provo a metterli in quattro nomi. Se non sono quattro, alzo un errore che dice quanti ne ho trovati.
- Leggo l'ora. Se
leggi_oraalza un errore, ne alzo uno più completo, che contiene il suo messaggio e la riga intera. - Controllo tornello, badge e verso: se uno non va,
raise.
def leggi_timbratura(riga: str) -> dict:
campi = [campo.strip() for campo in riga.split(";")]
try:
ora, tornello, badge, verso = campi
except ValueError:
raise ValueError(f"Campi trovati: {len(campi)} invece di 4: {riga!r}")
try:
minuto = leggi_ora(ora)
except ValueError as errore:
raise ValueError(f"{errore}, nella riga {riga!r}")
if tornello not in TORNELLI:
raise ValueError(f"Tornello sconosciuto: {tornello!r}")
if len(badge) != 5 or not badge.startswith("B-") or not badge[2:].isdigit():
raise ValueError(f"Badge non valido: {badge!r}")
if verso not in ("entrata", "uscita"):
raise ValueError(f"Verso non valido: {verso!r}")
return {"minuto": minuto, "tornello": tornello, "badge": badge, "verso": verso}Passo per passo, con "23.2x;Servizio;B-122;uscita".
| Riga di codice | Cosa succede |
|---|---|
campi = … | Quattro campi: "23.2x", "Servizio", "B-122", "uscita" |
ora, tornello, badge, verso = campi | Quattro nomi per quattro campi: va bene |
leggi_ora(ora) | Alza ValueError: Ora non valida: '23.2x' |
except ValueError as errore | Prende l'errore: errore è il suo messaggio |
raise ValueError(…) | Ne alza uno nuovo: Ora non valida: '23.2x', nella riga '23.2x;Servizio;B-122;uscita' |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
ora, tornello, badge, verso = campi senza try | Con 3 campi esce il ValueError di Python, in inglese. Il tipo è quello giusto, il messaggio no | test_livello_2_campi_che_mancano, test_livello_2_separatore_sbagliato, test_livello_2_troppi_campi |
minuto = leggi_ora(ora) senza try | L'errore dell'ora passa così com'è: dice l'ora, ma non quale riga. In un registro di 365 righe, non basta | test_livello_2_ora_illeggibile_con_la_riga |
Livello 3 · Il registro intero
In italiano.
- Due liste vuote: buone e scarti.
- Per ogni riga, con il suo numero (da 1): se è vuota, passo oltre.
- Provo a leggerla. Se
leggi_timbraturaalza unValueError, aggiungo uno scarto con numero, riga e messaggio, e passo oltre. - Se va, aggiungo il numero alla timbratura e la metto tra le buone.
def leggi_registro(righe: list[str]) -> tuple[list[dict], list[dict]]:
buone = []
scarti = []
for numero, riga in enumerate(righe, 1):
if riga.strip() == "":
continue
try:
timbratura = leggi_timbratura(riga)
except ValueError as errore:
scarti.append({"numero": numero, "riga": riga, "motivo": str(errore)})
continue
timbratura["numero"] = numero
buone.append(timbratura)
return buone, scartiPasso per passo, con ["23:05;Nord;B-201;entrata", "", "23:07;Est;B-203;entrata"].
numero | riga | Cosa fa | buone | scarti |
|---|---|---|---|---|
| 1 | "23:05;Nord;B-201;entrata" | leggi_timbratura va bene: la salva con numero 1 | 1 | 0 |
| 2 | "" | vuota: continue, non è uno scarto | 1 | 0 |
| 3 | "23:07;Est;B-203;entrata" | Tornello sconosciuto: 'Est': scarto numero 3 | 1 | 1 |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Il try intorno a tutto il ciclo | Alla prima riga rotta la lettura finisce: di tutto il registro ne leggi una parte | test_livello_3_le_buone_hanno_il_numero_di_riga e altri sei, tra i livelli 3, 4, 5 e 6, perché tutti usano leggi_registro |
except Exception as errore (con anche il controllo della riga vuota dentro il try) | Un None nel registro è un bug, ma l'except lo prende per una riga rotta e lo mette tra gli scarti: nessuno lo vede | test_livello_3_un_none_e_un_bug_e_non_si_nasconde |
| Niente controllo sulla riga vuota | Le righe vuote finiscono tra gli scarti con un messaggio di campi, ma non sono guasti | test_livello_3_gli_scarti_dicono_numero_riga_e_motivo, test_livello_3_una_riga_vuota_non_e_uno_scarto, test_livello_4_una_riga_su_stderr_per_ogni_scarto, test_livello_5_gli_scarti_per_tornello |
Livello 4 · Gli avvisi
In italiano. Per ogni scarto, una riga su stderr: il numero e il motivo.
def avvisa_scarti(scarti: list[dict]) -> None:
for scarto in scarti:
print(f"Riga {scarto['numero']} scartata: {scarto['motivo']}", file=sys.stderr)Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
print(…) senza file=sys.stderr | Gli avvisi finiscono su stdout, dentro il quaderno. Con 2> scarti.txt il file resterebbe vuoto | test_livello_4_niente_su_stdout, test_livello_4_una_riga_su_stderr_per_ogni_scarto |
Livello 5 · Dove sono le righe rotte
In italiano. Uno schema «contare»: per ogni scarto, trovo il suo tornello. Se non l'ho ancora visto, parte da uno; se l'ho visto, aggiungo uno.
def scarti_per_tornello(scarti: list[dict]) -> dict[str, int]:
conti = {}
for scarto in scarti:
tornello = tornello_di_una_riga(scarto["riga"])
conti[tornello] = conti.get(tornello, 0) + 1
return contiLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
if tornello == "sconosciuto": continue | Le righe di cui non si capisce il tornello spariscono dal conto: i numeri non tornano più con gli scarti | test_livello_5_gli_scarti_per_tornello |
conti[tornello] = 1 | Ogni tornello vale uno, comunque siano messi gli scarti | test_livello_5_gli_scarti_per_tornello |
Livello 6 · L'ultima timbratura pulita
In italiano.
- Prendo i numeri di riga degli scarti di quel tornello. Se non ce n'è nessuno,
None. - Il più basso è il primo scarto.
- Scorro le timbrature buone: tengo l'ultima che è di quel tornello e ha un numero di riga più basso del primo scarto.
def ultima_pulita_prima(buone: list[dict], scarti: list[dict], tornello: str) -> dict | None:
numeri = [s["numero"] for s in scarti if tornello_di_una_riga(s["riga"]) == tornello]
if not numeri:
return None
primo = min(numeri)
ultima = None
for timbratura in buone:
if timbratura["tornello"] == tornello and timbratura["numero"] < primo:
ultima = timbratura
return ultimaLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
| L'ultima timbratura buona del tornello, senza guardare gli scarti | È l'ultima di tutta la notte, non quella prima del guaio | test_livello_6_l_ultima_pulita_prima_del_primo_scarto, test_livello_6_nessuna_pulita_prima |
| La prima timbratura buona dopo l'ultimo scarto | È la prima persona passata dopo la raffica: un'altra persona, e un'altra domanda | test_livello_6_l_ultima_pulita_prima_del_primo_scarto, test_livello_6_nessuna_pulita_prima, test_livello_6_un_altro_tornello |
Il finale
Il quaderno, sul registro vero, con le funzioni giuste (python storia/tornelli.py 2> scarti.txt):
IL QUADERNO DEL COMMISSARIO MAPELLI
(None vuol dire: quel livello è ancora da scrivere)
Il registro di Largo Lista ha 365 righe.
1 · L'ora: 1401 | ValueError: Ora non valida: '23.2x'
2 · La riga: {'minuto': 1400, 'tornello': 'Servizio', 'badge': 'B-117', 'verso': 'entrata'}
una riga a cui manca un campo: ValueError: Campi trovati: 3 invece di 4: '23:27;Servizio;entrata'
3 · Il registro: 228 righe buone, 133 scartate.
4 · Gli avvisi (su stderr, uno per scarto): vedi il terminale, o scarti.txt
5 · Scarti per tornello: {'Nord': 16, 'sconosciuto': 28, 'Sud': 4, 'Servizio': 85}
6 · L'ultima timbratura pulita prima del primo scarto di ogni tornello:
Nord: B-112, uscita, alle 23:04, riga 26
Sud: B-107, entrata, alle 23:13, riga 62
Servizio: B-117, entrata, alle 23:20, riga 92
Gli scarti di Servizio vanno dalla riga 94 alla riga 274: tra le 23:21 e le 23:38.
Hai un nome? python storia/verifica.py "Nome Cognome"Le righe rotte non sono rumore. Servizio ne ha 85 su 133, e vanno tutte dalla riga 94 alla 274: i diciotto minuti, dalle 23:21 alle 23:38. Nord e Sud ne hanno qualcuna sparsa, qua e là, per tutta la notte: quelle sì sono rumore.
Prima della raffica, l'ultimo badge che il tornello di servizio ha letto bene è B-117, un'entrata alle 23:20. In personale.py, B-117 è Carlo Pirovano, elettricista della squadra di notte. Qualcuno è passato, poi ha mandato in tilt il tornello per coprire chi passava dopo di lui.
python storia/verifica.py "Carlo Pirovano"Le piste sbagliate, e perché:
| Il nome | Cosa hai guardato | Perché non va |
|---|---|---|
| Ornella Rizzi | La prima timbratura pulita dopo la raffica | Quando passa lei il tornello è già tornato normale: chi l'ha mandato in tilt è passato prima |
| Franca Mariani, Paolo Mazza | L'ultima pulita prima del primo scarto di Nord o di Sud | Sono tornelli quasi puliti: poche righe rotte, sparse. Il guaio è a Servizio |
| Giulio Sanna | Chi ha dato l'allarme | Chi segnala lo sbalzo non è per forza chi lo ha provocato |