python实现decorator模式

python有个很常用的语法糖是@decorator，使用它可以很方便的创建decorator装饰器模式。（当然，@的用处可不只用在创建装饰器模式）方法有两种，一种是通过创建一个包裹类Wrapper，另一种就是直接通过一个函数创建closure

简要说下装饰器模式：不改变目标的内部行为，改变目标的外在表现方式的一种模式。重点在于，它一定不干涉“内政”，只可以在目标的外围进行修饰，对目标是透明的。

函数的方法最简单

def wrap(num):
    print("wrap initialed")
    def w(func):
        print("w start", num)
        def w2(*args):
            print("w2 start")
            func(*args)
            print("w2 end")
            return "some thing"       
        return w2
    return w

@wrap(10)
def foo2(num, string):
    print(string * num)

print("BEING:")
foo2(3, 'z')
foo2(4, 'y')
print(foo2)

输出结果是：

wrap initialed
('w start', 10)
BEING:
w2 start
zzz
w2 end
w2 start
yyyy
w2 end
<function w2 at 0x7f25d74735f0>

这里就相当与执行了语句

wrap(10)(foo2)(3, 'z')

每一层都先计算出本层的对象，然后再调用被嵌套的函数
这里可以看到

wrap initialed
('w start', 10)

最先输出了一次，说明虽然是包裹函数，但是其已经形成了闭包，全局唯一

如果使用类来实现，情况也比较类似

import datetime
class Wrapper(object):
    def __init__(self, num = -1):
        print("Wrapper Initialed", num)
        self.num = num
        
        
    def __call__(self, func):
        print("Wrapper Called")
        # 以下表明参数的写法虽运行无误，但是是没有意义的
        def w(fff, ggg, *args):
            print("Wrapper Preparing", datetime.datetime.now())
            # 这样传参数是没有意义的
            func(num = ggg, x = self.num,  *args)
            print("Wrapper Finished", datetime.datetime.now())
#        w.__name__ = func.__name__
        return w

#将值3传入Wrapper的self.num
@Wrapper(3)
def foo(num = 1, x = 'z', *args):
    print(x * num, args, 'x=', x, 'num=', num)

    
if __name__ == '__main__':
    print('BEGIN:')
    foo(2, 'a')
    foo(3, 'b')
    print(foo)

输出结果是：

('Wrapper Initialed', 3)
Wrapper Called
BEGIN:
('Wrapper Preparing', datetime.datetime(2012, 5, 5, 0, 25, 58, 136713))
('aaa', (), 'x=', 3, 'num=', 'a')
('Wrapper Finished', datetime.datetime(2012, 5, 5, 0, 25, 58, 136829))
('Wrapper Preparing', datetime.datetime(2012, 5, 5, 0, 25, 58, 136864))
('bbb', (), 'x=', 3, 'num=', 'b')
('Wrapper Finished', datetime.datetime(2012, 5, 5, 0, 25, 58, 136920))
<function w at 0x7f11d4f21758>

可以看出Wrapper类也只执行了一次初始化。我怀疑可不可能是因为

foo = Wrapper(3)(foo)(*args)

返回了一个闭包。通过最后一行的打印结果证实了我的想法。这个类也形成了一个闭包。

值得注意的有两点：一是Wrapper类使用了__call__函数，这个函数仅在发生调用时instance(*args)，才会被激活，相当与instance.__call__(*args)
二是不要瞎折腾。 我在这里尝试把Wrapper的参数，传递给foo，这里需要w函数和foo的参数列表保持一致就可以不报错。但是这样做起不到改变foo函数行为的作用，顶多改变这个foo函数的默认参数，所以是毫无意义的！如果没有特殊必要，请不要把Wrapper的参数往foo中塞，Wrapper的函数仅在foo调用前后调用才有意义。

最后一点写参数表的心得体会是，在写装饰器的时候，如果拿不准func参数怎么写，怎么把它包装起来，那么就先写func(*args)，然后再完善上面一层封包，直至最后把w(func)函数参数写好。