Moduli e file, 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 qualche test e si rompono su un altro.
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 · Quanti treni servono
In italiano. Divido le persone per i posti: 250 diviso 100 fa 2.5. Mezzo treno non esiste, quindi arrotondo per eccesso: 3. È proprio quello che fa math.ceil.
import math
def treni_necessari(persone: int, posti_per_treno: int) -> int:
return math.ceil(persone / posti_per_treno)L'import sta in cima al file, fuori dalla funzione: così il modulo math è pronto per tutto il file. math.ceil restituisce un int: 3, non 3.0.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return persone // posti_per_treno | // arrotonda per difetto: 250 persone, 2 treni, e 50 restano sulla banchina. Una persona sola: 0 treni | test_un_treno_in_piu_per_chi_avanza, test_una_persona_sola_vuole_un_treno |
return round(persone / posti_per_treno) | round arrotonda al più vicino: 0.01 diventa 0. E 2.5 diventa 2, perché quando un numero è esattamente a metà Python sceglie il pari | Gli stessi due |
return persone // posti_per_treno + 1 | Un treno in più, sempre: anche quando il conto è esatto, e anche con zero persone | test_conto_esatto, test_nessuno_nessun_treno |
2 · Gli avvisi del giorno
In italiano.
- Parto da una lista vuota.
- Apro il file, e per ogni riga tolgo l'a capo e gli spazi intorno.
- Se quello che resta non è vuoto, è un avviso: lo aggiungo.
def leggi_avvisi(percorso: Path) -> list[str]:
avvisi = []
with open(percorso, encoding="utf-8") as f:
for riga in f:
riga = riga.strip()
if riga != "":
avvisi.append(riga)
return avvisiÈ il setaccio del capitolo sulle liste, con un with open intorno. Il return sta fuori dal with: quando arriva, il file è già chiuso, e la lista è pronta.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Nessuno strip(): if riga != "" sulla riga così com'è | Ogni avviso si porta dietro il suo \n, e le righe «vuote» non sono vuote: sono "\n" | test_una_riga_per_avviso, test_toglie_gli_spazi_intorno, test_salta_le_righe_vuote |
avvisi.append(riga.strip()), senza if | Le righe vuote diventano avvisi vuoti: nella lista compaiono degli '' | test_salta_le_righe_vuote |
3 · Il registro dei ritardi
In italiano. Apro il file in modo "a": scrive in fondo, e se il file non c'è lo crea. Scrivo la riga, con l'a capo in fondo.
def registra_ritardo(percorso: Path, treno: str, minuti: int) -> None:
with open(percorso, "a", encoding="utf-8") as f:
f.write(f"{treno},{minuti}\n")Niente return: la funzione restituisce None, ed è giusto così. Il suo risultato è il file, e infatti i test leggono il file, non quello che la funzione restituisce. La f-string serve anche per un altro motivo: write vuole testo, e minuti è un numero.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
open(percorso, "w", encoding="utf-8") | "w" svuota il file a ogni chiamata: resta solo l'ultimo ritardo, 'M16,10\n' | test_aggiunge_in_fondo_senza_cancellare, test_due_ritardi_due_righe |
f.write(f"{treno},{minuti}"), senza \n | Le righe si incollano una all'altra: 'M12,5M16,10' | test_crea_il_file_se_non_c_e, test_aggiunge_in_fondo_senza_cancellare, test_due_ritardi_due_righe |
4 · I minuti di ritardo
In italiano.
- Leggo tutte le righe e salto la prima, l'intestazione.
- Per ogni riga tolgo l'a capo. Se resta vuota,
continue. - La divido in treno e minuti.
- Al totale del treno (zero, se è la prima volta che lo vedo) aggiungo i minuti, trasformati in numero.
def minuti_di_ritardo(percorso: Path) -> dict[str, int]:
totali = {}
with open(percorso, encoding="utf-8") as f:
righe = f.readlines()
for riga in righe[1:]: # la riga 0 è l'intestazione
riga = riga.strip()
if riga == "":
continue # riga vuota: si passa al giro dopo
treno, minuti = riga.split(",")
totali[treno] = totali.get(treno, 0) + int(minuti)
return totaliPasso per passo, con il file della docstring (treno,minuti, poi M12,5, M14,3, M12,10):
| Giro | riga dopo strip() | treno, minuti | totali dopo il giro |
|---|---|---|---|
| 1 | 'M12,5' | 'M12', '5' | {'M12': 5} |
| 2 | 'M14,3' | 'M14', '3' | {'M12': 5, 'M14': 3} |
| 3 | 'M12,10' | 'M12', '10' | {'M12': 15, 'M14': 3} |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
for riga in righe: senza [1:] | Il primo giro è l'intestazione: ValueError: invalid literal for int() with base 10: 'minuti' | test_somma_i_minuti_di_ogni_treno, test_solo_l_intestazione_nessun_ritardo, test_le_righe_vuote_si_saltano |
totali.get(treno, 0) + minuti, senza int() | Un numero più un testo: TypeError: unsupported operand type(s) for +: 'int' and 'str' | test_somma_i_minuti_di_ogni_treno, test_le_righe_vuote_si_saltano |
| Nessun controllo sulla riga vuota | ''.split(",") dà un pezzo solo: ValueError: not enough values to unpack (expected 2, got 1) | test_le_righe_vuote_si_saltano |
5 · Gli oggetti smarriti
In italiano.
- Parto da una lista vuota.
- Apro il file e lo do a
csv.DictReader: ogni riga diventa un dizionario con le chiavi dell'intestazione. - Se la stazione della riga è quella cercata, aggiungo la sua descrizione.
def oggetti_di(percorso: Path, stazione: str) -> list[str]:
trovati = []
with open(percorso, encoding="utf-8") as f:
for riga in csv.DictReader(f):
if riga["stazione"] == stazione:
trovati.append(riga["descrizione"])
return trovatiCon DictReader non c'è un'intestazione da saltare, né un a capo da togliere: ci pensa lui.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
A mano: data, dove, descrizione = riga.strip().split(",") | La riga con la virgola tra virgolette si spezza in quattro pezzi: ValueError: too many values to unpack (expected 3) | test_la_virgola_tra_virgolette_non_divide |
Il return trovati con un rientro di troppo, dentro il for | La funzione esce al primo giro: ['guanto rosso']. Il secondo oggetto della stazione, il libro di ricette, non arriva mai | test_gli_oggetti_di_una_stazione_in_ordine |
La seconda è la trappola del return del capitolo sulle funzioni: con un solo oggetto per stazione il test passa, con due no.
6 · Il tabellone da terminale
In italiano.
- Se gli argomenti sono meno di due, manca il file: spiego come si usa, su stderr, e restituisco 1.
- Leggo le righe del file che sta in
argomenti[1]. - Per ogni riga dopo l'intestazione: la pulisco e la divido alle virgole.
- Tre pezzi: è una partenza, su stdout. Altrimenti: avviso su stderr, con il numero della riga contato da 1.
- Alla fine restituisco 0.
def main(argomenti: list[str]) -> int:
if len(argomenti) < 2:
print("Si usa così: python palestra/tabellone.py <file.csv>", file=sys.stderr)
return 1
with open(argomenti[1], encoding="utf-8") as f:
righe = f.readlines()
for i in range(1, len(righe)): # da 1: la riga 0 è l'intestazione
riga = righe[i].strip()
pezzi = riga.split(",")
if len(pezzi) == 3:
treno, destinazione, binario = pezzi
print(f"{treno} per {destinazione}, binario {binario}")
else:
print(f"Riga {i + 1} ignorata: {riga}", file=sys.stderr) # le persone contano da 1
return 0Il disegno.
Passo per passo, con palestra/esempi/tabellone.csv:
i | riga | Pezzi | Dove va |
|---|---|---|---|
| 1 | 'M12,Piazza Query,2' | 3 | stdout: M12 per Piazza Query, binario 2 |
| 2 | 'M14,Porta Codice,1' | 3 | stdout: M14 per Porta Codice, binario 1 |
| 3 | 'M16,Ponte Ciclo' | 2 | stderr: Riga 4 ignorata: M16,Ponte Ciclo |
| 4 | 'M18,Largo Lista,2' | 3 | stdout: M18 per Largo Lista, binario 2 |
Il return 1 in cima è un'uscita anticipata: se manca il file, il resto della funzione non parte nemmeno.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
I due messaggi con print(...), senza file=sys.stderr | Gli avvisi finiscono su stdout, mescolati alle partenze: il tabellone mostrerebbe «Riga 4 ignorata» ai passeggeri | test_senza_il_file_spiega_come_si_usa, test_le_righe_rotte_vanno_su_stderr_con_il_numero |
open(argomenti[0], ...) | argomenti[0] è il programma, non il file: FileNotFoundError: [Errno 2] No such file or directory: 'tabellone.py' | test_una_riga_per_ogni_partenza, test_le_righe_rotte_vanno_su_stderr_con_il_numero, test_solo_l_intestazione_tabellone_vuoto |
if len(argomenti) == 0: | sys.argv non è mai vuota: c'è sempre il programma. Il controllo non scatta, e argomenti[1] dà IndexError: list index out of range | test_senza_il_file_spiega_come_si_usa |
f"Riga {i} ignorata: {riga}" | Il numero di Python, contato da 0: la terza riga del file diventa «Riga 2» | test_le_righe_rotte_vanno_su_stderr_con_il_numero |
La storia
Livello 1 · Le righe vere
In italiano. Come gli avvisi della palestra: apro, tolgo l'a capo e gli spazi a ogni riga, tengo quelle non vuote.
def righe_utili(percorso: Path) -> list[str]:
utili = []
with open(percorso, encoding="utf-8") as f:
for riga in f:
riga = riga.strip()
if riga != "":
utili.append(riga)
return utiliNel registro vero: 25 righe utili, la prima è l'intestazione. Le righe vuote e quella di soli spazi tra la sera e la mattina sono sparite.
La trappola.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Nessuno strip() | Le righe tengono l'a capo, e le righe vuote, che sono "\n", passano l'if | test_livello_1_toglie_gli_a_capo, test_livello_1_toglie_gli_spazi_intorno, test_livello_1_salta_le_righe_vuote |
Livello 2 · I campi
In italiano. Divido alle virgole, poi tolgo gli spazi a ogni pezzo.
def campi(riga: str) -> list[str]:
puliti = []
for campo in riga.split(","):
puliti.append(campo.strip())
return pulitiNel registro vero: campi("M12, sera, 22510, Ada") dà ['M12', 'sera', '22510', 'Ada'].
La trappola.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return riga.split(",") | Gli spazi restano attaccati ai pezzi: ' X1 ', ' sera' | test_livello_2_toglie_gli_spazi_da_ogni_campo, test_livello_3_salta_le_righe_con_i_campi_sbagliati |
Il test del livello 3 diventa rosso anche lui, perché leggi_letture usa campi: un errore in una funzione si porta dietro tutte quelle che la usano. Se il livello 3 è rosso senza motivo, controlla prima il 2.
Livello 3 · Le righe rotte
In italiano.
- Prendo le righe utili, senza la prima: l'intestazione.
- Per ogni riga, i campi.
- Se non sono quattro, o uno è vuoto: avviso su stderr e
continue. - Altrimenti li spacchetto e costruisco il dizionario della lettura.
def leggi_letture(percorso: Path) -> list[dict]:
righe = righe_utili(percorso)
letture = []
for riga in righe[1:]: # la riga 0 è l'intestazione
valori = campi(riga)
if len(valori) != 4 or "" in valori:
print("Riga saltata, campi mancanti:", riga, file=sys.stderr)
continue
treno, momento, km, firma = valori
letture.append({"treno": treno, "momento": momento, "km": km, "firma": firma})
return lettureIl disegno.
"" in valori chiede se nella lista c'è un campo vuoto: è l'in delle liste.
Nel registro vero: 21 letture. Su stderr, tre righe saltate:
Riga saltata, campi mancanti: M13,sera,,Ada
Riga saltata, campi mancanti: M15,mattina,17,650,Gino
Riga saltata, campi mancanti: M16,mattina,25033Un campo vuoto, cinque campi (Gino ha scritto 17,650 con la virgola delle migliaia), tre campi. Tutte e tre hanno la riga giusta subito sotto.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
for riga in righe: senza [1:] | L'intestazione diventa una lettura: {'treno': 'treno', 'momento': 'momento', …} | test_livello_3_ogni_riga_e_un_dizionario, test_livello_3_solo_l_intestazione, test_livello_3_salta_le_righe_con_i_campi_sbagliati |
Solo len(valori) != 4, senza "" in valori | La riga con il km vuoto passa, e nessuno la segnala | test_livello_3_salta_le_righe_con_i_campi_sbagliati, test_livello_3_le_righe_saltate_vanno_su_stderr |
print("Riga saltata, campi mancanti:", riga), senza file=sys.stderr | Gli avvisi finiscono su stdout, che doveva restare pulito | test_livello_3_le_righe_saltate_vanno_su_stderr |
Livello 4 · I numeri scritti male
In italiano.
- Per ogni lettura provo a trasformare i km in intero.
- Se
int()non ce la fa: avviso su stderr econtinue. - Se ce la fa: una copia della lettura, con i km in numero, va nella lista.
def km_numerici(letture: list[dict]) -> list[dict]:
buone = []
for lettura in letture:
try:
km = int(lettura["km"])
except ValueError:
print("Km scritti male, riga saltata:", lettura["treno"], lettura["momento"], lettura["km"], file=sys.stderr)
continue
nuova = dict(lettura)
nuova["km"] = km
buone.append(nuova)
return buoneIl disegno. Una lettura e la sua copia, dopo nuova["km"] = km: due scatole, e la copia ha i km in numero.
Il disegno.
Passo per passo, su quattro letture del registro vero:
lettura["km"] | int(...) | Cosa succede |
|---|---|---|
'18204 km' | ValueError | except: avviso, continue |
'18204' | 18204 | Copia con "km": 18204, nella lista |
'31.002' | ValueError | except: avviso, continue |
'undicimila' | ValueError | except: avviso, continue |
Nel try c'è una riga sola: se ci fosse tutto il corpo del ciclo, un errore diverso, magari un bug, finirebbe nello stesso except e sparirebbe. Il try piccolo dice esattamente cosa può andare storto.
Nel registro vero: 17 letture. Su stderr, quattro righe saltate:
Km scritti male, riga saltata: M11 sera 18204 km
Km scritti male, riga saltata: treno momento km
Km scritti male, riga saltata: M14 mattina 31.002
Km scritti male, riga saltata: M19 mattina undicimilaLa seconda è una sorpresa: Gino, la mattina, ha incollato di nuovo l'intestazione. Al livello 3 aveva quattro campi pieni ed è passata; qui int("km") la ferma. Due controlli in fila prendono più cose di uno solo.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
int(lettura["km"]) senza try | Il programma si ferma alla prima riga rotta, come quello vecchio: ValueError: invalid literal for int() with base 10: '2.000' | test_livello_4_salta_i_km_scritti_male, test_livello_4_i_km_scritti_male_vanno_su_stderr |
float(lettura["km"]) al posto di int | float accetta il punto: '31.002' diventa 31.002, trentun chilometri, mentre Gino ne intendeva trentunomila. La riga passa, sbagliata, e non viene segnalata | test_livello_4_salta_i_km_scritti_male, test_livello_4_i_km_scritti_male_vanno_su_stderr |
Livello 5 · I treni che si sono mossi
In italiano.
- Primo giro: metto i km in due dizionari,
seraemattina, treno → km. - Secondo giro, sui treni della sera: se c'è anche la lettura del mattino, calcolo mattina meno sera.
- Se sono più di
MANOVRA_MASSIMA, il treno è uscito: va nel risultato, con i suoi km.
def treni_mossi(letture: list[dict]) -> dict[str, int]:
sera = {}
mattina = {}
for lettura in letture:
if lettura["momento"] == "sera":
sera[lettura["treno"]] = lettura["km"]
elif lettura["momento"] == "mattina":
mattina[lettura["treno"]] = lettura["km"]
mossi = {}
for treno, km_sera in sera.items():
if treno in mattina:
fatti = mattina[treno] - km_sera
if fatti > MANOVRA_MASSIMA:
mossi[treno] = fatti
return mossiCon due dizionari l'ordine delle righe nel registro non conta più: la sera e la mattina di un treno si ritrovano per nome.
Passo per passo, il secondo giro sul registro vero:
| Treno | Sera | Mattina | Fatti | Più di 2? |
|---|---|---|---|---|
| M11 | 18204 | 18204 | 0 | No |
| M12 | 22510 | 22512 | 2 | No: è una manovra |
| M13, M14, M15, M16, M18 | — | — | 0 | No |
| M17 | 14321 | 14359 | 38 | Sì |
| M19 | 11480 | manca | — | Non si confronta: la riga del mattino era «undicimila» |
Nel registro vero: {'M17': 38}. Un treno ha fatto 38 chilometri mentre doveva dormire.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
fatti >= MANOVRA_MASSIMA | Due chilometri diventano un viaggio: nel registro vero spunta anche M12, che era solo andato al lavaggio | test_livello_5_due_km_sono_una_manovra |
Nessun if treno in mattina | Un treno con la sola lettura della sera: KeyError | test_livello_5_con_una_lettura_sola_non_si_confronta |
km_sera - mattina[treno] | La sottrazione al contrario: i km fatti escono negativi, e nessun treno supera mai 2 | test_livello_5_il_treno_che_ha_viaggiato, test_livello_5_due_km_sono_una_manovra, test_livello_5_l_ordine_delle_righe_non_conta |
Livello 6 · La chiave
In italiano. Apro il JSON e lo carico con json.load: diventa una lista di dizionari. Poi tengo i movimenti con la chiave giusta.
def movimenti_chiave(percorso: Path, treno: str) -> list[dict]:
with open(percorso, encoding="utf-8") as f:
movimenti = json.load(f)
trovati = []
for movimento in movimenti:
if movimento["chiave"] == treno:
trovati.append(movimento)
return trovatiNiente strip(), niente int(), niente try: il JSON l'ha scritto un programma, e i tipi arrivano già giusti.
Nel registro vero, la chiave di M17:
21:51 resa · Franca Molteni
02:41 presa · Walter Bonomi
03:58 resa · Walter Bonomi
05:40 presa · Sergio ColomboLa trappola.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
json.loads(f) | loads vuole una stringa, non un file aperto: TypeError: the JSON object must be str, bytes or bytearray, not TextIOWrapper | test_livello_6_solo_la_chiave_di_quel_treno, test_livello_6_tutti_i_movimenti_in_ordine, test_livello_6_una_chiave_mai_toccata |
Il finale
- Livello 5: M17 ha fatto 38 km tra il giro della sera (22:00) e quello del mattino (05:00–05:30). M12 si è spostato di 2 km, ma è una manovra: la sua chiave l'ha avuta Ivo Brambati dalle 23:40 alle 23:58, il tempo di un giro al lavaggio.
- Livello 6, la chiave di M17:
- Franca Molteni l'ha resa alle 21:51, finito l'ultimo giro: prima della lettura delle 22:00. I suoi chilometri sono già nei 14321 della sera.
- Sergio Colombo l'ha presa alle 05:40, per il primo treno del mattino: dopo la lettura. I suoi chilometri non sono nel registro.
- In mezzo, dalle 02:41 alle 03:58, la chiave l'aveva Walter Bonomi. Alle 03:10 un treno a luci spente passava da Ponte Ciclo.
- Livelli 3 e 4: tutte le righe saltate hanno la loro correzione subito sotto, tranne M19 del mattino. Ma la chiave di M19 è nell'armadietto dalle 21:44, e nessuno l'ha toccata.
Il treno è uscito con la chiave di Walter Bonomi.
python storia/verifica.py "Walter Bonomi"