L'ereditarietà, le soluzioni
Il ragionamento, il codice, le trappole
Per ogni esercizio, sempre lo stesso ordine: in italiano → il codice → le trappole. Per i più difficili, anche il passo per passo.
La tua soluzione è diversa ma i test sono verdi? Probabilmente va bene: spesso ci sono più strade giuste. Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: alcune passano qualche test e si rompono su un altro.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
La palestra
1 · La navetta del parcheggio
In italiano. La navetta è piena quando non le resta nessun posto libero. Quanti posti liberi ha, lo sa già dire il genitore.
class Navetta(Mezzo):
def e_piena(self) -> bool:
return self.posti_liberi() <= 0posti_liberi non è scritto in Navetta: Python non lo trova nel figlio, sale a Mezzo e lo trova lì. Perché <= e non ==? Il sali del genitore non controlla niente: se salissero dieci persone su otto posti, i posti liberi sarebbero meno due, e la navetta sarebbe piena lo stesso. Va bene anche return self.a_bordo >= self.posti.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return self.posti_liberi == 0 | Senza parentesi self.posti_liberi è il metodo, non il suo risultato. Un metodo non è mai uguale a 0: la navetta non è mai piena (assert False is True) | test_con_tutti_i_posti_occupati_e_piena |
return posti_liberi() <= 0 | «È ereditato, lo chiamo e basta.» Ma un metodo si chiama sempre su un oggetto: NameError: name 'posti_liberi' is not defined | test_vuota_non_e_piena, test_a_meta_non_e_piena, test_con_tutti_i_posti_occupati_e_piena |
Ereditato vuol dire che la navetta ha quel metodo, non che diventa una funzione libera. Si chiama come un metodo scritto da te: self. davanti, le parentesi dopo.
2 · Il bus sostitutivo
In italiano.
- Faccio lavorare l'
__init__del genitore: scrive codice, posti e zero persone a bordo. - Poi scrivo il dato che ha solo il bus: la tratta.
class BusSostitutivo(Mezzo):
def __init__(self, codice: str, posti: int, tratta: str) -> None:
super().__init__(codice, posti)
self.tratta = trattasuper().__init__ va prima: così, se un giorno il figlio vuole cambiare qualcosa che ha scritto il genitore, lo trova già lì.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Solo self.tratta = tratta | L'__init__ del figlio prende il posto di quello del genitore, che non parte più. Nella scatola c'è solo la tratta: AttributeError: 'BusSostitutivo' object has no attribute 'codice' | test_i_dati_del_genitore, test_i_metodi_del_genitore_funzionano |
super().__init__(self, codice, posti) | self lo aggiunge già Python: così gli argomenti diventano quattro. TypeError: Mezzo.__init__() takes 3 positional arguments but 4 were given, e il bus non nasce nemmeno | tutti e quattro |
Solo super().__init__(codice, posti) | Il genitore fa la sua parte, ma la tratta non la scrive nessuno: AttributeError: 'BusSostitutivo' object has no attribute 'tratta' | test_il_dato_in_piu, test_il_cartello |
La prima è la più traditrice: il bus si crea senza errori, e l'errore arriva dopo, nel primo metodo che cerca un dato del genitore.
3 · Il treno merci
In italiano.
sali: qualunque cosa succeda, mi fermo con un errore che dice quale treno è.descrivi: il codice del treno, e la frase sua.
class TrenoMerci(Mezzo):
def sali(self, persone: int) -> None:
raise ValueError(f"{self.codice} è un treno merci: niente passeggeri")
def descrivi(self) -> str:
return f"{self.codice}: treno merci, niente passeggeri"Il genitore non cambia: un Mezzo fa salire chiunque e si descrive come sempre. Cambia solo la risposta per i treni merci, perché Python cerca prima in TrenoMerci.
persone non lo usa nessuno, ed è giusto così: il metodo deve avere gli stessi argomenti di quello del genitore, perché chi lo chiama non sa (e non deve sapere) se ha davanti un tram o un treno merci.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
def sale(self, persone): | Un metodo nuovo, con un nome sbagliato di una lettera. merci.sali(3) non trova niente nel figlio, sale al genitore, e tre persone salgono sul treno merci. Nessun errore: Failed: DID NOT RAISE ValueError | test_sul_treno_merci_non_si_sale |
return ValueError(...) | L'errore viene creato e restituito come un valore qualsiasi, ma niente si ferma: Failed: DID NOT RAISE ValueError | test_sul_treno_merci_non_si_sale |
La prima è la trappola tipica di questo capitolo: un metodo riscritto con il nome sbagliato non dà mai errore. Semplicemente, non è un metodo riscritto: risponde il genitore.
4 · La funicolare del Belvedere
In italiano.
sali: all'inizio salgono tutti quelli che aspettano.- Se sono più dei posti liberi, ne salgono solo quanti sono i posti liberi.
- A farli salire davvero è il
salidel genitore. descrivi: «Funicolare », più la descrizione del genitore.
class Funicolare(Mezzo):
def sali(self, persone: int) -> None:
entrano = persone
if entrano > self.posti_liberi():
entrano = self.posti_liberi()
super().sali(entrano)
def descrivi(self) -> str:
return "Funicolare " + super().descrivi()Il disegno, di sali:
Le prime tre righe di sali si possono scrivere anche con min: entrano = min(persone, self.posti_liberi()).
Passo per passo, con Funicolare("F1", 8):
| Chiamata | self.posti_liberi() | entrano | Chi fa salire | a_bordo dopo |
|---|---|---|---|---|
funi.sali(5) | 8 | 5 | super().sali(5), cioè Mezzo | 5 |
funi.sali(6) | 3 | 6, poi 3 | super().sali(3), cioè Mezzo | 8 |
funi.descrivi() | super().descrivi() dà "F1: 8 a bordo su 8 posti" | "Funicolare F1: 8 a bordo su 8 posti" |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
self.sali(entrano) al posto di super().sali(entrano) | La ricerca parte dalla funicolare e trova… la sali della funicolare. Che chiama se stessa, all'infinito: RecursionError: maximum recursion depth exceeded | test_se_c_e_posto_salgono_tutti, test_salgono_solo_quelli_che_ci_stanno, test_piena_non_sale_piu_nessuno, test_il_tabellone |
Calcolare entrano e fermarsi lì | Il conto è giusto, ma nessuno fa salire nessuno: a_bordo resta 0 (assert 0 == 5) | gli stessi quattro |
"Funicolare " + super().descrivi | Senza parentesi è il metodo, non la stringa: TypeError: can only concatenate str (not "method") to str | test_il_tabellone |
5 · La rimessa di Vecchia Fiera
In italiano.
- Una rimessa nuova ha un nome e una lista vuota: la sua.
aggiungi: il mezzo va in fondo alla lista.tabellone: a ogni mezzo chiedodescrivi(), e metto la risposta in una lista nuova.solo: un setaccio. Tengo i mezzi per cuiisinstance(mezzo, tipo)dice sì.
class Rimessa:
def __init__(self, nome: str) -> None:
self.nome = nome
self.mezzi = []
def aggiungi(self, mezzo: Mezzo) -> None:
self.mezzi.append(mezzo)
def tabellone(self) -> list[str]:
righe = []
for mezzo in self.mezzi:
righe.append(mezzo.descrivi())
return righe
def solo(self, tipo: type) -> list[Mezzo]:
trovati = []
for mezzo in self.mezzi:
if isinstance(mezzo, tipo):
trovati.append(mezzo)
return trovatiRimessa non ha niente tra parentesi: una rimessa non è un mezzo, ha dei mezzi. Se fosse figlia di Mezzo avrebbe un codice, dei posti e un metodo sali: per una rimessa non hanno senso.
Passo per passo, solo(Tram) sulla rimessa dei test:
mezzo | La sua classe | isinstance(mezzo, Tram) | type(mezzo) == Tram | trovati dopo |
|---|---|---|---|---|
| S01 | Mezzo | no: un mezzo non è per forza un tram | no | [] |
| T05 | Tram | sì | sì | [T05] |
| TN1 | TramNotturno | sì: il genitore di TramNotturno è Tram | no | [T05, TN1] |
Nel tabellone, invece, nessun if: il for chiede descrivi() a tutti, e il mezzo, il tram e il tram notturno rispondono ognuno con il suo.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
if type(mezzo) == tipo: | type guarda solo la classe esatta: il tram notturno non è un tram, e nessun tram è un mezzo. solo(Tram) dà solo ['T05'], solo(Mezzo) solo ['S01'] | test_solo_i_tram_anche_quelli_notturni, test_tutti_sono_mezzi |
mezzi = [] nel corpo della classe, fuori da __init__ | Una scatola sola per tutta la classe: ogni rimessa ci aggiunge i suoi mezzi, e test dopo test la lista si allunga | test_ogni_rimessa_ha_i_suoi_mezzi, test_il_tabellone_ognuno_a_modo_suo, test_solo_i_tram_anche_quelli_notturni, test_solo_i_tram_notturni, test_tutti_sono_mezzi |
righe.append(mezzo.descrivi) | Senza parentesi nella lista finiscono i metodi, non le descrizioni: <bound method Mezzo.descrivi of …> | test_il_tabellone_ognuno_a_modo_suo |
La seconda viene da Pydantic: in un BaseModel i campi si scrivono proprio nel corpo della classe. Ma lì ci pensa BaseModel a dare a ogni oggetto la sua scatola. In una classe tua, una riga fuori dai metodi crea una lista, attaccata allo stampo:
Rimessa (lo stampo) ── mezzi ──▶ [ T05, … ] una lista sola
prima ──▶ Rimessa: nome "Vecchia Fiera" mezzi? non ce l'ha: la cerca nello stampo
seconda ──▶ Rimessa: nome "Porta Codice" mezzi? la stessaCon self.mezzi = [] dentro __init__, invece, ogni scatola ha la sua.
La storia
Livello 1 · Il genitore
In italiano. La scatola parte con codice, conducente e zero km. Ogni viaggio aggiunge km. Il consumo è il doppio dei km.
class Mezzo:
def __init__(self, codice: str, conducente: str) -> None:
self.codice = codice
self.conducente = conducente
self.km = 0
def percorri(self, km: int) -> None:
self.km = self.km + km
def consumo(self) -> int:
return self.km * 2Sui dati veri: il carrello S01 ha fatto 3 km più 2, quindi 5 km: 10 kWh.
Livello 2 · Il treno
In italiano. Prima il genitore scrive codice, conducente e km; poi il treno aggiunge i vagoni.
class Treno(Mezzo):
def __init__(self, codice: str, conducente: str, vagoni: int) -> None:
super().__init__(codice, conducente)
self.vagoni = vagoniSui dati veri: M12 ha 6 vagoni, M14 ne ha 4.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Solo self.vagoni = vagoni | Il treno nasce con i vagoni e basta: AttributeError: 'Treno' object has no attribute 'codice' (e 'km', appena viaggia) | test_livello_2_il_treno_ha_tutto_quello_che_ha_un_mezzo, test_livello_2_percorri_lo_eredita, test_livello_4_il_treno_per_ogni_vagone, e i tre del livello 5 che usano un treno |
super().__init__(self, codice, conducente) | TypeError: Mezzo.__init__() takes 3 positional arguments but 4 were given: il treno non nasce | tutti i test del livello 2, test_livello_4_il_treno_per_ogni_vagone, e i tre del livello 5 che usano un treno |
Un errore al livello 2 fa diventare rossi anche il 4 e il 5. Se un livello è rosso senza motivo, guarda prima i livelli che usa.
Livello 3 · Il tram
In italiano. Un tram consuma il triplo dei suoi km.
class Tram(Mezzo):
def consumo(self) -> int:
return self.km * 3Sui dati veri: T05 ha fatto 12 km: 36 kWh.
descrivi è scritto in Mezzo, eppure per T05 scrive 36 kWh e non 24. Dentro descrivi c'è self.consumo(), e self è il tram: la ricerca parte da Tram, e trova il suo. Lo stesso per il tram storico, che di consumo non ne ha: la ricerca sale da TramStorico a Tram, e si ferma lì.
La trappola.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
def consuma(self): | Un metodo nuovo che nessuno chiama. tram.consumo() sale al genitore: 2 kWh per km invece di 3 (assert 8 == 12). E i tram onesti, al livello 5, diventano sospetti | test_livello_3_il_tram_tre_kwh_per_km, test_livello_3_descrivi_del_genitore_usa_il_consumo_del_tram, test_livello_3_il_tram_storico_consuma_come_un_tram, test_livello_5_chi_ha_consumato_troppo_in_ordine_alfabetico, test_livello_5_tra_i_tram_ci_sono_anche_i_figli |
Livello 4 · Il genitore, più qualcosa
In italiano. Il treno chiede al genitore il suo conto e lo moltiplica per i vagoni. La funicolare chiede al genitore il suo conto e ci aggiunge la fune.
class Treno(Mezzo):
# … __init__ del livello 2 …
def consumo(self) -> int:
return super().consumo() * self.vagoni
class Funicolare(Mezzo):
def consumo(self) -> int:
return super().consumo() + 50Passo per passo, m14.consumo() sui dati veri (10 km, 4 vagoni):
| # | Dove siamo | Cosa succede | Il valore |
|---|---|---|---|
| 1 | Treno.consumo | La ricerca trova il metodo nel treno | |
| 2 | super().consumo() | Lavora il consumo di Mezzo, con self che è sempre M14: self.km * 2 | 20 |
| 3 | * self.vagoni | Il treno aggiunge la sua regola | 80 |
Sui dati veri: M14 80 kWh. La funicolare F2 stanotte non si è mossa: 0 km, ma 50 kWh, la fune.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return self.consumo() * self.vagoni | Il consumo del treno chiama se stesso: RecursionError: maximum recursion depth exceeded | test_livello_4_il_treno_per_ogni_vagone, test_livello_5_chi_ha_consumato_troppo_in_ordine_alfabetico, test_livello_5_solo_i_treni |
return super().consumo + 50 | Senza parentesi, il metodo più un numero: TypeError: unsupported operand type(s) for +: 'method' and 'int' | test_livello_4_la_funicolare_piu_la_fune, test_livello_4_la_fune_consuma_anche_da_ferma, test_livello_5_chi_ha_consumato_troppo_in_ordine_alfabetico |
Livello 5 · Chi ha consumato troppo
In italiano.
- Parto da una lista vuota.
- Per ogni mezzo: lo tengo se è del tipo cercato (figli compresi) e il contatore segna più di quanto spiega il suo
consumo(). - Alla fine, in ordine alfabetico.
def sospetti(mezzi: list[Mezzo], energia: dict[str, int], tipo: type) -> list[str]:
trovati = []
for mezzo in mezzi:
if isinstance(mezzo, tipo) and energia[mezzo.codice] > mezzo.consumo():
trovati.append(mezzo.codice)
return sorted(trovati)Il disegno.
La riga che conta è mezzo.consumo(): la stessa chiamata per carrelli, treni, tram e funicolari, e ognuno risponde con la sua regola. Nessun if sul tipo per scegliere la formula: quella scelta l'hanno già fatta le classi.
Passo per passo, sui dati veri, sospetti(flotta, ENERGIA, Tram):
| Mezzo | isinstance(mezzo, Tram) | consumo() | ENERGIA | Sospetto? |
|---|---|---|---|---|
| S01, S02 | no: carrelli | |||
| M12, M14 | no: treni | |||
| T05 | sì | 36 | 36 | no: 36 non è più di 36 |
| T09 | sì | 0 | 0 | no |
| T28 | sì: è un TramStorico, figlio di Tram | 6 | 33 | sì |
| F1, F2 | no: funicolari |
Sui dati veri: tutta la flotta dà ['M12', 'T28']; solo i tram, ['T28'].
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
type(mezzo) == tipo | Nessun treno è un Mezzo e il tram storico non è un Tram: sui dati veri, due elenchi vuoti | test_livello_5_chi_ha_consumato_troppo_in_ordine_alfabetico, test_livello_5_tra_i_tram_ci_sono_anche_i_figli |
!= al posto di > | Diventa sospetto anche chi ha consumato meno: sui dati veri, il carrello S02 con il contatore guasto | test_livello_5_consumare_meno_non_e_sospetto |
return trovati, senza sorted | I codici escono nell'ordine della lista, non in quello alfabetico | test_livello_5_chi_ha_consumato_troppo_in_ordine_alfabetico |
Il finale
- Livello 5: due mezzi hanno consumato più di quanto spiegano i loro viaggi. Il treno M12 (72 kWh contro 48) e il tram T28 (33 contro 6).
- Gli appunti: la telecamera ha visto uscire un tram. M12 è un treno: dal cancello dei tram non passa. Tra i tram resta solo T28. (I 24 kWh in più di M12 sono un'altra storia: una prova dei freni che l'officina si era dimenticata di scrivere.)
- Il carrello S02 ha consumato meno, non di più: il contatore guasto del foglio dell'officina. Con
>non è mai stato un sospetto. - Il quaderno: T28 è il tram storico del 1928, e accanto al codice c'è il nome del suo conducente. I 27 kWh che mancano sono 9 km di tram, fatti a computer spento.
T28 lo guida Gualtiero Brivio, il tranviere più anziano della linea: l'unico che sa ancora guidare il tram del 1928.
python storia/verifica.py "Gualtiero Brivio"