Classi e oggetti
Lo stampo, le scatole, e self
- 12 minuti di lettura
Fin qui un treno era un dizionario: {"codice": "M12", "vagoni": 4}. I dati ci sono. Ma quello che un treno sa fare (partire, agganciare vagoni, presentarsi) sta da un'altra parte, in funzioni sparse che ricevono il dizionario e sperano che le chiavi siano scritte giuste.
Una classe mette insieme le due cose: i dati di un treno e quello che un treno sa fare.
Gli oggetti, in realtà, li usi da giorni:
"porta codice".upper() # una stringa sa diventare maiuscola
fermate.append("Largo Lista") # una lista sa allungarsi
vagoni.get("M14") # un dizionario sa cercare una chiaveIl punto collega un oggetto a qualcosa che sa fare, un metodo (con le parentesi), oppure a qualcosa che ha, un attributo (senza parentesi). In questo capitolo scrivi i tuoi.
Lo stampo e le scatole
La classe è lo stampo: dice com'è fatto ogni treno e cosa sa fare. Da sola non è un treno.
Un oggetto è una cosa fatta con lo stampo: un treno vero, con i suoi dati. Con uno stampo fai quanti oggetti vuoi: stessa forma, dati diversi.
Il disegno
Lo disegniamo come in Etichette e scatole. In alto lo stampo; sotto, etichette a sinistra, scatole a destra. Ogni oggetto è una scatola, e dentro ci sono i suoi attributi.
LA CLASSE (lo stampo)
Treno
ha: codice · vagoni · in_corsa
sa fare: parti() · aggancia(quanti) · descrivi()Uno stampo, due scatole. Ogni scatola ha i suoi attributi: se agganci vagoni a m12, quelli di m14 non si muovono.
Com'è fatta una classe
class Treno:
def __init__(self, codice, vagoni):
self.codice = codice
self.vagoni = vagoni
self.in_corsa = False
def parti(self):
self.in_corsa = True
def aggancia(self, quanti):
self.vagoni = self.vagoni + quanti
def descrivi(self):
return f"{self.codice}, {self.vagoni} vagoni"Riga per riga:
class Treno:è il nome dello stampo, con la maiuscola.Trenoè la classe;treno, minuscolo, sarà un oggetto.__init__prepara ogni oggetto nuovo: riempie la scatola. Parte da solo, quando crei un treno.self.codice = codice: a sinistra il posto nella scatola, a destra il valore che arriva da fuori.self.in_corsa = Falsenon arriva da fuori: ogni treno nuovo parte fermo.parti,agganciaedescrivisono i metodi: funzioni scritte dentro la classe. Ricevono sempreselfper primo.
Nei file della palestra i metodi hanno anche i type hints del capitolo Le funzioni, per esempio def aggancia(self, quanti: int) -> None:. A self il tipo non si mette. E -> None ti dice già una cosa: quel metodo cambia l'oggetto e non restituisce niente.
Creare un oggetto, in tre fotogrammi
m12 = Treno("M12", 4). Chiamare la classe come una funzione crea un oggetto. Succede in tre tempi:
1 · Python crea una scatola vuota, a forma di Treno
┌─ Treno ──────────────┐
│ (vuota) │
└──────────────────────┘
2 · Chiama __init__: self è attaccato alla scatola nuova,
codice vale "M12", vagoni vale 4
self ──▶ ┌─ Treno ──────────────┐
│ codice "M12" │
│ vagoni 4 │
│ in_corsa False │
└──────────────────────┘
3 · __init__ finisce, self si stacca, arriva l'etichetta m12
m12 ──▶ ┌─ Treno ──────────────┐
│ codice "M12" │
│ vagoni 4 │
│ in_corsa False │
└──────────────────────┘I valori tra parentesi vanno a __init__ dopo self: "M12" in codice, 4 in vagoni. self non lo passi mai tu: lo mette Python, ed è la scatola nuova.
self è l'oggetto prima del punto
Dentro un metodo, self è l'oggetto su cui stai lavorando. Quale? Quello prima del punto.
m12.aggancia(2) # Python lo legge come Treno.aggancia(m12, 2)
m14.parti() # Python lo legge come Treno.parti(m14)Non è un modo di dire: puoi scriverlo davvero, e fa la stessa cosa.
Treno.parti(m14)
print(m14.in_corsa) # Truem12.aggancia(2) è Treno.aggancia(m12, 2)
┌─ Treno ──────────────┐
m12 ─────────▶ │ codice "M12" │ ◀── self
│ vagoni 4 → 6 │
└──────────────────────┘
┌─ Treno ──────────────┐
m14 ─────────▶ │ codice "M14" │
│ vagoni 3 │ (nessuno la tocca)
└──────────────────────┘Lo stesso metodo, su due oggetti: ogni volta self è attaccato alla scatola prima del punto. Per questo self.vagoni vuol dire «i vagoni di questo treno».
Due tipi di metodi: cambiare o rispondere
Quasi ogni metodo è di uno di questi due tipi.
| Cambia l'oggetto | Risponde con un valore | |
|---|---|---|
| Esempi | parti(), aggancia(2) | descrivi() |
| Dentro c'è | self.qualcosa = … | return … |
| Restituisce | None | il valore |
| Si chiama così | da solo, su una riga: m12.aggancia(2) | dentro un'altra riga: testo = m12.descrivi() |
m12 = Treno("M12", 4)
m12.parti()
m12.aggancia(2)
print(m12.vagoni, m12.in_corsa) # 6 True
print(m12.descrivi()) # M12, 6 vagoniAttento anche alle parentesi. Un metodo senza parentesi non parte: print(m12.descrivi) stampa <bound method Treno.descrivi of …>, il metodo invece del suo risultato. E un attributo con le parentesi si arrabbia: m12.vagoni() dà TypeError: 'int' object is not callable.
Il self dimenticato
È l'errore più comune del capitolo, e ha tre facce.
Manca nella def. Il metodo non ha posto per la scatola:
def aggancia(quanti): # manca self
self.vagoni = self.vagoni + quantiTypeError: Treno.aggancia() takes 1 positional argument but 2 were givenLeggilo così: con m12.aggancia(2) Python passa due cose, la scatola m12 e il 2; la def ha posto per una.
Manca davanti a un attributo che leggi. Dentro il metodo, codice da solo è un'etichetta del metodo, e non esiste. Il codice sta nella scatola: self.codice.
def descrivi(self):
return f"{codice}, {self.vagoni} vagoni" # manca self.NameError: name 'codice' is not defined. Did you mean: 'self.codice'?Python 3.12 te lo suggerisce pure.
Manca davanti a un attributo che scrivi. È la più subdola, perché lì per lì non succede niente.
def __init__(self, codice, vagoni):
codice = codice # manca self.
self.vagoni = vagoni
self.in_corsa = Falsecodice = codice attacca un'etichetta su un foglietto che vive solo dentro __init__. Quando __init__ finisce, il foglietto si butta, e nella scatola il codice non c'è.
dentro __init__ la scatola di m12, dopo
codice ──▶ "M12" ┌─ Treno ──────────────┐
(buttato via alla fine) │ vagoni 4 │
│ in_corsa False │
└──────────────────────┘L'errore arriva dopo, quando qualcuno cerca il codice: AttributeError: 'Treno' object has no attribute 'codice'. In un metodo è anche peggio: con vagoni = self.vagoni + quanti non arriva nessun errore, e i vagoni restano quelli di prima.
Per vedere il buco, guarda dentro la scatola. vars ti mostra gli attributi di un oggetto come un dizionario, nome → valore:
m12 = Treno("M12", 4) # con il __init__ sbagliato di qui sopra
print(vars(m12)){'vagoni': 4, 'in_corsa': False}Il codice non c'è. Con il __init__ giusto, e dopo parti() e aggancia(2), avresti visto {'codice': 'M12', 'vagoni': 6, 'in_corsa': True}.
Stampare bene: __repr__
print(m12)<__main__.Treno object at 0x1078c36b0>Python sa solo che è un Treno e dove sta in memoria (quel numero cambia ogni volta). Come mostrarlo glielo dici tu, con un altro metodo speciale, __repr__: restituisce il testo che vuoi vedere.
class Treno:
# … __init__ e gli altri metodi, come prima …
def __repr__(self):
return f"Treno {self.codice}, {self.vagoni} vagoni"m12 = Treno("M12", 4)
m14 = Treno("M14", 3)
print(m12) # Treno M12, 4 vagoni
print([m12, m14]) # [Treno M12, 4 vagoni, Treno M14, 3 vagoni]Python lo usa dappertutto: con print, dentro le liste e i dizionari, nei messaggi di pytest quando un test è rosso.
Oggetti in liste e dizionari
Un oggetto è un valore come gli altri: sta in una lista, sta in un dizionario.
flotta = [Treno("M12", 4), Treno("M14", 3), Treno("M16", 6)]
for treno in flotta:
treno.aggancia(1) # a ogni giro, self è un treno diverso
print(flotta)[Treno M12, 5 vagoni, Treno M14, 4 vagoni, Treno M16, 7 vagoni]Il deposito è lo schema «indicizzare» del capitolo I dizionari, con gli oggetti al posto dei dizionari: codice → treno.
deposito = {}
for treno in flotta:
deposito[treno.codice] = treno # la chiave è un attributo del valore
deposito["M14"].parti()
print(deposito["M14"].in_corsa) # TrueSi legge da sinistra a destra, una scatola alla volta: deposito["M14"] è il treno, .parti() lavora su quello.
Le scatole Treno sono tre, non sei: la lista e il dizionario puntano agli stessi treni. Per questo adesso anche flotta[1].in_corsa vale True.
Due etichette, una scatola
= non copia un oggetto: attacca una seconda etichetta alla stessa scatola. È lo stesso treno, chiamato in due modi.
m12 = Treno("M12", 4)
riserva = m12
riserva.aggancia(2)
print(m12.vagoni) # 6Conta le scatole, non le etichette: qui la scatola è una. Per avere un secondo treno serve una seconda chiamata a Treno(...). Ne parla per intero il capitolo Etichette e scatole.
Verso FastAPI: la classe diventa un modello
Con Pydantic hai scritto classi così:
from pydantic import BaseModel
class Treno(BaseModel):
codice: str
vagoni: intÈ lo stesso stampo di questa pagina, senza __init__: lo scrive BaseModel per te, leggendo i campi e i loro tipi. In più controlla i dati: con Treno(codice="M12", vagoni="4") i vagoni diventano il numero 4; con vagoni="tanti" si ferma con un ValidationError, che in FastAPI diventa il 422.
Il resto lo sai già. Gli oggetti si creano con i nomi dei campi (codice="M12"), gli attributi si leggono con il punto (m12.vagoni), ogni treno è la sua scatola. Le parentesi dopo il nome, (BaseModel), sono l'ereditarietà: è il capitolo dopo, L'ereditarietà. I modelli, campo per campo: Pydantic.
Ricorda
- La classe è lo stampo, l'oggetto è una scatola fatta con lo stampo.
Treno("M12", 4)crea la scatola e chiama__init__per riempirla. selfè l'oggetto su cui stai lavorando, quello prima del punto:m12.parti()èTreno.parti(m12).- Dentro la classe:
selfprimo parametro di ogni metodo,self.davanti a ogni attributo. - Un metodo cambia l'oggetto (e restituisce
None) oppure risponde conreturn. __repr__decide come si vede un oggetto;vars(oggetto)ti mostra cosa c'è dentro.=non copia un oggetto: attacca un'altra etichetta alla stessa scatola.