Python 匿名函数

Python 匿名函数

有名函数

1
2
3
4
5
6
7
8
9
def f1():
print('from f1')

f1()
f1()

# 执行结果
from f1
from f1

匿名函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def func(x, y):
return x + y

print(func) # 通过函数名拿到内存地址

# 执行结果
<function func at 0x000001D493372EA0>

#########################################################################################
# 通过 函数+() 的方式来调用函数
func(1, 2)
print(func(1, 2))

# 执行结果
3

针对这种简单形式的函数,可以用匿名函数简写成一行
匿名函数本身自带 return

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
print(lambda x, y: x + y)

# 执行结果
<function <lambda> at 0x000001DA1A6A2EA0>

#########################################################################################
# 以下方式不是正规的匿名函数使用方式
res = (lambda x, y: x + y)(1, 2)
print(res)

# 执行结果
3

#########################################################################################
f = lambda x, y: x + y
res = f(1, 2)
print(res)

# 执行结果
3

  1. 不会单独使用,会与其他函数配合使用
  2. 匿名函数在于没有名字,如果没有名字表示用一次就立即回收
  3. 匿名函数的应用场景仅应用于只使用使用一次的场景

匿名函数与其他函数配合使用

配合常用的内置函数:maxminsortedmap, filter

max() 函数

获取薪资最高的人名

max 默认比较的是字典的 key

1
2
3
4
5
6
7
8
9
10
salaries = {
'egon': 3000,
'alex': 100000000,
'wupeiqi': 10000,
'yuanhao': 2000
}
print(max(salaries))

# 执行结果
yuanhao

max() 的结果一定是字典的 key
可以更改比较依据
max(比较对象,key=比较依据)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
salaries = {
'egon': 3000,
'alex': 100000000,
'wupeiqi': 10000,
'yuanhao': 2000
}

def func(k):
return salaries[k]

print(max(salaries, key=func)) # key=指定比较依据

# 执行结果
alex

工作原理:max() 拿到 salaries 的 key结果,传给 key=func ,把 func 的返回值当做比较依据

func 就是一次性的函数,可以用 lambda 替换

1
2
3
4
5
6
7
8
9
10
11
salaries = {
'egon': 3000,
'alex': 100000000,
'wupeiqi': 10000,
'yuanhao': 2000
}

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

# 执行结果
alex

获取薪资最小的人名

1
2
3
4
5
6
7
8
9
10
11
salaries = {
'egon': 3000,
'alex': 100000000,
'wupeiqi': 10000,
'yuanhao': 2000
}

print(min(salaries, key=lambda x: salaries[x]))

# 执行结果
yuanhao

sorted() 排序

默认从小到大排序

1
2
3
4
print(sorted([2, 4, 1, 5]))

# 执行结果
[1, 2, 4, 5]

按照薪资排序,从小到大排队

sorted 默认也是比较字典的 key
如果不给比较依据的话,就按默认的字典key字符串做比较

1
2
3
4
5
6
7
8
9
10
11
salaries = {
'egon': 3000,
'alex': 100000000,
'wupeiqi': 10000,
'yuanhao': 2000
}

print(sorted(salaries))

# 执行结果
['alex', 'egon', 'wupeiqi', 'yuanhao']

所以也要通过所获取的字典key,给予 比较依据,然后再做排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
salaries = {
'egon': 3000,
'alex': 100000000,
'wupeiqi': 10000,
'yuanhao': 2000
}

print(sorted(salaries, key=lambda x: salaries[x]))

# 执行结果
['yuanhao', 'egon', 'wupeiqi', 'alex']

#########################################################################################
# 反序排列
print(sorted(salaries, key=lambda x: salaries[x], reverse=True))

# 执行结果
['alex', 'wupeiqi', 'egon', 'yuanhao']

map() 函数

映射:把一个值映射成一个新的值

需求:把 人名 都映射成 人名_PY

1
2
3
4
5
6
names = ['alex', 'wupeiqi', 'yuanhao', 'liuqingzheng']
l = [name + "_PY" for name in names]
print(l)

# 执行结果
['alex_PY', 'wupeiqi_PY', 'yuanhao_PY', 'liuqingzheng_PY']

map(映射规则, 可迭代对象)

1
2
3
4
5
6
7
8
9
names = ['alex', 'wupeiqi', 'yuanhao', 'liuqingzheng']
obj = map(lambda x:x+"_PY", names) # map 的结果其实就是一个迭代器
print(obj)
# 执行结果
<map object at 0x00000230B9BDCA90>

print(list(obj))
# 执行结果
['alex_PY', 'wupeiqi_PY', 'yuanhao_PY', 'liuqingzheng_PY']

工作原理:会把可迭代对象作为迭代器传给第一个值,作为结果返回出来

filter() 函数

把 人名_sb 结尾的留下

1
2
3
4
5
6
names = ['alex_sb', 'wupeiqi_sb', 'egon', 'yuanhao_sb', 'liuqingzheng_sb']
l = [name for name in names if name.endswith('sb')]
print(l)

# 执行结果
['alex_sb', 'wupeiqi_sb', 'yuanhao_sb', 'liuqingzheng_sb']

filter(过滤规则, 可迭代对象)
filter 会得到 names 的迭代器对象obj,然后 next(obj),将得到的值传给函数

1
2
3
4
5
6
7
8
9
10
names = ['alex_sb', 'wupeiqi_sb', 'egon', 'yuanhao_sb', 'liuqingzheng_sb']
res = filter(lambda x: x.endswith('sb'), names) # filte 将函数返回值为 True 的那个值留下
print(res)
# 执行结果
<filter object at 0x000001867584C9B0>

#########################################################################################
print(list(res))
# 执行结果
['alex_sb', 'wupeiqi_sb', 'yuanhao_sb', 'liuqingzheng_sb']

也可以用 生成器表达式 来做

1
2
3
4
5
6
7
8
9
10
names = ['alex_sb', 'wupeiqi_sb', 'egon', 'yuanhao_sb', 'liuqingzheng_sb']
l = (name for name in names if name.endswith('sb'))
print(l)
# 执行结果
<generator object <genexpr> at 0x00000209162E55C8>

#########################################################################################
print(list(l))
# 执行结果
['alex_sb', 'wupeiqi_sb', 'yuanhao_sb', 'liuqingzheng_sb']

---------------- The End ----------------
0%