Python Funcții Lambda cu EXEMPLE

În ce este funcția Lambda Python?

A Funcția Lambda în Python programarea este o funcție anonimă sau o funcție fără nume. Este o funcție mică și restrânsă care nu are mai mult de o linie. La fel ca o funcție normală, o funcție Lambda poate avea mai multe argumente cu o singură expresie.

In Python, expresiile lambda (sau formele lambda) sunt utilizate pentru a construi funcții anonime. Pentru a face acest lucru, veți folosi lambda cuvânt cheie (la fel cum utilizați Def pentru a defini funcţiile normale). Fiecare funcție anonimă în care definiți Python va avea 3 părți esențiale:

• Cuvântul cheie lambda.
• Parametrii (sau variabilele legate) și
• Corpul funcțional.

O funcție lambda poate avea orice număr de parametri, dar corpul funcției poate conține doar unu expresie. Mai mult, un lambda este scris într-o singură linie de cod și poate fi, de asemenea, invocat imediat. Veți vedea toate acestea în acțiune în exemplele următoare.

Sintaxă și exemple

Sintaxa formală pentru a scrie o funcție lambda este următoarea:

lambda p1, p2: expression

Aici, p1 și p2 sunt parametrii care sunt trecuți funcției lambda. Puteți adăuga oricât de mulți sau câțiva parametri aveți nevoie.

Totuși, observați că nu folosim paranteze în jurul parametrilor, așa cum facem în cazul funcțiilor obișnuite. Ultima parte (expresia) este orice expresie validă Python expresie care operează asupra parametrilor pe care îi furnizați funcției.

Exemplu 1

Acum că știți despre lambda, să încercăm cu un exemplu. Deci, deschide-ți IDLE și introduceți următoarele:

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

Code Explicație

Aici definim o variabilă care va reține rezultatul returnat de funcția lambda.

1. Cuvântul cheie lambda utilizat pentru a defini o funcție anonimă.

2. x și y sunt parametrii pe care îi transmitem funcției lambda.

3. Acesta este corpul funcției, care adaugă cei 2 parametri pe care i-am transmis. Observați că este o singură expresie. Nu puteți scrie mai multe instrucțiuni în corpul unei funcții lambda.

4. Apelăm funcția și imprimăm valoarea returnată.

Exemplu 2

Acesta a fost un exemplu de bază pentru a înțelege elementele fundamentale și sintaxa lambda. Să încercăm acum să imprimăm o listă lambda și să vedem rezultatul. Din nou, deschideți IDLE și introduceți următoarele:

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

Acum salvați fișierul și apăsați F5 pentru a rula programul. Aceasta este rezultatul pe care ar trebui să-l obțineți.

ieșire:

<function <lambda> at 0x00000185C3BF81E0>

Ce se întâmplă aici? Să analizăm codul pentru a înțelege mai bine.

Code Explicaţie:

1. Aici, definim un şir pe care îl veți transmite ca parametru către lambda.

2. Declarăm o funcție lambda care apelează o instrucțiune print și afișează rezultatul.

Dar de ce programul nu afișează șirul de caractere pe care îl transmitem? Acest lucru se datorează faptului că lambda în sine returnează un obiect funcție. În acest exemplu, lambda nu este afișată. denumit de funcția de imprimare, ci pur și simplu revenind obiectul funcției și locația de memorie unde este stocat. Aceasta este ceea ce este afișat la consolă.

Exemplu 3

Cu toate acestea, dacă scrieți un program ca acesta:

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

Și rulați-l apăsând F5, veți vedea o ieșire de genul acesta.

ieșire:

some kind of a useless lambda

Acum, lambda este apelată, iar șirul pe care îl transmitem este afișat în consolă. Dar care este această sintaxă ciudată și de ce este definiția lambda între paranteze? Să înțelegem asta acum.

Code Explicaţie:

1. Iată același șir de caractere pe care l-am definit în exemplul anterior.

2. În această parte, definim o funcție lambda și o apelăm imediat prin transmiterea șirului de caractere ca argument. Aceasta se numește IIFE și veți afla mai multe despre ea în secțiunile următoare ale acestui tutorial.

Exemplu 4

Să ne uităm la un ultim exemplu pentru a înțelege cum sunt executate funcțiile lambda și cele obișnuite. Așadar, deschideți IDLE și într-un fișier nou, tastați următoarele:

#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'))

Acum, salvați fișierul și apăsați F5 pentru a rula programul. Dacă nu ați făcut nicio greșeală, rezultatul ar trebui să fie ceva de genul acesta.

ieșire:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code Explicaţie:

1. O funcție numită guru care primește o altă funcție ca prim parametru și orice alte argumente care o urmează.

2. printer_one este o funcție simplă care afișează parametrul transmis și îl returnează.

3. printer_two este similar cu printer_one, dar fără instrucțiunea return.

4. În această parte, apelăm funcția guru și transmitem funcțiile de imprimantă și un șir de caractere ca parametri.

5. Aceasta este sintaxa pentru a realiza al patrulea pas (adică apelarea funcției guru), dar folosind lambda.

În secțiunea următoare, veți învăța cum să utilizați funcțiile lambda cu Hartă(), reduce() și filtru() in Python.

Folosind lambda cu Python încorporate

Funcțiile Lambda oferă o modalitate elegantă și puternică de a efectua operațiuni folosind metode încorporate în Python. Este posibil deoarece lambda poate fi invocat imediat și transmis ca argument acestor funcții.

IIFE în Python Lambda

IIFE standuri pentru execuția funcției invocată imediat. Înseamnă că o funcție lambda poate fi apelată imediat ce este definită. Să înțelegem acest lucru cu un exemplu: porniți funcția IDLE și introduceți următoarele:

 (lambda x: x + x)(2)

Iată rezultatul și explicația codului:

Această capacitate a lambdas de a fi invocată imediat vă permite să le utilizați în cadrul unor funcții precum map() și reduce(). Este util deoarece este posibil să nu doriți să utilizați din nou aceste funcții.

lambdas în filtru ()

Funcția de filtrare este utilizată pentru a selecta anumite elemente dintr-o secvență de elemente. Secvența poate fi orice iterator, cum ar fi liste, seturi, tupluri etc.

Elementele care vor fi selectate se bazează pe o constrângere predefinită. Aceasta necesită 2 parametri:

• O funcție care definește constrângerea de filtrare
• O secvență (orice iterator cum ar fi liste, tupluri etc.)

De exemplu,

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

Iată rezultatul:

[10, 8, 7, 5, 11]

Code Explicaţie:

1. În prima declarație, definim o listă numită secvențe care conține unele numere.

2. Aici, declarăm o variabilă numită filtered_result, care va stoca valorile filtrate returnate de funcția filter().

3. O funcție lambda care rulează pe fiecare element al listei și returnează adevărat dacă este mai mare de 4.

4. Imprimați rezultatul returnat de funcția de filtrare.

lambdas în hartă()

Funcția map este utilizată pentru a aplica o anumită operație fiecărui element dintr-o secvență. La fel ca filter(), și ea primește 2 parametri:

1. O funcție care definește operația care trebuie efectuată asupra elementelor
2. Una sau mai multe secvențe

De exemplu, iată un program care tipărește pătratele numerelor dintr-o listă dată:

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

ieșire:

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

Code Explicaţie:

1. Aici, definim o listă numită secvențe care conține niște numere.

2. Declarăm o variabilă numită filtered_result care va stoca valorile mapate.

3. O funcție lambda care rulează pe fiecare element al listei și returnează pătratul numărului respectiv.

4. Afișați rezultatul returnat de funcția map.

lambdas în reduce()

Funcția reduce, ca map(), este folosită pentru a aplica o operație fiecărui element dintr-o secvență. Cu toate acestea, diferă de hartă în funcționarea sa. Aceștia sunt pașii urmați de funcția reduce() pentru a calcula o ieșire:

Pas 1) Efectuați operația definită pe primele 2 elemente ale secvenței.

Pas 2) Salvați acest rezultat.

Pas 3) Efectuați operația cu rezultatul salvat și următorul element din secvență.

Pas 4) Repetați până când nu mai rămân elemente.

De asemenea, ia doi parametri:

1. O funcție care definește operația de efectuat
2. O secvență (orice iterator cum ar fi liste, tupluri etc.)

De exemplu, iată un program care returnează produsul tuturor elementelor dintr-o listă:

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

Iată rezultatul:

120

Code Explicaţie:

1. Importați reduce din modulul functools.

2. Aici, definim o listă numită secvențe care conține niște numere.

3. Declarăm o variabilă numită product care va stoca valoarea redusă.

4. O funcție lambda care rulează pe fiecare element al listei. Va returna produsul acelui număr conform rezultatului anterior.

5. Afișați rezultatul returnat de funcția reduce.

De ce (și de ce nu) folosiți funcțiile lambda?

După cum veți vedea în secțiunea următoare, lambda sunt tratate la fel ca și funcțiile obișnuite la nivel de interpret. Într-un fel, ați putea spune că lambda oferă o sintaxă compactă pentru scrierea funcțiilor care returnează o singură expresie.

Cu toate acestea, ar trebui să știți când este o idee bună să utilizați lambda și când să le evitați. În această secțiune, veți afla câteva dintre principiile de proiectare utilizate de Python dezvoltatorii când scriu lambda.

Unul dintre cele mai comune cazuri de utilizare pentru lambda este în programarea funcțională, deoarece Python acceptă o paradigmă (sau stil) de programare cunoscută sub numele de programare funcțională.

Vă permite să furnizați o funcție ca parametru unei alte funcții (de exemplu, într-o hartă, un filtru etc.). În astfel de cazuri, utilizarea lambdelor oferă o modalitate elegantă de a crea o funcție unică și de a o transmite ca parametru.

Când nu ar trebui să utilizați Lambda?

Nu ar trebui să scrieți niciodată funcții lambda complicate într-un mediu de producție. Va fi foarte dificil pentru programatorii care vă întrețin codul să-l decripteze. Dacă vă treziți să faceți expresii complexe de o singură linie, ar fi o practică mult superioară să definiți o funcție adecvată. Ca cea mai bună practică, trebuie să rețineți că codul simplu este întotdeauna mai bun decât codul complex.

Lambda vs. Funcții obișnuite

Așa cum am menționat anterior, funcțiile lambda sunt doar funcții care nu au un identificator legat de ele. Mai simplu spus, acestea sunt funcții fără nume (deci, anonime). Iată un tabel care ilustrează diferența dintre funcțiile lambda și funcțiile obișnuite în Python.

lambda x : x + x

def (x) :
return x + x 

Explicația diferențelor

Diferența principală dintre o funcție lambda și o funcție obișnuită este că funcția lambda evaluează doar o singură expresie și generează un obiect funcție. În consecință, putem numi rezultatul funcției lambda și îl putem folosi în programul nostru așa cum am făcut în exemplul anterior.

O funcție obișnuită pentru exemplul de mai sus ar arăta astfel:

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

Aici, trebuie să definim a nume pentru funcţia care Returnează rezultatul când noi apel O funcție lambda nu conține o instrucțiune de returnare deoarece va avea o singură expresie care este întotdeauna returnată în mod implicit. Nici măcar nu trebuie să atribuiți o funcție lambda, deoarece aceasta poate fi invocată imediat (vezi secțiunea anterioară). După cum veți vedea, funcțiile lambda devin deosebit de puternice atunci când le folosim cu Pythonfuncțiile încorporate ale lui.

Cu toate acestea, s-ar putea să vă întrebați în ce fel lambdas sunt diferite de o funcție care returnează o singură expresie (cum ar fi cea de mai sus). La nivel de interpret, nu este mare diferență. Poate suna surprinzător, dar orice funcție lambda pe care o definiți Python este tratată ca o funcție normală de către interpret.

La nivel de bytecode, cele două definiții sunt gestionate în același mod de către Python interpretor. Acum, nu poți denumi o funcție lambda deoarece este rezervat de Python, dar orice alt nume de funcție va genera același bytecode.

Întrebări frecvente