Hur man använder Lambda-funktioner i Python [With Examples]

I den här handledningen kommer du att lära dig allt om lambda-funktioner i Python – från syntaxen för att definiera lambda-funktioner till de olika användningsfallen med kodexempel.

I Python är lambdas anonyma funktioner som har en kortfattad syntax och kan användas med andra användbara inbyggda funktioner. I slutet av denna handledning har du lärt dig hur du definierar lambda-funktioner och när du bör överväga att använda dem över vanliga Python-funktioner.

Låt oss börja!

Python Lambda Funktion: Syntax och exempel

Här är den allmänna syntaxen för att definiera en lambda-funktion i Python:

lambda parameter(s):return value

I ovanstående allmänna syntax:

  • lambda är nyckelordet du ska använda för att definiera en lambdafunktion, följt av en eller flera parametrar som funktionen ska ta.
  • Det finns ett kolon som separerar parametrarna och returvärdet.

💡 När du definierar en lambdafunktion bör du se till att returvärdet beräknas genom att utvärdera ett uttryck som sträcker sig över en enda kodrad. Du kommer att förstå detta bättre när vi kodar exempel.

Python Lambda-funktionsexempel

Det bästa sättet att förstå lambda-funktioner är att börja med att skriva om vanliga Python-funktioner som lambda-funktioner.

👩🏽‍💻 Du kan koda med i en Python REPL eller i adminvista.com online Python-redigerare.

#1. Betrakta följande funktion square(), som tar in ett tal, num, som argument och returnerar kvadraten på talet.

def square(num):
    return num*num

Du kan anropa funktionen med argument och verifiera att den fungerar korrekt.

>>> square(9)
81
>>> square(12)
144

Du kan tilldela detta lambda-uttryck till ett variabelnamn, säg kvadrat1 för att göra funktionsdefinitionen mer kortfattad: kvadrat1 = lambdanummer: num*num och sedan anropa kvadrat1-funktionen med valfritt tal som argument. Vi vet dock att lambdas är anonyma funktioner, så du bör undvika att tilldela dem till en variabel.

För funktionen square() är parametern num och returvärdet är num*num. Efter att vi har identifierat dessa kan vi koppla in dem i lambda-uttrycket och kalla det med ett argument, som visas:

>>> (lambda num: num*num)(2)
4

Detta är konceptet för Immediately Invoked Function Expression, där vi anropar en funktion direkt efter att ha definierat den.

#2. Låt oss sedan skriva om en annan enkel funktion add() som tar in siffror, num1 och num2, och returnerar deras summa, num1 + num2.

def add(num1,num2):
    return num1 + num2

Låt oss kalla funktionen add() med två siffror som argument:

>>> add(4,3)
7
>>> add(12,5)
17
>>> add(12,6)
18

I det här fallet är num1 och num2 de två parametrarna och returvärdet är num1 + num2.

>>> (lambda num1, num2: num1 + num2)(3,7)
10

Python-funktioner kan också ta standardvärden för parametrar. Låt oss ändra definitionen av add()-funktionen och ställa in standardvärdet för parametern num2 till 10.

def add(num1, num2=10):
    return num1 + num2

I följande funktionsanrop:

  • I det första funktionsanropet är värdet på num1 1 och värdet på num2 är 3. När du skickar in värdet för num2 i funktionsanropet används det värdet; funktionen returnerar 4.
  • Men om du bara skickar in ett argument (num1 är 7), används standardvärdet 10 för num2; funktionen returnerar 17.
>>> add(1,3)
4
>>> add(7)
17

När du skriver funktioner som tar in standardvärden för vissa parametrar som lambda-uttryck, kan du ange standardvärdet när du definierar parametrarna.

>>> (lambda num1, num2 = 10: num1 + num2)(1)
11

När ska du använda Lambda-funktioner i Python?

Nu när du har lärt dig grunderna för lambda-funktioner i Python, här är några användningsfall:

  • När du har en funktion vars returuttryck är en enda kodrad och du inte behöver referera till funktionen någon annanstans i samma modul, kan du använda lambda-funktioner. Vi har också kodat några exempel för att förstå detta.
  • Du kan använda lambda-funktioner när du använder inbyggda funktioner, såsom map(), filter() och reduce().
  • Lambda-funktioner kan vara till hjälp för att sortera Python-datastrukturer som listor och ordböcker.

Hur man använder Python Lambda med inbyggda funktioner

1. Använda Lambda med map()

Map()-funktionen tar in en iterabel och en funktion och tillämpar funktionen på varje objekt i den iterable, som visas:

Låt oss skapa en nums-lista och använda map()-funktionen för att skapa en ny lista som innehåller kvadraten på varje tal i nums-listan. Lägg märke till användningen av lambdafunktionen för att definiera kvadreringen.

>>> nums = [4,5,6,9]
>>> list(map(lambda num:num*num,nums))
[16, 25, 36, 81]

Eftersom map()-funktionen returnerar ett kartobjekt bör vi kasta det till en lista.

▶️ Kolla in den här handledningen om map()-funktionen i Python.

2. Använda Lambda med filter()

Låt oss definiera nums, en lista med siffror:

>>> nums = [4,5,6,9]

Anta att du vill filtrera den här listan och bara behålla de udda siffrorna.

Du kan använda Pythons inbyggda filter()-funktion.

Filter()-funktionen tar in ett villkor och en iterabel: filter(condition, iterable). Resultatet innehåller endast de element i den ursprungliga iterable som uppfyller villkoret. Du kan casta det returnerade objektet till en Python iterable såsom lista.

För att filtrera bort alla jämna nummer behåller vi endast de udda talen. Så lambda-uttrycket bör vara lambda num: num%2!=0. Kvantiteten num%2 är resten när num divideras med 2.

  • num%2!=0 är sant när num är udda, och
  • num%2!=0 är falskt när num är jämnt.
>>> nums = [4,5,6,9]
>>> list(filter(lambda num:num%2!=0,nums))
[5, 9]

3. Använda Lambda med reduce()

Funktionen reduce() tar in en iterabel och en funktion. Det minskar det iterbara genom att applicera funktionen iterativt på objekten i det iterbara.

För att använda reduce()-funktionen måste du importera den från Pythons inbyggda functools-modul:

>>> from functools import reduce

Låt oss använda reduce()-funktionen för att beräkna summan av alla tal i nums-listan. Vi definierar ett lambdauttryck: lambda num1,num2:num1+num2, som den reducerande summafunktionen.

Reduktionsoperationen kommer att ske så här: f(f(f(4,5),6),9) = f(f(9,6),9) = f(15,9) = 24. Här är f summeringsoperationen för två poster i listan, definierade av lambdafunktionen.

>>> from functools import reduce
>>> nums = [4,5,6,9]
>>> reduce(lambda num1,num2:num1+num2,nums)
24

Python Lambda-funktioner för att anpassa sortering

Förutom att använda lambda-funktioner med inbyggda Python-funktioner, såsom map(), filter() och reduce(), kan du även använda dem för att anpassa inbyggda funktioner och metoder som används för sortering.

1. Sortera Python-listor

När du arbetar med Python-listor måste du ofta sortera dem utifrån vissa sorteringskriterier. För att sortera Python-listor på plats kan du använda den inbyggda sort()-metoden på dem. Om du behöver en sorterad kopia av listan kan du använda sortered()-funktionen.

Syntaxen för att använda Pythons sorted()-funktion är sorterad(iterable, key=…,reverse= True | False).

– Nyckelparametern används för att anpassa sorteringen.
– Den omvända parametern kan ställas in på True eller False; standardvärdet är False.

Vid sortering av listor med nummer och strängar är standardsortering i stigande ordning respektive alfabetisk ordning. Men du kanske ibland vill definiera något anpassat kriterium för sortering.

Tänk på följande frukter. Anta att du vill få en sorterad kopia av listan. Du bör sortera strängarna efter antalet förekomster av ’p’ i dem – i fallande ordning.

>>> fruits = ['apple','pineapple','grapes','mango']

Det är dags att använda den valfria nyckelparametern. En sträng är en iterabel i Python och för att få fram antalet förekomster av ett tecken i den kan du använda den inbyggda .count()-metoden. Så vi sätter nyckeln till lambda x:x.count(’p’) så att sorteringen baseras på antalet gånger ’p’ förekommer i strängen.

>>> fruits = ['apple','pineapple','grapes','mango']
>>> sorted(fruits,key=lambda x:x.count('p'),reverse=True)
['pineapple', 'apple', 'grapes', 'mango']

I det här exemplet:

  • Nyckeln att sortera på är antalet förekomster av tecknet ’p’, och det definieras som ett lambda-uttryck.
  • Eftersom vi har satt den omvända parametern till True, sker sorteringen i minskande ordning av antalet förekomster av ’p’.

I fruktlistan innehåller ’ananas’ 3 förekomster av ’p’ och strängarna ’äpple’, ’druvor’ och ’mango’ innehåller 2, 1 respektive 0 förekomster av ’p’.

Förstå stabil sortering

Tänk på ett annat exempel. För samma sorteringskriterium har vi omdefinierat fruktlistan. Här förekommer ’p’ i strängarna ’äpple’ och ’druvor’ två gånger respektive en gång. Och det förekommer aldrig i strängarna ’mango’ och ’melon’.

>>> fruits = ['mango','apple','melon','grapes']
>>> sorted(fruits,key=lambda x:x.count('p'),reverse=True)
['apple', 'grapes', 'mango', 'melon']

I utgångslistan kommer ’mango’ före ’melon’ även om de båda inte har tecknet ’p’. Men varför är det så? Funktionen sorted() utför en stabil sortering; så när antalet ’p’ är lika för två strängar, bevaras ordningen på elementen i den ursprungliga fruktlistan.

Som en snabb övning kan du byta positionerna för ’mango’ och ’melon’ i fruktlistan, sortera listan utifrån samma kriterium och observera resultatet.

▶️ Lär dig mer om att sortera Python-listor.

2. Sortera en Python-ordbok

Du kan också använda lambdas när du sorterar Python-ordböcker. Tänk på följande ordbok price_dict som innehåller artiklar och deras priser.

>>> price_dict = {
... 'Milk':10,
... 'Honey':15,
... 'Bread':7,
... 'Candy':3
... }

För att få nyckel-värdeparen i en ordbok som en lista över tupler kan du använda den inbyggda ordboksmetoden .items():

>>> price_dict_items = price_dict.items()
dict_items([('Milk', 10), ('Honey', 15), ('Bread', 7), ('Candy', 3)])

I Python följer alla iterables: listor, tupler, strängar och mer nollindexering. Så den första posten är vid index 0, den andra posten är vid index 1, och så vidare.

Vi skulle vilja sortera efter värdet, vilket är priset för varje artikel i ordboken. I varje tuppel i listan price_dict_items är artikeln i index 1 priset. Så vi satte nyckeln till lambda x:x[1] eftersom det kommer att använda objektet i index 1, priset, för att sortera ordboken.

>>> dict(sorted(price_dict_items,key=lambda x:x[1]))
{'Candy': 3, 'Bread': 7, 'Milk': 10, 'Honey': 15}

I utgången har ordboksartiklarna sorterats i stigande ordningsföljd av priser: börjar med ”Candy”, prissatt till 3 enheter till ”Honey”, prissatt till 15 enheter.

▶️ För att lära dig mer, kolla in den här detaljerade guiden om att sortera en Python-ordbok efter nyckel och värde.

Summering

Och där har du det! Du har lärt dig hur du definierar lambda-funktioner och använder dem effektivt med andra inbyggda Python-funktioner. Här är en sammanfattning av de viktigaste takeaways:

  • I Python är lambdas anonyma funktioner som kan ta in flera argument och returnera ett värde; uttrycket som ska utvärderas för att generera detta returvärde bör vara en rad kod. De kan användas för att göra små funktionsdefinitioner mer koncisa.
  • För att definiera lambdafunktionen kan du använda syntaxen: lambda parameter(s): returvärde.
  • Några av de viktiga användningsfallen inkluderar att använda dem med map(), filter() och reduce() funktioner och som nyckelparameter för att anpassa sorteringen av Python iterables.

Lär dig sedan hur du utför våningsindelning i Python.