Python Lambdafunktioner med EKSEMPLER

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 (udtryk) er ethvert gyldigt pythonudtryk, 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))

Her er output:

3

Kode 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 på at forstå lambdas grundlæggende principper og syntaks. Lad os nu prøve at printe en lambda ud 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å yderligere.

Kode Forklaring

1. Her definerer vi en streng som du vil videregive som en parameter til lambdaen.
2. Vi erklærer en lambda, der kalder en print-erklæring og udskriver resultatet.

Men hvorfor udskriver programmet ikke den streng, vi passerer? Dette skyldes, at lambdaen selv returnerer et funktionsobjekt. I dette eksempel bliver lambdaen ikke kaldet ved printfunktionen, men ganske enkelt vender tilbage funktionsobjektet og hukommelsesstedet, hvor det er gemt. Det er det, der bliver udskrevet 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 kør det ved at trykke på F5, du vil se et output som dette.

Output:

some kind of a useless lambda

Nu bliver lambdaen kaldt, og den streng, vi passerer, bliver trykt ved konsollen. Men hvad er den mærkelige syntaks, og hvorfor er lambda-definitionen 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 vil lære mere om det i de kommende afsnit af denne øvelse.

Eksempel 4

Lad os se på et sidste eksempel for at forstå, hvordan lambdaer og almindelige funktioner udføres. Så åben 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 lavede nogen fejl, skulle outputtet være noget som dette.

Output:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Kode Forklaring

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

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; fyr op for 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]

Kodeforklaring:

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

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

1. En funktion, der definerer den operation, 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]

[KR1]

Kodeforklaring:

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

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

Kodeforklaring:

1. Importer reducere fra functools-modulet
2. Her definerer vi en liste kaldet sekvenser, som indeholder nogle tal.
3. Vi erklærer en variabel kaldet produkt, som vil gemme den reducerede værdi
4. En lambda-funktion, der kører på hvert element på listen. Det vil returnere produktet af dette nummer som i det forrige resultat.
5. Udskriv resultatet returneret af reduceringsfunktionen.

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 lambdas, og hvornår du skal undgå dem. I dette afsnit lærer du nogle af de designprincipper, som python-udviklere bruger, når de skriver lambdaer.

En af de mest almindelige use cases for lambdaer er i funktionel programmering som Python understøtter et paradigme (eller stil) af programmering kendt som funktionel programmering.

Det giver dig mulighed for at levere en funktion som en parameter til en anden funktion (for eksempel i kort, filter osv.). I sådanne tilfælde tilbyder lambdaer en elegant måde at oprette en engangsfunktion og videregive 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[vV4][J5] kun funktioner, som ikke har en identifikator bundet til sig. I enklere ord er de funktioner uden navne (derfor anonyme). Her er en tabel for at illustrere forskellen mellem lambdas og almindelige funktioner i python.

Lambdas

Almindelige funktioner

Syntaks:

lambda x : x + x

Syntaks:

def (x) :
return x + x 

Lambdafunktioner kan kun have ét udtryk i deres krop.

Regulære funktioner kan have flere udtryk og udsagn i deres krop.

Lambdaer har ikke et navn forbundet med dem. Derfor er de også kendt som anonyme funktioner.

Almindelige funktioner skal have navn og signatur.

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

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

Forklaring på 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 vil have 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ærligt kraftfulde, når vi bruger dem sammen 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.

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

Resumé

• Lambdaer, også kendt som anonyme funktioner, er små, begrænsede funktioner, som ikke behøver et navn (dvs. en identifikator).
• Hver lambda-funktion i Python har 3 væsentlige dele:
• Lambda nøgleordet.
• Parametrene (eller bundne variabler), og
• Funktionslegemet.
• Syntaksen for at skrive en lambda er: lambda parameter: udtryk
• Lambdaer kan have et hvilket som helst antal parametre, men de er ikke omgivet af seler
• En lambda kan kun have 1 udtryk i sin funktions krop, som returneres som standard.
• På bytecode-niveau er der ikke meget forskel på, hvordan lambdas og almindelige funktioner håndteres af tolken.
• Lambdaer understøtter IIFE gennem denne syntaks: (lambda parameter: udtryk) (argument)
• Lambdaer bruges almindeligvis med følgende python indbyggede:
• Filter: filter (lambda parameter: udtryk, iterable-sequence)
• Kort: kort (lambda-parameter: udtryk, iterable-sekvenser)
• Reducer: reducer (lambda parameter1, parameter2: udtryk, iterable-sequence)
• Skriv ikke komplicerede lambda-funktioner i et produktionsmiljø, da det vil være svært for kode-vedligeholdere.

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

Denne kode kan redigeres. Klik på Kør for at udføre