A brief discussion on the usage of Lambda function in Python

Today I would like to recommend a super easy-to-use built-in function in Python, which is the lambda method. This tutorial will share with you roughly:

• What is a lambda function
• lambda function filters list elements
• Combined use of lambda function and map() method
• Combined use of lambda function and apply() method
• When is it not appropriate to use lambda methods?

What is Lambda function

In Python, we often use the lambda keyword to declare an anonymous function, the so-called anonymous function, In layman's terms, it is a function without a name. The specific syntax format is as follows:

lambda arguments : expression

It can accept any number of parameters, but is only allowed to contain one expression, and the result of the expression is For the return value of the function, we can simply write an example:

(lambda x:x**2)(5)

output:

25

Filter the elements in the list

So how do we filter the elements in the list? Woolen cloth? Here you need to combine the lambda function and the filter() method, and the syntax format of the filter() method:

filter(function, iterable)

• function -- Judgment function
• iterable -- Available Iterate object, list or dictionary

We have such a list:

import numpy as np
yourlist = list(np.arange(2,50,3))

We want to filter out the elements that are less than 100 after the second power, let’s define an anonymous Function, as follows:

lambda x:x**2<100

The final result is as follows:

list(filter(lambda x:x**2<100, yourlist))

output:

[2, 5, 8]

If you encounter a complicated calculation process, the editor still recommends that you do it yourself Customize a function, but if it is a simple calculation process, lambda anonymous function is definitely the best choice.

Combined use with the map() function

The syntax of the map() function is similar to the filter() function above, such as the following anonymous function:

lambda x: x**2+x**3

We will It is used in conjunction with the map() method:

list(map(lambda x: x**2+x**3, yourlist))

output:

[12,
 150,
 576,
 1452,
 2940,
 5202,
 ......]

Of course, as we mentioned before, the lambda anonymous function can accept multiple numbers of parameters, we can try it here For example, there are two sets of lists,

mylist = list(np.arange(4,52,3))
yourlist = list(np.arange(2,50,3))

We also use the map() method to operate, the code is as follows:

list(map(lambda x,y: x**2+y**2, yourlist,mylist))

output:

[20,
 74,
 164,
 290,
 452,
 650,
 884,
 1154,
......]

and apply() method The joint use

apply() method is often used in Pandas data tables, and the lambda anonymous function is brought into the apply() method. We create a new data table as follows:

myseries = pd.Series(mylist)
myseries

output:

04
17
2 10
3 13
4 16
5 19
6 22
7 25
8 28
......
dtype: int32

The use of the apply() method is slightly different from the previous two. For both the map() method and the filter() method, we need to put the iterable object into it, and here The apply() does not need:

myseries.apply(lambda x: (x+5)/x**2)

output:

0 0.562500
1 0.244898
2 0.150000
3 0.106509
4 0.082031
5 0.066482
6 0.055785
7 0.048000
......
dtype: float64

And if you encounter DataFarme table data, the same operation is done

df = pd.read_csv(r'Dummy_Sales_Data_v1.csv')
df["Sales_Manager"] = df["Sales_Manager"].apply(lambda x: x.upper())
df["Sales_Manager"].head()

output:

0PABLO
1PABLO
2KRISTEN
3ABDUL
4 STELLA
Name: Sales_Manager, dtype: object

And processing it through the apply() method is faster than processing it directly with the str.upper() method! !

Scenarios that are not suitable for use

So what are the scenarios that are not suitable for use? So first of all, the lambda function, as an anonymous function, is not suitable for assigning it to a variable, such as the following case:

squared_sum = lambda x,y: x**2 + y**2
squared_sum(3,4)

In comparison, it is better to customize a function for processing:

def squared_sum(x,y):
return x**2 + y**2

squared_sum(3,4)

output:

25

When we encounter the following situation, we can simplify the code slightly:

import math
mylist = [10, 25, 40, 49, 65, 81]
sqrt_list = list(map(lambda x: math.sqrt(x), mylist))
sqrt_list

output:

[3.16227766, 5.0, 6.324555320, 7.0, 8.062257748, 9.0]

We can Simplified to:

import math
mylist = [10, 25, 40, 49, 65, 81]
sqrt_list = list(map(math.sqrt, mylist))
sqrt_list

output:

[3.162277, 5.0, 6.324555, 7.0, 8.062257, 9.0]

If it is a built-in function in Python, especially a module used for arithmetic such as math, it does not need to be placed in the lambda function, it can be directly Pull it out and use

The above is the detailed content of A brief discussion on the usage of Lambda function in Python. For more information, please follow other related articles on the PHP Chinese website!