Python Funcții Lambda cu EXEMPLE

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.

Cu toate acestea, observați că nu folosim paranteze în jurul parametrilor, așa cum facem cu funcțiile obișnuite. Ultima parte (expresie) este orice expresie python validă care operează pe parametrii 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))

Iată rezultatul:

3

Explicarea codului

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ă tipărim o 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 intampla aici? Să ne uităm la cod pentru a înțelege mai departe.

Explicarea codului

1. Aici definim a şir pe care îl vei transmite ca parametru lambda.
2. Declarăm un lambda care apelează o instrucțiune print și tipărește rezultatul.

Dar de ce programul nu tipărește șirul pe care îl transmitem? Acest lucru se datorează faptului că lambda în sine returnează un obiect funcție. În acest exemplu, lambda nu este denumit prin funcția de imprimare ci pur și simplu revenind obiectul funcției și locația de memorie în care este stocat. Asta se imprimă 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 ca aceasta.

ieșire:

some kind of a useless lambda

Acum, lambda este apelată, iar șirul pe care îl trecem este tipărit la consolă. Dar care este acea sintaxă ciudată și de ce definiția lambda este acoperită între paranteze? Să înțelegem asta acum.

Explicarea codului

1. Iată același șir pe care l-am definit în exemplul anterior.
2. În această parte, definim un lambda și îl apelăm imediat prin trecerea șirului ca argument. Acesta este ceva numit IIFE și veți afla mai multe despre el în secțiunile următoare ale acestui tutorial.

Exemplu 4

Să ne uităm la un exemplu final pentru a înțelege cum sunt executate lambda și funcțiile obișnuite. Deci, 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 cam așa.

ieșire:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Explicarea codului

1. O funcție numită guru care ia o altă funcție ca prim parametru și orice alte argumente care o urmează.
2. printer_one este o funcție simplă care tipărește parametrul transmis și îl returnează.
3. printer_two este similar cu printer_one, dar fără instrucțiunea return.
4. În această parte, numim funcția guru și transmitem funcțiile imprimantei și un șir ca parametri.
5. Aceasta este sintaxa pentru a realiza al patrulea pas (adică, apelarea funcției guru), dar folosind lambdas.

Î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 este apelabilă imediat ce este definită. Să înțelegem asta cu un exemplu; aprinde-ți 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ă. Este nevoie de 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]

Explicația codului:

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 folosită pentru a aplica o anumită operație fiecărui element dintr-o secvență. La fel ca filter(), este nevoie de 2 parametri:

1. O funcție care definește operațiunea de 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]

[KR1]

Explicația codului:

1. Aici definim o listă numită secvențe care conține câteva 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 acelui număr.
4. Tipăriț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

Explicația codului:

1. Import reduce din modulul functools
2. Aici definim o listă numită secvențe care conține câteva numere.
3. Declarăm o variabilă numită produs 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. Imprimaț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 dezvoltatorii Python atunci când scrieți lambda.

Unul dintre cele mai comune cazuri de utilizare pentru lambda este în programarea funcțională ca 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, în hartă, filtru etc.). În astfel de cazuri, utilizarea lambda 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

După cum sa menționat anterior, lambda sunt [vV4][J5] doar funcții care nu au un identificator legat de ele. Cu cuvinte mai simple, sunt funcții fără nume (deci, anonime). Iată un tabel pentru a ilustra diferența dintre lambda și funcțiile obișnuite în python.

Lambda

Funcții obișnuite

Sintaxă:

lambda x : x + x

Sintaxă:

def (x) :
return x + x 

Funcțiile lambda pot avea o singură expresie în corpul lor.

Funcțiile obișnuite pot avea mai multe expresii și enunțuri în corpul lor.

Lambda nu au un nume asociat cu ele. De aceea sunt cunoscute și ca funcții anonime.

Funcțiile obișnuite trebuie să aibă un nume și o semnătură.

Lambda nu conțin o instrucțiune return, deoarece corpul este returnat automat.

Funcțiile care trebuie să returneze valoare ar trebui să includă o instrucțiune return.

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 ea. O funcție lambda nu conține o instrucțiune return, deoarece va avea doar o singură expresie care este întotdeauna returnată implicit. Nici măcar nu trebuie să atribuiți o lambda, deoarece poate fi invocată imediat (vezi secțiunea următoare). După cum veți vedea în exemplul următor, lambda devin deosebit de puternice atunci când le folosim împreună 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.

După cum puteți vedea în diagramă, cele două definiții sunt tratate în același mod de către interpretul Python atunci când sunt convertite în bytecode. Acum, nu puteți denumi o funcție lambda deoarece este rezervat de Python, dar orice alt nume de funcție va produce același bytecode[KR6].

Rezumat

• Lambda, cunoscute și ca funcții anonime, sunt funcții mici, restricționate, care nu au nevoie de un nume (adică, un identificator).
• Fiecare funcție lambda în Python are 3 părți esențiale:
• Cuvântul cheie lambda.
• Parametrii (sau variabilele legate) și
• Corpul funcțional.
• Sintaxa pentru scrierea unui lambda este: parametru lambda: expresie
• Lambda poate avea orice număr de parametri, dar nu sunt încadrați între acolade
• Un lambda poate avea doar o expresie în corpul său de funcție, care este returnată implicit.
• La nivel de bytecode, nu există o mare diferență între modul în care lambda și funcțiile obișnuite sunt gestionate de interpret.
• Lambda suportă IIFE prin această sintaxă: (parametru lambda: expresie) (argument)
• Lambda sunt utilizate în mod obișnuit cu următoarele prelucrări Python:
• Filtru: filtru (parametru lambda: expresie, secvență iterabilă)
• Hartă: hartă (parametru lambda: expresie, secvențe iterabile)
• Reduce: reduce (lambda parameter1, parameter2: expression, iterable-secvență)
• Nu scrieți funcții lambda complicate într-un mediu de producție, deoarece va fi dificil pentru menținătorii de cod.

[J5]Am adăugat un tabel, dar explicația este necesară pentru a înțelege diferențele.

Acest cod este editabil. Faceți clic pe Run to Execute