Python Lambda fungerar med EXEMPEL

Innehållsförteckning:

Anonim

Vad är Lambda-funktion i Python?

En Lambda-funktion i Python- programmering är en anonym funktion eller en funktion som inte har något 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.

I Python används lambdauttryck (eller lambdaformer) för att konstruera anonyma funktioner. För att göra det använder du lambda- nyckelordet (precis som du använder def för att definiera normala funktioner). Varje anonym funktion som du definierar i Python kommer att ha tre viktiga delar:

  • Nyckelordet lambda.
  • Parametrarna (eller bundna variabler) och
  • Funktionskroppen.

En lambdafunktion kan ha valfritt antal parametrar, men funktionskroppen kan bara innehålla ett uttryck. Dessutom skrivs en lambda i en enda kodrad och kan också åberopas omedelbart. Du kommer att se allt detta i aktion i de kommande exemplen.

I denna Lambda in Python-handledning lär du dig:

  • Syntax och exempel
  • Använda lambdas med Python-inbyggda program
  • lambdas i filter ()
  • lambdas på karta ()
  • lambdas i reducera ()
  • Varför (och varför inte) använda lambdafunktioner?
  • Lambdas kontra vanliga funktioner

Syntax och exempel

Den formella syntaxen för att skriva en lambda-funktion är enligt nedan:

lambda p1, p2: expression

Här är p1 och p2 de parametrar som överförs 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 ett giltigt pythonuttryck som fungerar på de parametrar som du tillhandahåller funktionen.

Exempel 1

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

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

Här är resultatet:

3

Kodförklaring

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

1. Lambda-nyckelordet som används för att definiera en anonym funktion.

2. x och y är de parametrar som vi överför till lambdafunktionen.

3. Detta är funktionen för funktionen, som lägger till de två parametrarna vi skickade. Lägg märke till att det är ett enda uttryck. Du kan inte skriva flera uttalanden i en lambdafunktion.

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

Exempel 2

Det var ett grundläggande exempel för att förstå lambdas grundläggande och syntax. 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 returnsstring='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 borde få.

Produktion:

 at 0x00000185C3BF81E0>

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

Kodförklaring

  1. Här definierar vi en sträng som du skickar som en parameter till lambda.
  2. Vi förklarar en lambda som kallar en utskrift och skriver ut resultatet.

Men varför skriver inte programmet ut den sträng vi skickar? Detta beror på att lambda själv returnerar ett funktionsobjekt. I det här exemplet är lambda inte bli kallad av utskriftsfunktionen utan helt enkelt återfunktionsobjektet och minnesplatsen där det lagras. Det är det som skrivs ut på konsolen.

Exempel 3

Men om du skriver ett program så här:

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

Och kör den genom att trycka på F5, du ser en utdata som den här.

Produktion:

some kind of a useless lambda

Nu kallas lambda och strängen vi passerar skrivs ut på konsolen. Men vad är den 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 denna del 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 lär dig mer om det i de kommande avsnitten i denna handledning.

Exempel 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 skriv in följande 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'))

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

Produktion:

skrivare 1 VANLIGT SAMTAL

skrivare 2 VANLIGT SAMTAL

skrivare 1 LAMBDA CALL

skrivare 2 LAMBDA CALL

Kodförklaring

  1. En funktion som kallas guru som tar en annan funktion som den första parametern och andra argument som följer 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 returuttalande.
  4. I den här delen ringer 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. att ringa till guru-funktionen) men använda lambdas.

I nästa avsnitt lär du dig hur du använder lambdafunktioner med map (), reducera () och filter () i Python.

Använda lambdas med Python-inbyggda program

Lambda-funktioner ger ett elegant och kraftfullt sätt att utföra operationer med hjälp av inbyggda metoder i Python. Det är möjligt eftersom lambdas kan åberopas omedelbart och skickas som ett argument för dessa funktioner.

IIFE i Python Lambda

IIFE står för omedelbart åberopad funktionskörning. Det betyder att en lambdafunktion kan anropas så snart den är definierad. Låt oss förstå detta med ett exempel; skjut 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 åberopas omedelbart gör att du kan använda dem i funktioner som map () och reducera (). 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 specifika element från en sekvens av element. Sekvensen kan vara vilken iterator som helst, listor, uppsättningar, tuplar etc.

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

  • En funktion som definierar filtreringsbegränsningen
  • En sekvens (valfri iterator som listor, tuplar 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 resultatet:

[10, 8, 7, 5, 11]

Kodförklaring:

1. I det första uttalandet definierar vi en lista som heter sekvenser som innehåller några siffror.

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

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

4. Skriv ut resultatet som returneras av filterfunktionen.

lambdas på karta ()

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

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

Här är till exempel ett program som skriver ut siffrorna i en viss 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, 121, 0, 1]

[KR1]

Kodförklaring:

  1. Här definierar vi en lista som heter sekvenser som innehåller några siffror.
  2. Vi deklarerar en variabel som heter filtered_result som lagrar de mappade värdena
  3. En lambda-funktion som körs på varje element i listan och returnerar kvadraten för det numret.
  4. Skriv ut resultatet som returneras av kartfunktionen.

lambdas i reducera ()

Funktionen reducera, som karta (), används för att tillämpa en operation på varje element i en sekvens. Det skiljer sig dock från kartan i dess arbete. Det här är stegen som följs av funktionen reducera () för att beräkna en utgång:

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 är kvar.

Det tar också två parametrar:

  1. En funktion som definierar den operation som ska utföras
  2. En sekvens (valfri iterator som listor, tuplar etc.)

Här är till exempel ett program som returnerar produkten av alla element i en lista:

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

Här är resultatet:

120

Kodförklaring:

  1. Importera reducera från funktionsmodulen
  2. Här definierar vi en lista som heter sekvenser som innehåller några siffror.
  3. Vi deklarerar en variabel som kallas produkt som lagrar det reducerade värdet
  4. En lambda-funktion som körs på varje element i listan. Den returnerar 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 skrivfunktioner 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 lär du dig några av de designprinciper som används av pythonutvecklare när du skriver lambdas.

Ett av de vanligaste användningsfallet för lambdas är i funktionell programmering eftersom Python stöder ett paradigm (eller stil) för 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 användning 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 bör aldrig skriva komplicerade lambdafunktioner i en produktionsmiljö. Det kommer att bli mycket svårt för kodare som underhåller din kod att dekryptera den. Om du befinner dig i att göra komplexa one-liner-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 sig. Med enklare ord är de funktioner utan namn (därmed anonyma). Här är en tabell för att illustrera skillnaden mellan lambdas och vanliga funktioner i python.

Lambdas

Regelbundna funktioner

Syntax:

lambda x : x + x

Syntax:

def (x) :return x + x

Lambdafunktioner kan bara ha ett uttryck i kroppen.

Vanliga funktioner kan ha flera uttryck och uttalanden i sin kropp.

Lambdas har inget namn associerat med sig. Det är därför de också kallas anonyma funktioner.

Vanliga funktioner måste ha namn och signatur.

Lambdas innehåller inte ett returuttalande eftersom kroppen returneras automatiskt.

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

Förklaring till skillnaderna?

Den primära skillnaden mellan en lambda och en vanlig funktion är att lambda-funktionen endast utvärderar ett enda uttryck och ger ett funktionsobjekt. Följaktligen kan vi namnge resultatet av lambdafunktionen och använda det 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 + yprint (adder (1, 2))

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

Men du kanske fortfarande undrar hur lambdas skiljer sig från en funktion som returnerar ett enda uttryck (som det ovan). På tolknivå är det inte så stor skillnad. Det kan låta överraskande, men vilken lambdafunktion 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 den konverteras till bytkod. Nu kan du inte namnge en funktion lambda eftersom den är reserverad av Python, men något annat funktionsnamn ger samma bytkod [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 i Python har tre viktiga delar:
  • Nyckelordet lambda.
  • Parametrarna (eller bundna variabler) och
  • Funktionskroppen.
  • Syntaxen för att skriva en lambda är: lambda-parameter: expression
  • Lambdas kan ha valfritt antal parametrar, men de är inte inneslutna i hängslen
  • En lambda kan bara ha 1 uttryck i sin funktion, som returneras som standard.
  • På bytekodnivå är det inte så stor skillnad mellan hur lambdas och vanliga funktioner hanteras av tolk.
  • Lambdas stöder IIFE genom denna syntax: (lambda-parameter: expression) (argument)
  • Lambdas används vanligtvis med följande python-inbyggda program:
  • Filter: filter (lambda-parameter: uttryck, iterabel-sekvens)
  • Karta: karta (lambda-parameter: expression, iterable-sequences)
  • Minska: minska (lambda parameter1, parameter2: uttryck, iterabel-sekvens)
  • Skriv inte komplicerade lambdafunktioner i en produktionsmiljö eftersom det blir svårt för kodhållare.

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