Vai al contenuto
code-to-code

Apro l'indice…

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

Python7. Moduli e filep. 198

Moduli e file, esercizi spiegati

Cinque esempi, una riga alla volta

  • 25 minuti di lettura

Cinque esempi, dal più semplice. Ognuno ha lo stesso ritmo:

  1. Prevedi: leggi il codice e scrivi su un foglio cosa stampa. Prima di aprire la risposta.
  2. In italiano: cosa fa il programma, a parole.
  3. Passo per passo: cosa succede a ogni riga, o a ogni giro.
  4. Cosa portiamo a casa: la cosa da ricordare.

Qui serve un file vero, non basta il terminale di Python: crea una cartella di prova, aprila in VS Code, scrivi i file dell'esempio e lancia il programma dal terminale di VS Code. Così la cartella da cui lanci è proprio quella.


A · Il modulo delle tariffe

La biglietteria di Porta Codice ha diviso il suo programma in due file, nella stessa cartella. In tariffe.py qualcuno ha lasciato un print in cima.

Python
# tariffe.py
PREZZO_CORSA = 2.2

print("tariffe.py: __name__ vale", __name__)


def prezzo(corse: int) -> float:
    return round(corse * PREZZO_CORSA, 2)


if __name__ == "__main__":
    print("Prova:", prezzo(3))
Python
# cassa.py
from tariffe import prezzo

print("cassa.py: __name__ vale", __name__)
print("Due corse:", prezzo(2))

Cosa stampa python cassa.py? E python tariffe.py?

Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
$ python cassa.py
tariffe.py: __name__ vale tariffe
cassa.py: __name__ vale __main__
Due corse: 4.4

$ python tariffe.py
tariffe.py: __name__ vale __main__
Prova: 6.6
  • La prima riga di python cassa.py arriva da tariffe.py: l'import esegue tutto il modulo, print compreso.
  • Importato, tariffe.py ha __name__ uguale a "tariffe": il blocco in fondo non parte, e «Prova» non c'è.
  • Lanciato da solo, tariffe.py è il programma: __name__ vale "__main__", e il blocco parte.

In italiano, python cassa.py:

  1. L'import chiede prezzo a tariffe: Python cerca tariffe.py nella cartella di cassa.py e lo esegue dall'alto.
  2. Dentro tariffe.py crea la costante, stampa la sua riga, crea la funzione e salta il blocco in fondo.
  3. Torna in cassa.py, che adesso conosce prezzo, e va avanti.

Passo per passo.

PassoDoveCosa faCosa stampa
1cassa.py, l'importfrom tariffe import prezzo: va a eseguire tariffe.py—
2tariffe.pyPREZZO_CORSA = 2.2—
3tariffe.pyIl print in cima: qui __name__ è "tariffe"tariffe.py: __name__ vale tariffe
4tariffe.pydef prezzo: crea la funzione, non la esegue—
5tariffe.py"tariffe" == "__main__" è falso: il blocco si salta—
6cassa.py, il primo printQui __name__ è "__main__"cassa.py: __name__ vale __main__
7cassa.py, il secondo printprezzo(2): 2 × 2.2Due corse: 4.4

Cosa portiamo a casa. Un print lasciato in cima a un modulo parte a ogni import, anche quando pytest importa il tuo file per i test. Le prove vanno sempre dentro if __name__ == "__main__":.


B · Il diario del capostazione

A Largo Lista il capostazione tiene un diario della giornata. Il programma lo scrive, ci aggiunge una riga e lo rilegge.

Python
with open("diario.txt", "w", encoding="utf-8") as f:
    f.write("06:00 apertura\n")
    f.write("06:12 primo treno\n")

with open("diario.txt", "a", encoding="utf-8") as f:
    f.write("06:30 ascensore guasto\n")

with open("diario.txt", encoding="utf-8") as f:
    for riga in f:
        print(riga)
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
06:00 apertura

06:12 primo treno

06:30 ascensore guasto

Le tre righe ci sono tutte, ma tra una e l'altra c'è una riga vuota (e un'altra in fondo). Ogni riga letta finisce con il suo \n, e print ci aggiunge il suo: due a capo.

In italiano.

  1. Apro il diario in scrittura ("w"): se c'era, si svuota. Scrivo due righe, ognuna con il suo \n.
  2. Lo riapro in aggiunta ("a"): la terza riga va in fondo, le prime due restano.
  3. Lo riapro in lettura e stampo le righe, una per giro.

Passo per passo. Cosa c'è nel file dopo ogni blocco:

BloccoModoIl file dopo il blocco
1"w"06:00 apertura\n06:12 primo treno\n
2"a"06:00 apertura\n06:12 primo treno\n06:30 ascensore guasto\n
3letturaUguale: leggere non cambia niente

E i giri del for, nel terzo blocco:

Girorigaprint(riga) scrive
1'06:00 apertura\n'il testo, l'a capo della riga, l'a capo di print
2'06:12 primo treno\n'lo stesso
3'06:30 ascensore guasto\n'lo stesso

La correzione. Si toglie l'a capo prima di stampare:

Python
with open("diario.txt", encoding="utf-8") as f:
    for riga in f:
        print(riga.strip())
06:00 apertura
06:12 primo treno
06:30 ascensore guasto

E se anche il secondo blocco avesse "w" al posto di "a"? Il diario conterrebbe una riga sola, 06:30 ascensore guasto: aprire con "w" cancella tutto, prima ancora di scrivere.

Cosa portiamo a casa. L'a capo è un carattere come gli altri: write non lo aggiunge, la lettura lo conserva, print ne aggiunge un altro. E "w" vuol dire «ricomincia da zero»: per allungare un file, "a".


C · Le salite del mattino

Il contapersone della Linea Menta scrive un CSV: a che ora, in che stazione, quante persone sono salite. In fondo c'è una riga vuota.

ora,stazione,salite
07:00,Porta Codice,120
07:00,Largo Lista,45
07:30,Porta Codice,80
07:30,Ponte Ciclo,60

Il programma somma le salite stazione per stazione.

Python
salite = {}
with open("salite.csv", 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
    ora, stazione, quante = riga.split(",")
    salite[stazione] = salite.get(stazione, 0) + int(quante)

print(salite)
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
{'Porta Codice': 200, 'Largo Lista': 45, 'Ponte Ciclo': 60}

Il disegno. Alla fine del programma:

salite = {"Porta Codice": 200, "Largo Lista": 45, "Ponte Ciclo": 60}salitedict"Porta Codice"200"Largo Lista"45"Ponte Ciclo"60
Dopo l'ultimo giro

In italiano.

  1. Leggo tutte le righe in una lista.
  2. Salto la prima: è l'intestazione, non un conteggio.
  3. Per ogni riga tolgo l'a capo. Se resta vuota, la salto.
  4. La divido alle virgole in tre pezzi: ora, stazione, quante.
  5. Aggiungo quante, diventato un numero, al totale della stazione. È lo schema «contare» del capitolo dei dizionari, con un numero al posto di 1.

Il disegno.

inizio salite = {} passo righe = f.readlines() per ogni riga in righe[1:] riga = riga.strip() se riga == "" sì: passo si salta, giro dopo no: ora, stazione, quante = riga.split(",") salite[stazione] + int(quante) mostra print(salite)salite = {}righe = f.readlines()per ogni riga in righe[1:]riga = riga.strip()riga == ""ora, stazione, quante =riga.split(",")salite[stazione] +int(quante)si salta, giro dopomostra print(salite)nosìfiniti
Il giro sulle righe del CSV

Passo per passo. righe è ['ora,stazione,salite\n', '07:00,Porta Codice,120\n', …, '\n']; il for parte dalla seconda.

Giroriga dopo strip()stazione, quantesalite dopo il giro
1'07:00,Porta Codice,120''Porta Codice', '120'{'Porta Codice': 120}
2'07:00,Largo Lista,45''Largo Lista', '45'{'Porta Codice': 120, 'Largo Lista': 45}
3'07:30,Porta Codice,80''Porta Codice', '80'{'Porta Codice': 200, 'Largo Lista': 45}
4'07:30,Ponte Ciclo,60''Ponte Ciclo', '60'{…, 'Ponte Ciclo': 60}
5''—continue: non cambia niente

Cosa portiamo a casa. Le quattro mosse del CSV a mano, sempre in quest'ordine: salta l'intestazione, strip(), split(","), int().


D · La virgola di troppo

I passeggeri lasciano segnalazioni sul sito della Linea Menta, e il sito le esporta in un CSV. Una segnalazione contiene una virgola, quindi sta tra virgolette.

stazione,segnalazione
Largo Lista,"scala mobile ferma, uscita A"
Ponte Ciclo,biglietteria chiusa

Prima a mano, come nell'esempio C:

Python
with open("segnalazioni.csv", encoding="utf-8") as f:
    righe = f.readlines()

for riga in righe[1:]:
    print(riga.strip().split(","))
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
['Largo Lista', '"scala mobile ferma', ' uscita A"']
['Ponte Ciclo', 'biglietteria chiusa']

split(",") non sa niente di virgolette: taglia a ogni virgola. La prima segnalazione diventa due pezzi, con le virgolette attaccate.

Adesso con il modulo csv:

Python
import csv

with open("segnalazioni.csv", encoding="utf-8") as f:
    for riga in csv.DictReader(f):
        print(riga["stazione"], "→", riga["segnalazione"])
Largo Lista → scala mobile ferma, uscita A
Ponte Ciclo → biglietteria chiusa

Il disegno. Il dizionario del primo giro:

riga = {"stazione": "Largo Lista", "segnalazione": "scala mobile ferma, uscita A"}rigadict"stazione""Largo Lista""segnalazione""scala mobile ferma, uscita A"
La riga del primo giro

In italiano.

  1. Apro il file, come sempre.
  2. csv.DictReader legge la prima riga e la usa come intestazione: le chiavi saranno stazione e segnalazione.
  3. Per ogni riga dopo, mi dà un dizionario. Le virgole tra virgolette restano dentro il campo, e le virgolette spariscono.
  4. Leggo i campi per nome, come in qualsiasi dizionario.

Passo per passo.

GirorigaCosa stampa
1{'stazione': 'Largo Lista', 'segnalazione': 'scala mobile ferma, uscita A'}Largo Lista → scala mobile ferma, uscita A
2{'stazione': 'Ponte Ciclo', 'segnalazione': 'biglietteria chiusa'}Ponte Ciclo → biglietteria chiusa

Con DictReader non c'è niente da saltare: l'intestazione l'ha già usata lui. E non serve strip() sull'ultimo campo: l'a capo lo toglie il modulo.

Cosa portiamo a casa. Se un campo è testo libero (una descrizione, un indirizzo, una segnalazione), prima o poi ci finisce una virgola: usa csv. I valori restano testo: un numero va comunque convertito con int().


E · Lanciato dalla cartella sbagliata

Un programmino conta le righe di un file. Il file glielo dai tu, dal terminale. Le cartelle sono queste:

~/linea-menta/
├── dati/
│   └── salite.csv        (5 righe, senza la riga vuota in fondo)
└── programmi/
    └── conta_righe.py
Python
# programmi/conta_righe.py
import sys


def conta_righe(percorso: str) -> int:
    with open(percorso, encoding="utf-8") as f:
        righe = f.readlines()
    return len(righe)


if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Si usa così: python conta_righe.py <file>", file=sys.stderr)
        sys.exit(1)
    percorso = sys.argv[1]
    print(f"{percorso}: {conta_righe(percorso)} righe")

Quattro comandi, uno dopo l'altro:

Terminale
cd ~/linea-menta
python programmi/conta_righe.py dati/salite.csv       # 1
cd programmi
python conta_righe.py dati/salite.csv                 # 2
python conta_righe.py ../dati/salite.csv              # 3
python conta_righe.py                                 # 4

Quali funzionano? Cosa stampano gli altri?

Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
1 ·  dati/salite.csv: 5 righe
2 ·  FileNotFoundError: [Errno 2] No such file or directory: 'dati/salite.csv'
3 ·  ../dati/salite.csv: 5 righe
4 ·  Si usa così: python conta_righe.py <file>
  • La 2 è l'ultima riga del traceback. Il programma è lo stesso della 1, il comando quasi: è cambiata solo la cartella da cui lanci.
  • La 3 funziona perché .. vuol dire «la cartella sopra»: da programmi si sale a linea-menta, poi si scende in dati.
  • La 4 non ha il file: il messaggio esce su stderr, e sys.exit(1) ferma il programma.

In italiano.

  1. Se negli argomenti c'è solo il nome del programma, spiego come si usa, su stderr, ed esco con 1.
  2. Altrimenti prendo il percorso da sys.argv[1], apro il file, conto le righe e stampo il risultato su stdout.

Il disegno.

inizio python conta_righe.py <file> se len(sys.argv) < 2 sì: mostra messaggio su stderr fine esce con 1 percorso = sys.argv[1] mostra percorso e numero di righepython conta_righe.py <file>len(sys.argv) < 2mostra messaggio su stderresce con 1percorso = sys.argv[1]mostra percorso e numero dirighenosì
Il programma conta_righe.py

Passo per passo.

#Terminale insys.argvopen cercaRisultato
1~/linea-menta['programmi/conta_righe.py', 'dati/salite.csv']~/linea-menta/dati/salite.csvLo trova: 5 righe
2~/linea-menta/programmi['conta_righe.py', 'dati/salite.csv']~/linea-menta/programmi/dati/salite.csvNon c'è: FileNotFoundError
3~/linea-menta/programmi['conta_righe.py', '../dati/salite.csv']~/linea-menta/dati/salite.csvLo trova: 5 righe
4~/linea-menta/programmi['conta_righe.py']—len(sys.argv) è 1: messaggio su stderr, uscita con 1

stdout e stderr, alla prova. Torna in ~/linea-menta e manda l'uscita in un file:

$ python programmi/conta_righe.py dati/salite.csv > conteggio.txt
$ cat conteggio.txt
dati/salite.csv: 5 righe
$ python programmi/conta_righe.py > conteggio.txt
Si usa così: python conta_righe.py <file>

Nel primo caso sullo schermo non compare niente: il risultato è andato nel file. Nel secondo il messaggio compare lo stesso, perché viaggia su stderr; conteggio.txt invece resta vuoto, perché > l'ha svuotato aprendolo, proprio come "w".

E per un file che il programma si porta dietro? Se accanto a conta_righe.py ci fosse fermate.txt, sempre lo stesso, il percorso si costruisce dalla cartella del programma:

Python
from pathlib import Path

percorso = Path(__file__).parent / "fermate.txt"

Con Path(__file__).parent, il programma trova fermate.txt sia da ~/linea-menta sia da ~/linea-menta/programmi, sia da qualsiasi altra cartella.

Cosa portiamo a casa. Un FileNotFoundError con un percorso relativo, quasi sempre, non è un errore nel codice: è la cartella da cui lanci. Prima di toccare il programma, guarda dove sei (pwd) e rileggi il percorso partendo da lì.


Pronto? Gli stessi schemi ti aspettano nella palestra: sei esercizi da scaricare, con i test.