Ebben az oktatóanyagban mindent megtudhat a Python lambda-függvényeiről – a szintaxistól a lambda-függvények meghatározásán át a különböző használati esetekig kódpéldákkal.
A Pythonban a lambdák névtelen függvények, amelyek tömör szintaxissal rendelkeznek, és más hasznos beépített függvényekkel együtt használhatók. Ennek az oktatóanyagnak a végére megtanulja, hogyan definiáljon lambda-függvényeket, és mikor érdemes ezeket a szokásos Python-függvényekkel szemben használni.
Kezdjük!
Tartalomjegyzék
Python Lambda függvény: Szintaxis és példák
Íme az általános szintaxis a lambda függvény definiálásához a Pythonban:
lambda parameter(s):return value
A fenti általános szintaxisban:
- A lambda az a kulcsszó, amelyet a lambda-függvény definiálásához kell használni, majd egy vagy több paramétert, amelyet a függvénynek fel kell vennie.
- A paramétereket és a visszatérési értéket kettőspont választja el.
💡 A lambda függvény definiálásakor ügyeljen arra, hogy a visszatérési érték kiszámítása egy olyan kifejezés kiértékelésével történjen, amely egy kódsoron át ível. Ezt jobban megérti, ha példákat kódolunk.
Példák a Python Lambda függvényekre
A lambda-függvények megértésének legjobb módja a szokásos Python-függvények lambda-függvényekké történő átírása.
👩🏽💻 Kódolhat Python REPL-ben vagy a etoppc.com online Python szerkesztőjében.
#1. Tekintsük a következő square() függvényt, amely egy számot vesz fel argumentumként, és a szám négyzetét adja vissza.
def square(num):
return num*num
Meghívhatja a függvényt argumentumokkal, és ellenőrizheti, hogy megfelelően működik-e.
>>> square(9) 81 >>> square(12) 144
Ezt a lambda-kifejezést hozzárendelheti egy változónévhez, például négyzet1-hez, hogy tömörebb legyen a függvénydefiníció: square1 = lambda num: num*num, majd meghívja a square1 függvényt tetszőleges számmal argumentumként. Tudjuk azonban, hogy a lambdák névtelen függvények, ezért kerülje el, hogy változóhoz rendelje őket.
A square() függvény paramétere num, a visszatérési érték pedig num*num. Miután azonosítottuk ezeket, beilleszthetjük őket a lambda kifejezésbe, és egy argumentummal hívhatjuk meg, amint látható:
>>> (lambda num: num*num)(2) 4
Ez az azonnal meghívott függvénykifejezés fogalma, ahol egy függvényt közvetlenül a definiálás után hívunk meg.
#2. Ezután írjunk át egy másik egyszerű add() függvényt, amely szám1 és szam2 számokat vesz fel, és ezek összegét adja vissza, a szám1 + szam2.
def add(num1,num2):
return num1 + num2
Nevezzük meg az add() függvényt két számmal argumentumként:
>>> add(4,3) 7 >>> add(12,5) 17 >>> add(12,6) 18
Ebben az esetben num1 és num2 a két paraméter, és a visszatérési érték num1 + num2.
>>> (lambda num1, num2: num1 + num2)(3,7) 10
A Python-függvények a paraméterek alapértelmezett értékeit is felvehetik. Módosítsuk az add() függvény definícióját, és állítsuk a num2 paraméter alapértelmezett értékét 10-re.
def add(num1, num2=10):
return num1 + num2
A következő függvényhívásokban:
- Az első függvényhívásban a num1 értéke 1, a num2 értéke pedig 3. Amikor a függvényhívásban megadja a num2 értékét, ez az érték kerül felhasználásra; a függvény 4-et ad vissza.
- Ha azonban csak egy argumentumot ad meg (a szám1 értéke 7), akkor a 10-es alapértelmezett értéket használja a 2. szám; a függvény 17-et ad vissza.
>>> add(1,3) 4 >>> add(7) 17
Amikor olyan függvényeket írunk, amelyek bizonyos paraméterekhez alapértelmezett értéket vesznek fel lambda-kifejezésként, a paraméterek meghatározásakor megadhatja az alapértelmezett értéket.
>>> (lambda num1, num2 = 10: num1 + num2)(1) 11
Mikor érdemes Lambda függvényeket használni a Pythonban?
Most, hogy megtanulta a lambda függvények alapjait a Pythonban, íme néhány használati eset:
- Ha van egy függvénye, amelynek visszatérési kifejezése egyetlen kódsor, és nem kell hivatkoznia a függvényre ugyanabban a modulban máshol, akkor lambda függvényeket használhat. Ennek megértéséhez néhány példát is kódoltunk.
- A lambda függvényeket beépített függvények használatakor használhatja, mint például a map(), a filter() és a redukció().
- A lambda függvények hasznosak lehetnek a Python adatstruktúrák, például listák és szótárak rendezésében.
A Python Lambda használata beépített funkciókkal
1. A Lambda használata a map()
A map() függvény felvesz egy iterálható és egy függvényt, és alkalmazza a függvényt az iterálható minden egyes elemére, az ábrán látható módon:
Hozzunk létre egy számlistát, és a map() függvény segítségével hozzunk létre egy új listát, amely tartalmazza a számlistában szereplő egyes számok négyzetét. Figyelje meg a lambda függvény használatát a négyzetesítési művelet meghatározásához.
>>> nums = [4,5,6,9] >>> list(map(lambda num:num*num,nums)) [16, 25, 36, 81]
Mivel a map() függvény egy térképobjektumot ad vissza, azt egy listába kell önteni.
▶️ Tekintse meg ezt az oktatóanyagot a Python térkép() funkcióján.
2. Lambda használata filter()
Határozzuk meg a számokat, egy számlistát:
>>> nums = [4,5,6,9]
Tegyük fel, hogy szűrni szeretné ezt a listát, és csak a páratlan számokat szeretné megtartani.
Használhatja a Python beépített filter() függvényét.
A filter() függvény felvesz egy feltételt és egy iterálhatót: filter(condition, iterable). Az eredmény csak azokat az elemeket tartalmazza az eredeti iterálhatóságban, amelyek teljesítik a feltételt. A visszaadott objektumot egy Python iterálható elembe, például listába öntheti.
Az összes páros szám kiszűréséhez csak a páratlan számokat tartjuk meg. Tehát a lambda kifejezés legyen lambda num: num%2!=0. A num%2 mennyiség a maradék, ha a számot elosztjuk 2-vel.
- num%2!=0 igaz, ha a szám páratlan, és
- num%2!=0 hamis, ha a szám páros.
>>> nums = [4,5,6,9] >>> list(filter(lambda num:num%2!=0,nums)) [5, 9]
3. A Lambda használata a redukcióval ()
A redukció() függvény egy iterálható és egy függvényt vesz fel. Csökkenti az iterálható mennyiséget azáltal, hogy a függvényt iteratívan alkalmazza az iterálható elemeire.
A Reduction() függvény használatához importálnia kell a Python beépített functools moduljából:
>>> from functools import reduce
Használjuk a Reduction() függvényt a számlistában szereplő összes szám összegének kiszámításához. A redukáló összeg függvényként egy lambda kifejezést definiálunk: lambda szám1,szám2:szám1+szám2.
A redukciós művelet a következőképpen történik: f(f(f(4,5),6),9) = f(f(9,6),9) = f(15,9) = 24. Itt f a lista két elemének összegző művelete, amelyet a lambda függvény határoz meg.
>>> from functools import reduce >>> nums = [4,5,6,9] >>> reduce(lambda num1,num2:num1+num2,nums) 24
Python Lambda-függvények a rendezés testreszabásához
A lambda-függvények beépített Python-függvényekkel, például map(), filter() és redukciós(-) használata mellett a beépített függvények és rendezési módszerek testreszabására is használhatók.
1. Python-listák rendezése
Amikor Python-listákkal dolgozik, gyakran bizonyos rendezési feltételek alapján kell rendeznie azokat. A Python-listák helyükre rendezéséhez használhatja a beépített sort() metódust. Ha szüksége van a lista rendezett másolatára, használhatja a sorted() függvényt.
A Python sorted() függvényének szintaxisa rendezett(iterálható, kulcs=…,fordított=igaz |hamis).
– A kulcsparaméter a rendezés testreszabására szolgál.
– A fordított paraméter igaz vagy hamis értékre állítható; az alapértelmezett érték False.
A számok és karakterláncok listáinak rendezésekor az alapértelmezett rendezés növekvő, illetve ábécé sorrendben történik. Előfordulhat azonban, hogy néha meg kíván határozni néhány egyéni rendezési kritériumot.
Vegye figyelembe a következő gyümölcslistát. Tegyük fel, hogy szeretné megszerezni a lista rendezett példányát. A karakterláncokat aszerint kell rendezni, hogy hány ‘p’ fordul elő bennük – csökkenő sorrendben.
>>> fruits = ['apple','pineapple','grapes','mango']
Ideje használni az opcionális kulcsparamétert. A karakterlánc egy iterálható Pythonban, és a benne lévő karakterek előfordulási számának meghatározásához használhatja a beépített .count() metódust. Tehát a kulcsot lambda x:x.count(‘p’) értékre állítottuk be, hogy a rendezés azon alapuljon, hogy hányszor fordul elő ‘p’ a karakterláncban.
>>> fruits = ['apple','pineapple','grapes','mango']
>>> sorted(fruits,key=lambda x:x.count('p'),reverse=True)
['pineapple', 'apple', 'grapes', 'mango']
Ebben a példában:
- A rendezés kulcsa a „p” karakter előfordulásának száma, és ez lambda-kifejezésként van definiálva.
- Mivel a fordított paramétert True-ra állítottuk, a rendezés a „p” előfordulásai számának csökkenő sorrendjében történik.
A gyümölcslistában az „ananász” 3 „p” előfordulását tartalmazza, az „alma”, „szőlő” és „mangó” karakterláncok pedig 2, 1 és 0 „p” előfordulását tartalmazzák.
A stabil rendezés megértése
Vegyünk egy másik példát. Ugyanerre a rendezési kritériumra újradefiniáltuk a gyümölcslistát. Itt a „p” kétszer, illetve egyszer fordul elő az „alma” és „szőlő” karakterláncokban. És soha nem fordul elő a „mangó” és a „dinnye” karakterláncokban.
>>> fruits = ['mango','apple','melon','grapes']
>>> sorted(fruits,key=lambda x:x.count('p'),reverse=True)
['apple', 'grapes', 'mango', 'melon']
A kimeneti listában a „mango” a „dinnye” elé kerül, bár mindkettőben nincs „p” karakter. De miért van ez így? A sorted() függvény stabil rendezést hajt végre; így ha a „p” száma egyenlő két karakterlánc esetén, az elemek sorrendje az eredeti gyümölcslistában megmarad.
Gyors gyakorlatként cserélje fel a „mangó” és a „dinnye” pozícióját a gyümölcslistában, rendezze a listát ugyanazon szempont alapján, és figyelje meg a kimenetet.
▶️ További információ a Python-listák rendezéséről.
2. Python szótár rendezése
A lambdákat a Python szótárak rendezésekor is használhatja. Tekintsük a következő szótárt price_dict, amely tartalmazza a tételeket és azok árait.
>>> price_dict = {
... 'Milk':10,
... 'Honey':15,
... 'Bread':7,
... 'Candy':3
... }
Ha egy szótár kulcs-érték párjait sorok listájaként szeretné megkapni, használja a beépített szótármódszert, az .items():
>>> price_dict_items = price_dict.items()
dict_items([('Milk', 10), ('Honey', 15), ('Bread', 7), ('Candy', 3)])
A Pythonban az összes iterálható elem: listák, sorok, karakterláncok és egyebek a nulla indexelést követik. Tehát az első elem a 0 indexnél, a második az 1 indexnél van, és így tovább.
Szeretnénk az érték szerint rendezni, ami a szótárban szereplő egyes tételek ára. A price_dict_items lista minden sorában az 1. indexű tétel az ár. Tehát a kulcsot lambda x:x-re állítottuk[1] mivel a szótár rendezéséhez az 1. indexű tételt, az árat fogja használni.
>>> dict(sorted(price_dict_items,key=lambda x:x[1]))
{'Candy': 3, 'Bread': 7, 'Milk': 10, 'Honey': 15}
A kimenetben a szótári tételek az árak növekvő sorrendjében vannak rendezve: „Candy”-val kezdődően, 3 egység árú „Méz”-ig, ára 15 egység.
▶️ További információért tekintse meg ezt a részletes útmutatót a Python-szótár kulcs és érték szerinti rendezéséről.
Összegezve
És megvan! Megtanulta, hogyan definiálhat lambda-függvényeket, és hogyan használhatja azokat hatékonyan más beépített Python-függvényekkel. Íme egy összefoglaló a legfontosabb tudnivalókról:
- A Pythonban a lambda névtelen függvények, amelyek több argumentumot is felvehetnek, és értéket adnak vissza; a visszatérési érték létrehozásához kiértékelendő kifejezésnek egy kódsornak kell lennie. Használhatók a kis függvénydefiníciók tömörebbé tételére.
- A lambda függvény meghatározásához használhatja a következő szintaxist: lambda paraméter(ek): visszatérési érték.
- A fontos felhasználási esetek közé tartozik a map(), filter() és redukció() függvényekkel való használatuk, valamint a Python iterables rendezése testreszabásának kulcsparamétere.
Ezután tanulja meg, hogyan hajthat végre padlóosztást Pythonban.