python中的lambda函数与sorted函数_sorted lambed

举例

1. 例1:传入多个参数的lambda函数

def sum(x,y):
      return x+y
1
2

用lambda来实现：

p = lambda x,y:x+y
print(p(4,6))
1
2

2. 例2：传入一个参数的lambda函数

a=lambda x:x*x
print(a(3))
1
2

3. 例3：多个参数的lambda形式：

a = lambda x,y,z:(x+8)*y-z
print(a(5,6,8))
1
2

匿名函数lambda：是指一类无需定义标识符（函数名）的函数或子程序。
lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。

注意

1-lambda 函数不能包含命令，
2-包含的表达式不能超过一个。
1
2

说明：一定非要使用lambda函数；任何能够使用它们的地方，都可以定义一个单独的普通函数来进行替换。我将它们用在需要封装特殊的、非重用代码上，避免令我的代码充斥着大量单行函数。

lambda匿名函数的格式：冒号前是参数，可以有多个，用逗号隔开，冒号右边的为表达式。其实lambda返回值是一个函数的地址，也就是函数对象。

a=lambda x:x*x
print(a)
print(a(3))
1
2
3

<function <lambda> at 0x0000000002093E18>
9
1
2

lambda常用使用场景

1.函数式编程:

例如：一个整数列表，要求按照列表中元素的绝对值大小升序排列

list1 = [3,5,-4,-1,0,-2,-6]
sorted(list1, key=lambda x: abs(x))
[0, -1, -2, 3, -4, 5, -6]
1
2
3

排序函数sorted支持接收一个函数作为参数，该参数作为 sorted的排序依据，这里按照列表元素的绝对值进行排序。

当然，我也可以用普通函数来实现：

def foo(x):
	return abs(x)
sorted(list1, key=foo)
[0, -1, -2, 3, -4, 5, -6]
1
2
3
4

只不过是这种方式代码看起来不够 Pythonic 而已。

lambda：这是Python支持一种有趣的语法，它允许你快速定义单行的最小函数，可以用在任何需要函数的地方：

add = lambda x,y : x+y
add(5,6)
11
(lambda x,y:x+y)(5,6)
11
1
2
3
4
5

2.Python中最常见的filter筛选、map小刷子、reduce合并，都可以用lambda表达式来生成

对于序列来讲，有三个函数式编程工具: filter()、map()和reduce()。

map(function,sequence)：把sequence中的值当参数逐个传给function，返回一个包含函数执行结果的list。如果function有两个参数，即map(function,sequence1,sequence2)。

#求1~20的平方
list(map(lambda x:x*x,range(1,21)))     
#Python2.x 使用map(lambda x:x*x,range(1,21))
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400]
1
2
3
4

filter(function,sequence)：对sequence中的item依次执行function(item)，将执行结果为True的item组成一个List/String/Tuple(取决于sequence的类型)返回。

#求1~20之间的偶数
list(filter(lambda x:x%2 == 0,range(1,21))) 
#Python2.x 使用filter(lambda x:x%2 == 0,range(1,21))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
1
2
3
4

reduce(function,sequence)：function接收的参数个数只能为2，先把sequence中第一个值和第二个值当参数传给function，再把function的返回值和第三个值当参数传给function，然后只返回一个结果。

#求1~100之和
from functools import reduce          
#Python3.x之后需要导入reduce模块
reduce(lambda x,y:x+y,range(1,101))
5050
1
2
3
4
5

#求1~100之和，再加上10000
reduce(lambda x,y:x+y,range(1,101),10000)
15050
1
2
3

sorted()函数

sorted(iterable[,key][,reverse])
1

函数接收三个参数：排序的变量、排序的规则、升降序选择

排序

1 简单列表(list)排序

list = ['a', 'b', 'c']
print(sorted(list))
# ['a', 'b', 'c']
print(sorted(list, reverse=True))
# ['c', 'b', 'a']
1
2
3
4
5

2 字典(dict)的键(key)排序

dict = {'c': 1, 'b': 2, 'a': 3}
print(sorted(dict))
# ['a', 'b', 'c']
print(sorted(dict, reverse=True))
# ['c', 'b', 'a']
1
2
3
4
5

3 字典(dict)的值(value)排序（使用lambda函数）

使用lambda函数让key为字典值即dict[]

dict = {'c': 1, 'b': 2, 'a': 3}
print(sorted(dict, key=lambda k: dict[k]))
# ['c', 'b', 'a']
print(sorted(dict, key=lambda k: dict[k], reverse=True))
# ['a', 'b', 'c']
1
2
3
4
5

4列表(list)内嵌套列表(list)排序（使用lambda函数）

list = [[4, 2, 9], [1, 5, 6], [7, 8, 3]]
# 以列表中列表的第一个数排序
print(sorted(list, key=lambda k: k[0]))
# [[1, 5, 6], [4, 2, 9], [7, 8, 3]]
# 以列表中列表的第二个数排序
print(sorted(list, key=lambda k: k[1]))
# [[4, 2, 9], [1, 5, 6], [7, 8, 3]]
# 以列表中列表的第三个数排序
print(sorted(list, key=lambda k: k[2]))
# [[7, 8, 3], [1, 5, 6], [4, 2, 9]]
# 以列表中列表的第一个数排序，且降序
print(sorted(list, key=lambda k: k[0], reverse=True))
# [[7, 8, 3], [4, 2, 9], [1, 5, 6]]
1
2
3
4
5
6
7
8
9
10
11
12
13

5字典(dict)内嵌套字典(dict)排序（使用lambda函数）

dict = {
        'a': {'x': 3, 'y': 2, 'z': 1},
        'b': {'x': 2, 'y': 1, 'z': 3},
        'c': {'x': 1, 'y': 3, 'z': 2}
        }
# 以内部字典的'x'对应的值排序
print(sorted(dict, key=lambda k: dict[k]['x']))
# ['c', 'b', 'a']
# 以内部字典的'y'对应的值排序
print(sorted(dict, key=lambda k: dict[k]['y']))
# ['b', 'a', 'c']
# 以内部字典的'z'对应的值排序
print(sorted(dict, key=lambda k: dict[k]['z']))
# ['a', 'c', 'b']
# 以内部字典的'x'对应的值排序,并降序
print(sorted(dict, key=lambda k: dict[k]['x'], reverse=True))
# ['a', 'b', 'c']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

6 列表(list)中嵌套字典(dict)排序（使用lambda函数）

list = [
    {'x': 3, 'y': 2, 'z': 1},
    {'x': 2, 'y': 1, 'z': 3},
    {'x': 1, 'y': 3, 'z': 2},
]
print(sorted(list, key=lambda k: k['x']))
# [{'z': 2, 'x': 1, 'y': 3}, {'z': 3, 'x': 2, 'y': 1}, {'z': 1, 'x': 3, 'y': 2}]
print(sorted(list, key=lambda k: k['y']))
# [{'z': 3, 'x': 2, 'y': 1}, {'z': 1, 'x': 3, 'y': 2}, {'z': 2, 'x': 1, 'y': 3}]
print(sorted(list, key=lambda k: k['z']))
# [{'z': 1, 'x': 3, 'y': 2}, {'z': 2, 'x': 1, 'y': 3}, {'z': 3, 'x': 2, 'y': 1}]
print(sorted(list, key=lambda k: k['x'], reverse=True))
# [{'z': 1, 'x': 3, 'y': 2}, {'z': 3, 'x': 2, 'y': 1}, {'z': 2, 'x': 1, 'y': 3}]
1
2
3
4
5
6
7
8
9
10
11
12
13

7字典(dict)中嵌套列表(list)排序（使用lambda函数）

dic = {
    'a': [1, 2, 3],
    'b': [2, 1, 3],
    'c': [3, 1, 2],
    }
print(sorted(dic, key=lambda k: dic[k][0]))
# ['a', 'b', 'c']
print(sorted(dic, key=lambda k: dic[k][1]))
# ['b', 'c', 'a']
print(sorted(dic, key=lambda k: dic[k][2]))
# ['c', 'b', 'a']
print(sorted(dic, key=lambda k: dic[k][0], reverse=True))
# ['c', 'b', 'a']
1
2
3
4
5
6
7
8
9
10
11
12
13

方法解释

依据lambda的解释，关注的主要是上述例子中k: 之后的表达式，其中k应该代表sorted()函数默认的key值。

比如：在3中，字典默认排序key是字典的键，所以lambda中k代表字典的键，想以字典的值排序，就应该是让排序中的key=dict[k]

在4中，列表默认排序key是列表中的元素，此处列表中的元素依旧是嵌入的列表，所以排序key取嵌入列表的第一项时，可以key=k[0]