函数式编程

函数赋值给变量

在 Python 中，所有的对象都可以赋值给变量，包括函数。这可能有点出乎意料，我们不妨来试一试：

def say_hello(name):
    return name + ', hello!'

f = say_hello

>>> f(‘开发者’)
‘开发者, hello!’

>>> f
<function say_hello at 0x10befec80>

注意，这里被赋值的是函数本身，而不是函数的结果。赋值后，变量 f与函数 say_hello 绑定，f 也就相当于是 say_hello 的别名，完全可以用调用 say_hello 的方式来调用 f

扩展：类也可以赋值给变量。如：

class Apple:
    who_am_i = 'apple'

banana = Apple

>>> banana.who_am_i
’apple’

注意，被赋值的是类本身，而不是类实例化后的对象。赋值后，变量 banana 与类 Apple 绑定，banana 也就相当于是 Apple 的别名，使用 banana 就相当于使用 Apple。

函数作为函数参数

一切对象都可以作为函数的参数，包括另一个函数。接受函数作为参数的函数，称为高阶函数。这和数学中的高阶函数有些相似。

来看一个函数作为参数的例子。

这个例子中，我们实现了一个函数，它从给定的数字列表中筛选数字，而具体的筛选策略由另一个函数决定并以参数的形式存在：

def filter_nums(nums, want_it):
    return [n for n in nums if want_it(n)]

函数 filter_nums 用来筛选数字，它接受两个参数，nums 是包含所有待筛选数字的列表，want_it 是一个函数，用来决定某个数字是否保留。

我们选定一个简单的策略来实现下 want_it 参数所对应的函数（其函数名不必为 want_it）：

def want_it(num):
    return num % 2 == 0

这里 want_it 接受一个数字作为参数，如果这个数字是 2 的倍数，则返回 True，否则返回 False。

调用一下 filter_nums 试试：

>>> def filter_nums(nums, want_it):
…     return [n for n in nums if want_it(n)]
…
>>> def want_it(num):
…     return num % 2 == 0
…
>>> filter_nums([11, 12, 13, 14, 15, 16, 17, 18], want_it)
[12, 14, 16, 18]

这里每个数字都经过 want_it() 函数的判断，而 want_it() 是以 filter_num() 第二个参数的形式传递进去，供 filter_num() 调用。

lambda 表达式

在 Python 中，可以通过 lambda 表达式来便捷地定义一个功能简单的函数，这个函数只有实现没有名字，所以叫作匿名函数。

lambda 表达式的写法如下：

lambda 参数1, 参数2, 参数N: 函数实现

使用上述表达式将定义一个匿名函数，这个匿名函数可接受若干参数，参数写在冒号前（:），多个参数时用逗号分隔，其实现写在冒号后（:）。

举个例子：

f = lambda x: x ** 2

这个 lambda 表达式定义了一个匿名函数，这个匿名函数接受一个参数 x，返回 x ** 2 的计算结果。同时赋值语句将这个匿名函数赋值给了变量 f。注意 f 保存的是函数，而不是函数结果。

>>> f
<function at 0x10bcba0d0>

>>> f(4)
16
>>> f(9)
81

通过观察上述示例可以发现，lambda 表达式中并没有 return 关键字，但结果被返回出来。是的，匿名函数的 函数实现 的执行结果就会作为它的返回值，无需使用 return 关键字。

从功能上来看，lambda x: x ** 2 等同于：

def no_name(x):
    return x ** 2

>>> no_name(4)
16

一般情况下，我们不会像 f = lambda x: x ** 2 这样直接将匿名函数赋值给变量，然后去用这个变量。而是在需要将函数作为参数时，才去使用 lambda 表达式，这样就无需在函数调用前去定义另外一个函数了。

如我们刚才写的函数 filter_nums：

def filter_nums(nums, want_it):
    return [n for n in nums if want_it(n)]

它的 want_it 参数需要是一个函数 ，这时用 lambda 表达式便能方便的解决问题。可以像这样来使用：

>>> filter_nums([11, 12, 13, 14, 15, 16, 17, 18], lambda x: x % 2 == 0)
[12, 14, 16, 18]

以前讲内置函数的时候，我们介绍过排序函数 sorted()。它有一个参数 key，用来在排序复杂元素时，指定排序所使用的字段，这个参数需要是个函数，同样可以用 lambda 表达式来解决：

>>> codes = [(‘上海’, ‘021’), (‘北京’, ‘010’), (‘成都’, ‘028’), (‘广州’, ‘020’)]
>>> sorted(codes, key=lambda x: x[1]) # 以区号字典来排序
[(‘北京’, ‘010’), (‘广州’, ‘020’), (‘上海’, ‘021’), (‘成都’, ‘028’)]

map() 和 filter()

Python 内置有两个非常好用的高阶函数 map() 和 filter()。

filter() 用于从可迭代对象中筛选元素。用法如下：

filter(筛选函数, 可迭代对象)

filter() 依次对 可迭代对象 中的每个元素调用 筛选函数，如果返回值为 True，则当前这个元素会被保留，否则被排除。最终返回一个包含所有被保留元素的迭代器。

显然这里的 筛选函数 可以用 lambda 表达式来创建。

例如，从 ['a', 'b', 'cd', 'efg', 'hig', 'klmn', 'opqr'] 筛选出长度为奇数的字符串。可以这样写：

filter(lambda x: len(x) % 2 == 1, ['a', 'b', 'cd', 'efg', 'hig', 'klmn', 'opqr'])

>>> list(filter(lambda x: len(x) % 2 == 1, [‘a’, ‘b’, ‘cd’, ‘efg’, ‘hig’, ‘klmn’, ‘opqr’]))
[‘a’, ‘b’, ‘efg’, ‘hig’]

这里我们用 list() 将迭代器转换为列表。

map() 用于对可迭代对象中每一个元素逐一作处理。用法如下：

map(处理函数, 可迭代对象)

map() 依次对 可迭代对象 中的每个元素调用 处理函数，最终返回一个包含所有被处理过后的元素的迭代器。

显然这里的 处理函数 也可以用 lambda 表达式来创建。

例如，将 ['a', 'b', 'cd', 'efg', 'hig', 'klmn', 'opqr'] 全部转换为大写。可以这样来写：

map(lambda x: x.upper(), ['a', 'b', 'cd', 'efg', 'hig', 'klmn', 'opqr'])

>>> list(map(lambda x: x.upper(), [‘a’, ‘b’, ‘cd’, ‘efg’, ‘hig’, ‘klmn’, ‘opqr’]))
[‘A’, ‘B’, ‘CD’, ‘EFG’, ‘HIG’, ‘KLMN’, ‘OPQR’]

这里我们用 list() 将迭代器转换为列表。