I den här guiden kommer du att utforska alla aspekter av lambdafunktioner i Python, från deras syntax till praktiska tillämpningar med konkreta kodexempel.
Lambdafunktioner i Python är korta, anonyma funktioner som kan användas i kombination med flera inbyggda funktioner. Efter att ha gått igenom den här guiden kommer du att behärska konsten att skapa lambdafunktioner och veta när det är lämpligt att föredra dem framför vanliga Python-funktioner.
Låt oss sätta igång!
Python Lambda Funktion: Syntax och illustrationer
Den grundläggande strukturen för en lambdafunktion i Python ser ut så här:
lambda parameter(s):returvärde
I denna struktur:
- ’lambda’ är det reserverade ordet som används för att initiera en lambdafunktion, följt av en eller flera parametrar som funktionen tar emot.
- Ett kolon separerar parametrarna från det värde som returneras.
💡 När du skapar en lambdafunktion, tänk på att returvärdet beräknas från ett enda uttryck som ryms inom en kodrad. Vi kommer att klargöra detta genom exempel.
Python Lambda-funktion i praktiken
Det mest effektiva sättet att förstå lambdafunktioner är att omvandla standardmässiga Python-funktioner till lambdafunktioner.
👩🏽💻 Du kan följa exemplen i en Python REPL eller i en online Python-editor, som adminvista.com.
#1. Låt oss ta funktionen `square()`, som tar ett tal, `num`, och returnerar kvadraten av detta tal.
def square(num):
return num*num
Du kan testa funktionen med argument för att verifiera att den fungerar som förväntat.
>>> square(9) 81 >>> square(12) 144
Du kan lagra detta lambdauttryck i en variabel, till exempel `square1`, vilket gör funktionsdefinitionen mer kompakt: `square1 = lambda num: num*num`, och sedan anropa `square1`-funktionen med valfritt tal. Men eftersom lambdafunktioner är anonyma, bör vi undvika att tilldela dem till variabler.
I funktionen `square()` är `num` parametern och `num*num` är returvärdet. Med denna information kan vi integrera dem i ett lambda-uttryck och anropa det med ett argument:
>>> (lambda num: num*num)(2) 4
Detta koncept kallas omedelbart anropat funktionsuttryck, där vi anropar funktionen direkt efter att ha definierat den.
#2. Låt oss sedan omvandla en annan enkel funktion, `add()`, som tar två tal, `num1` och `num2`, och returnerar deras summa, `num1 + num2`.
def add(num1,num2):
return num1 + num2
Låt oss anropa funktionen `add()` med två tal som argument:
>>> add(4,3) 7 >>> add(12,5) 17 >>> add(12,6) 18
I detta fall är `num1` och `num2` de två parametrarna och `num1 + num2` är returvärdet.
>>> (lambda num1, num2: num1 + num2)(3,7) 10
Python-funktioner kan också ha standardvärden för parametrarna. Låt oss modifiera definitionen av `add()`-funktionen för att sätta standardvärdet för parametern `num2` till 10.
def add(num1, num2=10):
return num1 + num2
I följande funktionsanrop:
- I det första anropet är värdet på `num1` 1 och värdet på `num2` är 3. När du anger värdet för `num2` i anropet, används det; funktionen returnerar 4.
- Men om du bara anger ett argument (där `num1` är 7), används standardvärdet 10 för `num2`; funktionen returnerar 17.
>>> add(1,3) 4 >>> add(7) 17
När du skapar funktioner med standardvärden för vissa parametrar som lambda-uttryck, kan du ange standardvärdet samtidigt som du definierar parametrarna.
>>> (lambda num1, num2 = 10: num1 + num2)(1) 11
När bör du använda Lambda-funktioner i Python?
Nu när du förstår lambdafunktionerna i Python, här är några användningsområden:
- När du har en funktion vars returvärde är ett enkelt uttryck på en enda rad och du inte behöver referera till funktionen någon annanstans i din modul, är lambdafunktioner idealiska. Vi har även illustrerat detta med flera exempel.
- Du kan utnyttja lambdafunktioner när du använder inbyggda funktioner som `map()`, `filter()` och `reduce()`.
- Lambdafunktioner är också användbara för att sortera datastrukturer i Python som listor och ordlistor.
Hur man använder Python Lambda med inbyggda funktioner
1. Använda Lambda med `map()`
Funktionen `map()` tar en iterabel och en funktion, och applicerar funktionen på varje element i den iterabla:
Låt oss skapa en lista med siffror, `nums`, och använda `map()`-funktionen för att skapa en ny lista som innehåller kvadraten på varje tal i `nums`. Lägg märke till hur lambdafunktionen används för att definiera kvadreringsoperationen.
>>> nums = [4,5,6,9] >>> list(map(lambda num:num*num,nums)) [16, 25, 36, 81]
Eftersom `map()`-funktionen returnerar ett map-objekt, måste vi omvandla det till en lista.
▶️ Utforska mer om `map()`-funktionen i Python.
2. Använda Lambda med `filter()`
Låt oss definiera en lista med siffror, `nums`:
>>> nums = [4,5,6,9]
Antag att du vill filtrera den här listan och bara behålla de udda siffrorna.
Du kan använda Pythons inbyggda funktion `filter()`.
`filter()`-funktionen tar emot ett villkor och en iterabel: `filter(condition, iterable)`. Resultatet kommer att innehålla endast de element från den iterabla som uppfyller villkoret. Det returnerade objektet kan konverteras till en Python-iterabel, som en lista.
För att filtrera bort alla jämna tal behåller vi endast de udda talen. Lambda-uttrycket bör vara `lambda num: num%2!=0`. Uttrycket `num%2` ger resten när `num` divideras med 2.
- `num%2!=0` är `True` när `num` är udda.
- `num%2!=0` är `False` 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 en iterabel och en funktion. Den reducerar den iterabla genom att iterativt tillämpa funktionen på objekten i iterabeln.
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 listan `nums`. Vi definierar ett lambda-uttryck: `lambda num1,num2:num1+num2`, som den reducerande summan.
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, definierad av lambdafunktionen.
>>> from functools import reduce >>> nums = [4,5,6,9] >>> reduce(lambda num1,num2:num1+num2,nums) 24
Python Lambda-funktioner för anpassad sortering
Förutom att använda lambdafunktioner med inbyggda funktioner som `map()`, `filter()` och `reduce()`, kan du också 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 är det ofta nödvändigt att sortera dem baserat på specifika kriterier. Du kan använda den inbyggda `sort()`-metoden för att sortera en Python-lista på plats. Om du behöver en sorterad kopia av listan kan du använda funktionen `sorted()`.
Syntaxen för Pythons `sorted()`-funktion är `sorted(iterable, key=…,reverse= True | False)`.
– Parametern `key` används för att anpassa sorteringen.
– Parametern `reverse` kan sättas till `True` eller `False`; standardvärdet är `False`.
När du sorterar listor med siffror och strängar är standardsorteringen i stigande ordning respektive alfabetisk ordning. Men ibland kan det vara nödvändigt att definiera egna sorteringskriterier.
Tänk på följande lista med frukter. Anta att du vill ha en sorterad kopia av listan, där strängarna är sorterade efter antalet förekomster av bokstaven ”p” i fallande ordning.
>>> fruits = ['apple','pineapple','grapes','mango']
Det är här den valfria nyckelparametern kommer in i bilden. En sträng är en iterabel i Python, och för att räkna antalet förekomster av ett visst tecken kan du använda metoden `.count()`. Vi sätter nyckeln till `lambda x:x.count(’p’)` så att sorteringen baseras på hur många gånger ”p” visas i strängen.
>>> fruits = ['apple','pineapple','grapes','mango']
>>> sorted(fruits,key=lambda x:x.count('p'),reverse=True)
['pineapple', 'apple', 'grapes', 'mango']
I detta exempel:
- Nyckeln som används för sortering är antalet förekomster av tecknet ”p”, som definieras med ett lambda-uttryck.
- Eftersom `reverse`-parametern är satt till `True`, sker sorteringen i fallande ordning av antalet förekomster av ”p”.
I listan med frukter har ”ananas” 3 förekomster av ”p”, medan strängarna ”äpple”, ”druvor” och ”mango” har 2, 1 respektive 0 förekomster av ”p”.
Förstå stabil sortering
Låt oss betrakta ett annat exempel. Med samma sorteringskriterium har vi omdefinierat fruktlistan. Här förekommer ”p” i strängarna ”äpple” och ”druvor” två respektive en gång. Och den förekommer inte alls i ”mango” och ”melon”.
>>> fruits = ['mango','apple','melon','grapes']
>>> sorted(fruits,key=lambda x:x.count('p'),reverse=True)
['apple', 'grapes', 'mango', 'melon']
I den resulterande listan kommer ”mango” före ”melon” trots att ingen av dem innehåller bokstaven ”p”. Men varför är det så? Funktionen `sorted()` utför en stabil sortering; om antalet ”p” är lika för två strängar, behålls ordningen från den ursprungliga listan.
Som en snabb övning kan du byta plats på ”mango” och ”melon” i listan, sortera den med samma kriterium och observera resultatet.
▶️ Lär dig mer om att sortera Python-listor.
2. Sortera en Python-ordbok
Du kan också använda lambdafunktioner när du sorterar Python-ordböcker. Tänk på följande ordlista, `price_dict`, som innehåller varor och deras priser.
>>> price_dict = {
... 'Milk':10,
... 'Honey':15,
... 'Bread':7,
... 'Candy':3
... }
För att få nyckel-värdeparen från en ordlista som en lista med tupler kan du använda den inbyggda metoden `.items()`:
>>> price_dict_items = price_dict.items()
dict_items([('Milk', 10), ('Honey', 15), ('Bread', 7), ('Candy', 3)])
I Python är listor, tupler, strängar och andra iterablar nollindexerade. Så det första objektet finns på index 0, det andra objektet på index 1 och så vidare.
Vi vill sortera efter värdet, som är priset på varje vara i ordlistan. I varje tuppel i listan `price_dict_items` är varan på index 0 och priset på index 1. Därför sätter vi nyckeln till `lambda x:x[1]`, eftersom detta kommer att använda objektet på index 1, priset, för att sortera ordlistan.
>>> dict(sorted(price_dict_items,key=lambda x:x[1]))
{'Candy': 3, 'Bread': 7, 'Milk': 10, 'Honey': 15}
I utdata har elementen i ordlistan sorterats i stigande prisordning: från ”Candy” som kostar 3 enheter, till ”Honey” som kostar 15 enheter.
▶️ För mer information, läs denna detaljerade guide om att sortera en Python-ordbok efter nyckel och värde.
Sammanfattning
Och det var allt! Du har nu lärt dig hur man skapar lambdafunktioner och hur man effektivt använder dem med andra inbyggda Python-funktioner. Här är en sammanfattning av de viktigaste punkterna:
- Lambdafunktioner i Python är anonyma funktioner som kan ta flera argument och returnera ett värde; uttrycket som genererar returvärdet måste vara på en enda rad kod. De används för att göra korta funktionsdefinitioner mer koncisa.
- För att definiera en lambdafunktion använder du syntaxen: `lambda parameter(s): returvärde`.
- Några viktiga användningsområden inkluderar att använda dem med `map()`, `filter()` och `reduce()`-funktioner samt som nyckelparameter för att anpassa sorteringen av Python-iterablar.
Nästa steg är att lära dig hur man gör våningsindelning i Python.