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.
import math
math.sqrt(16) # → 4.0
math.floor(7.8) # → 7
sqrt(16) # → NameError: name 'sqrt' is not definedGli 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:
# 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.
from math import sqrt, pi
sqrt(25) # → 5.0
pi # → 3.141592653589793
import statistics as st
st.mean([3, 0, 12, 5]) # → 5Evita 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.
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 errorceil serve quando «ne serve uno in più, anche se avanza posto». 45 passeggeri, 12 posti per carrozza:
import math
passeggeri = 45
posti_per_carrozza = 12
passeggeri / posti_per_carrozza # → 3.75
math.ceil(passeggeri / posti_per_carrozza) # → 4random
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.
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.
import random
fermate = ["Porta Codice", "Via Variabile", "Largo Lista"]
fermate = random.shuffle(fermate)
fermate # → Nonewith 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.
# 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.
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:17Le 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:
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'è.
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 1Con il secondo "w" le tre righe di prima sono sparite. Se vuoi aggiungere, usa "a".
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.
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.txtwrite_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:
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.
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 minutiAnche 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].
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.
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).
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",12I 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.
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 # → TrueIn JSON True diventa true, None diventa null, e le stringhe vogliono le virgolette doppie:
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.
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.
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 # → TrueCon 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
}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.
# saluta.py
import sys
print(sys.argv)
nome = sys.argv[1]
volte = int(sys.argv[2])
for _ in range(volte):
print("Ciao,", nome)python saluta.py Lucia 2['saluta.py', 'Lucia', '2']
Ciao, Lucia
Ciao, LuciaSe 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.
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.