Python Lambda funkciók példákkal

Miben található a lambda funkció? Python?

A Lambda funkció be Python A programozás névtelen vagy névtelen függvény. Ez egy kicsi és korlátozott függvény, amelynek legfeljebb egy sora van. Csakúgy, mint egy normál függvénynek, a Lambda függvénynek több argumentuma is lehet egyetlen kifejezéssel.

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.

Azonban vegyük észre, hogy a paraméterek körül nem használunk zárójeleket, mint a hagyományos függvényeknél. Az utolsó rész (kifejezés) bármilyen érvényes Python egy 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))

Code 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áljuk meg kinyomtatni a lambdát és megnézni az eredményt. Nyisd meg újra a 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.

Code Magyarázat:

1. Itt definiálunk egy húr amit paraméterként fogsz átadni a lambda függvénynek.

2. Deklarálunk egy lambda függvényt, amely meghív egy print utasítást és kiírja az eredményt.

De miért nem írja ki a program az átadott karakterláncot? Ez azért van, mert maga a lambda egy függvényobjektumot ad vissza. Ebben a példában a lambda nem kerül kiírásra. hívott a nyomtatási függvény által, hanem egyszerűen visszatérő a függvényobjektumot és a memóriahelyét, ahol tárolva van. Ez jelenik meg 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 indítsd el az F5 billentyű lenyomásával, egy ilyen kimenetet fogsz látni.

output:

some kind of a useless lambda

Most a lambda meghívódik, és az átadott karakterlánc megjelenik a konzolon. De mi ez a furcsa szintaxis, és miért van a lambda definíciója zárójelben? Nézzük meg most.

Code Magyarázat:

1. Itt ugyanaz a karakterlánc, mint amit az előző példában definiáltunk.

2. Ebben a részben egy lambda függvényt definiálunk, és azonnal meghívjuk a karakterlánc argumentumként történő átadásával. Ezt IIFE-nek hívják, és erről a tutoriál következő szakaszaiban többet is megtudhatsz.

Példa 4

Nézzünk egy utolsó példát, hogy megértsük, hogyan futnak a lambda függvények és a reguláris függvények. Tehát nyissuk meg a 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 mentsd el a fájlt, és nyomd meg az F5 billentyűt a program futtatásához. Ha nem követtél el hibákat, a kimenetnek valami ilyesminek kell lennie.

output:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code 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 kinyomtatja a neki átadott paramétert, majd visszaadja azt.

3. A printer_two hasonló a printer_one-hoz, de a return utasítás nélkül.

4. Ebben a részben meghívjuk a guru függvényt, és paraméterként átadjuk 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 lambda függvények használatával.

A következő részben megtudhatja, hogyan használhatja a lambda függvényeket térkép(), csökkenti()és 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 meghívható, amint definiálva van. Értsük meg ezt egy példával; indítsd el a 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álasztásra kerülő elemek valamilyen előre meghatározott feltételen alapulnak. Két paramétert kell megadni:

• 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]

Code Magyarázat:

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 map függvény egy adott művelet végrehajtására szolgál egy sorozat minden elemére. A filter()-hez hasonlóan ez is 2 paramétert fogad el:

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]

Code Magyarázat:

1. Itt definiálunk egy sorozatnak nevezett listát, amely néhány számot tartalmaz.

2. Deklarálunk egy filtered_result nevű változót, amely a leképezett értékeket tárolja.

3. Egy lambda függvény, amely a lista minden elemén lefut, és az adott szám négyzetét adja vissza.

4. Nyomtassa ki a map függvény á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

Code Magyarázat:

1. Importáld a reduce függvényt a functools modulból.

2. Itt definiálunk egy sorozatnak nevezett listát, amely néhány számot tartalmaz.

3. Deklarálunk egy szorzat nevű változót, amely a redukált értéket tárolja.

4. Egy lambda függvény, amely a lista minden elemén lefut. Az előző eredménynek megfelelően visszaadja az adott szám szorzatát.

5. Nyomtassa ki a reduce 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 tudnod kell, mikor jó ötlet lambda függvényeket használni, és mikor érdemes kerülni őket. Ebben a részben megismerkedhetsz a következők által használt tervezési elvekkel: Python fejlesztők lambda dák írásakor.

A lambda függvények egyik leggyakoribb felhasználási területe a funkcionális programozás, mivel Python támogatja a funkcionális programozásnak nevezett programozási paradigmát (vagy stílust).

Lehetővé teszi, hogy egy függvényt paraméterként adjunk meg egy másik függvénynek (például a map, filter stb. függvényekben). Ilyen esetekben a lambda használata elegáns módot kínál egy egyszer használatos 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

Ahogy korábban említettük, a lambda függvények olyan függvények, amelyekhez nincs azonosító kötve. Egyszerűbben fogalmazva, név nélküli függvények (ezért névtelenek). Íme egy táblázat, amely szemlélteti a lambda és a hagyományos függvények közötti különbséget: Python.

lambda x : x + x

def (x) :
return x + x 

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. Egy lambda függvény nem tartalmaz return utasítást, mivel csak egyetlen kifejezéssel rendelkezik, amelyet alapértelmezés szerint mindig visszaad. Még csak hozzá sem kell rendelni egy lambda függvényt, mivel az azonnal meghívható (lásd az előző szakaszt). Amint látni fogod, a lambda függvények különösen hatékonyak lesznek, ha a következővel 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.

Bájtkód szinten a két definíciót ugyanúgy kezeli a Python értelmező. Most nem nevezhet el egy függvényt lambda mert le van foglalva Python, de bármely más függvénynév ugyanazt a bájtkódot fogja eredményezni.

GYIK