Python Lambdafunksjoner med EKSEMPLER

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.

Vær imidlertid oppmerksom på at vi ikke bruker parentes rundt parametrene slik vi gjør med vanlige funksjoner. Den siste delen (uttrykket) er et hvilket som helst gyldig python-uttrykk som opererer på parameterne 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))

Her er utgangen:

3

Kode 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. Igjen, åpne din 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å ytterligere.

Kode Forklaring

1. Her definerer vi en string som du sender som en parameter til lambdaen.
2. Vi erklærer en lambda som kaller en utskriftserklæring og skriver ut resultatet.

Men hvorfor skriver ikke programmet ut strengen vi passerer? Dette er fordi lambdaen selv returnerer et funksjonsobjekt. I dette eksemplet blir ikke lambdaen som heter ved utskriftsfunksjonen, men ganske enkelt retur funksjonsobjektet og minnestedet der det er lagret. Det er det som skrives ut på 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, du vil se en utgang som dette.

Utgang:

some kind of a useless lambda

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

Kode 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 er noe som kalles en IIFE, og du vil lære mer om det i de kommende delene av denne opplæringen.

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 filen og trykk F5 for å kjøre programmet. Hvis du ikke har gjort noen feil, bør utgangen være noe sånt som dette.

Utgang:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Kode Forklaring

1. En funksjon kalt guru som tar en annen funksjon som den første parameteren og eventuelle andre argumenter etter den.
2. printer_one er en enkel funksjon som skriver ut parameteren som er sendt til den og returnerer den.
3. printer_two ligner på 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 å bruke lambdas.

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; fyr opp din 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 vil bli valgt er basert på en forhåndsdefinert begrensning. Det tar 2 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 output:

[10, 8, 7, 5, 11]

Kodeforklaring:

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

kartfunksjonen brukes til å bruke en bestemt operasjon på hvert element i en sekvens. Som filter(), tar det også 2 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]

[KR1]

Kodeforklaring:

1. Her definerer vi en liste kalt sekvenser som inneholder noen tall.
2. Vi erklærer 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 returnert 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

Kodeforklaring:

1. Importer redusere fra functools-modulen
2. Her definerer vi en liste kalt sekvenser som inneholder noen tall.
3. Vi erklærer en variabel kalt produkt som vil lagre den reduserte verdien
4. En lambda-funksjon som kjører på hvert element i listen. Det vil returnere produktet av det nummeret i henhold til forrige resultat.
5. Skriv ut resultatet returnert av reduseringsfunksjonen.

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 en god idé å bruke lambdaer og når du bør unngå dem. I denne delen vil du lære noen av designprinsippene som brukes av python-utviklere når de skriver lambdaer.

En av de vanligste brukssakene 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 lambdaer en elegant måte å lage 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[vV4][J5] bare funksjoner som ikke har en identifikator bundet til seg. Med enklere ord er de funksjoner uten navn (derav anonyme). Her er en tabell for å illustrere forskjellen mellom lambdaer og vanlige funksjoner i python.

Lambdas

Vanlige funksjoner

Syntaks:

lambda x : x + x

Syntaks:

def (x) :
return x + x 

Lambdafunksjoner kan bare ha ett uttrykk i kroppen.

Regulære funksjoner kan ha flere uttrykk og utsagn i kroppen.

Lambdaer har ikke et navn knyttet til seg. Derfor er de også kjent som anonyme funksjoner.

Vanlige funksjoner må ha navn og signatur.

Lambdas inneholder ikke en returerklæring fordi kroppen automatisk returneres.

Funksjoner som må returnere verdi bør inkludere en returerklæring.

Forklaring på 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 et enkelt uttrykk som alltid returneres som standard. Du trenger ikke engang å tilordne en lambda da den kan påkalles umiddelbart (se neste avsnitt). Som du vil se i følgende eksempel, 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.

Som du kan se i diagrammet, håndteres de to definisjonene på samme måte av python-tolken når de konverteres til bytekode. Nå kan du ikke navngi en funksjon lambda fordi den er reservert av Python, men et hvilket som helst annet funksjonsnavn vil gi samme bytekode[KR6].

Sammendrag

• Lambdaer, også kjent som anonyme funksjoner, er små, begrensede funksjoner som ikke trenger et navn (dvs. en identifikator).
• Hver lambdafunksjon i Python har 3 viktige deler:
• Lambda-stikkordet.
• Parametrene (eller bundne variabler), og
• Funksjonskroppen.
• Syntaksen for å skrive en lambda er: lambda parameter: uttrykk
• Lambdaer kan ha et hvilket som helst antall parametere, men de er ikke innelukket i klammeparenteser
• En lambda kan bare ha 1 uttrykk i funksjonskroppen, som returneres som standard.
• På bytekodenivå er det ikke stor forskjell på hvordan lambdaer og vanlige funksjoner håndteres av tolken.
• Lambdaer støtter IIFE gjennom denne syntaksen: (lambda-parameter: uttrykk) (argument)
• Lambdaer brukes ofte med følgende python innebygde:
• Filter: filter (lambda-parameter: uttrykk, iterable-sequence)
• Kart: kart (lambda-parameter: uttrykk, iterable-sekvenser)
• Reduser: reduser (lambda parameter1, parameter2: expression, iterable-sequence)
• Ikke skriv kompliserte lambdafunksjoner i et produksjonsmiljø fordi det vil være vanskelig for kodevedlikeholdere.

[J5]Jeg har lagt til en tabell, men forklaringen er nødvendig for å forstå forskjellene.

Denne koden er redigerbar. Klikk Kjør for å kjøre