Python从零单排系列（一）—初识Python
Python从零单排系列（二）—Python基础
Python从零单排系列（三）—Python函数
Python从零单排系列（四）—面向对象编程
Python从零单排系列（五）—模块化以及相关库
Python从零单排系列（六）—异常处理
Python从零单排系列（八）—Python高级特性
引言
函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。
而函数式编程（请注意多了一个“式”字）——Functional Programming，虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算。
来自维基百科中对函数式编程的解释:
函数式编程，或称函数程序设计，又称泛函编程，是一种编程范型，它将电脑运算视为数学上的函数计算，并且避免使用程序状态以及易变对象。函数编程语言最重要的基础是λ演算。而且λ演算的函数可以接受函数当作输入 （引数）和输出（传出值）。
比起命令式编程，函数式编程更强调程序执行的结果而非执行的过程，倡导利用简单的执行单元让计算结果不断渐进，逐层推导复杂的运算，而不是设计一个复杂的执行过程。
Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。
命令式编程 & 函数式编程
认识函数式编程，从我们熟悉的命令式编程开始。其实，不管我们的业务代码有多复杂，都离不开以下几类操作：
- 函数定义：def
- 条件控制：if, elif, else
- 循环控制：for, break, continue, while
对应地，函数式编程也有自己的基本单元：
- 基本函数：map()、reduce()、filter()、sorted()
- 匿名函数：lambda
我们用以上单元就基本可以写完整的Python项目了，可见函数式编程抽象的力度之大。
lambda函数
在展开之前，我们先提一下lambda函数，又称匿名函数。可以利用lambda函数的语法，定义函数。lambda例子如下：
1
2
func = lambda x,y: x + y
print func(3,4)
lambda生成一个函数对象。该函数参数为x,y，返回值为x+y。函数对象赋给func。func的调用与正常函数无异。
以上定义可以写成以下形式：
1
2
def func(x, y):
return x + y
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：
1
2
3
4
5
>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25
同样，也可以把匿名函数作为返回值返回，比如：
1
2
def build(x, y):
return lambda: x * x + y * y
內建高阶函数
函数式编程之所以是一种抽象程度很高的编程范式，主要是得利于高度封装的函数。python 对函数式编程(Functional Programming)的重要支持方式就是允许把函数本身作为参数传入另一个函数，还允许返回一个函数。 由此可以引申出高阶函数(Higher-order function)
如上述的map()、reduce()、filter()、sorted()，这些都是Python中常见的內建高阶函数，下面来逐一介绍。
Map()
map()函数的常见调用形式如下所示：
1
map(func, iterable)
map()需要两个必填参数，第一个参数是一个函数名，第二个参数是一个可迭代的对象，如列表、元组等。
map()实现的功能很简单，就是将第二个参数（iterable）中的每一个元素分别传给第一个参数（func），依次执行函数得到结果，并将结果组成一个新的list对象后进行返回。返回结果永远都是一个list。
简单示例如下：
1
2
3
>>> double_func = lambda s : s * 2
>>> map(double_func, [1,2,3,4,5])
[2, 4, 6, 8, 10]
除了传入一个可迭代对象这种常见的模式外，map()还支持传入多个可迭代对象。
1
map(func, iterable1, iterable2)
在传入多个可迭代对象的情况下，map()会依次从所有可迭代对象中依次取一个元素，组成一个元组列表，然后将元组依次传给func；若可迭代对象的长度不一致，则会以None进行补上。
通过以下示例应该就比较容易理解。
1
2
3
4
5
6
7
>>> plus = lambda x,y : (x or 0) + (y or 0)
>>> map(plus, [1,2,3], [4,5,6])
[5, 7, 9]
>>> map(plus, [1,2,3,4], [4,5,6])
[5, 7, 9, 4]
>>> map(plus, [1,2,3], [4,5,6,7])
[5, 7, 9, 7]
在上面的例子中，之所以采用x or 0的形式，是为了防止None + int出现异常。
需要注意的是，可迭代对象的个数应该与func的参数个数一致，否则就会出现异常，因为传参个数与函数参数个数不一致了，这个应该比较好理解。
1
2
3
4
5
>>> plus = lambda x,y : x + y
>>> map(plus, [1,2,3])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: <lambda>() takes exactly 2 arguments (1 given)
另外，map()还存在一种特殊情况，就是func为None。这个时候，map()仍然是从所有可迭代对象中依次取一个元素，组成一个元组列表，然后将这个元组列表作为结果进行返回。
1
2
3
4
5
6
7
8
>>> map(None, [1,2,3,4])
[1, 2, 3, 4]
>>> map(None, [1,2,3,4], [5,6,7,8])
[(1, 5), (2, 6), (3, 7), (4, 8)]
>>> map(None, [1,2,3,4], [5,6,7])
[(1, 5), (2, 6), (3, 7), (4, None)]
>>> map(None, [1,2,3,4], [6,7,8,9], [11,12])
[(1, 6, 11), (2, 7, 12), (3, 8, None), (4, 9, None)]
Reduce()
reduce()函数的调用形式如下所示：
1
reduce(func, iterable[, initializer])
reduce()函数的功能是对可迭代对象（iterable）中的元素从左到右进行累计运算，最终得到一个数值。第三个参数initializer是初始数值，可以空置，空置为None时就从可迭代对象（iterable） 的第二个元素开始，并将第一个元素作为之前的结果。
文字描述可能不大清楚，看下reduce()的源码应该就比较清晰了。
1
2
3
4
5
6
7
8
9
10
11
def reduce(function, iterable, initializer=None):
it = iter(iterable)
if initializer is None:
try:
initializer = next(it)
except StopIteration:
raise TypeError('reduce() of empty sequence with no initial value')
accum_value = initializer
for x in it:
accum_value = function(accum_value, x)
return accum_value
再加上如下示例，对reduce()的功能应该就能掌握了。
1
2
3
4
5
>>> plus = lambda x, y : x + y
>>> reduce(plus, [1,2,3,4,5])
15
>>> reduce(plus, [1,2,3,4,5], 10)
25
Filter()
filter()函数的调用形式如下：
1
filter(func, iterable)
filter()有且仅有两个参数，第一个参数是一个函数名，第二个参数是一个可迭代的对象，如列表、元组等。
filter()函数的调用形式与map()比较相近，都是将第二个参数（iterable）中的每一个元素分别传给第一个参数（func），依次执行函数得到结果；差异在于，filter()会判断每次执行结果的bool值，并只将bool值为true的筛选出来，组成一个新的列表并进行返回。
1
2
3
>>> mode2 = lambda x : x % 2
>>> filter(mode2, [1,2,3,4,5,6,7,8,9,10])
[1, 3, 5, 7, 9]
Sorted()
Python内置的sorted()函数就可以对list进行排序，sorted()也是一个高阶函数，调用形式如下：
1
sorted(iterable, cmp=None, key=None, reverse=False)
filter()有四个参数，第一个参数是一个可迭代对象，第二个是 ，第三个可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序，其实相当于用传入的函数(比如abs)对list进行map，作为key， 然后按key排序，返回list，第四个选择排序顺序，默认为False正序。
如下示例：
1
2
3
>>>lst = [36, 5, -12, 9, -21]
>>>sorted(lst,key=abs)
[5, 9, -12, -21, 36]
再如：
1
2
3
4
5
>>>sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower) # 忽略大小写
['about', 'bob', 'Credit', 'Zoo']
>>>sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True) # 逆序
['Zoo', 'Credit', 'bob', 'about']
以上就是Python中几个常见的內建高阶函数，像这种把函数作为参数传入的函数称为高阶函数。除了上述列举的，Python中还有像all()、any()、enumerate()、zip()等也都是高阶函数。
闭包
闭包(closure)是函数式编程的重要的语法结构。在Python中，一个闭包就是你调用了一个函数A，这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。 你在调用函数A的时候传递的参数就是自由变量。
举个例子：
1
2
3
4
5
6
7
def func(name):
def inner_func(age):
print 'name:', name, 'age:', age
return inner_func
bb = func('the5fire')
bb(26) # >>> name: the5fire age: 26
这里面调用func的时候就产生了一个闭包——inner_func,并且该闭包持有自由变量——name，因此这也意味着，当函数func的生命周期结束之后，name这个变量依然存在，因为它被闭包引用了，所以不会被回收。
另一个需要注意的问题是，返回的函数并没有立刻执行，而是直到调用了bb()才执行。我们再来看一个例子：
1
2
3
4
5
6
7
8
9
def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs
f1, f2, f3 = count()
在上面的例子中，每次循环，都创建了一个新的函数，然后，把创建的3个函数都返回了。
你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果是：
1
2
3
4
5
6
>>> f1()
9
>>> f2()
9
>>> f3()
9
全部都是9！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。
返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>>> def count():
... fs = []
... for i in range(1, 4):
... def f(j):
... def g():
... return j*j
... return g
... fs.append(f(i))
... return fs
...
>>> f1, f2, f3 = count()
>>> f1()
1
>>> f2()
4
>>> f3()
9
另外再说一点，闭包并不是Python中特有的概念，所有把函数做为一等公民的语言均有闭包的概念。不过像Java这样以class为一等公民的语言中也可以使用闭包，只是它得用类或接口来实现。
装饰器
装饰器(decorator)是一种高级Python语法。装饰器可以对一个函数、方法或者类进行加工。在Python中，我们有多种方法对函数和类进行加工，比如在Python闭包中，我们见到函数对象作为某一个函数的返回结果。相对于其它方式，装饰器语法简单，代码可读性高。因此，装饰器在Python项目中有广泛的应用。
装饰函数
由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。
1
2
3
4
5
6
>>> def now():
... print '2016-12-25'
...
>>> f = now
>>> f()
2016-12-25
函数对象有一个__name__属性，可以拿到函数的名字：
1
2
3
4
>>> now.__name__
'now'
>>> f.__name__
'now'
现在，假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
本质上，decorator就是一个返回函数的高阶函数。所以，我们要定义一个能打印日志的decorator，可以定义如下：
1
2
3
4
5
def log(func):
def wrapper(*args, **kw):
print 'call %s():' % func.__name__
return func(*args, **kw)
return wrapper
观察上面的log，因为它是一个decorator，所以接受一个函数作为参数，并返回一个函数。我们要借助Python的@语法，把decorator置于函数的定义处：
1
2
3
@log
def now():
print '2016-12-25'
调用now()函数，不仅会运行now()函数本身，还会在运行now()函数前打印一行日志：
1
2
3
>>> now()
call now():
2016-12-25
把@log放到now()函数的定义处，相当于执行了语句：
1
now = log(now)
由于log()是一个decorator，返回一个函数，所以，原来的now()函数仍然存在，只是现在同名的now变量指向了新的函数，于是调用now()将执行新函数，即在log()函数中返回的wrapper()函数。
wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。
如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数，写出来会更复杂。比如，要自定义log的文本：
1
2
3
4
5
6
7
8
9
10
11
12
def log(text):
def decorator(func):
def wrapper(*args, **kw):
print '%s %s():' % (text, func.__name__)
return func(*args, **kw)
return wrapper
return decorator
这个3层嵌套的decorator用法如下：
@log('execute')
def now():
print '2016-12-25'
执行结果如下：
1
2
3
>>> now()
execute now():
2016-12-25
和两层嵌套的decorator相比，3层嵌套的效果是这样的：
1
>>> now = log('execute')(now)
我们来剖析上面的语句，首先执行log(‘execute’)，返回的是decorator函数，再调用返回的函数，参数是now函数，返回值最终是wrapper函数。
以上两种decorator的定义都没有问题，但还差最后一步。因为我们讲了函数也是对象，它有__name__等属性，但你去看经过decorator装饰之后的函数，它们的__name__已经从原来的’now’变成了’wrapper’：
1
2
>>> now.__name__
'wrapper'
因为返回的那个wrapper()函数名字就是’wrapper’，所以，需要把原始函数的__name__等属性复制到wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。
不需要编写wrapper.__name__ = func.__name__这样的代码，Python内置的functools.wraps就是干这个事的，所以，一个完整的decorator的写法如下：
1
2
3
4
5
6
7
8
import functools
def log(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print 'call %s():' % func.__name__
return func(*args, **kw)
return wrapper
或者针对带参数的decorator：
1
2
3
4
5
6
7
8
9
10
import functools
def log(text):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print '%s %s():' % (text, func.__name__)
return func(*args, **kw)
return wrapper
return decorator
装饰类
在上面的例子中，装饰器接收一个函数，并返回一个函数，从而起到加工函数的效果。在Python 2.6以后，装饰器被拓展到类。一个装饰器可以接收一个类，并返回一个类，从而起到加工类的效果。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def decorator(aClass):
class newClass:
def __init__(self, age):
self.total_display = 0
self.wrapped = aClass(age)
def display(self):
self.total_display += 1
print("total display", self.total_display)
self.wrapped.display()
return newClass
@decorator
class Bird:
def __init__(self, age):
self.age = age
def display(self):
print("My age is",self.age)
eagleLord = Bird(5)
for i in range(3):
eagleLord.display()
在decorator中，我们返回了一个新类newClass。在新类中，我们记录了原来类生成的对象（self.wrapped），并附加了新的属性total_display，用于记录调用display的次数。我们也同时更改了display方法。
通过修改，我们的Bird类可以显示调用display的次数了。
函数式编程优点
函数式的风格通常被认为有如下优点：
逻辑可证：这是一个学术上的优点：没有边界效应使得更容易从逻辑上证明程序是正确的（而不是通过测试）。
模块化：函数式编程推崇简单原则，一个函数只做一件事情，将大的功能拆分成尽可能小的模块。小的函数更易于阅读和检查错误。
组件化：小的函数更容易加以组合形成新的功能。
易于调试：细化的、定义清晰的函数使得调试更加简单。当程序不正常运行时，每一个函数都是检查数据是否正确的接口，能更快速地排除没有问题的代码，定位到出现问题的地方。
易于测试：不依赖于系统状态的函数无须在测试前构造测试桩，使得编写单元测试更加容易。
更高的生产率：函数式编程产生的代码比其他技术更少（往往是其他技术的一半左右），并且更容易阅读和维护。
虽然函数式编程优点很多，但是在实际开发中代码的易读性可能相比命令式编程要差些，而且掌握起来可能也需要一定的时间。但是即使代码不用写成pure函数式风格，但在某些时候局部使用 lambda/map/reduce/filter也能大大简化代码，也是一个不错的选择。
引用链接
Python 的函数式编程–从入门到⎡放弃⎦
什么是函数式编程，有何优点？
要下班了？扫一扫，地铁上阅读 ：)
