python 装饰器 分析

刚开始接触装饰器的时候感觉很迷惑，装饰器类似java中面向切面的概念，java中是通过拦截和解析注解的方式来实现的，python作为一种解释语言其实现方式肯定也不一样，所以以java的角度来看装饰器，还真有些不适应。

要了解装饰器，先来看看一个python内置函数reduce：

def myadd(x, y):
    print 'x=%s y=%s' %(x, y)
    return x + y

print reduce(myadd, ('a', 'b', 'c', 'd'))

打印结果:

x=a y=b
x=ab y=c
x=abc y=d
abcd

其原理为：它通过取出序列的头两个元素，将他们传入二元函数来获得一个单一的值来实现。然后又用这个值和序列的下一个元素来获得又一个值，然后继续直到整个序列的内容都遍历完毕以及最后的值会被计算出来为止。

相当于： myadd(myadd(myadd('a','b'), 'c'),'d')

r1 = myadd('a','b')

r2 = myadd(r1, 'c')

r3 = myadd(r2, 'd')

没有看过python的内部实现，但是感觉装饰器跟reduce很类似，先来写一个装饰器函数：

def wrapDecorator(arg1, arg2='arg2', arg3='arg3'):
    print '[++]begin wrapDecorator arg1=%s arg2=%s arg3=%s' % (arg1, arg2, arg3)
    
    def wrapFunction(f):
        print '[++]begin wrapFunction f id is:%d' % id(f)
        
        def wrapFunctionCall(*arg):
            print '[++]begin wrapFunctionCall, arg is:', arg
            f(arg)
            print '[--]end wrapFunctionCall'
            
        print '[--]end wrapFunction, wrapFunctionCall id:%d' % id(wrapFunctionCall)
        return wrapFunctionCall
    
    print '[--]end wrapDecorator'
    return wrapFunction

一个很普通的函数，里面嵌套了两个内部函数，里面的内容很简单，就几个print语句，具体是干嘛用的，后话再提。

再来写一个小函数：

def myfunc(param1='my', param2='function'):
    print 'hello', param1, param2

把两个函数放到同一个py文件中，点击eclipse的run按钮，控制台不会有任何输出

然后在myfunc上加一个装饰器，美化一下：

@wrapDecorator('add Decorator')
def myfunc(param1='my', param2='function'):
    print 'hello', param1, param2

然后点击eclipse的run按钮，控制台输出如下：

[++]begin wrapDecorator arg1=add Decorator arg2=arg2 arg3=arg3
[--]end wrapDecorator
[++]begin wrapFunction f id is:11234288
[--]end wrapFunction, wrapFunctionCall id:11233968

只是申明了一下装饰器，居然开始执行程序了，脚本就是脚本。

如果进行单步调试，会看到在申明装饰器的地方，会进入函数wrapDecorator。

看来这个装饰器相当于Lisp中的宏了，在解释程序之前会把程序展开，联系到刚开始的reduce函数，reduce返回的是值，而装饰器返回的是函数，装饰器可以这么理解：

@wrapDecorator('add Decorator')
def myfunc(param1='my', param2='function'):
f1 = wrapDecorator('add Decorator') #其实f1 = wrapFunction()
f2 = wrapFunction(myfunc)           #f2 = wrapFunctionCall

最终myfunc将等于wrapFunctionCall，那么myfunc到哪儿去了呢：

所有的程序如下：test.py

def wrapDecorator(arg1, arg2='arg2', arg3='arg3'):
    print '[++]begin wrapDecorator arg1=%s arg2=%s arg3=%s' % (arg1, arg2, arg3)
    
    def wrapFunction(f):
        print '[++]begin wrapFunction f id is:%d' % id(f)
        
        def wrapFunctionCall(*arg):
            print '[++]begin wrapFunctionCall, arg is:', arg
            f(arg)               #<--------
            print '[--]end wrapFunctionCall'
            
        print '[--]end wrapFunction, wrapFunctionCall id:%d' % id(wrapFunctionCall)
        return wrapFunctionCall  #<--------
    
    print '[--]end wrapDecorator'
    return wrapFunction          #<----

@wrapDecorator('add Decorator')
def myfunc(param1='my', param2='function'):
    print 'hello', param1, param2


print '-------begin call myfunc, id :%d---------' % id(myfunc)
myfunc()

程序运行后的log如下：
[++]begin wrapDecorator arg1=add Decorator arg2=arg2 arg3=arg3
[--]end wrapDecorator
[++]begin wrapFunction f id is:11689328
[--]end wrapFunction, wrapFunctionCall id:11234288
-------begin call myfunc, id :11234288---------
[++]begin wrapFunctionCall, arg is: ()
hello () function
[--]end wrapFunctionCall

从上面的log可以看出，myfunc其实变成了wrapFunctionCall，从前的myfunc被藏到函数wrapDecorator中，变成了函数的属性f了
python在解析装饰器时，把装饰器参数，myfunc的定义全部当成参数，稀里哗啦把myfunc折腾得id都变了，比明星美容还惨。

上面程序有点问题，按照预期myfunc会打印出默认的信息： hello my function，实际打印的是hello () function，
作为myfunc的替身函数wrapFunctionCall，其接口应该跟myfunc保持一致。
如果邪恶一点，wrapFunctionCall的参数自己定，而且在wrapFunctionCall中也不调用f（），而调用其它的函数，这个装饰器就变成神器了

装饰器函数中的函数名没有规则，反正对于python来说，一串数字就可以识别了，关键还是看函数的返回值

如果装饰器没有参数，那么装饰器函数就可以少一层：

def wrapDecorator1(f):
    def wrapFunctionCall(p1='another', p2='function'):
        f(p1, p2)
    return wrapFunctionCall

@wrapDecorator1
def myfunc1(param1='another', param2 ='function'):
    print 'hello', param1, param2

用类来实现装饰器：

class classDecorator(object):
    def __init__(self, arg1, arg2='arg2', arg3='arg3'):
        self.arg1 = arg1
        self.arg2 = arg2
        self.arg3 = arg3
    
    def __call__(self, f):
        self.f = f
        
        def wrapFunctionCall(p1 = 'my', p2 = 'function'):
            print '>>>>>'
            self.f(p1, p2)
            print '<<<<<'
        
        return wrapFunctionCall
        
@classDecorator('add Decorator')
def myfunc(param1='my', param2='function'):
    print 'hello', param1, param2
       
print '-------begin call myfunc, id :%d---------' % id(myfunc)
myfunc()

没有参数时也可以少一个内嵌函数：

class classDecorator(object):
    def __init__(self, f):
        self.f = f
    
    def __call__(self, p1 = 'my', p2 = 'function'):
        print '>>>>>'
        self.f(p1, p2)
        print '<<<<<'
       
        
@classDecorator
def myfunc(param1='my', param2='function'):
    print 'hello', param1, param2