Python匿名函数Lambda

一、概念介绍

1.匿名函数介绍

在Python中，通过lambda关键字来定义的函数称为匿名函数；
lambda函数能接收任何数量（可以是0个）的参数，但只能返回一个表达式的值，lambda函数是一个函数对象，直接赋值给一个变量，这个变量就成了一个函数对象
语法：lambda 参数 : 表达式
先写lambda关键字，然后依次写匿名函数的参数，多个参数中间用英文逗号分隔，然后是一个英文冒号，冒号后面写返回的表达式；

2.匿名函数与普通函数的对比

def sum_func(a, b, c):
    return a + b + c

sum_lambda = lambda a, b, c: a + b + c

print(sum_func(1, 100, 10000))
print(sum_lambda(1, 100, 10000))

运行结果：

10101
10101

  • 可以看到，lambda适用于多个参数、一个返回值的情况，可以用一个变量来接收，变量是一个函数对象，执行这个函数对象的结果与执行一个普通函数的结果一样。

  • lambda函数比普通函数更简洁，且没有声明函数名，上面的代码是用一个变量来接收lambda函数返回的函数对象，并不是lambda函数的名字。

3.匿名函数的多种形式

#无参数
lambda_a = lambda :1001
print(lambda_a())

#一个参数
lambda_b = lambda b : b * 10
print(lambda_b(10))

#多个参数
lambda_c = lambda a,b,c : a+b+c
print(lambda_c(5,6,7))

#表达式
lambda_d = lambda x: x if x % 2 ==0 else x+1
print(lambda_d(5))
print(lambda_d(6))

运行结果：

1001
100
18
6
6

lambda的参数可以是0个或多个，并且返回的表达式可以是一个复杂的表达式，只要最后返回的是一个值就可以了；

4.lambda作为一个参数传递

def sub_func(a,b,func):
    print('a = ',a)
    print('b = ',b)
    print('a + b = ',func(a,b))

sub_func(12,5,lambda a,b:a+b)

运行结果：

a =  12
b =  5
a + b =  17

5.lambda函数与python内置函数配合使用

list1 = [{'a': 10, 'b': 20}, {'a': 13, 'b': 2}, {'a': 23, 'b': 13}, {'a': 32, 'b': 17}]
max_a = max(list1, key=lambda x: x['a'])		# 列表元素中关键字'a'的最大值
max_b = max(list1, key=lambda x: x['b'])		# 列表元素中关键字'b'的最大值

print('列表最大数：', max_a)
print('列表最大数：', max_b)

运行结果：

列表最大数： {'a': 32, 'b': 17}
列表最大数： {'a': 10, 'b': 20}

6.lambda作为函数的返回值

def ret_func(a,b):
    return lambda c : a + b + c
return_func = ret_func(50, 51)
print(return_func)
print(return_func(4))

运行结果：

<function ret_func.<locals>.<lambda> at 0x000001711D2B8400>
105

匿名函数可以作为一个函数的返回值，在如上代码中，ret_func返回的是一个匿名函数，返回的是一个函数对象，当执行这个函数时，可以得到lamdba函数的结果。
注意：其中a,b两个参数是ret_func中的参数，但执行返回的函数return_func时，已经不在ret_func的作用域内，而lambda函数仍然能使用a,b,参数，说明lambda函数会将它的运行环境保存一份，一直保留到它自己执行的时候使用。

7.匿名函数的优点

  • 使用Python写一些脚本时，使用lambda可以省去定义函数的过程，让代码更精简；
  • 对于一些抽象的，不会被别的地方再重复使用的函数，有时候函数起个名称也是个难题，使用lambda不需要考虑命命名问题；
  • 使用lambda在某些时候代码更容易理解

二、使用场景

使用场景：
1.需要将一个函数对象作为参数来传递时，可以直接定义一个lambda函数（作为函数的参数或返回值）；
2.要处理的业务符合lambda函数的情况（任意多个参数和一个返回值），并且只有一个地方会使用这个函数，不会在其他地方重用，可以使用lambad函数；
3.与一些python的内置函数配合合适，提高代码的可读性；

1、和map函数一起使用

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回

遍历序列，对序列中每个元素进行函数操作，最终获取新的序列。

案例如下：

求列表[1,2,3,4,5,6,7,8,9],返回一个n*n 的列表

#一般解决方案
li = [1,2,3,4,5,6,7,8,9]
for ind,val in enumerate(li):
    li[ind] = val * val
print(li)

[1, 4, 9, 16, 25, 36, 49, 64, 81]

$\textcolor{blue}{enumerate()是python的内置函数, 在字典赏识枚举、列举的意思；}$
$\textcolor{blue}{enumerate参数为可遍历/可迭代的对象（如列表、字符串）；}$
$\textcolor{blue}{enumerate多用于在for循环中得到计数，利用它可以同时获得索引和值，即需要 index 和 value 值的时候可以使用enumerate；}$
$\textcolor{blue}{enumerate()返回的是一个enumerate对象 。}$

#高级解决方案
li = [1,2,3,4,5,6,7,8,9]
print(list(map(lambda x:x*x,li)))

[1, 4, 9, 16, 25, 36, 49, 64, 81]

2、与reduce函数一起使用

reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：

reduce(func,[1,2,3]) 等同于 func(func(1,2),3),返回值为单个值

对于序列内所有元素进行累计操作

#接受一个list并利用reduce()求积
from functools import reduce
li = [1,2,3,4,5,6,7,8,9]
print(reduce(lambda x,y:x * y,li))

结果 : 123456789 = 362880

a = [12, 34, 56]

print reduce(lambda x , y: x + y, a)  # 102

print reduce(lambda x , y: x - y, a) # -78

3、和filter函数一起使用

filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

对于序列中的元素进行筛选，最终获取符合条件的序列

在一个list中，删掉偶数，只保留奇数

li = [1, 2, 4, 5, 6, 9, 10, 15]
print(list(filter(lambda x:x % 2==1,li)))  # [1, 5, 9, 15]

回数是指从左向右读和从右向左读都是一样的数，例如12321，909。请利用filter()筛选出回数

li = list(range(1, 200))
print(list(filter(lambda x:int(str(x))==int(str(x)[::-1]),li)))

[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191]

4、和sorted函数一起使用

sorted(iterable, /, *, key=None, reverse=False)

接收一个key函数来实现对可迭代对象进行自定义的排序

可迭代对象：主要与列表，字符串，元祖，集合和字典

key：接受一个函数，根据此函数返回的结果，进行排序

reverse：排序方向，默认为从小到大，reverse=True为逆向

对列表按照绝对值进行排序

li= [-21, -12, 5, 9, 36]
print(sorted(li, key = lambda x:abs(x)))

[5, 9, -12, -21, 36]

"""
sorted()函数按照keys进行排序，并按照对应关系返回list相应的元素：

keys排序结果 => [5, 9, 12, 21, 36]
| | | | |
最终结果 => [5, 9, -12, -21, 36]
"""

把下面单词以首字母排序

li = ['bad', 'about', 'Zoo', 'Credit']
print(sorted(li, key = lambda x : x[0]))

输出['Credit', 'Zoo', 'about', 'bad']

"""
对字符串排序，是按照ASCII的大小比较的，由于'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面。
"""

假设我们用一组tuple表示学生名字和成绩：

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]

请用sorted()对上述列表分别按名字排序

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

输出[('Adam', 92), ('Bart', 66), ('Bob', 75), ('Lisa', 88)]

再按成绩从高到低排序

print(sorted(L, key = lambda x : x[1], reverse=True))

输出[('Adam', 92), ('Lisa', 88), ('Bob', 75), ('Bart', 66)]

5、与三元运算结合

如下：

#if 条件为真的时候返回if前面内容，否则返回0 
exp1= lambda x:x+1 if 2==1 else 0 
print(exp1(2))
exp2 = lambda x:x+1 if 1==1 else 0 
print(exp2(2))

输出：

0
3

#if not 为假返回if not前面内容，否则返回0  
exp3 = lambda x:x+1 if not 2==1 else 0  
print(exp3(2))  

exp4 = lambda x:x+1 if not 1==1 else 0  
print(exp4(2))

输出：
3
0