装饰器模式

学习一下python装饰器模式的概念与基本使用。

示例

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

def now():
    print "Time is 2017-10-23"

f = now
f()

运行结果输出为: “Time is 2017-10-23”

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

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

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

@log
def now():
    print "Time is 2017-10-23"

if __name__ == '__main__':
    now()

运行结果如下:

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

@log
def now():
    print "Time is 2017-10-23"

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

把 @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 "Time is 2017-10-23"

执行结果如下:

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

now = log('execute')(now)

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

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

---

装饰器的那些坑

位置错误的代码

def html_tags(tag_name):
    print 'begin outer function.'
    def wrapper_(func):
        print "begin of inner wrapper function."
        def wrapper(*args, **kwargs):
            content = func(*args, **kwargs)
            print "<{tag}>{content}</{tag}>".format(tag=tag_name, content=content)
        print 'end of inner wrapper function.'
        return wrapper
    print 'end of outer function'
    return wrapper_

@html_tags('b')
def hello(name='Toby'):
    return 'Hello {}!'.format(name)

hello()
hello()

在装饰器中我在各个可能的位置都加上了print语句，用于记录被调用的情况。你知道他们最后打印出来的顺序吗？如果你心里没底，那么最好不要在装饰器函数之外添加逻辑功能，否则这个装饰器就不受你控制了。以下是输出结果：

错误的函数签名和文档

装饰器装饰过的函数看上去名字没变，其实已经变了。

def logging(func):
    def wrapper(*args, **kwargs):
        """print log before a function."""
        print "[DEBUG] {}: enter {}()".format(datetime.now(), func.__name__)
        return func(*args, **kwargs)
    return wrapper

@logging
def say(something):
    """say something"""
    print "say {}!".format(something)

print say.__name__  # wrapper

为什么会这样呢？只要你想想装饰器的语法糖@代替的东西就明白了。@等同于这样的写法。

say = logging(say)

logging 其实返回的函数名字刚好是 wrapper ，那么上面的这个语句刚好就是把这个结果赋值给 say， say 的 __name__ 自然也就是 wrapper 了。不仅仅是 name，其他属性也都是来自 wrapper ，比如 doc ，source 等等。

使用标准库的 functools.wraps，可以基本解决这个问题。

from functools import wraps

def logging(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        """print log before a function."""
        print "[DEBUG] {}: enter {}()".format(datetime.now(), func.__name__)
        return func(*args, **kwargs)
    return wrapper

@logging
def say(something):
    """say something"""
    print "say {}!".format(something)

print say.__name__  # say
print say.__doc__ # say something

---

参考

• 装饰器
• 详解Python的装饰器