【Python基础】详解匿名函数 lambda 和函数式编程

匿名函数在实际工作中同样举足轻重，它们往往很简短，就一行，并且有个很酷炫的名字——lambda。正确地运用匿名函数，能让我们的代码更简洁、易读。

匿名函数基础

匿名函数的关键字是 lambda，之后是一系列的参数，然后用冒号隔开，最后则是由这些参数组成的表达式。

lambda argument1, argument2,... argumentN : expression

匿名函数 lambda 和常规函数 def 一样，返回的都是一个函数对象（function object），它们的用法也极其相似，不过还是有下面几点区别。

1.lambda 是一个表达式（expression），并不是一个语句（statement）。

所谓的表达式，就是用一系列“公式”去表达一个东西，比如 x+2、 x**2 等等；而所谓的语句，则一定是完成了某些功能，比如赋值语句 x = 1 完成了赋值，print 语句 print(x) 完成了打印变量 x，条件语句 if x < 0: 完成了选择功能等等。

常规函数 def 必须通过其函数名被调用，因此必须首先被定义。但是作为一个表达式的 lambda，返回的函数对象就不需要名字了。因此，lambda 可以用在一些常规函数 def 不能用的地方，比如，lambda 可以用在列表内部，而常规函数却不能：

[(lambda x: x*x)(x) for x in range(10)] # [(lambda x: x*x)(参数x) for 参数x in range(10)]
# 输出
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

再比如，lambda 可以被用作某些函数的参数，而常规函数 def 也不能：

l = [(1, 20), (3, 0), (9, 10), (2, -1)]
l.sort(key=lambda x: x[1]) # 按列表中元祖的第二个元素排序
print(l)
# 输出
[(2, -1), (3, 0), (9, 10), (1, 20)]

2.lambda 的主体是只有一行的简单表达式，并不能扩展成一个多行的代码块。

Python 之所以发明 lambda，就是为了让它和常规函数 def 各司其职：lambda 专注于简单的任务，而常规函数 def 则负责更复杂的多行逻辑。

为什么要使用匿名函数？

通常，我们用函数的目的无非就是这么几点：

1. 减少代码的重复性；
   如果你的程序在不同地方包含了相同的代码，那么我们就会把这部分相同的代码写成一个函数，并为它取一个名字，方便在相对应的不同地方调用。
2. 模块化代码。
   如果你的一块儿代码是为了实现一个功能，但内容非常多，写在一起降低了代码的可读性，那么通常我们也会把这部分代码单独写成一个函数，然后加以调用。

不过，再试想一下这样的情况。你需要一个函数，但它非常简短，只需要一行就能完成；同时它在程序中只被调用一次而已。那么请问，你还需要像常规函数一样，给它一个定义和名字吗？

答案当然是否定的。这种情况下，函数就可以是匿名的，你只需要在适当的地方定义并使用，就能让匿名函数发挥作用了。理论上来说，Python 中有匿名函数的地方，都可以被替换成等价的其他表达形式，一个 Python 程序实际上是可以不用任何匿名函数的。不过，在一些情况下，使用匿名函数 lambda，可以帮助我们大大简化代码的复杂度，提高代码的可读性。

举一个例子，在 Python 的 Tkinter GUI 应用中，如果想实现这样一个简单的功能：创建显示一个按钮，每当用户点击时，就打印出一段文字。那么，使用 lambda 函数就可以表示成下面这样：

from tkinter import Button, mainloop
button = Button(
    text='This is a button',
    command=lambda: print('being pressed')) # 点击时调用lambda函数
button.pack()
mainloop()

而如果我们使用常规函数 def，那么需要写更多的代码：

from tkinter import Button, mainloop

def print_message():
    print('being pressed')

button = Button(
    text='This is a button',
    command=print_message) # 点击时调用lambda函数
button.pack()
mainloop()

显然，运用匿名函数的代码简洁很多，也更加符合 Python 的编程习惯。

Python 函数式编程

所谓函数式编程，是指代码中每一块都是不可变的（immutable），都由纯函数（pure function）的形式组成。这里的纯函数，是指函数本身相互独立、互不影响，对于相同的输入，总会有相同的输出，没有任何副作用。

举个很简单的例子，比如对于一个列表，我们想让列表中的元素值都变为原来的两倍，可以写成下面的形式：

def multiply_2(l):
    for index in range(0, len(l)):
        l[index] *= 2
    return l

# 测试
l = [1,2,3,4]
multiply_2(l)
[2, 4, 6, 8]
multiply_2(l)
[4, 8, 12, 16]
multiply_2(l)
[8, 16, 24, 32]

但是，这段代码就不是一个纯函数的形式，因为列表中元素的值被改变了，如果多次调用 multiply_2() 这个函数，那么每次得到的结果都不一样。要想让它成为一个纯函数的形式，就得写成下面这种形式，重新创建一个新的列表并返回。

def multiply_2_pure(l):
    new_list = [] # 重新创建一个新的列表
    for item in l:
        new_list.append(item * 2)
    return new_list

# 测试
l = [1,2,3,4]
multiply_2_pure(l)
[2, 4, 6, 8]
multiply_2_pure(l)
[2, 4, 6, 8]
multiply_2_pure(l)
[2, 4, 6, 8]

函数式编程的优点，主要在于其纯函数和不可变的特性使得程序更加健壮，易于调试（debug）和测试；但缺点主要在于限制多，难写。当然，Python 并不是一门函数式编程语言，不过，它也提供了一些函数式编程的特性，主要是提供了这么几个函数：map()、filter() 和 reduce()，通常结合匿名函数 lambda 一起使用。

1.map(function, iterable)

函数 map(function, iterable) 的第一个参数是函数对象，第二个参数是一个可以遍历的集合，它表示对 iterable 的每一个元素，都运用 function 这个函数，最后返回一个新的可遍历的集合（Python 2.x 返回一个列表；Python 3.x 返回一个迭代器。）。比如刚才的例子，要让列表中的元素值都变为原来的两倍，那么用 map 就可以表示为下面这样：

l = [1, 2, 3, 4, 5]
new_list = list(map(lambda x: x * 2, l)) # Python 3中 map()返回一个迭代器，而不是列表
new_list
[2, 4, 6, 8, 10]

相比起用 for 循环和 list comprehension（列表解析）对列表进行操作，map() 提供的函数式编程接口的性能是最快的，因为 map() 函数直接由 C 语言写的，运行时不需要通过 Python 解释器间接调用，并且内部做了诸多优化，所以运行速度最快。

2.filter(function, iterable)

filter() 函数表示对 iterable 中的每个元素，都使用 function 判断，并返回 True 或者 False，最后将返回 True 的元素组成一个新的可遍历的集合（Python 2.x 中返回的是过滤后的列表, 而Python 3.x 返回的是一个 filter 类，可以看成是一个迭代器）。举个例子，比如我们要返回一个列表中的所有偶数，可以写成下面这样：

list_2 = [1, 2, 3, 4, 5]
new_list = list(filter(lambda x: x % 2 == 0, list_2))  # Python 3返回的是一个 filter类,可以看成是一个迭代器, 有惰性运算的特性, 相对 Python2.x 提升了性能, 可以节约内存。
print(new_list) 
[2, 4]

3.reduce(function, iterable)

reduce() 函数通常用来对一个集合做一些累积操作。第一个参数 function 同样是一个函数对象，规定它有两个参数，表示对第二个参数 iterable 中的每个元素以及上一次调用后的结果，运用 function 进行计算，所以最后返回的是一个单独的数值。需要注意的是，在 Python3 中，reduce() 函数已经被从全局名字空间里移除了，它现在被放置在 functools 模块里，如果想要使用它，则需要通过引入 functools 模块来调用 reduce() 函数。举个例子，比如想要计算某个列表元素的乘积，就可以用 reduce() 函数来表示：

from functools import reduce

l = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, l)
product
120 # 1*2*3*4*5 = 120

当然，类似的，filter() 和 reduce() 的功能，也可以用 for 循环或者 list comprehension 来实现。通常来说，当我们想对集合中的元素进行一些操作时，如果操作非常简单，比如相加、累积这种，那么我们优先考虑 map()、filter()、reduce() 这类 Python 提供的函数式编程接口，或者 list comprehension 的形式。

• 在数据量非常多的情况下，比如机器学习的应用，那我们一般更倾向于函数式编程的表示，因为效率更高；
• 在数据量不多的情况下，并且你想要程序更加 Pythonic 的话，那么 list comprehension 也不失为一个好选择。
• 不过，如果你要对集合中的元素，做一些比较复杂的操作，那么，考虑到代码的可读性，我们通常会使用 for 循环，这样更加清晰明了。

小结

1. Python 中的匿名函数 lambda 的主要用途是减少代码的复杂度。
2. 需要注意的是 lambda 是一个表达式，并不是一个语句；它只能写成一行的表达形式，语法上并不支持多行。
3. 匿名函数的使用场景通常是：程序中需要使用一个函数完成一个简单的功能，并且该函数只调用一次。
4. 函数式编程的优点，主要在于其纯函数和不可变的特性使程序更加健壮，易于调试（debug）和测试；缺点主要在于限制多，难写。
5. Python 也提供了一些函数式编程的特性，比如常见的 map()，fiilter() 和 reduce() 三个函数，相比其他形式（for 循环，list comprehension），它们的性能效率是最优的。

参考

《Python核心技术与实战》