Vai al contenuto
code-to-code

Apro l'indice…

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

Errori e debugger4. try, except, raisep. 95

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.

errori-try-except-raise-soluzioni.zip24 KB

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.

Python
def ritardo_dal_tablet(testo: str) -> int:
    try:
        return int(testo)
    except ValueError:
        return 0

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
except: da soloPrende tutto, anche il TypeError di int(None): la funzione risponde 0 e il bug è sparitotest_un_none_e_un_bug_e_ferma_il_programma
except Exception:Sembra più «per bene», ma TypeError è un Exception come gli altri: stesso guaiotest_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.

  1. Provo a trasformare il testo in numero. Se non ci riesco, rispondo None.
  2. Fuori dal try, cerco la posizione del binario nella lista. Se il binario non c'è, index alza il suo ValueError e nessuno lo ferma.
Python
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 sbagliatoCosa succedeIl test rosso
try: con return binari.index(int(testo)) e except ValueError: return NoneUna 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 maletest_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.

  1. Parto da zero.
  2. Per ogni testo: provo a leggerlo come numero.
  3. Se non lo è, passo al testo dopo.
  4. Altrimenti lo sommo.
Python
def somma_ritardi(testi: list[str]) -> int:
    totale = 0
    for testo in testi:
        try:
            minuti = int(testo)
        except ValueError:
            continue
        totale = totale + minuti
    return totale

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Il try fuori dal ciclo, con except ValueError: passAlla prima riga rotta l'errore esce dal ciclo intero: le righe dopo non si leggono maitest_una_riga_rotta_in_mezzo_non_ferma_il_ciclo, test_una_riga_rotta_all_inizio
try dentro il ciclo, ma except ValueError: return totaleSi ferma alla prima riga rotta: return esce dalla funzione, continue solo dal girotest_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.

  1. Parto da un dizionario vuoto.
  2. Per ogni riga, con il suo numero (da 1): provo a spezzarla in codice e testo, e a leggere i minuti.
  3. Se uno dei due fallisce, scrivo l'avviso su stderr e passo alla riga dopo.
  4. Altrimenti metto il treno nel dizionario.
Python
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 ritardi

Il disegno.

inizio ritardi = {} per ogni riga, con il suo numero passo codice, testo = riga.split(",") passo minuti = int(testo) se uno dei due alza ValueError sì: mostra avviso su stderr no: ritardi[codice] = minuti restituisci ritardiritardi = {}per ogni riga, con il suonumerocodice, testo =riga.split(",")minuti = int(testo)uno dei due alzaValueErrorritardi[codice] = minutimostra avviso su stderrrestituisci ritardinosìfiniti
Il giro delle righe

Passo per passo, con ["M12,5", "M14,cinque", "M16"].

numerorigaNel tryCosa faritardi dopo
1"M12,5"split dà M12 e 5; int dà 5niente errore: salva{"M12": 5}
2"M14,cinque"split va bene; int("cinque") alza ValueErrorstderr: Riga 2 scartata: 'M14,cinque', continue{"M12": 5}
3"M16"split dà un solo pezzo: codice, testo = … alza ValueErrorstderr: Riga 3 scartata: 'M16', continue{"M12": 5}

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
print(f"Riga …") senza file=sys.stderrL'avviso va su stdout, mescolato al resto: chi salva il risultato con > si ritrova gli avvisi dentrotest_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'1I numeri partono da 0: la riga 2 diventa «Riga 1». Per le persone la prima riga è la numero 1test_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 cicloAlla prima riga rotta il ciclo finisce: M16 non entra nel dizionariotest_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.

Python
def durata_sosta(entrata: int, uscita: int) -> int:
    if uscita < entrata:
        raise ValueError(f"Uscita prima dell'entrata: entrata {entrata}, uscita {uscita}")
    return uscita - entrata

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
print(f"Uscita prima dell'entrata: …") e poi return uscita - entrataIl messaggio compare sullo schermo, ma la funzione restituisce -15, un numero finto. Chi la usa non sa che è un erroretest_uscita_prima_dell_entrata_e_un_errore_con_i_valori, test_il_messaggio_dice_i_valori_arrivati, test_non_restituisce_un_numero_finto
return NoneNessun errore, nessun numero: un valore che sembra «niente», e chi lo usa dopo ci fa un'addizione e si becca un TypeError lontano da quigli stessi tre
raise ValueError("Uscita prima dell'entrata")L'errore c'è, ma senza i valori: chi legge il traceback non sa quali ore eranotest_uscita_prima_dell_entrata_e_un_errore_con_i_valori, test_il_messaggio_dice_i_valori_arrivati

6 · Il conto del turno

In italiano.

  1. Totale e scartati partono da zero.
  2. Per ogni coppia (entrata, uscita): provo a chiamare durata_passaggio.
  3. Se alza ValueError, aggiungo uno agli scartati e passo al prossimo.
  4. Altrimenti sommo i minuti.
  5. Alla fine restituisco la coppia (totale, scartati).
Python
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, scartati

Passo per passo, con [(10, 25), (50, 40), (60, 61)].

Giroentrata, uscitadurata_passaggiototalescartati
prima——00
110, 2515150
250, 40alza ValueError151
360, 611161

La funzione durata_passaggio non è cambiata: alza, e basta. È sosta_totale che decide.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Nessun tryAl primo passaggio sbagliato il ValueError esce da sosta_totale e ferma il contotest_un_passaggio_sbagliato_si_scarta_e_si_conta, test_il_passaggio_sbagliato_all_inizio_non_ferma_il_conto
Il try intorno a tutto il cicloSi conta uno scarto, ma il ciclo finisce lì: i passaggi dopo non si sommanogli stessi due
Cambiare durata_passaggio perché restituisca 0 invece di alzareAdesso 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 mestieretest_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.

  1. Spezzo la riga in campi.
  2. Prendo treno, sigla e ora: se manca un campo, l'indice sbagliato alza IndexError, e io alzo un ValueError con la riga.
  3. Cerco la sigla nelle stazioni: se non c'è, KeyError, e io alzo un ValueError con la sigla.
  4. Leggo l'ora: se è illeggibile, ValueError, e io ne alzo uno nuovo con l'ora e il messaggio vecchio.
Python
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.

inizio leggi_fermata(riga) passo campi = riga.split(";") se manca un campo sì: errore ValueError Riga incompleta se la sigla non è in STAZIONI sì: errore ValueError Sigla sconosciuta se l'ora non è leggibile sì: errore ValueError Ora non leggibile restituisci il dizionario della fermataleggi_fermata(riga)campi = riga.split(";")manca un campoValueError Riga incompletala sigla non è inSTAZIONIValueError Sigla sconosciutal'ora non èleggibileValueError Ora non leggibilerestituisci il dizionariodella fermatanosìnosìnosì
Tre controlli, un solo tipo di errore

Passo per passo, con tre righe.

RigaCosa succedeRisultato
"M12;LL;23:14"Tre campi. STAZIONI["LL"] dà Largo Lista. da_ora_a_minuti("23:14") dà 1394il dizionario
"M12;LL"campi[2] non esiste: IndexError, preso dal primo exceptValueError: 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 erroreValueError: Ora non leggibile: '23.14' (not enough values to unpack (expected 2, got 1))

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Nessun try per la riga e per la siglaEscono IndexError e KeyError, con i loro messaggi poco chiari: il test si aspetta un ValueErrortest_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 è arrivatotutti 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'oraIl messaggio c'è, con il valore. Ma il motivo di Python (not enough values…, invalid literal…) si perdetest_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.

Python
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 + minuti

Il controllo con isdigit() viene prima dell'int(): così l'errore lo alzi tu, con il tuo messaggio.

Le trappole.

Il codice sbagliatoCosa succedeIl 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 eratest_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 limiti24:00 e 23:60 passano per ore veretest_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.

  1. Spezzo la riga e pulisco ogni campo dagli spazi.
  2. Provo a metterli in quattro nomi. Se non sono quattro, alzo un errore che dice quanti ne ho trovati.
  3. Leggo l'ora. Se leggi_ora alza un errore, ne alzo uno più completo, che contiene il suo messaggio e la riga intera.
  4. Controllo tornello, badge e verso: se uno non va, raise.
Python
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 codiceCosa succede
campi = …Quattro campi: "23.2x", "Servizio", "B-122", "uscita"
ora, tornello, badge, verso = campiQuattro nomi per quattro campi: va bene
leggi_ora(ora)Alza ValueError: Ora non valida: '23.2x'
except ValueError as errorePrende 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 sbagliatoCosa succedeIl test rosso
ora, tornello, badge, verso = campi senza tryCon 3 campi esce il ValueError di Python, in inglese. Il tipo è quello giusto, il messaggio notest_livello_2_campi_che_mancano, test_livello_2_separatore_sbagliato, test_livello_2_troppi_campi
minuto = leggi_ora(ora) senza tryL'errore dell'ora passa così com'è: dice l'ora, ma non quale riga. In un registro di 365 righe, non bastatest_livello_2_ora_illeggibile_con_la_riga

Livello 3 · Il registro intero

In italiano.

  1. Due liste vuote: buone e scarti.
  2. Per ogni riga, con il suo numero (da 1): se è vuota, passo oltre.
  3. Provo a leggerla. Se leggi_timbratura alza un ValueError, aggiungo uno scarto con numero, riga e messaggio, e passo oltre.
  4. Se va, aggiungo il numero alla timbratura e la metto tra le buone.
Python
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, scarti

Passo per passo, con ["23:05;Nord;B-201;entrata", "", "23:07;Est;B-203;entrata"].

numerorigaCosa fabuonescarti
1"23:05;Nord;B-201;entrata"leggi_timbratura va bene: la salva con numero 110
2""vuota: continue, non è uno scarto10
3"23:07;Est;B-203;entrata"Tornello sconosciuto: 'Est': scarto numero 311

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Il try intorno a tutto il cicloAlla prima riga rotta la lettura finisce: di tutto il registro ne leggi una partetest_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 vedetest_livello_3_un_none_e_un_bug_e_non_si_nasconde
Niente controllo sulla riga vuotaLe righe vuote finiscono tra gli scarti con un messaggio di campi, ma non sono guastitest_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.

Python
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 sbagliatoCosa succedeIl test rosso
print(…) senza file=sys.stderrGli avvisi finiscono su stdout, dentro il quaderno. Con 2> scarti.txt il file resterebbe vuototest_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.

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

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
if tornello == "sconosciuto": continueLe righe di cui non si capisce il tornello spariscono dal conto: i numeri non tornano più con gli scartitest_livello_5_gli_scarti_per_tornello
conti[tornello] = 1Ogni tornello vale uno, comunque siano messi gli scartitest_livello_5_gli_scarti_per_tornello

Livello 6 · L'ultima timbratura pulita

In italiano.

  1. Prendo i numeri di riga degli scarti di quel tornello. Se non ce n'è nessuno, None.
  2. Il più basso è il primo scarto.
  3. Scorro le timbrature buone: tengo l'ultima che è di quel tornello e ha un numero di riga più basso del primo scarto.
Python
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 ultima

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
L'ultima timbratura buona del tornello, senza guardare gli scartiÈ l'ultima di tutta la notte, non quella prima del guaiotest_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 domandatest_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.

Terminale
python storia/verifica.py "Carlo Pirovano"

Le piste sbagliate, e perché:

Il nomeCosa hai guardatoPerché non va
Ornella RizziLa prima timbratura pulita dopo la rafficaQuando passa lei il tornello è già tornato normale: chi l'ha mandato in tilt è passato prima
Franca Mariani, Paolo MazzaL'ultima pulita prima del primo scarto di Nord o di SudSono tornelli quasi puliti: poche righe rotte, sparse. Il guaio è a Servizio
Giulio SannaChi ha dato l'allarmeChi segnala lo sbalzo non è per forza chi lo ha provocato