Le funzioni
def, return o print, parametri, default, argomenti con nome, type hints, lambda e la lista di default
Una funzione è un pezzo di codice con un nome: lo scrivi una volta, lo usi tutte le volte che vuoi. Ogni voce dice a cosa serve un pezzo della def, mostra un esempio da provare e la cosa da ricordare. Nel codice, # → dice cosa vale quella riga, o cosa stampa. La macchinetta con l'ingresso e lo sportello, e il perché di tutto, sono nel capitolo Le funzioni.
def e la chiamata
def insegna a Python una parola nuova. Il corpo è tutto quello che sta rientrato di quattro spazi sotto, e parte solo quando chiami la funzione, con le tonde.
def prezzo_corsa(zone):
return 1.5 * zone
prezzo_corsa(2) # → 3.0
prezzo_corsa(3) # → 4.5
totale = prezzo_corsa(2) + prezzo_corsa(1)
totale # → 4.5Scrivere la def non esegue niente: per questo va scritta prima della riga che la usa.
saluta() # → NameError: name 'saluta' is not defined
def saluta():
print("Benvenuti sulla Linea Menta")
saluta() # → Benvenuti sulla Linea Mentareturn contro print
print mostra: scrive nel terminale, per te che guardi. return consegna: dà il valore a chi ha chiamato la funzione, che lo può salvare, usare in un conto, passare a un'altra funzione.
def prezzo_mostrato(zone):
print(1.5 * zone)
def prezzo(zone):
return 1.5 * zone
a = prezzo_mostrato(2)
# → 3.0
b = prezzo(2)
a # → None
b # → 3.0
b * 2 # → 6.0
a * 2 # → TypeError: unsupported operand type(s) for *: 'NoneType' and 'int'Una funzione senza return consegna comunque qualcosa: None, il valore che vuol dire «niente». Vale anche per una funzione che contiene solo pass.
def ancora_da_scrivere(zone):
pass
ancora_da_scrivere(2) # → NoneParametri e argomenti
Il parametro è il posto vuoto nella def; l'argomento è il valore che ci metti quando chiami. Gli argomenti riempiono i posti in ordine: il primo nel primo, il secondo nel secondo.
def benvenuto(nome, fermata):
return f"Ciao {nome}, sei a {fermata}"
benvenuto("Lucia", "Largo Lista") # → 'Ciao Lucia, sei a Largo Lista'
benvenuto("Largo Lista", "Lucia") # → 'Ciao Largo Lista, sei a Lucia'
benvenuto("Lucia") # → TypeError: benvenuto() missing 1 required positional argument: 'fermata'
benvenuto("Lucia", "Largo Lista", "binario 2") # → TypeError: benvenuto() takes 2 positional arguments but 3 were givenPython non sa cosa vuol dire ogni posto: se scambi gli argomenti, non si lamenta, ma il risultato è sbagliato. Con uno in meno o uno in più invece si ferma subito, e il messaggio dice quale manca.
Valori di default
Un parametro può avere un valore già pronto: quello che vale se chi chiama non lo passa.
def annuncio(fermata, binario=1):
return f"{fermata}, binario {binario}"
annuncio("Largo Lista") # → 'Largo Lista, binario 1'
annuncio("Largo Lista", 2) # → 'Largo Lista, binario 2'Nella def i parametri con il default vanno dopo quelli senza. def annuncio(binario=1, fermata): non parte nemmeno: SyntaxError: parameter without a default follows parameter with a default.
Argomenti con nome
Nella chiamata puoi scrivere il nome del parametro: ritardo=5. Si capisce al volo cos'è quel 5, puoi saltare i parametri con il default, e tra gli argomenti con nome l'ordine non conta.
def annuncio(fermata, binario=1, ritardo=0):
return f"{fermata}, binario {binario}, ritardo {ritardo} minuti"
annuncio("Ponte Ciclo", ritardo=5) # → 'Ponte Ciclo, binario 1, ritardo 5 minuti'
annuncio(ritardo=5, fermata="Ponte Ciclo") # → 'Ponte Ciclo, binario 1, ritardo 5 minuti'
annuncio("Ponte Ciclo", 2, 5) # → 'Ponte Ciclo, binario 2, ritardo 5 minuti'
annuncio("Ponte Ciclo", minuti=5) # → TypeError: annuncio() got an unexpected keyword argument 'minuti'
annuncio("Ponte Ciclo", fermata="Largo Lista") # → TypeError: annuncio() got multiple values for argument 'fermata'Nella chiamata gli argomenti con nome vanno dopo quelli senza, se no SyntaxError: positional argument follows keyword argument. Li conosci già: sep= ed end= di print(), reverse= e key= di sorted().
Restituire più valori
Scrivi i valori dopo il return, separati da virgole: la funzione consegna una tupla, e chi chiama la spacchetta in tante etichette.
def minimo_e_massimo(ritardi):
return min(ritardi), max(ritardi)
minimo_e_massimo([3, 0, 12, 5]) # → (0, 12)
piu_basso, piu_alto = minimo_e_massimo([3, 0, 12, 5])
piu_basso # → 0
piu_alto # → 12Tuple e spacchettamento spiegati: Insiemi e tuple.
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):
for ritardo in ritardi:
if ritardo > 10:
return ritardo
return None
primo_grave([3, 12, 25]) # → 12
primo_grave([3, 4]) # → NoneÈ lo schema cerca il primo: il return del «trovato» sta dentro il for, quello del «non c'è» sta dopo il for.
def totale_sbagliato(ritardi):
somma = 0
for ritardo in ritardi:
somma = somma + ritardo
return somma
def totale(ritardi):
somma = 0
for ritardo in ritardi:
somma = somma + ritardo
return somma
totale_sbagliato([3, 12, 25]) # → 3
totale([3, 12, 25]) # → 40Le variabili locali
I parametri e le variabili create dentro una funzione nascono quando la chiami e spariscono quando torna. Da fuori non si vedono: l'unica cosa che esce è quello che consegna il return.
def con_sconto(prezzo):
sconto = prezzo * 0.2
return prezzo - sconto
con_sconto(10) # → 8.0
sconto # → NameError: name 'sconto' is not definedAnche con lo stesso nome, dentro e fuori sono due etichette diverse: cambiare quella dentro non tocca quella fuori.
zone = 5
def doppio(zone):
zone = zone * 2
return zone
doppio(3) # → 6
zone # → 5def aggiungi_fermata(linea, fermata):
linea.append(fermata)
menta = ["Porta Codice"]
aggiungi_fermata(menta, "Via Variabile")
menta # → ['Porta Codice', 'Via Variabile']Type hints
Dicono che tipo di valore ti aspetti: zone: int per un parametro, -> float per quello che esce. Python non li controlla mentre il programma gira; li leggono VS Code (che ti avvisa prima), FastAPI, i colleghi, e tu tra una settimana.
def prezzo_corsa(zone: int) -> float:
return 1.5 * zone
prezzo_corsa(2) # → 3.0
prezzo_corsa("2") # → TypeError: can't multiply sequence by non-int of type 'float'Il "2" entra lo stesso: l'errore arriva dopo, dentro, alla moltiplicazione. Quelli che incontri più spesso:
nomi: list[str]: una lista di testi;ore: dict[str, int]: un dizionario da testo a numero;-> bool: restituisceTrueoFalse;-> str | None: un testo, oppureNone(per esempio: «non l'ho trovato»);-> None: non restituisce niente, è una funzione che stampa e basta.
def chi_ha_piu_ore(ore: dict[str, int]) -> str | None:
if not ore:
return None
return max(ore, key=ore.get)
chi_ha_piu_ore({"Lucia": 31, "Sergio": 38}) # → 'Sergio'
chi_ha_piu_ore({}) # → NoneDocstring
La prima riga del corpo, tra tre virgolette: cosa fa la funzione, in una frase. VS Code la mostra quando passi il mouse sul nome della funzione.
def prezzo_corsa(zone: int) -> float:
"""Il prezzo di una corsa che attraversa quel numero di zone."""
return 1.5 * zone
prezzo_corsa.__doc__ # → 'Il prezzo di una corsa che attraversa quel numero di zone.'Se serve, sotto la frase aggiungi un esempio, su più righe, sempre dentro le tre virgolette. Python tiene la docstring attaccata alla funzione: help(prezzo_corsa) nel terminale te la mostra. Un commento con # invece lo legge solo chi apre il file. Negli esercizi del libro la docstring è la consegna: dice cosa deve uscire.
Funzioni come valori
Una funzione è un valore come un altro: le puoi attaccare un'altra etichetta, o passarla a un'altra funzione. È quello che fai con key=: dici a sorted, max e min quale funzione usare per confrontare.
fermate = ["Porta Codice", "Via Variabile", "Ponte Ciclo"]
sorted(fermate, key=len) # → ['Ponte Ciclo', 'Porta Codice', 'Via Variabile']
max(fermate, key=len) # → 'Via Variabile'
def minuti(corsa):
return corsa[1]
corse = [("M12", 7), ("M14", 3), ("M16", 12)]
sorted(corse, key=minuti) # → [('M14', 3), ('M12', 7), ('M16', 12)]
min(corse, key=minuti) # → ('M14', 3)
misura = len
misura("Largo Lista") # → 11sorted chiama minuti su ogni corsa e ordina per quello che esce: i minuti, non il codice del treno.
fermate = ["Porta Codice", "Via Variabile", "Ponte Ciclo"]
sorted(fermate, key=len()) # → TypeError: len() takes exactly one argument (0 given)lambda
Una funzione piccola, senza nome, scritta in una riga: prima dei due punti il parametro, dopo quello che restituisce (senza return). lambda corsa: corsa[1] fa la stessa cosa della minuti della voce sopra.
corse = [("M12", 7), ("M14", 3), ("M16", 12)]
sorted(corse, key=lambda corsa: corsa[1]) # → [('M14', 3), ('M12', 7), ('M16', 12)]
ore = {"Lucia": 31, "Sergio": 38, "Marta": 26}
sorted(ore.items(), key=lambda coppia: coppia[1], reverse=True) # → [('Sergio', 38), ('Lucia', 31), ('Marta', 26)]
treni = [{"codice": "M12", "vagoni": 4}, {"codice": "M14", "vagoni": 3}]
min(treni, key=lambda treno: treno["vagoni"]) # → {'codice': 'M14', 'vagoni': 3}Usala solo dentro key=, dove serve una funzione da usare una volta e subito. Per tutto il resto scrivi una def con un nome: si legge meglio, ha la sua docstring e si può provare con un test. Altri esempi con i dizionari: ordinare per valore.
La lista come valore di default
Sembra comodo scrivere def f(x=[]) per partire da una lista vuota. Non lo è: la lista del default si crea una volta sola, quando Python legge la def, non a ogni chiamata. Tutte le chiamate che non passano quell'argomento usano la stessa scatola.
def aggiungi_passeggero(nome, carrozza=[]):
carrozza.append(nome)
return carrozza
aggiungi_passeggero("Lucia") # → ['Lucia']
aggiungi_passeggero("Ivo") # → ['Lucia', 'Ivo']Ivo si ritrova in carrozza con Lucia, che era salita nella chiamata prima. Il rimedio: None come default, e la lista nuova dentro la funzione, a ogni chiamata.
def aggiungi_passeggero(nome, carrozza=None):
if carrozza is None:
carrozza = []
carrozza.append(nome)
return carrozza
aggiungi_passeggero("Lucia") # → ['Lucia']
aggiungi_passeggero("Ivo") # → ['Ivo']
aggiungi_passeggero("Marta", ["Sergio"]) # → ['Sergio', 'Marta']