Vai al contenuto
code-to-code

Apro l'indice…

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

Python7. Moduli e filep. 209

I registri del deposito

Un'indagine della Linea Menta, a sei livelli

  • 90–120 minuti di lavoro

Milano, notte tra il 9 e il 10 dicembre. Linea Menta.

Alle 03:10 un operaio della squadra lavori, fermo sui binari di Ponte Ciclo, vede passare un treno a luci spente. Di notte non dovrebbe muoversi niente: i treni dormono nei depositi, e il più vicino è quello di Vecchia Fiera.

Il commissario Mapelli va al deposito. Ogni sera e ogni mattina un guardiano legge il contachilometri di ogni treno e lo scrive in un registro, un file CSV. Se un treno ha fatto strada di notte, il registro lo sa.

Il problema è il programma del deposito, quello che dovrebbe leggerlo. Si ferma alla prima riga:

ValueError: invalid literal for int() with base 10: '18204 km'

«Un programma che si ferma alla prima riga rotta», dice Mapelli, «è un testimone che sviene alla prima domanda. Me ne serve uno che arrivi in fondo, e che mi dica cosa ha saltato.»

Gli esercizi da scaricare

Una cartella con i file da completare e i test già pronti. Come si usa: la guida in cinque passi.

python-moduli-e-file.zip20 KB

Lo zip è lo stesso della palestra: la storia è nella cartella storia/.

La notte

LA NOTTE AL DEPOSITO DI VECCHIA FIERA

  22:00            03:10                 05:00–05:30          05:40
    │                │                        │                 │
    ▼                ▼                        ▼                 ▼
 giro della      un treno a luci        giro del mattino:    i primi treni
 sera: Ada       spente passa da        Gino legge di        escono dal
 legge i km      Ponte Ciclo            nuovo i km           deposito

Prima delle 22:00 tutti i treni sono rientrati. Dentro il deposito un treno si può spostare al massimo di 2 km: il binario del lavaggio, l'officina. Di più, vuol dire che è uscito.

I file

FileCosa c'èSi tocca?
registro.csvIl registro dei contachilometri: treno, momento (sera o mattina), km, firmaNo, si legge
chiavi.jsonL'armadietto delle chiavi: chi ha preso o reso la chiave di ogni treno, e a che ora. L'ha scaricato la centrale dalla sua APINo, si legge
registri.pySei funzioni, una per livello. In fondo, il quaderno del commissarioSì, solo questo
test_registri.pyI test. Scrivono registri di prova in una cartella temporanea: nessun test ti dice la soluzioneNo
verifica.pyIl commissario controlla il nome che gli daiNo

Il registro l'hanno scritto a mano due guardiani. Ada Bassi, la sera, mette spazi dove capita. Gino Ferrario, la mattina, scrive i numeri come sugli assegni e ogni tanto dimentica un pezzo; quando se ne accorge, riscrive la riga giusta sotto, senza cancellare quella sbagliata. Una riga buona, letta e pulita, diventa un dizionario così:

Python
{"treno": "M12", "momento": "sera", "km": "22510", "firma": "Ada"}

Come si gioca

Un livello alla volta, sempre così:

  1. Leggi la domanda del commissario e la cosa nuova del livello.
  2. In registri.py, al posto di pass, scrivi la funzione.
  3. pytest storia -v -k livello_1 (poi livello_2, …) finché è verde.
  4. python storia/registri.py: il quaderno ti mostra cosa trovano le tue funzioni sul registro vero. Scrivi la risposta su un foglio.

Il quaderno trova registro.csv con Path(__file__).parent: funziona sia dalla cartella principale dello zip, sia da dentro storia/, sia con F5 in VS Code. Dal livello 3, nel terminale vedrai anche le righe saltate: arrivano su stderr. Se vuoi il quaderno senza avvisi, mandali in un file: python storia/registri.py 2> scarti.txt.


Livello 1 · Le righe vere

«Quante righe ha davvero, questo registro?»

righe_utili(percorso): le righe del file, senza a capo e senza spazi intorno, saltando quelle vuote.

La cosa nuova: niente di più della palestra. È l'esercizio 2, gli avvisi del giorno, su un altro file.

Aiutino 1
with open(percorso, encoding="utf-8") as f:, un for sulle righe, strip(). Una riga di soli spazi, dopo lo strip(), è "": si salta.

Livello 2 · I campi

«Ada mette gli spazi dove capita. Mi servono i campi puliti.»

campi(riga): la riga divisa alle virgole, ogni campo senza spazi intorno.

Python
campi(" M12 , sera, 22510 , Ada")   # ["M12", "sera", "22510", "Ada"]
campi("M13,sera,,Ada")              # ["M13", "sera", "", "Ada"]

La cosa nuova: lo strip() della riga intera non basta. Gli spazi stanno anche in mezzo, attaccati alle virgole: va fatto su ogni pezzo.

Aiutino 1
riga.split(",") dà la lista dei pezzi, ancora con gli spazi. Poi un setaccio senza if: lista vuota, for sui pezzi, append di ogni pezzo dopo lo strip().

Livello 3 · Le righe rotte

«Gino ogni tanto dimentica un pezzo. Quelle righe non le voglio. Ma voglio sapere quali sono.»

leggi_letture(percorso): un dizionario per ogni riga buona, con le chiavi treno, momento, km, firma. Usa righe_utili e campi. La prima riga utile è l'intestazione: non è una lettura.

Una riga si salta se non ha quattro campi, o se uno dei campi è vuoto. Prima di saltarla, la segnali su stderr:

Riga saltata, campi mancanti: M13,sera,,Ada

La cosa nuova: le righe rotte non fermano il programma e non spariscono in silenzio. Si dicono, sul canale giusto: print(..., file=sys.stderr), come nel tabellone della palestra.

Aiutino 1
righe_utili(percorso)[1:] ti dà le righe senza l'intestazione. Per ognuna, campi(riga). Le due condizioni del salto: len(valori) != 4 oppure "" in valori.
Aiutino 2
Quando i campi sono quattro e pieni, spacchettali: treno, momento, km, firma = valori. Poi il dizionario, e append. I km restano testo: li converte il livello 4.

Livello 4 · I numeri scritti male

«Undicimila. Scritto in lettere, nel registro. Questo programma deve sopravvivere anche a Gino.»

km_numerici(letture): le stesse letture, con i km trasformati in numeri interi. Una lettura con i km che non sono un intero ("31.002", "18204 km", "undicimila") si salta, e si segnala su stderr:

Km scritti male, riga saltata: M14 mattina 31.002

La cosa nuova: try ed except ValueError. Il campo è pieno, ma int() non lo capisce, e da solo fermerebbe tutto. Si prova, e se non va si passa oltre:

Python
try:
    km = int("31.002")
except ValueError:
    print("Non è un numero intero: salto la riga")
print("e il programma va avanti")
Non è un numero intero: salto la riga
e il programma va avanti

Python esegue il blocco try. Se una riga lì dentro fa scattare un ValueError, invece di fermarsi salta nel blocco except, e poi continua. Scrivi sempre il nome dell'errore: except ValueError prende solo quello, e tutti gli altri errori, i bug veri, restano visibili. Il resto (raise, il try piccolo, quando gestire e quando no) è nel capitolo try, except, raise.

Aiutino 1
Nel try metti solo la riga che può sbagliare: km = int(lettura["km"]). Nell'except, il print su stderr e continue: questa lettura no, alla prossima.
Aiutino 2
Dopo il try, km è sicuramente un numero. Crea un dizionario nuovo con dict(lettura), cambiagli "km", e append. Così le letture che hai ricevuto non cambiano.

Livello 5 · I treni che si sono mossi

«Chi ha fatto strada stanotte? E quanta?»

treni_mossi(letture): un dizionario treno → km fatti di notte (mattina meno sera), solo per i treni che hanno fatto più di MANOVRA_MASSIMA km. Un treno senza la lettura della sera, o senza quella del mattino, non si può confrontare: si salta.

La cosa nuova: niente di nuovo sui file. Due dizionari, uno per la sera e uno per il mattino, che poi si guardano: è il capitolo dei dizionari.

Aiutino 1
Primo giro: riempi sera e mattina, due dizionari treno → km, guardando lettura["momento"]. Secondo giro, sui treni di sera: se il treno è anche in mattina, fai la sottrazione.
Aiutino 2
Il test dice KeyError? Un treno ha una lettura sola: prima di mattina[treno], chiedi if treno in mattina. Il test della manovra è rosso? Due chilometri sono una manovra: serve >, non >=.

Livello 6 · La chiave

«Un treno non esce da solo. Ognuno ha la sua chiave, e l'armadietto registra chi la prende.»

movimenti_chiave(percorso, treno): dal file JSON dell'armadietto, la lista dei movimenti della chiave di quel treno, nell'ordine del file. Un movimento è un dizionario:

Python
{"ora": "21:10", "chiave": "M12", "persona": "Sergio Colombo", "azione": "resa"}

La cosa nuova: json.load. Il file l'ha scritto un programma, non una persona: è pulito, e json.load lo trasforma in una lista di dizionari in un colpo solo.

Aiutino 1
with open(...) as f: e movimenti = json.load(f). Poi un setaccio su movimento["chiave"].
Aiutino 2
the JSON object must be str, bytes or bytearray, not TextIOWrapper? Hai scritto json.loads, con la s: quello vuole una stringa. Con un file aperto, json.load.

Il finale

Il quaderno ti ha dato due cose: il treno che ha fatto strada di notte e i movimenti della sua chiave. Mettile accanto al disegno della notte.

  • Chi ha toccato la chiave prima del giro della sera? I suoi chilometri sono già nella lettura delle 22:00.
  • Chi l'ha presa dopo il giro del mattino? I suoi chilometri non sono nel registro.
  • Chi l'aveva in mano in mezzo, quando il treno è passato da Ponte Ciclo?

Quando hai un nome:

Terminale
python storia/verifica.py "Nome Cognome"

Se è sbagliato, per le piste più probabili il commissario ti dice dove hai preso la strada sbagliata.