Le condizioni, 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: con le condizioni le strade giuste sono spesso tante (una scala dall'alto o dal basso, un if o una riga sola). Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: quasi tutte passano qualche test e si rompono su un confine.
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 condizionatore
In italiano. La temperatura va bene se è almeno 19 e al massimo 24.
def temperatura_giusta(gradi: float) -> bool:
return 19 <= gradi <= 24Il confronto dà già True o False: non serve un if che restituisce True e un else che restituisce False. Funziona anche quello, ma è la stessa cosa scritta più lunga.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return 19 < gradi < 24 | Gli estremi restano fuori: a 19 e a 24 gradi la spia è rossa | test_gli_estremi_sono_compresi |
return gradi >= 19 or gradi <= 24 | Ogni numero è almeno 19 oppure al massimo 24: sempre True, anche a 35 gradi | test_troppo_freddo, test_troppo_caldo |
2 · Il tabellone degli arrivi
In italiano. Una scala, nell'ordine della tabella: prima i negativi, poi lo zero, poi i ritardi dal più piccolo al più grande. Quello che resta è il forte ritardo.
def stato_treno(ritardo: int) -> str:
if ritardo < 0:
return "in anticipo"
elif ritardo == 0:
return "in orario"
elif ritardo <= 4:
return "lieve ritardo"
elif ritardo <= 14:
return "in ritardo"
else:
return "forte ritardo"Il disegno.
elif ritardo <= 4 non ha bisogno di dire «da 1»: se Python è arrivato lì, il ritardo non è negativo e non è zero. Va bene anche la scala dall'alto: if ritardo >= 15, poi elif ritardo >= 5, poi elif ritardo >= 1, poi elif ritardo == 0, poi else.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
elif ritardo >= 1: prima di elif ritardo >= 5: | Ogni ritardo positivo si ferma al gradino «lieve»: quelli sotto non li raggiunge nessuno | test_in_ritardo, test_forte_ritardo |
La scala dall'alto con else: return "in orario" in fondo | L'else prende tutto quello che resta, anche i numeri negativi: il treno in anticipo risulta in orario | test_in_anticipo |
3 · Il servizio notturno
In italiano. Il servizio è attivo se sono almeno le 22, oppure se sono meno delle 2.
def servizio_notturno(ora: int) -> bool:
return ora >= 22 or ora < 2Passo per passo, intorno alla mezzanotte:
ora | ora >= 22 | ora < 2 | or |
|---|---|---|---|
| 21 | False | False | False |
| 22 | True | False | True |
| 23 | True | False | True |
| 0 | False | True | True |
| 1 | False | True | True |
| 2 | False | False | False |
Ogni ora soddisfa al massimo una delle due metà, mai tutte e due. Per questo serve or: con and non andrebbe bene nessuna ora.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return 22 <= ora < 2 | Vuol dire 22 <= ora and ora < 2: nessun numero è insieme almeno 22 e minore di 2. Sempre False | test_la_sera, test_dopo_mezzanotte |
return ora >= 22 or ora <= 2 | Alle 2 il servizio risulta ancora attivo | test_le_2_sono_escluse |
4 · Le porte del treno
In italiano. Le porte si aprono se il treno non è in movimento, e in più è in stazione oppure c'è l'emergenza.
def porte_si_aprono(in_movimento: bool, in_stazione: bool, emergenza: bool) -> bool:
return not in_movimento and (in_stazione or emergenza)Passo per passo, quattro casi:
in_movimento | in_stazione | emergenza | not in_movimento | in_stazione or emergenza | Risultato |
|---|---|---|---|---|---|
False | True | False | True | True | True |
False | False | False | True | False | False |
False | False | True | True | True | True |
True | False | True | False | True | False |
Nell'ultima riga la parentesi fa il suo lavoro: l'emergenza c'è, ma and vuole vere tutte e due le metà, e il treno è in corsa.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
not in_movimento and in_stazione or emergenza | Senza parentesi Python fa prima and, poi or: legge (not in_movimento and in_stazione) or emergenza. Con l'emergenza le porte si aprono anche in corsa | test_in_movimento_mai |
in_movimento and (in_stazione or emergenza) | Manca il not: tutto al contrario, le porte si aprono solo in corsa | test_fermo_in_stazione, test_fermo_in_galleria_con_emergenza, test_fermo_in_stazione_con_emergenza, test_in_movimento_mai |
Non serve scrivere in_movimento == False: not in_movimento dice la stessa cosa, e si legge meglio.
5 · Il binario zero
In italiano. Se il binario è None, è da definire. Altrimenti, qualunque numero sia (anche 0), lo scrivo.
def annuncio_binario(treno: str, binario: int | None) -> str:
if binario is None:
return f"{treno}: binario da definire"
return f"{treno}: binario {binario}"Il secondo return non ha bisogno dell'else: se Python arriva lì, il primo return non è partito.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
if binario: | Lo 0 è falso: il treno di servizio diventa «S1: binario da definire» | test_il_binario_zero_esiste |
if binario >= 0: | Con None il confronto non si può fare: TypeError: '>=' not supported between instances of 'NoneType' and 'int' | test_binario_da_definire |
La prima è la più subdola, perché funziona con tutti i binari tranne uno. È lo stesso guaio dell'esempio D: if x: chiede «è vero?», non «c'è?».
6 · La multa del controllore
In italiano.
- Parto da zero.
- Senza biglietto? Aggiungo 50.
- Piedi sul sedile? Aggiungo 20.
- Cane senza museruola? Aggiungo 30.
Tre domande indipendenti: tre if separati.
def multa(senza_biglietto: bool, piedi_sul_sedile: bool, cane_senza_museruola: bool) -> int:
totale = 0
if senza_biglietto:
totale = totale + 50
if piedi_sul_sedile:
totale = totale + 20
if cane_senza_museruola:
totale = totale + 30
return totaleQui if senza_biglietto: senza == True va benissimo: il parametro è già un bool.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
elif al posto del secondo e del terzo if | La scala si ferma alla prima infrazione: senza biglietto e con i piedi sul sedile, 50 invece di 70 | test_due_infrazioni_si_sommano, test_tutte_e_tre |
totale = 20 al posto di totale = totale + 20 | Ogni infrazione sostituisce quella prima: resta solo l'ultima | gli stessi due |
7 · La scadenza dell'abbonamento
In italiano.
- Se il mese di oggi viene prima del mese di scadenza, vale: il giorno non conta.
- Se è lo stesso mese, decide il giorno: vale fino al giorno di scadenza, compreso.
- Se il mese è dopo, è scaduto.
def ancora_valido(giorno: int, mese: int, giorno_scadenza: int, mese_scadenza: int) -> bool:
if mese < mese_scadenza:
return True
elif mese == mese_scadenza:
return giorno <= giorno_scadenza
else:
return FalsePasso per passo, con la scadenza al 10 maggio:
| Oggi | mese < mese_scadenza? | mese == mese_scadenza? | Risposta |
|---|---|---|---|
| 20 marzo | 3 è meno di 5: sì | non la guarda | True |
| 5 maggio | no | sì: 5 è al massimo 10 | True |
| 10 maggio | no | sì: 10 è al massimo 10 | True |
| 11 maggio | no | sì: 11 è più di 10 | False |
| 1 giugno | no | no | False, dall'else |
La stessa cosa in una riga sola, con and e or:
return mese < mese_scadenza or (mese == mese_scadenza and giorno <= giorno_scadenza)Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
giorno <= giorno_scadenza and mese <= mese_scadenza | Giorno e mese confrontati ognuno per conto suo. Il 20 marzo: 20 è più di 10, quindi «scaduto». Ma a marzo il giorno non conta | test_un_mese_prima_vale_anche_se_il_giorno_e_piu_grande |
mese < mese_scadenza or giorno <= giorno_scadenza | Manca «nello stesso mese». Il 1° giugno: 1 è meno di 10, quindi «vale» | test_un_mese_dopo_e_scaduto_anche_se_il_giorno_e_piu_piccolo |
giorno < giorno_scadenza nello stesso mese | Il giorno della scadenza risulta già scaduto: l'abbonamento perde un giorno | test_il_giorno_della_scadenza_vale_ancora, test_l_ultimo_giorno_dell_anno |
Le prime due sono la stessa idea sbagliata: il giorno e il mese non pesano uguale. Prima decide il mese; il giorno conta solo a parità di mese.
La storia
Livello 1 · La tariffa per età
In italiano. Una scala di quattro gradini, dall'età più piccola. Ogni gradino scrive solo il limite di sopra: quello di sotto è già garantito dai gradini prima.
def prezzo_per_eta(eta: int) -> float:
if eta <= 5:
return 0.0
elif eta <= 13:
return 1.1
elif eta <= 64:
return 2.2
else:
return 1.5Nel quaderno: Aldo 1.5, Franca 1.5, Teo 1.1, Rosa 2.2. Per Ugo il livello 1 non basta: la sua tessera non ha l'età.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
elif eta >= 14: return 2.2 e il senior nell'else | Chi ha 14 anni o più si ferma sul gradino dell'intero: l'else del senior non lo raggiunge nessuno | test_livello_1_senior_da_65_anni, e al livello 4 test_livello_4_il_senior_fuori_punta_ha_lo_sconto |
if eta > 65: return 1.5 | Chi ha 65 anni esatti paga l'intero | test_livello_1_senior_da_65_anni |
Livello 2 · L'ora di punta
In italiano. È di punta se l'ora sta tra 7 (compreso) e 10 (escluso), oppure tra 17 (compreso) e 20 (escluso).
def ora_di_punta(ora: int) -> bool:
return 7 <= ora < 10 or 17 <= ora < 20Nel quaderno: alle 10, False. L'ora di punta è appena finita, e questo cambia tutto per due tessere su cinque.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
7 <= ora <= 10 or 17 <= ora <= 20 | Le 10 e le 20 diventano ora di punta | test_livello_2_le_10_e_le_20_sono_escluse |
and al posto di or | Un'ora non è mai insieme di mattina e di sera: l'ora di punta sparisce | test_livello_2_la_mattina, test_livello_2_la_sera, e tre test dei livelli 3, 4 e 5 che chiedono l'ora di punta |
Livello 3 · L'abbonamento
In italiano. Il mensile vale sempre. Il fuori punta vale se è il fuori punta e non è ora di punta. Tutto il resto, None e "scaduto" compresi, non vale.
def abbonamento_valido(abbonamento: str | None, ora: int) -> bool:
if abbonamento == "mensile":
return True
if abbonamento == "fuori punta" and not ora_di_punta(ora):
return True
return FalseNon c'è bisogno di un controllo apposta per None: None == "mensile" è False, e il None arriva da solo all'ultima riga.
Nel quaderno: solo Franca True. Alle 10 il suo fuori punta vale.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
if abbonamento: return True per tutto quello che non è il fuori punta | "scaduto" è una stringa non vuota, quindi è vera: l'abbonamento scaduto fa passare gratis | test_livello_3_l_abbonamento_scaduto_non_vale, test_livello_5_un_abbonamento_che_non_vale_si_paga |
ora_di_punta(ora) senza not | Il fuori punta vale solo in ora di punta: tutto al contrario | test_livello_3_il_fuori_punta_vale_fuori_dall_ora_di_punta, test_livello_3_il_fuori_punta_non_vale_in_ora_di_punta, test_livello_5_un_abbonamento_che_non_vale_si_paga |
Livello 4 · La tessera anonima
In italiano.
- Se l'età non c'è, 2,20. Questo gradino va per primo: dopo,
etaè sicuramente un numero. - Se è un senior e siamo in ora di punta, 2,20.
- Altrimenti, il prezzo per età del livello 1.
def prezzo_corsa(eta: int | None, ora: int) -> float:
if eta is None:
return 2.2
elif eta >= 65 and ora_di_punta(ora):
return 2.2
else:
return prezzo_per_eta(eta)Nel quaderno: Ugo 2.2. Aldo e Franca 1.5: sono senior, ma alle 10 non è ora di punta.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
if not eta: | Il neonato ha 0 anni, e 0 è falso: paga 2,20 come una tessera anonima | test_livello_4_un_neonato_non_e_una_tessera_anonima |
Il controllo sul senior prima di quello su None | Con la tessera anonima None >= 65 si ferma: TypeError: '>=' not supported between instances of 'NoneType' and 'int' | test_livello_4_la_tessera_anonima_paga_l_intero, e quattro test dei livelli 5 e 6 con la tessera anonima |
Livello 5 · Il credito
In italiano.
- Se l'abbonamento vale, il tornello non toglie niente: 0.0.
- Altrimenti calcolo il prezzo della corsa.
- Se il credito basta (anche giusto giusto), tolgo il prezzo. Se no,
None: il tornello resta chiuso.
def addebito(eta: int | None, ora: int, abbonamento: str | None, credito: float) -> float | None:
if abbonamento_valido(abbonamento, ora):
return 0.0
prezzo = prezzo_corsa(eta, ora)
if credito >= prezzo:
return prezzo
return NoneL'ultima riga si potrebbe togliere: una funzione che finisce senza return restituisce None lo stesso. Scritta, però, dice a chi legge che None è una risposta voluta, non una dimenticanza.
Nel quaderno: Franca 0.0, Aldo 1.5, Ugo 2.2. Teo 1.1 e Rosa 2.2, tutti e due con il credito giusto giusto.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
credito > prezzo | Il credito giusto giusto non basta più: Teo e Rosa restano fuori. E il bambino con il credito a zero: 0.0 > 0.0 è falso | test_livello_5_il_credito_giusto_giusto_basta, test_livello_5_gratis_anche_con_il_credito_a_zero |
| Prima il controllo sul credito, poi l'abbonamento | Chi ha l'abbonamento ma il credito a zero resta fuori | test_livello_5_con_l_abbonamento_si_passa_anche_senza_credito, test_livello_6_ricarica_se_restano_meno_di_2_20 |
Livello 6 · Il display
In italiano.
- Chiedo l'addebito al livello 5. Se è
None, il display dice «Credito insufficiente» e basta. - Il messaggio principale: «Abbonamento valido», oppure «Pagato» con due decimali.
- Primo avviso, per conto suo: se restano meno di 2,20 €, aggiungo «Ricarica la tessera».
- Secondo avviso, per conto suo: se la tessera è anonima, aggiungo «Registra la tessera».
def display(eta: int | None, ora: int, abbonamento: str | None, credito: float) -> str:
pagato = addebito(eta, ora, abbonamento, credito)
if pagato is None:
return "Credito insufficiente"
if abbonamento_valido(abbonamento, ora):
messaggio = "Abbonamento valido"
else:
messaggio = f"Pagato {pagato:.2f}"
if credito - pagato < 2.2:
messaggio = messaggio + " · Ricarica la tessera"
if eta is None:
messaggio = messaggio + " · Registra la tessera"
return messaggioPasso per passo, con la tessera di Ugo: età None, nessun abbonamento, 3,00 € di credito.
| Riga | Cosa succede | messaggio dopo la riga |
|---|---|---|
pagato = addebito(...) | tessera anonima: 2.2. Il credito basta | — |
if pagato is None: | no | — |
if abbonamento_valido(...) | no: si va nell'else | "Pagato 2.20" |
if credito - pagato < 2.2: | restano circa 0,80 €: sì | "Pagato 2.20 · Ricarica la tessera" |
if eta is None: | sì | "Pagato 2.20 · Ricarica la tessera · Registra la tessera" |
Nel quaderno:
Aldo Cattaneo Pagato 1.50 · Ricarica la tessera
Franca Mauri Abbonamento valido
Teo Galbiati Pagato 1.10 · Ricarica la tessera
Rosa Bellini Pagato 2.20 · Ricarica la tessera
Ugo Pirola Pagato 2.20 · Ricarica la tessera · Registra la tesseraLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
elif eta is None: al posto del secondo if | Con poco credito e la tessera anonima compare solo il primo avviso | test_livello_6_due_avvisi_insieme |
if not pagato: al posto di if pagato is None: | Chi passa senza pagare (un bambino, un abbonato) ha pagato uguale a 0.0, che è falso: il display scrive «Credito insufficiente» | test_livello_6_un_bambino_piccolo_passa_gratis, test_livello_6_abbonamento_valido, test_livello_6_ricarica_se_restano_meno_di_2_20, test_livello_6_con_2_20_esatti_non_serve_ricaricare |
"Pagato " + str(pagato) | str(2.2) è "2.2": il display scrive «Pagato 2.2» e «Pagato 0.0» | test_livello_6_pagato_con_due_decimali e altri cinque test del livello 6 |
Il finale
Metti il quaderno accanto al registro. Ogni riga ha la sua tessera:
| Registro | Display | Tessera |
|---|---|---|
| 10:01 | Abbonamento valido | Franca Mauri |
| 10:02 | Pagato 2.20 · Ricarica la tessera · Registra la tessera | Ugo Pirola |
| 10:04 | Pagato 2.20 · Ricarica la tessera | Rosa Bellini |
| 10:06 | Pagato 1.50 · Ricarica la tessera | Aldo Cattaneo |
| 10:09 | Pagato 1.10 · Ricarica la tessera | Teo Galbiati |
Alle 10:04, un minuto dopo il furto, è passata la tessera di Rosa Bellini: 34 anni, nessun abbonamento, 2,20 € sulla tessera, giusti giusti per una corsa intera.
python storia/verifica.py "Rosa Bellini"Le piste sbagliate. Con una trappola sola, la riga delle 10:04 combacia con due o tre tessere. Ecco da dove arrivano i nomi sbagliati più probabili:
| Se hai detto | La trappola | Perché |
|---|---|---|
| Aldo Cattaneo | Livello 1, il senior da 66 anni o mai; oppure livello 2, le 10 comprese | Aldo ha 65 anni appena compiuti. Se per te non è senior, o se alle 10 è ancora ora di punta, paga 2,20 e il suo display diventa uguale a quello delle 10:04 |
| Franca Mauri | Livello 2, le 10 comprese | Se alle 10 è ora di punta, il suo fuori punta non vale: paga 2,20 da senior in ora di punta, con lo stesso display |
| Ugo Pirola | Livello 6, elif negli avvisi | Il suo display perde «Registra la tessera» e resta uguale a quello delle 10:04 |
In tutti e tre i casi il segnale c'era: due o tre tessere con lo stesso display, e almeno una riga del registro senza nessuno.