Lambda in Python: funzioni anonime, chiave di ordinamento e map/filter

Una funzione a cui non serve un nome

La maggior parte delle funzioni in Python si definisce con def, ha un nome e vive in un file dove può essere riutilizzata. Una lambda è un'alternativa più piccola e senza nome, utile nei pochi casi in cui definire una funzione completa sarebbe più cerimonia di quanto valga.

Ecco le due forme a confronto:

def double(x):
    return x * 2

double_lambda = lambda x: x * 2

print(double(5))
print(double_lambda(5))

Due funzioni che fanno esattamente la stessa cosa. La versione lambda sta su una riga perché in fondo è quello il suo compito: una funzione usa e getta per un momento usa e getta.

Sintassi

lambda <params>: <expression>

• <params> è la stessa lista di parametri che useresti con def: supporta valori predefiniti, *args, **kwargs.
• <expression> è una singola espressione il cui valore diventa il valore restituito.

Esempi:

add = lambda a, b: a + b
print(add(3, 4))

square = lambda n: n * n
print(square(8))

greet = lambda name="world": f"Hello, {name}"
print(greet())
print(greet("Rosa"))

Niente parola chiave return. Il valore dell'espressione viene restituito implicitamente.

L'unico limite

Una lambda può contenere solo una singola espressione. Non puoi metterci dentro delle istruzioni:

# Queste non funzionano:
# bad = lambda x: x = x + 1         # non puoi assegnare
# worse = lambda x:                 # non puoi avere if/elif/else come istruzioni
#     if x > 0:
#         return x
#     else:
#         return -x

Però puoi usare l'espressione ternaria:

signed = lambda x: x if x > 0 else -x
print(signed(-5))
print(signed(5))

Se ti serve più di un'espressione, è il segnale per passare a def.

Dove le lambda sono davvero utili

Una lambda assegnata a una variabile è quasi sempre peggio di una def con nome:

# Non farlo.
double = lambda x: x * 2

È decisamente peggio di def double(x): return x * 2: stessa leggibilità, e in più la versione lambda mostra nei traceback il nome poco utile <lambda>.

Le lambda danno il meglio in un solo punto: come argomenti inline di funzioni di ordine superiore.

Chiavi di ordinamento personalizzate

Il caso classico:

users = [
    {"name": "Ada", "age": 36},
    {"name": "Boris", "age": 28},
    {"name": "Ciara", "age": 44},
]

by_age = sorted(users, key=lambda u: u["age"])
print(by_age)

L'argomento key di sorted vuole una funzione che riceve un elemento e restituisce il valore in base a cui ordinare. Una lambda su una riga è perfetta, mentre una def completa sembrerebbe pesante per una cosa così piccola.

Puoi ordinare in base a più campi usando una tupla:

records = [("Ada", 2), ("Boris", 1), ("Ada", 1), ("Boris", 3)]

by_name_then_version = sorted(records, key=lambda r: (r[0], r[1]))
print(by_name_then_version)

min, max, filter, map

Stessa storia: accettano tutte un argomento funzione opzionale:

prices = [{"item": "apple", "cost": 0.50}, {"item": "bread", "cost": 2.00}]

cheapest = min(prices, key=lambda p: p["cost"])
print(cheapest)

# map: applica una funzione a ogni elemento
numbers = [1, 2, 3, 4]
doubled = list(map(lambda n: n * 2, numbers))
print(doubled)

# filter: tiene gli elementi per cui la funzione restituisce true
evens = list(filter(lambda n: n % 2 == 0, numbers))
print(evens)

Per map e filter, una list comprehension di solito è ancora più chiara:

numbers = [1, 2, 3, 4]

doubled = [n * 2 for n in numbers]
evens = [n for n in numbers if n % 2 == 0]
print(doubled, evens)

Per questo motivo la maggior parte di chi scrive Python preferisce le comprehension a map/filter. lambda resta la scelta naturale per sorted, min e max, dove non esiste una scorciatoia con le comprehension.

Lambda e operator

Quando la tua lambda si limita a "prendere una chiave" o "prendere un attributo", il modulo operator di Python offre alternative più veloci e chiare:

from operator import itemgetter, attrgetter

users = [{"name": "Ada", "age": 36}, {"name": "Boris", "age": 28}]

# Queste due sono equivalenti:
a = sorted(users, key=lambda u: u["name"])
b = sorted(users, key=itemgetter("name"))

print(a)
print(b)

Non è un guadagno enorme, ma nel codice che importa già operator si legge in modo un po' più dichiarativo.

Quando tornare a def

Se vale anche solo una di queste condizioni, scrivi una def:

1. La logica non sta comodamente in una singola espressione.
2. Vuoi dare un nome alla funzione perché il nome aiuterebbe la leggibilità.
3. Useresti la stessa logica in più di un punto.
4. La funzione ha bisogno di una docstring (le lambda non possono averne).

Ricorda: in Python non si vince per numero di righe. Una funzione con nome di tre righe si legge quasi sempre meglio di una lambda su una riga, non appena la logica smette di essere banale.

Prossimo argomento: i decoratori

Le lambda passano funzioni in giro come valori. I decoratori portano la stessa idea un passo più in là: ti permettono di avvolgere qualsiasi funzione con un comportamento riutilizzabile (logging, misurazione dei tempi, cache, autenticazione) usando un solo @ nella riga sopra. È l'argomento della prossima pagina.