Ce este funcția Lambda în Python?
O funcție Lambda în programarea Python este o funcție anonimă sau o funcție fără nume. Este o funcție mică și restricționată 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.
În Python, expresiile lambda (sau formele lambda) sunt utilizate pentru a construi funcții anonime. Pentru a face acest lucru, veți utiliza cuvântul cheie lambda (la fel cum utilizați def pentru a defini funcțiile normale). Fiecare funcție anonimă pe care o definiți în Python va avea 3 părți esențiale:
- Cuvântul cheie lambda.
- Parametrii (sau variabilele legate) și
- Corpul funcției.
O funcție lambda poate avea orice număr de parametri, dar corpul funcției poate conține o singură expresie. Mai mult, o 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 viitoare.
În acest tutorial Lambda în Python, veți afla:
- Sintaxă și exemple
- Utilizarea lambdas cu Python încorporate
- lambdas în filtru ()
- lambdas în hartă ()
- lambdas în reduce ()
- De ce (și de ce nu) folosim funcțiile lambda?
- Lambdas vs. Funcții regulate
Sintaxă și exemple
Sintaxa formală pentru a scrie o funcție lambda este cea prezentată mai jos:
lambda p1, p2: expression
Aici, p1 și p2 sunt parametrii care sunt trecuți la funcția lambda. Puteți adăuga oricâți sau puțini 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 oferiți funcției.
Exemplul 1
Acum, că știți despre lambdas, să încercăm cu un exemplu. Deci, deschideți IDLE și tastați următoarele:
adder = lambda x, y: x + yprint (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 folosit pentru a defini o funcție anonimă.
2. x și y sunt parametrii pe care îi trecem funcției lambda.
3. Acesta este corpul funcției, care adaugă cei 2 parametri pe care i-am trecut. Observați că este o singură expresie. Nu puteți scrie mai multe afirmații în corpul unei funcții lambda.
4. Apelăm la funcție și imprimăm valoarea returnată.
Exemplul 2
Acesta a fost un exemplu de bază pentru a înțelege fundamentele și sintaxa lambda. Să încercăm acum să imprimăm o lambda și să vedem rezultatul. Din nou, deschideți IDLE și tastați următoarele:
#What a lambda returnsstring='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. Acesta este rezultatul pe care ar trebui să-l obțineți.
Ieșire:
at 0x00000185C3BF81E0>
Ce se intampla aici? Să ne uităm la cod pentru a înțelege mai departe.
Explicarea codului
- Aici, definim un șir pe care îl veți transmite ca parametru lambda.
- Declarăm o lambda care apelează o declarație de tipărire și imprimă rezultatul.
Dar de ce programul nu tipărește șirul pe care îl trecem? Acest lucru se datorează faptului că lambda în sine returnează un obiect funcțional. În acest exemplu, lambda nu este apelată de funcția de imprimare, ci pur și simplu returnează obiectul funcției și locația de memorie în care este stocată. Asta se imprimă la consolă.
Exemplul 3
Cu toate acestea, dacă scrieți un program ca acesta:
#What a lambda returns #2x="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 imprimat la consolă. Dar ce este acea sintaxă ciudată și de ce este definiția lambda acoperită între paranteze? Să înțelegem asta acum.
Explicarea codului
- Iată același șir pe care l-am definit în exemplul anterior.
- În această parte, definim o lambda și o chemăm imediat trecând șirul ca argument. Acesta este ceva numit IIFE și veți afla mai multe despre acesta în următoarele secțiuni ale acestui tutorial.
Exemplul 4
Să vedem un ultim exemplu pentru a înțelege cum sunt executate lambdas și funcțiile obișnuite. Deci, deschideți IDLE și într-un fișier nou, introduceți următoarele:
#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'))
Acum, salvați fișierul și apăsați F5 pentru a rula programul. Dacă nu ați făcut greșeli, rezultatul ar trebui să fie de genul acesta.
Ieșire:
imprimanta 1 APEL REGULAR
imprimanta 2 APEL REGULAR
imprimantă 1 LAMBDA CALL
imprimanta 2 LAMBDA CALL
Explicarea codului
- O funcție numită guru care ia o altă funcție ca prim parametru și orice alte argumente care îl urmează.
- printer_one este o funcție simplă care imprimă parametrul transmis către acesta și îl returnează.
- printer_two este similar cu printer_one dar fără declarația return.
- În această parte, apelăm funcția guru și trecem funcțiile imprimantei și un șir ca parametri.
- 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 map (), reduce () și filter () în Python.
Utilizarea lambdas cu Python încorporate
Funcțiile Lambda oferă un mod elegant și puternic de a efectua operațiuni folosind metode încorporate în Python. Este posibil, deoarece lambdas poate fi invocat imediat și transmis ca argument la aceste funcții.
IIFE în Python Lambda
IIFE reprezintă executarea funcției invocate imediat. Înseamnă că o funcție lambda poate fi apelată imediat ce este definită. Să înțelegem acest lucru cu un exemplu; aprindeți IDLE și introduceți următoarele:
(lambda x: x + x)(2)
Iată explicația de ieșire și cod:
Această abilitate a lambdas de a fi invocată imediat vă permite să le utilizați în 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 unele elemente particulare dintr-o succesiune 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]
Explicatie cod:
1. În prima afirmaț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 de hartă este utilizată pentru a aplica o anumită operație fiecărui element dintr-o secvență. La fel ca filter (), ia și 2 parametri:
- O funcție care definește opțiunea de efectuat asupra elementelor
- 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, 121, 0, 1]
[KR1]
Explicatie cod:
- Aici, definim o listă numită secvențe care conține unele numere.
- Declarăm o variabilă numită filtered_result care va stoca valorile mapate
- O funcție lambda care rulează pe fiecare element al listei și returnează pătratul acelui număr.
- Imprimați rezultatul returnat de funcția hartă.
lambdas în reduce ()
Funcția de reducere, cum ar fi map (), este utilizată pentru a aplica o operație fiecărui element dintr-o secvență. Cu toate acestea, diferă de hartă prin funcționarea sa. Aceștia sunt pașii urmați de funcția reduce () pentru a calcula o ieșire:
Pasul 1) Efectuați operația definită pe primele 2 elemente ale secvenței.
Pasul 2) Salvați acest rezultat
Pasul 3) Efectuați operația cu rezultatul salvat și cu următorul element din secvență.
Pasul 4) Repetați până nu mai rămân elemente.
De asemenea, este nevoie de doi parametri:
- O funcție care definește operațiunea care trebuie efectuată
- 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 reducesequences = [1,2,3,4,5]product = reduce (lambda x, y: x*y, sequences)print(product)
Iată rezultatul:
120
Explicatie cod:
- Import reduce din modulul functools
- Aici, definim o listă numită secvențe care conține unele numere.
- Declarăm o variabilă numită produs care va stoca valoarea redusă
- O funcție lambda care rulează pe fiecare element al listei. Se va returna produsul cu numărul respectiv conform rezultatului anterior.
- Imprimați rezultatul returnat de funcția de reducere.
De ce (și de ce nu) folosim funcțiile lambda?
După cum veți vedea în secțiunea următoare, lambda sunt tratate la fel ca funcțiile obișnuite la nivel de interpret. Într-un fel, ați putea spune că lambdas oferă sintaxă compactă pentru funcțiile de scriere care returnează o singură expresie.
Cu toate acestea, ar trebui să știți când este o idee bună să utilizați lambdas și când să le evitați. În această secțiune, veți afla câteva dintre principiile de proiectare utilizate de dezvoltatorii de python atunci când scriu lambdas.
Unul dintre cele mai frecvente cazuri de utilizare pentru lambdas 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 pentru o altă funcție (de exemplu, în hartă, filtru etc.). În astfel de cazuri, utilizarea lambdas oferă un mod elegant de a crea o funcție unică și de a o transmite ca parametru.
Când nu trebuie 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 codificatorii care vă întrețin codul să îl decripteze. Dacă vă veți face expresii complexe cu o singură linie, ar fi o practică mult superioară să definiți o funcție adecvată. Ca o bună practică, trebuie să vă amintiți că codul simplu este întotdeauna mai bun decât codul complex.
Lambdas vs. Funcții regulate
După cum sa menționat anterior, lambdas sunt [vV4] [J5] doar funcții care nu au un identificator legat de ele. În cuvinte mai simple, acestea sunt funcții fără nume (deci, anonime). Iată un tabel pentru a ilustra diferența dintre funcțiile lambdas și funcțiile obișnuite din python.
Lambdas
Funcții regulate
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 expresii și afirmații multiple în corpul lor.
Lambdas nu are un nume asociat. De aceea sunt cunoscute și sub numele de funcții anonime.
Funcțiile obișnuite trebuie să aibă un nume și o semnătură.
Lambdas nu conține o declarație de returnare, deoarece corpul este returnat automat.
Funcțiile care trebuie să returneze valoarea ar trebui să includă o declarație de returnare.
Explicație a diferențelor?
Diferența principală între o funcție lambda și o funcție regulată este că funcția lambda evaluează doar o singură expresie și produce un obiect funcțional. În consecință, putem denumi 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 + yprint (adder (1, 2))
Aici, trebuie să definim un nume pentru funcția care returnează rezultatul atunci când îl numim . O funcție lambda nu conține o instrucțiune return, deoarece va avea doar o singură expresie care este întotdeauna returnată în mod implicit. Nici măcar nu trebuie să atribuiți o lambda, deoarece poate fi imediat invocată (consultați secțiunea următoare). După cum veți vedea în exemplul următor, lambdas devin deosebit de puternici atunci când le folosim cu funcțiile încorporate ale Python.
Cu toate acestea, s-ar putea să vă întrebați în continuare cum diferă lambdas de o funcție care returnează o singură expresie (ca cea de mai sus). La nivel de interpret, nu există prea multe diferențe. Poate suna surprinzător, dar orice funcție lambda pe care o definiți în 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
- Lambdas, cunoscute și sub numele de funcții anonime, sunt funcții mici, restricționate, care nu au nevoie de un nume (adică un identificator).
- Fiecare funcție lambda din Python are 3 părți esențiale:
- Cuvântul cheie lambda.
- Parametrii (sau variabilele legate) și
- Corpul funcției.
- Sintaxa pentru scrierea unui lambda este: lambda parametru: expresie
- Lambdas poate avea orice număr de parametri, dar nu sunt cuprinși între paranteze
- O lambda poate avea doar 1 expresie în corpul funcției sale, care este returnată în mod implicit.
- La nivel de bytecode, nu există prea multe diferențe între modul în care lambdas și funcțiile obișnuite sunt tratate de către interpret.
- Lambdas acceptă IIFE prin această sintaxă: (parametru lambda: expresie) (argument)
- Lambdas sunt utilizate în mod obișnuit cu următoarele python încorporate:
- Filtru: filtru (parametru lambda: expresie, secvență iterabilă)
- Hartă: hartă (parametru lambda: expresie, secvențe iterabile)
- Reduce: reduce (parametru lambda1, parametru2: expresie, secvență iterabilă)
- Nu scrieți funcții lambda complicate într-un mediu de producție, deoarece va fi dificil pentru întreținătorii de cod.
[J5] Am adăugat un tabel, dar explicația este necesară pentru a înțelege diferențele.