Python中lambda详解（包括内置函数map、reduce、filter、sorted、max）_lamda map reduce

一、lambda是什么？

python 使用 lambda 来创建匿名函数。

对比使用 def关键字 创建的是 有名字的函数 ，使用 lambda关键字 创建的则是没有名字的函数。

1.lambda语法

其语法是唯一的，其形式如下：

lambda argument_list:expression
1

其中，lambda 是Python预留的关键字，argument_list 和 expression 由用户自定义。

可理解为：

lambda 参数1,参数2,…: 表达式

2.语法详解

1、这里的argument_list是参数列表，它的结构与Python中函数(function)的参数列表是一样的。

2、这里的expression是一个关于参数的表达式。表达式中出现的参数需要在argument_list中有定义，并且表达式只能是单行的。

3、这里的 lambda argument_list: expression 表示的是一个函数。这个函数叫做lambda函数。

4、lambda函数输入的是传入到参数列表argument_list的值，输出的是根据表达式expression计算得到的值。

二、lambda的使用

1.定义

lambda x,y,z:x+y+z
1

等同于：

def func(x,y,z):
    return x+y+z
1
2

2.调用

方式一：

直接调用

res=(lambda x,y,z:x+y+z)(1,2,3)
1

方式二：

将lambda函数赋值给一个变量，通过这个变量间接调用该lambda函数。

add=lambda x,y:x+y 
res=add(1,2)
1
2

执行语句add=lambda x, y: x+y，定义了加法函数lambda x, y: x+y，并将其赋值给变量add。

这样变量add便成为具有加法功能的函数。例如，执行add(1,2)，输出为3。

但是，“匿名”的本质就是要没有名字，所以此处为匿名函数指定名字是没有意义的。

3.替换

将lambda函数赋值给其他函数，从而将其他函数用该lambda函数替换。

例如，为了把标准库time中的函数sleep的功能屏蔽，我们可以在程序初始化时调用：

time.sleep=lambda x:None
1

这样，在后续代码中调用time库的sleep函数将不会执行原有的功能。

例如，执行time.sleep(3)时，程序不会休眠3秒钟，而是什么都不做。

4.作返回值

将lambda函数作为其他函数的返回值，返回给调用者。

函数的返回值也可以是函数。例如：

return lambda x, y: x+y
1

返回一个加法函数。

这时，lambda函数实际上是定义在某个函数内部的函数，称之为嵌套函数，或者内部函数。

对应的，将包含嵌套函数的函数称之为外部函数。

内部函数能够访问外部函数的局部变量，这个特性也是闭包(Closure)编程的基础。

闭包简介

三、lambda作参数

可以将lambda函数作为参数传递给其他函数。

部分内置函数接收函数作为参数。

例如函数map、reduce、filter都支持迭代器协议，可用来处理可迭代对象。

1.map函数

map() 会根据提供的函数对指定序列做映射。

map() 函数语法：

map(function, iterable, ...)
1

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

iterable 表示一个或多个序列

此时lambda函数用于指定对每一个元素的共同操作。

对array的每个元素做平方处理，可以使用map函数。

map函数可以接收两个参数，一个是函数，另外一个是可迭代对象，具体用法如下：

>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])
[1, 4, 9, 16, 25]
1
2

使用list可以依次迭代res，取得的值作为列表元素。

map会依次迭代array，得到的值依次传给匿名函数（也可以是有名函数），而map函数得到的结果仍然是迭代器。

在数据科学领域，可以使用 pandas 库来处理数据。

如下所示，我们可以使用 lambda 函数通过 map() 函数从现有数据中创建新数据。

除了使用 lambda 函数外，我们还可以直接使用算术函数，因为 pandas 是支持的：

>>> import pandas as pd
>>> data = pd.Series([1, 2, 3, 4])
>>> data.map(lambda x: x + 5)
0    6
1    7
2    8
3    9
dtype: int64
>>> data + 5
0    6
1    7
2    8
3    9
dtype: int64
1
2
3
4
5
6
7
8
9
10
11
12
13
14

dtype：数据类型对象

Int64：是有符号 64位整数(64bit interger)，相当于 long long，占8个字节

2.reduce函数

reduce() 函数会对参数序列中元素进行累积。

reduce() 函数语法：

reduce(function, iterable[, initializer])
1

reduce函数可以接收三个参数，一个是函数，第二个是可迭代对象，第三个是初始值（可选，默认为0）。

函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：

用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

此时lambda函数用于指定列表中两两相邻元素的结合条件。

注意：Python3.x reduce() 已经被移到 functools 模块里，如果我们要使用，需要引入 functools 模块来调用 reduce() 函数：

from functools import reduce

def add(x, y) : # 两数相加
    return x + y
sum1 = reduce(lambda x, y: x+y, [1,2,3,4,5])
print(sum1) # 结果为：15
1
2
3
4
5
6

3.filter函数

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

它接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

以下是 filter() 方法的语法:

filter(function, iterable)
1

参数：
function – 判断函数。
iterable – 可迭代对象。

此时lambda函数用于指定过滤列表元素的条件。

例如

filter(lambda x: x % 3 == 0, [1, 2, 3])
1

指定将列表[1,2,3]中能够被3整除的元素过滤出来。

print(list(filter(lambda x: x % 3 == 0, [1, 2, 3])))
1

运行结果：[3]

4.sorted函数

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，返回的是对已经存在的列表进行操作，无返回值

sorted 可以对所有可迭代的对象进行排序操作，返回的是一个新的 list，而不是在原来的基础上进行的操作。

sorted 语法：

sorted(iterable, cmp=None, key=None, reverse=False)
1

参数说明：

iterable：可迭代对象。

cmp：比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。

key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse：排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
 
>>> students = [('Jack', 'A', 15), ('Tom', 'B', 12), ('Dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[('Dave', 'B', 10), ('Tom', 'B', 12), ('Jack', 'A', 15)]
 
>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[('Jack', 'A', 15), ('Tom', 'B', 12), ('Dave', 'B', 10)]
>>>
1
2
3
4
5
6
7
8
9
10
11
12
13

5.max函数

函数形式：max( x ,key=lambda a : b )，x可以是任何数值，可以有多个x值。

这个函数的意思是：我们先把x值带入lambda函数转换成b值，然后再将b值进行比较。

实例：想在一个记录着人名和对应年龄的字典里筛选出年龄最大的那个人的一条字典记录：

x={"Tom" :18 , "Jack":99}
max_age=max(x.items(), key=lambda a: a[1])
print(max_age)        #输出('Jack', 99)
1
2
3

注意：使用字典的话一定要x.items()，不能直接输入x值！

6.在字典中的应用

匿名函数与有名函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放。

所以匿名函数用于临时使用一次的场景，匿名函数通常与其他函数配合使用。

实例一：

salaries = {
    'A': 6000,
    'B': 7000,
    'C': 10000,
    'D': 8000
}
1
2
3
4
5
6

要想取得薪水的最大值和最小值，我们可以使用内置函数max和min。

>>> max(salaries)
'C'
>>> min(salaries)
'A'
1
2
3
4

内置max和min都支持迭代器协议，工作原理都是迭代字典，取得是字典的键。当字典中的值相同的时候，才会比较键。

因而比较的是键的最大和最小值，而我们想要的是比较值的最大值与最小值，于是设计如下方案：

方案一：

print(max(salaries, key=lambda k: salaries[k]))
1

结果：C

函数max会迭代字典salaries，每取出一个“人名”就会当做参数传给指定的匿名函数，然后将匿名函数的返回值当做比较依据，最终返回薪资最高的那个人的名字。

方案二：

先使用zip把字典的keys和values翻转过来，再用max取出值最大的那组数据。

这个时候key是值，value是之前的key。

max_salaries_name = max(zip(salaries.values(), salaries.keys()))
print(max_salaries_name)
1
2

结果：(10000, ‘C’)

同理，我们直接对字典进行排序，默认也是按照字典的键去排序的：

>>> sorted(salaries)
['A', 'B', 'C', 'D']
1
2

实例二：

如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格。
1、用filter过滤出价格大于100的股票有哪些。
2、用sorted按价格从高到底排序列表portfolio。
3、用max找出价格最高的那支股票。

portfolio = [
    {'name': 'IBM', 'shares': 100, 'price': 91.1},
    {'name': 'AAPL', 'shares': 50, 'price': 543.22},
    {'name': 'FB', 'shares': 200, 'price': 21.09},
    {'name': 'QCOM', 'shares': 35, 'price': 31.75},
    {'name': 'YHOO', 'shares': 45, 'price': 16.35},
    {'name': 'NIO', 'shares': 75, 'price': 115.65}
]

print(list(filter(lambda f: f.get('price') > 100, portfolio)))
print(list(sorted(portfolio, key=lambda s: s.get('price'), reverse=True)))
print(max(portfolio, key=lambda m: m.get('price')))

1
2
3
4
5
6
7
8
9
10
11
12
13

运行结果：
[{‘name’: ‘AAPL’, ‘shares’: 50, ‘price’: 543.22}, {‘name’: ‘NIO’, ‘shares’: 75, ‘price’: 115.65}]
[{‘name’: ‘AAPL’, ‘shares’: 50, ‘price’: 543.22}, {‘name’: ‘NIO’, ‘shares’: 75, ‘price’: 115.65}, {‘name’: ‘IBM’, ‘shares’: 100, ‘price’: 91.1}, {‘name’: ‘QCOM’, ‘shares’: 35, ‘price’: 31.75}, {‘name’: ‘FB’, ‘shares’: 200, ‘price’: 21.09}, {‘name’: ‘YHOO’, ‘shares’: 45, ‘price’: 16.35}]
{‘name’: ‘AAPL’, ‘shares’: 50, ‘price’: 543.22}

备注：Python 字典 get() 函数返回指定键的值。
get()方法语法：

dict.get(key, default=None)
1

参数
key – 字典中要查找的键。
default – 如果指定键的值不存在时，返回该默认值。

结语

以上就是Python中lambda详解（包括内置函数），希望对大家有所帮助。 如果大家有任何疑问请给我留言，我会尽快回复大家。在此也非常感谢大家对CSDN的支持！