Python 提供 3 种内建函数和 lambda 表达式等来支持函数式编程。

匿名函数

Python 允许用 lambda 关键字创造匿名函数。匿名顾名思义就是没有名字，即不需要以标准的方式来声明，比如说，使用 def 加函数名来声明。一个完整的 lambda “语句”代表了一个表达式，这个表达式的定义体必须和声明放在同一行。语法如下：

lambda [arg1[, arg2, ... argN]]: expression

参数是可选的，如果使用参数的话，参数通常也会出现在表达式中。

注意：lambda 表达式返回可调用的函数对象。其实 lambda 表达式本身就是一个函数，这个函数定义了输入（冒号左边）和输出（冒号右边），只不过这个函数没有名字，但是我们可以把它赋给一个变量。

比如简单的加法函数。一般我们是这么写的：

def add(x, y):
    return x+y

lambda 表达式这么写：

lambda x, y : x + y

我们可以把 lambda x, y : x + y 赋值给 f ，然后给 f 传参数：

>>> f = lambda x, y : x + y
>>> f
 at 0x10377f320>
>>> f(-10,8)
-2
>>> f(12, 100)
112
>>> f(-33, -22)
-55

可以看到，f 确实是个函数，可以接收两个参数，并返回这两个参数的和，等价于上面的 add 函数。

使用场景

1、函数式编程
2、闭包
简单粗暴地理解为闭包就是一个定义在函数内部的函数，闭包使得变量即使脱离了该函数的作用域范围也依然能被访问到。

高阶函数

高阶函数英文叫 Higher-order function 。一般函数的输入参数和返回值都只能是变量或常量，如果某个函数可以接收函数作为其输入参数，或者其返回值中包含函数，那么该函数就是高阶函数。
Python 中有三个内建的用来支持函数式编程的高阶函数，分别是 filter()，map() 和 reduce()。

filter()

filter(function, sequence) 返回一个 sequence (序列)，返回的序列中包括了输入序列中所有调用 function(item) 后返回值为 true 的元素。

举个栗子：

>>> def f(x): return x % 3 == 0 or x % 5 == 0
...
>>> filter(f, range(2, 25))
[3, 5, 6, 9, 10, 12, 15, 18, 20, 21, 24]

因为 filter() 的输入参数中包含函数 f() ，所以 filter() 是高阶函数。上面的例子中返回 2~24 中能被 3 或 5 整除的数组成的列表。

当然，也可以使用匿名函数 lambda 表达式实现：

>>> filter(lambda x : x % 3 == 0 or x % 5 == 0, range(2, 25))
[3, 5, 6, 9, 10, 12, 15, 18, 20, 21, 24]

或者使用列表生成式：

>>> [x for x in range(2, 25) if x % 3 == 0 or x % 5 == 0]
[3, 5, 6, 9, 10, 12, 15, 18, 20, 21, 24]

map()

map() 与 filter() 相似，因为它也能通过函数来处理序列。map()将函数调用“映射”到序列的每个元素上，并返回一个含有所有返回值的列表。

举个栗子：

>>> def cube(x): return x**3
...
>>> map(cube, range(1,11))

[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

上面的例子中，将 1~10 里的每个数分别调用 cube() ，并将返回值（x 的 3 次方）放入列表中。

lambda 表达式：

>>> map(lambda x : x**3, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

列表生成式：

>>> [x**3 for x in range(1, 11)]
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

注意：map() 也可以处理多个序列。

>>> map(lambda x, y: x + y, [1, 3, 5], [2, 4, 6])
[3, 7, 11]
>>> map(lambda x, y: (x+y, x-y), [1, 3, 5], [2, 4, 6])
[(3, -1), (7, -1), (11, -1)]
>>> map(None, [1, 3, 5], [2, 4, 6])
[(1, 2), (3, 4), (5, 6)]

reduce()

reduce(function, sequence) 返回一个单值，它是这样构造的：首先以序列的前两个元素调用函数 function，再以返回值和第三个参数调用，依次执行下去。

例如，以下程序计算 0 到 5 的整数之和:

>>> def add(x, y): return x+y
...
>>> reduce(add, range(0, 5))
10

实际上 reduce() 执行了如下的运算：

((((0+1)+2)+3)+4)   ==>  10

lambda 表达式：

reduce(lambda x, y : x + y, range(0, 5))

偏函数

偏函数解决这样的问题：如果我们有函数是多个参数的，我们希望能固定其中某几个参数的值（类似于默认值）。

举个栗子：

int() 函数可以把字符串转换为整数，当仅传入字符串时，int() 函数默认按十进制转换：

>>> int('11111')
11111

但 int() 函数还提供额外的 base 参数（默认值为10） 。如果传入 base 参数，就可以做 N 进制的转换：

>>> int('11111',8)
4681
>>> int('11111',base=16)
69905

假设要转换大量的二进制字符串，每次都传入 int(x, base=2) 非常麻烦，于是，我们想到，可以定义一个 int2() 的函数，默认把 base=2 传进去：

def int2(x, base=2):
    return int(x, base)

这样，我们就可以方便地转换二进制了：

>>> int2('1000000')
64
>>> int2('1010101')
85

functools.partial 就是帮助我们创建一个偏函数的，不需要我们自己定义 int2() ，可以直接使用下面的代码创建一个新的函数 int2 ：

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('11111')
31
>>> int2('10000')
16

总结一下，functools.partial 的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

需要注意的是，上面的新的 int2 函数，仅仅是把 base 参数重新设定默认值为 2 ，但也可以在函数调用时传入其他值：

>>> int2('11111',base=10)
11111
>>> int2('11111',base=8)
4681