Python Lambdafunktioner med EXEMPEL

In Python, används lambda-uttryck (eller lambda-former) för att konstruera anonyma funktioner. För att göra det använder du lambda nyckelord (precis som du använder def för att definiera normala funktioner). Varje anonym funktion du definierar i Python kommer att ha 3 viktiga delar:

• Lambda nyckelordet.
• Parametrarna (eller bundna variabler), och
• Funktionskroppen.

En lambdafunktion kan ha hur många parametrar som helst, men funktionskroppen kan bara innehålla ett uttryck. Dessutom skrivs en lambda i en enda kodrad och kan även anropas omedelbart. Du kommer att se allt detta i aktion i de kommande exemplen.

Syntax och exempel

Den formella syntaxen för att skriva en lambdafunktion är enligt nedan:

lambda p1, p2: expression

Här är p1 och p2 parametrarna som skickas till lambdafunktionen. Du kan lägga till så många eller få parametrar som du behöver.

Observera dock att vi inte använder parenteser runt parametrarna som vi gör med vanliga funktioner. Den sista delen (uttryck) är vilket giltigt pythonuttryck som helst som fungerar på parametrarna du tillhandahåller funktionen.

Exempelvis 1

Nu när du känner till lambdas låt oss prova det med ett exempel. Så öppna din IDLE och skriv in följande:

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

Här är utgången:

3

Kodförklaring

Här definierar vi en variabel som kommer att hålla resultatet som returneras av lambda-funktionen.

1. Nyckelordet lambda används för att definiera en anonym funktion.

2. x och y är parametrarna som vi skickar till lambdafunktionen.

3. Detta är huvuddelen av funktionen, som lägger till de 2 parametrarna vi skickade. Lägg märke till att det är ett enda uttryck. Du kan inte skriva flera påståenden i kroppen av en lambdafunktion.

4. Vi anropar funktionen och skriver ut det returnerade värdet.

Exempelvis 2

Det var ett grundläggande exempel för att förstå grunderna och syntaxen för lambda. Låt oss nu försöka skriva ut en lambda och se resultatet. Återigen, öppna din IDLE och skriv in följande:

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

Spara nu din fil och tryck på F5 för att köra programmet. Det här är resultatet du bör få.

Produktion:

<function <lambda> at 0x00000185C3BF81E0>

Vad händer här? Låt oss titta på koden för att förstå ytterligare.

Kodförklaring

1. Här definierar vi a sträng som du skickar som en parameter till lambdan.
2. Vi deklarerar en lambda som anropar ett print statement och skriver ut resultatet.

Men varför skriver inte programmet ut strängen vi passerar? Detta beror på att lambdan själv returnerar ett funktionsobjekt. I det här exemplet är lambdan inte att vara kallas av utskriftsfunktionen men helt enkelt tillbaka funktionsobjektet och minnesplatsen där det är lagrat. Det är vad som skrivs ut på konsolen.

Exempelvis 3

Men om du skriver ett program som detta:

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

Och kör den genom att trycka på F5, du kommer att se en utgång som denna.

Produktion:

some kind of a useless lambda

Nu anropas lambdan och strängen vi passerar skrivs ut vid konsolen. Men vad är den där konstiga syntaxen, och varför täcks lambdadefinitionen inom parentes? Låt oss förstå det nu.

Kodförklaring

1. Här är samma sträng som vi definierade i föregående exempel.
2. I den här delen definierar vi en lambda och kallar den omedelbart genom att skicka strängen som ett argument. Detta är något som kallas en IIFE, och du kommer att lära dig mer om det i de kommande avsnitten av denna handledning.

Exempelvis 4

Låt oss titta på ett sista exempel för att förstå hur lambdas och vanliga funktioner utförs. Så öppna din IDLE och i en ny fil skriver du in följande:

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

Spara nu filen och tryck på F5 för att köra programmet. Om du inte gjorde några misstag, bör utdata vara ungefär så här.

Produktion:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Kodförklaring

1. En funktion som kallas guru som tar en annan funktion som den första parametern och alla andra argument som följer efter den.
2. printer_one är en enkel funktion som skriver ut parametern som skickas till den och returnerar den.
3. printer_two liknar printer_one men utan retursatsen.
4. I den här delen anropar vi guru-funktionen och skickar skrivarfunktionerna och en sträng som parametrar.
5. Detta är syntaxen för att uppnå det fjärde steget (dvs anropa gurufunktionen) men med lambdas.

I nästa avsnitt får du lära dig hur du använder lambdafunktioner med Karta(), minska(), och filtrera() in Python.

Använder lambdas med Python inbyggda

Lambdafunktioner ger ett elegant och kraftfullt sätt att utföra operationer med hjälp av inbyggda metoder Python. Det är möjligt eftersom lambdas kan anropas omedelbart och skickas som ett argument till dessa funktioner.

IIFE in Python Lambda

IIFE står för omedelbart anropade funktionsexekvering. Det betyder att en lambdafunktion är anropbar så snart den har definierats. Låt oss förstå detta med ett exempel; elda upp din IDLE och skriv in följande:

 (lambda x: x + x)(2)

Här är utdata och kodförklaring:

Denna förmåga hos lambdas att anropas omedelbart gör att du kan använda dem i funktioner som map() och reduce(). Det är användbart eftersom du kanske inte vill använda dessa funktioner igen.

lambdas i filter()

Filterfunktionen används för att välja vissa speciella element från en sekvens av element. Sekvensen kan vara vilken iterator som helst som listor, uppsättningar, tupler, etc.

Elementen som kommer att väljas är baserade på någon fördefinierad begränsning. Det krävs 2 parametrar:

• En funktion som definierar filtreringsbegränsningen
• En sekvens (valfri iterator som listor, tupler, etc.)

Till exempel,

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

Här är utgången:

[10, 8, 7, 5, 11]

Kodförklaring:

1. I det första påståendet definierar vi en lista som kallas sekvenser som innehåller några siffror.

2. Här deklarerar vi en variabel som heter filtered_result, som kommer att lagra de filtrerade värdena som returneras av filter()-funktionen.

3. En lambda-funktion som körs på varje element i listan och returnerar sant om det är större än 4.

4. Skriv ut resultatet som returneras av filterfunktionen.

lambdas i kartan()

kartfunktionen används för att tillämpa en viss operation på varje element i en sekvens. Precis som filter() tar det också två parametrar:

1. En funktion som definierar den operation som ska utföras på elementen
2. En eller flera sekvenser

Till exempel, här är ett program som skriver ut kvadraterna av siffror i en given lista:

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, 9, 121, 0, 1]

[KR1]

Kodförklaring:

1. Här definierar vi en lista som kallas sekvenser som innehåller några nummer.
2. Vi deklarerar en variabel som heter filtered_result som kommer att lagra de mappade värdena
3. En lambdafunktion som körs på varje element i listan och returnerar kvadraten på det talet.
4. Skriv ut resultatet som returneras av kartfunktionen.

lambdas i reduce()

Reduceringsfunktionen, som map(), används för att tillämpa en operation på varje element i en sekvens. Den skiljer sig dock från kartan i sin funktion. Det här är stegen som följs av reduce()-funktionen för att beräkna en utdata:

Steg 1) Utför den definierade operationen på de två första elementen i sekvensen.

Steg 2) Spara detta resultat

Steg 3) Utför operationen med det sparade resultatet och nästa element i sekvensen.

Steg 4) Upprepa tills inga fler element finns kvar.

Det krävs också två parametrar:

1. En funktion som definierar operationen som ska utföras
2. En sekvens (valfri iterator som listor, tupler, etc.)

Till exempel, här är ett program som returnerar produkten av alla element i en lista:

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

Här är utgången:

120

Kodförklaring:

1. Importera reducera från modulen functools
2. Här definierar vi en lista som kallas sekvenser som innehåller några nummer.
3. Vi deklarerar en variabel som heter produkt som kommer att lagra det reducerade värdet
4. En lambdafunktion som körs på varje element i listan. Det kommer att returnera produkten av det numret enligt föregående resultat.
5. Skriv ut resultatet som returneras av reduceringsfunktionen.

Varför (och varför inte) använda lambdafunktioner?

Som du kommer att se i nästa avsnitt behandlas lambdas på samma sätt som vanliga funktioner på tolknivå. På ett sätt kan man säga att lambdas ger kompakt syntax för att skriva funktioner som returnerar ett enda uttryck.

Du bör dock veta när det är en bra idé att använda lambdas och när du ska undvika dem. I det här avsnittet kommer du att lära dig några av designprinciperna som används av pythonutvecklare när du skriver lambdas.

Ett av de vanligaste användningsfallen för lambdas är i funktionell programmering som Python stöder ett paradigm (eller stil) av programmering som kallas funktionell programmering.

Det låter dig tillhandahålla en funktion som en parameter till en annan funktion (till exempel i karta, filter, etc.). I sådana fall erbjuder lambdas ett elegant sätt att skapa en engångsfunktion och skicka den som parameter.

När ska du inte använda Lambda?

Du ska aldrig skriva komplicerade lambdafunktioner i en produktionsmiljö. Det kommer att vara mycket svårt för kodare som underhåller din kod att dekryptera den. Om du kommer på dig själv med att göra komplexa enkelriktade uttryck, skulle det vara en mycket överlägsen praxis att definiera en korrekt funktion. Som en bästa praxis måste du komma ihåg att enkel kod alltid är bättre än komplex kod.

Lambdas kontra vanliga funktioner

Som tidigare nämnts är lambdas[vV4][J5] bara funktioner som inte har en identifierare bunden till dem. Med enklare ord är de funktioner utan namn (därav anonyma). Här är en tabell för att illustrera skillnaden mellan lambdas och vanliga funktioner i python.

Lambdas

Vanliga funktioner

Syntax:

lambda x : x + x

Syntax:

def (x) :
return x + x 

Lambdafunktioner kan bara ha ett uttryck i sin kropp.

Reguljära funktioner kan ha flera uttryck och uttalanden i kroppen.

Lambdas har inget namn kopplat till dem. Det är därför de också kallas anonyma funktioner.

Vanliga funktioner måste ha namn och signatur.

Lambdas innehåller inget returmeddelande eftersom kroppen automatiskt returneras.

Funktioner som behöver returnera värde bör innehålla ett returmeddelande.

Förklaring till skillnaderna?

Den primära skillnaden mellan en lambda och en vanlig funktion är att lambdafunktionen endast utvärderar ett enda uttryck och ger ett funktionsobjekt. Följaktligen kan vi namnge resultatet av lambdafunktionen och använda den i vårt program som vi gjorde i föregående exempel.

En vanlig funktion för exemplet ovan skulle se ut så här:

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

Här måste vi definiera en namn för den funktion som återgår resultatet när vi Ring det. En lambda-funktion innehåller inte en retursats eftersom den bara kommer att ha ett enda uttryck som alltid returneras som standard. Du behöver inte ens tilldela en lambda heller eftersom den omedelbart kan anropas (se nästa avsnitt). Som du kommer att se i följande exempel blir lambdas extra kraftfulla när vi använder dem med Pythons inbyggda funktioner.

Men du kanske fortfarande undrar hur lambda skiljer sig från en funktion som returnerar ett enda uttryck (som det ovan). På tolknivå är det inte så stor skillnad. Det kanske låter överraskande, men vilken lambdafunktion som helst som du definierar i Python behandlas som en normal funktion av tolken.

Som du kan se i diagrammet hanteras de två definitionerna på samma sätt av pythontolken när de konverteras till bytekod. Nu kan du inte namnge en funktion lambda eftersom det är reserverat av Python, men alla andra funktionsnamn kommer att ge samma bytekod[KR6].

Sammanfattning

• Lambdas, även kända som anonyma funktioner, är små, begränsade funktioner som inte behöver ett namn (dvs. en identifierare).
• Varje lambdafunktion in Python har 3 viktiga delar:
• Lambda nyckelordet.
• Parametrarna (eller bundna variabler), och
• Funktionskroppen.
• Syntaxen för att skriva en lambda är: lambda parameter: expression
• Lambdas kan ha hur många parametrar som helst, men de är inte inneslutna i hängslen
• En lambda kan bara ha ett uttryck i sin funktionskropp, som returneras som standard.
• På bytekodnivå är det inte så stor skillnad mellan hur lambdas och vanliga funktioner hanteras av tolken.
• Lambdas stöder IIFE genom denna syntax: (lambda parameter: expression)(argument)
• Lambdas används vanligtvis med följande inbyggda python:
• Filter: filter (lambda-parameter: expression, iterable-sequence)
• Karta: karta (lambda-parameter: uttryck, iterable-sequences)
• Reducera: reducera (lambda parameter1, parameter2: expression, iterable-sequence)
• Skriv inte komplicerade lambdafunktioner i en produktionsmiljö eftersom det kommer att vara svårt för kodunderhållare.

[J5]Jag har lagt till en tabell, men förklaringen är nödvändig för att förstå skillnaderna.

Denna kod är redigerbar. Klicka på Kör för att köra