Vai al contenuto
code-to-code

Apro l'indice…

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

Errori e debugger7. I bug silenziosip. 177

I bug silenziosi, le soluzioni

Il bug, il commento, la correzione, le trappole

Per ogni esercizio, sempre lo stesso ordine: in italiano (qual è il bug e perché) → il codice (con il commento # BUG: e la correzione) → le trappole. Per i più difficili, anche il passo per passo, con i valori presi dal debugger.

La tua correzione è diversa ma i test sono verdi, compreso quello del commento? Probabilmente va bene: spesso ci sono più strade giuste. Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: alcune fanno passare il test rosso e ne lasciano un altro rosso.

Una cosa vale per tutti gli esercizi: la correzione senza il commento # BUG: non basta. Il test del commento è rosso anche con la funzione giusta. Succede, ed è proprio quello che il test vuole insegnarti.

Le soluzioni complete

La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.

errori-bug-silenziosi-soluzioni.zip19 KB

La palestra

1 · I ritardi registrati

In italiano. La condizione if ritardo: non chiede «il dato c'è?». Chiede «il valore è vero?». Per Python 0 è falso, e un treno puntuale (0 minuti di ritardo) sparisce dall'elenco insieme a quelli senza dato. Si chiede la cosa che interessa: il dato è None o no?

Python
def treni_registrati(ritardi: dict[str, int | None]) -> list[str]:
    registrati = []
    for codice, ritardo in ritardi.items():
        # BUG: if ritardo è falso anche per 0, e un treno puntuale (0 minuti) sparisce dall'elenco.
        # Serve chiedere se il dato c'è: is not None.
        if ritardo is not None:
            registrati.append(codice)
    return registrati

Passo per passo. Con {"M12": 0, "M14": 5, "M16": None} il debugger si ferma sulla riga dell'if tre volte. Quello che prevedi (la funzione dovrebbe tenere M12 e M14) contro quello che vedi con l'if ritardo: originale:

Girocodiceritardoregistrati primaPrevedoCon if ritardo:
1M120[]lo aggiungenon lo aggiunge
2M145[]lo aggiungelo aggiunge
3M16None['M14']non lo aggiungenon lo aggiunge

Il bug è al giro 1. Il test con None è verde per caso: if ritardo: scarta anche None, che è proprio quello che si vuole.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Togliere l'if e fare sempre registrati.append(codice)Lo zero ora passa, ma passa anche None: M16, che non ha dato, risulta registratotest_un_treno_senza_dato_non_e_registrato
if ritardo is not None: senza il commentoLa funzione è giusta: tutti i test del comportamento sono verditest_prima_della_correzione_il_commento

La regola: per sapere se un dato c'è si usa is not None, non il valore usato come condizione. Lo trovi in Le condizioni.


2 · Il badge sporco

In italiano. testo.strip() non cambia testo: le stringhe non si possono modificare, e strip() ne restituisce una nuova. Nel programma quella nuova viene calcolata e buttata via, e la return lavora ancora sulla vecchia, con gli spazi. La nuova va messa da qualche parte.

Python
def pulisci_badge(testo: str) -> str:
    # BUG: strip() non cambia la stringa, ne restituisce una nuova: la riga la butta via e testo resta con gli spazi.
    testo = testo.strip()
    return testo.upper()

Il debugger lo mostra bene: dopo la riga testo.strip(), premi F10 e guarda VARIABLES.

testo = '  b-07 '        ← prima della riga con strip()
testo = '  b-07 '        ← dopo: identico

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
return testo.replace(" ", "").upper()Toglie gli spazi dei due test principali. Ma una tabulazione o un a capo ("\tb-11\n") non sono spazi: restanotest_tabulazione_e_a_capo
testo = testo.strip() senza il commentoLa funzione è giustatest_prima_della_correzione_il_commento

strip() toglie tutti gli spazi bianchi ai due capi: spazi, tabulazioni, a capo. Per questo è la scelta giusta. Una soluzione scritta apposta per il caso del test (replace degli spazi) funziona finché i dati sono come quelli del test. Il concetto è in Le stringhe.


3 · Chi entra in officina

In italiano. La storia dice: in servizio e del reparto officina. Il codice dice: in servizio oppure del reparto officina. Con or basta una delle due condizioni: Sergio, che è in servizio ma fa il macchinista, entra. Nadia, che è dell'officina ma non è in servizio, entra. Servono tutte e due: and.

Python
def ammessi_in_officina(personale: list[dict]) -> list[str]:
    ammessi = []
    for persona in personale:
        # BUG: con or basta una delle due condizioni, e chi è in servizio entra anche se non è dell'officina.
        # Servono tutte e due: and.
        if persona["attivo"] and persona["reparto"] == "officina":
            ammessi.append(persona["nome"])
    return ammessi

Passo per passo. Con tre persone (Ivo, Sergio, Nadia) il debugger si ferma tre volte sull'if. Con or:

Giropersona["nome"]attivoreparto == "officina"PrevedoCon or
1IvoTrueTrueentraentra
2SergioTrueFalsenon entraentra
3NadiaFalseTruenon entraentra

Con or la lista finale è ['Ivo', 'Sergio', 'Nadia']: tutti. Con and, solo ['Ivo'].

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
if persona["attivo"] and persona["reparto"]:Ha l'and, ma al posto di confrontare il reparto lo usa come condizione: una stringa non vuota è «vera». Sergio, in servizio, entratest_in_servizio_ma_di_un_altro_reparto_non_entra, test_un_elenco_misto_in_ordine
if persona["attivo"] and persona["reparto"] == "officina": senza il commentoLa funzione è giustatest_prima_della_correzione_il_commento

La prima è una correzione «a metà»: cambia or in and ma lascia l'altra metà della frase mal scritta. Una condizione va letta ad alta voce, intera.


4 · I passeggeri del giorno

In italiano. La chiave è scritta male: "salti" al posto di "saliti". giro.get("salti", 0) non si ferma quando la chiave non c'è: risponde con il ripiego, 0. Così il refuso diventa un errore silenzioso: ogni giro aggiunge zero, e il totale resta 0. La correzione è doppia: la chiave giusta, e la lettura con le quadre, che si ferma se il dato manca.

Python
def passeggeri_del_giorno(giri: list[dict]) -> int:
    totale = 0
    for giro in giri:
        # BUG: la chiave è scritta male ("salti"): get non trova niente e dà il ripiego 0, quindi il refuso non fa errore.
        # Il dato deve esserci: le quadre e la chiave giusta.
        totale = totale + giro["saliti"]
    return totale

Passo per passo. Il debugger sulla riga del totale, con due giri:

Girogiro in VARIABLEStotale primaPrevedo che aggiungaCon get("salti", 0) aggiunge
1{'treno': 'M12', 'saliti': 120, 'scesi': 95}01200
2{'treno': 'M14', 'saliti': 80, 'scesi': 100}0800

Alla fine il programma stampa 0. In VARIABLES la chiave saliti c'è, con il numero giusto, e la riga non la guarda nemmeno.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
giro.get("saliti", 0)La chiave ora è giusta e il totale è corretto. Ma un giro senza il dato vale ancora zero passeggeri, senza dire niente: il prossimo refuso nei dati passa inosservatotest_un_giro_senza_il_dato_ferma_il_programma
giro["saliti"] senza il commentoLa funzione è giustatest_prima_della_correzione_il_commento

get con un ripiego è giusto quando la chiave può mancare e il ripiego ha senso. Qui il dato deve esserci: se manca, è un guaio da far vedere, non da nascondere con uno zero. Se ti serve ripassare le due letture: I dizionari.


5 · Il treno più in ritardo

In italiano. Il ciclo tiene aggiornato il massimo dei minuti, ma non il codice del treno che lo ha fatto. Alla fine la funzione restituisce codice: la variabile del for, che dopo l'ultimo giro vale quello dell'ultimo treno della lista. Il massimo è stato trovato; il treno è quello sbagliato (a meno che il massimo non sia proprio l'ultimo: ecco perché un test è verde anche con il bug).

La correzione: una variabile in più, piu_in_ritardo, che prende il codice nel giro in cui il massimo cambia. La return restituisce quella.

Python
def treno_piu_in_ritardo(ritardi: list[tuple[str, int]]) -> str:
    massimo = -1
    for codice, minuti in ritardi:
        if minuti > massimo:
            massimo = minuti
            # BUG: dopo il ciclo codice vale quello dell'ultimo giro, non quello del massimo.
            # Il codice del massimo va ricordato nel giro in cui il massimo cambia.
            piu_in_ritardo = codice
    return piu_in_ritardo

Il disegno.

inizio massimo = -1 per ogni codice, minuti in ritardi se minuti > massimo sì: massimo = minuti piu_in_ritardo = codice restituisci piu_in_ritardomassimo = -1per ogni codice, minuti inritardiminuti > massimomassimo = minutipiu_in_ritardo = codicerestituisci piu_in_ritardonosìfiniti
Il massimo e il suo treno

Passo per passo. Con [("M12", 4), ("M14", 11), ("T28", 2)], un breakpoint sulla riga dell'if, prima della riga:

Girocodiceminutimassimo primaminuti > massimo?massimo dopo
1M124-1sì4
2M14114sì11
3T28211no11

Il giro 2 è quello che conta: massimo diventa 11, e il treno è M14. Al giro 3 massimo resta 11, ma codice diventa T28. Con un breakpoint sulla return il debugger mostra:

VARIABLES
  massimo = 11
  codice = 'T28'
  minuti = 2

Il valore che prevedevi in codice era 'M14'. Eccolo, il punto in cui previsione e osservazione si separano.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
return "M14"Il test del primo esempio passa: la risposta è scritta a mano. Con qualunque altra lista sbagliatest_il_massimo_in_testa, test_il_massimo_in_fondo, test_a_parita_vince_il_primo
if minuti >= massimo: (con la variabile in più)Il codice si ricorda, ma a parità vince l'ultimo treno, non il primo: M14 prende il posto di M12test_a_parita_vince_il_primo
La correzione giusta, senza il commentoLa funzione è giustatest_prima_della_correzione_il_commento

La seconda è la più sottile. Un >= sembra innocuo, e «a parità vince il primo» era scritto nella consegna: la consegna fa parte del test. Il numero scritto a mano è il tipico trucco per far passare un test.


La storia

Cinque funzioni, un livello per funzione. In ognuna, il commento # BUG: e la correzione.

Livello 1 · La segnalazione di T28

In italiano. La regola dice «tre segnalazioni o più». La riga dice «più di tre». T28 ne ha tre: per > non bastano. Il confine non è compreso. Si controlla sempre un confine sul valore esatto.

Python
def troppe_segnalazioni(treno: dict) -> bool:
    # BUG: con > tre segnalazioni non bastano: serve averne almeno quattro. La soglia è «tre o più»: >=.
    return treno["segnalazioni"] >= 3

Il debugger, con T28 (tre segnalazioni) e due espressioni in WATCH:

treno = {'codice': 'T28', 'segnalazioni': 3}
WATCH treno['segnalazioni'] > 3 → False
WATCH treno['segnalazioni'] >= 3 → True

Il piano dopo il livello 1. T28 sparisce dai treni che escono, e quelli dopo di lui salgono di un posto:

In officina (3): T28, M16, T34
Escono:
  05:00  M12  binario 1  controllo rinforzato
  05:12  M14  binario 2  controllo rinforzato
  05:24  M18  binario 3  controllo rinforzato
  ...

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
return treno["segnalazioni"] == 3T28, con tre segnalazioni, va in officina. Ma un treno con cinque, che è messo peggio, escetest_livello_1_di_piu_e_ancora_troppe

Un >= 3 è giusto; un > 2 è uguale e va bene lo stesso, per numeri interi. Quello che non va è fermarsi sul valore del caso da risolvere.


Livello 2 · I chilometri

In italiano. I km nel registro sono testo. Python confronta due testi carattere per carattere, da sinistra: "11500" contro "9000" si ferma al primo carattere, '1' contro '9', e '1' viene prima. Quindi per Python "11500" è minore di "9000", anche se come numeri è vero il contrario. M20 e T32 (11500 e 12000 km) restano fuori dall'officina. Il rimedio: trasformare il testo in numero, e confrontare numeri.

Python
def troppi_km(treno: dict) -> bool:
    # BUG: i km sono testo e Python confronta il testo carattere per carattere: "11500" viene prima di "9000" perché '1' viene prima di '9'.
    # Vanno confrontati come numeri: int().
    return int(treno["km"]) >= 9000

Il debugger, con M20:

treno = {'codice': 'M20', 'km': '11500'}
WATCH treno['km'] >= '9000' → False
WATCH int(treno['km']) >= 9000 → True

Il piano dopo il livello 2. Entrano in officina anche M20 e T32. Le uscite scendono a sette:

In officina (5): T28, M16, M20, T32, T34
...
Nel deposito: 7 treni · escono 7 · in officina 5

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
return int(treno["km"]) > 9000I numeri ora sono numeri, ma > lascia fuori il confine: un treno con 9000 km esatti escetest_livello_2_il_confine_esatto

Due errori diversi nella stessa riga: aggiustarne uno e dimenticare l'altro è facile. Per questo i test controllano il valore esatto del confine.


Livello 3 · I controlli

In italiano. Il return è dentro il for, allineato all'if. Il ciclo fa il primo giro, e alla riga return la funzione finisce. Con M12 controllato, la lista è vuota: «tutti i controlli fatti». Il return va fuori dal ciclo, allineato al for: si esce solo dopo aver guardato tutti i treni.

Python
def non_controllati(treni: list[dict]) -> list[str]:
    mancanti = []
    for treno in treni:
        if not treno["controllato"]:
            mancanti.append(treno["codice"])
    # BUG: il return era dentro il for: la funzione finiva al primo treno, e se quello era a posto restituiva [].
    # Il return va fuori dal ciclo, allineato al for.
    return mancanti

Passo per passo. Un breakpoint sull'if, con i treni di stanotte, prima della correzione:

Girotreno["codice"]controllatomancanti primaCosa succede
1M12True[]niente da aggiungere, poi la return: la funzione esce con []

Una fermata sola, e previsione e osservazione si separano subito: prevedevi dodici giri. Dopo la correzione i giri sono dodici, e mancanti cambia in due punti:

Girotreno["codice"]controllatomancanti dopo
1M12True[]
2T28False['T28']
8M24False['T28', 'M24']

Gli altri nove giri non la cambiano. Il commento # BUG: sta sopra la return perché è la riga che cambia di posto.

Il piano dopo il livello 3. La riga dei controlli cambia:

Controlli di stanotte: mancano T28, M24

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Un break dopo l'append, con la return fuori dal cicloIl ciclo si ferma al primo non controllato: con due treni da segnalare, il secondo non comparetest_livello_3_li_trova_anche_se_il_primo_e_a_posto
La correzione giusta, senza il commentoLa funzione è giustatest_livello_3_prima_della_correzione_il_commento

Il return dentro il for è giusto quando vuoi uscire appena hai trovato (ne parla Le funzioni). Qui devi raccogliere tutti: si esce dopo il ciclo.


Livello 4 · Chi esce

In italiano. escono = treni non fa una copia: dà una seconda etichetta alla stessa lista. Poi escono.remove(treno) toglie un treno da quella lista, e treni è la stessa lista: quando il programma conta len(treni) per scrivere «Nel deposito», ne trova dieci invece di dodici. Si disegna in due righe, come in Etichette e scatole:

ETICHETTE        SCATOLE

treni  ──┐
         ├──►  [ M12, T28, M14, ... ]      una scatola sola
escono ──┘

La correzione: una scatola nuova con gli stessi treni, list(treni).

Python
def treni_che_escono(treni: list[dict], in_officina: list[dict]) -> list[dict]:
    # BUG: escono = treni non fa una copia, dà una seconda etichetta alla stessa lista: i remove tolgono i treni anche da treni.
    # Serve una lista nuova: list(treni).
    escono = list(treni)
    for treno in in_officina:
        escono.remove(treno)
    return escono

Passo per passo. Un breakpoint sulla riga del remove, con dodici treni e due in officina, prima della correzione:

Fermatalen(escono)escono is trenilen(treni)
112True12
211True11

is chiede se due nomi sono la stessa scatola: la risposta è True, e dopo un remove anche treni è più corta. Alla fine i due contano dieci, e il piano scrive «Nel deposito: 10 treni».

Il piano dopo il livello 4. I dodici tornano:

Nel deposito: 12 treni · escono 7 · in officina 5

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
[treno for treno in treni if treno["codice"] not in in_officina]La lista di partenza non cambia, ma il confronto è sbagliato: un codice (testo) non è mai uguale a un treno (dizionario) dentro in_officina. Nessun treno viene tolto, tutti esconotest_livello_4_escono_tutti_tranne_l_officina

La stessa correzione con treni[:] o treni.copy() va bene: l'importante è una scatola nuova.


Livello 5 · Il controllo a bordo

In italiano. I due if sono indipendenti. Con 300 minuti, il primo è vero e assegna «doppio». Ma il secondo è vero anche lui (300 è minore di 396) e assegna «rinforzato», e vince l'ultimo. Il secondo if non sa che il primo c'è già stato. Con una catena (elif) si arriva al secondo solo se il primo non era vero.

Python
def controllo_a_bordo(minuti_uscita: int) -> str:
    if minuti_uscita < 360:
        controllo = "doppio"
    # BUG: due if di fila: per un'ora prima delle 6:00 vale anche il secondo, che sovrascrive «doppio» con «rinforzato».
    # Il secondo deve essere un elif: si arriva lì solo se il primo non è vero.
    elif minuti_uscita < 396:
        controllo = "rinforzato"
    else:
        controllo = "normale"
    return controllo

Passo per passo. Debug Test sul test «prima delle sei», con 300 minuti, e F10 una riga alla volta:

Dopo la rigaminuti_uscitacontrollo
if minuti_uscita < 360: (vera) e la riga sotto300'doppio'
il secondo if minuti_uscita < 396: (vero) e la riga sotto300'rinforzato'

Nella stessa chiamata controllo cambia due volte. Prevedevi che cambiasse una volta sola.

Il piano dopo il livello 5. I primi cinque treni hanno il controllo doppio:

  05:00  M12  binario 1  controllo doppio
  05:12  M14  binario 2  controllo doppio
  05:24  M18  binario 3  controllo doppio
  05:36  M22  binario 4  controllo doppio
  05:48  M24  binario 1  controllo doppio
  06:00  T26  binario 2  controllo rinforzato
  06:12  T30  binario 3  controllo rinforzato

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
La catena if / elif / else, ma con prima il confronto minuti_uscita < 396 e dopo quello < 360La catena c'è, ma l'ordine è sbagliato: ogni ora sotto le 6:36 entra nel primo ramo, e «doppio» non viene mai assegnatotest_livello_5_prima_delle_sei_e_doppio

In una catena di elif conta l'ordine: prima il caso più stretto, poi quello più largo. Il capitolo Le condizioni ne parla.


Il finale

Il registro modifiche.txt cita le righe per testo e per funzione, mai per numero. Le cinque funzioni che hai corretto sono troppe_segnalazioni, troppi_km, non_controllati, treni_che_escono e controllo_a_bordo.

ChiQuante righe in tuttoLe cinque funzioni che hai corretto
Giorgio Fumagalli8 (il più attivo)tre: le segnalazioni, i km, i controlli
Elena Conti5tre: i km, i treni che escono, il controllo a bordo
Paola Neri2una: le segnalazioni, la riga di T28
Marco Riva3nessuna
Ernesto Pozzi1 (la firma)nessuna
Livia Marchetti6tutte e cinque

Una sola persona compare in tutte e cinque: Livia Marchetti, del turno di notte. Se ti fermi al livello tre, restano due nomi: Giorgio Fumagalli e lei. Al quarto ne resta uno solo.

Terminale
python storia/verifica.py "Livia Marchetti"
Il commissario Mapelli posa il caffè.
«Cinque righe, cinque funzioni, e un solo nome in tutte: Livia Marchetti, del turno di notte.
Sapeva che il programma non avrebbe dato nessun errore, e che Ernesto avrebbe firmato un piano pulito.
T28 con i freni da controllare doveva uscire alle 5:12. Andiamo a trovarla.»

Caso chiuso.

Se hai dato un altro nome, il commissario ti dice perché non è lui: è la parte di verifica.py che non si legge.