Vai al contenuto
code-to-code

Apro l'indice…

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

Python10. L'ereditarietàp. 302

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.

Python
class Tram(Mezzo):      # tra parentesi, il genitore: un Tram è un Mezzo
    pass

Il genitore

Il genitore è una classe normale, come quelle del capitolo 9. Questo è Mezzo: lo ritroverai in tutta la pagina.

Python
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.

Python
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())   # 60

Il 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.

t05 = Tram(codice="T05", posti=90, a_bordo=30)t05Tramcodice"T05"posti90a_bordo30
La scatola di un tram

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».

Python
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 0

super().__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.

Python
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 Mezzo

Il 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ì ──▶ parte

Se 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.

Python
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 vagoni

isinstance: 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.

Python
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 esatta

Per 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.

Python
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 persone

Domani 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:

  1. 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.
  2. È un, o ha un? Un tram è un mezzo: figlio. Una rimessa ha dei mezzi: niente figlio, un attributo con la lista.
  3. Il figlio butterebbe via metà del genitore? Allora non è un figlio: è un'altra classe.
Python
class Rimessa:                 # non è un Mezzo: ha dei mezzi
    def __init__(self, nome):
        self.nome = nome
        self.mezzi = []        # i mezzi stanno qui, in una lista

Lo 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.

Python
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))   # True

Un 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

VuoiSi scriveCosa succede
Un figlioclass Tram(Mezzo):Il figlio ha tutto quello che ha il genitore
Un dato in piùsuper().__init__(codice, posti), poi self.vagoni = vagoniPrima il genitore riempie la scatola, poi il figlio aggiunge
Cambiare un metodoNel figlio, un metodo con lo stesso nomePer il figlio vince il suo; il genitore non cambia
Il genitore, più qualcosasuper().descrivi() + "…"Lavora il genitore, poi il figlio aggiunge
Chiedere il tipoisinstance(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__(...), senza self.
  • 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 con self.metodo().
  • isinstance dice sì anche ai figli; type(x) == no.
  • È un: figlio. Ha un: attributo.