L'ereditarietà
Il figlio è il genitore, con qualcosa in più
- 10 minuti di lettura
Nel capitolo Classi e oggetti hai scritto uno stampo per i treni. Ma nel deposito della Linea Menta non ci sono solo treni: ci sono i tram, la funicolare del Belvedere, le navette. Tutti hanno un codice, dei posti e delle persone a bordo; su tutti la gente sale allo stesso modo.
Scrivere le stesse righe in quattro classi vuol dire sbagliarle in quattro posti. L'ereditarietà le scrive una volta sola, in una classe genitore. Ogni classe figlia le riceve tutte, e aggiunge solo quello che ha di diverso.
class Tram(Mezzo): # tra parentesi, il genitore: un Tram è un Mezzo
passIl genitore
Il genitore è una classe normale, come quelle del capitolo 9. Questo è Mezzo: lo ritroverai in tutta la pagina.
class Mezzo:
def __init__(self, codice, posti):
self.codice = codice
self.posti = posti
self.a_bordo = 0 # ogni mezzo parte vuoto
def sali(self, persone):
self.a_bordo = self.a_bordo + persone
def posti_liberi(self):
return self.posti - self.a_bordo
def descrivi(self):
return f"{self.codice}: {self.a_bordo} a bordo su {self.posti} posti"Il figlio ha tutto
class Tram(Mezzo): vuol dire: un tram è un mezzo. Anche se dentro c'è solo pass, un tram sa già fare tutto quello che sa fare un mezzo.
class Tram(Mezzo):
pass
t05 = Tram("T05", 90) # __init__ è quello di Mezzo
t05.sali(30) # sali è quello di Mezzo
print(t05.descrivi()) # T05: 30 a bordo su 90 posti
print(t05.posti_liberi()) # 60Il disegno
Due disegni. Il primo è l'albero di famiglia: il genitore in alto, i figli sotto. Ogni figlio ha tutto quello che sta sopra di lui, più quello che è scritto nel suo riquadro.
Mezzo (il genitore)
codice · posti · a_bordo
sali() · posti_liberi() · descrivi()
│
┌───────────────┼────────────────┐
│ │ │
Tram Treno Funicolare
niente di + vagoni riscrive
nuovo allunga descrivi()
descrivi()Il secondo è la scatola, come in Etichette e scatole. La scatola di t05 è un Tram, ma dentro ci sono i dati che ci ha messo l'__init__ di Mezzo.
Un dato in più: super().__init__
Un treno ha qualcosa che un tram non ha: i vagoni. Quindi il figlio ha bisogno del suo __init__. Ma codice, posti e a_bordo li sa già scrivere il genitore: glielo chiedi con super(), che vuol dire «il mio genitore».
class Treno(Mezzo):
def __init__(self, codice, posti, vagoni):
super().__init__(codice, posti) # il genitore riempie codice, posti e a_bordo
self.vagoni = vagoni # il figlio aggiunge il suo
m12 = Treno("M12", 600, 6)
print(m12.codice, m12.vagoni, m12.a_bordo) # M12 6 0super().__init__(codice, posti) fa lavorare l'__init__ del genitore sulla stessa scatola. self non si passa: lo aggiunge Python, come sempre.
Riscrivere un metodo
Sul tabellone la funicolare vuole una descrizione tutta sua. Nel figlio scrivi un metodo con lo stesso nome di quello del genitore: per le funicolari vince il suo.
class Funicolare(Mezzo):
def descrivi(self):
return f"Funicolare {self.codice}: sale con {self.a_bordo} persone"
f1 = Funicolare("F1", 40)
f1.sali(12)
print(f1.descrivi()) # Funicolare F1: sale con 12 persone
print(f1.posti_liberi()) # 28: questo è ancora quello di MezzoIl genitore non cambia: Mezzo("S01", 4).descrivi() dà sempre S01: 0 a bordo su 4 posti.
Chi risponde
Quando chiami un metodo, Python lo cerca prima nella classe dell'oggetto, poi nel genitore. Il primo che ce l'ha, risponde. È il disegno da tenere a mente:
f1.descrivi() f1.sali(12)
1 Funicolare descrivi? sì ──▶ parte 1 Funicolare sali? no: salgo
│
▼
2 Mezzo (non ci arriva) 2 Mezzo sali? sì ──▶ parteSe un figlio ha a sua volta un figlio (un TramStorico figlio di Tram), la ricerca sale di un piano in più: figlio, genitore, nonno. E se nessuno ha quel metodo:
AttributeError: 'Funicolare' object has no attribute 'vola'Il genitore, più qualcosa: super().metodo()
A volte non vuoi buttare via il metodo del genitore: vuoi allungarlo. Il treno si descrive come ogni mezzo, più i vagoni. Nel metodo riscritto, super().descrivi() fa lavorare il genitore e ti restituisce il suo risultato.
class Treno(Mezzo):
def __init__(self, codice, posti, vagoni):
super().__init__(codice, posti)
self.vagoni = vagoni
def descrivi(self):
return super().descrivi() + f", {self.vagoni} vagoni"
m12 = Treno("M12", 600, 6)
m12.sali(100)
print(m12.descrivi()) # M12: 100 a bordo su 600 posti, 6 vagoniisinstance: di che tipo è?
isinstance(oggetto, Classe) risponde True se l'oggetto è di quella classe o di un suo figlio. Un treno è un treno, ma è anche un mezzo.
print(isinstance(m12, Treno)) # True
print(isinstance(m12, Mezzo)) # True: un treno è un mezzo
print(isinstance(m12, Tram)) # False
print(type(m12) == Mezzo) # False: type guarda solo la classe esattaPer chiedere «è un mezzo?» si usa isinstance. type(x) == dimentica i figli.
Tanti mezzi, una domanda sola
Ecco il guadagno vero. Una lista può tenere mezzi di tipi diversi, e il for fa a tutti la stessa domanda. Ognuno risponde a modo suo, senza un if per ogni tipo.
flotta = [Treno("M14", 400, 4), Tram("T09", 90), Funicolare("F2", 40)]
for mezzo in flotta:
mezzo.sali(20)
print(mezzo.descrivi())M14: 20 a bordo su 400 posti, 4 vagoni
T09: 20 a bordo su 90 posti
Funicolare F2: sale con 20 personeDomani arriva un mezzo nuovo, una navetta? Scrivi la sua classe figlia. Il for resta com'è.
Quando non serve
L'ereditarietà non è l'unico modo di mettere insieme le classi. Tre domande prima di scrivere un figlio:
- Cambia solo un valore? Un tram da 90 posti e uno da 120 sono due oggetti della stessa classe, non due classi. I valori diversi vanno negli attributi.
- È un, o ha un? Un tram è un mezzo: figlio. Una rimessa ha dei mezzi: niente figlio, un attributo con la lista.
- Il figlio butterebbe via metà del genitore? Allora non è un figlio: è un'altra classe.
class Rimessa: # non è un Mezzo: ha dei mezzi
def __init__(self, nome):
self.nome = nome
self.mezzi = [] # i mezzi stanno qui, in una listaLo conosci già: BaseModel
Nel capitolo 9 hai visto class Treno(BaseModel):, e con le API hai scritto classi come queste. Sono ereditarietà: la classe tra parentesi è il genitore.
from pydantic import BaseModel
class OspiteNuovo(BaseModel): # il genitore è BaseModel
nome: str
eta: int
class Ospite(OspiteNuovo): # tutto quello di OspiteNuovo, più l'id
id: int
ospite = Ospite(id=7, nome="Nadia Russo", eta=41)
print(ospite.nome) # Nadia Russo
print(isinstance(ospite, OspiteNuovo)) # TrueUn modello Pydantic non ha mai avuto un __init__ scritto da te: lo eredita da BaseModel, che in più controlla i tipi. E Ospite è un OspiteNuovo con un dato in più, come il treno con i vagoni. Il resto è nel capitolo Pydantic.
Le mosse
| Vuoi | Si scrive | Cosa succede |
|---|---|---|
| Un figlio | class Tram(Mezzo): | Il figlio ha tutto quello che ha il genitore |
| Un dato in più | super().__init__(codice, posti), poi self.vagoni = vagoni | Prima il genitore riempie la scatola, poi il figlio aggiunge |
| Cambiare un metodo | Nel figlio, un metodo con lo stesso nome | Per il figlio vince il suo; il genitore non cambia |
| Il genitore, più qualcosa | super().descrivi() + "…" | Lavora il genitore, poi il figlio aggiunge |
| Chiedere il tipo | isinstance(m12, Mezzo) | True anche per i figli |
Ricorda
class Figlio(Genitore):e il figlio ha tutto quello che ha il genitore.- Se il figlio ha il suo
__init__, la prima riga èsuper().__init__(...), senzaself. - Un metodo si cerca prima nel figlio, poi nel genitore: il primo che ce l'ha, risponde.
- Nel metodo riscritto il genitore si chiama con
super().metodo(), mai conself.metodo(). isinstancedice sì anche ai figli;type(x) ==no.- È un: figlio. Ha un: attributo.