Lambdafunktioner i Python

Vad är Lambda-funktioner?

â € <
I Python är funktioner objekt: de kan tilldelas variabler, kan returneras från andra funktioner, lagras i listor eller dicts och skickas som parametrar för andra funktioner. Tänk till exempel på map() inbyggd funktion. Dess syntax är map(function, iterable) och det används för att smidigt applicera function till varje del av iterable.

map() returnerar faktiskt en iterator objekt. I praktiken gjuter vi resultatet som ett list, tuple, set, dictosv, vilket som är lämpligast.
â € <
Anta att du vill kvadratisera varje term i en lista med hjälp av map() fungera. För att göra det kommer vi att definiera en square() funktion och använd den som parameter för 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]

â € <
Men om den enda användningen av vår square() funktionen är att skapa den här listan, det är renare att använda en lambda fungera:

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]

I Python, lambda funktioner är anonyma funktioner som tar sitt namn och syntax från Alonzo Church Lambdakalkyl. Deras syntax är:

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

Detta skapar en anonym funktion som tar emot variablerna som input x_1, ..., x_n och returnerar den utvärderade expression(x_1, ..., x_n).
â € <
Syftet med lambda funktioner ska användas som parameter för funktioner som accepterar funktioner som parameter, som vi gjorde med map() ovan. Python låter dig tilldela en lambda funktion till en variabel, men PEP 8 stilguide avråder det. Om du vill tilldela en enkel funktion till en variabel är det bättre att göra det som en enradsdefinition. Detta säkerställer att det resulterande objektet får ett korrekt namn, vilket förbättrar spårningsläsbarheten:

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__)

Varför använda Lambda-funktioner?

Efter det sista stycket kanske du undrar varför du skulle vilja använda en lambda fungera. När allt kommer omkring, allt som kan göras med en lambda funktion kan göras med en namngiven funktion.
â € <
Svaret på detta är det lambda funktions Syftet är att leva inuti större uttryck som representerar en beräkning. Ett sätt att tänka på detta är i analogi med variabler och värden. Tänk på följande kod:

x = 2

Variabeln x är en platshållare (eller ett namn) för heltal 2. Till exempel att ringa print(x) och print(2) ger exakt samma effekt. När det gäller funktioner:

def square(x): return x**2

Funktionen square() är en platshållare för beräkning av kvadrering av ett tal. Denna beräkning kan skrivas på ett namnlöst sätt som lambda x: x**2.
â € <
Efter denna filosofiska utvikning, låt oss se några exempel på tillämpningar för lambda funktioner.
â € <

Använda Lambda med funktionen sortered().

Smakämnen sorted() funktion sorterar en iterabel. Den accepterar en funktion som sin key argument, och resultatet av funktionen som tillämpas på varje element i iterabeln används för att ordna elementen.
â € <
Detta passar perfekt till en lambda funktion: genom att ställa in key parameter med a lambda funktion, kan vi sortera efter vilken typ av attribut som helst för elementen. Vi kan till exempel sortera en lista med namn efter efternamn:

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

Använda Lambda med 'filter()'-funktionen

Smakämnen filter() funktionen har följande syntax: filter(function, iterable) och det matar ut elementen i iterable som utvärderar function(element) som sant (det liknar en WHERE klausul i SQL). Vi kan använda lambda fungerar som parametrar för filter() för att välja element från en iterabel.

Tänk på följande exempel:

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() tillämpar lambda fungera lambda x: (x % 3 == 0) and (x % 5 == 0) till varje element av range(0,100), och returnerar en filter objekt. Vi kommer åt elementen genom att gjuta det som list.
â € <

Använda Lambda med Map()-funktionen

â € <
Vårt sista exempel är något vi har sett i inledningen – den map() fungera. De map() funktionssyntax är: map(function, iterable)och map() applicerar function till varje element av iterable, returnerar en map objekt som kan nås genom att casta till en list.

Vi har sett hur detta kan tillämpas på listor, men det kan tillämpas på dikter med hjälp av dict.items() metod:

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

eller till en sträng:

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

'cdefghi'

Vi kan använda map() fungera på geniala sätt – ett exempel är att tillämpa många funktioner på samma ingång.

Anta till exempel att du skapar ett API som tar emot en textsträng och att du vill använda en lista med funktioner på den.

Varje funktion extraherar någon funktion från texten. Funktionerna vi vill extrahera är antalet ord, det andra ordet och den fjärde bokstaven i det fjärde ordet:

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

â € <

Slutsats

â € <
I den här guiden har vi utforskat funktionaliteten hos lambda funktioner i Python. Det har vi sett lambda funktioner är anonyma funktioner som ska användas som en inline funktionsparameter för andra funktioner. Vi har sett några användningsfall samt när man inte ska använda dem.
â € <
När man programmerar är det viktigt att tänka på Donald Knuths citat: "Programs are meant to be read by humans and only incidentally for computers to exekvering." Med detta i åtanke, lambda funktioner är ett användbart verktyg för att förenkla vår kod, men bör användas på ett klokt sätt.