Funzioni lambda in Python: guida per principianti

Le funzioni lambda in Python sono strumenti potenti e concisi per creare al volo piccole funzioni anonime. Sono perfette per semplificare compiti a breve termine, snellire il codice con funzioni di ordine superiore come map, filter o sorted e ridurre il rumore quando definisci logiche temporanee o usa e getta. Offrono anche una soluzione elegante per migliorare la leggibilità del codice in scenari semplici. In questo articolo esploreremo cosa sono le funzioni lambda, le loro caratteristiche e come usarle in modo efficace.

In questa guida, ti forniremo una panoramica completa delle funzioni lambda in Python, includendo il loro funzionamento, la sintassi e il confronto con le funzioni standard, con esempi semplici per illustrare i concetti chiave. Esploriamo i casi d’uso più comuni, come l’impiego delle lambda nei paradigmi di programmazione funzionale e la loro efficienza rispetto alle funzioni standard. Esempi pratici e buone pratiche ti aiuteranno a integrare efficacemente le funzioni lambda nella tua programmazione Python.

Che cos’è una funzione lambda in Python?

Le funzioni lambda differiscono dalle funzioni standard di Python in diversi aspetti chiave. Sono espressioni anonime, cioè non hanno un nome a meno che non vengano assegnate esplicitamente a una variabile. Sono anche più concise e definite su una singola riga senza bisogno dell’istruzione return. Questo le rende ideali per operazioni semplici e una tantum e per l’uso come argomenti inline in funzioni di ordine superiore come map, filter e sorted.

Ecco un esempio di funzione lambda che somma due numeri:

fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xe508b8>

Come funzionano le funzioni lambda

Come funziona questa funzione lambda? Per capirlo, confrontiamola con una funzione standard di Python.

# Example: add two numbers using standard Python function
def add_numbers(x, y):
    return x + y

Questa funzione standard è lineare. La parola chiave def definisce la funzione, che accetta due argomenti, x e y. Calcola la somma di x e y e restituisce il risultato.

Ora vediamo come la nostra funzione lambda ottiene lo stesso risultato.

# Example: add two numbers using a lambda function
fn = lambda x, y: x + y
print(fn)

# <function <lambda> at 0xbfb968>

La parola chiave lambda indica che stiamo definendo una funzione lambda, eliminando la necessità della parola chiave def. Subito dopo lambda sono elencati gli argomenti di input x e y. Dopo i due punti, specifichiamo l’espressione il cui risultato verrà restituito, x + y.

Scrivere funzioni lambda in Python: esempi

Per aiutarti a padroneggiare i concetti visti finora, analizziamo alcuni esempi di come funzionano le funzioni Lambda in Python. 

Guida passo passo alla scrittura di funzioni lambda

Le funzioni lambda sono ideali per creare funzioni brevi e lineari senza complessità extra. 

Per esempio, supponi di voler verificare se un intero non nullo è pari. Potresti scrivere una funzione Python standard, ma la stessa funzionalità può essere ottenuta con una lambda di una sola riga assegnata a una variabile: is_even = lambda x: x % 2 == 0. 

Qui, la funzione lambda a destra dell’assegnazione prende un input x e restituisce True se x è pari (cioè se il resto della divisione per 2 è 0). 

Questa funzione lambda viene poi assegnata alla variabile is_even, permettendone la chiamata come una normale funzione. Per esempio, is_even(5) (restituisce False) e is_even(678432) (restituisce True).

Le funzioni lambda sono ottime anche per definire formule semplici. Ad esempio, per convertire i gradi Celsius in Fahrenheit, puoi usare una lambda: c_to_f = lambda c: (c * 9/5) + 32. Poi chiami la funzione come qualsiasi altra funzione: c_to_f(0).

Casi d’uso comuni delle funzioni lambda

Le funzioni lambda sono spesso usate nella programmazione funzionale, in particolare con funzioni come map() e filter(), che accettano altre funzioni come argomenti per elaborare gli elementi di una collezione. Vediamo come usare una funzione lambda con filter(). Ecco uno snippet:

# Use filter with lambda function
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))  # print the list of the filter object to see the result

# [2, 4, 6, 8]

In questo codice, iniziamo definendo un insieme di numbers. Poi creiamo una funzione lambda per verificare se un numero è pari. La funzione filter applica questa lambda all’insieme numbers. Infine, stampiamo la lista dei numeri pari identificati da filter.

Analogamente, possiamo usare la funzione map per applicare una lambda a una collezione di elementi. Nell’esempio seguente, calcoliamo le lunghezze delle stringhe in una lista mappando la funzione len() su ogni elemento.

# Use map with lambda function
fruits = ['apple', 'banana', 'cherry']
lengths = list(map(lambda x: len(x), fruits))
print(lengths)

# [5, 6, 6]

Le funzioni lambda sono usate anche con la funzione sorted(), che ordina gli elementi di una collezione restituendo una nuova collezione. Nel seguente esempio (senza lambda), usiamo sorted() per ordinare una lista di numeri.

numbers = [1, 10, -1, 3, -10, 5]
sorted_stuff = sorted(numbers)
print(sorted_stuff)

# [-10, -1, 1, 3, 5, 10]

Supponiamo di voler ordinare la lista di numeri per valore assoluto. Come possiamo farlo? La funzione sorted() include un argomento key che ci consente di personalizzare l’ordine di ordinamento fornendo una funzione lambda.

# Sort according to absolute value
sorted_numbers_absolute = sorted(numbers, key=lambda x: abs(x))
print(sorted_numbers_absolute)

# [1, -1, 3, 5, 10, -10]

Un altro caso d’uso di sort() con una funzione lambda è ordinare una lista di tuple in base a un elemento specifico, per esempio il secondo.

# Sort a list of tuples by the second element
data = [(1, 3), (2, 1), (4, 2)]
sorted_data = sorted(data, key=lambda x: x[1])
print(sorted_data)

# [(2, 1), (4, 2), (1, 3)]

In questo snippet, definiamo data come una lista di tuple. Poi usiamo la funzione sorted() con il parametro key, dove una funzione lambda estrae il secondo elemento di ogni tupla per l’ordinamento.

Le funzioni lambda sono più veloci in Python?

In Python, le funzioni lambda non sono intrinsecamente più veloci delle funzioni standard, poiché entrambe vengono compilate in bytecode simile. Tuttavia, possono ridurre leggermente l’overhead nei casi in cui definire una funzione completa aggiungerebbe boilerplate non necessario.

Ecco alcuni test che confrontano le funzioni lambda con le funzioni standard di Python. Il codice è stato eseguito sul mio laptop, un MacBook Pro con chip Apple M1 Pro, 16 GB di memoria, macOS Sequoia 15.2.

Le funzioni lambda possono essere usate inline come funzioni anonime quando vengono passate direttamente a funzioni di ordine superiore come map(), filter() o sorted(). Questo evita la necessità di definire e referenziare una funzione nominata separata, riducendo sia il codice boilerplate sia l’overhead di lookup.

import time

numbers = list(range(1, 1000000))

# Standard function
def double_standard(x):
    return x * 2

start = time.time()
map(double_standard, numbers)
print(time.time() - start)

# Lambda function
double_lambda = map(lambda x: x * 2, numbers)

start = time.time()
list(map(lambda x: x * 2, numbers))
print(time.time() - start)

# 3.504753112792969e-05
# 2.384185791015625e-05

Le funzioni lambda sono ideali per usi una tantum o temporanei, perché eliminano la necessità di un blocco formale def, risparmiando tempo e spazio. Nel blocco seguente, confrontiamo le prestazioni di una funzione standard con quelle di una lambda. Ordiniamo un dizionario con un milione di elementi, in cui le chiavi sono codici casuali di due lettere e i valori sono interi casuali.

import random
import string

# Generate a dictionary with elements of the form 'XX': number.
NUMBER_ITEMS = 1000000
items = {
    ''.join(random.choices(string.ascii_uppercase, k=2)): random.randint(1, 100)
    for _ in range(NUMBER_ITEMS)
}

# Standard function (extra definition step)
def sort_standard(item):
    return item[1]

print('Standard')
start = time.time()
sorted_items_standard = sorted(items, key=sort_standard)
print(time.time() - start)
print(sorted_items_standard[:5])
print()

# Lambda function
print('Lambda')
start = time.time()
sorted_items_lambda = sorted(items, key=lambda x: x[1])
print(time.time() - start)
print(sorted_items_lambda[:5])
print()

# Standard
# 0.00011610984802246094
# ['OA', 'VA', 'XA', 'IA', 'BA']
# Lambda
# 0.00011014938354492188
# ['OA', 'VA', 'XA', 'IA', 'BA']

Funzioni lambda in Python: esempi ed esercizi

Vediamo altri esempi pratici per mostrare come funzionano le funzioni Lambda in Python. 

Esempi pratici

Le funzioni lambda sono spesso usate con i metodi built-in di Python. Per esempio, vediamo come usare reduce() per applicare cumulativamente una funzione binaria definita dall’utente agli elementi di una sequenza.

# Example: Use lambda function with built-in Python method reduce.
from functools import reduce

numbers = [5, -6, 2, 7]
total = reduce(lambda x, y: x + y, numbers)
print(f'The sum of the numbers is {total}.')

# The sum of the numbers is 8.

Similmente a filter() o map() visti sopra, reduce() applica una funzione, qui fornita da una lambda, a un insieme di elementi.

Ora esploriamo un’altra funzione built-in di Python, zip(). La funzione zip accoppia gli elementi corrispondenti di più liste in tuple. Per esempio, il risultato di zip(['a', 'b', 'c'], [1, 2, 3]) è [('a', 1), ('b', 2), ('c', 3)].

# Example: Use lambda function with built-in Python method zip.
list1 = [1, 2, 3]
list2 = [4, 5, 6]

# Using zip and a lambda function to multiply corresponding elements
result = list(map(lambda x: x[0] * x[1], zip(list1, list2)))

print(f'The result of multiplying corresponding elements is {result}.')

# The result of multiplying corresponding elements is [4, 10, 18].

Questo codice calcola il prodotto degli elementi corrispondenti di due liste, list1 e list2. Usa zip() per accoppiare gli elementi delle liste in tuple, poi applica una funzione lambda con map() per moltiplicare gli elementi accoppiati e infine converte il risultato in una lista.

Esempio reale: trasformazione dei dati

Immagina di gestire un banco di frutta e di voler calcolare l’importo totale delle vendite per ogni tipo di frutta.

Per prima cosa, creiamo alcuni record di vendita. Poi usiamo map() con una funzione lambda per calcolare total_sales moltiplicando prezzo e quantità per ciascun elemento nel dizionario sales_data. La sintassi **record espande il dizionario originale, assicurando che tutte le sue chiavi e i suoi valori siano preservati nel nuovo dizionario. Infine, stampiamo ogni record dei dati trasformati.

# Sample data: list of dictionaries representing sales records
sales_data = [
	{'fruit': 'peaches', 'price': 1.41, 'quantity': 3},
	{'fruit': 'pears', 'price': 1.21, 'quantity': 2},
	{'fruit': 'mangoes', 'price': 0.56, 'quantity': 3},
]

# Using a lambda function to calculate total sales for each record
transformed_data = list(
	map(
		lambda entry: {**entry, 'total_sales': round(entry['price'] * entry['quantity'], 2)},
		sales_data
	)
)

# Print the transformed data
for record in transformed_data:
	print(record)

# {'fruit': 'peaches', 'price': 1.41, 'quantity': 3, 'total_sales': 4.23}
# {'fruit': 'pears', 'price': 1.21, 'quantity': 2, 'total_sales': 2.42}
# {'fruit': 'mangoes', 'price': 0.56, 'quantity': 3, 'total_sales': 1.68}

Problemi semplici da risolvere con le funzioni lambda

Se vuoi esercitarti con le funzioni lambda, ecco alcuni problemi da provare.

• Dato un numero, trovarne il quadrato.
• Dati due numeri, trovare il maggiore.
• Dato un numero, verificare se è dispari.
• Data una lista di interi positivi, filtrare tutti i numeri dispari.
• Ordinare una lista di tuple di 3 elementi utilizzando il terzo elemento.
• Estrarre il dominio da un indirizzo email. Ad esempio, dato [email protected], estrarre example.com.

Errori comuni legati alle lambda

Vediamo alcuni errori comuni che i programmatori commettono con le lambda e come risolverli.

1. Il primo errore è usare una funzione lambda quando non è appropriato. È importante ricordare che le funzioni lambda sono pensate per compiti brevi e semplici, non per gestire logiche complesse. Per esempio, il seguente snippet non è un caso d’uso ideale per una lambda.

# Complex logic in a lambda
result = lambda x: (x ** 2 + x - 1) / (x + 1 if x != -1 else 1)
print(result(5))  # Hard to understand

# 4.833333333333333

In questo caso, è meglio usare una normale funzione Python.

def complex_logic(x):
    if x == -1:
        return x ** 2 + x - 1
    return (x ** 2 + x - 1) / (x + 1)
print(complex_logic(5))

# 4.833333333333333

2. Un altro errore semplice è confondere la sintassi. Per esempio, dimenticare la parola chiave lambda causerà un errore. Un altro errore comune di sintassi è omettere gli argomenti di input:

# Forgetting the required arguments
numbers = [1, 2, 3, 4]
squared = map(lambda: x ** 2, numbers)  # <-- Where is the input argument? Error: lambda missing argument

La correzione è includere l’argomento di input:

squared = map(lambda x: x ** 2, numbers)

Un buon modo per intercettare errori di questo tipo è includere casi di test informali e semplici durante lo sviluppo.

print(list(squared))

3. Un altro errore da evitare è non includere logica per i casi limite. Per esempio, questo codice fallisce quando y è 0. La correzione è includere una semplice istruzione if per intercettare il caso problematico o racchiudere il codice in un blocco di eccezione.

# Dividing without handling zero
divide = lambda x, y: x / y

safe_divide = lambda x, y: x / y if y != 0 else "undefined"
print(safe_divide(5, 0))

# undefined

4. Un problema più sottile è dimenticare di convertire l’iteratore in una lista quando si vogliono mostrare i risultati. Per esempio, la funzione map() restituisce un oggetto map, non una lista. Per accedere ai risultati, converti l’oggetto map in una list.

# Forgetting to convert to a list
numbers = [1, 2, 3]
squared = map(lambda x: x ** 2, numbers)
print(squared)  # <-- squared is the map, not the result

# <map object at 0x106d2b0>

print(list(squared))  # list(squared) gives the result

# [1, 4, 9]

Strategie di debug per le lambda in Python

Come possiamo fare il debug delle lambda? Ecco alcune possibilità.

• Scomponi la lambda. Converti temporaneamente in una funzione nominata per scopi di debug.
• Usa print per mostrare valori intermedi in funzioni di ordine superiore come map() o filter().
• Testa i casi limite. Prova con valori estremi, non validi o di confine per intercettare potenziali errori.

Un trucco utile per stampare passaggi intermedi è includere un’istruzione print all’interno di una tupla insieme al risultato. L’output desiderato può poi essere passato alla funzione di ordine superiore indicizzando la tupla in posizione 1. 

Ecco un esempio:

numbers = [1, 2, 3, 4, 5]

# Lambda function with print to debug intermediate values
filtered_numbers = filter(lambda x: (print(f'Checking: {x} -> {x >= 3}'), x >= 3)[1], numbers)

# Converting filter object to list to force evaluation
print(list(filtered_numbers))

# Checking: 1 -> False
# Checking: 2 -> False
# Checking: 3 -> True
# Checking: 4 -> True
# Checking: 5 -> True
# [3, 4, 5]

In questo codice, si usa un trucco per stampare i passaggi intermedi mentre si filtra una lista di numeri. La funzione lambda in filter include una tupla: il primo elemento è un’istruzione print che registra il numero corrente e se soddisfa la condizione (x >= 3), il secondo elemento è la condizione stessa. 

L’[1] alla fine della lambda assicura che la condizione (x >= 3) venga restituita alla funzione filter consentendo al contempo l’esecuzione di print per il debug. 

Convertire l’oggetto filter in una lista forza la valutazione di tutti gli elementi, attivando le istruzioni print per ogni numero. Questo approccio aiuta a fare il debug della logica mantenendo la funzionalità dell’operazione di filtraggio.

Buone pratiche per usare le funzioni lambda

Le buone pratiche per usare le funzioni lambda riguardano la comprensione di quando sono appropriate e quando andrebbero evitate.

Quando usare le funzioni Lambda

• Logica breve e semplice. Ideali per operazioni concise che non richiedono una definizione completa di funzione.
• Funzioni di ordine superiore. Funzionano bene come argomenti di funzioni di ordine superiore come map(), filter() o sorted().
• Funzioni temporanee (usa e getta). Utili quando serve una funzione solo una volta e definirla con def renderebbe il codice più complicato del necessario.
• Migliore leggibilità. Adatte per compiti semplici in cui una lambda mantiene il codice compatto e facile da seguire.

Quando evitare le funzioni Lambda

• Logica complessa o multilinea. Le lambda sono limitate a una sola espressione e diventano rapidamente illeggibili per operazioni più articolate.
• Funzioni riutilizzabili o con nome. Se la funzione deve essere riutilizzata o beneficia di un nome descrittivo, è più appropriata una funzione standard con def.
• Debug o documentazione. Le funzioni lambda non possono includere docstring e possono essere più difficili da debuggare rispetto alle funzioni con nome.

Per migliorare leggibilità e manutenibilità usando le lambda, segui queste buone pratiche:

• Usa nomi descrittivi per chiarezza.
• Tieni tutto semplice: le lambda idealmente devono stare su una riga e rappresentare una logica lineare.
• Limita l’annidamento: evita di usare funzioni lambda dentro altre lambda o in strutture dati complesse se non necessario.
• Preferisci la leggibilità alla concisione: se usare una lambda compromette la leggibilità, è meglio definire una funzione con nome.

Conclusione

Le funzioni lambda in Python sono uno strumento potente per scrivere funzioni concise e anonime. Danno il meglio in scenari che richiedono operazioni brevi, temporanee o inline, in particolare se usate con funzioni di ordine superiore come map, filter o sorted. 

Tuttavia, andrebbero usate con giudizio, perché la logica più complessa è più adatta a funzioni standard definite con def. Capendo punti di forza, limiti e buone pratiche, potrai sfruttare efficacemente le funzioni lambda per scrivere codice Python pulito, efficiente e manutenibile.

Per saperne di più sulle funzioni Python, dai un’occhiata alle risorse di DataCamp.

• Funzioni Python: come chiamare e scrivere funzioni
• Corso Writing Functions in Python
• Fondamenti di dati in Python
• Fondamenti di programmazione in Python
• Corso Intermediate Python for Developers