Le funzioni, esercizi spiegati
Cinque esempi, una riga alla volta
- 25 minuti di lettura
Cinque esempi, dal più semplice. Ognuno ha lo stesso ritmo:
- Prevedi: leggi il codice e scrivi su un foglio cosa stampa. Prima di aprire la risposta.
- In italiano: cosa fa il programma, a parole.
- Passo per passo: cosa succede riga per riga, e dove si trova Python.
- Cosa portiamo a casa: la cosa da ricordare.
Puoi provare ogni esempio nel terminale di Python (python3, poi incolla) o su Python Tutor, che disegna ogni chiamata come un riquadro a parte: vedi la funzione che si apre, lavora e sparisce.
A · Lo sportello e il display
La macchinetta di Porta Codice ha un display e uno sportello. Due funzioni, quasi uguali.
def prezzo_mostrato(zone):
print("Display:", 1.5 * zone)
def prezzo(zone):
return 1.5 * zone
a = prezzo_mostrato(2)
b = prezzo(2)
print("a vale", a)
print("b vale", b)
print("Due biglietti:", b * 2)
print("Due biglietti:", a * 2)Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Display: 3.0
a vale None
b vale 3.0
Due biglietti: 6.0
TypeError: unsupported operand type(s) for *: 'NoneType' and 'int'- La prima riga la stampa la funzione, mentre lavora: è il suo
print. avaleNone:prezzo_mostratoha mostrato il prezzo, ma non l'ha consegnato.bvale3.0:prezzonon ha stampato niente, ma ha consegnato.b * 2si può fare.a * 2no: èNoneper 2, e Python si ferma.
In italiano.
- Chiamo la funzione che mostra: il prezzo compare sul display, e in
afinisceNone. - Chiamo la funzione che consegna: sullo schermo niente, in
bfinisce il prezzo. - Stampo tutte e due le etichette, poi provo a fare un conto con ognuna.
Passo per passo.
| Riga | Sullo schermo | a | b |
|---|---|---|---|
a = prezzo_mostrato(2) | Display: 3.0 (dentro la funzione) | None | — |
b = prezzo(2) | niente | None | 3.0 |
print("a vale", a) | a vale None | None | 3.0 |
print("b vale", b) | b vale 3.0 | None | 3.0 |
print(…, b * 2) | Due biglietti: 6.0 | None | 3.0 |
print(…, a * 2) | TypeError |
Cosa portiamo a casa. Il display l'hai visto, ma il biglietto non è uscito. Una funzione che calcola finisce con return; il print, se vuoi vedere, lo fa chi la chiama: print(prezzo(2)).
B · Il primo ritardo grave, e il totale
Il capotreno ha i ritardi di oggi, in minuti, nell'ordine delle corse. Vuole il primo ritardo grave (più di 10 minuti) e il totale. Il collega ha scritto la seconda funzione di fretta.
def primo_grave(ritardi):
for ritardo in ritardi:
if ritardo > 10:
return ritardo
return None
def totale_sbagliato(ritardi):
somma = 0
for ritardo in ritardi:
somma = somma + ritardo
return somma
print(primo_grave([3, 12, 25]))
print(primo_grave([3, 4]))
print(totale_sbagliato([3, 12, 25]))Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
12
None
3primo_gravesi ferma al 12: il 25 non lo guarda nemmeno.- Con
[3, 4]ilforfinisce senza trovare niente, e si arriva alreturn Nonedopo il ciclo. totale_sbagliatorestituisce 3, non 40: esce al primo giro.
In italiano.
primo_grave: guardo i ritardi uno per uno; appena ne trovo uno sopra 10, lo consegno e ho finito. Se arrivo in fondo, non c'era:None.totale_sbagliatovoleva dire: parto da zero, aggiungo ogni ritardo, alla fine consegno la somma. Ma «alla fine» è scritto nel posto sbagliato.
Il disegno, di primo_grave:
Passo per passo, primo_grave([3, 12, 25]):
| Giro | ritardo | ritardo > 10? | Cosa succede |
|---|---|---|---|
| 1 | 3 | no | si passa al giro dopo |
| 2 | 12 | sì | return 12: la funzione finisce qui |
| 3 | — | — | non arriva mai |
totale_sbagliato([3, 12, 25]):
| Giro | ritardo | somma dopo la riga | Cosa succede |
|---|---|---|---|
| 1 | 3 | 3 | return 3: il return è dentro il for, la funzione finisce qui |
| 2, 3 | — | — | non arrivano mai |
La correzione. Il return torna indietro di un rientro, allineato al for:
def totale(ritardi):
somma = 0
for ritardo in ritardi:
somma = somma + ritardo
return sommaAdesso totale([3, 12, 25]) dà 40.
Cosa portiamo a casa. Prima di scrivere il return, chiediti: posso rispondere adesso, a questo giro, o solo alla fine? Il primo che trovo: adesso, dentro il for. La somma di tutti: alla fine, dopo il for.
C · Il parcheggio di Porta Codice
Al parcheggio di interscambio la prima ora è gratis, fino a tre ore si pagano 2 euro, oltre 5 euro. La funzione sta in parcheggio.py, i suoi tre test in test_parcheggio.py. Uno dei test è rosso.
def tariffa_parcheggio(ore: int) -> int:
"""Gli euro da pagare: la prima ora è gratis, fino a 3 ore si pagano 2 euro, oltre 5 euro."""
if ore <= 1:
return 0
if ore <= 3:
return 2from parcheggio import tariffa_parcheggio
def test_la_prima_ora_e_gratis():
assert tariffa_parcheggio(1) == 0
def test_tre_ore():
assert tariffa_parcheggio(3) == 2
def test_tutto_il_giorno():
assert tariffa_parcheggio(8) == 5Prevedi: lanciando pytest test_parcheggio.py -v, quale test è rosso? E cosa dice la riga che comincia con E?
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
test_parcheggio.py::test_la_prima_ora_e_gratis PASSED [ 33%]
test_parcheggio.py::test_tre_ore PASSED [ 66%]
test_parcheggio.py::test_tutto_il_giorno FAILED [100%]
def test_tutto_il_giorno():
> assert tariffa_parcheggio(8) == 5
E assert None == 5
E + where None = tariffa_parcheggio(8)Con 8 ore nessuno dei due if è vero, e dopo il secondo if la funzione finisce senza un return. Esce None.
In italiano. Tre casi, tre strade: fino a un'ora, fino a tre ore, oltre. Ma nel codice le strade con un return sono solo due.
Passo per passo. Ogni test è un ingresso diverso nella scatola nera; guardiamo quale strada prende.
| Test | ore | ore <= 1? | ore <= 3? | Cosa esce |
|---|---|---|---|---|
| la prima ora | 1 | sì | — | 0 |
| tre ore | 3 | no | sì | 2 |
| tutto il giorno | 8 | no | no | nessun return: None |
La correzione. Una riga in fondo, per la strada che mancava:
if ore <= 3:
return 2
return 5Cosa portiamo a casa. Prima di consegnare, conta le strade: ogni strada, un return. E per provare una funzione come una scatola nera, un test per strada, più i confini (1 ora, 3 ore): sono i posti dove si nascondono gli errori.
D · Il biglietto stampato
La macchinetta stampa il biglietto: la zona è obbligatoria, il numero di corse e il ridotto no.
def biglietto(zona: str, corse: int = 1, ridotto: bool = False) -> str:
testo = f"{zona} · corse: {corse}"
if ridotto:
testo = testo + " · ridotto"
return testo
print(biglietto("urbana"))
print(biglietto("urbana", 10))
print(biglietto("urbana", ridotto=True))
print(biglietto(ridotto=True, zona="extraurbana", corse=2))
print(biglietto("urbana", True))
print(biglietto())Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
urbana · corse: 1
urbana · corse: 10
urbana · corse: 1 · ridotto
extraurbana · corse: 2 · ridotto
urbana · corse: True
TypeError: biglietto() missing 1 required positional argument: 'zona'La quinta è la sorpresa: senza nome, True va nel secondo posto, che è corse. Nessun errore, solo un biglietto assurdo.
In italiano. Tre parametri. zona va sempre passato; corse e ridotto, se non li passi, valgono 1 e False.
Passo per passo. Per ogni chiamata, cosa finisce in ogni parametro:
| Chiamata | zona | corse | ridotto |
|---|---|---|---|
biglietto("urbana") | "urbana" | 1 (default) | False (default) |
biglietto("urbana", 10) | "urbana" | 10 | False (default) |
biglietto("urbana", ridotto=True) | "urbana" | 1 (default) | True, per nome |
biglietto(ridotto=True, zona=…, corse=2) | "extraurbana" | 2 | True: con i nomi l'ordine non conta |
biglietto("urbana", True) | "urbana" | True, per posizione | False (default) |
biglietto() | manca, e non ha default | TypeError |
Cosa portiamo a casa. Senza nome, un argomento va nel posto che gli tocca per posizione, anche se non c'entra niente. Quando passi un True, un False o un numero che non si capisce da solo, dagli il suo nome: ridotto=True.
E · L'abbonamento scontato
Gli studenti hanno lo sconto sull'abbonamento. Due funzioni: una calcola quanto togliere, l'altra la usa.
def sconto(prezzo: float, percentuale: int) -> float:
return prezzo * percentuale / 100
def prezzo_abbonamento(prezzo: float, percentuale: int) -> float:
da_togliere = sconto(prezzo, percentuale)
return prezzo - da_togliere
finale = prezzo_abbonamento(40, 25)
print(finale)
print(da_togliere)Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
30.0
NameError: name 'da_togliere' is not definedda_togliere è nata dentro prezzo_abbonamento ed è sparita quando la funzione ha consegnato. Fuori è arrivato solo il return: 30.0.
In italiano.
scontofa un conto solo: quanto vale quella percentuale del prezzo.prezzo_abbonamentochiede ascontoquanto togliere, salva la risposta, e consegna il prezzo meno lo sconto.
Il disegno. Due salti dentro, due ritorni:
IL PROGRAMMA prezzo_abbonamento sconto
finale = ──── salta ───▶ prezzo = 40, percentuale = 25
da_togliere = ──── salta ───▶ prezzo = 40, percentuale = 25
return 40 * 25 / 100
da_togliere = 10.0 ◀── torna ──── 10.0
return 40 - 10.0
finale = 30.0 ◀── torna ── 30.0Passo per passo. Dove si trova Python, e quali etichette esistono in quel momento:
| Passo | Dove siamo | Etichette vive lì | Cosa succede |
|---|---|---|---|
| 1 | programma | — | chiama prezzo_abbonamento(40, 25): salta dentro |
| 2 | prezzo_abbonamento | prezzo 40, percentuale 25 | chiama sconto(40, 25): salta dentro, e aspetta |
| 3 | sconto | prezzo 40, percentuale 25 | return 10.0: torna |
| 4 | prezzo_abbonamento | prezzo 40, percentuale 25, da_togliere 10.0 | return 30.0: torna |
| 5 | programma | finale 30.0 | da_togliere non esiste più: NameError |
I due prezzo del passo 2 e del passo 3 hanno lo stesso nome e lo stesso valore, ma sono due etichette diverse: ogni chiamata ha le sue.
Cosa portiamo a casa. Ogni chiamata ha le sue etichette, che spariscono quando torna. Fuori arriva solo il return. Se un valore ti serve fuori, restituiscilo e salvalo: finale = prezzo_abbonamento(40, 25).
Pronto? Gli stessi schemi ti aspettano nella palestra: sette esercizi da scaricare, con i test.