Python Lambdafunksjoner med EKSEMPLER

Hva er Lambda-funksjonen i Python?

A Lambdafunksjon i Python programmering er en anonym funksjon eller en funksjon uten navn. Det er en liten og begrenset funksjon som ikke har mer enn én linje. Akkurat som en vanlig funksjon, kan en Lambda-funksjon ha flere argumenter med ett uttrykk.

In Python, lambda-uttrykk (eller lambda-former) brukes til å konstruere anonyme funksjoner. For å gjøre det, bruker du lambda nøkkelord (akkurat som du bruker def for å definere normale funksjoner). Hver anonym funksjon du definerer i Python vil ha 3 viktige deler:

• Lambda-stikkordet.
• Parametrene (eller bundne variabler), og
• Funksjonskroppen.

En lambda-funksjon kan ha et hvilket som helst antall parametere, men funksjonskroppen kan bare inneholde en uttrykk. Dessuten er en lambda skrevet i en enkelt kodelinje og kan også påkalles umiddelbart. Du vil se alt dette i aksjon i de kommende eksemplene.

Syntaks og eksempler

Den formelle syntaksen for å skrive en lambda-funksjon er som gitt nedenfor:

lambda p1, p2: expression

Her er p1 og p2 parametrene som sendes til lambda-funksjonen. Du kan legge til så mange eller få parametere du trenger.

Merk imidlertid at vi ikke bruker parenteser rundt parameterne slik vi gjør med vanlige funksjoner. Den siste delen (uttrykket) er et hvilket som helst gyldig Python uttrykk som opererer på parametrene du oppgir til funksjonen.

Eksempel 1

Nå som du vet om lambda, la oss prøve det med et eksempel. Så åpne din IDLE og skriv inn følgende:

adder = lambda x, y: x + y
print (adder (1, 2))

Code Forklaring

Her definerer vi en variabel som vil holde resultatet returnert av lambda-funksjonen.

1. Lambda-nøkkelordet som brukes til å definere en anonym funksjon.

2. x og y er parameterne som vi sender til lambda-funksjonen.

3. Dette er hoveddelen av funksjonen, som legger til de 2 parameterne vi passerte. Legg merke til at det er et enkelt uttrykk. Du kan ikke skrive flere utsagn i kroppen til en lambda-funksjon.

4. Vi kaller funksjonen og skriver ut den returnerte verdien.

Eksempel 2

Det var et grunnleggende eksempel for å forstå det grunnleggende og syntaksen til lambda. La oss nå prøve å skrive ut en lambda og se resultatet. Åpne igjen IDLE og skriv inn følgende:

#What a lambda returns
string='some kind of a useless lambda'
print(lambda string : print(string))

Lagre nå filen og trykk F5 for å kjøre programmet. Dette er utgangen du bør få.

Utgang:

<function <lambda> at 0x00000185C3BF81E0>

Hva skjer her? La oss se på koden for å forstå det bedre.

Code Forklaring:

1. Her definerer vi en string som du vil sende som en parameter til lambdaen.

2. Vi deklarerer en lambda som kaller en print-setning og skriver ut resultatet.

Men hvorfor skriver ikke programmet ut strengen vi sender? Dette er fordi lambda-verdien i seg selv returnerer et funksjonsobjekt. I dette eksemplet blir ikke lambda-verdien som heter av utskriftsfunksjonen, men er ganske enkelt retur funksjonsobjektet og minneplasseringen der det er lagret. Det er det som skrives ut i konsollen.

Eksempel 3

Men hvis du skriver et program som dette:

#What a lambda returns #2
x="some kind of a useless lambda"
(lambda x : print(x))(x)

Og kjør den ved å trykke F5, så får du opp en utdata som dette.

Utgang:

some kind of a useless lambda

Nå kalles lambdaen, og strengen vi sender skrives ut i konsollen. Men hva er den rare syntaksen, og hvorfor er lambda-definisjonen dekket i parentes? La oss forstå det nå.

Code Forklaring:

1. Her er den samme strengen som vi definerte i forrige eksempel.

2. I denne delen definerer vi en lambda og kaller den umiddelbart ved å sende strengen som et argument. Dette kalles en IIFE, og du vil lære mer om det i de kommende delene av denne veiledningen.

Eksempel 4

La oss se på et siste eksempel for å forstå hvordan lambdaer og vanlige funksjoner utføres. Så, åpne din IDLE og i en ny fil, skriv inn følgende:

#A REGULAR FUNCTION
def guru( funct, *args ):
funct( *args )
def printer_one( arg ):
return print (arg)
def printer_two( arg ):
print(arg)
#CALL A REGULAR FUNCTION 
guru( printer_one, 'printer 1 REGULAR CALL' )
guru( printer_two, 'printer 2 REGULAR CALL \n' )
#CALL A REGULAR FUNCTION THRU A LAMBDA
guru(lambda: printer_one('printer 1 LAMBDA CALL'))
guru(lambda: printer_two('printer 2 LAMBDA CALL'))

Lagre nå filen og trykk F5 for å kjøre programmet. Hvis du ikke har gjort noen feil, skal resultatet være omtrent slik.

Utgang:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code Forklaring:

1. En funksjon kalt guru som tar en annen funksjon som den første parameteren og eventuelle andre argumenter som følger den.

2. printer_one er en enkel funksjon som skriver ut parameteren som sendes til den og returnerer den.

3. printer_two er lik printer_one, men uten retursetningen.

4. I denne delen kaller vi guru-funksjonen og sender skriverfunksjonene og en streng som parametere.

5. Dette er syntaksen for å oppnå det fjerde trinnet (dvs. kalle guru-funksjonen), men ved bruk av lambdaer.

I neste avsnitt lærer du hvordan du bruker lambda-funksjoner med kart(), redusere()og filter() in Python.

Bruker lambda med Python innebygde

Lambda-funksjoner gir en elegant og kraftig måte å utføre operasjoner ved hjelp av innebygde metoder Python. Det er mulig fordi lambdaer kan påkalles umiddelbart og sendes som et argument til disse funksjonene.

IIFE inn Python Lambda

IIFE står for umiddelbart påkalte funksjonsutførelse. Det betyr at en lambda-funksjon kan kalles så snart den er definert. La oss forstå dette med et eksempel; start opp IDLE og skriv inn følgende:

 (lambda x: x + x)(2)

Her er utdata- og kodeforklaringen:

Denne muligheten til lambdaer å bli påkalt umiddelbart lar deg bruke dem i funksjoner som map() og reduce(). Det er nyttig fordi du kanskje ikke vil bruke disse funksjonene igjen.

lambdas i filter()

Filterfunksjonen brukes til å velge enkelte elementer fra en sekvens av elementer. Sekvensen kan være hvilken som helst iterator som lister, sett, tupler, etc.

Elementene som blir valgt er basert på en forhåndsdefinert begrensning. Det kreves to parametere:

• En funksjon som definerer filtreringsbegrensningen
• En sekvens (enhver iterator som lister, tupler osv.)

For eksempel,

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = filter (lambda x: x > 4, sequences) 
print(list(filtered_result))

Her er utgangen:

[10, 8, 7, 5, 11]

Code Forklaring:

1. I den første setningen definerer vi en liste kalt sekvenser som inneholder noen tall.

2. Her erklærer vi en variabel kalt filtered_result, som vil lagre de filtrerte verdiene som returneres av filter()-funksjonen.

3. En lambda-funksjon som kjører på hvert element i listen og returnerer sann hvis den er større enn 4.

4. Skriv ut resultatet returnert av filterfunksjonen.

lambdas i kart()

Map-funksjonen brukes til å utføre en bestemt operasjon på hvert element i en sekvens. I likhet med filter() tar den også to parametere:

1. En funksjon som definerer operasjonen som skal utføres på elementene
2. En eller flere sekvenser

For eksempel, her er et program som skriver ut kvadratene av tall i en gitt liste:

sequences = [10,2,8,7,5,4,3,11,0, 1]
filtered_result = map (lambda x: x*x, sequences) 
print(list(filtered_result))

Utgang:

 [100, 4, 64, 49, 25, 16, 9, 121, 0, 1]

Code Forklaring:

1. Her definerer vi en liste kalt sekvenser som inneholder noen tall.

2. Vi deklarerer en variabel kalt filtered_result som vil lagre de tilordnede verdiene.

3. En lambda-funksjon som kjører på hvert element i listen og returnerer kvadratet av det tallet.

4. Skriv ut resultatet som returneres av kartfunksjonen.

lambdas i redusere()

Reduseringsfunksjonen, som map(), brukes til å bruke en operasjon på hvert element i en sekvens. Imidlertid skiller det seg fra kartet i sin virkemåte. Dette er trinnene etterfulgt av reduce()-funksjonen for å beregne en utdata:

Trinn 1) Utfør den definerte operasjonen på de to første elementene i sekvensen.

Trinn 2) Lagre dette resultatet.

Trinn 3) Utfør operasjonen med det lagrede resultatet og neste element i sekvensen.

Trinn 4) Gjenta til det ikke er flere elementer igjen.

Det krever også to parametere:

1. En funksjon som definerer operasjonen som skal utføres
2. En sekvens (enhver iterator som lister, tupler osv.)

For eksempel, her er et program som returnerer produktet av alle elementene i en liste:

from functools import reduce
sequences = [1,2,3,4,5]
product = reduce (lambda x, y: x*y, sequences)
print(product)

Her er utgangen:

120

Code Forklaring:

1. Importer reduce fra functools-modulen.

2. Her definerer vi en liste kalt sekvenser som inneholder noen tall.

3. Vi deklarerer en variabel kalt produkt som vil lagre den reduserte verdien.

4. En lambda-funksjon som kjører på hvert element i listen. Den vil returnere produktet av det tallet i henhold til forrige resultat.

5. Skriv ut resultatet som returneres av reduce-funksjonen.

Hvorfor (og hvorfor ikke) bruke lambda-funksjoner?

Som du vil se i neste avsnitt, behandles lambdaer på samme måte som vanlige funksjoner på tolknivå. På en måte kan du si at lambdaer gir kompakt syntaks for å skrive funksjoner som returnerer et enkelt uttrykk.

Du bør imidlertid vite når det er lurt å bruke lambdaer og når du bør unngå dem. I denne delen lærer du noen av designprinsippene som brukes av Python utviklere når de skriver lambdaer.

Et av de vanligste bruksområdene for lambdaer er i funksjonell programmering, som Python støtter et paradigme (eller stil) for programmering kjent som funksjonell programmering.

Den lar deg gi en funksjon som en parameter til en annen funksjon (for eksempel i kart, filter osv.). I slike tilfeller tilbyr bruk av lambdaer en elegant måte å opprette en engangsfunksjon og sende den som parameter.

Når bør du ikke bruke Lambda?

Du bør aldri skrive kompliserte lambdafunksjoner i et produksjonsmiljø. Det vil være svært vanskelig for kodere som vedlikeholder koden din å dekryptere den. Hvis du finner deg selv i å lage komplekse one-liner-uttrykk, ville det være en mye overlegen praksis å definere en riktig funksjon. Som en beste praksis må du huske at enkel kode alltid er bedre enn kompleks kode.

Lambdas vs. vanlige funksjoner

Som tidligere nevnt er lambdaer bare funksjoner som ikke har en identifikator bundet til seg. Enklere sagt er de funksjoner uten navn (derav anonyme). Her er en tabell som illustrerer forskjellen mellom lambdaer og vanlige funksjoner i Python.

lambda x : x + x

def (x) :
return x + x 

Forklaring av forskjellene

Den primære forskjellen mellom en lambda- og en vanlig funksjon er at lambda-funksjonen kun evaluerer et enkelt uttrykk og gir et funksjonsobjekt. Følgelig kan vi navngi resultatet av lambda-funksjonen og bruke den i programmet vårt som vi gjorde i forrige eksempel.

En vanlig funksjon for eksemplet ovenfor vil se slik ut:

def adder (x, y):
return x + y 
print (adder (1, 2))

Her må vi definere en navn for funksjonen som avkastning resultatet når vi ring den. En lambda-funksjon inneholder ikke en retursetning fordi den bare vil ha ett enkelt uttrykk som alltid returneres som standard. Du trenger ikke engang å tilordne en lambda heller, da den kan kalles umiddelbart (se forrige avsnitt). Som du vil se, blir lambdaer spesielt kraftige når vi bruker dem med Pythoninnebygde funksjoner.

Imidlertid lurer du kanskje fortsatt på hvordan lambdas er annerledes enn en funksjon som returnerer et enkelt uttrykk (som det ovenfor). På tolknivå er det ikke stor forskjell. Det høres kanskje overraskende ut, men hvilken som helst lambda-funksjon du definerer i Python behandles som en normal funksjon av tolken.

På bytekodenivå håndteres de to definisjonene på samme måte av Python tolk. Nå kan du ikke navngi en funksjon lambda fordi den er reservert av Python, men ethvert annet funksjonsnavn vil gi samme bytekode.

Spørsmål og svar