Lambda függvények Pythonban

Mik azok a lambda funkciók?

.
A Pythonban a függvények objektumok: hozzárendelhetők változókhoz, visszaadhatók más függvényekből, listákban vagy diktatúrákban tárolhatók, és más függvények paramétereiként adhatók át. Vegyük például a map() beépített funkció. A szintaxisa az map(function, iterable) és kézenfekvő alkalmazásra használják function minden eleméhez iterable.

map() valójában egy iterator tárgy. A gyakorlatban az eredményt a list, tuple, set, dictstb., amelyik kényelmesebb.
.
Tegyük fel, hogy egy lista minden tagját négyzetre szeretné tenni a map() funkció. Ennek érdekében meghatározzuk a square() függvényt, és használja paraméterként map():

my_list = [1,2,3,4,5]
def square(x):
    return x**2

my_modified_list = list(map(square, my_list))
print(my_modified_list)

[1, 4, 9, 16, 25]

.
Azonban, ha az egyetlen használata a mi square() funkció a lista létrehozása, tisztább az a lambda funkció:

my_list = [1,2,3,4,5]
my_modified_list = list(map(lambda x: x**2, my_list))
print(my_modified_list)

[1, 4, 9, 16, 25]

A Pythonban lambda A függvények névtelen függvények, amelyek nevüket és szintaxisukat Alonzo Church-től vették Lambda kalkulus. Szintaxisuk a következő:

lambda x_1,..., x_n : expression(x_1, ..., x_n)

Ez létrehoz egy anonim függvényt, amely bemenetként fogadja a változókat x_1, ..., x_n és visszaadja az értékelt expression(x_1, ..., x_n).
.
A cél a lambda A függvényeket paraméterként kell használni azoknál a függvényeknél, amelyek paraméterként fogadnak el függvényeket, ahogyan azt mi is tettük map() felett. A Python lehetővé teszi, hogy a lambda függvény egy változóhoz, de a PEP 8 stílus útmutató nem tanácsolja. Ha egy változóhoz egyszerű függvényt akarunk rendelni, akkor jobb, ha egysoros definícióként tesszük. Ez biztosítja az eredményül kapott objektum megfelelő elnevezését, javítva a visszakövetési olvashatóságot:

anonymous_square = lambda x : x**2
​
def named_square(x): return x**2
​
print(anonymous_square.__name__)
print(named_square.__name__)


a = anonymous_square
b = named_square
print(a.__name__)
print(b.__name__)

Miért használjunk lambda függvényeket?

Az utolsó bekezdés után felmerülhet a kérdés, hogy miért szeretné használni a lambda funkció. Hiszen bármi, amit meg lehet tenni a lambda függvény egy elnevezett függvénnyel végezhető el.
.
A válasz erre az lambda függvény cél az, hogy egy számítást reprezentáló nagyobb kifejezésekben éljünk. Ennek egyik módja a változókkal és értékekkel való analógia. Vegye figyelembe a következő kódot:

x = 2

A változó x az egész szám helyőrzője (vagy neve). 2. Például hívás print(x) és a print(2) pontosan ugyanazt a kimenetet adja. Függvények esetén:

def square(x): return x**2

A funkció square() egy helyőrző egy szám négyzetre emelésének kiszámításához. Ez a számítás névtelenül felírható, mint lambda x: x**2.
.
Ezt a filozófiai kitérőt követően lássunk néhány példát a következő alkalmazásokra lambda funkciókat.
.

Lambda használata a rendezett() függvénnyel

A sorted() függvény egy iterálható elemet rendez. Funkciót fogad el sajátjaként key argumentum, és az iterálható egyes elemeire alkalmazott függvény eredményét használjuk az elemek rendezésére.
.
Ez tökéletesen megfelel a lambda funkció: beállításával a key paramétert a lambda függvényt, az elemek bármilyen attribútuma szerint rendezhetjük. Például sorba rendezhetjük a nevek listáját vezetéknév szerint:

name_list = ['Grace Hopper', 'Ada Lovelace', 'Emmy Noether', 'Marie Curie']
​
sorted_by_surname = sorted(name_list, key = lambda x: x.split()[1])
​
print(sorted_by_surname)

['Marie Curie', 'Grace Hopper', 'Ada Lovelace', 'Emmy Noether']

Lambda használata a 'filter()' függvénnyel

A filter() függvény szintaxisa a következő: filter(function, iterable) és az elemeit adja ki iterable amelyek értékelik function(element) mint igaz (hasonlít egy WHERE záradék SQL-ben). Tudjuk használni lambda paramétereiként funkcionál filter() elemek kiválasztásához egy iterálhatóból.

Tekintsük a következő példát:

num_list = list(range(0,100))
​
multiples_of_15= filter(lambda x: (x % 3 == 0) and (x % 5 == 0), num_list)
​
print(list(multiples_of_15))

[0, 15, 30, 45, 60, 75, 90]

filter() alkalmazza a lambda funkció lambda x: (x % 3 == 0) and (x % 5 == 0) minden eleméhez range(0,100), és visszaadja a filter tárgy. Úgy érjük el az elemeket, hogy mint öntjük list.
.

A Lambda használata a map() függvénnyel

.
Utolsó példánk egy olyan dolog, amit a bevezetőben láthattunk – a map() funkció. A map() a függvény szintaxisa: map(function, iterable)és map() alkalmazandó function minden eleméhez iterable, visszatérő a map objektum, amelyhez öntéssel lehet hozzáférni a list.

Láttuk, hogyan alkalmazható ez a listákra, de a diktatúrákra is alkalmazható a dict.items() eljárás:

my_data = {'Mary':1, 'Alice':2, 'Bob':0}
map_obj = map(lambda x: f'{x[0]} had {x[1]} little lamb', my_data.items())
print(', '.join((map_obj)))

Mary had 1 little lamb, Alice had 2 little lamb, Bob had 0 little lamb

vagy egy karakterláncra:

my_string = 'abcdefg'
''.join(map(lambda x: chr(ord(x)+2),my_string))

'cdefghi'

Tudjuk használni map() zseniális módon működik – az egyik példa számos függvény alkalmazása ugyanarra a bemenetre.

Tegyük fel például, hogy egy API-t hoz létre, amely szöveges karakterláncot kap, és függvénylistát szeretne alkalmazni rá.

Minden függvény kivon egy jellemzőt a szövegből. A kinyerni kívánt jellemzők a szavak száma, a második szó és a negyedik szó negyedik betűje:

def number_of_words(text):
  return len(text.split())
​
def second_word(text):
  return text.split()[1]
​
def fourth_letter_of_fourth_word(text):
  return text.split()[3][3]
​
function_list = [number_of_words, second_word, fourth_letter_of_fourth_word]
​
my_text = 'Mary had a little lamb'
map_obj = map(lambda f: f(my_text), function_list)
​
feature_list = list(map_obj)
​
print(feature_list)

[5, 'had', 't']

.

Következtetés

.
Ebben az útmutatóban megvizsgáltuk a funkcióit lambda függvények Pythonban. Ezt láttuk lambda A függvények névtelen függvények, amelyek más függvények soron belüli függvényparamétereiként használhatók. Láttunk néhány használati esetet, valamint azt, hogy mikor ne használjuk őket.
.
A programozás során fontos szem előtt tartani Donald Knuth idézetét: „A programok arra valók, hogy az emberek olvassák, és csak mellékesen a számítógépek hajtsák végre.” Ezt szem előtt tartva, lambda A függvények hasznos eszközök a kódunk egyszerűsítésére, de okosan kell használni őket.