Le funzioni Lambda in Python

Le funzioni lambda in Python sono un argomento interessante e molto utile. Permettimi di spiegarti tutto nel dettaglio, partendo dalle basi e arrivando ad esempi più complessi.

Le funzioni lambda, dette anche funzioni anonime, sono piccole funzioni che possono essere definite in una sola riga di codice. In pratica, sono un modo rapido e conciso per creare funzioni semplici senza utilizzare la parola chiave def.

Cos’è una funzione lambda?

Una funzione lambda è una funzione senza nome che può essere definita in una sola riga di codice. La sintassi di una funzione lambda è la seguente:

lambda argomenti: espressione

• argomenti: sono gli argomenti della funzione.
• espressione: è il valore restituito dalla funzione.

Facciamo alcuni esempi per capire meglio:

Funzione lambda semplice

# Funzione lambda che restituisce il quadrato di un numero
quadrato = lambda x: x ** 2
print(quadrato(5)) # Stamperà 25

Funzione lambda con più argomenti

# Funzione lambda che somma due numeri
somma = lambda a, b: a + b
print(somma(3, 4)) # Stamperà 7

A cosa servono le funzioni lambda?

Le funzioni lambda possono essere utilizzate per una varietà di scopi, tra cui:

• Creare funzioni semplici: Le funzioni lambda sono un ottimo modo per creare funzioni semplici che non verranno utilizzate spesso.
• Passare funzioni come argomenti ad altre funzioni: Alcune funzioni accettano altre funzioni come argomenti. Le funzioni lambda possono essere utilizzate per creare queste funzioni.
• Filtrare e ordinare liste: Le funzioni lambda possono essere utilizzate per filtrare e ordinare liste utilizzando le funzioni filter() e sorted()

Utilizzi comuni delle lambda

Le funzioni lambda sono particolarmente utili in alcune situazioni:

Nella funzione map()

# Moltiplicare ogni numero di una lista per 2
numeri = [1, 2, 3, 4, 5]
raddoppiati = list(map(lambda x: x * 2, numeri))
print(raddoppiati) # [2, 4, 6, 8, 10]

Nella funzione filter()

# Filtrare solo i numeri pari
numeri = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pari = list(filter(lambda x: x % 2 == 0, numeri))
print(pari) # [2, 4, 6, 8, 10]

Nell’ordinamento con sorted()

# Ordinare una lista di tuple in base al secondo elemento
coppie = [(1, 5), (3, 2), (2, 8)]
ordinato = sorted(coppie, key=lambda x: x[1])
print(ordinato) # [(3, 2), (1, 5), (2, 8)]

Altri esempi di utilizzo

# Utilizzo di una funzione lambda per calcolare il quadrato di una lista di numeri
numbers = [1, 2, 3, 4, 5]
squared_numbers = map(lambda x: x ** 2, numbers)
print(list(squared_numbers))

# Utilizzo di una funzione lambda per filtrare una lista di numeri pari
numbers = [1, 2, 3, 4, 5]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))

# Utilizzo di una funzione lambda per ordinare una lista di numeri in ordine decrescente
numbers = [1, 2, 3, 4, 5]
numbers.sort(key=lambda x: -x)
print(numbers)

Usare la funzione lambda in un ciclo

E’ anche possibile usare una funzione lambda all’interno di un ciclo in Python. Anche se non è l’uso più comune (spesso si preferiscono le list comprehension o generator expression per operazioni semplici su iterabili), ci sono scenari in cui l’uso di lambda in un ciclo può risultare utile o persino necessario.

Ecco alcuni modi in cui puoi usare le lambda all’interno di un ciclo e quando potrebbe essere appropriato:

Creazione di una lista di funzioni lambda:

Puoi usare un ciclo per creare dinamicamente una lista di funzioni lambda, ognuna con un comportamento leggermente diverso.

def crea_moltiplicatori(n):
    """Crea una lista di funzioni lambda che moltiplicano per numeri da 1 a n."""
    moltiplicatori = []
    for i in range(1, n + 1):
        moltiplicatori.append(lambda x, fattore=i: x * fattore)  # Importante: fattore=i
    return moltiplicatori

# Esempio di utilizzo:
moltiplicatori = crea_moltiplicatori(5)

for i, moltiplica in enumerate(moltiplicatori):
    print(f"3 * {i+1} = {moltiplica(3)}")
# Esempio di utilizzo:
moltiplicatori = crea_moltiplicatori(5)

for i, moltiplica in enumerate(moltiplicatori):
print(f"3 * {i+1} = {moltiplica(3)}")

3 * 1 = 3
3 * 2 = 6
3 * 3 = 9
3 * 4 = 12
3 * 5 = 15

Spiegazione dell’esempio e perché fattore=i è cruciale:

• All’interno del ciclo for, creiamo una funzione lambda che moltiplica x per i.
• Fondamentale: Usiamo fattore=i come argomento predefinito nella lambda. Questo “cattura” il valore corrente di i al momento della definizione della lambda. Senza questo, tutte le lambda nella lista finirebbero per usare l’ultimo valore di i (in questo caso, 5), a causa del late binding delle variabili nei closure.

Uso di lambda con map(), filter() o sorted() all’interno di un ciclo (meno comune):

dati = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

for riga in dati:
    risultati = list(map(lambda x: x * 2, riga))
    print(risultati)

In questo caso, l’uso del ciclo è per iterare sulle righe della matrice dati, non per la logica di moltiplicazione, che è gestita da map() e dalla lambda.

Vantaggi delle lambda:

• Codice più conciso
• Funzioni temporanee senza necessità di definizione formale
• Utili per operazioni brevi e semplici

Limitazioni:

• Non possono contenere più espressioni
• Meno leggibili per logiche complesse
• Non supportano annotazioni o docstring

Consiglio:

Usa le lambda quando la logica è semplice. Per funzioni più complesse, preferisci sempre le funzioni definite con def.

Esempio 1: Trasformazione Dati in Applicazioni Reali

Immagina di avere una lista di nomi e voler estrarre solo i nomi che iniziano con una lettera specifica:

nomi = ['Alessandro', 'Maria', 'Carlo', 'Anna', 'Marco']

# Lambda per filtrare nomi che iniziano con 'A'
nomi_a = list(filter(lambda nome: nome.startswith('A'), nomi))
print(nomi_a) # Risultato: ['Alessandro', 'Anna']

In questo esempio, la lambda function controlla l’iniziale di ogni nome.

Esempio 2: Calcoli Matematici Rapidi

Supponiamo di voler calcolare l’area di diverse forme geometriche:

# Lambda per calcolare l'area di diverse forme
calcola_area_cerchio = lambda raggio: 3.14 * raggio ** 2
calcola_area_quadrato = lambda lato: lato ** 2
calcola_area_rettangolo = lambda base, altezza: base * altezza

print(calcola_area_cerchio(5)) # Area di un cerchio con raggio 5
print(calcola_area_quadrato(4)) # Area di un quadrato di lato 4
print(calcola_area_rettangolo(3,6)) # Area di un rettangolo 3x6

Esempio 3: Ordinamento Complesso di Dizionari

In una gestione di dipendenti, potresti voler ordinare per criteri multipli:

dipendenti = [
    {'nome': 'Mario', 'stipendio': 2000, 'anzianita': 5},
    {'nome': 'Luigi', 'stipendio': 2500, 'anzianita': 3},
    {'nome': 'Anna', 'stipendio': 2000, 'anzianita': 7}
]

# Ordina prima per stipendio, poi per anzianità
ordinati = sorted(dipendenti, key=lambda x: (x['stipendio'], x['anzianita']))
for dipendente in ordinati:
    print(f"{dipendente['nome']}: {dipendente['stipendio']} €")

Mario: 2000 €
Anna: 2000 €
Luigi: 2500 €

Esempio 4: Elaborazione Stringhe

Trasformazioni rapide di stringhe:

# Converti una lista di parole in maiuscolo
parole = ['python', 'lambda', 'programmazione']
maiuscole = list(map(lambda x: x.upper(), parole))
print(maiuscole)

# Rimuovi spazi bianchi
nomi_sporchi = [' mario ', ' luigi ', 'anna ']
nomi_puliti = list(map(lambda x: x.strip(), nomi_sporchi))
print(nomi_puliti)

[‘PYTHON’, ‘LAMBDA’, ‘PROGRAMMAZIONE’]
[‘mario’, ‘luigi’, ‘anna’]

Esempio 5: Funzioni di Trasformazione Dinamica

Creare funzioni lambda che generano altre funzioni:

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

# Crea funzioni specializzate
raddoppia = moltiplicatore(2)
triplica = moltiplicatore(3)

print(raddoppia(5))   # 10
print(triplica(5))    # 15

(105)