I denne veiledningen vil du utforske alle aspekter ved lambda-funksjoner i Python, fra hvordan du definerer dem til hvordan de kan brukes i forskjellige scenarier med praktiske kodeeksempler.
Lambda-funksjoner i Python er anonyme funksjoner som utmerker seg med en kortfattet struktur og kan benyttes sammen med flere innebygde funksjoner. Etter å ha gått gjennom denne veiledningen, vil du ha solid kunnskap om hvordan du lager lambda-funksjoner og når det er fordelaktig å foretrekke dem fremfor tradisjonelle Python-funksjoner.
La oss starte!
Python Lambda-funksjoner: Struktur og Eksempler
Her er den grunnleggende strukturen for å opprette en lambda-funksjon i Python:
lambda parameter(e): returverdi
I den generelle strukturen ovenfor:
- `lambda` er nøkkelordet som brukes til å definere en lambda-funksjon, etterfulgt av én eller flere parametere som funksjonen skal operere på.
- Et kolon skiller parameterne fra returverdien.
💡 Når du definerer en lambda-funksjon, er det viktig at returverdien beregnes ved å evaluere et uttrykk som er begrenset til en enkelt linje med kode. Dette vil bli tydeligere når vi ser på konkrete kodeeksempler.
Eksempler på Lambda-funksjoner i Python
Den mest effektive måten å forstå lambda-funksjoner på er å begynne med å konvertere vanlige Python-funksjoner til lambda-funksjoner.
👩🏽💻 Du kan skrive og teste koden i en Python REPL eller benytte en online Python-editor som tipsbilk.net.
#1. La oss vurdere følgende funksjon `kvadrat()`, som aksepterer et tall, `num`, som argument og returnerer kvadratet av tallet.
def kvadrat(num):
return num*num
Du kan kalle opp funksjonen med ulike argumenter for å sikre at den fungerer korrekt:
>>> kvadrat(9) 81 >>> kvadrat(12) 144
Man kan lagre dette lambda-uttrykket i en variabel, for eksempel `kvadrat1`, for en mer komprimert funksjonsdefinisjon: `kvadrat1 = lambda num: num*num`. Deretter kan funksjonen `kvadrat1` kalles med et valgfritt tall som argument. Likevel, siden lambda-funksjoner er anonyme, er det vanligvis best å unngå å tilordne dem til variabler.
For funksjonen `kvadrat()` er `num` parameteren og `num*num` er returverdien. Etter å ha identifisert disse, kan vi overføre dem til lambda-uttrykket og kalle det med et argument, slik:
>>> (lambda num: num*num)(2) 4
Dette er kjent som et «Immediately Invoked Function Expression», hvor en funksjon kalles umiddelbart etter at den er definert.
#2. La oss nå konvertere en annen enkel funksjon, `add()`, som aksepterer to tall, `num1` og `num2`, og returnerer summen av dem, `num1 + num2`.
def add(num1,num2):
return num1 + num2
La oss kalle `add()`-funksjonen med to tall som argumenter:
>>> add(4,3) 7 >>> add(12,5) 17 >>> add(12,6) 18
I dette tilfellet er `num1` og `num2` de to parameterne, og returverdien er `num1 + num2`.
>>> (lambda num1, num2: num1 + num2)(3,7) 10
Python-funksjoner kan også ta imot standardverdier for parametere. La oss endre definisjonen av `add()`-funksjonen og sette standardverdien for parameteren `num2` til 10.
def add(num1, num2=10):
return num1 + num2
I de følgende funksjonskallene:
- I det første kallet er verdien av `num1` lik 1, og verdien av `num2` er 3. Når verdien for `num2` sendes inn i funksjonskallet, benyttes den verdien; funksjonen returnerer 4.
- Dersom kun ett argument sendes inn (tallet 7 for `num1`), brukes standardverdien 10 for `num2`; funksjonen returnerer 17.
>>> add(1,3) 4 >>> add(7) 17
Ved bruk av funksjoner som aksepterer standardverdier for spesifikke parametere som lambda-uttrykk, kan du definere standardverdien under parameterdefinisjonen.
>>> (lambda num1, num2 = 10: num1 + num2)(1) 11
Når bør Lambda-funksjoner benyttes i Python?
Nå som du har fått en grunnleggende forståelse av lambda-funksjoner i Python, her er noen scenarioer der de kan være nyttige:
- Når du har en funksjon hvor returverdien er et enkelt uttrykk på én kodelinje og det ikke er behov for å henvise til funksjonen andre steder i samme modul, kan du benytte lambda-funksjoner. Vi har også sett på noen eksempler for å illustrere dette.
- Du kan bruke lambda-funksjoner i kombinasjon med innebygde funksjoner som `map()`, `filter()` og `reduce()`.
- Lambda-funksjoner kan være praktiske for å sortere datastrukturer i Python, som lister og ordbøker.
Slik bruker du Lambda-funksjoner i Python med Innebygde Funksjoner
1. Bruke Lambda med `map()`
`map()`-funksjonen aksepterer en iterabel og en funksjon, og anvender funksjonen på hvert element i iterabelen, som vist nedenfor:
La oss konstruere en liste kalt `nums` og benytte `map()`-funksjonen til å skape en ny liste som inneholder kvadratet av hvert tall i `nums`-listen. Merk bruken av lambda-funksjonen for å definere operasjonen for kvadrering.
>>> nums = [4,5,6,9] >>> list(map(lambda num:num*num,nums)) [16, 25, 36, 81]
Siden `map()`-funksjonen returnerer et kartobjekt, må vi konvertere det til en liste.
▶️ Sjekk ut denne veiledningen om `map()`-funksjonen i Python.
2. Bruke Lambda med `filter()`
La oss definere `tall`, en liste med tall:
>>> nums = [4,5,6,9]
Anta at du ønsker å filtrere denne listen og kun beholde oddetallene.
Du kan bruke Pythons innebygde `filter()`-funksjon.
`filter()`-funksjonen aksepterer en betingelse og en iterabel: `filter(betingelse, iterabel)`. Resultatet inkluderer kun de elementene fra den opprinnelige iterabelen som oppfyller betingelsen. Det returnerte objektet kan konverteres til en Python-iterabel, for eksempel en liste.
For å filtrere ut alle partall, beholder vi kun oddetallene. Derfor bør lambda-uttrykket være `lambda num: num%2!=0`. Uttrykket `num%2` gir resten når `num` deles på 2.
- `num%2!=0` er `True` når `num` er et oddetall, og
- `num%2!=0` er `False` når `num` er et partall.
>>> nums = [4,5,6,9] >>> list(filter(lambda num:num%2!=0,nums)) [5, 9]
3. Bruke Lambda med `reduce()`
`reduce()`-funksjonen aksepterer en iterabel og en funksjon. Den reduserer iterabelen ved å anvende funksjonen iterativt på elementene i den.
For å benytte `reduce()`-funksjonen, må du importere den fra Pythons innebygde `functools`-modul:
>>> from functools import reduce
La oss bruke `reduce()`-funksjonen for å beregne summen av alle tallene i tallisten. Vi definerer et lambda-uttrykk: `lambda num1,tall2:tall1+tall2`, som den reduserende summeringsfunksjonen.
Reduksjonsoperasjonen vil skje på denne måten: `f(f(f(4,5),6),9) = f(f(9,6),9) = f(15,9) = 24`. Her er `f` summeringsoperasjonen på to elementer i listen, som definert av lambda-funksjonen.
>>> from functools import reduce >>> nums = [4,5,6,9] >>> reduce(lambda num1,num2:num1+num2,nums) 24
Python Lambda-funksjoner for Tilpasset Sortering
I tillegg til å bruke lambda-funksjoner sammen med innebygde Python-funksjoner som `map()`, `filter()` og `reduce()`, kan du også benytte dem til å tilpasse innebygde funksjoner og metoder som brukes til sortering.
1. Sortering av Python-lister
Når du arbeider med Python-lister, er det ofte behov for å sortere dem basert på bestemte sorteringskriterier. For å sortere Python-lister på plass, kan du bruke den innebygde `sort()`-metoden på dem. Hvis du behøver en sortert kopi av listen, kan du benytte `sorted()`-funksjonen.
Syntaksen for bruk av Pythons `sorted()`-funksjon er `sorted(iterabel, key=…, reverse= True | False)`.
– `key`-parameteren brukes for å tilpasse sorteringen.
– `reverse`-parameteren kan settes til `True` eller `False`; standardverdien er `False`.
Ved sortering av lister med tall og strenger er standard sortering henholdsvis i stigende rekkefølge og alfabetisk rekkefølge. Av og til kan det være ønskelig å definere et tilpasset sorteringskriterium.
La oss se på følgende liste med frukt. Anta at du ønsker å generere en sortert kopi av listen. Du skal sortere strengene basert på antall forekomster av bokstaven «p» i dem – i synkende rekkefølge.
>>> fruits = ['apple','pineapple','grapes','mango']
Nå er det på tide å ta i bruk den valgfrie `key`-parameteren. En streng er en iterabel i Python, og for å finne antall forekomster av et tegn i den, kan du benytte den innebygde `.count()`-metoden. Dermed setter vi `key` til `lambda x:x.count(«p»)`, slik at sorteringen er basert på antall forekomster av bokstaven «p» i strengen.
>>> fruits = ['apple','pineapple','grapes','mango']
>>> sorted(fruits,key=lambda x:x.count('p'),reverse=True)
['pineapple', 'apple', 'grapes', 'mango']
I dette eksemplet:
- Sorteringsnøkkelen er antall forekomster av tegnet «p», og den er definert som et lambda-uttrykk.
- Siden vi har satt `reverse`-parameteren til `True`, skjer sorteringen i synkende rekkefølge basert på antall forekomster av «p».
I fruktlisten inneholder «ananas» 3 forekomster av «p», mens strengene «eple», «druer» og «mango» inneholder henholdsvis 2, 1 og 0 forekomster av «p».
Forstå Stabil Sortering
La oss betrakte et nytt eksempel. Med det samme sorteringskriteriet har vi redefinert fruktlisten. Her opptrer «p» i strengene «eple» og «druer» henholdsvis to ganger og én gang. Og det forekommer aldri i strengene «mango» og «melon».
>>> fruits = ['mango','apple','melon','grapes']
>>> sorted(fruits,key=lambda x:x.count('p'),reverse=True)
['apple', 'grapes', 'mango', 'melon']
I utdatalisten kommer «mango» før «melon», selv om ingen av dem har bokstaven «p». Men hvorfor er det slik? `sorted()`-funksjonen utfører en stabil sortering; når antallet «p» er likt for to strenger, opprettholdes rekkefølgen av elementene i den opprinnelige fruktlisten.
Som en rask øvelse, bytt plass på «mango» og «melon» i fruktlisten, sorter listen basert på samme kriterium, og observer resultatet.
▶️ Lær mer om sortering av Python-lister.
2. Sortering av en Python-ordbok
Du kan også bruke lambda-funksjoner når du sorterer Python-ordbøker. La oss se på den følgende ordboken `price_dict` som inneholder varer og deres priser.
>>> price_dict = {
... 'Milk':10,
... 'Honey':15,
... 'Bread':7,
... 'Candy':3
... }
For å konvertere nøkkelverdi-parene til en ordbok til en liste over tupler, kan du bruke den innebygde ordbokmetoden `.items()`:
>>> price_dict_items = price_dict.items()
dict_items([('Milk', 10), ('Honey', 15), ('Bread', 7), ('Candy', 3)])
I Python er alle iterabler, slik som lister, tupler, strenger og lignende, nullindekserte. Det betyr at det første elementet er på indeks 0, det andre elementet er på indeks 1, og så videre.
Vi vil gjerne sortere ordboken basert på verdien, altså prisen på hver vare. I hver tuppel i listen `price_dict_items` er prisen på varen i indeks 1. Derfor setter vi `key` til `lambda x:x[1]` da den vil bruke elementet på indeks 1 (prisen) til å sortere ordboken.
>>> dict(sorted(price_dict_items,key=lambda x:x[1]))
{'Candy': 3, 'Bread': 7, 'Milk': 10, 'Honey': 15}
I utdataene er ordbokelementene sortert i stigende rekkefølge basert på pris: fra «Candy» til 3 enheter til «Honey» til 15 enheter.
▶️ For å lære mer, se denne detaljerte veiledningen for sortering av en Python-ordbok etter nøkkel og verdi.
Oppsummering
Og der har du det! Du har lært hvordan du definerer lambda-funksjoner og bruker dem effektivt sammen med andre innebygde Python-funksjoner. Her er en oppsummering av de viktigste punktene:
- I Python er lambda-funksjoner anonyme funksjoner som kan akseptere flere argumenter og returnere en verdi; uttrykket som skal evalueres for å generere denne returverdien bør være en enkelt kodelinje. De kan benyttes for å gjøre små funksjonsdefinisjoner mer konsise.
- For å definere en lambda-funksjon bruker du syntaksen: `lambda parameter(e): returverdi`.
- Noen av de viktigste bruksområdene omfatter bruk av dem med `map()`, `filter()` og `reduce()` funksjoner, og som `key`-parameter for å tilpasse sortering av Python-iterabler.
Neste steg er å lære om heltallsdivisjon i Python.