Le funzioni, 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 · Il cartellino del vagone
In italiano. Metto il treno in maiuscolo, poi compongo il cartellino: treno, trattino, numero. E lo consegno.
def codice_vagone(treno: str, numero: int) -> str:
return f"{treno.upper()}-{numero}"Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
print(f"{treno.upper()}-{numero}") al posto di return | Il cartellino compare sullo schermo, ma la funzione consegna None: assert None == 'M12-3'. E nella frase: TypeError: can only concatenate str (not "NoneType") to str | test_treno_e_numero, test_il_treno_in_maiuscolo, test_il_cartellino_si_puo_usare_in_una_frase |
treno.upper() da solo su una riga, poi return f"{treno}-{numero}" | upper restituisce un testo nuovo, e nessuno lo prende: treno resta com'era. assert 'm14-1' == 'M14-1' | test_il_treno_in_maiuscolo |
La prima è la trappola del capitolo. Se lanci il file con il print al posto del return, la vedi con i tuoi occhi:
M12-3
None
M14-1
NoneOgni cartellino compare due volte, in due modi diversi: la prima riga la stampa la funzione, la seconda è il print del blocco in fondo che stampa quello che la funzione ha consegnato. Cioè niente.
2 · I posti liberi
In italiano.
- I posti del treno sono i vagoni per 120; tolgo le persone a bordo.
- Se il conto viene sotto zero, i posti liberi sono 0.
- Altrimenti consegno il conto.
def posti_liberi(vagoni: int, a_bordo: int) -> int:
"""Restituisce i posti liberi sul treno: mai meno di zero.
posti_liberi(4, 300) -> 180
"""
liberi = vagoni * POSTI_PER_VAGONE - a_bordo
if liberi < 0:
return 0
return liberiOgni pezzo della prima riga è una richiesta del commento: il nome, i due parametri nell'ordine, un tipo per ciascuno, -> int per quello che esce. La docstring è la prima riga del corpo. Va bene anche return max(0, liberi): il più grande tra 0 e il conto.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
def posti_liberi(vagoni, a_bordo):, senza i tipi | Il conto è giusto, ma i type hints mancano. Il test li legge in posti_liberi.__annotations__ e li trova vuoti | test_ha_i_type_hints |
def posti_liberi(n: int, persone: int) -> int: | I nomi dei parametri fanno parte della funzione: chi la chiama con a_bordo=10 riceve TypeError: posti_liberi() got an unexpected keyword argument 'a_bordo' | test_i_parametri_hanno_il_nome_giusto, test_ha_i_type_hints |
Solo return vagoni * POSTI_PER_VAGONE - a_bordo | Con 150 persone su un vagone i posti liberi sono -30 | test_piu_persone_che_posti |
3 · La lucina del ritardo
In italiano. Dal ritardo più piccolo al più grande: in orario o in anticipo, verde; fino a 5, giallo; fino a 15, arancione. Tutto il resto, rosso.
def colore_ritardo(minuti: int) -> str:
if minuti <= 0:
return "verde"
if minuti <= 5:
return "giallo"
if minuti <= 15:
return "arancione"
return "rosso"Il disegno.
Passo per passo. Quattro ingressi, quattro strade:
minuti | <= 0? | <= 5? | <= 15? | Cosa esce |
|---|---|---|---|---|
| -2 | sì | — | — | "verde" |
| 5 | no | sì | — | "giallo" |
| 6 | no | no | sì | "arancione" |
| 40 | no | no | no | l'ultimo return: "rosso" |
Dopo ogni return la funzione è già uscita: per questo il secondo if può scrivere solo minuti <= 5, senza ripetere «e più di 0».
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Manca l'ultimo return "rosso" | Con 16 minuti nessun if è vero e la funzione finisce senza return: assert None == 'rosso' | test_rosso_oltre_quindici_minuti |
Gli if in ordine inverso, partendo da minuti <= 15 | Vince il primo return che si incontra: con 0 minuti 0 <= 15 è già vero, e la lucina è arancione | test_in_orario_e_in_anticipo, test_giallo_fino_a_cinque_minuti |
< al posto di <= | I confini scivolano nel colore dopo: 0 diventa giallo, 5 arancione, 15 rosso | test_in_orario_e_in_anticipo, test_giallo_fino_a_cinque_minuti, test_arancione_fino_a_quindici_minuti |
4 · L'avviso in banchina
In italiano.
- Tre parametri: la stazione obbligatoria, il binario che di default vale 1, il ritardo che di default vale 0.
- Il pezzo che non cambia mai: stazione, binario, «treno in arrivo».
- Se c'è ritardo aggiungo i minuti e il punto; altrimenti solo il punto.
def avviso(stazione: str, binario: int = 1, ritardo: int = 0) -> str:
"""Restituisce il testo dell'avviso per il treno in arrivo."""
inizio = f"{stazione}, binario {binario}: treno in arrivo"
if ritardo > 0:
return f"{inizio} con {ritardo} minuti di ritardo."
return f"{inizio}."L'ordine dei parametri è una scelta: il binario sta prima del ritardo perché chi chiama passa più spesso il binario, e così può scriverlo senza nome: avviso("Largo Lista", 2).
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
def avviso(stazione: str, ritardo: int = 0, binario: int = 1) -> str: | Senza nome il 2 finisce nel secondo posto, che adesso è il ritardo: «Largo Lista, binario 1: treno in arrivo con 2 minuti di ritardo.» | test_la_stazione_e_il_binario |
def avviso(stazione: str, binario: int, ritardo: int) -> str:, senza default | Chi passa solo la stazione riceve TypeError: avviso() missing 2 required positional arguments: 'binario' and 'ritardo' | test_solo_la_stazione, test_la_stazione_e_il_binario, test_il_ritardo_con_il_suo_nome |
Nella prima trappola il test con tutti i nomi resta verde: con i nomi, l'ordine della def non conta più. È proprio il motivo per cui i nomi aiutano.
5 · Il gruppo in banchina
In italiano.
- Guardo i vagoni uno per uno, con la loro posizione.
- Appena un vagone ha posti liberi almeno quante sono le persone, consegno il suo numero: la posizione più uno.
- Se arrivo in fondo senza trovarlo,
None.
def primo_vagone_libero(posti: list[int], persone: int) -> int | None:
for i, liberi in enumerate(posti):
if liberi >= persone:
return i + 1
return NoneIl disegno.
Passo per passo, con [0, 3, 12, 40] e 10 persone:
| Giro | i | liberi | liberi >= 10? | Cosa succede |
|---|---|---|---|---|
| 1 | 0 | 0 | no | avanti |
| 2 | 1 | 3 | no | avanti |
| 3 | 2 | 12 | sì | return 3: la funzione finisce qui |
| 4 | — | — | — | il vagone da 40 non lo guarda nessuno |
Senza l'ultima riga il test «nessun vagone» passerebbe lo stesso, perché una funzione che finisce senza return consegna None. Scriverla dice a chi legge che quel caso l'hai pensato.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
else: return None dentro il for | Al primo vagone pieno la funzione esce: con [0, 3, 12, 40] risponde None già al giro 1 | test_il_primo_che_ha_posto, test_i_posti_giusti_giusti_bastano, test_il_primo_non_il_piu_vuoto |
trovato = i + 1 dentro il for, e return trovato dopo | Il ciclo arriva fino in fondo, e ogni vagone buono prende il posto del precedente: esce l'ultimo con posto, 4 invece di 3 | test_il_primo_che_ha_posto, test_i_posti_giusti_giusti_bastano, test_il_primo_non_il_piu_vuoto |
return i | Le posizioni partono da 0, i cartelli da 1: il terzo vagone diventa il 2 | test_il_primo_che_ha_posto, test_si_conta_da_uno, test_i_posti_giusti_giusti_bastano, test_il_primo_non_il_piu_vuoto |
6 · Il turno del macchinista
In italiano.
in_minuti: divido l'ora in ore e minuti, li trasformo in numeri, e consegno ore per 60 più minuti.durata_turno: chiedo ain_minutii minuti dell'inizio e della fine, li salvo, e consegno la differenza.
def in_minuti(ora: str) -> int:
ore, minuti = ora.split(":")
return int(ore) * 60 + int(minuti)
def durata_turno(inizio: str, fine: str) -> int:
minuti_inizio = in_minuti(inizio)
minuti_fine = in_minuti(fine)
return minuti_fine - minuti_inizioPasso per passo, durata_turno("05:30", "13:45"):
| Passo | Dove siamo | Cosa succede |
|---|---|---|
| 1 | durata_turno | chiama in_minuti("05:30"): salta dentro |
| 2 | in_minuti | "05" e "30" diventano 5 e 30: return 330 |
| 3 | durata_turno | minuti_inizio = 330; chiama in_minuti("13:45") |
| 4 | in_minuti | return 825 |
| 5 | durata_turno | minuti_fine = 825; return 825 - 330, cioè 495 |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
in_minuti(inizio) e in_minuti(fine) da soli, poi return fine - inizio | I minuti si calcolano e si buttano; si sottraggono le ore di partenza, che sono testo: TypeError: unsupported operand type(s) for -: 'str' and 'str' | test_durata_di_un_turno, test_durata_di_un_turno_corto |
In in_minuti, print(…) al posto di return | in_minuti consegna None, e durata_turno fa None - None: TypeError: unsupported operand type(s) for -: 'NoneType' and 'NoneType' | tutti e cinque |
La seconda trappola è in in_minuti, ma rompe anche durata_turno, che è scritta bene. Un errore in una funzione si porta dietro tutte quelle che la usano: quando tanti test sono rossi insieme, comincia dalla funzione più in basso.
7 · Il museo dei tram
In italiano.
ingresso: sotto i 6 anni gratis; sotto i 14 o dai 65 in su il ridotto; tutti gli altri l'intero.costo_gruppo: parto da zero e, per ogni persona, aggiungo il suo ingresso. Alla fine, il totale.conviene_la_tessera: il gruppo pagherebbe più della tessera?
def ingresso(eta: int) -> int:
if eta < 6:
return 0
if eta < 14 or eta >= 65:
return PREZZO_RIDOTTO
return PREZZO_INTERO
def costo_gruppo(eta_di_tutti: list[int]) -> int:
totale = 0
for eta in eta_di_tutti:
totale = totale + ingresso(eta)
return totale
def conviene_la_tessera(eta_di_tutti: list[int], prezzo_tessera: int = 30) -> bool:
return costo_gruppo(eta_di_tutti) > prezzo_tesseraPasso per passo, costo_gruppo([40, 38, 10, 4]):
| Giro | eta | ingresso(eta) | totale dopo il giro |
|---|---|---|---|
| prima | — | — | 0 |
| 1 | 40 | 8 | 8 |
| 2 | 38 | 8 | 16 |
| 3 | 10 | 5 | 21 |
| 4 | 4 | 0 | 21 |
Poi conviene_la_tessera([40, 38, 10, 4]) chiede a costo_gruppo (21) e confronta: 21 > 30 è False, e quel False è già la risposta. Non serve if … return True else return False: un confronto è un True o un False, e si consegna così com'è.
Tre funzioni, tre compiti: ognuna si legge in un colpo d'occhio, si prova da sola, e se cambia il prezzo del ridotto si tocca una riga sola.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return totale dentro il for | Esce al primo giro: il gruppo paga 8 euro invece di 21, e un gruppo vuoto consegna None. Sbagliano anche le risposte sulla tessera, che usano quel totale | test_costo_di_un_gruppo, test_costo_di_un_gruppo_vuoto, test_la_tessera_conviene, test_un_altro_prezzo_della_tessera |
ingresso(eta) da solo dentro il for | Ogni prezzo si calcola e si butta: il totale resta 0 | test_costo_di_un_gruppo, test_la_tessera_conviene, test_un_altro_prezzo_della_tessera |
if costo_gruppo(eta_di_tutti) > prezzo_tessera: return True, e basta | Quando la tessera non conviene non c'è nessun return: assert None is False | test_la_tessera_non_conviene, test_a_parita_la_tessera_non_conviene |
> 30 al posto di > prezzo_tessera | Il parametro c'è, ma nessuno lo usa: chi passa prezzo_tessera=20 riceve la risposta per 30 | test_un_altro_prezzo_della_tessera |
La storia
Livello 1 · La targhetta
In italiano. Tre pezzi del dizionario in una f-string, e la consegno.
def targhetta(treno: dict) -> str:
return f"{treno['codice']} · {treno['vagoni']} vagoni · {treno['carica']}%"Nel pannello vero compaiono le dieci targhette, da M10 · 4 vagoni · 96% a M19 · 4 vagoni · 77%.
La trappola. Con print al posto di return diventano rossi i due test del livello 1, e i tre del livello 6: il tabellone usa targhetta, e scrive Porta Codice: None. Il vecchio pannello era proprio così.
Livello 2 · Il semaforo
In italiano. Dal più grave: porte aperte o batteria sotto il minimo, rosso. Batteria sotto la metà, giallo. Tutto il resto, verde.
def semaforo(treno: dict) -> str:
if not treno["porte_ok"] or treno["carica"] < CARICA_MINIMA:
return "rosso"
if treno["carica"] < CARICA_PIENA:
return "giallo"
return "verde"Nel pannello vero: M10 è rosso con il 96% di carica, per le porte; M14 è verde con il 50% esatto; M13 (45%) e M15 (35%) sono gialli; M17 (porte) e M18 (15%) rossi.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Il verde per primo: if treno["carica"] >= CARICA_PIENA: return "verde", poi il rosso | Un treno con la batteria piena esce dal primo return e le porte non le guarda nessuno. L'errore sale: puo_uscire lo fa partire, primo_in_uscita lo sceglie, il tabellone lo mostra | test_livello_2_le_porte_vengono_prima_di_tutto, test_livello_4_giallo_o_rosso_non_esce, test_livello_5_il_primo_che_puo_uscire, test_livello_5_il_giro_lungo, i tre test_livello_6_… |
treno["carica"] <= CARICA_PIENA | Con il 50% esatto il treno diventa giallo | test_livello_2_il_cinquanta_e_gia_verde |
Livello 3 · I chilometri
In italiano. Il limite meno i km fatti. Il limite è il parametro: o quello che passa chi chiama, o il default.
def km_alla_revisione(treno: dict, limite: int = LIMITE_REVISIONE) -> int:
return limite - treno["km"]Nel pannello vero, M12 ha 8700 km: senza passare il limite gliene restano 3300, con limite=LIMITE_TRENI_LUNGHI solo 300. Stessa funzione, due risposte: decide chi chiama.
La trappola. return LIMITE_REVISIONE - treno["km"]: la costante al posto del parametro. Il limite che passa chi chiama viene ignorato, e il treno lungo sembra avere 3300 km davanti. Rossi: test_livello_3_con_un_altro_limite, test_livello_4_i_treni_lunghi_hanno_il_loro_limite.
Livello 4 · Può uscire?
In italiano.
- Se il semaforo non è verde, la risposta è già
False. - Chiedo i km alla revisione: per un treno lungo con il suo limite, per gli altri con il default.
- Consegno il confronto: bastano per il giro?
def puo_uscire(treno: dict, km_da_fare: int = GIRO_NORMALE) -> bool:
if semaforo(treno) != "verde":
return False
if treno["vagoni"] >= VAGONI_TRENO_LUNGO:
restano = km_alla_revisione(treno, limite=LIMITE_TRENI_LUNGHI)
else:
restano = km_alla_revisione(treno)
return restano >= km_da_fareIl disegno.
Nessun conto rifatto: il colore lo sa semaforo, i chilometri li sa km_alla_revisione. Se domani cambia il regolamento della carica, si tocca solo il semaforo.
Nel pannello vero, per un giro normale possono uscire M11, M12, M14, M16 e M19.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
km_alla_revisione(treno) per tutti, senza il limite dei treni lunghi | Un treno da sei vagoni con 8800 km sembra avere 3200 km davanti, invece di 200 | test_livello_4_i_treni_lunghi_hanno_il_loro_limite |
semaforo == "verde", senza le tonde | Confronta la funzione con un testo: sempre False, nessun errore. Non esce più nessun treno, e i livelli 5 e 6 rispondono «nessun treno» | quattro test_livello_4_…, test_livello_5_il_primo_che_puo_uscire, test_livello_5_il_giro_lungo, i tre test_livello_6_… |
Livello 5 · Il primo della fila
In italiano. Scorro la fila; il primo treno di quel deposito che può fare il giro lo consegno subito. Se arrivo in fondo, None.
def primo_in_uscita(treni: list[dict], deposito: str, km_da_fare: int = GIRO_NORMALE) -> dict | None:
for treno in treni:
if treno["deposito"] == deposito and puo_uscire(treno, km_da_fare):
return treno
return Nonekm_da_fare passa di mano: chi chiama primo_in_uscita lo dà a lei, lei lo dà a puo_uscire. Se lo dimentica, puo_uscire usa il suo default.
Nel pannello vero, a Porta Codice, per un giro normale: M12. M10 è prima nella fila, ma è rosso.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
else: return None dentro il for | Il primo treno della fila non va bene, e la funzione esce subito: «nessun treno» dappertutto | test_livello_5_il_primo_che_puo_uscire, test_livello_5_il_giro_lungo, i tre test_livello_6_… |
| Nessun controllo sul deposito | Esce il primo treno pronto di tutta la linea, anche se dorme in un altro deposito | test_livello_5_il_primo_che_puo_uscire, test_livello_5_un_deposito_senza_treni, test_livello_5_il_giro_lungo, i tre test_livello_6_… |
trovato = treno nel for, e return trovato dopo | Esce l'ultimo della fila, non il primo | test_livello_5_il_primo_che_puo_uscire, test_livello_6_una_riga_per_deposito, test_livello_6_un_deposito_senza_treni |
puo_uscire(treno), senza passare km_da_fare | Il giro lungo si perde per strada: la funzione cerca sempre per un giro normale | test_livello_5_il_giro_lungo, test_livello_6_il_giro_lungo_passa_di_mano |
Livello 6 · Il tabellone
In italiano. Una riga per deposito. Chiedo il primo in uscita; se non c'è, «nessun treno»; se c'è, la sua targhetta.
def tabellone(treni: list[dict], depositi: list[str], km_da_fare: int = GIRO_NORMALE) -> list[str]:
righe = []
for deposito in depositi:
treno = primo_in_uscita(treni, deposito, km_da_fare)
if treno is None:
righe.append(f"{deposito}: nessun treno")
else:
righe.append(f"{deposito}: {targhetta(treno)}")
return righeIl disegno.
Nel pannello vero, per un giro normale:
Porta Codice: M12 · 6 vagoni · 90%
Piazza Query: M11 · 4 vagoni · 88%
Vecchia Fiera: nessun trenoLa trappola. Passare il risultato a targhetta senza controllare: per Vecchia Fiera primo_in_uscita dà None, e targhetta prova a leggere None['codice']. TypeError: 'NoneType' object is not subscriptable. Rosso: test_livello_6_un_deposito_senza_treni. Quando una funzione può rispondere None, chi la chiama controlla con is None prima di usare il risultato.
Il finale
La domanda di Marta Villa è il livello 5 con un argomento in più: il primo della fila a Porta Codice, ma per il giro lungo. In fondo a pannello.py:
primo_giro_lungo = primo_in_uscita(TRENI, "Porta Codice", km_da_fare=GIRO_LUNGO)
print(" Il primo treno da Porta Codice per il giro lungo:", targhetta(primo_giro_lungo)) Il primo treno da Porta Codice per il giro lungo: M14 · 4 vagoni · 50%Passo per passo, la fila di Porta Codice con km_da_fare=450:
| Treno | Semaforo | Limite | Km alla revisione | Bastano per 450? | Esce? |
|---|---|---|---|---|---|
| M10 | rosso: le porte | — | — | — | no |
| M12 | verde | 9000: ha sei vagoni | 300 | no | no |
| M14 | verde: il 50% esatto basta | 12000 | 450 | sì, giusti giusti | sì: return |
| M16, M19 | — | — | — | — | non li guarda nessuno |
Il treno è M14.
python storia/verifica.py M14Le risposte sbagliate più probabili, e da dove vengono:
| Risposta | Da dove viene |
|---|---|
| M10 | Il semaforo guarda la carica prima delle porte (livello 2) |
| M11 | primo_in_uscita non controlla il deposito (livello 5): M11 dorme a Piazza Query |
| M12 | Il giro lungo non è arrivato: manca km_da_fare=GIRO_LUNGO nella chiamata, o primo_in_uscita non lo passa a puo_uscire. Oppure puo_uscire usa per M12 il limite normale (livelli 3 e 4) |
| M16 | Un confine: con <= nel semaforo M14 diventa giallo (livello 2) |
| M19 | primo_in_uscita consegna l'ultimo della fila, non il primo (livello 5) |
None | Un else: return None dentro il for (livello 5), o semaforo senza le tonde (livello 4) |