Python Lambda

Cos'è una Funzione Lambda?

Una funzione lambda è una piccola funzione anonima definita con la parola chiave lambda invece di def. Anonima significa che non ha un nome associato — sebbene tu possa assegnarla a una variabile se hai bisogno di riutilizzarla. Le funzioni lambda sono un modo conciso per scrivere funzioni semplici a singola espressione inline, senza il sovraccarico di una definizione di funzione completa.

Le funzioni lambda sono particolarmente utili come callback di breve durata passate a funzioni di ordine superiore come map(), filter() e sorted().

Sintassi

lambda arguments: expression

• arguments — zero o più parametri separati da virgola (come la lista di parametri di una funzione def, inclusi i valori predefiniti).
• expression — una singola espressione il cui valore viene restituito automaticamente. Le istruzioni (come i blocchi if/else, i cicli for o return) non sono consentite nel corpo di una lambda.

Un confronto valido affiancato:

def square(x):
    return x ** 2

square_lambda = lambda x: x ** 2

print(square(5))        # Output: 25
print(square_lambda(5)) # Output: 25

Esempi di Base

# No arguments
greet = lambda: "Hello, World!"
print(greet())  # Output: Hello, World!

# One argument
square = lambda x: x ** 2
print(square(5))  # Output: 25

# Two arguments
add = lambda x, y: x + y
print(add(10, 20))  # Output: 30

# Default argument value
greet_name = lambda name="World": "Hello, " + name + "!"
print(greet_name())          # Output: Hello, World!
print(greet_name("Alice"))   # Output: Hello, Alice!

Logica Condizionale in una Lambda

Poiché le lambda devono essere una singola espressione, non puoi usare un'istruzione if/else. Puoi, tuttavia, usare un'espressione ternaria (condizionale):

classify = lambda n: "positive" if n > 0 else ("zero" if n == 0 else "negative")

print(classify(5))   # Output: positive
print(classify(0))   # Output: zero
print(classify(-3))  # Output: negative

Le espressioni ternarie profondamente annidate riducono rapidamente la leggibilità — passa a una funzione def normale non appena la logica cresce.

Utilizzo di Lambda con map()

map(function, iterable) applica una funzione a ogni elemento di un iterabile e restituisce un oggetto map. Lambda è particolarmente adatta come argomento funzione.

nums = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, nums))
print(doubled)  # Output: [2, 4, 6, 8, 10]

La lista di comprensione equivalente è spesso preferita per la leggibilità:

doubled = [x * 2 for x in nums]  # same result

Consulta List Comprehension per ulteriori informazioni su questo approccio.

Utilizzo di Lambda con filter()

filter(function, iterable) mantiene solo gli elementi per cui la funzione restituisce True.

nums = [1, 2, 3, 4, 5]
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens)  # Output: [2, 4]

Utilizzo di Lambda con sorted()

Il parametro key di sorted() (e list.sort()) accetta un callable che restituisce il valore di confronto per ogni elemento. Lambda rende concisi i criteri di ordinamento occasionali.

# Sort strings by length
words = ["banana", "apple", "cherry", "date"]
by_length = sorted(words, key=lambda s: len(s))
print(by_length)  # Output: ['date', 'apple', 'banana', 'cherry']

# Sort a list of tuples by the second element
pairs = [(1, "b"), (2, "a"), (3, "c")]
by_second = sorted(pairs, key=lambda p: p[1])
print(by_second)  # Output: [(2, 'a'), (1, 'b'), (3, 'c')]

Per ulteriori informazioni sull'ordinamento delle liste, consulta Sort Lists.

Lambda Invocata Immediatamente

Una lambda può essere chiamata nel momento in cui viene definita, racchiudendola tra parentesi e aggiungendo gli argomenti:

result = (lambda x, y: x + y)(3, 7)
print(result)  # Output: 10

Questo schema è poco comune nel codice di produzione, ma occasionalmente utile negli script una tantum o nei test rapidi.

Lambda Memorizzata in una Struttura Dati

Poiché una lambda è un oggetto di prima classe in Python, puoi memorizzare le lambda in liste o dizionari per costruire semplici tabelle di dispatch:

ops = {
    "add": lambda x, y: x + y,
    "sub": lambda x, y: x - y,
    "mul": lambda x, y: x * y,
}

print(ops["add"](3, 4))   # Output: 7
print(ops["sub"](10, 3))  # Output: 7
print(ops["mul"](2, 6))   # Output: 12

Lambda vs. def — Quando Usare Quale

La guida di stile PEP 8 raccomanda di non assegnare una lambda a un nome di variabile quando un def sarebbe più chiaro. Ad esempio, preferire def add(x, y): return x + y rispetto a add = lambda x, y: x + y quando la funzione si trova a livello di modulo.

Limitazioni Principali

• Solo singola espressione. Nessuna assegnazione, ciclo o logica multilinea.
• Nessuna istruzione. print() è una chiamata di funzione (valida), ma assert, raise o return sono istruzioni e non possono comparire nel corpo di una lambda.
• Nessuna annotazione. Le annotazioni di tipo (x: int) non sono consentite nelle liste di parametri lambda.
• Più difficile da debuggare. Le tracce dello stack mostrano <lambda> invece di un nome di funzione significativo.
• Non serializzabile con pickle. Il modulo standard pickle non può serializzare oggetti lambda — rilevante quando si utilizza il multiprocessing.

Relazione con Closure e Decoratori

Come una funzione normale definita con def, una lambda chiude sulle variabili nel suo scope di inclusione:

def make_multiplier(n):
    return lambda x: x * n   # 'n' is captured from the enclosing scope

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))  # Output: 10
print(triple(5))  # Output: 15

Per un'analisi più approfondita di come funzionano le closure in Python, consulta Python Closures. Le funzioni lambda compaiono anche frequentemente all'interno dei Python Decorators come wrapper leggeri. Per una panoramica completa delle definizioni di funzione, consulta Python Functions.

Esercitazione