È necessario ordinare i prodotti in base al prezzo. Scrivere una funzione con nome separato solo per dire “usa il prezzo” sembra una sorta di cerimonia. Le funzioni lambda di Python ti consentono di definire quel piccolo pezzo di logica in linea, esattamente dove lo usi.

I Lambda sono utili, ma sono anche facili da abusare. Questa guida mostra dove aiutano veramente e dove rendono il codice più difficile da leggere. Abbiamo eseguito ogni esempio su Python 3.13 e l’output mostrato proviene da quell’esecuzione.

Cos’è una lambda?

Una lambda è una funzione senza nome, scritta con la parola chiave lambda:

lambda arguments: expression

Accetta un numero qualsiasi di argomenti e restituisce automaticamente il valore di una singola espressione. Non esiste una parola chiave return e nessun insieme di istruzioni.

square = lambda x: x * x
print(square(4))                     # 16

print((lambda a, b=10: a + b)(5))    # 15

La seconda riga definisce una lambda con un argomento predefinito e la chiama immediatamente. Raramente lo scriveresti in codice reale, ma mostra che un lambda è un oggetto funzione ordinario.

lambda contro def

Questi due producono funzioni che si comportano allo stesso modo:

square = lambda x: x * x

def square_def(x):
    return x * x

print(square(4), square_def(4))                 # 16 16
print(square.__name__, square_def.__name__)     # <lambda> square_def

Guarda i nomi. Ogni lambda è chiamato semplicemente <lambda>, quindi i messaggi di errore e i log non possono dirti quale ha avuto esito negativo. Questo è il motivo principale per cui le guide di stile come PEP 8 consigliano un def ogni volta che si desidera dare un nome a una funzione.

Ordinamento con chiave: il miglior utilizzo

Funzioni come sorted, min e max accettano una funzione key che decide cosa confrontare. È qui che brillano le lambda:

products = [("pen", 10), ("bag", 900), ("book", 250)]

sorted(products, key=lambda p: p[1])
# [('pen', 10), ('book', 250), ('bag', 900)]

max(products, key=lambda p: p[1])
# ('bag', 900)

Per ordinare in base a più elementi, restituire una tupla. Qui le persone sono ordinate per età, prima il più anziano e poi per nome:

people = [{"name": "Asha", "age": 31}, {"name": "Ben", "age": 25},
          {"name": "Dev", "age": 31}]

[p["name"] for p in sorted(people, key=lambda p: (-p["age"], p["name"]))]
# ['Asha', 'Dev', 'Ben']

Il segno meno inverte l’ordine solo per il numero. A volte non è affatto necessario un lambda, perché una funzione esistente fa già il lavoro. Confronta l’ordinamento predefinito con uno senza distinzione tra maiuscole e minuscole:

names = ["Asha", "ben", "Chitra", "dev"]

sorted(names)                  # ['Asha', 'Chitra', 'ben', 'dev']
sorted(names, key=str.lower)   # ['Asha', 'ben', 'Chitra', 'dev']

Per impostazione predefinita, tutte le parole in maiuscolo vengono messe per prime. Passare str.lower risolve il problema senza lambda. Il modulo operator offre aiutanti simili, come itemgetter(1) per lambda p: p[1].

mappare e filtrare

map applica una funzione a ogni elemento e filter mantiene gli elementi per i quali restituisce true. Entrambi funzionano con lambda, ma confrontali ciascuno con una comprensione di elenco:

nums = [1, 2, 3, 4, 5, 6]

list(map(lambda n: n * 10, nums))      # [10, 20, 30, 40, 50, 60]
[n * 10 for n in nums]                 # [10, 20, 30, 40, 50, 60]

list(filter(lambda n: n % 2 == 0, nums))   # [2, 4, 6]
[n for n in nums if n % 2 == 0]            # [2, 4, 6]

I risultati sono identici e la maggior parte degli sviluppatori Python trova le comprensioni più facili da leggere. Nota anche che map e filter restituiscono iteratori pigri, quindi è necessario list() per vedere i valori. La nostra guida alla comprensione dell’elenco Python tratta questo stile in modo approfondito. map funziona ancora bene con una funzione con nome esistente, come in map(str.strip, lines).

ridurre

functools.reduce combina gli elementi in un unico valore, portando un risultato corrente:

from functools import reduce

reduce(lambda acc, n: acc + n, nums, 0)   # 21
sum(nums)                                 # 21

Per i lavori comuni, come i totali, utilizzare un built-in come sum, max o any. Mantieni reduce per i casi più rari e considera un ciclo semplice se la lambda inizia a sembrare complicata.

Condizioni in una lambda

Non puoi utilizzare un’istruzione if in una lambda, ma puoi utilizzare un’espressione condizionale:

label = lambda total: "large" if total >= 1000 else "small"

label(1200), label(300)
# ('large', 'small')

Una condizione va bene. Una volta che inizi a nidificarli, i lettori devono lavorare sodo, il che è un chiaro segno per passare a def con istruzioni if ordinarie.

Lambda che restituiscono funzioni

Una funzione può creare e restituire un lambda che ricorda un valore dall’ambiente circostante:

def multiplier(n):
    return lambda x: x * n

double = multiplier(2)
double(7)   # 14

Funziona grazie alle chiusure, che il nostro articolo sulle chiusure JavaScript spiega in una lingua diversa. Python functools.partial offre un altro modo per precompilare gli argomenti.

La trappola del legame tardivo

Questo alla fine cattura quasi tutti. Abbiamo creato tre lambda in un ciclo, aspettandoci che ciascuno restituisca il proprio numero:

funcs = [lambda: i for i in range(3)]
[f() for f in funcs]

# [2, 2, 2]

Tutti e tre restituiscono 2. Una lambda non cattura il valore di i quando viene creata. Cerca la variabile quando viene chiamata, e a quel punto il ciclo è terminato, lasciando i su 2. La soluzione usuale è acquisire il valore come argomento predefinito, poiché i valori predefiniti vengono valutati al momento della definizione:

funcs = [lambda i=i: i for i in range(3)]
[f() for f in funcs]

# [0, 1, 2]

Questo non è esclusivo dei lambda, poiché un def all’interno di un ciclo si comporta allo stesso modo. Appare più spesso con i lambda, perché sono comunemente creati in loop, ad esempio quando si allegano callback di pulsanti.

Tabelle di ricerca di piccole funzioni

I lambda si adattano perfettamente a un dizionario che associa i nomi a piccole operazioni:

ops = {
    "add": lambda a, b: a + b,
    "sub": lambda a, b: a - b,
}

ops["sub"](10, 3)   # 7

Questo può sostituire una lunga catena di if e elif. La guida al dizionario Python copre più modelli di dizionario e il modulo operator fornisce già operator.add e operator.sub.

Limiti delle lambda

• Solo un’espressione. Nessuna assegnazione con =, nessun loop e nessun blocco try.
• Nessuna dichiarazione. Scrivere lambda x: return x fallisce con un SyntaxError, come confermato dal nostro test.
• Nessuna stringa di documento o suggerimento sul tipo. Strumenti e lettori ricevono meno aiuto.
• Debug più difficile. Gli errori puntano a <lambda> anziché a un nome utile.

Ovviamente i Lambda possono ancora sollevare eccezioni. La loro gestione funziona allo stesso modo di qualsiasi altra funzione, come spiegato in Gestione delle eccezioni Python.

Quando non utilizzare una lambda

Quest’ultimo punto è importante. Vale la pena testare la logica che vale la pena riutilizzare e una funzione con nome è molto più semplice da testare, come mostra il nostro tutorial pytest.

Considerazioni finali

Un buon lambda è abbastanza corto da poter essere letto a colpo d’occhio e usato una volta, di solito come argomento. Le chiavi di ordinamento sono l’esempio classico. Per controllare il tuo codice, cerca = lambda e trasformalo in funzioni con nome. Quindi guarda qualsiasi map o filter con una lambda e vedi se una comprensione si legge meglio.

Domande frequenti

Continua a imparare