Python Funzioni Lambda con ESEMPI

In cosa consiste la funzione Lambda Python?

A Funzione Lambda inserita Python la programmazione è una funzione anonima o una funzione senza nome. È una funzione piccola e limitata che non ha più di una riga. Proprio come una funzione normale, una funzione Lambda può avere più argomenti con un'unica espressione.

In Python, le espressioni lambda (o forme lambda) vengono utilizzate per costruire funzioni anonime. Per fare ciò, utilizzerai il file lambda parola chiave (proprio come usi def per definire le funzioni normali). Ogni funzione anonima definita in Python avrà 3 parti essenziali:

• La parola chiave lambda.
• I parametri (o variabili legate), e
• Il corpo della funzione.

Una funzione lambda può avere un numero qualsiasi di parametri, ma il corpo della funzione può solo contenere prima espressione. Inoltre una lambda è scritta in un'unica riga di codice e può essere invocata anche immediatamente. Vedrai tutto questo in azione nei prossimi esempi.

Sintassi ed esempi

La sintassi formale per scrivere una funzione lambda è la seguente:

lambda p1, p2: expression

Qui, p1 e p2 sono i parametri che vengono passati alla funzione lambda. Puoi aggiungere tutti i parametri di cui hai bisogno o pochi.

Tuttavia, notate che non usiamo le parentesi intorno ai parametri come facciamo con le funzioni normali. L'ultima parte (espressione) è qualsiasi valida Python espressione che opera sui parametri forniti alla funzione.

esempio 1

Ora che conosci le lambda, proviamolo con un esempio. Quindi, apri il tuo IDLE e digita quanto segue:

adder = lambda x, y: x + y
print (adder (1, 2))

Code Spiegazione

Qui definiamo una variabile che manterrà il risultato restituito dalla funzione lambda.

1. La parola chiave lambda utilizzata per definire una funzione anonima.

2. xey sono i parametri che passiamo alla funzione lambda.

3. Questo è il corpo della funzione, che aggiunge i 2 parametri che abbiamo passato. Si noti che si tratta di una singola espressione. Non è possibile scrivere più istruzioni nel corpo di una funzione lambda.

4. Chiamiamo la funzione e stampiamo il valore restituito.

esempio 2

Questo era un esempio di base per comprendere i fondamenti e la sintassi di lambda. Proviamo ora a stampare una lambda e vediamo il risultato. Di nuovo, apri il tuo IDLE e digita quanto segue:

#What a lambda returns
string='some kind of a useless lambda'
print(lambda string : print(string))

Ora salva il tuo file e premi F5 per eseguire il programma. Questo è l'output che dovresti ottenere.

Produzione:

<function <lambda> at 0x00000185C3BF81E0>

Cosa sta succedendo qui? Analizziamo il codice per comprenderlo meglio.

Code Spiegazione:

1. Qui definiamo un stringa che passerai come parametro alla lambda.

2. Dichiariamo una lambda che richiama un'istruzione print e ne stampa il risultato.

Ma perché il programma non stampa la stringa che passiamo? Questo perché la lambda stessa restituisce un oggetto funzione. In questo esempio, la lambda non viene detto dalla funzione di stampa ma è semplicemente di ritorno l'oggetto funzione e l'indirizzo di memoria in cui è memorizzato. Questo è ciò che viene stampato sulla console.

esempio 3

Tuttavia, se scrivi un programma come questo:

#What a lambda returns #2
x="some kind of a useless lambda"
(lambda x : print(x))(x)

Eseguilo premendo F5, vedrai un output simile a questo.

Produzione:

some kind of a useless lambda

Ora, la lambda viene chiamata e la stringa che le passiamo viene stampata sulla console. Ma cos'è quella strana sintassi e perché la definizione della lambda è racchiusa tra parentesi quadre? Cerchiamo di capirlo.

Code Spiegazione:

1. Ecco la stessa stringa che abbiamo definito nell'esempio precedente.

2. In questa parte, definiamo una lambda e la richiamiamo immediatamente passando la stringa come argomento. Questo è ciò che viene chiamato IIFE (Initial IIfe Function Expression), e ne saprai di più nelle sezioni successive di questo tutorial.

esempio 4

Vediamo un ultimo esempio per capire come vengono eseguite le lambda e le funzioni normali. Quindi, apri il tuo IDLE e in un nuovo file, digita quanto segue:

#A REGULAR FUNCTION
def guru( funct, *args ):
funct( *args )
def printer_one( arg ):
return print (arg)
def printer_two( arg ):
print(arg)
#CALL A REGULAR FUNCTION 
guru( printer_one, 'printer 1 REGULAR CALL' )
guru( printer_two, 'printer 2 REGULAR CALL \n' )
#CALL A REGULAR FUNCTION THRU A LAMBDA
guru(lambda: printer_one('printer 1 LAMBDA CALL'))
guru(lambda: printer_two('printer 2 LAMBDA CALL'))

Ora, salva il file e premi F5 per eseguire il programma. Se non hai commesso errori, l'output dovrebbe essere simile a questo.

Produzione:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code Spiegazione:

1. Una funzione chiamata guru che accetta un'altra funzione come primo parametro e tutti gli altri argomenti che la seguono.

2. printer_one è una semplice funzione che stampa il parametro che le viene passato e lo restituisce.

3. printer_two è simile a printer_one ma senza l'istruzione return.

4. In questa parte, richiamiamo la funzione guru e passiamo come parametri le funzioni della stampante e una stringa.

5. Questa è la sintassi per realizzare il quarto passaggio (ovvero, chiamare la funzione guru) ma utilizzando le espressioni lambda.

Nella sezione successiva imparerai come utilizzare le funzioni lambda con map (), ridurre()e filtro() in Python.

Utilizzando lambda con Python built-in

Le funzioni Lambda forniscono un modo elegante e potente per eseguire operazioni utilizzando metodi incorporati in Python. È possibile perché i lambda possono essere richiamati immediatamente e passati come argomento a queste funzioni.

IIFE dentro Python Lambda

IFE sta per esecuzione della funzione immediatamente invocata. Significa che una funzione lambda è richiamabile non appena viene definita. Cerchiamo di capirlo con un esempio; avvia il tuo IDLE e digita quanto segue:

 (lambda x: x + x)(2)

Ecco l'output e la spiegazione del codice:

Questa capacità dei lambda di essere invocati immediatamente consente di utilizzarli all'interno di funzioni come map() e reduce(). È utile perché potresti non voler utilizzare più queste funzioni.

lambda nel filtro()

La funzione filtro viene utilizzata per selezionare alcuni elementi particolari da una sequenza di elementi. La sequenza può essere qualsiasi iteratore come elenchi, insiemi, tuple, ecc.

Gli elementi che verranno selezionati si basano su alcuni vincoli predefiniti. Richiede 2 parametri:

• Una funzione che definisce il vincolo di filtraggio
• Una sequenza (qualsiasi iteratore come liste, tuple, ecc.)

Per esempio,

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = filter (lambda x: x > 4, sequences) 
print(list(filtered_result))

Ecco l'output:

[10, 8, 7, 5, 11]

Code Spiegazione:

1. Nella prima istruzione definiamo una lista chiamata sequenze che contiene alcuni numeri.

2. Qui dichiariamo una variabile chiamata filtered_result, che memorizzerà i valori filtrati restituiti dalla funzione filter().

3. Una funzione lambda che viene eseguita su ciascun elemento dell'elenco e restituisce true se è maggiore di 4.

4. Stampa il risultato restituito dalla funzione filtro.

lambda nella mappa()

La funzione map viene utilizzata per applicare una particolare operazione a ogni elemento di una sequenza. Come filter(), accetta anche 2 parametri:

1. Una funzione che definisce l'operazione da eseguire sugli elementi
2. Una o più sequenze

Ad esempio, ecco un programma che stampa i quadrati dei numeri in un elenco dato:

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = map (lambda x: x*x, sequences) 
print(list(filtered_result))

Produzione:

 [100, 4, 64, 49, 25, 16, 9, 121, 0, 1]

Code Spiegazione:

1. Qui definiamo un elenco chiamato sequenze che contiene alcuni numeri.

2. Dichiariamo una variabile chiamata filtered_result che memorizzerà i valori mappati.

3. Una funzione lambda che viene eseguita su ciascun elemento della lista e restituisce il quadrato di quel numero.

4. Stampa il risultato restituito dalla funzione map.

lambda in riduzione()

La funzione reduce, come map(), viene utilizzata per applicare un'operazione a ogni elemento in una sequenza. Tuttavia, differisce dalla mappa nel suo funzionamento. Questi sono i passaggi seguiti dalla funzione reduce() per calcolare un output:

Passo 1) Eseguire l'operazione definita sui primi 2 elementi della sequenza.

Passo 2) Salva questo risultato.

Passo 3) Eseguire l'operazione con il risultato salvato e l'elemento successivo nella sequenza.

Passo 4) Ripeti fino a quando non rimangono più elementi.

Richiede inoltre due parametri:

1. Una funzione che definisce l'operazione da eseguire
2. Una sequenza (qualsiasi iteratore come liste, tuple, ecc.)

Ad esempio, ecco un programma che restituisce il prodotto di tutti gli elementi in una lista:

from functools import reduce
sequences = [1,2,3,4,5]
product = reduce (lambda x, y: x*y, sequences)
print(product)

Ecco l'output:

120

Code Spiegazione:

1. Importare reduce dal modulo functools.

2. Qui definiamo un elenco chiamato sequenze che contiene alcuni numeri.

3. Dichiariamo una variabile chiamata prodotto che memorizzerà il valore ridotto.

4. Una funzione lambda che viene eseguita su ciascun elemento della lista. Restituirà il prodotto di quel numero in base al risultato precedente.

5. Stampa il risultato restituito dalla funzione reduce.

Perché (e perché no) utilizzare le funzioni lambda?

Come vedrai nella sezione successiva, le lambda vengono trattate allo stesso modo delle normali funzioni a livello di interprete. In un certo senso, si potrebbe dire che le lambda forniscono una sintassi compatta per scrivere funzioni che restituiscono una singola espressione.

Tuttavia, dovresti sapere quando è una buona idea usare le lambda e quando evitarle. In questa sezione, imparerai alcuni dei principi di progettazione utilizzati da Python sviluppatori durante la scrittura di lambda.

Uno dei casi d'uso più comuni per le lambda è nella programmazione funzionale, come Python supporta un paradigma (o stile) di programmazione noto come programmazione funzionale.

Consente di passare una funzione come parametro a un'altra funzione (ad esempio, in map, filter, ecc.). In questi casi, l'utilizzo delle lambda offre un modo elegante per creare una funzione da utilizzare una sola volta e passarla come parametro.

Quando non dovresti usare Lambda?

Non dovresti mai scrivere funzioni lambda complicate in un ambiente di produzione. Sarà molto difficile per i programmatori che gestiscono il tuo codice decifrarlo. Se ti ritrovi a creare espressioni complesse one-liner, sarebbe una pratica molto migliore definire una funzione appropriata. Come buona pratica, devi ricordare che il codice semplice è sempre meglio del codice complesso.

Lambda e funzioni regolari

Come affermato in precedenza, le lambda sono semplicemente funzioni a cui non è associato un identificatore. In parole più semplici, sono funzioni senza nome (quindi, anonime). Ecco una tabella per illustrare la differenza tra lambda e funzioni normali in Python.

lambda x : x + x

def (x) :
return x + x 

Spiegazione delle differenze

La differenza principale tra una funzione lambda e una funzione regolare è che la funzione lambda valuta solo una singola espressione e produce un oggetto funzione. Di conseguenza possiamo dare un nome al risultato della funzione lambda e utilizzarlo nel nostro programma come abbiamo fatto nell'esempio precedente.

Una funzione regolare per l'esempio precedente sarebbe simile a questa:

def adder (x, y):
return x + y 
print (adder (1, 2))

Qui dobbiamo definire a Nome per la funzione che problemi il risultato quando noi chiamata Una funzione lambda non contiene un'istruzione return perché avrà solo una singola espressione che viene sempre restituita per impostazione predefinita. Non è nemmeno necessario assegnare un valore a una lambda, poiché può essere invocata immediatamente (vedi la sezione precedente). Come vedrai, le lambda diventano particolarmente potenti quando le usiamo con Pythonle funzioni integrate.

Tuttavia, potresti ancora chiederti in che modo i lambda sono diversi da una funzione che restituisce una singola espressione (come quella sopra). A livello di interprete non c’è molta differenza. Può sembrare sorprendente, ma qualsiasi funzione lambda definita in Python viene trattata come una normale funzione dall'interprete.

A livello di bytecode, le due definizioni vengono gestite allo stesso modo dal Python interprete. Ora, non puoi dare un nome a una funzione lambda perché è riservato da Pythonma qualsiasi altro nome di funzione produrrà lo stesso bytecode.

DOMANDE FREQUENTI