Le funzioni
Una macchinetta con un ingresso e un'uscita
- 12 minuti di lettura
Alla biglietteria di Porta Codice il prezzo di una corsa si calcola in tre punti del programma: allo sportello, alla macchinetta, nell'app. Lo stesso conto, scritto tre volte. Il giorno che il prezzo cambia, ne correggi due e ti dimentichi il terzo.
Una funzione è un pezzo di codice con un nome. Lo scrivi una volta, lo usi tutte le volte che vuoi.
def prezzo_corsa(zone: int) -> float:
return 1.5 * zone
prezzo_corsa(2) # 3.0
prezzo_corsa(3) # 4.5Il disegno
Pensala come una macchinetta della stazione. Dall'alto entra quello che le dai, dentro succede il lavoro, dallo sportello in basso esce il risultato. Chi la usa non ha bisogno di sapere com'è fatta dentro: gli basta sapere cosa metterci e cosa esce.
2 ← l'INGRESSO: il valore che le dai
│
▼
┌───────────────────────┐
│ prezzo_corsa │
│ │
│ zone = 2 │ ← il lavoro, dentro
│ return 1.5 * zone │
└───────────┬───────────┘
│
▼
3.0 ← l'USCITA: quello che consegnaQuando la usi, il programma salta dentro la funzione, esegue le sue righe, e torna nel punto da cui era partito, con il risultato in mano.
IL PROGRAMMA LA FUNZIONE
prezzo = prezzo_corsa(2) ──── 1 · salta ───▶ def prezzo_corsa(zone): zone = 2
▲ return 1.5 * zone
│ │
└────────────── 2 · torna con 3.0 ◀───────────────────┘
print(prezzo) # 3.0I pezzi di una def
def prezzo_corsa(zone: int) -> float:
"""Il prezzo di una corsa che attraversa quel numero di zone."""
return 1.5 * zone| Pezzo | Cos'è |
|---|---|
def | «Sto definendo una funzione» |
prezzo_corsa | Il nome: dice cosa fa, o cosa restituisce |
(zone: int) | Il parametro, con il tipo che si aspetta |
-> float | Il tipo di quello che esce |
: e il rientro | Il corpo: tutto quello che è rientrato di quattro spazi sotto la def |
"""…""" | La docstring: cosa fa, in una frase |
return | Quello che la funzione consegna a chi la usa |
Scrivere una def non esegue niente: insegna a Python una parola nuova. Il corpo parte solo quando chiami la funzione, con le tonde: prezzo_corsa(2).
Parametri e argomenti
Due parole che si confondono sempre:
- il parametro è il posto vuoto, nella
def:zone; - l'argomento è il valore che ci metti quando la chiami:
2.
Al momento della chiamata Python attacca l'etichetta del parametro al valore dell'argomento, come se dentro la funzione ci fosse scritto zone = 2.
def saluto(nome: str, stazione: str) -> str: # due parametri: due posti vuoti
return f"Ciao {nome}, benvenuto a {stazione}"
saluto("Ada", "Largo Lista") # due argomenti: "Ada" va in nome, "Largo Lista" in stazioneGli argomenti riempiono i posti in ordine: il primo nel primo, il secondo nel secondo. Uno in meno o uno in più, e Python si ferma subito:
saluto("Ada")
TypeError: saluto() missing 1 required positional argument: 'stazione'
saluto("Ada", "Largo Lista", "binario 2")
TypeError: saluto() takes 2 positional arguments but 3 were givenreturn o print
È il punto più confuso di Python, quindi lo diciamo chiaro: print mostra, return consegna.
printscrive sullo schermo, per te che guardi. Il valore finisce lì: il programma non lo può più usare.returnconsegna il valore a chi ha chiamato la funzione, che lo può salvare in una variabile, usare in un conto, passare a un'altra funzione.
Nella macchinetta: print è il display, che leggi con gli occhi. return è lo sportello, da cui esce il biglietto che ti porti via.
def prezzo_mostrato(zone):
print(1.5 * zone) # lo mostra...
def prezzo(zone):
return 1.5 * zone # ...lo consegna
a = prezzo_mostrato(2) # sullo schermo: 3.0
b = prezzo(2) # sullo schermo: niente
print(a, b) # None 3.0Una funzione senza return consegna comunque qualcosa: None, il valore che vuol dire «niente». Vale anche per una funzione che contiene solo pass.
Ed ecco perché i test vedono return e non print. Il test chiama la funzione e confronta quello che esce dallo sportello:
def test_due_zone():
> assert prezzo_mostrato(2) == 3.0
E assert None == 3.0
E + where None = prezzo_mostrato(2)
----------------------------- Captured stdout call -----------------------------
3.0Leggilo così: la funzione ha stampato 3.0 (pytest lo mette da parte, sotto «Captured stdout»), ma ha consegnato None.
E il print, allora? Serve, ma fuori dalle funzioni che calcolano: print(prezzo(2)). La funzione consegna; chi la chiama decide se stampare.
Il return esce subito
Quando Python incontra un return, la funzione finisce lì: consegna il valore e torna indietro. Le righe sotto non vengono eseguite, nemmeno i giri del for che mancavano.
def primo_grave(ritardi: list[int]) -> int | None:
"""Il primo ritardo di più di 10 minuti."""
for ritardo in ritardi:
if ritardo > 10:
return ritardo # trovato: esce subito, il for non va avanti
return None # il for è finito senza trovarlo
primo_grave([3, 12, 25]) # 12
primo_grave([3, 4]) # NoneÈ lo schema cerca il primo: il return sta dentro il for, dentro l'if. Il «non l'ho trovato» sta dopo il for.
L'accumulatore (la somma, il conteggio) è l'opposto: il return va dopo il for, quando i giri sono finiti tutti.
def totale(ritardi: list[int]) -> int:
somma = 0
for ritardo in ritardi:
somma = somma + ritardo
return somma # allineato al for: dopo l'ultimo giro
totale([3, 12, 25]) # 40Più return, in rami diversi
Una funzione può avere più return, uno per ogni strada. Vince il primo che Python incontra: come negli if, la prima condizione vera.
def tariffa(eta: int) -> float:
if eta < 6:
return 0.0
if eta < 14:
return 1.1
return 2.2
tariffa(4), tariffa(10), tariffa(40) # 0.0, 1.1, 2.2Dopo un return non serve elif: la funzione è già uscita. Se elif ti è più chiaro, scrivilo pure. Controlla però che ogni strada arrivi a un return: una strada che finisce senza consegna None, e te ne accorgi solo con un test.
def tariffa_dimenticata(eta: int) -> float:
if eta < 6:
return 0.0
if eta < 14:
return 1.1
# e gli adulti? Nessun return
tariffa_dimenticata(40) # NoneValori di default e argomenti con nome
Un parametro può avere un valore di default: quello che vale se chi chiama non lo passa.
def annuncio(stazione: str, binario: int = 1) -> str:
return f"{stazione}, binario {binario}"
annuncio("Largo Lista") # "Largo Lista, binario 1": il binario non c'è, vale 1
annuncio("Largo Lista", 2) # "Largo Lista, binario 2"
annuncio("Largo Lista", binario=3) # con il nome: si legge cos'è quel 3
annuncio(binario=3, stazione="Largo Lista") # con il nome, l'ordine non conta piùGli argomenti con il nome (binario=3) servono soprattutto con i numeri e con True e False: biglietto("urbana", ridotto=True) si capisce al volo, biglietto("urbana", 1, True) no.
Due regole d'ordine, che Python controlla prima ancora di partire:
| Cosa | Se sbagli |
|---|---|
Nella def, i parametri con il default vanno dopo quelli senza | SyntaxError: parameter without a default follows parameter with a default |
| Nella chiamata, gli argomenti con il nome vanno dopo quelli senza | SyntaxError: positional argument follows keyword argument |
Type hints e docstring
I type hints dicono che tipo di valore ti aspetti: zone: int per un parametro, -> float per quello che esce. Python non li controlla: tariffa("dieci") parte lo stesso, e si ferma solo dentro, al primo confronto. Li leggono VS Code (che ti avvisa prima), i colleghi, e tu tra una settimana.
| Si scrive | Vuol dire |
|---|---|
-> str | restituisce un testo |
-> None | consegna solo None: è una funzione che stampa, e basta |
-> int | None | un numero, oppure None (per esempio: «non l'ho trovato») |
nomi: list[str] | una lista di testi |
La docstring è la prima riga del corpo, tra tre virgolette: cosa fa la funzione, in una frase, e se serve un esempio. VS Code la mostra quando passi il mouse sul nome. Negli esercizi di questo libro è la consegna.
def prezzo_corsa(zone: int) -> float:
"""Il prezzo di una corsa che attraversa quel numero di zone.
prezzo_corsa(2) -> 3.0
"""
return 1.5 * zoneCosa vive dentro la funzione
I parametri e le variabili create dentro una funzione sono locali: nascono quando la chiami e spariscono quando torna. Da fuori non si vedono.
def con_sconto(prezzo: float) -> float:
sconto = prezzo * 0.2
return prezzo - sconto
finale = con_sconto(10)
print(finale) # 8.0
print(sconto) # NameError: name 'sconto' is not definedDalla funzione esce solo quello che consegna con return. E lo stesso nome, dentro e fuori, sono due etichette diverse:
zone = 5
def doppio(zone: int) -> int:
zone = zone * 2 # questa zone vive solo qui dentro
return zone
print(doppio(3)) # 6
print(zone) # 5: quella fuori non è cambiataLeggere una costante scritta fuori, in maiuscolo, invece va benissimo: POSTI_PER_VAGONE = 120 in cima al file, e dentro la funzione la usi.
Una funzione, un compito
Se per dire cosa fa una funzione ti serve una «e», sono due funzioni. «Calcola il prezzo e stampa lo scontrino» è troppo:
def scontrino(zone: int) -> None: # calcola E stampa: il prezzo non lo può usare nessuno
prezzo = 1.5 * zone
print(f"Biglietto da {zone} zone: {prezzo:.2f} euro")Meglio due funzioni, una per compito:
def prezzo_corsa(zone: int) -> float: # calcola
return 1.5 * zone
def riga_scontrino(zone: int) -> str: # compone il testo, e il prezzo lo chiede all'altra
return f"Biglietto da {zone} zone: {prezzo_corsa(zone):.2f} euro"Adesso il prezzo si prova con un test e si usa anche dove lo scontrino non serve. Le funzioni piccole hanno un nome che si capisce, si provano una alla volta, si mettono insieme.
Funzioni che chiamano funzioni
Una funzione può chiamarne un'altra: il risultato della prima diventa un pezzo del lavoro della seconda.
def prezzo_corsa(zone: int) -> float:
return 1.5 * zone
def andata_e_ritorno(zone: int) -> float:
andata = prezzo_corsa(zone) # salta dentro prezzo_corsa, torna con il prezzo
return andata * 2
andata_e_ritorno(2) # 6.0Ogni chiamata è un salto dentro e un ritorno. La funzione di fuori aspetta ferma finché quella di dentro non ha consegnato:
andata_e_ritorno(2)
│ zone = 2
│ andata = prezzo_corsa(2) ───▶ prezzo_corsa(2)
│ │ zone = 2
│ │ return 1.5 * 2
│ andata = 3.0 ◀──── 3.0 ────────┘
│ return 3.0 * 2
▼
6.0La funzione come scatola nera
Per usare len non hai mai avuto bisogno di sapere com'è fatta dentro: sai cosa metterci e cosa esce. Le tue funzioni sono uguali: una scatola nera, con un ingresso e un'uscita.
Ed è così che si provano: dai un ingresso, controlli l'uscita. Un test è proprio questo:
from prezzi import prezzo_corsa
def test_due_zone():
assert prezzo_corsa(2) == 3.0
def test_nessuna_zona():
assert prezzo_corsa(0) == 0.0La prima riga va a prendere prezzo_corsa nel file prezzi.py, dove l'hai scritta. Come funziona import lo vedi nel capitolo Moduli e file.
Il test non guarda dentro: non sa se hai usato un for o un if. Guarda solo quello che esce dallo sportello. Per questo una funzione che stampa invece di restituire non si può provare. Come si scrive un test: Scrivere un test.
La funzione nella tua API
Nel primo server le rotte di FastAPI sono funzioni, e FastAPI leggeva la def per capire dove guardare:
@app.get("/treni/{codice}")
def leggi_treno(codice: str, con_vagoni: bool = False) -> Treno:
...
return trenoNella def | Per FastAPI |
|---|---|
codice: str, che è anche tra graffe nel percorso | un pezzo dell'indirizzo: /treni/M12 |
con_vagoni: bool = False, con un default | un parametro facoltativo, nella query: ?con_vagoni=true |
return treno | il corpo della risposta, in JSON |
Il return è la risposta che arriva al client; un print lo vedi solo tu, nel terminale del server. Il resto è in La forma della chiamata.
Ricorda
- Il parametro è il posto vuoto nella
def; l'argomento è il valore che ci metti quando chiami. printmostra,returnconsegna. SenzareturnesceNone:assert None == ….returnesce subito: dentro ilforper cercare il primo, dopo ilforper accumulare.- Ogni strada della funzione arriva a un
return. - Il risultato di una chiamata si prende:
x = f(…). - Una funzione, un compito: se ti serve una «e», sono due.