本文目的是由浅入深地介绍python装饰器原理

装饰器(Decorators)是 Python 的一个重要部分

其功能是，在不修改原函数(类)定义代码的情况下，增加新的功能

为了理解和实现装饰器，我们先引入2个核心操作：

1 必要的2个核心操作

1.1 核心操作1， 函数内部可以定义函数

def hi(name='world'):

    print(f"hello, {name}")

    def howdoyoudo(name2=name):

        print(f"how do you do? {name2}")

    howdoyoudo()

    howdoyoudo('world')

hi("ytt") # 但是新函数还是存在的。

hi("ycy") # 但是新函数还是存在的。

try:

    howdoyoudo()

except:

    print("function not found")

在这个例子中，函数hi的形参name，默认为'world'

在函数内部，又定义了另一个函数 howdoyoudo，定义这个函数时，将形参name作为新函数的形参name2的默认值。

因此，在函数内部调用howdoyoudo()时，将以调用hi时的实参为默认值，但也可以给howdoyoudo输入其他参数。

上面的例子运行后输出结果为：

hello, ytt

how do you do? ytt

how do you do? world

hello, ycy

how do you do? ycy

how do you do?

worldfunction not found

这里新定义的howdoyoudo可以称作一个“闭包”。不少关于装饰器的blog都提到了这个概念，但其实没必要给它取一个多专业的名字。我们知道闭包是函数内的函数就可以了

1.2 核心操作2 函数可以作为对象被输入输出

1.2.1 核心操作2的前置条件，函数是对象

当我们进行 def 的时候，我们在做什么？

def hi():

    print("hi")

    return "world"

这时，hi函数，打印一个字符串，同时返回一个字符串。

但hi函数本身也是一个对象，一个可以执行的对象。执行的方式是hi()。

这里hi和hi()有本质区别，

hi 代表了这个函数对象本身

hi() 则是运行了函数，得到函数的返回值。

def hi(name='world'):

    print(f"hello, {name}")

    return name

msg = hi()  # 运行函数，返回字符串，因此msg是个字符串

print(msg)

hello = hi  # 将函数本身赋值给hello，此时hello是另一个函数，即使删除原函数hi，新函数hello也可以正常调用

del hi  # 删除原函数hi

try:

    hi()

except:

    print("func hi not found")

hello("ycy") # 但是新函数还是存在的。

作为对比，可以想象以下代码

a = 'example'

b = a

del a

此时也是b存在，可以正常使用。

1.2.2函数作为输入

我们定义2个函数，分别实现自加1， 自乘2，

再定义一个函数double_exec，内容是将某个函数调用2次

在调用double_exec时，可以将函数作为输入传进来

def func1(n):

    return n+1

def func2(n):

    return n*2

def double_exec(f,x):

    return f(f(x))    

rst = double_exec(func1, 5)

print(rst)

rst = double_exec(func2, 3)

print(rst)

输出结果就是

7

27

1.2.3 函数作为输出

同样，也可以将函数作为输出

def select_func(i):

    def func1(n):

        return n+1

    def func2(n):

        return n*2

    func_list = [func1, func2]

    return func_list[i]

func = select_func(0)  # 第1个函数

print(func(5))

func = select_func(1)  # 第2个函数

print(func(5))

输出结果为

6

10

2 尝试构造装饰器

有了以上两个核心操作，我们可以尝试构造装饰器了。

装饰器的目的：在不修改原函数(类)定义代码的情况下，增加新的功能

试想一下，现在有一个原函数

def original_function:

    print("this is original function")

在不修改原函数定义代码的情况下，如果想进行函数内容的添加，可以将这个函数作为一个整体，添加到这样的包裹中：

def my_decorator(f):

    def wrap_func():

        print(f"before call {f.__name__}")

        f()

        print(f"after call {f.__name__}")

    return wrap_func

new_function = my_decorator(original_function)

我们定义了一个my_decorator函数，这个函数进行了一种操作：

对传入的f，添加操作(运行前后增加打印)，并把添加操作后的内容连同运行原函数的内容，一起传出

这个my_decorator，定义了一种增加前后打印内容的行为

调用my_decorator时，对这个行为进行了操作。

因此，new_function是一个在original_function上增加了前后打印行为的新函数

这个过程被可以被称作装饰。

例子中的对象	角色	说明
wrap	闭包函数	重新定义了一种格式，这个格式可以任意的，是装饰器的真正内容
my_decorator	装饰器	定义了按warp这种格式进行操作的函数
f	待装饰函数(形参)	在定义装饰器时，待装饰函数只是一个参数
original_function	实际进行装饰的函数	一个具体的需要装饰的函数
new_function	装饰后的函数	一个具体的装饰完成的函数

这里已经可以发现，装饰器本身对于被装饰的函数是什么，是不需要考虑的。装饰器本身只定义了一种装饰行为，这个行为是通过装饰器内部的闭包函数()进行定义的。

运行装饰前后的函数，可以清晰看到装饰的效果

def original_function():

    print("this is original function")

def my_decorator(f):

    def wrap_func():

        print(f"before calling {f.__name__}")

        f()

        print(f"after calling {f.__name__}")

    return wrap_func

new_function = my_decorator(original_function)

original_function()

print("#########")

new_function()

3装饰器定义的简写

我们复现一下实际要用装饰器的情况，我们往往有一种装饰器，想应用于很多个函数，比如

def my_decorator(f):

    def wrap_func():

        print(f"before calling {f.__name__}")

        f()

        print(f"after calling {f.__name__}")

    return wrap_func

def print1():

    print("num=1")

def print2():

    print("num=2")

def print3():

    print("num=3")

此时，如果我们想给3个print函数都加上装饰器，需要这么做

new_print1 = my_decorator(print1)

new_print2 = my_decorator(print2)

new_print3 = my_decorator(print3)

实际调用的时候，就需要调用添加装饰器的函数名了

new_print1()

new_print2()

new_print3()

当然，也可以赋值给原函数名

print1 = my_decorator(print1)

print1 = my_decorator(print2)

print3 = my_decorator(print3)

这样至少不需要管理一系列装饰前后的函数。

同时，在不需要进行装饰的时候，需要把

print1 = my_decorator(print1)

print1 = my_decorator(print2)

print3 = my_decorator(print3)

全部删掉。

事实上，这样并不方便，尤其对于更复杂的装饰器来说

为此，python提供了一种简写方式

def my_decorator(f):

    def wrap_func():

        print(f"before calling {f.__name__}")

        f()

        print(f"after calling {f.__name__}")

    return wrap_func

@my_decorator

def print1():

    print("num=1")

这个定义print1函数前的@my_decorator，相当于在定义完print1后，自动直接运行了

print1 = my_decorator(print1)

一个新的麻烦及解决办法

不论采用@my_decorator放在新函数前，还是显示地重写print1 = my_decorator(print1)，都会存在一个问题：

装饰后的函数，名字改变了(其实不止名字，一系列的索引都改变了)

def print1():

    print("num=1") 

print(f"before decorate, function name: {print1.__name__}")

print1 = my_decorator(print1)

print(f"after decorate, function name: {print1.__name__}")

输出结果为:

before decorate, function name: print1

after decorate, function name: wrap_func

这个现象的原因是，装饰行为本身，是通过构造了一个新的函数（例子中是wrap_func函数）来实现装饰这个行为的，然后把这个修改后的函数赋给了原函数名。

这样，会导致我们预期的被装饰函数的一些系统变量（比如__name__）发生了变化。

对此，python提供了解决方案：

from functools import wraps  # 导入一个系统工具

def my_decorator(f):

    @wraps(f)  # 在定义装饰行为函数的时候，增加一个新的装饰器

    def wrap_func():

        print(f"before calling {f.__name__}")

        f()

        print(f"after calling {f.__name__}")

    return wrap_func

经过这个行为后，被装饰函数的系统变量问题被解决了

def print1():

    print("num=1") 

print(f"before decorate, function name: {print1.__name__}")

print1 = my_decorator(print1)

print(f"after decorate, function name: {print1.__name__}")

输出结果为

before decorate, function name: print1

after decorate, function name: print1

当然，如果你不需要使用一些系统变量，也可以不关注这个问题。

复杂一点的情况1 被装饰函数有输入输出

刚才的例子都比较简单，被装饰的函数是没有参数的。如果被装饰的函数有参数，只需要在定义装饰行为时（事实上，这个才更通用），增加(*args, **kwargs)描述即可

from functools import wraps

def my_decorator(f):

    @wraps(f)

    def wrap_func(*args, **kwargs):  # 增加了输入参数

        print(f"before calling {f.__name__}")

        ret = f(*args, **kwargs)  # 透传了输入参数，并记录了输出

        print(f"after calling {f.__name__}") # line-after

        return ret  # 执行 "line-after" 后，将f的输出返回

    return wrap_func

之前的描述中可以感受到，对于例子中的装饰行为(前后加打印)，函数被装饰后，本质上是调用了新的装饰函数wrap_func。

因此，如果原函数需要有输入参数传递，只需要在wrap_func（或其他任意名字的装饰函数）定义时，也增加参数输入(*args, **kwargs)，并将这些参数，原封不动地传给待装饰函数f。

这种定义装饰行为的方式更具有普遍性，忘记之前的定义方式吧

我们试一下

@my_decorator

def my_add(x, y):

    return x + y

n = my_add(1, 3)

print(n)

输出

before calling my_add

after calling my_add

4

这里需要注意的是，如果按照以下的方式定义装饰器

from functools import wraps

def my_decorator(f):

    @wraps(f)

    def wrap_func(*args, **kwargs):  # 增加了输入参数

        print(f"before calling {f.__name__}")

        return f(*args, **kwargs)  # 透传了输入参数，并记录了输出

        print(f"after calling {f.__name__}") # line-after

    return wrap_func

那么以下语句将不会执行

 print(f"after calling {f.__name__}") # line-after

因为装饰后实际的函数wrap_func(虽然名字被改成了原函数，系统参数也改成了原函数)，运行到return f(*args, **kwargs) 的时候已经结束了

复杂一点的情况2 装饰器有输入

因为装饰器my_decorator本身也是可以输入的，因此，只需要在定义装饰器时，增加参数，并在后续函数中使用就可以了，比如

from functools import wraps

def my_decorator(f, msg=""):

    @wraps(f)

    def wrap_func(*args, **kwargs):  # 增加了输入参数

        print(f"{msg}, before calling {f.__name__}")

        return f(*args, **kwargs)  # 透传了输入参数，并记录了输出

        print(f"{msg}, after calling {f.__name__}") # line-after

    return wrap_func

此时装饰器已经可以有输入参数了

def my_add(x, y):

    return x + y

my_add = my_decorator(my_add, 'yusheng')

n = my_add(1, 3)

print(n)

输出

yusheng, before calling my_add

yusheng, after calling my_add

4

你可能发现，为什么不用简写版的方法了

@my_decorator(msg='yusheng')

def my_add(x, y):

    return x + y

n = my_add(1, 3)

print(n)

因为以上代码会报错！！

究其原因，虽然

@my_decorator

def my_add(x, y):

    return x + y

等价于

def my_add(x, y):

    return x + y

my_add = my_decorator(my_add)

但是，

@my_decorator(msg='yusheng')

def my_add(x, y):

    return x + y

并不等价于

def my_add(x, y):

    return x + y

my_add = my_decorator(my_add, msg='yusheng')

这本身和@语法有关，使用@my_decorator时，是系统在应用一个以单个函数作为参数的闭包函数。即，@是不能带参数的。

但是你应该发现了，之前的@wraps(f)不是带参数了吗？请仔细观察以下代码

def my_decorator_with_parma(msg='')

    def my_decorator(f):

        @wraps(f)

        def wrap_func(*args, **kwargs):  # 增加了输入参数

            print(f"{msg}, before calling {f.__name__}")

            return f(*args, **kwargs)  # 透传了输入参数，并记录了输出

            print(f"{msg}, after calling {f.__name__}") # line-after

        return wrap_func

    return my_decorator

通过一层嵌套，my_decorator_with_parma本质上是返回了一个参数仅为一个函数的函数(my_decorator)，但因为my_decorator对my_decorator_with_parma来说是一个闭包，my_decorator_with_parma是可以带参数的。（这句话真绕）

通过以上的定义，我们再来看

@my_decorator_with_parma(msg='yusheng')

def my_add(x, y):

    return x + y

可以这么理解，my_decorator_with_parma(msg='yusheng')的结果是原来的my_decorator函数，同时，因为my_decorator_with_parma可以传参，参数实际上是参与了my_decorator的（因为my_decorator对my_decorator_with_parma是闭包），my_decorator_with_parma(msg='yusheng')全等于一个有参数参加的my_decorator

因此，以上代码等价于有参数msg传递的

@my_decorator

def my_add(x, y):

    return x + y

比较绕，需要理解一下，或者干脆强记这种范式：

from functools import wraps

def my_decorator(msg=''):  # 名字改一下

    def inner_decorator(f):  # 名字改一下

        @wraps(f)

        def wrap_func(*args, **kwargs):  # 增加了输入参数

            print(f"{msg}, before calling {f.__name__}")

            ret = f(*args, **kwargs)  # 透传了输入参数，并记录了输出

            print(f"{msg}, after calling {f.__name__}") # line-after

            return ret

        return wrap_func

    return inner_decorator

以上范式包含函数的输入输出、装饰器的输入，可以应对大部分情况了。

实验一下：

@my_decorator(msg='yusheng')

def my_add(x, y):

    return x + y

my_add(1, 2)

输出

yusheng, before calling my_add

yusheng, after calling my_add

有用的函数装饰器例子

统计耗时的日志

from functools import wraps

import datetime

def log(output_path=None):  # 名字改一下

    def decorator(f):  # 名字改一下

        @wraps(f)

        def wrap_func(*args, **kwargs):  # 增加了输入参数

            now = datetime.datetime.now()

            msg = now.strftime("%Y-%m-%d %H:%M:%S")  # 运行时刻

            msg += f" {f.__name__}()\n"  # 运行的函数名            

            ret = f(*args, **kwargs)  # 透传了输入参数，并记录了输出

            aft = datetime.datetime.now()

            time_cost = aft - now

            ms = time_cost.total_seconds() * 10**3  # 毫秒

            msg += now.strftime("%Y-%m-%d %H:%M:%S")

            msg += f" {f.__name__}() return, cost {ms} ms"

            if output_path is None:

                print(msg)

            else:

                print(f"print logs into {output_path}")

                with open(output_path, 'a+') as fp:

                    fp.write(msg + '\n')

        return wrap_func

    return decorator

以上是一个log装饰器，利用datetime统计了函数的耗时，

并且，装饰器可以进行输出文件操作，如果给出了文件路径，则输出文件，否则就打印。

利用这个装饰器，可以灵活地进行耗时统计

@log()

def my_sum(x, y):

    s = 0

    for i in range(x, y+1):

        s += i

    return s

my_sum(1, 9999999)

不设置输出文件地址，则打印。运行结果为：

2021-12-03 10:01:52 my_sum()

2021-12-03 10:01:52 my_sum() return, cost 506.3299999999999 ms

也可以输出到文件

@log('test.log')

def my_sum(x, y):

    s = 0

    for i in range(x, y+1):

        s += i

    return s   

my_sum(1, 9999999)

输出结果为

print logs into test.log

同时在当前目录生成了一个test.log 文件，内容为：

2021-12-03 10:03:17 my_sum()

2021-12-03 10:03:17 my_sum() return, cost 461.813 ms

从装饰函数到装饰类

以上的装饰器都是以函数形式出现的，但我们可以稍做改写，将装饰器以类的形式实现。

from functools import wraps

import datetime

class Log:

    def __init__(self, path=None):

        self._output = path

    def __call__(self, f):  # 相当于原来的 inner_decorator

        @wraps(f)

        def wrap_func(*args, **kwargs):  # 增加了输入参数

            now = datetime.datetime.now()

            msg = now.strftime("%Y-%m-%d %H:%M:%S")  # 运行时刻

            msg += f" {f.__name__}()\n"  # 运行的函数名            

            ret = f(*args, **kwargs)  # 透传了输入参数，并记录了输出

            aft = datetime.datetime.now()

            time_cost = aft - now

            ms = time_cost.total_seconds() * 10**3  # 毫秒

            msg += now.strftime("%Y-%m-%d %H:%M:%S")

            msg += f" {f.__name__}() return, cost {ms} ms"

            if self._output is None:

                print(msg)

            else:

                print(f"print logs into {self._output}")

                with open(self._output, 'a+') as fp:

                    fp.write(msg + '\n')

        return wrap_func

这个装饰器类Log 上个例子里的装饰器函数log功能是一样的，同时，这个装饰器类还可以作为基类被其他继承，进一步增加功能。