Classi e oggetti, 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.
Nel codice qui sotto mancano le docstring e i type hints, per stare corti: nei file scaricati ci sono.
La palestra
1 · Il badge nuovo
In italiano. Riempio la scatola del badge nuovo: tre attributi arrivano dai parametri, il quarto è sempre True.
class Badge:
def __init__(self, numero, nome, ruolo):
self.numero = numero
self.nome = nome
self.ruolo = ruolo
self.attivo = TrueLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
nome = nome, senza self. | Il nome finisce su un foglietto di __init__, che si butta. Chi lo cerca trova AttributeError: 'Badge' object has no attribute 'nome' | test_il_badge_ricorda_i_suoi_dati, test_ogni_badge_ha_i_suoi_dati |
def __init__(self, numero, nome, ruolo, attivo) | Sembra giusto, «ogni attributo un parametro». Ma i badge si creano con tre valori: TypeError: Badge.__init__() missing 1 required positional argument: 'attivo' | tutti e tre |
Un attributo non deve per forza arrivare da fuori. Se ha sempre lo stesso valore all'inizio, si scrive direttamente in __init__.
2 · Il tornello che conta
In italiano. passa: i passaggi di questo tornello aumentano di uno. azzera: tornano a zero.
def passa(self):
self.passaggi = self.passaggi + 1
def azzera(self):
self.passaggi = 0Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
passaggi = self.passaggi + 1 | Nessun errore: il conto va su un foglietto e si butta. I passaggi restano 0: assert 0 == 1 | test_un_passaggio, test_tre_passaggi, test_ogni_tornello_conta_i_suoi |
def passa(): | TypeError: Tornello.passa() takes 0 positional arguments but 1 was given: Python passa la scatola, la def non ha posto per lei | gli stessi tre |
self.passaggi == 0 in azzera | == confronta, non assegna: la riga calcola False e lo butta via. I passaggi restano 340 | test_azzera |
La prima è la più comune, e la più cattiva: il programma gira, non si lamenta, e i conti sono sbagliati. Quando un metodo «non fa niente», guarda la riga con l'=: a sinistra c'è self.?
3 · Il cartello di stazione
In italiano. testo: compongo la frase con la stazione e i minuti di questo cartello, e la restituisco. in_arrivo: restituisco la risposta alla domanda «i minuti sono al massimo uno?».
def testo(self):
return f"{self.stazione}: prossimo treno tra {self.minuti} min"
def in_arrivo(self):
return self.minuti <= 1self.minuti <= 1 è già True o False: non serve un if per restituirlo.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
print(...) al posto di return in testo | Il testo compare nel terminale, ma il metodo restituisce None: assert None == 'Porta Codice: prossimo treno tra 3 min' | test_il_testo_del_cartello, test_ogni_cartello_ha_il_suo_testo |
f"{stazione}: prossimo treno tra {minuti} min" | Dentro il metodo stazione da sola non esiste: NameError: name 'stazione' is not defined | gli stessi due |
if self.minuti <= 1: return True, e basta | Quando il treno è lontano, il metodo arriva in fondo senza return e restituisce None. E None non è False: assert None is False | test_non_ancora_in_arrivo |
4 · La tessera a corse
In italiano.
ricarica: aggiungo le corse nuove a quelle che ci sono.timbra: se c'è almeno una corsa, ne tolgo una e rispondoTrue.- Altrimenti non tocco niente e rispondo
False.
def ricarica(self, quante):
self.corse = self.corse + quante
def timbra(self):
if self.corse > 0:
self.corse = self.corse - 1
return True
return FalseIl disegno.
timbra fa due cose insieme: cambia l'oggetto e risponde. Il return True chiude il metodo: il return False in fondo si raggiunge solo quando l'if è falso.
Passo per passo, con t.ricarica(1), poi due volte t.timbra():
| Chiamata | self.corse prima | self.corse > 0? | Restituisce | self.corse dopo |
|---|---|---|---|---|
t.ricarica(1) | 0 | — | None | 1 |
t.timbra() | 1 | sì | True | 0 |
t.timbra() | 0 | no | False | 0 |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
def ricarica(quante): | TypeError: Tessera.ricarica() takes 1 positional argument but 2 were given: due cose passate (la tessera e le corse), un posto solo | test_ricarica, test_due_ricariche_si_sommano, test_timbra_scala_una_corsa, test_l_ultima_corsa |
self.corse = quante | La seconda ricarica cancella la prima: 5 corse invece di 15 | test_due_ricariche_si_sommano |
timbra senza if: toglie una corsa e return True | Con la tessera vuota si passa lo stesso, e le corse vanno a -1: assert True is False | test_senza_corse_non_si_passa, test_l_ultima_corsa |
5 · Il binario sul tabellone
In italiano.
occupa: il codice del treno va nell'attributotreno.libera: l'attributo tornaNone.__repr__: setrenoèNonela parola è «libero», altrimenti è il codice. Poi compongo il testo e lo restituisco.
def occupa(self, codice):
self.treno = codice
def libera(self):
self.treno = None
def __repr__(self):
if self.treno is None:
stato = "libero"
else:
stato = self.treno
return f"{self.stazione}, binario {self.numero}: {stato}"Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
def __str__ al posto di def __repr__ | print(b) funziona, ma dentro una lista Python chiede __repr__, e trova solo quello di serie, che mostra l'indirizzo: [<binario.Binario object at 0x…>, …] | test_si_legge_anche_in_una_lista |
print(...) al posto di return in __repr__ | TypeError: __str__ returned non-string (type NoneType), e nella lista __repr__ returned non-string | tutti e quattro |
self.treno = "libero" in libera | Il tabellone mostra la cosa giusta, ma il dato è sbagliato: un treno che si chiama «libero». assert 'libero' is None | test_libera |
La terza è un errore di idea, più che di codice: il dato e come lo mostri sono due cose diverse. Il dato è None; la parola «libero» la decide __repr__, solo quando serve mostrarlo.
6 · Le lampade della galleria
In italiano.
aggiungi: metto la lampada, l'oggetto intero, in fondo alla lista.spente: setaccio la lista; di ogni lampada spenta tengo il codice.accendi_tutte: per ogni lampada, chiamo il suoaccendi.
def aggiungi(self, lampada):
self.lampade.append(lampada)
def spente(self):
codici = []
for lampada in self.lampade:
if not lampada.accesa:
codici.append(lampada.codice)
return codici
def accendi_tutte(self):
for lampada in self.lampade:
lampada.accendi()Il disegno, nel test test_la_lampada_nella_galleria_e_la_stessa: la lampada viene spenta dopo essere entrata nella galleria.
append non fa una copia: mette nella lista una freccia verso la stessa scatola di l1. Così l1.spegni() spegne anche la lampada «della galleria», perché è una sola.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
codici.append(lampada) | Una lista di oggetti al posto di una lista di codici: [<galleria.Lampada object at 0x…>] == ['L-2', 'L-3'] | test_spente, test_la_lampada_nella_galleria_e_la_stessa |
self.accendi() dentro il for | self è la galleria, non la lampada del giro: AttributeError: 'Galleria' object has no attribute 'accendi' | test_accendi_tutte |
if not lampada.accesa(): | accesa è un attributo, un bool, non un metodo: TypeError: 'bool' object is not callable | test_spente, test_nessuna_spenta, test_la_lampada_nella_galleria_e_la_stessa |
7 · Le bici di Ponte Ciclo
In italiano.
aggancia: se la rastrelliera è piena, no. Se la bici è già qui, no. Altrimenti la metto nel dizionario, con il suo numero come chiave, e rispondo sì.sgancia: se il numero non c'è,None. Se c'è, prendo la bici, cancello la chiave e restituisco la bici.liberi: i posti meno le bici che ci sono.
def aggancia(self, bici):
if len(self.bici) >= self.posti:
return False
if bici.numero in self.bici:
return False
self.bici[bici.numero] = bici
return True
def sgancia(self, numero):
if numero not in self.bici:
return None
bici = self.bici[numero]
del self.bici[numero]
return bici
def liberi(self):
return self.posti - len(self.bici)Il disegno, di aggancia:
I controlli vengono prima di scrivere, ognuno con il suo return False: quando uno scatta, il metodo finisce lì, e il dizionario non viene toccato.
Passo per passo, nel test test_la_bici_passa_da_una_rastrelliera_all_altra:
| Riga | Cosa succede | ponte.bici | query.bici | Le etichette sulla bici 7 |
|---|---|---|---|---|
ponte.aggancia(b7) | c'è posto e non c'è già: entra | {7: Bici 7 (0 km)} | {} | b7, ponte.bici[7] |
in_viaggio = ponte.sgancia(7) | la prende, cancella la chiave, la restituisce | {} | {} | b7, in_viaggio |
in_viaggio.pedala(4) | self è la bici 7 | {} | {} | b7, in_viaggio |
query.aggancia(in_viaggio) | entra a Piazza Query | {} | {7: Bici 7 (4 km)} | b7, in_viaggio, query.bici[7] |
Una bici sola, tre etichette. del self.bici[numero] toglie un'etichetta (quella della rastrelliera), non la bici: la bici resta, finché qualcuno la indica.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
| Nessun controllo sui posti | La terza bici entra in una rastrelliera da due: assert True is False | test_piena |
bici = self.bici[numero] senza controllare prima | Le quadre su una chiave che non c'è: KeyError: 99 | test_sgancia_una_bici_che_non_c_e |
return self.bici.get(numero) | Restituisce la bici ma non la toglie: assert 7 not in {7: Bici 7 (0 km)}. La stessa bici risulta agganciata in due stazioni | test_sgancia_restituisce_la_bici, test_la_bici_passa_da_una_rastrelliera_all_altra |
La storia
Livello 1 · La scheda
In italiano. Quattro attributi: tre dalla scheda, e la lista dei guasti, vuota.
def __init__(self, codice, vagoni, km):
self.codice = codice
self.vagoni = vagoni
self.km = km
self.guasti = []Nel quaderno: {'codice': 'M99', 'vagoni': 3, 'km': 4990, 'guasti': []}.
La trappola. self.km = 0, copiato dall'in_corsa della teoria che partiva sempre uguale. I km però arrivano dalla scheda. Diventano rossi i due test del livello 1, test_livello_1_la_scheda e test_livello_1_ogni_treno_ha_la_sua_scheda, e con loro otto test dei livelli dopo: test_livello_2_percorri_somma_i_km, test_livello_3_a_5000_km_non_parte, i due cartellini del livello 4, test_livello_5_dal_codice_al_treno e tre test del livello 6. Uno stampo sbagliato si porta dietro tutti gli oggetti fatti con lui. Se tanti livelli diventano rossi insieme, guarda prima __init__.
Livello 2 · La notte di un treno
In italiano. Tre metodi che cambiano il treno: i km si sommano, i guasti si mettono in fila, la riparazione svuota la fila.
def percorri(self, km):
self.km = self.km + km
def segnala_guasto(self, guasto):
self.guasti.append(guasto)
def ripara(self):
self.guasti = []Nel quaderno: dopo 5 km e un guasto, {'codice': 'M99', 'vagoni': 3, 'km': 4995, 'guasti': ['luci']}; dopo la riparazione, 'guasti': [].
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
self.km = km | I km della notte prendono il posto di quelli vecchi: assert 2 == 1042 | test_livello_2_percorri_somma_i_km, test_livello_6_i_km_della_notte, test_livello_6_cambia_i_treni_che_sono_gia_nel_deposito |
guasti = [] in ripara | La lista vuota finisce su un foglietto: i guasti restano, assert ['porte', 'luci'] == [] | test_livello_2_ripara_toglie_tutti_i_guasti, test_livello_3_dopo_la_riparazione_parte, test_livello_6_guasti_e_riparazioni |
Livello 3 · Il controllo
In italiano. I posti sono i vagoni per i posti di un vagone. Un treno può uscire se non ha guasti e ha meno km del limite.
def posti(self):
return self.vagoni * POSTI_PER_VAGONE
def puo_partire(self):
return len(self.guasti) == 0 and self.km < KM_REVISIONENel quaderno: Posti: 360 · può partire: True.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
self.km <= KM_REVISIONE | Un treno con 5000 km esatti esce invece di andare in officina: assert True is False | test_livello_3_a_5000_km_non_parte |
return vagoni * POSTI_PER_VAGONE | NameError: name 'vagoni' is not defined: i vagoni stanno nella scatola | test_livello_3_i_posti, test_livello_5_sono_treni_con_i_loro_metodi |
Livello 4 · Il cartellino
In italiano.
- Decido l'elenco dei guasti: «nessuno» se la lista è vuota, altrimenti i guasti uniti da virgola e spazio.
- Compongo il cartellino e lo restituisco.
def __repr__(self):
if len(self.guasti) == 0:
elenco = "nessuno"
else:
elenco = ", ".join(self.guasti)
return f"{self.codice} · {self.vagoni} vagoni · {self.km} km · guasti: {elenco}"Nel quaderno: M99 · 3 vagoni · 4995 km · guasti: nessuno.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
print(...) al posto di return | TypeError: __str__ returned non-string (type NoneType); nella lista, __repr__ returned non-string | tutti e tre i test del livello 4 |
elenco = self.guasti, senza join | Il cartellino mostra la lista com'è: guasti: ['porte', 'luci'] | test_livello_4_il_cartellino_con_i_guasti |
Livello 5 · Il deposito
In italiano. Per ogni scheda costruisco un treno, e lo metto nel dizionario con il suo codice come chiave.
def crea_deposito(schede):
deposito = {}
for scheda in schede:
treno = Treno(scheda["codice"], scheda["vagoni"], scheda["km"])
deposito[treno.codice] = treno
return depositoÈ lo schema «indicizzare» del capitolo dei dizionari, con una riga in più: dalla scheda, che è un dizionario, nasce un oggetto.
Nel quaderno, il deposito alle 22:00:
M10 · 3 vagoni · 300 km · guasti: nessuno
M12 · 4 vagoni · 2600 km · guasti: nessuno
M14 · 6 vagoni · 4180 km · guasti: nessuno
M16 · 6 vagoni · 3900 km · guasti: nessuno
M18 · 7 vagoni · 1500 km · guasti: nessuno
M20 · 6 vagoni · 4100 km · guasti: nessuno
M22 · 7 vagoni · 4940 km · guasti: nessuno
M24 · 5 vagoni · 900 km · guasti: nessunoLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
deposito[scheda["codice"]] = scheda | Nel deposito ci sono le schede, non i treni. Un dizionario non ha attributi né metodi: AttributeError: 'dict' object has no attribute 'vagoni' | test_livello_5_dal_codice_al_treno, test_livello_5_sono_treni_con_i_loro_metodi |
deposito[treno] = treno | Un oggetto può fare da chiave (un dizionario no), quindi nessun errore subito. Ma la chiave è la scatola intera, non il codice: deposito["X2"] dà KeyError: 'X2' | gli stessi due |
Livello 6 · La notte nel deposito
In italiano.
- Per ogni voce del registro, trovo il treno nel deposito e gli attacco un'etichetta,
treno. - Guardo cosa è successo, e chiamo il metodo giusto su quel treno.
def applica_registro(deposito, registro):
for voce in registro:
treno = deposito[voce["treno"]]
if voce["cosa"] == "percorre":
treno.percorri(voce["valore"])
elif voce["cosa"] == "guasto":
treno.segnala_guasto(voce["valore"])
elif voce["cosa"] == "riparato":
treno.ripara()Il disegno.
La funzione non restituisce niente, e non scrive mai nel dizionario: treno è una seconda etichetta sulla scatola che sta nel deposito. Cambiare il treno da treno è cambiarlo nel deposito.
Passo per passo, le voci di M16 nel registro vero:
| Ora | Voce | Cosa chiama | M16 dopo |
|---|---|---|---|
| 22:00 | la scheda | Treno("M16", 6, 3900) | M16 · 6 vagoni · 3900 km · guasti: nessuno |
| 00:50 | "guasto", "freni" | treno.segnala_guasto("freni") | M16 · 6 vagoni · 3900 km · guasti: freni |
| 03:30 | "riparato", None | treno.ripara() | M16 · 6 vagoni · 3900 km · guasti: nessuno |
| 04:10 | "percorre", 30 | treno.percorri(30) | M16 · 6 vagoni · 3930 km · guasti: nessuno |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
deposito[voce["treno"]] = treno.percorri(voce["valore"]) | percorri restituisce None, e None prende il posto del treno nel deposito. Alla voce dopo: AttributeError: 'NoneType' object has no attribute 'percorri' | test_livello_6_i_km_della_notte, test_livello_6_cambia_i_treni_che_sono_gia_nel_deposito |
Nessun ramo per "riparato" | Le riparazioni della notte non arrivano ai treni: assert ['porte'] == [] | test_livello_6_guasti_e_riparazioni |
Il finale
Il quaderno, con tutti i livelli verdi, mostra il deposito alle 5:00:
M10 · 3 vagoni · 300 km · guasti: nessuno · posti: 360 · può partire: True
M12 · 4 vagoni · 2600 km · guasti: nessuno · posti: 480 · può partire: True
M14 · 6 vagoni · 4300 km · guasti: nessuno · posti: 720 · può partire: True
M16 · 6 vagoni · 3930 km · guasti: nessuno · posti: 720 · può partire: True
M18 · 7 vagoni · 1500 km · guasti: porte, luci · posti: 840 · può partire: False
M20 · 6 vagoni · 4100 km · guasti: nessuno · posti: 720 · può partire: True
M22 · 7 vagoni · 5000 km · guasti: nessuno · posti: 840 · può partire: False
M24 · 5 vagoni · 900 km · guasti: porte · posti: 600 · può partire: FalseLe quattro regole, una alla volta:
- Guasti aperti: M18 (porte e luci) e M24 (porte) restano in deposito.
- 5000 km o più: M22 è arrivato a 5000 esatti con i 60 km delle 23:15. Va in officina.
- Il più capiente tra quelli che restano: 720 posti, e li hanno in tre, M14, M16 e M20.
- Meno km: M16 con 3930, poi M20 con 4100, poi M14 con 4300.
Esce M16: i freni rotti a mezzanotte e cinquanta, riparati alle 3:30, provati per 30 km alle 4:10.
python storia/verifica.py M16Le strade sbagliate più probabili, e dove portano:
| Risposta | Dove ti sei perso |
|---|---|
| M22 | I km della notte non si sommano (livello 2 o 6), oppure puo_partire lascia uscire un treno con 5000 km esatti (livello 3) |
| M18 | I guasti non arrivano al treno (livelli 2 e 6), oppure puo_partire non li guarda (livello 3) |
| M20 | Le riparazioni non funzionano: ripara (livello 2) o il ramo "riparato" (livello 6). M16 risulta ancora con i freni rotti |
| M14 | A parità di posti hai preso il primo della lista, non quello con meno km |
| M10 | Hai guardato solo i km: M10 è quasi nuovo, ma con 360 posti settecento persone non ci stanno |