Vai al contenuto
code-to-code

Apro l'indice…

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

Python10. L'ereditarietàp. 320

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.

python-ereditarieta-soluzioni.zip19 KB

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.

Python
class Navetta(Mezzo):
    def e_piena(self) -> bool:
        return self.posti_liberi() <= 0

posti_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 sbagliatoCosa succedeIl test rosso
return self.posti_liberi == 0Senza 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 definedtest_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.

  1. Faccio lavorare l'__init__ del genitore: scrive codice, posti e zero persone a bordo.
  2. Poi scrivo il dato che ha solo il bus: la tratta.
Python
class BusSostitutivo(Mezzo):
    def __init__(self, codice: str, posti: int, tratta: str) -> None:
        super().__init__(codice, posti)
        self.tratta = tratta

super().__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 sbagliatoCosa succedeIl test rosso
Solo self.tratta = trattaL'__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 nemmenotutti 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.

  1. sali: qualunque cosa succeda, mi fermo con un errore che dice quale treno è.
  2. descrivi: il codice del treno, e la frase sua.
Python
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 sbagliatoCosa succedeIl 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 ValueErrortest_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 ValueErrortest_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.

  1. sali: all'inizio salgono tutti quelli che aspettano.
  2. Se sono più dei posti liberi, ne salgono solo quanti sono i posti liberi.
  3. A farli salire davvero è il sali del genitore.
  4. descrivi: «Funicolare », più la descrizione del genitore.
Python
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:

inizio sali(self, persone) entrano = persone se entrano > self.posti_liberi() sì: entrano = self.posti_liberi() super().sali(entrano) finesali(self, persone)entrano = personeentrano >self.posti_liberi()entrano =self.posti_liberi()super().sali(entrano)finenosì
La funicolare non strabocca

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

Chiamataself.posti_liberi()entranoChi fa salirea_bordo dopo
funi.sali(5)85super().sali(5), cioè Mezzo5
funi.sali(6)36, poi 3super().sali(3), cioè Mezzo8
funi.descrivi()super().descrivi() dà "F1: 8 a bordo su 8 posti""Funicolare F1: 8 a bordo su 8 posti"

Le trappole.

Il codice sbagliatoCosa succedeIl 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 exceededtest_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().descriviSenza parentesi è il metodo, non la stringa: TypeError: can only concatenate str (not "method") to strtest_il_tabellone

5 · La rimessa di Vecchia Fiera

In italiano.

  1. Una rimessa nuova ha un nome e una lista vuota: la sua.
  2. aggiungi: il mezzo va in fondo alla lista.
  3. tabellone: a ogni mezzo chiedo descrivi(), e metto la risposta in una lista nuova.
  4. solo: un setaccio. Tengo i mezzi per cui isinstance(mezzo, tipo) dice sì.
Python
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 trovati

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

mezzoLa sua classeisinstance(mezzo, Tram)type(mezzo) == Tramtrovati dopo
S01Mezzono: un mezzo non è per forza un tramno[]
T05Tramsìsì[T05]
TN1TramNotturnosì: il genitore di TramNotturno è Tramno[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 sbagliatoCosa succedeIl 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 allungatest_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 stessa

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

Python
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 * 2

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

Python
class Treno(Mezzo):
    def __init__(self, codice: str, conducente: str, vagoni: int) -> None:
        super().__init__(codice, conducente)
        self.vagoni = vagoni

Sui dati veri: M12 ha 6 vagoni, M14 ne ha 4.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Solo self.vagoni = vagoniIl 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 nascetutti 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.

Python
class Tram(Mezzo):
    def consumo(self) -> int:
        return self.km * 3

Sui 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 sbagliatoCosa succedeIl 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 sospettitest_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.

Python
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() + 50

Passo per passo, m14.consumo() sui dati veri (10 km, 4 vagoni):

#Dove siamoCosa succedeIl valore
1Treno.consumoLa ricerca trova il metodo nel treno
2super().consumo()Lavora il consumo di Mezzo, con self che è sempre M14: self.km * 220
3* self.vagoniIl treno aggiunge la sua regola80

Sui dati veri: M14 80 kWh. La funicolare F2 stanotte non si è mossa: 0 km, ma 50 kWh, la fune.

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
return self.consumo() * self.vagoniIl consumo del treno chiama se stesso: RecursionError: maximum recursion depth exceededtest_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 + 50Senza 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.

  1. Parto da una lista vuota.
  2. Per ogni mezzo: lo tengo se è del tipo cercato (figli compresi) e il contatore segna più di quanto spiega il suo consumo().
  3. Alla fine, in ordine alfabetico.
Python
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.

inizio sospetti(mezzi, energia, tipo) trovati = [] per ogni mezzo in mezzi se è del tipo e consuma più del previsto sì: trovati.append(mezzo.codice) restituisci sorted(trovati)sospetti(mezzi, energia,tipo)trovati = []per ogni mezzo in mezziè del tipo e consumapiù del previstotrovati.append(mezzo.codice)restituisci sorted(trovati)nosìfiniti
Chi ha consumato troppo

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

Mezzoisinstance(mezzo, Tram)consumo()ENERGIASospetto?
S01, S02no: carrelli
M12, M14no: treni
T05sì3636no: 36 non è più di 36
T09sì00no
T28sì: è un TramStorico, figlio di Tram633sì
F1, F2no: funicolari

Sui dati veri: tutta la flotta dà ['M12', 'T28']; solo i tram, ['T28'].

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
type(mezzo) == tipoNessun treno è un Mezzo e il tram storico non è un Tram: sui dati veri, due elenchi vuotitest_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 guastotest_livello_5_consumare_meno_non_e_sospetto
return trovati, senza sortedI codici escono nell'ordine della lista, non in quello alfabeticotest_livello_5_chi_ha_consumato_troppo_in_ordine_alfabetico

Il finale

  1. 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).
  2. 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.)
  3. Il carrello S02 ha consumato meno, non di più: il contatore guasto del foglio dell'officina. Con > non è mai stato un sospetto.
  4. 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.

Terminale
python storia/verifica.py "Gualtiero Brivio"