Python Lambdafunktioner med EXEMPEL

Vad är Lambda-funktionen i Python?

A Lambdafunktion in Python programmering är en anonym funktion eller en funktion utan namn. Det är en liten och begränsad funktion som inte har mer än en rad. Precis som en normal funktion kan en Lambda-funktion ha flera argument med ett uttryck.

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 (uttrycket) är valfritt giltigt Python uttryck som arbetar på de parametrar du anger i 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))

Code Fö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 enkelt 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. Öppna din [fil] igen. 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å mer.

Code Förklaring:

1. Här definierar vi en sträng som du kommer att skicka som en parameter till lambdan.

2. Vi deklarerar en lambda som anropar en print-sats och skriver ut resultatet.

Men varför skriver inte programmet ut strängen vi skickar? Detta beror på att lambdan själv returnerar ett funktionsobjekt. I det här exemplet används inte lambdan. kallas av utskriftsfunktionen men är helt enkelt tillbaka funktionsobjektet och minnesplatsen där det lagras. Det är det som skrivs ut i 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, så ser du en utdata som denna.

Produktion:

some kind of a useless lambda

Nu anropas lambdan och strängen vi skickar skrivs ut i konsolen. Men vad är den där konstiga syntaxen, och varför är lambdans definition täckt inom parenteser? Låt oss förstå det nu.

Code Fö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 anropar den omedelbart genom att skicka strängen som ett argument. Detta kallas en IIFE, och du kommer att lära dig mer om det i kommande avsnitt av den här handledningen.

Exempelvis 4

Låt oss titta på ett sista exempel för att förstå hur lambdas och vanliga funktioner exekveras. 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 resultatet se ut ungefär så här.

Produktion:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code Förklaring:

1. En funktion som heter guru som tar en annan funktion som första parameter och eventuella andra argument som följer på den.

2. printer_one är en enkel funktion som skriver ut parametern som skickats till den och returnerar den.

3. printer_two liknar printer_one men utan return-satsen.

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 guru-funktionen) men med hjälp av 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 är definierad. Låt oss förstå detta med ett exempel; starta 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 baseras på en fördefinierad begränsning. Det krävs två 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]

Code Fö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()

Map-funktionen används för att tillämpa en specifik operation på varje element i en sekvens. Precis som filter() tar den 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]

Code Förklaring:

1. Här definierar vi en lista som kallas sekvenser och som innehåller några tal.

2. Vi deklarerar en variabel som heter filtered_result som lagrar de mappade värdena.

3. En lambdafunktion som körs på varje element i listan och returnerar kvadraten av det talet.

4. Skriv ut resultatet som returneras av map-funktionen.

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

Code Förklaring:

1. Importera reduce från functools-modulen.

2. Här definierar vi en lista som kallas sekvenser och som innehåller några tal.

3. Vi deklarerar en variabel som heter produkt som lagrar det reducerade värdet.

4. En lambdafunktion som körs på varje element i listan. Den returnerar produkten av det talet enligt föregående resultat.

5. Skriv ut resultatet som returneras av reduce-funktionen.

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 de designprinciper som används av Python utvecklare när de skriver lambdas.

Ett av de vanligaste användningsområdena för lambdas är inom funktionell programmering, eftersom Python stöder ett paradigm (eller stil) av programmering som kallas funktionell programmering.

Det låter dig ange en funktion som en parameter till en annan funktion (till exempel i map, filter, etc.). I sådana fall erbjuder användningen av 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 bara funktioner som inte har någon identifierare bunden till sig. Enklare uttryckt är de funktioner utan namn (därav anonyma). Här är en tabell som illustrerar skillnaden mellan lambdas och vanliga funktioner i Python.

lambda x : x + x

def (x) :
return x + x 

Förklaring av 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 den. En lambda-funktion innehåller inte en retursats eftersom den bara har ett enda uttryck som alltid returneras som standard. Du behöver inte ens tilldela en lambda heller, eftersom den kan anropas omedelbart (se föregående avsnitt). Som du kommer att se blir lambdor särskilt 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.

På bytekodnivå hanteras de två definitionerna på samma sätt av Python tolk. Nu kan du inte namnge en funktion lambda eftersom det är reserverat av Python, men alla andra funktionsnamn kommer att ge samma bytekod.

Vanliga frågor