Python 装饰器的产生演进让你彻底明白装饰器原理

客官°小女子只卖身不卖艺 2024-04-18 16:17 160阅读 0赞

## 想要给一个已经写好的函数“加点料”，怎么办？ ##

### 装饰器的产生 ###

最初大约在2000年左右，程序员是这样做的：

#定义好的原始函数
    def say():
        print( "hello world!")
    
    #很久很久以前的做法
    def debug(func):#接收函数地址
        def wrapper():#替换原函数的新函数地址
            print ("[DEBUG]: enter {}()".format(func.__name__))
            return func()
        return wrapper
    
    say = debug(say)#这就是装饰器的原始模样吧
    say()#其实是wrapper()
    输出：
    [DEBUG]: enter say()#加的料
    hello world!

其实就是一个加料的新函数wrapper替换原函数

### 装饰器的演进1：只是加入@语法糖 ###

def debug(func):#加了@语法糖！
        def wrapper():
            print ("@语法糖 [DEBUG]: enter {}()".format(func.__name__))
            return func()
        return wrapper
    
    @debug
    def say():
        print ("hello world!")
    
    say()#其实是wrapper()
    输入：
    @语法糖 [DEBUG]: enter say()
    hello world!

@debug								
    def say():
        print ("hello world!")
    //等价于：
    def say():
        print ("hello world!")
    say = debug(say)

### 装饰器的演进2：函数加入固定参数 ###

def debug(func):#把函数接过来返回包装后的函数！wrapper才是替换的函数
        def wrapper(n):  # 指定一致的参数
            print( "[DEBUG]: enter {}()".format(func.__name__))
            return func(n)
        return wrapper  # 返回包装过的新函数
    
    @debug #可以理解为：用debug中的wapper替换下面的函数
    def say(something):
        print (something)
    
    say('hello world!')#其实是wrapper('hello world!')
    输出：
    [DEBUG]: enter say()
    hello world!

### 装饰器的演进3：函数加入任意参数 ###

def debug(func):#接收被替换函数
        def wrapper(*args, **kwargs):  # 新函数指定任意参数
            print ("[DEBUG]: enter {}()".format(func.__name__))
            print('*args:',end=' ')
            print(*args)
            print('kwargs:',end=' ')
            print(kwargs)
            print('------------------------------------------')
            return func(*args, **kwargs)
        return wrapper  
    
    @debug
    def say(*args, **kwargs):
        print(*args,end=' ')
        print(kwargs)
    
    say(1,2,3,'hello world!',key1 = 1,key2 = 2)#实际上是wrapper(1,2,3..)/或者是：debug(say)(1,2,3..)
    输出：
    [DEBUG]: enter say()
    *args: 1 2 3 hello world!
    kwargs: { 'key1': 1, 'key2': 2}
    ------------------------------------------
    1 2 3 hello world! { 'key1': 1, 'key2': 2}

### 装饰器的演进4：装饰器加入参数 ###

def logging(level):#最外层用于接受第一个参数
        def wrapper(func):
            def inner_wrapper(*args, **kwargs):
                print ("[{}]: enter function {}()".format(level,func.__name__))
                return func(*args, **kwargs)
            return inner_wrapper
        
        return wrapper
    
    @logging(level='INFO')
    def say(something):
        print( "say {}！".format(something))
    
    @logging(level='DEBUG')
    def do(something):
        print ("do {}！".format(something))
    
    say('hello')
    do("my work")
    
    # 如果没有使用@语法，say('hello') == logging(level='INFO')(say)('hello')

### 装饰器的演进5：类装饰器 ###

\*\*  
装饰器函数其实是这样一个接口约束，它必须接受一个callable对象作为参数，然后返回一个callable对象。  
在Python中一般callable对象都是函数，但也有例外。  
只要某个对象重载了\_\_call\_\_()方法，那么这个对象就是callable的。  
\*\*

class Test():
        def __call__(self):
            print ('call me!')
    
    t = Test()
    t()  # call me 想像不像函数

回到装饰器上的概念上来，装饰器要求接受一个callable对象，  
并返回一个callable对象（不太严谨，详见后文）。那么用类来实现也是也可以的。  
我们可以让类的构造函数\_\_init\_\_()接受一个函数，  
然后重载\_\_call\_\_()并返回一个函数，也可以达到装饰器函数的效果

class logging(object):
        def __init__(self, func):
            self.func = func
    
        def __call__(self, *args, **kwargs):
            print ("[DEBUG]: enter function {func}()".format(
                func=self.func.__name__))
            return self.func(*args, **kwargs)
    @logging
    def say(something):
        print ("say {}!".format(something))
    
    say('hello world!')
    输出：
    [DEBUG]: enter function say()
    say hello world!!

‘’’  
如果需要通过类形式实现带参数的装饰器，那么会比前面的例子稍微复杂一点。  
那么在构造函数里接受的就不是一个函数，而是传入的参数。通过类把这些参数保存起来。  
然后在重载\_\_call\_\_方法是就需要接受一个函数并返回一个函数。’’’

class logging(object):
        def __init__(self, level='INFO'):
            self.level = level
            
        def __call__(self, func): # 接受函数
            def wrapper(*args, **kwargs):
                print( "[{level}]: enter function {func}()".format(
                    level=self.level,
                    func=func.__name__))
                func(*args, **kwargs)
            return wrapper  #返回函数
    
    @logging(level='INFO')
    def say(something):
        print( "say {}!".format(something))
    
    say('hello world!')
    输出：
    [INFO]: enter function say()
    say hello world!!