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.

However, notice that we do not use brackets around the parameters as we do with regular functions. The last part (expression) is any valid Python expression that operates on the parameters you provide to the function.

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

That was a basic example to understand the fundamentals and syntax of lambda. Let us now try to print out a lambda and see the result. Again, open your 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>

What is happening here? Let us look at the code to understand further.

Code Förklaring:

1. Here, we define a sträng that you will pass as a parameter to the lambda.

2. We declare a lambda that calls a print statement and prints the result.

But why does the program not print the string we pass? This is because the lambda itself returns a function object. In this example, the lambda is not being kallas by the print function but is simply tillbaka the function object and the memory location where it is stored. That is what gets printed at the console.

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)

And run it by hitting F5, you will see an output like this.

Produktion:

some kind of a useless lambda

Now, the lambda is being called, and the string we pass gets printed at the console. But what is that weird syntax, and why is the lambda definition covered in brackets? Let us understand that now.

Code Förklaring:

1. Here is the same string we defined in the previous example.

2. In this part, we are defining a lambda and calling it immediately by passing the string as an argument. This is something called an IIFE, and you will learn more about it in the upcoming sections of this tutorial.

Exempelvis 4

Let us look at a final example to understand how lambdas and regular functions are executed. So, open your 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'))

Now, save the file and hit F5 to run the program. If you did not make any mistakes, the output should be something like this.

Produktion:

printer 1 REGULAR CALL

printer 2 REGULAR CALL

printer 1 LAMBDA CALL

printer 2 LAMBDA CALL

Code Förklaring:

1. A function called guru that takes another function as the first parameter and any other arguments following it.

2. printer_one is a simple function which prints the parameter passed to it and returns it.

3. printer_two is similar to printer_one but without the return statement.

4. In this part, we are calling the guru function and passing the printer functions and a string as parameters.

5. This is the syntax to achieve the fourth step (i.e., calling the guru function) but using 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. It means that a lambda function is callable as soon as it is defined. Let us understand this with an example; fire up your 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.

The elements which will be selected are based on some pre-defined constraint. It takes 2 parameters:

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

The map function is used to apply a particular operation to every element in a sequence. Like filter(), it also takes 2 parameters:

1. A function that defines the operation to perform on the elements
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. Here, we define a list called sequences which contains some numbers.

2. We declare a variable called filtered_result which will store the mapped values.

3. A lambda function which runs on each element of the list and returns the square of that number.

4. Print the result returned by the map function.

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) Save this result.

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. Import reduce from the functools module.

2. Here, we define a list called sequences which contains some numbers.

3. We declare a variable called product which will store the reduced value.

4. A lambda function that runs on each element of the list. It will return the product of that number as per the previous result.

5. Print the result returned by the reduce function.

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.

However, you should know when it is a good idea to use lambdas and when to avoid them. In this section, you will learn some of the design principles used by Python developers when writing lambdas.

One of the most common use cases for lambdas is in functional programming, as Python stöder ett paradigm (eller stil) av programmering som kallas funktionell programmering.

It allows you to provide a function as a parameter to another function (for example, in map, filter, etc.). In such cases, using lambdas offers an elegant way to create a one-time function and pass it as the 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

As previously stated, lambdas are just functions which do not have an identifier bound to them. In simpler words, they are functions with no names (hence, anonymous). Here is a table to illustrate the difference between lambdas and regular functions in Python.

lambda x : x + x

def (x) :
return x + x 

Explanation of the differences

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 it. A lambda function does not contain a return statement because it will have only a single expression which is always returned by default. You do not even have to assign a lambda either, as it can be immediately invoked (see the previous section). As you will see, lambdas become particularly powerful when we use them with 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.

At the bytecode level, the two definitions are handled in the same way by the Python interpreter. Now, you cannot name a function lambda eftersom det är reserverat av Python, but any other function name will yield the same bytecode.

Vanliga frågor