浅析Python装饰器

时间：2024-01-27 19:31:33

1、什么是装饰器

在介绍装饰器之前，我们先来思考一个问题：使用Python语言进行程序设计时，如果我们想扩展一个函数的功能，一般会怎么做呢？

比如，有一个名为print_info函数，当前该函数内只做一些简单的打印操作，现在我们想扩展这个函数功能，如在发生错误时，我们将错误行号传入到该函数打印出来。

def print_info():
    print("Hello World")

看到这个问题，我们的第一反应肯定是重新修改这个函数。在print_info函数增加一个参数，用于接收外部传入的错误行号，在函数内部增加打印行号信息语句。

def print_info(err_line):
    print("Hello World")
    print("The Error Occurred Line Number: %d" %(err_line))

似乎，通过修改函数内容，也能实现我们的需求。但有没有这种可能呢，不直接进行修改print_info函数内容，通过其他的方式增加print_info函数的额外功能。答案肯定是有的，能实现这种功能的就是我们要讲的装饰器。

装饰器到底是什么呢？使用比较严谨的语言来描述：

装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。
装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。

 概括的讲，装饰器的作用就是为已经存在的函数或对象添加额外的功能。

2、怎么写一个装饰器

我们先来看一段这样的代码

 1 import sys
 2 
 3 def log(fcn):
 4     def wrapper(*argc, **kw):
 5         #New Operations Are Added Here
 6         if len(argc) != 1:
 7             print('Illegal parameter')
 8             return -1
 9         print("The Error Occurred Line Number: %d" %(argc[0]))
10         return fcn()
11     return wrapper      
12 
13 def print_info():
14     print("Hello World")
15 
16 print_info = log(print_info) # 添加功能并保持原函数名不变
17 
18 def main():
19     print_info(sys._getframe().f_lineno) # sys._getframe().f_lineno代表当前的行号
20 
21 if __name__ == "__main__":
22     main()

log函数是一个“闭包”（关于什么是“闭包”可参考“浅析Python闭包”），该函数有一个参数fcn，返回值是内部实现的wrapper函数。

比较重要的一条语句print_info = log(print_info)，这里通过对print_info变量赋值改变它原来指向的类型，起到了对print_info函数赋予了新功能。执行这句语句之后print_info变量不再表示前面定义的print_info函数，而是表示log函数内实现的wrapper函数，但原来定义的print_info函数仍然存在。

最终调用的print_info函数，其实调用的是log中的wrapper函数。由于“闭包”特性，虽然wrapper函数已经离开了创造它的环境log函数，但它仍然可以使用log函数中的*变量。wrapper函数中，打印了传入的错误行号，并调用了传入的原定义的print_info函数，这样便做到了对定义的print_info函数内容做修改，调用print_info增加了额外功能。

运行结果

The Error Occurred Line Number: 19 # 打印出新增的对应行号信息，在19行被调用，所以传入行号是19
Hello World #原print_info函数执行内容

上面的log函数其实已经是一个装饰器了，它对原函数做了包装并返回了另外一个函数，额外添加了一些功能。因为这样写实在不太优雅，新版本Python中支持了@语法糖，我们可以把它使用起来。

下面代码等同于上面的写法。

import sys

def log(fcn):
    def wrapper(*argc, **kw):
        #New Operations Are Added Here
        if len(argc) != 1:
            print('Illegal parameter')
            return -1
        print("The Error Occurred Line Number: %d" %(argc[0]))
        return fcn()
    return wrapper    
    
@log                      
def print_info():
    print("Hello World")

#print_info = log(print_info)

def main():
    print_info(sys._getframe().f_lineno)

if __name__ == "__main__":
    main()

把@log放到print_info函数定义处，相当于执行了print_info = log(print_info)语句

3、完整装饰器的写法

前面写的装饰器都没有问题，但是还差最后一步，虽然装饰器装饰过的函数看上去名字没变，其实已经变了。 

def log(fcn):
    def wrapper(*args, **kw):
        print(fcn.__name__)
        return fcn()
    return wrapper  

@log
def print_info():
    print('Hello World')
    
def main():
    print_info()
    print(print_info.__name__)
    
if __name__ == "__main__":
    main()

运行结果

print_info
Hello World
wrapper
>>>

上面print_info函数经log装饰器装饰后，它的__name__属性已经从原来的‘print_info’变成了‘wrapper’

因为返回的那个wrapper()函数名字就是'wrapper'，所以，需要把原始函数的__name__等属性复制到wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。

不需要在内部添加wrapper.__name__=fcn.__name__这样的代码，Python内置的functools.wraps就是干这个事的，所以，一个完整的decorator的写法如下：

import functools

def log(fcn):
    @functools.wraps(fcn)
    def wrapper(*args, **kw):
        print(fcn.__name__)
        return fcn()
    return wrapper

4、高阶一点装饰器

4.1 带参数装饰器

如果装饰器函数本身要传入参数，那么装饰器就会是这样的

import sys

def log(text):
    def wrapper(fcn)
        def inner_wrapper(*argc, **kw):
            #New Operations Are Added Here
            print(text)
            if len(argc) != 1:
                print('Illegal parameter')
                return -1
            print("The Error Occurred Line Number: %d" %(argc[0]))
            return fcn()
        return inner_wrapper
    return wrapper    
    
@log('With Parameter Decorator')
def print_info():
    print("Hello World")

#print_info = log(print_info)

def main():
    print_info(sys._getframe().f_lineno)

if __name__ == "__main__":
    main()

对于带参数装饰器，可以这么理解，当带参数的装饰器被装饰在某个函数上时，比如上述代码@log('With Parameter Decorator')，log('With Parameter Decorator')其实是一个函数，会马上被执行，它返回的结果任是一个装饰器wrapper。

也就是下面代码其实等价于print_info = wrapper(print_info)

@log('With Parameter Decorator')
def print_info():
    print("Hello World")

4.2 装饰器装饰类方法

前面我们介绍的都是用装饰器装饰函数，装饰器同时也可以装饰类方法，下面来看如何用装饰器装饰类的方法

我们定义了名为simple_test的类，这个类有一个data属性和get_data方法。类里的实现非常简单，get_data方法只返回data属性值，并不进行其他操作。同时，我们还需定义了一个装饰器装饰类的get_data方法，装饰器中根据数据获取源来编写其中功能，比如我们这里选择从串口终端获取数据，直接修改装饰器的内容让其获取终端输入数据。

这样在设计一个类时，做到了将类中稳定的部分和经常要修改的部分独立开。类设计完成后，我们不需要更改类的源码，在使用时只需要根据需求修改类方法的装饰器就能实现我们的需求。

def serial_data(fcn):
    def wrapper(self, *args, **kw):
        str = input('Please enter an integer: ')
        try:
            tmp = int(str)
        except ValueError:
            print('Invalid Value')
            return None
        self.data = tmp
        return fcn(self)
    return wrapper

class simple_test(object):
    def __init__(self, _val = 0):
        self.data = _val
    
    @serial_data
    def get_data(self):
        return self.data
    
def main():
    obj = simple_test()
    val = obj.get_data()
    if val is not None:
        print('get Data: %d' %(val))
    
if __name__ == "__main__":
    main() 

运行结果： 

Please enter an integer: 100
get Data: 100
>>>

相关文章