Vai al contenuto
code-to-code

Apro l'indice…

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

Python7. Moduli e filep. 214

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.

python-moduli-e-file-soluzioni.zip22 KB

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.

Python
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 sbagliatoCosa succedeIl test rosso
return persone // posti_per_treno// arrotonda per difetto: 250 persone, 2 treni, e 50 restano sulla banchina. Una persona sola: 0 trenitest_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 pariGli stessi due
return persone // posti_per_treno + 1Un treno in più, sempre: anche quando il conto è esatto, e anche con zero personetest_conto_esatto, test_nessuno_nessun_treno

2 · Gli avvisi del giorno

In italiano.

  1. Parto da una lista vuota.
  2. Apro il file, e per ogni riga tolgo l'a capo e gli spazi intorno.
  3. Se quello che resta non è vuoto, è un avviso: lo aggiungo.
Python
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 sbagliatoCosa succedeIl 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 ifLe 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.

Python
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 sbagliatoCosa succedeIl 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 \nLe 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.

  1. Leggo tutte le righe e salto la prima, l'intestazione.
  2. Per ogni riga tolgo l'a capo. Se resta vuota, continue.
  3. La divido in treno e minuti.
  4. Al totale del treno (zero, se è la prima volta che lo vedo) aggiungo i minuti, trasformati in numero.
Python
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 totali

Passo per passo, con il file della docstring (treno,minuti, poi M12,5, M14,3, M12,10):

Giroriga dopo strip()treno, minutitotali 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 sbagliatoCosa succedeIl 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.

  1. Parto da una lista vuota.
  2. Apro il file e lo do a csv.DictReader: ogni riga diventa un dizionario con le chiavi dell'intestazione.
  3. Se la stazione della riga è quella cercata, aggiungo la sua descrizione.
Python
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 trovati

Con DictReader non c'è un'intestazione da saltare, né un a capo da togliere: ci pensa lui.

Le trappole.

Il codice sbagliatoCosa succedeIl 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 forLa funzione esce al primo giro: ['guanto rosso']. Il secondo oggetto della stazione, il libro di ricette, non arriva maitest_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.

  1. Se gli argomenti sono meno di due, manca il file: spiego come si usa, su stderr, e restituisco 1.
  2. Leggo le righe del file che sta in argomenti[1].
  3. Per ogni riga dopo l'intestazione: la pulisco e la divido alle virgole.
  4. Tre pezzi: è una partenza, su stdout. Altrimenti: avviso su stderr, con il numero della riga contato da 1.
  5. Alla fine restituisco 0.
Python
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 0

Il disegno.

inizio main(argomenti) se len(argomenti) < 2 sì: mostra come si usa, su stderr restituisci 1 passo righe = le righe del file per ogni riga dopo l'intestazione pezzi = riga.split(",") se len(pezzi) == 3 sì: mostra treno per destinazione, binario no: mostra riga ignorata, su stderr restituisci 0main(argomenti)len(argomenti) < 2mostra come si usa, sustderrrestituisci 1righe = le righe del fileper ogni riga dopol'intestazionepezzi = riga.split(",")len(pezzi) == 3mostra riga ignorata, sustderrmostra treno perdestinazione, binariorestituisci 0nosìnosìfiniti
Il tabellone da terminale

Passo per passo, con palestra/esempi/tabellone.csv:

irigaPezziDove va
1'M12,Piazza Query,2'3stdout: M12 per Piazza Query, binario 2
2'M14,Porta Codice,1'3stdout: M14 per Porta Codice, binario 1
3'M16,Ponte Ciclo'2stderr: Riga 4 ignorata: M16,Ponte Ciclo
4'M18,Largo Lista,2'3stdout: 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 sbagliatoCosa succedeIl test rosso
I due messaggi con print(...), senza file=sys.stderrGli avvisi finiscono su stdout, mescolati alle partenze: il tabellone mostrerebbe «Riga 4 ignorata» ai passeggeritest_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 rangetest_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.

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

Nel 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 sbagliatoCosa succedeIl test rosso
Nessuno strip()Le righe tengono l'a capo, e le righe vuote, che sono "\n", passano l'iftest_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.

Python
def campi(riga: str) -> list[str]:
    puliti = []
    for campo in riga.split(","):
        puliti.append(campo.strip())
    return puliti

Nel registro vero: campi("M12, sera, 22510, Ada") dà ['M12', 'sera', '22510', 'Ada'].

La trappola.

Il codice sbagliatoCosa succedeIl 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.

  1. Prendo le righe utili, senza la prima: l'intestazione.
  2. Per ogni riga, i campi.
  3. Se non sono quattro, o uno è vuoto: avviso su stderr e continue.
  4. Altrimenti li spacchetto e costruisco il dizionario della lettura.
Python
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 letture

Il disegno.

inizio leggi_letture(percorso) righe = righe_utili(percorso) letture = [] per ogni riga in righe[1:] valori = campi(riga) se len(valori) != 4 or "" in valori sì: mostra avviso su stderr no: letture.append(la lettura) restituisci lettureleggi_letture(percorso)righe =righe_utili(percorso)letture = []per ogni riga in righe[1:]valori = campi(riga)len(valori) != 4 or"" in valoriletture.append(la lettura)mostra avviso su stderrrestituisci letturenosìfiniti
Le righe rotte

"" 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,25033

Un 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 sbagliatoCosa succedeIl 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 valoriLa riga con il km vuoto passa, e nessuno la segnalatest_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.stderrGli avvisi finiscono su stdout, che doveva restare pulitotest_livello_3_le_righe_saltate_vanno_su_stderr

Livello 4 · I numeri scritti male

In italiano.

  1. Per ogni lettura provo a trasformare i km in intero.
  2. Se int() non ce la fa: avviso su stderr e continue.
  3. Se ce la fa: una copia della lettura, con i km in numero, va nella lista.
Python
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 buone

Il disegno. Una lettura e la sua copia, dopo nuova["km"] = km: due scatole, e la copia ha i km in numero.

lettura = {"treno": "M12", "momento": "sera", "km": "22510", "firma": "Ada"} nuova = {"treno": "M12", "momento": "sera", "km": 22510, "firma": "Ada"}letturanuovadict"treno""M12""momento""sera""km""22510""firma""Ada"dict"treno""M12""momento""sera""km"22510"firma""Ada"
La lettura e la copia con i km in numero

Il disegno.

inizio km_numerici(letture) buone = [] per ogni lettura in letture se int(lettura["km"]) dà ValueError sì: mostra avviso su stderr no: nuova = copia con km in numero buone.append(nuova) restituisci buonekm_numerici(letture)buone = []per ogni lettura in lettureint(lettura["km"])dà ValueErrornuova = copia con km innumerobuone.append(nuova)mostra avviso su stderrrestituisci buonenosìfiniti
I km scritti male

Passo per passo, su quattro letture del registro vero:

lettura["km"]int(...)Cosa succede
'18204 km'ValueErrorexcept: avviso, continue
'18204'18204Copia con "km": 18204, nella lista
'31.002'ValueErrorexcept: avviso, continue
'undicimila'ValueErrorexcept: 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 undicimila

La 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 sbagliatoCosa succedeIl test rosso
int(lettura["km"]) senza tryIl 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 intfloat accetta il punto: '31.002' diventa 31.002, trentun chilometri, mentre Gino ne intendeva trentunomila. La riga passa, sbagliata, e non viene segnalatatest_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.

  1. Primo giro: metto i km in due dizionari, sera e mattina, treno → km.
  2. Secondo giro, sui treni della sera: se c'è anche la lettura del mattino, calcolo mattina meno sera.
  3. Se sono più di MANOVRA_MASSIMA, il treno è uscito: va nel risultato, con i suoi km.
Python
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 mossi

Con 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:

TrenoSeraMattinaFattiPiù di 2?
M1118204182040No
M1222510225122No: è una manovra
M13, M14, M15, M16, M18——0No
M17143211435938Sì
M1911480manca—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 sbagliatoCosa succedeIl test rosso
fatti >= MANOVRA_MASSIMADue chilometri diventano un viaggio: nel registro vero spunta anche M12, che era solo andato al lavaggiotest_livello_5_due_km_sono_una_manovra
Nessun if treno in mattinaUn treno con la sola lettura della sera: KeyErrortest_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 2test_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.

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

Niente 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 Colombo

La trappola.

Il codice sbagliatoCosa succedeIl test rosso
json.loads(f)loads vuole una stringa, non un file aperto: TypeError: the JSON object must be str, bytes or bytearray, not TextIOWrappertest_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

  1. 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.
  2. 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.
  3. 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.

Terminale
python storia/verifica.py "Walter Bonomi"