Python Lambda fungerer med EKSEMPLER

Indholdsfortegnelse:

Anonim

Hvad er Lambda-funktion i Python?

En Lambda-funktion i Python- programmering er en anonym funktion eller en funktion uden navn. Det er en lille og begrænset funktion, der ikke har mere end en linje. Ligesom en normal funktion kan en Lambda-funktion have flere argumenter med et udtryk.

I Python bruges lambda-udtryk (eller lambda-former) til at konstruere anonyme funktioner. For at gøre dette bruger du lambda- nøgleordet (ligesom du bruger def til at definere normale funktioner). Hver anonym funktion, du definerer i Python, har 3 vigtige dele:

  • Nøgleordet lambda.
  • Parametrene (eller bundne variabler) og
  • Funktionskroppen.

En lambda-funktion kan have et vilkårligt antal parametre, men funktionselementet kan kun indeholde et udtryk. Desuden er en lambda skrevet i en enkelt kodelinje og kan også påberåbes med det samme. Du vil se alt dette i aktion i de kommende eksempler.

I denne Lambda in Python-tutorial lærer du:

  • Syntaks og eksempler
  • Brug af lambdas med Python-indbyggede
  • lambdas i filter ()
  • lambdas på kort ()
  • lambdas i reducere ()
  • Hvorfor (og hvorfor ikke) bruge lambdafunktioner?
  • Lambdas vs. regelmæssige funktioner

Syntaks og eksempler

Den formelle syntaks til at skrive en lambda-funktion er som angivet nedenfor:

lambda p1, p2: expression

Her er p1 og p2 de parametre, der overføres til lambda-funktionen. Du kan tilføje så mange eller få parametre, som du har brug for.

Bemærk dog, at vi ikke bruger parenteser omkring parametrene, som vi gør med almindelige funktioner. Den sidste del (udtryk) er ethvert gyldigt pythonudtryk, der fungerer på de parametre, du giver funktionen.

Eksempel 1

Nu hvor du kender til lambdas, lad os prøve det med et eksempel. Så åbn din IDLE og skriv følgende:

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

Her er output:

3

Kode Forklaring

Her definerer vi en variabel, der holder det resultat, der returneres af lambda-funktionen.

1. Lambda-nøgleordet bruges til at definere en anonym funktion.

2. x og y er de parametre, som vi overfører til lambda-funktionen.

3. Dette er selve funktionen, som tilføjer de 2 parametre, vi har bestået. Bemærk, at det er et enkelt udtryk. Du kan ikke skrive flere udsagn i kroppen af ​​en lambda-funktion.

4. Vi kalder funktionen og udskriver den returnerede værdi.

Eksempel 2

Det var et grundlæggende eksempel for at forstå lambdas grundlæggende og syntaks. Lad os nu prøve at udskrive en lambda og se resultatet. Åbn igen din IDLE og skriv følgende:

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

Gem nu din fil og tryk på F5 for at køre programmet. Dette er det output, du skal få.

Produktion:

 at 0x00000185C3BF81E0>

Hvad sker der her? Lad os se på koden for at forstå yderligere.

Kode Forklaring

  1. Her definerer vi en streng, som du sender som en parameter til lambda.
  2. Vi erklærer en lambda, der kalder en udskriftserklæring og udskriver resultatet.

Men hvorfor udskriver ikke programmet den streng, vi sender? Dette skyldes, at lambda selv returnerer et funktionsobjekt. I dette eksempel kaldes lambda ikke af udskrivningsfunktionen, men returnerer blot funktionsobjektet og hukommelsesplaceringen, hvor den er gemt. Det er det, der bliver trykt 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 kør det ved at trykke på F5, du vil se en output som denne.

Produktion:

some kind of a useless lambda

Nu kaldes lambda, og den streng, vi passerer, bliver trykt på konsollen. Men hvad er den underlige syntaks, og hvorfor er lambdadefinitionen dækket i parentes? Lad os forstå det nu.

Kode Forklaring

  1. Her er den samme streng, som vi definerede i det foregående eksempel.
  2. I denne del definerer vi en lambda og kalder den straks ved at sende strengen som et argument. Dette er noget, der kaldes en IIFE, og du lærer mere om det i de kommende afsnit af denne vejledning.

Eksempel 4

Lad os se på et sidste eksempel for at forstå, hvordan lambdas og regelmæssige funktioner udføres. Så åbn din IDLE og skriv i 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'))

Gem nu filen og tryk på F5 for at køre programmet. Hvis du ikke lavede nogen fejl, skulle output være sådan noget.

Produktion:

printer 1 REGULAR OPKALD

printer 2 REGULÆRT OPKALD

printer 1 LAMBDA-OPKALD

printer 2 LAMBDA-OPKALD

Kode Forklaring

  1. En funktion kaldet guru, der tager en anden funktion som den første parameter og andre argumenter, der følger den.
  2. printer_one er en simpel funktion, der udskriver den parameter, der sendes til den, og returnerer den.
  3. printer_two ligner printer_one, men uden returneringserklæringen.
  4. I denne del kalder vi gurufunktionen og sender printerfunktionerne og en streng som parametre.
  5. Dette er syntaksen for at opnå det fjerde trin (dvs. kalde gurufunktionen) men bruge lambdas.

I det næste afsnit lærer du, hvordan du bruger lambdafunktioner med map (), reducer () og filter () i Python.

Brug af lambdas med Python-indbyggede

Lambda-funktioner giver en elegant og kraftfuld måde at udføre operationer ved hjælp af indbyggede metoder i Python. Det er muligt, fordi lambdas kan påberåbes med det samme og sendes som et argument til disse funktioner.

IIFE i Python Lambda

IIFE står for øjeblikkelig påkaldt funktionskørsel. Det betyder, at en lambda-funktion kan kaldes, så snart den er defineret. Lad os forstå dette med et eksempel; affyr din tomgang og skriv følgende:

 (lambda x: x + x)(2)

Her er output og kode forklaring:

Denne evne til at påberåbe sig lambdas straks giver dig mulighed for at bruge dem inde i funktioner som map () og reducere (). Det er nyttigt, fordi du måske ikke vil bruge disse funktioner igen.

lambdas i filter ()

Filterfunktionen bruges til at vælge nogle bestemte elementer fra en række af elementer. Sekvensen kan være enhver iterator som lister, sæt, tupler osv.

De elementer, der vælges, er baseret på en foruddefineret begrænsning. Det tager to parametre:

  • En funktion, der definerer filtreringsbegrænsningen
  • 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]

Kode Forklaring:

1. I den første sætning definerer vi en liste kaldet sekvenser, der indeholder nogle tal.

2. Her erklærer vi en variabel kaldet filtered_result, som gemmer de filtrerede værdier, der returneres af filter () -funktionen.

3. En lambda-funktion, der kører på hvert element på listen og returnerer true, hvis den er større end 4.

4. Udskriv resultatet, der returneres af filterfunktionen.

lambdas på kort ()

kortfunktionen bruges til at anvende en bestemt operation på hvert element i en sekvens. Ligesom filter () tager det også to parametre:

  1. En funktion, der definerer det op, der skal udføres på elementerne
  2. En eller flere sekvenser

For eksempel er her et program, der udskriver kvadraterne med tal i en given liste:

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

Produktion:

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

[KR1]

Kode Forklaring:

  1. Her definerer vi en liste kaldet sekvenser, der indeholder nogle tal.
  2. Vi erklærer en variabel kaldet filtered_result, der gemmer de kortlagte værdier
  3. En lambda-funktion, der kører på hvert element på listen og returnerer kvadratet for dette nummer.
  4. Udskriv resultatet, der returneres af kortfunktionen.

lambdas i reducere ()

Funktionen reducere, som kort (), bruges til at anvende en operation på hvert element i en sekvens. Det adskiller sig imidlertid fra kortet, når det fungerer. Dette er trinene, der efterfølges af funktionen reducere () for at beregne et output:

Trin 1) Udfør den definerede operation på de første 2 elementer i sekvensen.

Trin 2) Gem dette resultat

Trin 3) Udfør operationen med det gemte resultat og det næste element i sekvensen.

Trin 4) Gentag, indtil der ikke er flere elementer tilbage.

Det tager også to parametre:

  1. En funktion, der definerer den operation, der skal udføres
  2. En sekvens (enhver iterator som lister, tupler osv.)

For eksempel er her et program, der returnerer produktet af alle elementer på en liste:

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

Her er output:

120

Kode Forklaring:

  1. Importreduktion fra funktionsværktøjsmodulet
  2. Her definerer vi en liste kaldet sekvenser, der indeholder nogle tal.
  3. Vi erklærer en variabel kaldet produkt, der gemmer den reducerede værdi
  4. En lambda-funktion, der kører på hvert element på listen. Det returnerer produktet af dette nummer i henhold til det foregående resultat.
  5. Udskriv resultatet, der returneres af reduceringsfunktionen.

Hvorfor (og hvorfor ikke) bruge lambdafunktioner?

Som du vil se i det næste afsnit, behandles lambdas det samme som almindelige funktioner på tolkeniveau. På en måde kan man sige, at lambdas giver kompakt syntaks til skrivefunktioner, der returnerer et enkelt udtryk.

Du skal dog vide, hvornår det er en god ide at bruge lambdas, og hvornår man skal undgå dem. I dette afsnit lærer du nogle af de designprincipper, der bruges af pythonudviklere, når de skriver lambdas.

En af de mest almindelige anvendelsestilfælde for lambdas er i funktionel programmering, da Python understøtter et paradigme (eller stil) for programmering, kendt som funktionel programmering.

Det giver dig mulighed for at give en funktion som parameter til en anden funktion (for eksempel i kort, filter osv.). I sådanne tilfælde tilbyder brug af lambdas en elegant måde at oprette en engangsfunktion på og videregive den som parameter.

Hvornår skal du ikke bruge Lambda?

Du bør aldrig skrive komplicerede lambdafunktioner i et produktionsmiljø. Det vil være meget vanskeligt for kodere, der vedligeholder din kode, at dekryptere den. Hvis du finder dig selv i at lave komplekse one-liner-udtryk, ville det være en meget overlegen praksis at definere en ordentlig funktion. Som en bedste praksis skal du huske, at enkel kode altid er bedre end kompleks kode.

Lambdas vs. regelmæssige funktioner

Som tidligere nævnt er lambdas [vV4] [J5] bare funktioner, der ikke har en identifikator bundet til sig. I enklere ord er de funktioner uden navne (dermed anonyme). Her er en tabel, der illustrerer forskellen mellem lambdas og regelmæssige funktioner i python.

Lambdas

Regelmæssige funktioner

Syntaks:

lambda x : x + x

Syntaks:

def (x) :return x + x

Lambda-funktioner kan kun have et udtryk i deres krop.

Regelmæssige funktioner kan have flere udtryk og udsagn i deres krop.

Lambdas har ikke et navn tilknyttet. Derfor er de også kendt som anonyme funktioner.

Almindelige funktioner skal have navn og signatur.

Lambdas indeholder ikke en returerklæring, fordi kroppen returneres automatisk.

Funktioner, der skal returnere værdi, skal omfatte en returerklæring.

Forklaring på forskellene?

Den primære forskel mellem en lambda og en regelmæssig funktion er, at lambda-funktionen kun vurderer et enkelt udtryk og giver et funktionsobjekt. Derfor kan vi navngive resultatet af lambda-funktionen og bruge det i vores program som vi gjorde i det foregående eksempel.

En regelmæssig funktion til ovenstående eksempel vil se sådan ud:

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

Her skal vi definere et navn til den funktion, der returnerer resultatet, når vi kalder det. En lambda-funktion indeholder ikke en returerklæring, fordi den kun har et enkelt udtryk, som altid returneres som standard. Du behøver ikke engang at tildele en lambda, da den straks kan påberåbes (se næste afsnit). Som du vil se i det følgende eksempel, bliver lambdas særlig kraftige, når vi bruger dem med Pythons indbyggede funktioner.

Du kan dog stadig undre dig over, hvordan lambdas adskiller sig fra en funktion, der returnerer et enkelt udtryk (som det ovenfor). På tolkeniveau er der ikke meget forskel. Det lyder måske overraskende, men enhver lambda-funktion, som du definerer i Python, behandles som en normal funktion af tolken.

Som du kan se i diagrammet håndteres de to definitioner på samme måde af pythontolken, når de konverteres til bytekode. Nu kan du ikke navngive en funktion lambda, fordi den er reserveret af Python, men ethvert andet funktionsnavn giver den samme bytecode [KR6].

Resumé

  • Lambdas, også kendt som anonyme funktioner, er små, begrænsede funktioner, som ikke har brug for et navn (dvs. en identifikator).
  • Hver lambda-funktion i Python har 3 vigtige dele:
  • Nøgleordet lambda.
  • Parametrene (eller bundne variabler) og
  • Funktionskroppen.
  • Syntaksen for at skrive en lambda er: lambda-parameter: udtryk
  • Lambdas kan have et vilkårligt antal parametre, men de er ikke lukket i seler
  • En lambda kan kun have 1 udtryk i sin funktionsdel, som returneres som standard.
  • På bytecode-niveau er der ikke meget forskel på, hvordan lambdas og almindelige funktioner håndteres af tolken.
  • Lambdas understøtter IIFE gennem denne syntaks: (lambda parameter: expression) (argument)
  • Lambdas bruges almindeligvis med følgende python-indbyggede:
  • Filter: filter (lambda-parameter: udtryk, iterabel-sekvens)
  • Kort: kort (lambda-parameter: udtryk, iterable-sekvenser)
  • Reducer: reducer (lambda parameter1, parameter2: udtryk, iterabel-sekvens)
  • Skriv ikke komplicerede lambda-funktioner i et produktionsmiljø, fordi det vil være vanskeligt for kodeholdere.

[J5] Jeg har tilføjet en tabel, men forklaringen er nødvendig for at forstå forskellene.