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:
- Prevedi: leggi il codice e scrivi su un foglio cosa stampa. Prima di aprire la risposta.
- In italiano: cosa fa il programma, a parole.
- Passo per passo: cosa succede a ogni riga, o a ogni giro.
- 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.
# 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))# 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.pyarriva datariffe.py: l'import esegue tutto il modulo,printcompreso. - Importato,
tariffe.pyha__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:
- L'import chiede
prezzoatariffe: Python cercatariffe.pynella cartella dicassa.pye lo esegue dall'alto. - Dentro
tariffe.pycrea la costante, stampa la sua riga, crea la funzione e salta il blocco in fondo. - Torna in
cassa.py, che adesso conosceprezzo, e va avanti.
Passo per passo.
| Passo | Dove | Cosa fa | Cosa stampa |
|---|---|---|---|
| 1 | cassa.py, l'import | from tariffe import prezzo: va a eseguire tariffe.py | — |
| 2 | tariffe.py | PREZZO_CORSA = 2.2 | — |
| 3 | tariffe.py | Il print in cima: qui __name__ è "tariffe" | tariffe.py: __name__ vale tariffe |
| 4 | tariffe.py | def prezzo: crea la funzione, non la esegue | — |
| 5 | tariffe.py | "tariffe" == "__main__" è falso: il blocco si salta | — |
| 6 | cassa.py, il primo print | Qui __name__ è "__main__" | cassa.py: __name__ vale __main__ |
| 7 | cassa.py, il secondo print | prezzo(2): 2 × 2.2 | Due 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.
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 guastoLe 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.
- Apro il diario in scrittura (
"w"): se c'era, si svuota. Scrivo due righe, ognuna con il suo\n. - Lo riapro in aggiunta (
"a"): la terza riga va in fondo, le prime due restano. - Lo riapro in lettura e stampo le righe, una per giro.
Passo per passo. Cosa c'è nel file dopo ogni blocco:
| Blocco | Modo | Il 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 |
| 3 | lettura | Uguale: leggere non cambia niente |
E i giri del for, nel terzo blocco:
| Giro | riga | print(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:
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 guastoE 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.
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:
In italiano.
- Leggo tutte le righe in una lista.
- Salto la prima: è l'intestazione, non un conteggio.
- Per ogni riga tolgo l'a capo. Se resta vuota, la salto.
- La divido alle virgole in tre pezzi: ora, stazione, quante.
- 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.
Passo per passo. righe è ['ora,stazione,salite\n', '07:00,Porta Codice,120\n', …, '\n']; il for parte dalla seconda.
| Giro | riga dopo strip() | stazione, quante | salite 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 chiusaPrima a mano, come nell'esempio C:
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:
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 chiusaIl disegno. Il dizionario del primo giro:
In italiano.
- Apro il file, come sempre.
csv.DictReaderlegge la prima riga e la usa come intestazione: le chiavi sarannostazioneesegnalazione.- Per ogni riga dopo, mi dà un dizionario. Le virgole tra virgolette restano dentro il campo, e le virgolette spariscono.
- Leggo i campi per nome, come in qualsiasi dizionario.
Passo per passo.
| Giro | riga | Cosa 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# 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:
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 # 4Quali 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»: daprogrammisi sale alinea-menta, poi si scende indati. - La 4 non ha il file: il messaggio esce su stderr, e
sys.exit(1)ferma il programma.
In italiano.
- Se negli argomenti c'è solo il nome del programma, spiego come si usa, su stderr, ed esco con 1.
- Altrimenti prendo il percorso da
sys.argv[1], apro il file, conto le righe e stampo il risultato su stdout.
Il disegno.
Passo per passo.
| # | Terminale in | sys.argv | open cerca | Risultato |
|---|---|---|---|---|
| 1 | ~/linea-menta | ['programmi/conta_righe.py', 'dati/salite.csv'] | ~/linea-menta/dati/salite.csv | Lo trova: 5 righe |
| 2 | ~/linea-menta/programmi | ['conta_righe.py', 'dati/salite.csv'] | ~/linea-menta/programmi/dati/salite.csv | Non c'è: FileNotFoundError |
| 3 | ~/linea-menta/programmi | ['conta_righe.py', '../dati/salite.csv'] | ~/linea-menta/dati/salite.csv | Lo 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:
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.