Python爬虫技术--基础篇--函数式编程（下篇）

1.装饰器

由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。

>>> def now():
... print('2015-3-25')
...
>>> f = now
>>> f()
2015-3-25

函数对象有一个​​__name__​​属性，可以拿到函数的名字：

>>> now.__name__
'now'
>>> f.__name__
'now'

现在，假设我们要增强​​now()​​​函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改​​now()​​函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

本质上，decorator就是一个返回函数的高阶函数。所以，我们要定义一个能打印日志的decorator，可以定义如下：

def log(func):
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper

观察上面的​​log​​，因为它是一个decorator，所以接受一个函数作为参数，并返回一个函数。我们要借助Python的@语法，把decorator置于函数的定义处：

@log
def now():
print('2015-3-25')

调用​​now()​​​函数，不仅会运行​​now()​​​函数本身，还会在运行​​now()​​函数前打印一行日志：

>>> now()
call now():
2015-3-25

把​​@log​​​放到​​now()​​函数的定义处，相当于执行了语句：

now = log(now)

由于​​log()​​​是一个decorator，返回一个函数，所以，原来的​​now()​​​函数仍然存在，只是现在同名的​​now​​​变量指向了新的函数，于是调用​​now()​​​将执行新函数，即在​​log()​​​函数中返回的​​wrapper()​​函数。

​​wrapper()​​​函数的参数定义是​​(*args, **kw)​​​，因此，​​wrapper()​​​函数可以接受任意参数的调用。在​​wrapper()​​函数内，首先打印日志，再紧接着调用原始函数。

如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数，写出来会更复杂。比如，要自定义log的文本：

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('2015-3-25')

执行结果如下：

>>> now()
execute now():
2015-3-25

和两层嵌套的decorator相比，3层嵌套的效果是这样的：

>>> now = log('execute')(now)

我们来剖析上面的语句，首先执行​​log('execute')​​​，返回的是​​decorator​​​函数，再调用返回的函数，参数是​​now​​​函数，返回值最终是​​wrapper​​函数。

以上两种decorator的定义都没有问题，但还差最后一步。因为我们讲了函数也是对象，它有​​__name__​​​等属性，但你去看经过decorator装饰之后的函数，它们的​​__name__​​​已经从原来的​​'now'​​​变成了​​'wrapper'​​：

>>> now.__name__
'wrapper'

因为返回的那个​​wrapper()​​​函数名字就是​​'wrapper'​​​，所以，需要把原始函数的​​__name__​​​等属性复制到​​wrapper()​​函数中，否则，有些依赖函数签名的代码执行就会出错。

不需要编写​​wrapper.__name__ = func.__name__​​​这样的代码，Python内置的​​functools.wraps​​就是干这个事的，所以，一个完整的decorator的写法如下：

import functools

def log(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper

或者针对带参数的decorator：

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

​​import functools​​​是导入​​functools​​​模块。模块的概念稍候讲解。现在，只需记住在定义​​wrapper()​​​的前面加上​​@functools.wraps(func)​​即可。

小结

在面向对象（OOP）的设计模式中，decorator被称为装饰模式。OOP的装饰模式需要通过继承和组合来实现，而Python除了能支持OOP的decorator外，直接从语法层次支持decorator。Python的decorator可以用函数实现，也可以用类实现。

decorator可以增强函数的功能，定义起来虽然有点复杂，但使用起来非常灵活和方便。

2.偏函数

Python的​​functools​​模块提供了很多有用的功能，其中一个就是偏函数（Partial function）。要注意，这里的偏函数和数学意义上的偏函数不一样。

在介绍函数参数的时候，我们讲到，通过设定参数的默认值，可以降低函数调用的难度。而偏函数也可以做到这一点。举例如下：

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

>>> int('12345')
12345

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

>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565

假设要转换大量的二进制字符串，每次都传入​​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('1000000')
64
>>> int2('1010101')
85

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

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

>>> int2('1000000', base=10)
1000000

最后，创建偏函数时，实际上可以接收函数对象、​​*args​​​和​​**kw​​这3个参数，当传入：

int2 = functools.partial(int, base=2)

实际上固定了int()函数的关键字参数​​base​​，也就是：

int2('10010')

相当于：

kw = { 'base': 2 }
int('10010', **kw)

当传入：

max2 = functools.partial(max, 10)

实际上会把​​10​​​作为​​*args​​的一部分自动加到左边，也就是：

max2(5, 6, 7)

相当于：

args = (10, 5, 6, 7)
max(*args)

结果为​​10​​。

小结

当函数的参数个数太多，需要简化时，使用​​functools.partial​​可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。