Python装饰器的详细解析

用户8949263

发布于 2022-04-08 13:05:33

5330

发布于 2022-04-08 13:05:33

文章被收录于专栏：Python数据分析实例

什么是装饰器？

Python装饰器（fuctional decorators）就是用于拓展原来函数功能的一种函数，目的是在不改变原函数名(或类名)的情况下，给函数增加新的功能。

这个函数的特殊之处在于它的返回值也是一个函数，这个函数是内嵌“原" 函数的函数。

一般而言，我们要想拓展原来函数代码，最直接的办法就是侵入代码里面修改，例如：

import time

def f():
    print("hello")
    time.sleep(1)
    print("world")

这是我们最原始的的一个函数，然后我们试图记录下这个函数执行的总时间，那最简单的做法就是改动原来的代码：

import time
def f():
    start_time = time.time()
    print("hello")
    time.sleep(1)
    print("world")
    end_time = time.time()
    execution_time = (end_time - start_time)*1000
    print("time is %d ms" %execution_time)

但是实际工作中，有些时候核心代码并不可以直接去改，所以在不改动原代码的情况下，我们可以再定义一个函数。（但是生效需要再次执行函数）

import time
def deco(func):
    start_time = time.time()
    f()
    end_time = time.time()
    execution_time = (end_time - start_time)*1000
    print("time is %d ms" %execution_time)

def f():
    print("hello")
    time.sleep(1)
    print("world")

if __name__ == '__main__':
    deco(f)
    print("f.__name__ is",f.__name__)
    print()

输出如下：

hello
world
time is 1000 ms
f.__name__ is f

这里我们定义了一个函数deco，它的参数是一个函数，然后给这个函数嵌入了计时功能。但是想要拓展这一千万个函数功能，

就是要执行一千万次deco()函数，所以这样并不理想！接下来，我们可以试着用装饰器来实现，先看看装饰器最原始的面貌。

import time
def deco(f):
    def wrapper():
        start_time = time.time()
        f()
        end_time = time.time()
        execution_time = (end_time - start_time) * 1000
        print("time is %d ms" % execution_time)

    return wrapper

@deco
def f():
    print("hello")
    time.sleep(1)
    print("world")

if __name__ == '__main__':
    f()

输出如下：

hello
world
time is 1000 ms

这里的deco函数就是最原始的装饰器，它的参数是一个函数，然后返回值也是一个函数。

其中作为参数的这个函数f()就在返回函数wrapper()的内部执行。然后在函数f()前面加上@deco，

f()函数就相当于被注入了计时功能，现在只要调用f()，它就已经变身为“新的功能更多”的函数了,（不需要重复执行原函数）。

扩展1：带有固定参数的装饰器

import time
def deco(f):
    def wrapper(a,b):
        start_time = time.time()
        f(a,b)
        end_time = time.time()
        execution_time = (end_time - start_time)*1000
        print("time is %d ms" % execution_time)
    return wrapper

@deco
def f(a,b):
    print("be on")
    time.sleep(1)
    print("result is %d" %(a+b))

if __name__ == '__main__':
    f(3,4)

输出如下：

be on
result is 7
time is 1000 ms

扩展2：无固定参数的装饰器

import time
def deco(f):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        f(*args, **kwargs)
        end_time = time.time()
        execution_time = (end_time - start_time)*1000
        print("time is %d ms" %execution_time)
    return wrapper

@deco
def f(a,b):
    print("be on")
    time.sleep(1)
    print("result is %d" %(a+b))

@deco
def f2(a,b,c):
    print("be on")
    time.sleep(1)
    print("result is %d" %(a+b+c))

if __name__ == '__main__':
    f2(3,4,5)
    f(3,4)

输出如下：

be on
result is 12
time is 1000 ms
be on
result is 7
time is 1000 ms

扩展3：使用多个装饰器，装饰一个函数

import  time
def deco01(f):
    def wrapper(*args, **kwargs):
        print("this is deco01")
        start_time = time.time()
        f(*args, **kwargs)
        end_time = time.time()
        execution_time = (end_time - start_time)*1000
        print("time is %d ms" % execution_time)
        print("deco01 end here")
    return wrapper

def deco02(f):
    def wrapper(*args, **kwargs):
        print("this is deco02")
        f(*args, **kwargs)
        print("deco02 end here")
    return wrapper

@deco01
@deco02
def f(a,b):
    print("be on")
    time.sleep(1)
    print("result is %d" %(a+b))

if __name__ == '__main__':
    f(3,4)

输出如下：

this is deco01
this is deco02
be on
result is 7
deco02 end here
time is 1009 ms
deco01 end here

装饰器调用顺序

装饰器是可以叠加使用的，那么使用装饰器以后代码是啥顺序呢？

对于Python中的”@”语法糖，装饰器的调用顺序与使用 @ 语法糖声明的顺序相反。

在这个例子中，f(3, 4) 等价于 deco01(deco02(f(3, 4)))。

Python内置装饰器

在Python中有三个内置的装饰器，都是跟class相关的：staticmethod、classmethod 和property。

staticmethod 是类静态方法，其跟成员方法的区别是没有 self 参数，并且可以在类不进行实例化的情况下调用
classmethod 与成员方法的区别在于所接收的第一个参数不是 self （类实例的指针），而是cls（当前类的具体类型）
property 是属性的意思，表示可以通过通过类实例直接访问的信息

对于staticmethod和classmethod这里就不介绍了，通过一个例子看看property。

class Foo(object):

    def __init__(self, var):
        super(Foo, self).__init__()
        self.__var = var

    @property
    def var(self):
        return self.__var

    @var.setter
    def var(self, var):
        self.__var = var


if __name__ == "__main__":
    foo = Foo("var1")
    print(foo.var)
    foo.var = "var2"
    print(foo.var)

注意,对于Python新式类(在 py3 里面的继承 object 的类(默认），以及它的子类都是新式类），如果将上面的 “@var.setter” 装饰器所装饰的成员函数去掉，则Foo.var 属性为只读属性，使用 “foo.var = ‘var 2′” 进行赋值时会抛出异常。但是，对于Python classic class，所声明的属性不是 read-only的，所以即使去掉”@var.setter”装饰器也不会报错。

参数化装饰器

在实际代码中可能需要使用参数化的装饰器。如果用函数作为装饰器的话，那么解决方法很简单：再增加一层包装。例如：

def repeat(number=3):
    """多次重复执行原始函数，返回最后一次调用的值作为结果"""
    def actual_decorator(function):
        def wrapper(*args, **kwargs):
            result = None
            for i in range(number):
                result = function(*args, **kwargs)
            return result
        return wrapper
    return actual_decorator

@repeat()  # 即使有默认参数，这里的括号也不能省略
def f():
    print("喵")

@repeat(2)
def g(a,b):
    print("g函数执行中")
    return a + b

if __name__ == "__main__":
    f()
    print()
    print(g(1, 2))

保存原始函数的文档字符串和函数名看下面的例子：

def dumy_dec(function):
    def wrapped(*args, **kwargs):
        """包装函数内部文档"""
        return function(*args, **kwargs)
    return wrapped

@dumy_dec
def function():
    """原始的文档字符串"""

if __name__ == "__main__":
    print(function.__name__)
    print(function.__doc__)

使用装饰器后，我们如果想查看原始函数的函数名或原始函数的文档字符串，返回的却是：

wrapped
包装函数内部文档

解决这个问题的正确办法，是使用functools模块内置的wraps()装饰器。

from functools import wraps

def preserving_dec(function):
    @wraps(function)  # 注意看这里！
    def wrapped(*args, **kwargs):
        """包装函数内部文档"""
        return function(*args, **kwargs)
    return wrapped

@preserving_dec
def function():
    """原始的文档字符串"""
if __name__ == "__main__":
    print(function.__name__)
    print(function.__doc__)

结果如下：

function
原始的文档字符串

用类来实现装饰器

装饰器函数其实是这样一个接口约束，它必须接受一个callable对象作为参数，然后返回一个callable对象。在Python中一般callable对象都是函数，但也有例外。只要某个对象重载了__call__()方法，那么这个对象就是callable的。由此使用用户自定义的类也可以实现装饰器：

class Decorator:
    def __init__(self, function):
        self.function = function

    def __call__(self, *args, **kwargs):
        print("Do something here before call The original function")
        print(self.function.__doc__)
        result = self.function(*args, **kwargs)
        print("Do something here after call The original function")
        return result

@Decorator
def add(a, b):
    """原始函数的文档字符串"""
    print("The original function is running")
    return a + b

if __name__ == "__main__":
    add(1, 2)

结果如下：

Do something here before call The original function
原始函数的文档字符串
The original function is running
Do something here after call The original function

不能装饰静态方法和类方法

from datetime import datetime

def logging(func):
    def wrapper(*args, **kwargs):
        """print log before a function."""
        print("[DEBUG] {}: enter {}()".format(datetime.now(), func.__name__))
        return func(*args, **kwargs)
    return wrapper

class Car(object):
    def __init__(self, model):
        self.model = model

    @logging  # 装饰实例方法，OK
    def run(self):
        print(f"{self.model} is running!")

    @logging  # 装饰静态方法，Failed
    @staticmethod
    def check_model_for(obj):
        if isinstance(obj, Car):
            print(f"The model of your car is {obj.model}")
        else:
            print(f"{obj} is not a car!")

car = Car("麒麟")
car.run()
Car.check_model_for(car)

会报错：

Traceback (most recent call last):
  File "F:/AutoOps_platform/装饰器.py", line 253, in <module>
    Car.check_model_for(car)
  File "F:/AutoOps_platform/装饰器.py", line 231, in wrapper
    print("[DEBUG] {}: enter {}()".format(datetime.now(), func.__name__))
AttributeError: 'staticmethod' object has no attribute '__name__'
[DEBUG] 2021-08-06 13:11:19.070195: enter run()
麒麟 is running!

@staticmethod 这个装饰器，其实返回的并不是一个callable对象，而是一个staticmethod 对象，那么它是不符合装饰器要求的（比如传入一个callable对象），你自然不能在它之上再加别的装饰器。要解决这个问题很简单，只要把你的装饰器放在@staticmethod 之前就好了：

@staticmethod
@logging  # 先装饰就没问题
def check_model_for(obj):
    if isinstance(obj, Car):
        print(f"The model of your car is {obj.model}")
    else:
        print(f"{obj} is not a car!")

[DEBUG] 2021-08-06 13:14:40.404121: enter run()
麒麟 is running!
[DEBUG] 2021-08-06 13:14:40.404121: enter check_model_for()
The model of your car is 麒麟

使用第三方库优化你的装饰器

decorator.py 是一个非常简单的装饰器加强包。你可以很直观的先定义包装函数wrapper()，再使用decorate(func, wrapper)方法就可以完成一个装饰器。

from decorator import decorate
from datetime import datetime

def wrapper(func, *args, **kwargs):
    """print log before a function."""
    print("[DEBUG] {}: enter {}()".format(datetime.now(), func.__name__))
    return func(*args, **kwargs)

def logging(func):
    return decorate(func, wrapper)  # 用wrapper装饰func
@logging
def f(a, b):
    return a + b

f(1,2)

你也可以使用它自带的@decorator装饰器来完成你的装饰器。


from decorator import decorator
from datetime import datetime

@decorator
def logging(func, *args, **kwargs):
    print(f"[DEBUG] {datetime.now()}: enter {func.__name__}()")
    return func(*args, **kwargs)

@logging
def f(a, b):
    return a + b

f(1,2)

[DEBUG] 2021-08-06 13:19:44.920748: enter f()

decorator.py实现的装饰器能完整保留原函数的name，doc和args。

也可以使用第三方库wrapt：

import wrapt

@wrapt.decorator  # without argument in decorator
def logging(wrapped, instance, args, kwargs):  # instance is must
    print(f"[DEBUG]: enter {wrapped.__name__}()")
    return wrapped(*args, **kwargs)

@logging
def say(something):
    print(f"is saying {something}")

say("喵")

[DEBUG]: enter say()
is saying 喵

使用wrapt你只需要定义一个装饰器函数，但是函数签名是固定的，必须是(wrapped, instance, args, kwargs)，注意第二个参数instance是必须的，就算你不用它。当装饰器装饰在不同位置时它将得到不同的值，比如装饰在类实例方法时你可以拿到这个类实例。根据instance的值你能够更加灵活的调整你的装饰器。另外，args和kwargs也是固定的，注意前面没有星号。在装饰器内部调用原函数时才带星号。

如果你需要使用wrapt写一个带参数的装饰器，可以这样写:

def logging(level):
    @wrapt.decorator
    def wrapper(wrapped, instance, args, kwargs):
        print("[{}]: enter {}()".format(level, wrapped.__name__))
        return wrapped(*args, **kwargs)
    return wrapper

@logging(level="INFO")
def say(something):
    print(f"is saying {something}")

say("喵")