A Python Lambda PÉLDÁKKAL működik

Tartalomjegyzék:

Anonim

Mi a Lambda funkció a Pythonban?

A Lambda függvény a Python programozásban egy névtelen vagy név nélküli függvény. Ez egy kicsi és korlátozott funkció, amelynek legfeljebb egy sora van. A normál függvényhez hasonlóan a Lambda függvénynek is több argumentuma lehet egy kifejezéssel.

A Pythonban a lambda kifejezéseket (vagy lambda formákat) használják névtelen függvények létrehozására. Ehhez a lambda kulcsszót fogja használni (ugyanúgy, mint a def használatával a normál függvények meghatározásához). A Pythonban definiált minden névtelen függvénynek 3 lényeges része lesz:

  • A lambda kulcsszó.
  • A paraméterek (vagy kötött változók), és
  • A függvénytest.

A lambda függvénynek tetszőleges számú paramétere lehet, de a függvénytest csak egy kifejezést tartalmazhat . Sőt, a lambda egyetlen kódsorba van írva, és azonnal meghívható is. Mindezt működés közben látni fogja a következő példákban.

Ebben a Lambda in Python oktatóanyagban megtudhatja:

  • Szintaxis és példák
  • Lambdas használata Python beépített programokkal
  • lambdas szűrőben ()
  • lambdas a térképen ()
  • lambdas redukcióban ()
  • Miért (és miért nem) használja a lambda függvényeket?
  • Lambdas vs. Rendszeres funkciók

Szintaxis és példák

A lambda függvény megírásának formális szintaxisa az alábbiak szerint alakul:

lambda p1, p2: expression

Itt p1 és p2 azok a paraméterek, amelyeket átadunk a lambda függvénynek. Hozzáadhat annyi vagy kevés paramétert, amennyire szüksége van.

Azonban vegye figyelembe, hogy a paraméterek körül nem használunk zárójelet, mint a szokásos funkcióknál. Az utolsó rész (kifejezés) minden érvényes python kifejezés, amely a függvényhez megadott paramétereken működik.

1. példa

Most, hogy tud a lambdasról, próbáljuk ki egy példával. Tehát nyissa meg az IDLE-t, és írja be a következőt:

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

Itt van a kimenet:

3

Kód Magyarázat

Itt meghatározunk egy változót, amely megtartja 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 összeadja az általunk átadott 2 paramétert. Figyelje meg, hogy ez egyetlen kifejezés. Nem írhat több utasítást a lambda függvény törzsébe.

4. Meghívjuk a függvényt, és kinyomtatjuk a visszaadott értéket.

2. példa

Ez alapvető példa volt a lambda alapjainak és szintaxisának megértéséhez. Próbáljuk meg most kinyomtatni a lambdát és megnézni az eredményt. Ismét nyissa meg az IDLE-t, és írja be a következőket:

#What a lambda returnsstring='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.

Kimenet:

 at 0x00000185C3BF81E0>

Mi történik itt? Nézzük meg a kódot a további megértéshez.

Kód Magyarázat

  1. Itt definiálunk egy karakterláncot, amelyet paraméterként ad át a lambda-nak.
  2. Kijelentjük a lambdát, amely nyomtatott utasítást hív és kinyomtatja az eredményt.

De miért nem nyomtatja ki a program az átadott karakterláncot? Ez azért van, mert a lambda maga ad vissza egy függvényobjektumot. Ebben a példában a lambdát nem a nyomtatási függvény hívja meg, hanem egyszerűen visszaadja a függvényobjektumot és a memória helyét, ahol tárolva van. Ezt nyomtatja ki a konzol.

3. példa

Ha azonban egy ilyen programot írsz:

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

És futtassa az F5 lenyomásával, akkor megjelenik egy ilyen kimenet.

Kimenet:

some kind of a useless lambda

Most hívják a lambdát, és az általunk átadott húr nyomtatásra kerül a konzolon. De mi ez a furcsa szintaxis, és miért van zárójelben a lambda definíció? Ezt most értsük meg.

Kód Magyarázat

  1. Itt van ugyanaz a karakterlánc, amelyet az előző példában definiáltunk.
  2. Ebben a részben definiálunk egy lambdát, és azonnal hívjuk úgy, hogy argumentumként átadjuk a karakterláncot. Ezt nevezik IIFE-nek, és többet megtudhat erről az oktatóanyag következő szakaszaiban.

4. példa

Nézzünk meg egy utolsó példát, hogy megértsük, hogyan hajtják végre a lambdas és a reguláris függvényeket. Tehát nyissa meg az IDLE-t, és egy új fájlba írja be a következőket:

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

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

Kimenet:

nyomtató 1 SZABÁLYOS HÍVÁS

nyomtató 2 SZABÁLYOS HÍVÁS

nyomtató 1 LAMBDA CALL

nyomtató 2 LAMBDA CALL

Kód Magyarázat

  1. A guru nevű függvény, amely első paraméterként egy másik függvényt vesz fel, és az azt követő egyéb argumentumok.
  2. A printer_one egy egyszerű függvény, amely kinyomtatja a neki átadott paramétert és visszaadja.
  3. A printer_two hasonló a printer_one-hez, de a return utasítás nélkül.
  4. Ebben a részben a guru függvényt hívjuk meg, és a nyomtató függvényeket és egy karakterláncot adjuk át paraméterként.
  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 kell használni a lambda függvényeket a map (), a reduc () és a filter () Pythonban.

Lambdas használata Python beépített programokkal

A Lambda funkciók elegáns és hatékony módszert kínálnak a műveletek végrehajtására a Python beépített módszereivel. Ez azért lehetséges, mert a lambdas azonnal meghívható és argumentumként átadható ezeknek a függvényeknek.

IIFE a Python Lambda-ban

Az IIFE az azonnal meghívott függvény végrehajtást jelenti. Ez azt jelenti, hogy a lambda függvény azonnal meghatározható. Értsük meg ezt egy példával; indítsa el az IDLE-t, és írja be a következőt:

 (lambda x: x + x)(2)

Itt van a kimenet és a kód magyarázata:

Ez a lambdas azonnal meghívható képessége lehetővé teszi, hogy azokat olyan funkciókban használja, mint a map () és a reduc (). Ez azért hasznos, mert előfordulhat, hogy nem szeretné újra használni ezeket a funkciókat.

lambdas szűrőben ()

A szűrő funkcióval bizonyos elemeket kiválaszthatunk az elemek sorozatából. A szekvencia bármilyen iterátor lehet, például listák, halmazok, sorok stb.

A kiválasztandó elemek valamilyen előre meghatározott korláton alapulnak. 2 paraméter szükséges:

  • A szűrési kényszert meghatározó függvény
  • Egy szekvencia (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ázat:

1. Az első utasításban meghatározunk egy szekvenciának nevezett listát, amely tartalmaz néhány számot.

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

3. A lista minden elemén futó lambda függvény, amely 4-nél nagyobb értéket ad vissza.

4. Nyomtassa ki a szűrő funkcióval kapott eredményt.

lambdas a térképen ()

a térképfüggvény egy adott művelet alkalmazására szolgál egy sorozat minden elemére. A filter () -hez hasonlóan 2 paramétert is megkövetel:

  1. Olyan függvény, amely meghatározza az op-ot az elemeken való teljesítéshez
  2. Egy vagy több szekvencia

Például itt van egy program, amely kinyomtatja az adott listában szereplő számok négyzetét:

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

Kimenet:

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

[KR1]

Kód Magyarázat:

  1. Itt meghatározunk egy szekvenciának nevezett listát, amely tartalmaz néhány számot.
  2. Kijelentjük a 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 fut, és ennek a számnak a négyzetét adja vissza.
  4. Nyomtassa ki a térképfunkció által visszaadott eredményt.

lambdas redukcióban ()

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

1. lépés: Végezze el a megadott műveletet a szekvencia első 2 elemén.

2. lépés: Mentsd el ezt az eredményt

3. lépés: Végezze el a műveletet a mentett eredménnyel és a sorozat következő elemével.

4. lépés: Ismételje meg, amíg nem marad több elem.

Két paraméterre is szükség van:

  1. Funkció, amely meghatározza az elvégzendő műveletet
  2. Egy szekvencia (bármilyen iterátor, például listák, sorok stb.)

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

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

Itt van a kimenet:

120

Kód Magyarázat:

  1. Importálás csökkentése a functools modulból
  2. Itt meghatározunk egy szekvenciának nevezett listát, amely tartalmaz néhány számot.
  3. Deklaráljuk a termék nevű változót, amely tárolja a csökkentett értéket
  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énynek megfelelően.
  5. Nyomtassa ki a kicsinyítés funkcióval kapott eredményt.

Miért (és miért nem) használja a lambda függvényeket?

Amint a következő szakaszban látni fogja, a lambdákat a tolmácsszinten ugyanúgy kezelik, mint a szokásos funkciókat. Bizonyos szempontból azt mondhatnánk, hogy a lambdas kompakt szintaxist biztosít az írásfunkciók számára, amelyek egyetlen kifejezést adnak vissza.

Azt azonban tudnia kell, hogy mikor érdemes lambdákat használni, és mikor kerülje el őket. Ebben a szakaszban megismerheti azokat a tervezési elveket, amelyeket a python fejlesztői használnak a lambdas írásakor.

A lambdas egyik leggyakoribb használati esete a funkcionális programozás, mivel a Python támogatja a programozás paradigmáját (vagy stílusát), amelyet funkcionális programozásnak neveznek.

Lehetővé teszi, hogy egy függvényt paraméterként adjon meg egy másik függvénynek (például térképen, szűrőben stb.). Ilyen esetekben a lambdas 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 ne használja a Lambda-t?

Soha ne írjon bonyolult lambda függvényeket termelési környezetben. A kódodat karbantartó kódolóknak nagyon nehéz lesz visszafejteni. Ha összetett egyvonalas kifejezéseket talál magának, sokkal jobb gyakorlat lenne meghatározni a megfelelő funkciót. Legjobb gyakorlatként emlékeznie kell arra, hogy az egyszerű kód mindig jobb, mint az összetett kód.

Lambdas vs. Rendszeres funkciók

Amint azt korábban elmondtuk, a lambdák csak [vV4] [J5] funkciók, amelyekhez nincs azonosító kötve. Egyszerűbben fogalmazva, ezek függvények név nélkül (tehát névtelenek). Itt egy táblázat szemlélteti a lambdas és a Python rendszeres funkciói közötti különbséget.

Lambdas

Rendszeres funkciók

Szintaxis:

lambda x : x + x

Szintaxis:

def (x) :return x + x

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

A rendszeres funkciók testében több kifejezés és utasítás is szerepelhet.

A lambdákhoz nincs társítva név. Ezért névtelen funkciókként is ismerik őket.

A rendszeres funkcióknak névvel és aláírással kell rendelkezniük.

A Lambdas nem tartalmaz visszatérési utasítást, mert a törzs automatikusan visszatér.

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

Magyarázat a különbségekre?

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 meg tudjuk nevezni a lambda függvény eredményét és felhasználni a programunkban, ahogy az előző példában is tettük.

A fenti példa rendszeres funkciója így néz ki:

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

Itt meg kell határoznunk a függvény nevét , amely az eredményt adja vissza, amikor meghívjuk . A lambda függvény nem tartalmaz visszatérési utasítást, mert csak egyetlen kifejezése lesz, amelyet alapértelmezés szerint mindig visszaadnak. Még lambdát sem kell hozzárendelnie, mivel azonnal meghívható (lásd a következő részt). Amint a következő példában láthatja, a lambdák akkor válnak különösen erőteljessé, ha a Python beépített függvényeivel együtt használjuk őket.

Azonban még mindig kíváncsi lehet, hogy a lambdák miben különböznek egy olyan függvénytől, amely egyetlen kifejezést ad vissza (mint a fenti). Tolmács szinten nincs sok különbség. Meglepőnek tűnhet, de a Pythonban definiált lambda-függvényeket a tolmács normál függvényként kezeli.

Amint az ábrán látható, a két definíciót a python tolmács ugyanúgy kezeli, ha bytecodekká konvertálják. Most nem nevezhet meg egy lambda függvényt, mert azt a Python fenntartja, de bármely más függvénynév ugyanazt a bájtkódot adja [KR6].

Összegzés

  • A Lambdas, más néven névtelen függvények, kicsi, korlátozott függvények, amelyekhez nem szükséges név (azaz azonosító).
  • A Python minden lambda függvényének 3 lényeges része van:
  • A lambda kulcsszó.
  • A paraméterek (vagy kötött változók), és
  • A függvénytest.
  • A lambda írásának szintaxisa: lambda paraméter: kifejezés
  • A lambdáknak tetszőleges számú paraméterük lehet, de nem zárójelben vannak
  • A lambda csak 1 kifejezést tartalmazhat a függvénytörzsében, amely alapértelmezés szerint visszatér.
  • Bájtkód szinten nincs sok különbség a tolmács által a lambdas és a reguláris függvények kezelése között.
  • A Lambdas támogatja a IIFE-t ezen a szintaxison keresztül: (lambda paraméter: kifejezés) (argumentum)
  • A lambdákat általában a következő python beépített modulokkal használják:
  • Szűrő: szűrő (lambda paraméter: kifejezés, iterálható szekvencia)
  • Térkép: térkép (lambda paraméter: kifejezés, iterálható szekvenciák)
  • Reduce: reduc (lambda paraméter1, paraméter2: kifejezés, iterálható szekvencia)
  • Ne írjon bonyolult lambda függvényeket termelési környezetbe, mert a kódfenntartók számára nehéz lesz.

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