Python Lambdafunktioner med EKSEMPLER

Hvad er Lambda-funktionen i Python?

A 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 én linje. Ligesom en normal funktion kan en Lambda-funktion have flere argumenter med ét udtryk.

In Python, bruges lambda-udtryk (eller lambda-former) til at konstruere anonyme funktioner. For at gøre det skal du bruge lambda søgeord (ligesom du bruger def for at definere normale funktioner). Hver anonym funktion, du definerer i Python vil have 3 væsentlige dele:

• Lambda nøgleordet.
• Parametrene (eller bundne variabler), og
• Funktionslegemet.

En lambda-funktion kan have et hvilket som helst antal parametre, men funktionslegemet kan kun indeholde en udtryk. Desuden er en lambda skrevet i en enkelt kodelinje og kan også aktiveres med det samme. Du vil se alt dette i aktion i de kommende eksempler.

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, som sendes 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 (udtrykket) er et hvilket som helst gyldigt Python udtryk, der opererer på de parametre, du angiver til funktionen.

Eksempel 1

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

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

Code Forklaring

Her definerer vi en variabel, der vil holde resultatet returneret af lambda-funktionen.

1. Nøgleordet lambda bruges til at definere en anonym funktion.

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

3. Dette er kroppen af ​​funktionen, som tilføjer de 2 parametre, vi har passeret. 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å det grundlæggende og syntaksen i lambda. Lad os nu prøve at udskrive en lambda og se resultatet. Åbn igen din IDLE og indtast følgende:

#What a lambda returns
string='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å.

Output:

<function <lambda> at 0x00000185C3BF81E0>

Hvad sker der her? Lad os se på koden for at forstå det nærmere.

Code Forklaring:

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

2. Vi erklærer en lambda, der kalder en print-sætning og udskriver resultatet.

Men hvorfor udskriver programmet ikke den streng, vi sender? Dette skyldes, at lambda selv returnerer et funktionsobjekt. I dette eksempel udskrives lambda ikke. kaldet af printfunktionen, men er simpelthen vender tilbage funktionsobjektet og den hukommelsesplacering, hvor det er gemt. Det er det, der udskrives 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 kør den ved at trykke på F5, så ser du et output som dette.

Output:

some kind of a useless lambda

Nu kaldes lambdaen, og den streng, vi sender, udskrives i konsollen. Men hvad er den mærkelige syntaks, og hvorfor er lambda-definitionen dækket af parenteser? Lad os forstå det nu.

Code Forklaring:

1. Her er den samme streng, som vi definerede i det forrige eksempel.

2. I denne del definerer vi en lambda og kalder den med det samme ved at sende strengen som et argument. Dette kaldes en IIFE, og du vil lære mere om det i de kommende afsnit af denne vejledning.

Eksempel 4

Lad os se på et sidste eksempel for at forstå, hvordan lambdaer og almindelige funktioner udføres. Så åbn din IDLE og indtast følgende i en ny fil:

#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'))

Gem nu filen, og tryk på F5 for at køre programmet. Hvis du ikke har lavet nogen fejl, burde outputtet se sådan ud.

Output:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code Forklaring:

1. En funktion kaldet guru, der tager en anden funktion som den første parameter og eventuelle 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 return-sætningen.

4. I denne del kalder vi guru-funktionen og sender printerfunktionerne og en streng som parametre.

5. Dette er syntaksen til at udføre det fjerde trin (dvs. kald af guru-funktionen), men ved brug af lambdaer.

I næste afsnit lærer du, hvordan du bruger lambda-funktioner med kort(), reducere()og filter() in Python.

Bruger lambdas med Python indbyggede

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

IIFE ind Python Lambda

IIFE står for øjeblikkeligt påkaldt funktionsudførelse. Det betyder, at en lambda-funktion kan kaldes, så snart den er defineret. Lad os forstå dette med et eksempel; tænd din IDLE og indtast følgende:

 (lambda x: x + x)(2)

Her er output- og kodeforklaringen:

Denne lambdas evne til at blive påberåbt med det samme giver dig mulighed for at bruge dem i funktioner som map() og reduce(). Det er nyttigt, fordi du måske ikke ønsker at bruge disse funktioner igen.

lambdas i filter()

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

De elementer, der vil blive valgt, er baseret på en foruddefineret begrænsning. Det kræver 2 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]

Code Forklaring:

1. I den første sætning definerer vi en liste kaldet sekvenser, som 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 sand, hvis den er større end 4.

4. Udskriv resultatet returneret af filterfunktionen.

lambdas på kort()

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

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

For eksempel er her et program, der udskriver kvadraterne af 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))

Output:

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

Code Forklaring:

1. Her definerer vi en liste kaldet sekvenser, som indeholder nogle tal.

2. Vi deklarerer en variabel kaldet filtered_result, som vil gemme de mappede værdier.

3. En lambda-funktion, der kører på hvert element i listen og returnerer kvadratet af det pågældende tal.

4. Udskriv resultatet returneret af map-funktionen.

lambdas i reducere()

Reduceringsfunktionen, som map(), bruges til at anvende en operation på hvert element i en sekvens. Det adskiller sig dog fra kortet i sin funktion. Dette er trinene efterfulgt af reduce()-funktionen 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 kræver 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 reduce
sequences = [1,2,3,4,5]
product = reduce (lambda x, y: x*y, sequences)
print(product)

Her er output:

120

Code Forklaring:

1. Importer reduce fra functools-modulet.

2. Her definerer vi en liste kaldet sekvenser, som indeholder nogle tal.

3. Vi deklarerer en variabel kaldet produkt, som vil gemme den reducerede værdi.

4. En lambda-funktion, der kører på hvert element i listen. Den returnerer produktet af det pågældende tal som i det foregående resultat.

5. Udskriv resultatet returneret af reduce-funktionen.

Hvorfor (og hvorfor ikke) bruge lambda-funktioner?

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

Du bør dog vide, hvornår det er en god idé at bruge lambdaer, og hvornår du skal undgå dem. I dette afsnit lærer du nogle af de designprincipper, der anvendes af Python udviklere, når de skriver lambdaer.

Et af de mest almindelige anvendelsesscenarier for lambdaer er i funktionel programmering, da Python understøtter et paradigme (eller stil) af programmering kendt som funktionel programmering.

Det giver dig mulighed for at angive en funktion som en parameter til en anden funktion (f.eks. i et map, filter osv.). I sådanne tilfælde er brugen af ​​lambdas en elegant måde at oprette en engangsfunktion og overføre den som parameter.

Hvornår bør du ikke bruge Lambda?

Du bør aldrig skrive komplicerede lambda-funktioner i et produktionsmiljø. Det vil være meget svært 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 korrekt funktion. Som en bedste praksis skal du huske, at simpel kode altid er bedre end kompleks kode.

Lambdas vs. almindelige funktioner

Som tidligere nævnt er lambdaer blot funktioner, der ikke har en identifikator bundet til sig. Enklere sagt er de funktioner uden navne (og dermed anonyme). Her er en tabel, der illustrerer forskellen mellem lambdaer og almindelige funktioner i Python.

lambda x : x + x

def (x) :
return x + x 

Forklaring af forskellene

Den primære forskel mellem en lambda og en regulær funktion er, at lambda-funktionen kun evaluerer 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 almindelig funktion for ovenstående eksempel ville se sådan ud:

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

Her skal vi definere en navn for den funktion, som afkast resultatet når vi ringe det. En lambda-funktion indeholder ikke en return-sætning, fordi den kun har et enkelt udtryk, som altid returneres som standard. Du behøver ikke engang at tildele en lambda, da den kan kaldes med det samme (se det foregående afsnit). Som du vil se, bliver lambdaer særligt kraftfulde, når vi bruger dem med Python's indbyggede funktioner.

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

På bytekodeniveau håndteres de to definitioner på samme måde af Python fortolker. Nu kan du ikke navngive en funktion lambda fordi det er reserveret af Python, men ethvert andet funktionsnavn vil give den samme bytekode.

Ofte Stillede Spørgsmål