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.
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?
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 registratiPasso 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:
| Giro | codice | ritardo | registrati prima | Prevedo | Con if ritardo: |
|---|---|---|---|---|---|
| 1 | M12 | 0 | [] | lo aggiunge | non lo aggiunge |
| 2 | M14 | 5 | [] | lo aggiunge | lo aggiunge |
| 3 | M16 | None | ['M14'] | non lo aggiunge | non 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 sbagliato | Cosa succede | Il 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 registrato | test_un_treno_senza_dato_non_e_registrato |
if ritardo is not None: senza il commento | La funzione è giusta: tutti i test del comportamento sono verdi | test_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.
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: identicoLe trappole.
| Il codice sbagliato | Cosa succede | Il 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: restano | test_tabulazione_e_a_capo |
testo = testo.strip() senza il commento | La funzione è giusta | test_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.
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 ammessiPasso per passo. Con tre persone (Ivo, Sergio, Nadia) il debugger si ferma tre volte sull'if. Con or:
| Giro | persona["nome"] | attivo | reparto == "officina" | Prevedo | Con or |
|---|---|---|---|---|---|
| 1 | Ivo | True | True | entra | entra |
| 2 | Sergio | True | False | non entra | entra |
| 3 | Nadia | False | True | non entra | entra |
Con or la lista finale è ['Ivo', 'Sergio', 'Nadia']: tutti. Con and, solo ['Ivo'].
Le trappole.
| Il codice sbagliato | Cosa succede | Il 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, entra | test_in_servizio_ma_di_un_altro_reparto_non_entra, test_un_elenco_misto_in_ordine |
if persona["attivo"] and persona["reparto"] == "officina": senza il commento | La funzione è giusta | test_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.
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 totalePasso per passo. Il debugger sulla riga del totale, con due giri:
| Giro | giro in VARIABLES | totale prima | Prevedo che aggiunga | Con get("salti", 0) aggiunge |
|---|---|---|---|---|
| 1 | {'treno': 'M12', 'saliti': 120, 'scesi': 95} | 0 | 120 | 0 |
| 2 | {'treno': 'M14', 'saliti': 80, 'scesi': 100} | 0 | 80 | 0 |
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 sbagliato | Cosa succede | Il 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 inosservato | test_un_giro_senza_il_dato_ferma_il_programma |
giro["saliti"] senza il commento | La funzione è giusta | test_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.
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_ritardoIl disegno.
Passo per passo. Con [("M12", 4), ("M14", 11), ("T28", 2)], un breakpoint sulla riga dell'if, prima della riga:
| Giro | codice | minuti | massimo prima | minuti > massimo? | massimo dopo |
|---|---|---|---|---|---|
| 1 | M12 | 4 | -1 | sì | 4 |
| 2 | M14 | 11 | 4 | sì | 11 |
| 3 | T28 | 2 | 11 | no | 11 |
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 = 2Il valore che prevedevi in codice era 'M14'. Eccolo, il punto in cui previsione e osservazione si separano.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return "M14" | Il test del primo esempio passa: la risposta è scritta a mano. Con qualunque altra lista sbaglia | test_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 M12 | test_a_parita_vince_il_primo |
| La correzione giusta, senza il commento | La funzione è giusta | test_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.
def troppe_segnalazioni(treno: dict) -> bool:
# BUG: con > tre segnalazioni non bastano: serve averne almeno quattro. La soglia è «tre o più»: >=.
return treno["segnalazioni"] >= 3Il debugger, con T28 (tre segnalazioni) e due espressioni in WATCH:
treno = {'codice': 'T28', 'segnalazioni': 3}
WATCH treno['segnalazioni'] > 3 → False
WATCH treno['segnalazioni'] >= 3 → TrueIl 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 sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return treno["segnalazioni"] == 3 | T28, con tre segnalazioni, va in officina. Ma un treno con cinque, che è messo peggio, esce | test_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.
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"]) >= 9000Il debugger, con M20:
treno = {'codice': 'M20', 'km': '11500'}
WATCH treno['km'] >= '9000' → False
WATCH int(treno['km']) >= 9000 → TrueIl 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 5Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return int(treno["km"]) > 9000 | I numeri ora sono numeri, ma > lascia fuori il confine: un treno con 9000 km esatti esce | test_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.
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 mancantiPasso per passo. Un breakpoint sull'if, con i treni di stanotte, prima della correzione:
| Giro | treno["codice"] | controllato | mancanti prima | Cosa succede |
|---|---|---|---|---|
| 1 | M12 | True | [] | 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:
| Giro | treno["codice"] | controllato | mancanti dopo |
|---|---|---|---|
| 1 | M12 | True | [] |
| 2 | T28 | False | ['T28'] |
| 8 | M24 | False | ['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, M24Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Un break dopo l'append, con la return fuori dal ciclo | Il ciclo si ferma al primo non controllato: con due treni da segnalare, il secondo non compare | test_livello_3_li_trova_anche_se_il_primo_e_a_posto |
| La correzione giusta, senza il commento | La funzione è giusta | test_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).
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 esconoPasso per passo. Un breakpoint sulla riga del remove, con dodici treni e due in officina, prima della correzione:
| Fermata | len(escono) | escono is treni | len(treni) |
|---|---|---|---|
| 1 | 12 | True | 12 |
| 2 | 11 | True | 11 |
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 5Le trappole.
| Il codice sbagliato | Cosa succede | Il 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 escono | test_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.
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 controlloPasso per passo. Debug Test sul test «prima delle sei», con 300 minuti, e F10 una riga alla volta:
| Dopo la riga | minuti_uscita | controllo |
|---|---|---|
if minuti_uscita < 360: (vera) e la riga sotto | 300 | 'doppio' |
il secondo if minuti_uscita < 396: (vero) e la riga sotto | 300 | '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 rinforzatoLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
La catena if / elif / else, ma con prima il confronto minuti_uscita < 396 e dopo quello < 360 | La catena c'è, ma l'ordine è sbagliato: ogni ora sotto le 6:36 entra nel primo ramo, e «doppio» non viene mai assegnato | test_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.
| Chi | Quante righe in tutto | Le cinque funzioni che hai corretto |
|---|---|---|
| Giorgio Fumagalli | 8 (il più attivo) | tre: le segnalazioni, i km, i controlli |
| Elena Conti | 5 | tre: i km, i treni che escono, il controllo a bordo |
| Paola Neri | 2 | una: le segnalazioni, la riga di T28 |
| Marco Riva | 3 | nessuna |
| Ernesto Pozzi | 1 (la firma) | nessuna |
| Livia Marchetti | 6 | tutte 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.
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.