Cos'è la funzione Lambda in Python?
Una funzione Lambda nella programmazione Python è una funzione anonima o una funzione senza nome. È una funzione piccola e limitata che non ha più di una riga. Proprio come una normale funzione, una funzione Lambda può avere più argomenti con un'unica espressione.
In Python, le espressioni lambda (o form lambda) vengono utilizzate per costruire funzioni anonime. Per fare ciò, utilizzerai la parola chiave lambda (proprio come usi def per definire le normali funzioni). Ogni funzione anonima che definisci in Python avrà 3 parti essenziali:
- La parola chiave lambda.
- I parametri (o variabili associate) e
- Il corpo della funzione.
Una funzione lambda può avere un numero qualsiasi di parametri, ma il corpo della funzione può contenere solo un'espressione. Inoltre, un lambda viene scritto in una singola riga di codice e può anche essere richiamato immediatamente. Vedrai tutto questo in azione nei prossimi esempi.
In questo tutorial Lambda in Python imparerai:
- Sintassi ed esempi
- Utilizzo di lambda con built-in Python
- lambda nel filtro ()
- lambda nella mappa ()
- lambda in reduce ()
- Perché (e perché no) utilizzare le funzioni lambda?
- Lambda vs. funzioni regolari
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 tanti o pochi parametri di cui hai bisogno.
Tuttavia, nota che non usiamo parentesi attorno ai parametri come facciamo con le normali funzioni. L'ultima parte (espressione) è qualsiasi espressione python valida che opera sui parametri forniti alla funzione.
Esempio 1
Ora che sai di lambda proviamolo con un esempio. Quindi, apri il tuo IDLE e digita quanto segue:
adder = lambda x, y: x + yprint (adder (1, 2))
Ecco l'output:
3
Spiegazione del codice
Qui, definiamo una variabile che conterrà 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 passati. Notare che è 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 è stato un esempio di base per comprendere i fondamenti e la sintassi di lambda. Proviamo ora a stampare un lambda e vedere il risultato. Di nuovo, apri il tuo IDLE e digita quanto segue:
#What a lambda returnsstring='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:
at 0x00000185C3BF81E0>
Cosa sta succedendo qui? Diamo un'occhiata al codice per capire meglio.
Spiegazione del codice
- Qui definiamo una stringa che passerai come parametro al lambda.
- Dichiariamo un lambda che chiama un'istruzione print e stampa il risultato.
Ma perché il programma non stampa la stringa che passiamo? Questo perché lo stesso lambda restituisce un oggetto funzione. In questo esempio, lambda non viene chiamato dalla funzione print ma restituisce semplicemente l'oggetto funzione e la posizione di memoria in cui è archiviato. Questo è ciò che viene stampato sulla console.
Esempio 3
Tuttavia, se scrivi un programma come questo:
#What a lambda returns #2x="some kind of a useless lambda"(lambda x : print(x))(x)
Ed eseguilo premendo F5, vedrai un output come questo.
Produzione:
some kind of a useless lambda
Ora, il lambda viene chiamato e la stringa che passiamo viene stampata sulla console. Ma qual è questa strana sintassi e perché la definizione lambda è racchiusa tra parentesi? Capiamolo ora.
Spiegazione del codice
- Ecco la stessa stringa che abbiamo definito nell'esempio precedente.
- In questa parte, definiamo un lambda e lo chiamiamo immediatamente passando la stringa come argomento. Questo è qualcosa chiamato IIFE e ne imparerai di più nelle prossime sezioni di questo tutorial.
Esempio 4
Diamo un'occhiata a un esempio finale per capire come vengono eseguiti i lambda e le funzioni regolari. Quindi, apri il tuo IDLE e in un nuovo file, digita quanto segue:
#A REGULAR FUNCTIONdef guru( funct, *args ):funct( *args )def printer_one( arg ):return print (arg)def printer_two( arg ):print(arg)#CALL A REGULAR FUNCTIONguru( printer_one, 'printer 1 REGULAR CALL' )guru( printer_two, 'printer 2 REGULAR CALL \n' )#CALL A REGULAR FUNCTION THRU A LAMBDAguru(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 qualcosa del genere.
Produzione:
stampante 1 CHIAMATA REGOLARE
stampante 2 CHIAMATA REGOLARE
stampante 1 LAMBDA CALL
stampante 2 LAMBDA CALL
Spiegazione del codice
- Una funzione chiamata guru che accetta un'altra funzione come primo parametro e qualsiasi altro argomento che la segue.
- printer_one è una semplice funzione che stampa il parametro passato e lo restituisce.
- printer_two è simile a printer_one ma senza l'istruzione return.
- In questa parte, chiamiamo la funzione guru e passiamo le funzioni della stampante e una stringa come parametri.
- Questa è la sintassi per raggiungere il quarto passaggio (cioè chiamare la funzione guru) ma usando lambda.
Nella sezione successiva, imparerai come usare le funzioni lambda con map (), reduce () e filter () in Python.
Utilizzo di lambda con built-in Python
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 in Python Lambda
IIFE sta per esecuzione di funzioni invocate immediatamente. Significa che una funzione lambda è richiamabile non appena viene definita. Comprendiamolo 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à di invocare immediatamente lambda ti consente di usarli all'interno di funzioni come map () e reduce (). È utile perché potresti non voler utilizzare nuovamente queste funzioni.
lambda nel filtro ()
La funzione di 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 elenchi, 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]
Spiegazione del codice:
1. Nella prima affermazione, 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 ogni elemento della lista e restituisce true se è maggiore di 4.
4. Stampare il risultato restituito dalla funzione di filtro.
lambda nella mappa ()
la funzione map viene utilizzata per applicare una particolare operazione a ogni elemento in una sequenza. Come filter (), accetta anche 2 parametri:
- Una funzione che definisce l'operazione da eseguire sugli elementi
- Una o più sequenze
Ad esempio, ecco un programma che stampa i quadrati dei numeri in una data lista:
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, 121, 0, 1]
[KR1]
Spiegazione del codice:
- Qui, definiamo un elenco chiamato sequenze che contiene alcuni numeri.
- Dichiariamo una variabile chiamata filtered_result che memorizzerà i valori mappati
- Una funzione lambda che viene eseguita su ogni elemento della lista e restituisce il quadrato di quel numero.
- Stampa il risultato restituito dalla funzione map.
lambda in reduce ()
La funzione reduce, come map (), è usata 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:
Passaggio 1) Eseguire l'operazione definita sui primi 2 elementi della sequenza.
Passaggio 2) Salva questo risultato
Passaggio 3) Eseguire l'operazione con il risultato salvato e l'elemento successivo nella sequenza.
Passaggio 4) Ripetere fino a quando non sono rimasti più elementi.
Accetta anche due parametri:
- Una funzione che definisce l'operazione da eseguire
- Una sequenza (qualsiasi iteratore come elenchi, tuple, ecc.)
Ad esempio, ecco un programma che restituisce il prodotto di tutti gli elementi in un elenco:
from functools import reducesequences = [1,2,3,4,5]product = reduce (lambda x, y: x*y, sequences)print(product)
Ecco l'output:
120
Spiegazione del codice:
- Import reduce dal modulo functools
- Qui, definiamo un elenco chiamato sequenze che contiene alcuni numeri.
- Dichiariamo una variabile chiamata prodotto che memorizzerà il valore ridotto
- Una funzione lambda che viene eseguita su ogni elemento dell'elenco. Restituirà il prodotto di quel numero come per il risultato precedente.
- Stampa il risultato restituito dalla funzione di riduzione.
Perché (e perché no) utilizzare le funzioni lambda?
Come vedrai nella prossima sezione, i lambda vengono trattati allo stesso modo delle normali funzioni a livello di interprete. In un certo senso, si potrebbe dire che i lambda forniscono una sintassi compatta per la scrittura di funzioni che restituiscono una singola espressione.
Tuttavia, dovresti sapere quando è una buona idea usare i lambda e quando evitarli. In questa sezione imparerai alcuni dei principi di progettazione utilizzati dagli sviluppatori Python durante la scrittura di lambda.
Uno dei casi d'uso più comuni per lambda è nella programmazione funzionale poiché Python supporta un paradigma (o stile) di programmazione noto come programmazione funzionale.
Consente di fornire una funzione come parametro a un'altra funzione (ad esempio, in mappa, filtro, ecc.). In questi casi, l'utilizzo di lambda offre un modo elegante per creare una funzione occasionale e passarla come parametro.
Quando non dovresti usare Lambda?
Non dovresti mai scrivere complicate funzioni lambda in un ambiente di produzione. Sarà molto difficile per i programmatori che mantengono il codice decrittografarlo. Se ti ritrovi a fare complesse espressioni di una riga, sarebbe una pratica molto superiore definire una funzione appropriata. Come best practice, è necessario ricordare che il codice semplice è sempre meglio del codice complesso.
Lambda vs. funzioni regolari
Come affermato in precedenza, le lambda sono [vV4] [J5] solo 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 regolari in python.
Lambdas
Funzioni regolari
Sintassi:
lambda x : x + x
Sintassi:
def (x) :return x + x
Le funzioni Lambda possono avere solo un'espressione nel loro corpo.
Le funzioni regolari possono avere più espressioni e istruzioni nel loro corpo.
Lambda non ha un nome associato a loro. Ecco perché sono anche conosciute come funzioni anonime.
Le funzioni regolari devono avere un nome e una firma.
Lambda non contengono un'istruzione return perché il corpo viene restituito automaticamente.
Le funzioni che devono restituire un valore dovrebbero includere un'istruzione return.
Spiegazione delle differenze?
La differenza principale tra una funzione lambda e una funzione regolare è che la funzione lambda valuta solo una singola espressione e restituisce un oggetto funzione. Di conseguenza, possiamo nominare il risultato della funzione lambda e usarlo 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 + yprint (adder (1, 2))
Qui dobbiamo definire un nome per la funzione che restituisce il risultato quando la chiamiamo . 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 lambda poiché può essere richiamato immediatamente (vedere la sezione successiva). Come vedrai nell'esempio seguente, i lambda diventano particolarmente potenti quando li usiamo con le funzioni integrate di Python.
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 che definisci in Python viene trattata come una normale funzione dall'interprete.
Come puoi vedere nel diagramma, le due definizioni vengono gestite allo stesso modo dall'interprete python quando convertite in bytecode. Ora, non puoi nominare una funzione lambda perché è riservata da Python, ma qualsiasi altro nome di funzione produrrà lo stesso bytecode [KR6].
Sommario
- Lambda, note anche come funzioni anonime, sono funzioni piccole e limitate che non richiedono un nome (cioè un identificatore).
- Ogni funzione lambda in Python ha 3 parti essenziali:
- La parola chiave lambda.
- I parametri (o variabili associate) e
- Il corpo della funzione.
- La sintassi per scrivere un lambda è: parametro lambda: espressione
- Lambda può avere un numero qualsiasi di parametri, ma non sono racchiusi tra parentesi graffe
- Un lambda può avere solo un'espressione nel corpo della funzione, che viene restituita per impostazione predefinita.
- A livello di bytecode, non c'è molta differenza tra il modo in cui i lambda e le funzioni regolari vengono gestite dall'interprete.
- Lambda supporta IIFE attraverso questa sintassi: (parametro lambda: espressione) (argomento)
- I lambda sono comunemente usati con i seguenti built-in Python:
- Filtro: filtro (parametro lambda: espressione, sequenza-iterabile)
- Mappa: mappa (parametro lambda: espressione, sequenze iterabili)
- Riduci: riduci (parametro lambda1, parametro2: espressione, sequenza-iterabile)
- Non scrivere complicate funzioni lambda in un ambiente di produzione perché sarà difficile per i manutentori del codice.
[J5] Ho aggiunto una tabella, ma la spiegazione è necessaria per capire le differenze.