Vai al contenuto
code-to-code

Apro l'indice…

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

Prontuario Python8. File e moduli

File e moduli

import, math, random, leggere e scrivere file con open e pathlib, csv, json e sys.argv

I moduli sono pezzi di Python già scritti: li prendi con import e li usi. I file servono a far ricordare qualcosa al programma anche dopo che è finito. Ogni voce dice a cosa serve, mostra un esempio da provare e la cosa da ricordare. Nel codice, # → dice cosa vale quella riga, o cosa stampa.

Gli esempi che leggono un file prima lo creano, nelle prime righe: così ognuno funziona da solo, anche in una cartella vuota. La spiegazione lunga è nel capitolo Moduli e file.

import

Porta nel programma un modulo: un file di Python pieno di funzioni pronte. Dopo l'import scrivi il nome del modulo, un punto e il nome della funzione.

Python
import math

math.sqrt(16)  # → 4.0
math.floor(7.8)  # → 7
sqrt(16)  # → NameError: name 'sqrt' is not defined

Gli import vanno in cima al file, una volta sola. Con import math il nome che hai in mano è math: le sue funzioni si chiamano sempre math.qualcosa.

Anche un tuo file è un modulo. Se nella stessa cartella c'è orari.py, da main.py lo prendi con import orari, senza .py:

Python
# orari.py
def prima_corsa(fermata):
    return "06:10"


# main.py, nella stessa cartella
import orari

print(orari.prima_corsa("Porta Codice"))

from … import e as

from prende dal modulo solo i nomi che ti servono, e li usi senza il prefisso. as dà al modulo (o al nome) un altro nome, di solito più corto.

Python
from math import sqrt, pi

sqrt(25)  # → 5.0
pi  # → 3.141592653589793

import statistics as st

st.mean([3, 0, 12, 5])  # → 5

Evita from math import *: porta dentro tutti i nomi del modulo, e poi non sai più da dove arriva cosa.

math

Le funzioni matematiche che non sono già pronte: radice quadrata, arrotondamenti sempre in giù o sempre in su, pi greco.

Python
import math

math.sqrt(2)  # → 1.4142135623730951
math.floor(7.8)  # → 7
math.ceil(7.2)  # → 8
math.pi  # → 3.141592653589793
round(math.pi, 2)  # → 3.14
math.sqrt(-1)  # → ValueError: math domain error

ceil serve quando «ne serve uno in più, anche se avanza posto». 45 passeggeri, 12 posti per carrozza:

Python
import math

passeggeri = 45
posti_per_carrozza = 12
passeggeri / posti_per_carrozza  # → 3.75
math.ceil(passeggeri / posti_per_carrozza)  # → 4

random

Scelte e numeri a caso. Con random.seed(…) fissi il punto di partenza: da lì il «caso» dà sempre gli stessi risultati, ed è comodo mentre provi e nei test.

Python
import random

random.seed(7)
random.choice(["Lucia", "Ivo", "Marta", "Sergio"])  # → 'Marta'
random.randint(1, 6)  # → 2

fermate = ["Porta Codice", "Via Variabile", "Largo Lista", "Ponte Ciclo"]
random.shuffle(fermate)
fermate  # → ['Via Variabile', 'Porta Codice', 'Largo Lista', 'Ponte Ciclo']

choice pesca un elemento da una lista. randint(1, 6) dà un intero da 1 a 6, compresi tutti e due (non come range). shuffle mescola la lista stessa. Senza seed ogni esecuzione dà risultati diversi: è quello che vuoi nel programma vero.

Python
import random

fermate = ["Porta Codice", "Via Variabile", "Largo Lista"]
fermate = random.shuffle(fermate)
fermate  # → None

with open() per leggere

open apre un file, with lo richiude da solo quando il blocco finisce, anche se nel mezzo c'è un errore. read() ti dà tutto il file in una stringa sola.

Python
# Prima creiamo il file da leggere.
with open("orari.txt", "w", encoding="utf-8") as f:
    f.write("Porta Codice 06:10\nVia Variabile 06:13\nLargo Lista 06:17\n")

with open("orari.txt", encoding="utf-8") as f:
    testo = f.read()

testo  # → 'Porta Codice 06:10\nVia Variabile 06:13\nLargo Lista 06:17\n'
print(testo)
# → Porta Codice 06:10
# → Via Variabile 06:13
# → Largo Lista 06:17
testo.splitlines()  # → ['Porta Codice 06:10', 'Via Variabile 06:13', 'Largo Lista 06:17']

encoding="utf-8" mettilo sempre: senza, su qualche computer le lettere accentate escono storpiate. splitlines() divide il testo in righe e toglie gli a capo.

Se il file non c'è, arriva un FileNotFoundError: il percorso è cercato a partire dalla cartella da cui lanci il programma. Nella voce pathlib e Path trovi come partire dalla cartella del tuo file.

Leggere riga per riga

Un file aperto si può scorrere con un for: una riga per giro. Ogni riga arriva con il suo a capo \n in fondo.

Python
with open("orari.txt", "w", encoding="utf-8") as f:
    f.write("Porta Codice 06:10\nVia Variabile 06:13\nLargo Lista 06:17\n")

with open("orari.txt", encoding="utf-8") as f:
    for riga in f:
        print(riga)
# → Porta Codice 06:10
# →
# → Via Variabile 06:13
# →
# → Largo Lista 06:17

Le righe vuote in mezzo ci sono perché la riga ha già il suo a capo, e print ne aggiunge un altro. Con strip() togli spazi e a capo all'inizio e alla fine:

Python
with open("orari.txt", "w", encoding="utf-8") as f:
    f.write("Porta Codice 06:10\nVia Variabile 06:13\nLargo Lista 06:17\n")

with open("orari.txt", encoding="utf-8") as f:
    for riga in f:
        print(riga.strip())
# → Porta Codice 06:10
# → Via Variabile 06:13
# → Largo Lista 06:17

with open("orari.txt", encoding="utf-8") as f:
    righe = [riga.strip() for riga in f]

righe  # → ['Porta Codice 06:10', 'Via Variabile 06:13', 'Largo Lista 06:17']

Scrivere un file: w e a

Il secondo argomento di open dice cosa vuoi fare. "w" (write) crea il file, oppure lo svuota se c'era già. "a" (append) scrive in fondo, senza toccare quello che c'è.

Python
with open("ritardi.txt", "w", encoding="utf-8") as f:
    f.write("T-07 3\n")
    f.write("T-12 0\n")

with open("ritardi.txt", "a", encoding="utf-8") as f:
    f.write("T-03 12\n")

with open("ritardi.txt", encoding="utf-8") as f:
    print(f.read())
# → T-07 3
# → T-12 0
# → T-03 12

with open("ritardi.txt", "w", encoding="utf-8") as f:
    f.write("T-05 1\n")

with open("ritardi.txt", encoding="utf-8") as f:
    print(f.read())
# → T-05 1

Con il secondo "w" le tre righe di prima sono sparite. Se vuoi aggiungere, usa "a".

Python
with open("ritardi.txt", "w", encoding="utf-8") as f:
    f.write(12)
# → TypeError: write() argument must be str, not int

with open("ritardi.txt", "w", encoding="utf-8") as f:
    f.write("T-07 " + str(3) + "\n")
    print("T-12", 0, file=f)

with open("ritardi.txt", encoding="utf-8") as f:
    testo = f.read()

testo  # → 'T-07 3\nT-12 0\n'

pathlib e Path

Path è un percorso di file con dei metodi comodi: c'è? leggilo, scrivilo, come si chiama. Per i file piccoli ti risparmia il with open.

Python
from pathlib import Path

orari = Path("orari.txt")
orari.exists()  # → False
orari.write_text("Porta Codice 06:10\n", encoding="utf-8")  # → 19
orari.exists()  # → True
orari.read_text(encoding="utf-8")  # → 'Porta Codice 06:10\n'
orari.name  # → 'orari.txt'
orari.stem  # → 'orari'
orari.suffix  # → '.txt'

cartella = Path("dati")
print(cartella / "orari.txt")  # → dati/orari.txt

write_text scrive tutto il file in un colpo (come "w": quello che c'era sparisce) e restituisce quanti caratteri ha scritto. La / tra un Path e una stringa unisce i pezzi del percorso.

Un percorso come "orari.txt" parte dalla cartella da cui lanci il programma, non da quella dove sta il file .py: se lanci da un'altra cartella, arriva un FileNotFoundError. Per partire sempre dalla cartella del tuo programma:

Python
from pathlib import Path

CARTELLA = Path(__file__).parent
orari = CARTELLA / "orari.txt"
testo = orari.read_text(encoding="utf-8")

__file__ è il percorso del file .py che sta girando, .parent la sua cartella. Funziona solo dentro un file: nel terminale interattivo di Python __file__ non c'è.

csv.reader

Legge un file CSV (valori separati da virgole, una riga per riga di tabella). Ogni riga diventa una lista di stringhe.

Python
import csv

with open("ritardi.csv", "w", encoding="utf-8") as f:
    f.write("treno,fermata,minuti\nT-07,Porta Codice,3\nT-12,Largo Lista,0\nT-03,Ponte Ciclo,12\n")

with open("ritardi.csv", encoding="utf-8", newline="") as f:
    righe = list(csv.reader(f))

righe[0]  # → ['treno', 'fermata', 'minuti']
righe[1]  # → ['T-07', 'Porta Codice', '3']
int(righe[1][2]) + 1  # → 4

with open("ritardi.csv", encoding="utf-8", newline="") as f:
    lettore = csv.reader(f)
    next(lettore)
    for treno, fermata, minuti in lettore:
        print(treno, "a", fermata, "con", minuti, "minuti")
# → T-07 a Porta Codice con 3 minuti
# → T-12 a Largo Lista con 0 minuti
# → T-03 a Ponte Ciclo con 12 minuti

Anche i numeri arrivano come testo: '3', non 3. Per fare i conti serve int. La prima riga è l'intestazione: next(lettore) la salta.

csv.DictReader

Come reader, ma ogni riga diventa un dizionario, con le chiavi prese dall'intestazione. Quando le colonne sono tante, riga["minuti"] si legge meglio di riga[2].

Python
import csv

with open("ritardi.csv", "w", encoding="utf-8") as f:
    f.write("treno,fermata,minuti\nT-07,Porta Codice,3\nT-12,Largo Lista,0\nT-03,Ponte Ciclo,12\n")

with open("ritardi.csv", encoding="utf-8", newline="") as f:
    righe = list(csv.DictReader(f))

len(righe)  # → 3
righe[0]  # → {'treno': 'T-07', 'fermata': 'Porta Codice', 'minuti': '3'}
righe[0]["fermata"]  # → 'Porta Codice'
[r["treno"] for r in righe if int(r["minuti"]) > 5]  # → ['T-03']

L'intestazione non è tra le righe: è diventata le chiavi. Come si lavora con i dizionari è nella pagina Dizionari.

Python
import csv

with open("spazi.csv", "w", encoding="utf-8") as f:
    f.write("treno, minuti\nT-07, 3\n")

with open("spazi.csv", encoding="utf-8", newline="") as f:
    righe = list(csv.DictReader(f))

righe[0]  # → {'treno': 'T-07', ' minuti': ' 3'}
righe[0]["minuti"]  # → KeyError: 'minuti'

csv.writer

Scrive un file CSV. writerow scrive una riga (una lista), writerows tante righe (una lista di liste).

Python
import csv

with open("uscita.csv", "w", encoding="utf-8", newline="") as f:
    scrittore = csv.writer(f)
    scrittore.writerow(["treno", "fermata", "minuti"])
    scrittore.writerow(["T-07", "Porta Codice", 3])
    scrittore.writerows([["T-12", "Largo Lista", 0], ["T-03", "Ponte Ciclo, binario 2", 12]])

with open("uscita.csv", encoding="utf-8") as f:
    print(f.read())
# → treno,fermata,minuti
# → T-07,Porta Codice,3
# → T-12,Largo Lista,0
# → T-03,"Ponte Ciclo, binario 2",12

I numeri li trasforma in testo da solo. Il campo con la virgola dentro finisce tra virgolette, così chi legge il file non lo spezza in due: è il motivo per usare csv invece di attaccare le stringhe con ",". Per scrivere dizionari c'è csv.DictWriter, il gemello di DictReader.

json.dumps e json.loads

JSON è il formato di testo con cui i programmi si scambiano dati, per esempio le API. json.dumps trasforma un valore di Python in una stringa JSON, json.loads fa il contrario. La «s» finale sta per string.

Python
import json

treno = {"codice": "T-07", "fermate": ["Porta Codice", "Largo Lista"], "in_servizio": True, "ritardo": None}
testo = json.dumps(treno)
testo  # → '{"codice": "T-07", "fermate": ["Porta Codice", "Largo Lista"], "in_servizio": true, "ritardo": null}'
type(testo)  # → <class 'str'>

di_nuovo = json.loads(testo)
di_nuovo["fermate"][1]  # → 'Largo Lista'
di_nuovo == treno  # → True

In JSON True diventa true, None diventa null, e le stringhe vogliono le virgolette doppie:

Python
import json

json.loads('{"minuti": 3}')  # → {'minuti': 3}
json.loads("{'minuti': 3}")  # → JSONDecodeError: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)
print(json.dumps({"avviso": "è in ritardo"}))  # → {"avviso": "\u00e8 in ritardo"}
print(json.dumps({"avviso": "è in ritardo"}, ensure_ascii=False))  # → {"avviso": "è in ritardo"}

Le lettere accentate, senza ensure_ascii=False, diventano codici come \u00e8: è sempre JSON valido, ma non si legge.

Python
import json

json.loads(json.dumps({7: "T-07", "orari": ("06:10", "06:25")}))  # → {'7': 'T-07', 'orari': ['06:10', '06:25']}

json.dump e json.load

Senza la «s»: scrivono e leggono direttamente un file aperto. In json.dump(valore, f) prima c'è cosa salvare, poi dove.

Python
import json

treno = {"codice": "T-07", "fermate": ["Porta Codice", "Largo Lista"], "ritardo": 3}

with open("treno.json", "w", encoding="utf-8") as f:
    json.dump(treno, f, indent=2, ensure_ascii=False)

with open("treno.json", encoding="utf-8") as f:
    letto = json.load(f)

letto  # → {'codice': 'T-07', 'fermate': ['Porta Codice', 'Largo Lista'], 'ritardo': 3}
letto == treno  # → True

Con indent=2 il file va a capo e si legge bene anche a occhio. Dentro treno.json c'è:

{
  "codice": "T-07",
  "fermate": [
    "Porta Codice",
    "Largo Lista"
  ],
  "ritardo": 3
}
Python
import json

with open("vuoto.json", "w", encoding="utf-8") as f:
    pass

with open("vuoto.json", encoding="utf-8") as f:
    json.load(f)
# → JSONDecodeError: Expecting value: line 1 column 1 (char 0)

sys.argv

La lista delle parole scritte nel terminale per lanciare il programma. Il primo elemento è il nome del file, poi vengono gli argomenti, sempre come stringhe.

Python
# saluta.py
import sys

print(sys.argv)
nome = sys.argv[1]
volte = int(sys.argv[2])
for _ in range(volte):
    print("Ciao,", nome)
Terminale
python saluta.py Lucia 2
['saluta.py', 'Lucia', '2']
Ciao, Lucia
Ciao, Lucia

Se lanci python saluta.py senza argomenti, sys.argv è solo ['saluta.py'] e sys.argv[1] dà IndexError: list index out of range. Controlla prima len(sys.argv).

Il programma principale

if __name__ == "__main__": separa le righe che devono partire solo quando lanci il file da quelle che servono anche a chi lo importa.

Python
def annuncio(fermata):
    return f"Prossima fermata: {fermata}"


if __name__ == "__main__":
    print(annuncio("Ponte Ciclo"))
# → Prossima fermata: Ponte Ciclo

__name__  # → '__main__'

Se questo file si chiama annunci.py e lo lanci con python annunci.py, __name__ vale "__main__" e il blocco parte. Se invece un altro file fa import annunci, o pytest lo importa per i test, lì __name__ vale "annunci": la funzione c'è, ma il blocco non parte.