装饰器

装饰器

一、装饰器的引入

有一个需求，一个加法函数，想要增强它的功能，能够输出被调用过以及调用的参数信息，这种需求应该如何解决呢？

# 加法函数 add 的定义
def add(x, y):
    return x+y
# 增强它的功能，输出被调用过以及调用的参数信息
def add(x, y):
    print("call add, x = {}, y = {}".format(x, y))
    return x+y

思考：功能是增强了，但是这种直接在原来只计算值的函数中增加属于非业务功能的代码，这种方式好吗？肯定是不好的，缺点如下：

1. 首先打印语句的耦合性太高了

2. 加法函数属于业务的逻辑，输出信息属于非业务功能的代码，不应该直接放在该函数中。

代码改进，重新定义一个函数，在这个函数中来做输出信息的功能：

def add(x, y):
    return x+y
​
def message_show(fn):
    print("begin...call add")
    result = fn(4, 5)
    print("end...")
    return result
​
print(message_show(add))

思考：这种方式做到了业务功能的分离，但是 add 函数的传参是一个问题，这种方式很不灵活，继续改进。

代码改进，解决参数的问题：

def add(x, y):
    return x+y
​
def message_show(fn, *args):
    print(*args)
    print("begin...call add")
    result = fn(*args)
    print("end...{} + {}".format(*args))
    return result
​
print(message_show(add, 4, 5))

至此，成功做到了新增业务功能的分离，可以看到并没有在原来的 add 函数中加入任何的代码，从而增强了它显示信息的功能。

二、装饰器的改造

（一）柯里化

要写出装饰器，首先要对函数进行柯里化。柯里化的过程如下代码：

def add(x, y):
    return x+y
​
def message_show(fn):
    def wrapper(*args):
        print(*args)
        print("begin...call add")
        result = fn(*args)
        print("end...{} + {}".format(*args))
        return result
    return wrapper
​
print(message_show(add)(4, 5))

思考：message_show(add)(4, 5)这种调用方式能不能改造成add(4, 5)，这种调用方法是不是就看不出调用过 message_show 函数了，而是直接调用的 add 函数，继续改造。

（二）装饰器定义

代码改造，柯里化之后，就可以使用装饰器的语法糖：

def message_show(fn):
    def wrapper(*args):
        print(*args)
        print("begin...call add")
        result = fn(*args)
        print("end...{} + {}".format(*args))
        return result
    return wrapper
​
@message_show  # 等效于 add = message_show(add)
def add(x, y):
    return x+y
​
print(add(4, 5))

注意：装饰函数的代码，必须要定义在被装饰函数的代码之前。

至此，一个简单的装饰器就出来了。

三、无参装饰器

（一）无参装饰器的理解

• 装饰器本身就是一个函数，而且是一个高阶函数

• 它的形参是一个函数，ps：要被装饰的函数

• 它的返回值是一个函数

• 可以使用 @function_name 的方式调用

（二）装饰器的例子

def fn_strengthen(fn):
    def wrapper(*args, **kwargs):
        print("========start=======")
        print("args = {}, kwargs = {}".format(args, kwargs))
        result = fn(*args, **kwargs)
        print(result)
        print("========end=========")
        return result
    return wrapper
​
@fn_strengthen  # add = fn_strengthen(add)
def add(x, y):
    print("==========call add=============")
    return x + y
​
add(4, y=5)

（三）装饰器的副作用

def fn_strengthen(fn):
    def wrapper(*args, **kwargs):
        print("========start=======")
        print("args = {}, kwargs = {}".format(args, kwargs))
        result = fn(*args, **kwargs)
        print(result)
​
        print("========end=========")
        return result
    return wrapper
​
@fn_strengthen  # add = fn_strengthen(add)
def add(x, y):
    """This is a function to add"""
    print("==========call add=============")
    return x + y
​
print("name = {}, doc = {}".format(add.__name__, add.__doc__))  # name = wrapper, doc = None

注意：可以看出被装饰函数的属性都被替换了，这种问题应该如何解决？

代码改进，再定义一个函数，用来记录被装饰函数的属性：

def fn_strengthen(fn):
    def wrapper(*args, **kwargs):
        print("========start=======")
        print("args = {}, kwargs = {}".format(args, kwargs))
        result = fn(*args, **kwargs)
        print(result)
​
        print("========end=========")
        return result
    add_property(fn, wrapper)
    return wrapper
​
def add_property(fn, wrapper):
    wrapper.__name__ = fn.__name__
    wrapper.__doc__ = fn.__doc__
​
@fn_strengthen  # add = fn_strengthen(add)
def add(x, y):
    """This is a function to add"""
    print("==========call add=============")
    return x + y
​
print("name = {}, doc = {}".format(add.__name__, add.__doc__))

上面的方法解决了属性被覆盖的问题，考虑到add_property这个函数的通用性，可以将这个复制属性的函数也改造成装饰器函数，只不过是带参的装饰器，代码改造如下：

def add_property(fn):
    def _copy(wrapper):
        wrapper.__name__ = fn.__name__
        wrapper.__doc__ = fn.__doc__
        return wrapper
    return _copy
​
def fn_strengthen(fn):
    @add_property(fn)  # wrapper = add_property(fn)(wrapper)
    def wrapper(*args, **kwargs):
        print("========start=======")
        print("args = {}, kwargs = {}".format(args, kwargs))
        result = fn(*args, **kwargs)
        print(result)
​
        print("========end=========")
        return result
    return wrapper
​
@fn_strengthen  # add = fn_strengthen(add)
def add(x, y):
    """This is a function to add"""
    print("==========call add=============")
    return x + y
​
print("name = {}, doc = {}".format(add.__name__, add.__doc__))

四、带参装饰器

（一）带参装饰器的引入

有一个需求，获取函数的执行时长，对时长超过阈值的函数记录一下：

import datetime, time
​
def add_property(fn):
    def _copy(wrapper):
        wrapper.__name__ = fn.__name__
        wrapper.__doc__ = fn.__doc__
        return wrapper
    return _copy
​
def time_detection(timeout):
    def fn_strengthen(fn):
        @add_property(fn)  # wrapper = add_property(fn)(wrapper)
        def wrapper(*args, **kwargs):
            print("========start=======")
            start = datetime.datetime.now()
            result = fn(*args, **kwargs)
            print(result)
            delta = (datetime.datetime.now() - start).total_seconds()
            print("so slow") if delta > timeout else print("so fast")
            print("========end=========")
            return result
        return wrapper
    return fn_strengthen
​
@time_detection(5)  # add = time_detection(5)(add)
def add(x, y):
    """This is a function to add"""
    print("==========call add=============")
    time.sleep(6)
    return x + y
​
add(4, 5)

（二）带参装饰器的理解

• 带参装饰器本身是一个函数，而且是一个高阶函数

• 它的形参可以是一个函数，返回值是一个不带参数的装饰器函数

• 使用 @function_name(参数) 方式调用

• 可以看做是在装饰器的外层又加了一层函数

（三）带参装饰器的例子

将上一个例子中的记录时长的功能提取出来，能不能定义成一个参数来灵活的控制输出，代码改造如下：

import datetime, time
​
def add_property(fn):
    def _copy(wrapper):
        wrapper.__name__ = fn.__name__
        wrapper.__doc__ = fn.__doc__
        return wrapper
    return _copy
​
def time_detection(timeout, func=lambda name, delta:print("{} spend {}s".format(name, delta))):
    def fn_strengthen(fn):
        @add_property(fn)  # wrapper = add_property(fn)(wrapper)
        def wrapper(*args, **kwargs):
            print("========start=======")
            start = datetime.datetime.now()
            result = fn(*args, **kwargs)
            print(result)
            delta = (datetime.datetime.now() - start).total_seconds()
            if delta > timeout:
                func(fn.__name__, delta)
            print("========end=========")
            return result
        return wrapper
    return fn_strengthen
​
@time_detection(5)  # add = time_detection(5)(add)
def add(x, y):
    """This is a function to add"""
    print("==========call add=============")
    time.sleep(6)
    return x + y
​
add(4, 5)

五、functools模块

这个模块就省了自己重新写复制属性的那个函数，functools.update_wrapper(包装函数, 原函数)使用这个模块来改造前面获取原函数属性的函数：

import datetime, time, functools
​
def time_detection(timeout, func=lambda name, delta:print("{} spend {}s".format(name, delta))):
    def fn_strengthen(fn):
        def wrapper(*args, **kwargs):
            print("========start=======")
            start = datetime.datetime.now()
            result = fn(*args, **kwargs)
            print(result)
            delta = (datetime.datetime.now() - start).total_seconds()
            if delta > timeout:
                func(fn.__name__, delta)
            print("========end=========")
            return result
        return functools.update_wrapper(wrapper, fn)
    return fn_strengthen
​
@time_detection(5)  # add = time_detection(5)(add)
def add(x, y):
    """This is a function to add"""
    print("==========call add=============")
    time.sleep(6)
    return x + y
​
add(5, 6), add.__name__, add.__doc__

还可以使用这个模块的装饰器的方法来复制属性，@functools.wraps(原函数)：

import datetime, time, functools

def time_detection(timeout, func=lambda name, delta:print("{} spend {}s".format(name, delta))):
    def fn_strengthen(fn):
        @functools.wraps(fn)
        def wrapper(*args, **kwargs):
            print("========start=======")
            start = datetime.datetime.now()
            result = fn(*args, **kwargs)
            print(result)
            delta = (datetime.datetime.now() - start).total_seconds()
            if delta > timeout:
                func(fn.__name__, delta)
            print("========end=========")
            return result
        return wrapper
    return fn_strengthen

@time_detection(5)  # add = time_detection(5)(add)
def add(x, y):
    """This is a function to add"""
    print("==========call add=============")
    time.sleep(6)
    return x + y

print(add(5, 6), add.__name__, add.__doc__)