Vai al contenuto
code-to-code

Apro l'indice…

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

Python6. Le funzionip. 176

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.

python-funzioni-soluzioni.zip20 KB

La palestra

1 · Il cartellino del vagone

In italiano. Metto il treno in maiuscolo, poi compongo il cartellino: treno, trattino, numero. E lo consegno.

Python
def codice_vagone(treno: str, numero: int) -> str:
    return f"{treno.upper()}-{numero}"

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
print(f"{treno.upper()}-{numero}") al posto di returnIl cartellino compare sullo schermo, ma la funzione consegna None: assert None == 'M12-3'. E nella frase: TypeError: can only concatenate str (not "NoneType") to strtest_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
None

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

  1. I posti del treno sono i vagoni per 120; tolgo le persone a bordo.
  2. Se il conto viene sotto zero, i posti liberi sono 0.
  3. Altrimenti consegno il conto.
Python
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 liberi

Ogni 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 sbagliatoCosa succedeIl test rosso
def posti_liberi(vagoni, a_bordo):, senza i tipiIl conto è giusto, ma i type hints mancano. Il test li legge in posti_liberi.__annotations__ e li trova vuotitest_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_bordoCon 150 persone su un vagone i posti liberi sono -30test_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.

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

inizio colore_ritardo(minuti) se minuti <= 0 sì: restituisci "verde" se minuti <= 5 sì: restituisci "giallo" se minuti <= 15 sì: restituisci "arancione" restituisci "rosso"colore_ritardo(minuti)minuti <= 0restituisci "verde"minuti <= 5restituisci "giallo"minuti <= 15restituisci "arancione"restituisci "rosso"nosìnosìnosì
La lucina del ritardo

Passo per passo. Quattro ingressi, quattro strade:

minuti<= 0?<= 5?<= 15?Cosa esce
-2sì——"verde"
5nosì—"giallo"
6nonosì"arancione"
40nononol'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 sbagliatoCosa succedeIl 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 <= 15Vince il primo return che si incontra: con 0 minuti 0 <= 15 è già vero, e la lucina è arancionetest_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 rossotest_in_orario_e_in_anticipo, test_giallo_fino_a_cinque_minuti, test_arancione_fino_a_quindici_minuti

4 · L'avviso in banchina

In italiano.

  1. Tre parametri: la stazione obbligatoria, il binario che di default vale 1, il ritardo che di default vale 0.
  2. Il pezzo che non cambia mai: stazione, binario, «treno in arrivo».
  3. Se c'è ritardo aggiungo i minuti e il punto; altrimenti solo il punto.
Python
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 sbagliatoCosa succedeIl 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 defaultChi 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.

  1. Guardo i vagoni uno per uno, con la loro posizione.
  2. Appena un vagone ha posti liberi almeno quante sono le persone, consegno il suo numero: la posizione più uno.
  3. Se arrivo in fondo senza trovarlo, None.
Python
def primo_vagone_libero(posti: list[int], persone: int) -> int | None:
    for i, liberi in enumerate(posti):
        if liberi >= persone:
            return i + 1
    return None

Il disegno.

inizio primo_vagone_libero(posti, persone) per ogni i, liberi in enumerate(posti) se liberi >= persone sì: restituisci i + 1 restituisci Noneprimo_vagone_libero(posti,persone)per ogni i, liberi inenumerate(posti)liberi >= personerestituisci i + 1restituisci Nonenosìfiniti
Il primo vagone con posto

Passo per passo, con [0, 3, 12, 40] e 10 persone:

Giroiliberiliberi >= 10?Cosa succede
100noavanti
213noavanti
3212sì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 sbagliatoCosa succedeIl test rosso
else: return None dentro il forAl primo vagone pieno la funzione esce: con [0, 3, 12, 40] risponde None già al giro 1test_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 dopoIl ciclo arriva fino in fondo, e ogni vagone buono prende il posto del precedente: esce l'ultimo con posto, 4 invece di 3test_il_primo_che_ha_posto, test_i_posti_giusti_giusti_bastano, test_il_primo_non_il_piu_vuoto
return iLe posizioni partono da 0, i cartelli da 1: il terzo vagone diventa il 2test_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 a in_minuti i minuti dell'inizio e della fine, li salvo, e consegno la differenza.
Python
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_inizio

Passo per passo, durata_turno("05:30", "13:45"):

PassoDove siamoCosa succede
1durata_turnochiama in_minuti("05:30"): salta dentro
2in_minuti"05" e "30" diventano 5 e 30: return 330
3durata_turnominuti_inizio = 330; chiama in_minuti("13:45")
4in_minutireturn 825
5durata_turnominuti_fine = 825; return 825 - 330, cioè 495

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
in_minuti(inizio) e in_minuti(fine) da soli, poi return fine - inizioI 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 returnin_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.

  1. ingresso: sotto i 6 anni gratis; sotto i 14 o dai 65 in su il ridotto; tutti gli altri l'intero.
  2. costo_gruppo: parto da zero e, per ogni persona, aggiungo il suo ingresso. Alla fine, il totale.
  3. conviene_la_tessera: il gruppo pagherebbe più della tessera?
Python
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_tessera

Passo per passo, costo_gruppo([40, 38, 10, 4]):

Giroetaingresso(eta)totale dopo il giro
prima——0
14088
238816
310521
44021

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 sbagliatoCosa succedeIl test rosso
return totale dentro il forEsce 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 totaletest_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 forOgni prezzo si calcola e si butta: il totale resta 0test_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 bastaQuando la tessera non conviene non c'è nessun return: assert None is Falsetest_la_tessera_non_conviene, test_a_parita_la_tessera_non_conviene
> 30 al posto di > prezzo_tesseraIl parametro c'è, ma nessuno lo usa: chi passa prezzo_tessera=20 riceve la risposta per 30test_un_altro_prezzo_della_tessera

La storia

Livello 1 · La targhetta

In italiano. Tre pezzi del dizionario in una f-string, e la consegno.

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

Python
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 sbagliatoCosa succedeIl test rosso
Il verde per primo: if treno["carica"] >= CARICA_PIENA: return "verde", poi il rossoUn 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 mostratest_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_PIENACon il 50% esatto il treno diventa giallotest_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.

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

  1. Se il semaforo non è verde, la risposta è già False.
  2. Chiedo i km alla revisione: per un treno lungo con il suo limite, per gli altri con il default.
  3. Consegno il confronto: bastano per il giro?
Python
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_fare

Il disegno.

inizio puo_uscire(treno, km_da_fare) se semaforo(treno) != "verde" sì: restituisci False se vagoni >= VAGONI_TRENO_LUNGO sì: restano = km con il limite lungo no: restano = km con il limite normale restituisci restano >= km_da_farepuo_uscire(treno,km_da_fare)semaforo(treno) !="verde"restituisci Falsevagoni >=VAGONI_TRENO_LUNGOrestano = km con il limitenormalerestano = km con il limitelungorestituisci restano >=km_da_farenosìnosì
Può uscire?

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 sbagliatoCosa succedeIl test rosso
km_alla_revisione(treno) per tutti, senza il limite dei treni lunghiUn treno da sei vagoni con 8800 km sembra avere 3200 km davanti, invece di 200test_livello_4_i_treni_lunghi_hanno_il_loro_limite
semaforo == "verde", senza le tondeConfronta 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.

Python
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 None

km_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 sbagliatoCosa succedeIl test rosso
else: return None dentro il forIl primo treno della fila non va bene, e la funzione esce subito: «nessun treno» dappertuttotest_livello_5_il_primo_che_puo_uscire, test_livello_5_il_giro_lungo, i tre test_livello_6_…
Nessun controllo sul depositoEsce il primo treno pronto di tutta la linea, anche se dorme in un altro depositotest_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 dopoEsce l'ultimo della fila, non il primotest_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_fareIl giro lungo si perde per strada: la funzione cerca sempre per un giro normaletest_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.

Python
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 righe

Il disegno.

inizio tabellone(treni, depositi, km_da_fare) righe = [] per ogni deposito in depositi treno = primo_in_uscita(...) se treno is None sì: aggiungi «nessun treno» no: aggiungi la targhetta restituisci righetabellone(treni, depositi,km_da_fare)righe = []per ogni deposito indeposititreno = primo_in_uscita(...)treno is Noneaggiungi la targhettaaggiungi «nessun treno»restituisci righenosìfiniti
Una riga per deposito

Nel pannello vero, per un giro normale:

Porta Codice: M12 · 6 vagoni · 90%
Piazza Query: M11 · 4 vagoni · 88%
Vecchia Fiera: nessun treno

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

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

TrenoSemaforoLimiteKm alla revisioneBastano per 450?Esce?
M10rosso: le porte———no
M12verde9000: ha sei vagoni300nono
M14verde: il 50% esatto basta12000450sì, giusti giustisì: return
M16, M19————non li guarda nessuno

Il treno è M14.

Terminale
python storia/verifica.py M14

Le risposte sbagliate più probabili, e da dove vengono:

RispostaDa dove viene
M10Il semaforo guarda la carica prima delle porte (livello 2)
M11primo_in_uscita non controlla il deposito (livello 5): M11 dorme a Piazza Query
M12Il 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)
M16Un confine: con <= nel semaforo M14 diventa giallo (livello 2)
M19primo_in_uscita consegna l'ultimo della fila, non il primo (livello 5)
NoneUn else: return None dentro il for (livello 5), o semaforo senza le tonde (livello 4)