Vai al contenuto
code-to-code

Apro l'indice…

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

Python6. Le funzionip. 153

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.

Python
def prezzo_corsa(zone: int) -> float:
    return 1.5 * zone

prezzo_corsa(2)     # 3.0
prezzo_corsa(3)     # 4.5

Il 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 consegna

Quando 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.0

I pezzi di una def

Python
def prezzo_corsa(zone: int) -> float:
    """Il prezzo di una corsa che attraversa quel numero di zone."""
    return 1.5 * zone
PezzoCos'è
def«Sto definendo una funzione»
prezzo_corsaIl nome: dice cosa fa, o cosa restituisce
(zone: int)Il parametro, con il tipo che si aspetta
-> floatIl tipo di quello che esce
: e il rientroIl corpo: tutto quello che è rientrato di quattro spazi sotto la def
"""…"""La docstring: cosa fa, in una frase
returnQuello 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.

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

Gli 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 given

return o print

È il punto più confuso di Python, quindi lo diciamo chiaro: print mostra, return consegna.

  • print scrive sullo schermo, per te che guardi. Il valore finisce lì: il programma non lo può più usare.
  • return consegna 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.

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

Una 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.0

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

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

Python
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])            # 40

Più 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.

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

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

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

Valori di default e argomenti con nome

Un parametro può avere un valore di default: quello che vale se chi chiama non lo passa.

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

CosaSe sbagli
Nella def, i parametri con il default vanno dopo quelli senzaSyntaxError: parameter without a default follows parameter with a default
Nella chiamata, gli argomenti con il nome vanno dopo quelli senzaSyntaxError: 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 scriveVuol dire
-> strrestituisce un testo
-> Noneconsegna solo None: è una funzione che stampa, e basta
-> int | Noneun 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.

Python
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 * zone

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

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

Dalla funzione esce solo quello che consegna con return. E lo stesso nome, dentro e fuori, sono due etichette diverse:

Python
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 è cambiata

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

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

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

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

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

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

Python
from prezzi import prezzo_corsa

def test_due_zone():
    assert prezzo_corsa(2) == 3.0

def test_nessuna_zona():
    assert prezzo_corsa(0) == 0.0

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

Python
@app.get("/treni/{codice}")
def leggi_treno(codice: str, con_vagoni: bool = False) -> Treno:
    ...
    return treno
Nella defPer FastAPI
codice: str, che è anche tra graffe nel percorsoun pezzo dell'indirizzo: /treni/M12
con_vagoni: bool = False, con un defaultun parametro facoltativo, nella query: ?con_vagoni=true
return trenoil 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.
  • print mostra, return consegna. Senza return esce None: assert None == ….
  • return esce subito: dentro il for per cercare il primo, dopo il for per 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.