Python 装饰器学习心得

    最近打算重新开始记录自己的学习过程，于是就捡起被自己废弃了一年多的博客。这篇学习笔记主要是记录近来看的有关Python装饰器的东西。

0. 什么是装饰器？

    本质上来说，装饰器其实就是一个特殊功能的函数，这个特殊的功能就是：装饰另一个函数。举一个最简单的例子来说：

def identify(f):
    print 'Decorator identify called.'
    return f

这里identify其实是一个装饰器，这个装饰器对输入的参数f不进行任何修饰，然后返回这个参数。其中的打印语句是用来判断这个装饰器是什么时候被调用的。接下去，我们可以这样用这个装饰器：

@identify
def foo():
    print 'foo called.'

装饰器的语法是以@开头，然后跟着装饰器函数的名字，然后一些可选的装饰器函数的参数。紧跟着是被修饰的函数的定义。上述带装饰器的函数定义可以看成以下语法糖：

def foo():
    print 'foo called.'
foo = identify(foo)

写一个简单的类来对上述例子做一下测试：

# Decorators
def identify(f):
    print 'Decorator identify called.'
    return f
class SimpleDecorator(object):
    """
    This is my first decorator test class.
    """

    def __init__(self):
        super(SimpleDecorator, self).__init__()
        print 'SimpleDecorator init.'

    @identify
    def foo(self):
        print 'Foo called.'

    def test(self):
        self.foo()
if __name__ == '__main__':
    print '---- Test SimpleDecorator begin. ----'
    simpleDecorator = SimpleDecorator()
    simpleDecorator.test()
    print '---- Test SimpleDecorator end. ----'

为了简单起见，我这里没有把identify装饰器写成类静态方法，因为类静态方法的定义也是利用装饰器来的。运行上述的测试代码，得到如下的输出：

可以看到装饰器函数比类实例的初始化还早，这说明在利用装饰器定义foo函数的时候装饰器函数已经被调用了。

1. 注册函数的装饰器。

接下去，我们来定义一个稍微复杂一点的装饰器，这个装饰器能把被装饰的函数注册到一个全局的字典里面。

_functions = {}
def register1(class_name):
    def _register(f):
        """
        This is register1 doc.
        """
        print 'Decorator register1 called.'
        global _functions
        name = class_name + '.' + f.__name__
        _functions[name] = f
        print 'Function %s is registed.' % name
        def warpper(*args, **kwargs):
            """
            This is warpper doc.
            """
            f(*args, **kwargs)
        return warpper
    return _register

首先，这是一个带参数的装饰器。我们可以先看看怎么用这个装饰器，

@register1('RegisterDecorator')
def foo1():
    """
    This is the foo1 doc.
    """
    print 'Foo1 called.'

接下去，结合装饰器的定义来分析一下上述的代码。首先对于这句定义 @register1('RegisterDecorator')可以理解成@(register1('RegisterDecorator'))这样的优先级，也就是我们先传入参数'RegisterDecorator'来调用register1函数，可以看到register1函数其实是返回一个_register函数，在这里我更愿意把_register看成真正的装饰器。所以这句定义@register1('RegisterDecorator')就可以看成@_register，而这个_register其实是定义在带有参数'RegisterDecorator'信息的作用域内部。接下去的@_register就跟不带参数的装饰器一样了，所以在定义foo1函数的时候_register函数会被调用，在这个函数内部，foo1会被注册在一个全局的字典内部，然后返回一个跟foo1一样功能的函数。

2.functools装饰器工具

    我们在来深入讨论一下上述装饰器，上述装饰器虽然达到我们注册函数的装饰作用，但是其实你会发现，这个被装饰的函数foo1已经不是原来的foo1，比如foo1.__doc__和foo1.__name__已经不是原来foo1时的"This is the foo1 doc"和"foo1"。这是怎么回事呢？因为装饰器其实只是一个语法糖，被装饰的foo1其实等于_register里面返回的wrapper函数，也就是foo1 = _register(foo1)，而_register返回的正是wrapper函数，所以此时的foo1.__doc__和foo1.__name__应该是"This is wrapper doc."和"wrapper"。那么要如何避免上述的情况的呢，那就是利用装饰器工具functools。其实functools也是提供一些装饰器，这个装饰器可以保证你在定义装饰器时保留原来函数的__doc__和__name__属性。具体例子如下：

import functools


_functions = {}
def register1(class_name):
    def _register(f):
        """
        This is register1 doc.
        """
        print 'Decorator register1 called.'
        global _functions
        name = class_name + '.' + f.__name__
        _functions[name] = f
        print 'Function %s is registed.' % name
        def warpper(*args, **kwargs):
            """
            This is warpper doc.
            """
            f(*args, **kwargs)
        return warpper
    return _register


def register2(class_name):
    def _register(f):
        """
        This is register2 doc.
        """
        print 'Decorator register2 called.'
        global _functions
        name = class_name + '.' + f.__name__
        _functions[name] = f
        print 'Function %s is registed.' % name
        @functools.wraps(f)
        def warpper(*args, **kwargs):
            """
            This is warpper doc.
            """
            f(*args, **kwargs)
        return warpper
    return _register

class RegisterDecorator(object):
    """
    This is register Decorator.
    The decorator registed the function in golbal dict.
    """

    def __init__(self):
        super(RegisterDecorator, self).__init__()
        print 'RegisterDecorator init.'

    @register1('RegisterDecorator')
    def foo1(self):
        """
        This is the foo1 doc.
        """
        print 'Foo1 called.'

    @register2('RegisterDecorator')
    def foo2(self):
        """
        This is the foo2 doc.
        """
        print 'Foo2 called'

    def test(self):
        self.foo1()
        self.foo2()
        pass

if __name__ == '__main__':
    print '---- Test RegisterDecorator begin. ----'
    registerDecorator = RegisterDecorator()
    registerDecorator.test()
    print 'The doc of foo1 is: ', registerDecorator.foo1.__doc__
    print 'The name of foo1 is: ', registerDecorator.foo1.__name__
    print 'The doc of foo2 is: ', registerDecorator.foo2.__doc__
    print 'The name of foo2 is: ', registerDecorator.foo2.__name__
    print '---- Test RegisterDecorator end. ----'

register2和register1唯一不同的是，regisrer2返回的是被装饰器 @functools.wraps 装饰过的warpper函数。上述测试代码的输出为：

关于上述的测试代码托管在github上：https://github.com/fengzaihou/PythonLearning/tree/master/Decorators