Lambda-funktioner i Python

Hvad er Lambda-funktioner?

â € <
I Python er funktioner objekter: de kan tildeles variabler, kan returneres fra andre funktioner, gemmes i lister eller diktater og sendes som parametre for andre funktioner. Overvej for eksempel map() indbygget funktion. Dens syntaks er map(function, iterable) og det bruges til praktisk påføring function til hvert element af iterable.

map() faktisk returnerer en iterator objekt. I praksis støber vi resultatet som et list, tuple, set, dictosv., alt efter hvad der passer bedst.
â € <
Antag, at du vil kvadrere hvert led i en liste ved hjælp af map() fungere. For at gøre det, vil vi definere en square() funktion og brug den som parameter for 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 hvis den eneste brug af vores square() funktion er at oprette denne liste, det er renere at bruge en lambda fungere:

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 er anonyme funktioner, der tager deres navn og syntaks fra Alonzo Church's Lambdaregning. Deres syntaks er:

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

Dette skaber en anonym funktion, der modtager variablerne som input x_1, ..., x_n og returnerer det vurderede expression(x_1, ..., x_n).
â € <
Med henblik på lambda funktioner skal bruges som parameter for funktioner, der accepterer funktioner som parameter, som vi gjorde med map() over. Python giver dig mulighed for at tildele en lambda funktion til en variabel, men PEP 8 stilguide fraråder det. Hvis du vil tildele en simpel funktion til en variabel, er det bedre at gøre det som en en-linje definition. Dette sikrer, at det resulterende objekt er korrekt navngivet, hvilket forbedrer sporbarheden:

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

Hvorfor bruge Lambda-funktioner?

Efter det sidste afsnit undrer du dig måske over, hvorfor du vil bruge en lambda fungere. Efter alt, hvad der kan gøres med en lambda funktion kunne udføres med en navngivet funktion.
â € <
Svaret på dette er det lambda funktion formål er at leve inde i større udtryk, der repræsenterer en beregning. En måde at tænke dette på er ved analogi med variabler og værdier. Overvej følgende kode:

x = 2

Variablen x er en pladsholder (eller et navn) for hele tallet 2. For eksempel at ringe print(x) , print(2) giver nøjagtig det samme output. I tilfælde af funktioner:

def square(x): return x**2

funktionen square() er en pladsholder til beregning af kvadrering af et tal. Denne beregning kan skrives på en navnløs måde som lambda x: x**2.
â € <
Efter denne filosofiske digression, lad os se nogle eksempler på applikationer til lambda funktioner.
â € <

Brug af Lambda med funktionen sorteret().

sorted() funktion sorterer en iterabel. Den accepterer en funktion som sin key argument, og resultatet af funktionen anvendt på hvert element i den iterable bruges til at ordne elementerne.
â € <
Dette er perfekt egnet til en lambda funktion: ved at indstille key parameter med en lambda funktion, kan vi sortere efter enhver form for attribut for elementerne. For eksempel kan vi sortere en liste over navne efter efternavn:

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

Brug af Lambda med 'filter()'-funktionen

filter() funktion har følgende syntaks: filter(function, iterable) og det udsender elementerne af iterable som vurderer function(element) som sandt (det ligner en WHERE klausul i SQL). Vi kan bruge lambda fungerer som parametre for filter() at vælge elementer fra en iterabel.

Overvej følgende eksempel:

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() anvender lambda funktion lambda x: (x % 3 == 0) and (x % 5 == 0) til hvert element af range(0,100), og returnerer en filter objekt. Vi får adgang til elementerne ved at støbe det som list.
â € <

Brug af Lambda med funktionen map()

â € <
Vores sidste eksempel er noget, vi har set i indledningen – den map() fungere. Det map() funktions syntaks er: map(function, iterable)og map() gælder function til hvert element af iterable, returnerer en map objekt, der kan tilgås ved casting til en list.

Vi har set, hvordan dette kan anvendes på lister, men det kan anvendes på diktater ved hjælp af dict.items() metode:

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 til en streng:

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

'cdefghi'

Vi kan bruge map() fungere på geniale måder – et eksempel er at anvende mange funktioner på det samme input.

Antag for eksempel, at du laver en API, der modtager en tekststreng, og du vil anvende en liste over funktioner til den.

Hver funktion uddrager nogle funktioner fra teksten. De funktioner, vi ønsker at udtrække, er antallet af ord, det andet ord og det fjerde bogstav i det fjerde ord:

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

â € <

Konklusion

â € <
I denne guide har vi undersøgt funktionaliteten af lambda funktioner i Python. Det har vi set lambda funktioner er anonyme funktioner, der skal bruges som en inline funktionsparameter for andre funktioner. Vi har set nogle use cases samt hvornår man ikke skal bruge dem.
â € <
Når du programmerer, er det vigtigt at huske Donald Knuths citat: "Programmer er beregnet til at blive læst af mennesker og kun tilfældigt for computere at udføre." Med det i tankerne, lambda funktioner er et nyttigt værktøj til at forenkle vores kode, men bør bruges med omtanke.