Python Lambda funkciók példákkal

In Python, a lambda-kifejezések (vagy lambda-formák) névtelen függvények létrehozására szolgálnak. Ehhez használja a lambda kulcsszó (ahogyan használod def normál függvények meghatározásához). Minden névtelen függvény, amelyben definiálsz Python 3 alapvető része lesz:

• A lambda kulcsszó.
• A paraméterek (vagy kötött változók), és
• A funkciótest.

Egy lambda függvénynek tetszőleges számú paramétere lehet, de a függvénytörzs csak tartalmazhat egy kifejezés. Ezenkívül a lambda egyetlen kódsorba van írva, és azonnal meghívható. Mindezt működés közben láthatja a következő példákban.

Szintaxis és példák

A lambda függvény írásának formális szintaxisa a következő:

lambda p1, p2: expression

Itt p1 és p2 a lambda függvénynek átadott paraméterek. Annyi vagy kevés paramétert adhat hozzá, amennyire szüksége van.

Figyeljük meg azonban, hogy nem használunk zárójeleket a paraméterek körül, mint a normál függvényeknél. Az utolsó rész (kifejezés) bármely érvényes python kifejezés, amely a függvénynek megadott paraméterekkel működik.

Példa 1

Most, hogy ismeri a lambdákat, próbáljuk meg egy példával. Szóval nyisd ki a te IDLE és írja be a következőket:

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

Itt van a kimenet:

3

Kód Magyarázat

Itt definiálunk egy változót, amely tartalmazza a lambda függvény által visszaadott eredményt.

1. A lambda kulcsszó egy névtelen függvény meghatározására szolgál.

2. x és y azok a paraméterek, amelyeket átadunk a lambda függvénynek.

3. Ez a függvény törzse, amely hozzáadja az általunk átadott 2 paramétert. Figyeljük meg, hogy ez egyetlen kifejezés. Egy lambda-függvény törzsébe nem írhat több utasítást.

4. Meghívjuk a függvényt és kiírjuk a visszaadott értéket.

Példa 2

Ez egy alapvető példa volt a lambda alapjainak és szintaxisának megértéséhez. Most próbáljunk kinyomtatni egy lambdát, és meglátjuk az eredményt. Ismét nyissa ki a sajátját IDLE és írja be a következőket:

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

Most mentse el a fájlt, és nyomja meg az F5 billentyűt a program futtatásához. Ez az a kimenet, amelyet meg kell kapnia.

output:

<function <lambda> at 0x00000185C3BF81E0>

Mi történik itt? Nézzük meg a kódot, hogy jobban megértsük.

Kód Magyarázat

1. Itt definiáljuk a húr amit paraméterként át fog adni a lambdának.
2. Deklarálunk egy lambdát, amely meghív egy print utasítást és kiírja az eredményt.

De miért nem írja ki a program az általunk átadott karakterláncot? Ennek az az oka, hogy maga a lambda egy függvényobjektumot ad vissza. Ebben a példában a lambda nem lét hívott a nyomtatási funkcióval, hanem egyszerűen visszatérő a függvényobjektum és a memóriahely, ahol tárolják. Ezt nyomtatják ki a konzolon.

Példa 3

Ha azonban írsz egy ilyen programot:

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

És futtassa az F5 megnyomásával, ekkor egy ilyen kimenetet fog látni.

output:

some kind of a useless lambda

Most a lambdát hívják, és az általunk átadott karakterlánc kinyomtatja a konzolt. De mi ez a furcsa szintaxis, és miért van a lambda definíció zárójelben? Ezt most értsük meg.

Kód Magyarázat

1. Itt ugyanaz a karakterlánc, amelyet az előző példában definiáltunk.
2. Ebben a részben definiáljuk a lambdát, és azonnal meghívjuk a karakterlánc argumentumként való átadásával. Ezt IIFE-nek hívják, és többet megtudhat róla ennek az oktatóanyagnak a következő szakaszaiban.

Példa 4

Nézzünk meg egy utolsó példát, hogy megértsük, hogyan hajtódnak végre a lambda- és a reguláris függvények. Szóval nyisd ki a te IDLE és egy új fájlba írja be a következőket:

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

Most mentse el a fájlt, és nyomja meg az F5 billentyűt a program futtatásához. Ha nem hibázott, a kimenetnek valami ilyesminek kell lennie.

output:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Kód Magyarázat

1. Egy guru nevű függvény, amely egy másik függvényt vesz fel első paraméterként, és az azt követő összes többi argumentumot.
2. A printer_one egy egyszerű függvény, amely kiírja a neki átadott paramétert, és visszaadja azt.
3. nyomtató_kettő hasonló a nyomtató_egyhez, de a return utasítás nélkül.
4. Ebben a részben a guru függvényt hívjuk meg, és paraméterként adjuk át a nyomtató függvényeket és egy karakterláncot.
5. Ez a szintaxis a negyedik lépés eléréséhez (azaz a guru függvény meghívásához), de lambdas használatával.

A következő részben megtudhatja, hogyan használhatja a lambda függvényeket térkép(), csökkenti(), és a szűrő() in Python.

Lambda használata a Python beépítettek

A lambda-funkciók elegáns és hatékony módot biztosítanak a műveletek végrehajtására a beépített módszerekkel Python. Ez azért lehetséges, mert a lambdákat azonnal meg lehet hívni, és argumentumként át lehet adni ezeknek a függvényeknek.

IIFE be Python Lambda

IIFE jelentése azonnal meghívja a függvény végrehajtását. Ez azt jelenti, hogy egy lambda függvény hívható, amint meghatározásra került. Értsük meg ezt egy példával; gyújtsd fel a tiédet IDLE és írja be a következőket:

 (lambda x: x + x)(2)

Íme a kimenet és a kód magyarázata:

A lambdák ezen azonnali meghívásának képessége lehetővé teszi, hogy olyan függvényekben használhasd őket, mint a map() és a reduction(). Hasznos, mert előfordulhat, hogy nem kívánja újra használni ezeket a funkciókat.

lambdas a szűrőben ()

A szűrő funkció bizonyos elemek kiválasztására szolgál egy elemsorozatból. A sorozat lehet bármilyen iterátor, például listák, halmazok, sorok stb.

A kiválasztandó elemek valamilyen előre meghatározott megszorításon alapulnak. 2 paraméter kell hozzá:

• Egy függvény, amely meghatározza a szűrési kényszert
• Egy sorozat (bármilyen iterátor, például listák, sorok stb.)

Például,

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

Itt van a kimenet:

[10, 8, 7, 5, 11]

Kód magyarázata:

1. Az első utasításban definiálunk egy listát, amelyet sorozatoknak nevezünk, és amely néhány számot tartalmaz.

2. Itt deklarálunk egy filtered_result nevű változót, amely a filter() függvény által visszaadott szűrt értékeket tárolja.

3. Egy lambda függvény, amely a lista minden elemén fut, és igazat ad vissza, ha nagyobb, mint 4.

4. Nyomtassa ki a szűrőfüggvény által visszaadott eredményt.

lambdák a térképen()

a leképezés funkciót arra használják, hogy egy adott műveletet alkalmazzanak egy sorozat minden elemére. A filter()-hez hasonlóan ez is 2 paramétert igényel:

1. Egy függvény, amely meghatározza az elemeken végrehajtandó műveletet
2. Egy vagy több sorozat

Például itt van egy program, amely kiírja a számok négyzeteit egy adott listában:

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

output:

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

[KR1]

Kód magyarázata:

1. Itt definiálunk egy listát, amelyet sorozatoknak nevezünk, és amely néhány számot tartalmaz.
2. Deklarálunk egy filtered_result nevű változót, amely tárolja a leképezett értékeket
3. Egy lambda függvény, amely a lista minden elemén lefut, és a szám négyzetét adja vissza.
4. Nyomtassa ki a térkép funkció által visszaadott eredményt.

lambdas a redukcióban ()

A redukciós függvény, mint például a map(), arra szolgál, hogy egy műveletet alkalmazzon a sorozat minden elemére. Működésében azonban eltér a térképtől. Ezeket a lépéseket követi a redukció() függvény a kimenet kiszámításához:

Step 1) Hajtsa végre a meghatározott műveletet a sorozat első 2 elemén.

Step 2) Mentse el ezt az eredményt

Step 3) Hajtsa végre a műveletet a mentett eredménnyel és a sorozat következő elemével.

Step 4) Addig ismételje, amíg nem marad több elem.

Ehhez két paraméter is szükséges:

1. A végrehajtandó műveletet meghatározó függvény
2. Egy sorozat (bármilyen iterátor, például listák, sorok stb.)

Például itt van egy program, amely egy lista összes elemének szorzatát adja vissza:

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

Itt van a kimenet:

120

Kód magyarázata:

1. A csökkentés importálása a functools modulból
2. Itt definiálunk egy listát, amelyet sorozatoknak nevezünk, és amely néhány számot tartalmaz.
3. Deklarálunk egy termék nevű változót, amely a csökkentett értéket tárolja
4. Egy lambda függvény, amely a lista minden elemén fut. Ennek a számnak a szorzatát adja vissza az előző eredmény szerint.
5. Nyomtassa ki a redukciós függvény által visszaadott eredményt.

Miért (és miért ne) használjunk lambda függvényeket?

Amint a következő részben látni fogja, a lambdákat ugyanúgy kezeljük, mint a normál függvényeket tolmács szinten. Bizonyos értelemben azt is mondhatnánk, hogy a lambdas tömör szintaxist biztosít olyan függvények írásához, amelyek egyetlen kifejezést adnak vissza.

Azonban tudnia kell, mikor érdemes lambdákat használni, és mikor kerülni őket. Ebben a részben megtudhat néhány tervezési alapelvet, amelyet a python fejlesztők alkalmaznak a lambdák írásakor.

A lambdák egyik leggyakoribb felhasználási esete a funkcionális programozás Python támogatja a funkcionális programozásnak nevezett programozási paradigmát (vagy stílust).

Lehetővé teszi egy függvény megadását egy másik függvény paramétereként (például térképben, szűrőben stb.). Ilyen esetekben a lambda használata elegáns módot kínál egy egyszeri függvény létrehozására és paraméterként való átadására.

Mikor nem szabad Lambdát használni?

Soha ne írjon bonyolult lambda függvényeket éles környezetben. A kódot karbantartó kódolók számára nagyon nehéz lesz visszafejteni azt. Ha azon kapod magad, hogy összetett egysoros kifejezéseket készítesz, sokkal jobb gyakorlat lenne egy megfelelő függvény meghatározása. A legjobb gyakorlat szerint emlékeznie kell arra, hogy az egyszerű kód mindig jobb, mint az összetett kód.

Lambdák vs. reguláris függvények

Amint azt korábban említettük, a lambdák [vV4][J5] csak olyan függvények, amelyekhez nincs azonosító kötve. Egyszerűbb szavakkal, ezek név nélküli (tehát névtelen) függvények. Itt van egy táblázat, amely bemutatja a különbséget a lambda és a python normál függvényei között.

Lambdák

Rendszeres funkciók

Syntax:

lambda x : x + x

Syntax:

def (x) :
return x + x 

A lambda-funkcióknak csak egy kifejezése lehet a testükben.

A reguláris függvények törzsében több kifejezés és kijelentés is lehet.

A lambdákhoz nincs név társítva. Ezért névtelen függvényeknek is nevezik őket.

A normál függvényeknek névvel és aláírással kell rendelkezniük.

A lambdák nem tartalmaznak return utasítást, mert a törzs automatikusan visszaadásra kerül.

Azoknak a függvényeknek, amelyeknek értéket kell visszaadniuk, tartalmazniuk kell egy return utasítást.

A különbségek magyarázata?

Az elsődleges különbség a lambda és a reguláris függvény között az, hogy a lambda függvény csak egyetlen kifejezést értékel, és egy függvényobjektumot eredményez. Következésképpen a lambda függvény eredményét elnevezhetjük és felhasználhatjuk programunkban, ahogy az előző példában tettük.

A fenti példa szokásos függvénye így néz ki:

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

Itt meg kell határoznunk a név a funkcióhoz, amely Visszatér az eredmény, amikor mi hívás azt. A lambda függvény nem tartalmaz return utasítást, mert csak egyetlen kifejezést tartalmaz, amelyet alapértelmezés szerint mindig visszaad. Még csak lambdát sem kell hozzárendelnie, mert azonnal meghívható (lásd a következő részt). Amint azt a következő példában látni fogja, a lambdák különösen erőssé válnak, ha együtt használjuk őket Pythonbeépített funkcióit.

Mindazonáltal továbbra is felmerülhet a kérdés, hogy miben különbözik a lambda egy olyan függvénytől, amely egyetlen kifejezést ad vissza (mint a fenti). Tolmács szinten nincs sok különbség. Lehet, hogy meglepően hangzik, de bármelyik lambda függvény, amiben definiálsz Python a tolmács normál funkcióként kezeli.

Amint az ábrán látható, a két definíciót ugyanúgy kezeli a python interpreter, amikor bájtkódra konvertálja őket. Most nem nevezhet el függvényt lambda mert le van foglalva Python, de bármely más függvénynév ugyanazt a bájtkódot adja [KR6].

Összegzésként

• A lambdák, más néven anonim függvények, kicsi, korlátozott függvények, amelyeknek nincs szükségük névre (azaz azonosítóra).
• Minden lambda funkció be van kapcsolva Python 3 alapvető részből áll:
• A lambda kulcsszó.
• A paraméterek (vagy kötött változók), és
• A funkciótest.
• A lambda írásának szintaxisa: lambda paraméter: kifejezés
• A lambdáknak tetszőleges számú paramétere lehet, de nincsenek kapcsos zárójelek közé zárva
• A lambda függvény törzsében csak 1 kifejezés szerepelhet, amelyet alapértelmezés szerint ad vissza.
• A bájtkód szintjén nincs sok különbség a között, hogy a lambda és a normál függvényeket hogyan kezeli az értelmező.
• A lambda támogatja az IIFE-t a következő szintaxissal: (lambda paraméter: kifejezés) (argumentum)
• A lambdákat általában a következő python beépített elemekkel használják:
• Szűrő: szűrő (lambda paraméter: kifejezés, iterálható sorozat)
• Térkép: térkép (lambda paraméter: kifejezés, iterálható sorozatok)
• Kicsinyítés: redukálás (lambda paraméter1, paraméter2: kifejezés, iterálható sorozat)
• Ne írjon bonyolult lambda függvényeket éles környezetben, mert ez nehéz lesz a kódkarbantartóknak.

[J5]Hozzáadtam egy táblázatot, de a magyarázat szükséges a különbségek megértéséhez.

Ez a kód szerkeszthető. Kattintson a Futtatás a végrehajtáshoz gombra