Le classi
class, self, attributi e metodi, repr e str, ereditarietà, super, isinstance, dataclass e il ponte con Pydantic
Una classe è lo stampo, un oggetto è una cosa fatta con quello stampo. La classe Treno dice che ogni treno ha un codice e un ritardo, e cosa sa fare; Treno("T-07") è un treno vero. 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.
La spiegazione lunga è nei capitoli Classi e oggetti ed Ereditarietà.
class e il costruttore
class crea lo stampo. Il metodo __init__ (due trattini bassi prima e dopo) è il costruttore: parte da solo quando crei un oggetto con Treno(...) e gli dà i suoi primi valori.
class Treno:
def __init__(self, codice, linea):
self.codice = codice
self.linea = linea
self.ritardo = 0
t7 = Treno("T-07", "Menta")
t7.codice # → 'T-07'
t7.linea # → 'Menta'
t7.ritardo # → 0
type(t7) # → <class '__main__.Treno'>
Treno("T-12") # → TypeError: Treno.__init__() missing 1 required positional argument: 'linea'Il nome della classe ha l'iniziale maiuscola. Gli argomenti di Treno("T-07", "Menta") arrivano a codice e linea; il primo parametro, self, lo riempie Python.
self
self è l'oggetto su cui stai lavorando. Quando scrivi la classe non sai ancora se sarà il T-07 o il T-12: scrivi self, e a ogni chiamata Python ci mette l'oggetto giusto.
class Treno:
def __init__(self, codice):
self.codice = codice
self.ritardo = 0
def ritarda(self, minuti):
self.ritardo = self.ritardo + minuti
t7 = Treno("T-07")
t12 = Treno("T-12")
t7.ritarda(5)
t7.ritardo # → 5
t12.ritardo # → 0
Treno.ritarda(t12, 2)
t12.ritardo # → 2t7.ritarda(5) è come Treno.ritarda(t7, 5): l'oggetto prima del punto diventa self. Per questo ogni treno ha il suo ritardo.
Gli attributi
Le variabili attaccate a un oggetto, come codice e ritardo. Si leggono e si cambiano con il punto.
class Treno:
def __init__(self, codice):
self.codice = codice
self.ritardo = 0
t7 = Treno("T-07")
t7.ritardo = 3
t7.ritardo # → 3
t7.ritardo += 2
t7.ritardo # → 5
t7.colore # → AttributeError: 'Treno' object has no attribute 'colore'
vars(t7) # → {'codice': 'T-07', 'ritardo': 5}vars mostra tutti gli attributi di un oggetto in un dizionario: comodo quando non sai cosa c'è dentro. Gli attributi creali tutti nell'__init__, anche quelli che partono da zero: così ogni oggetto della classe ha gli stessi.
I metodi
Le funzioni che stanno dentro la classe. Il primo parametro è sempre self. Un metodo può cambiare l'oggetto oppure calcolare e restituire qualcosa.
class Treno:
def __init__(self, codice):
self.codice = codice
self.ritardo = 0
def ritarda(self, minuti):
self.ritardo += minuti
def in_orario(self):
return self.ritardo == 0
def annuncio(self):
if self.in_orario():
return f"{self.codice} è in orario"
return f"{self.codice} ha {self.ritardo} minuti di ritardo"
t7 = Treno("T-07")
t7.in_orario() # → True
t7.annuncio() # → 'T-07 è in orario'
t7.ritarda(4)
t7.annuncio() # → 'T-07 ha 4 minuti di ritardo'Dentro un metodo, gli attributi e gli altri metodi dello stesso oggetto si raggiungono con self.: self.ritardo, self.in_orario().
Chiamare un metodo
Oggetto, punto, nome del metodo, parentesi. Le parentesi ci vogliono sempre, anche quando sono vuote.
class Treno:
def __init__(self, codice):
self.codice = codice
self.ritardo = 7
def in_orario(self):
return self.ritardo == 0
t7 = Treno("T-07")
t7.in_orario() # → False
bool(t7.in_orario) # → TrueNel terminale, un metodo senza parentesi si presenta così (il numero dopo at cambia ogni volta):
>>> t7.in_orario
<bound method Treno.in_orario of <__main__.Treno object at 0x1027ea210>>Il self dimenticato
L'errore più comune con le classi. Se nella def di un metodo manca self, Python 3.12 dice così:
class Treno:
def __init__(self, codice):
self.codice = codice
def saluta():
return "Benvenuti a bordo"
t7 = Treno("T-07")
t7.saluta() # → TypeError: Treno.saluta() takes 0 positional arguments but 1 was given«takes 0 … but 1 was given»: tu tra le parentesi non hai messo niente, ma Python passa sempre l'oggetto come primo argomento. La cura è def saluta(self):.
Anche il self. davanti agli attributi si dimentica. Dentro un metodo, codice da solo è una variabile che non esiste:
class Treno:
def __init__(self, codice):
self.codice = codice
def annuncio(self):
return f"Treno {codice} in arrivo"
t7 = Treno("T-07")
t7.annuncio() # → NameError: name 'codice' is not definedE nell'__init__, senza self. il valore finisce in una variabile che sparisce appena il costruttore ha finito:
class Treno:
def __init__(self, codice):
codice = codice
t7 = Treno("T-07")
t7.codice # → AttributeError: 'Treno' object has no attribute 'codice'repr e str
Un oggetto senza istruzioni si stampa così, con l'indirizzo in memoria che cambia a ogni esecuzione e non ti dice niente:
>>> t7 = Treno("T-07")
>>> t7
<__main__.Treno object at 0x1027ea210>Con i metodi __repr__ e __str__ decidi tu cosa mostrare.
class Treno:
def __init__(self, codice, ritardo=0):
self.codice = codice
self.ritardo = ritardo
def __repr__(self):
return f"Treno('{self.codice}', {self.ritardo})"
def __str__(self):
return f"Treno {self.codice}, ritardo {self.ritardo} min"
t7 = Treno("T-07", 3)
t7 # → Treno('T-07', 3)
print(t7) # → Treno T-07, ritardo 3 min
str(t7) # → 'Treno T-07, ritardo 3 min'
f"In arrivo: {t7}" # → 'In arrivo: Treno T-07, ritardo 3 min'
[t7, Treno("T-12")] # → [Treno('T-07', 3), Treno('T-12', 0)]__repr__ è per chi programma: lo vedi nel terminale, nel debugger, dentro le liste. Di solito somiglia al codice che crea l'oggetto. __str__ è per chi legge: lo usano print, str e le f-string. Se scrivi solo __repr__, Python lo usa anche per print.
Oggetti in una lista e in un dizionario
Gli oggetti si mettono nelle liste e nei dizionari come qualunque altro valore. Con key= scegli quale attributo confrontare.
class Treno:
def __init__(self, codice, ritardo):
self.codice = codice
self.ritardo = ritardo
def __repr__(self):
return f"Treno('{self.codice}', {self.ritardo})"
treni = [Treno("T-07", 3), Treno("T-12", 0), Treno("T-03", 12)]
for treno in treni:
print(treno.codice, treno.ritardo)
# → T-07 3
# → T-12 0
# → T-03 12
[t.codice for t in treni if t.ritardo > 0] # → ['T-07', 'T-03']
max(treni, key=lambda t: t.ritardo) # → Treno('T-03', 12)
sorted(treni, key=lambda t: t.ritardo) # → [Treno('T-12', 0), Treno('T-07', 3), Treno('T-03', 12)]
max(treni) # → TypeError: '>' not supported between instances of 'Treno' and 'Treno'
per_codice = {t.codice: t for t in treni}
per_codice["T-12"] # → Treno('T-12', 0)
per_codice["T-12"].ritardo = 6
treni[1].ritardo # → 6Senza key, Python non sa quale treno è «più grande» e si ferma. Nella lista e nel dizionario c'è lo stesso oggetto, non una copia: se lo cambi da una parte, lo vedi cambiato anche dall'altra.
Due etichette sullo stesso oggetto
b = a non copia l'oggetto: gli attacca una seconda etichetta. Un cambiamento fatto con un nome si vede anche con l'altro.
class Treno:
def __init__(self, codice):
self.codice = codice
self.ritardo = 0
a = Treno("T-07")
b = a
b.ritardo = 10
a.ritardo # → 10
a is b # → True
c = Treno("T-07")
a is c # → False
a == c # → FalseTreno("T-07") scritto due volte fa due treni diversi, anche se dentro sono uguali. E per una classe normale == si comporta come is: due oggetti distinti non sono uguali finché non lo spieghi tu a Python (oppure usi @dataclass, più sotto). Il disegno delle etichette è nel capitolo Etichette e scatole.
Ereditarietà
Una classe può partire da un'altra e prendere tutto quello che ha: attributi e metodi. class Tram(Mezzo) si legge «un Tram è un Mezzo».
class Mezzo:
def __init__(self, codice):
self.codice = codice
self.ritardo = 0
def ritarda(self, minuti):
self.ritardo += minuti
def annuncio(self):
return f"{self.codice}: {self.ritardo} minuti di ritardo"
class Tram(Mezzo):
pass
tram = Tram("TR-2")
tram.ritarda(4)
tram.annuncio() # → 'TR-2: 4 minuti di ritardo'Mezzo è la classe madre, Tram la figlia. Tram qui non scrive niente (pass), eppure ha già __init__, ritarda e annuncio. La figlia scrive solo quello che ha in più o di diverso.
super()
Quando la figlia ha un suo __init__, quello della madre non parte più da solo. super().__init__(...) lo chiama: prima la madre prepara la sua parte, poi la figlia aggiunge la sua.
class Mezzo:
def __init__(self, codice):
self.codice = codice
self.ritardo = 0
class Tram(Mezzo):
def __init__(self, codice, capolinea):
super().__init__(codice)
self.capolinea = capolinea
class Bus(Mezzo):
def __init__(self, codice, capolinea):
self.capolinea = capolinea
tram = Tram("TR-2", "Vecchia Fiera")
tram.codice # → 'TR-2'
tram.capolinea # → 'Vecchia Fiera'
tram.ritardo # → 0
bus = Bus("B-4", "Piazza Query")
bus.capolinea # → 'Piazza Query'
bus.ritardo # → AttributeError: 'Bus' object has no attribute 'ritardo'Bus ha dimenticato super().__init__(codice): la parte della madre non è mai partita, e codice e ritardo non ci sono. Metti super().__init__(...) come prima riga dell'__init__ della figlia.
Riscrivere un metodo
La figlia può riscrivere un metodo della madre con lo stesso nome: per i suoi oggetti vale la versione nuova. Dentro, con super().nome_del_metodo() puoi usare anche la versione della madre.
class Mezzo:
def __init__(self, codice):
self.codice = codice
self.ritardo = 0
def annuncio(self):
return f"{self.codice}: {self.ritardo} minuti di ritardo"
class Tram(Mezzo):
def annuncio(self):
return "Tram " + super().annuncio()
class Treno(Mezzo):
def annuncio(self):
return f"Attenzione, treno {self.codice} in arrivo"
mezzi = [Mezzo("M-1"), Tram("TR-2"), Treno("T-07")]
for mezzo in mezzi:
print(mezzo.annuncio())
# → M-1: 0 minuti di ritardo
# → Tram TR-2: 0 minuti di ritardo
# → Attenzione, treno T-07 in arrivoLo stesso mezzo.annuncio() fa cose diverse a seconda dell'oggetto: il for non ha bisogno di chiedersi che mezzo ha in mano.
isinstance() con le classi
Risponde alla domanda «questo oggetto è di questa classe?». Tiene conto dell'ereditarietà: un tram è anche un mezzo.
class Mezzo:
pass
class Tram(Mezzo):
pass
class Treno(Mezzo):
pass
tram = Tram()
isinstance(tram, Tram) # → True
isinstance(tram, Mezzo) # → True
isinstance(tram, Treno) # → False
type(tram) == Mezzo # → Falsetype(x) == ... guarda solo la classe esatta, e per Python un tram non è «esattamente» un mezzo. Per questo negli if si usa isinstance. Con i tipi di base funziona allo stesso modo: lo trovi in Le funzioni di base.
@dataclass
Per le classi che servono soprattutto a tenere dati, la libreria standard ha @dataclass: scrivi i campi con il loro tipo, e __init__, __repr__ e == li scrive Python per te.
from dataclasses import dataclass
@dataclass
class Fermata:
nome: str
linea: str
accessibile: bool = True
largo = Fermata("Largo Lista", "Menta")
largo # → Fermata(nome='Largo Lista', linea='Menta', accessibile=True)
largo.nome # → 'Largo Lista'
largo == Fermata("Largo Lista", "Menta") # → True
Fermata("Vecchia Fiera", "Menta", accessibile=False) # → Fermata(nome='Vecchia Fiera', linea='Menta', accessibile=False)
Fermata("Ponte Ciclo") # → TypeError: Fermata.__init__() missing 1 required positional argument: 'linea'
Fermata(7, 8) # → Fermata(nome=7, linea=8, accessibile=True)I campi con un valore di partenza (accessibile: bool = True) vanno dopo quelli senza. Puoi aggiungere metodi come in una classe normale. I tipi scritti dopo i due punti sono solo un'indicazione: Fermata(7, 8) passa senza errori.
Da qui a Pydantic
Nel libro HTTP e API i dati che arrivano da fuori passano da Pydantic, una libreria che si installa con pip (qui non c'è, per questo l'esempio non si esegue). La forma è quasi quella di una dataclass: una classe con i campi e i loro tipi. La differenza è che Pydantic i tipi li controlla, e dove può li converte.
from pydantic import BaseModel
class Ospite(BaseModel):
nome: str
eta: int
abbonato: bool = False
lucia = Ospite(nome="Lucia", eta="34")
lucia.eta # 34: la stringa "34" è diventata un numero
lucia.abbonato # False
lucia.model_dump() # {'nome': 'Lucia', 'eta': 34, 'abbonato': False}
Ospite(nome="Ivo", eta="tanti") # ValidationError: eta non è un numero interoclass Ospite(BaseModel) è ereditarietà, come class Tram(Mezzo): Ospite prende da BaseModel tutto il lavoro di controllo, e tu scrivi solo i campi. Con Pydantic gli oggetti si creano con i nomi dei campi: Ospite(nome="Lucia", eta=34).