Python Lambda fungerer med EKSEMPLER

Innholdsfortegnelse:

Anonim

Hva er Lambda-funksjon i Python?

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

I Python brukes lambdauttrykk (eller lambda-former) til å konstruere anonyme funksjoner. For å gjøre det, vil du bruke lambda- nøkkelordet (akkurat som du bruker def for å definere normale funksjoner). Hver anonyme funksjon du definerer i Python vil ha tre viktige deler:

  • Nøkkelordet lambda.
  • Parametrene (eller bundne variabler), og
  • Funksjon kroppen.

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

I denne Lambda in Python-opplæringen lærer du:

  • Syntaks og eksempler
  • Bruke lambdas med Python-innebygde
  • lambdas i filter ()
  • lambdas i kart ()
  • lambdas i redusere ()
  • Hvorfor (og hvorfor ikke) bruke lambdafunksjoner?
  • Lambdas vs. vanlige funksjoner

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 overføres til lambda-funksjonen. Du kan legge til så mange eller få parametere som du trenger.

Vær imidlertid oppmerksom på at vi ikke bruker parenteser rundt parametrene slik vi gjør med vanlige funksjoner. Den siste delen (uttrykk) er et hvilket som helst gyldig pythonuttrykk som fungerer på parametrene du gir til funksjonen.

Eksempel 1

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

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

Her er utgangen:

3

Kode Forklaring

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

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

2. x og y er parametrene vi overfører til lambda-funksjonen.

3. Dette er funksjonen, som legger til de to parametrene 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 IDLE og skriv inn følgende:

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

Lagre filen din og trykk på F5 for å kjøre programmet. Dette er resultatet du bør få.

Produksjon:

 at 0x00000185C3BF81E0>

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

Kode Forklaring

  1. Her definerer vi en streng som du vil sende som parameter til lambda.
  2. Vi erklærer en lambda som kaller en utskrift og skriver ut resultatet.

Men hvorfor skriver ikke programmet ut strengen vi sender? Dette er fordi lambda selv returnerer et funksjonsobjekt. I dette eksemplet er lambda ikke blir kalt av utskriftsfunksjonen, men rett og slett tilbake til funksjonen objektet og minneplassen hvor det er lagret. Det er det som blir skrevet ut på konsollen.

Eksempel 3

Men hvis du skriver et program som dette:

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

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

Produksjon:

some kind of a useless lambda

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

Kode Forklaring

  1. Her er den samme strengen 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 lambdas og vanlige funksjoner utføres. Så åpne din IDLE og skriv inn følgende i en ny fil:

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

Lagre filen nå og trykk på F5 for å kjøre programmet. Hvis du ikke gjorde noen feil, skulle produksjonen være noe som dette.

Produksjon:

skriver 1 VANLIG SAMTALE

skriver 2 VANLIG SAMTALE

skriver 1 LAMBDA CALL

skriver 2 LAMBDA CALL

Kode Forklaring

  1. En funksjon kalt guru som tar en annen funksjon som den første parameteren og 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 ligner printer_one, men uten returoppgaven.
  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 gurufunksjonen), men bruke lambdas.

I neste avsnitt vil du lære hvordan du bruker lambdafunksjoner med map (), redusere () og filter () i Python.

Bruke lambdas med Python-innebygde

Lambda-funksjoner gir en elegant og kraftig måte å utføre operasjoner med innebygde metoder i Python. Det er mulig fordi lambdas kan påberopes umiddelbart og sendes som et argument til disse funksjonene.

IIFE i Python Lambda

IIFE står for umiddelbart påkalt funksjonskjøring. 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 kode forklaring:

Denne evnen til å påberope lambdas umiddelbart kan du bruke dem i funksjoner som map () og redusere (). Det er nyttig fordi du kanskje ikke vil bruke disse funksjonene igjen.

lambdas i filter ()

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

Elementene som skal velges er basert på noen forhåndsdefinerte begrensninger. Det tar to parametere:

  • En funksjon som definerer filtreringsbegrensningen
  • En sekvens (hvilken som helst 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]

Kode Forklaring:

1. I den første uttalelsen 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 true hvis den er større enn 4.

4. Skriv ut resultatet som returneres av filterfunksjonen.

lambdas i kart ()

kartfunksjonen brukes til å bruke en bestemt operasjon på hvert element i en sekvens. Som filter () tar det også to parametere:

  1. En funksjon som definerer op til å utføre på elementene
  2. Én eller flere sekvenser

Her er for eksempel et program som skriver ut kvadratene med 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))

Produksjon:

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

[KR1]

Kode Forklaring:

  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 til tallet.
  4. Skriv ut resultatet som returneres av kartfunksjonen.

lambdas i redusere ()

Reduksjonsfunksjonen, som map (), brukes til å bruke en operasjon på hvert element i en sekvens. Imidlertid skiller det seg fra kartet når det fungerer. Dette er trinnene fulgt av redusere () -funksjonen for å beregne en utgang:

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 tar også to parametere:

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

Her er for eksempel et program som returnerer produktet av alle elementene i en liste:

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

Her er utgangen:

120

Kode Forklaring:

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

Hvorfor (og hvorfor ikke) bruke lambdafunksjoner?

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

Du bør imidlertid vite når det er lurt å bruke lambdas og når du skal unngå dem. I denne delen vil du lære noen av designprinsippene som brukes av pythonutviklere når du skriver lambdas.

En av de vanligste brukssakene for lambdas er i funksjonell programmering, ettersom Python støtter et paradigme (eller stil) for programmering, kjent som funksjonell programmering.

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

Når skal du ikke bruke Lambda?

Du bør aldri skrive kompliserte lambdafunksjoner i et produksjonsmiljø. Det vil være veldig vanskelig for kodere som vedlikeholder koden din å dekryptere den. Hvis du finner ut at du lager komplekse uttrykk med en linje, ville det være en mye bedre praksis å definere en riktig funksjon. Som en god praksis må du huske at enkel kode alltid er bedre enn kompleks kode.

Lambdas vs. vanlige funksjoner

Som tidligere nevnt er lambdas [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 lambdas og vanlige funksjoner i python.

Lambdas

Vanlige funksjoner

Syntaks:

lambda x : x + x

Syntaks:

def (x) :return x + x

Lambda-funksjoner kan bare ha ett uttrykk i kroppen.

Vanlige funksjoner kan ha flere uttrykk og utsagn i kroppen.

Lambdas har ikke noe 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 returneres automatisk.

Funksjoner som trenger å returnere verdi bør inneholde en returoppgave.

Forklaring på forskjellene?

Den primære forskjellen mellom en lambda og en vanlig funksjon er at lambda-funksjonen bare evaluerer et enkelt uttrykk og gir et funksjonsobjekt. Derfor kan vi navngi resultatet av lambda-funksjonen og bruke det i vårt program som vi gjorde i forrige eksempel.

En vanlig funksjon for eksemplet ovenfor vil se slik ut:

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

Her må vi definere et navn på funksjonen som returnerer resultatet når vi kaller det. En lambda-funksjon inneholder ikke en returuttalelse fordi den bare har et enkelt uttrykk som alltid returneres som standard. Du trenger ikke engang å tildele en lambda heller, da den umiddelbart kan påberopes (se neste avsnitt). Som du vil se i eksemplet nedenfor, blir lambdas spesielt kraftige når vi bruker dem med Pythons innebygde funksjoner.

Du kan imidlertid fortsatt lure på hvordan lambdas er forskjellig fra en funksjon som returnerer et enkelt uttrykk (som det ovenfor). På tolknivå er det ikke så stor forskjell. Det høres kanskje overraskende ut, men enhver lambda-funksjon som du definerer i Python blir behandlet som en normal funksjon av tolken.

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

Sammendrag

  • Lambdas, 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:
  • Nøkkelordet lambda.
  • Parametrene (eller bundne variabler), og
  • Funksjon kroppen.
  • Syntaksen for å skrive en lambda er: lambda-parameter: uttrykk
  • Lambdas kan ha et hvilket som helst antall parametere, men de er ikke lukket i bukseseler
  • En lambda kan bare ha ett uttrykk i funksjonsdelen, som returneres som standard.
  • På bytecode-nivå er det ikke mye forskjell på hvordan lambdas og vanlige funksjoner håndteres av tolk.
  • Lambdas støtter IIFE gjennom denne syntaksen: (lambda parameter: expression) (argument)
  • Lambdas brukes ofte med følgende innebygde python:
  • Filter: filter (lambda-parameter: uttrykk, iterabel-sekvens)
  • Kart: kart (lambda-parameter: uttrykk, iterable-sekvenser)
  • Reduser: reduser (lambda parameter1, parameter2: uttrykk, iterabel-sekvens)
  • Ikke skriv kompliserte lambdafunksjoner i et produksjonsmiljø fordi det vil være vanskelig for kodeholdere.

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