[python] 之 装饰器

　　装饰器本质上是一个python函数，它可以让其它函数在不需要做任何代码变动的前提下增加额外的功能，装饰器的返回值也是一个函数对象。装饰器主要用于插入日志、性能测试、事务处理、缓存及权限校验等，解决代码重复使用。值得注意的是，内层函数保留（记忆）了外层函数的（参数）状态。

一、装饰器创建

　　装饰器的语法以@开头，接着是装饰器函数的变量名和可选参数，紧接着是被修饰函数的定义及被修饰函数的可选参数。

　　语法：

　　@decorator(dec_opt_args)

　　def fuc2Bdecorated(func_opt_args):

　　　　func_body

def dec1(func1):
    def wrapper1():
        print('hello!')
        return func1
    return wrapper1
@dec1
def test():
    pass

test()
#输出
hello！

　　装饰器可以像函数一样堆叠起来，如下：

def dec1(func1):
    def wrapper1():
        print('hello!')
        return func1
    return wrapper1

def dec2(func2):
    def wrapper2():
        print ('Pyhton!')
        return func2
    return wrapper2
 
@dec2
@dec1
def test():
    pass
if __name__ == '__main__':
　　test()
#输出
Python!

　　此时，函数变量名test作为一个参数传递给了装饰器函数dec1，并返回wrapper1；然后wrapper1作为参数传递给了dec2，并返回了wrapper2；最后test()等价于wrapper2()的调用，即dec2(dec1(test()))。注意，如果装饰器函数有参数，应现执行装饰器函数，并返回一个可调用函数，继续遵循上述的运算规则；如果被修饰的函数有参数，则作为最后返回的可调用的函数的参数，进行最后的运算，并返回值，执行结束。（如下）。

二、有参数的函数装饰器

　　2.1 被修饰的函数含有参数

　　该函数等价于dec2(dec1(test('dec00')))

def dec1(func1): #func = test
    def wrapper1(arg1): # arg1 = arg2
        print(arg1+' + hello!')
        return func1(arg1) #func1 = test
    return wrapper1

def dec2(func2): #func2 = wrapper1
    def wrapper2(arg2): # arg2 = 'dec00'
        print (arg2+' + Pyhton!')
        return func2(arg2) #wrapper1(arg2)
    return wrapper2

@dec2
@dec1
def test(t):
    print(t+' + test')
if __name__ == '__main__':
　　test('dec00')

#输出
dec00 + Pyhton!
dec00 + hello!
dec00 + test

　　2.2 装饰器函数含有参数

　　该函数首先执行dec2('dec2')，返回dec21，然后整个函数等价于dec21(dec1(test01('dec01')))或者dec2('dec2')(dec1(test01('dec01')))，请读者认真体会以上两种情况。

def dec1(func1): #func = test01
    def wrapper1(arg1): 
        print(arg1+' + hello!')
        return func1(arg1)
    return wrapper1
 
def dec2(level): #level = 'dec2'
    def dec21(func2): #func2 = wrapper1
        def wrapper2(arg2): #arg2 = 'dec01'
            print (level+' + '+arg2+' + Pyhton!')
            return func2(arg2) #func2 = wrapper1
        return wrapper2
    return dec21
@dec2('dec2')
@dec1
def test01(t):
    print(t +' + test01')
if __name__ == "__main__":
    test01('dec01')
#输出
dec2 + dec01 + Pyhton!
dec01 + hello!
dec01 + test01

三、基于类的装饰器

　　根据装饰器语法及其运算性质，可知装饰器函数本身必须是可调用（callable）的，然后返回一个可调用（callable）对象。在Python中一般callable对象都是函数，但也有例外。只要某个对象重载了__call__()方法，那么这个对象就是callable的。

 　　下面是可调用的类：

class P(object):
    def __call__(self):
        print ('callable')
    def func(self):
        print ('class')
    
i = P()
i.func()
i()

#输出
class
callable

　　3.1 基于可调用的类，创建装饰器：

class P(object):
    def __init__(self,func):
        self.func = func
    def __call__(self):
        print ('callable')
        return self.func()
@P
def test():
    print('test')
if __name__ == "__main__" : 
    test()
#输出
callable
test

　　在上述函数调用过程中，类P是一个可调用的对象，类似于函数。上述装饰器执行等价于P(test())。

　　3.2 带参数的类装饰器

class P(object):
    def __init__(self,level):
        self.level = level # level = 'level'
    def __call__(self,func): # func = test
        def wrapper(t): #t = 't'
            print (self.level + ' + callable')
            return func(t) # test('t')
        return wrapper
@P('level')
def test(t):
    print('test')
if __name__ == "__main__" : 
    test('t')

#输出
level + callable
test

　　此装饰器执行时，首先调用类P，初始化类并返回了函数变量名wrapper，此时该函数的参数，来源与被修饰的函数的参数，这一点和基于函数的装饰器是等同的。