python装饰器(Decorator)【修订版】

痛定思痛。 2022-11-18 01:24 239阅读 0赞

### python装饰器(Decorator) ###

什么是装饰器？“装饰”从字面意思来谁就是对特定的建筑物内按照一定的思路和风格进行美化的一种行为，所谓“器”就是工具，对于python来说装饰器就是能够在不修改原始的代码情况下给其添加新的功能，比如一款软件上线之后，我们需要在不修改源代码和不修改被调用的方式的情况下还能为期添加新的功能，在python种就可以用装饰器来实现。

python装饰器官方文档 [https://docs.python.org/zh-cn/3/glossary.html\#term-decorator][https_docs.python.org_zh-cn_3_glossary.html_term-decorator]

装饰器（decorator），一般指“装饰函数”（同的样概念也适用于类，但通常较少这样使用），其目的是在不对现有函数进行修改的情况下，实现新的额外的功能。最基本的理念来自于一种被称为“装饰模式”的设计模式。在 Python 中， 装饰器 一般用来修饰函数，实现公共功能，达到代码复用的目的。 在函数定义前加上 @xxxx ，然后函数就注入了某些功能。

由于Python装饰器的工作原理主要依赖于嵌套函数和闭包，所以我们必须先对嵌套函数和闭包有深入的了解。

先从**定义一个最简单函数**开始：

def foo(num):
        return num + 1
    
    print(foo(2)) #3

上面定义了一个函数，名字叫foo。

调用函数只需要给函数名加上括号并传递必要的参数（如果是有参数的函数）。

**函数还可以作为另函数的参数**，例如：

def foo(num):
        return num + 1
    
    def bar(fun):
        return fun(3)
    
    value = bar(foo)
    print(value)  # 4

**嵌套函数**

如果在一个函数的内部还定义了另一个函数，这个函数就叫嵌套函数。外部的我们叫它外函数，内部的我们叫他内函数。

我们先来看一个最简单的嵌套函数的例子。我们在outer函数里又定义了一个inner函数，并调用了它。你注意到了吗? 内函数在自己作用域内查找局部变量失败后，会进一步向上一层作用域里查找。

def outer():
        x = 1
        def inner():
            y = x + 1
            print(y)
    
        inner()
    
    outer() #输出结果 2

**闭包(Closure)**

闭包是Python编程一个非常重要的概念。如果一个外函数中定义了一个内函数，且内函数体内引用到了体外的变量，这时外函数通过return返回内函数的引用时，会把定义时涉及到的外部引用变量和内函数打包成一个整体（闭包）返回。

python中闭包从表现形式上看，如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，(又，一般外部函数的返回值为内部函数)，那么内部函数就被认为是闭包(closure)。

def func(name):
        def inner_func(age):
            print('name:', name, 'age:', age)
        return inner_func
    
    bb = func('Wang')
    bb(26)  # 输出 name: Wang age: 26

这里面调用func的时候就产生了一个闭包——inner\_func,并且该闭包持有自由变量——name，因此这也意味着，当函数func的生命周期结束之后，name这个变量依然存在，因为它被闭包引用了，所以不会被回收。

再举一例：

def outer(x):
        a = x
    
        def inner(y):
            b = y
            print(a+b)
    
        return inner 
    
    f1 = outer(1) 
    f1(10) # 输出11

inner(y)就是这个内部函数，对在外部作用域（但不是在全局作用域）的变量进行引用：x就是被引用的变量，x在外部作用域outer里面，但不在全局作用域里，则这个内部函数inner就是一个闭包。

一般一个函数运行结束的时候，临时变量会被销毁。但是闭包是一个特别的情况。当外函数发现，自己的临时变量会在将来的内函数中用到，自己在结束的时候，返回内函数的同时，会把外函数的临时变量同内函数绑定在一起。这样即使外函数已经结束了，内函数仍然能够使用外函数的临时变量。

关于 嵌套函数和闭包 可参见 [https://zhuanlan.zhihu.com/p/152408838][https_zhuanlan.zhihu.com_p_152408838]

有了上面的基础知识，就可以介绍python装饰器(Decorator)了。

**Python装饰器**(decorator)可以说是Python的一个神器，它可以在不改变一个函数代码和调用方式的情况下给函数添加新的功能。

Python的装饰器本质上是一个嵌套函数，它接受被装饰的函数(func)作为参数，并返回一个包装过的函数。这样我们可以**在不改变被装饰函数的代码的情况下给被装饰函数添加新的功能**。有了装饰器，我们就可以抽离出大量与函数功能本身无关的代码，增加一个函数的重用性。

在 Python 中，装饰器属于纯粹的“语法糖”，不使用也没关系，但是使用的话能够大大简化代码。

【语法糖：指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会。】

装饰器放在一个函数开始定义的地方，就像一顶帽子一样戴在这个函数的头上。和这个函数绑定在一起。

装饰器的一般使用形式如下（假设用 funA() 函数装饰器去装饰 funB() 函数）：

<table style="width:423px;"> 
 <tbody> 
  <tr> 
   <td style="vertical-align:top;width:420px;"> <p style="margin-left:0cm;">#funA 作为装饰器函数</p> <p style="margin-left:0cm;">def funA(fn):</p> <p style="margin-left:0cm;">&nbsp;&nbsp;&nbsp; ...</p> <p style="margin-left:0cm;">&nbsp;</p> <p style="margin-left:0cm;">#使用 ＠ 符号引用funA</p> <p style="margin-left:0cm;">@funA</p> <p style="margin-left:0cm;"># funB为被装饰函数</p> <p style="margin-left:0cm;">def funB():</p> <p style="margin-left:0cm;">&nbsp;&nbsp;&nbsp; ...</p> <p style="margin-left:0cm;">&nbsp;</p> </td> 
  </tr> 
 </tbody> 
</table>

**上面程序完全等价于下面的程序：**

在一个函数funB上加上@funA ，调用funB就相当于funA(funB)，使用 ＠ 符号引用已有的函数后，可用于修饰其他函数——被修饰的函数。当程序使用“＠函数”（比如＠ funA）装饰另一个函数（比如 funB）时，实际上完成如下两步：

将被修饰的函数（funB）作为参数传给 ＠ 符号引用的函数（funA）。

被“＠函数”（比如＠ funA）修饰的函数（比如 funB）不再是原来的函数，而是被替换成一个新的东西：被修饰的函数总是被替换成 ＠ 符号所引用的函数的返回值，因此被修饰的函数会变成什么，由＠ 符号所引用的函数的返回值决定，换句话，当您调用一个修饰函数时，您将得到一个可能与基本定义稍有不同的函数，该函数可能具有其他特性。这些话一开始可能不易理解，下面将给出一个简单示例：

def funA(fn):
        print('A')
        fn() # 执行传入的fn参数
        return 'OK'
    '''
    下面装饰效果相当于：funA(funB)，
    funB将会替换（装饰）成该语句的返回值；
    由于funA()函数返回OK，因此funB就是OK
    '''
    @funA
    def funB():
        print('B')
    
    print(funB)

运行结果类似如：

A  
B  
OK

上面程序使用 ＠funA 修饰 funB，这意味着程序要完成两步操作：  
将 funB 作为 funA() 的参数，也就是上面代码中 @funA 相当于执行 funA(funB)。  
将 funB 替换成上一步执行的结果，funA() 执行完成后返回 OK。 运行上面程序，可以看到如下输出结果： A   
B   
OK   
请记住，被修饰的函数总是被替换成 ＠ 符号所引用的函数的返回值，因此被修饰的函数会变成什么，由＠ 符号所引用的函数的返回值决定，换句话，当您调用一个修饰函数时，您将得到一个可能与基本定义稍有不同的函数，该函数可能具有其他特性。

＠ 符号来修饰函数是 Python 的一个非常实用的功能，它既可以在被修饰函数的前面添加一些额外的处理逻辑，这种改变不需要修改被修饰函数的代码，只要增加一个修饰即可。下面例子示范了如何通过函数装饰器为函数添加额外的处理功能。程序代码如下：

def auth(fn):
        def auth_fn(*args):
            # 用一条语句模拟额外的功能
            print("----这代表额外的处理功能----")
            # 回调要装饰的目标函数
            fn(*args)
        return auth_fn
    
    @auth
    def test(a, b):
        c=a+b
        print(" %s + %s = %s " % (a, b, c))
    
    # 调用test()函数,其实是调用装饰后返回的auth_fn函数
    test(20, 15)

运行结果如：

\----这代表额外的处理功能----  
 20 + 15 = 35

装饰器的用法有很多，下面的示例实现对函数计时——打印出func1、func2运行时间，代码如下：

import time
    
    def time_it(func):
          def inner():
               start = time.time()
               func()
               end = time.time()
               print('用时:{}秒'.format(end-start))
          return inner
    
    @time_it
    def func1():
          time.sleep(0.5)
          print("Func1 is running.")
    
    @time_it
    def func2():
          time.sleep(1.5)
          print("Func2 is running.")
    
    func1() #调用函数
    func2()

运行结果类似如：

Func1 is running.  
用时:0.5186727046966553秒  
Func2 is running.  
用时:1.5214245319366455秒

装饰器不仅可以是函数，还可以是类，但通常较少这样使用：

class AddNum():
        def __init__(self,func):
            self._func = func
    
        def __call__(self,alist):
            list1 = self._func(alist)
            num = 0
            for i in list1:
                num += i
            print("偶数序列为{}，其和为{}".format(list1,num))
    @AddNum
    def pprint(alist):
        list1 = []
        for i in alist:
            if i % 2 == 0:
                list1.append(i)
        return list1
                
    pprint([1,2,3,5,6,4,8,11,9])

运行结果如：

偶数序列为\[2, 6, 4, 8\]，其和为20

**解决装饰器的副作用**

Python装饰器（decorator）在实现的时候，有一些细节需要被注意。例如，被装饰后的函数其实已经是另外一个函数了（函数名等函数属性会发生改变）。例如：

def warfunc(func):
        def warpper(*args,**kwargs):
            print('warpper demo')
            ret = func(*args,**kwargs)
            return ret
        return warpper
    
    @warfunc
    def demofunc():
        print('func demo')
    
    demofunc()
    
    print(demofunc)#【注1】
    
    print(demofunc.__name__) #【注2】

运行输出：

warpper demo

func demo

<function warfunc.<locals>.warpper at 0x0000027533B57438>

warpper

其中，【注1】句输出：<function warfunc.<locals>.warpper at 0x0000027533B57438>

其中，【注2】句输出：warpper

说明函数名等函数属性会发生改变，怎么办？

为此，Python的functools包中提供了一个叫wraps的decorator来消除这样的副作用。写一个decorator的时候，最好在实现之前加上functools的wrap，它能保留原有函数的名称和docstring。

修改上例代码如下：

from functools import wraps #加入此句
    def warfunc(func):
        @wraps(func) # @wraps可以让我们在装饰器里面访问在装饰之前的函数的属性。
        def warpper(*args,**kwargs):
            print('warpper demo')
            ret = func(*args,**kwargs)
            return ret
        return warpper
    
    @warfunc
    def demofunc():
        print('func demo')
    
    demofunc()
    
    print(demofunc)#【注1】
    
    print(demofunc.__name__) #【注2】

运行输出：

warpper demo

func demo

demofunc

其中，【注1】句输出：<function demofunc at 0x0000020B9E467438>

其中，【注2】句输出：demofunc

符合正常期望了。

代码中的@wraps句，可以让我们在装饰器里面访问在装饰之前的函数的属性。

**装饰器范本**

你可以修改下面的代码段，设计自己的装饰器函数：

from functools import wraps
    def decorator_name(f):
        @wraps(f)
        def decorated(*args, **kwargs):
            if not can_run:
                return "函数将不运行"
            return f(*args, **kwargs)
        return decorated
    
    @decorator_name
    def func():
        return("函数运行")
    
    can_run	= True
    print(func())#输出：函数正在运行
    can_run	= False
    print(func()) #	输出：函数将不运行

**附录**、

关于Python的函数的几点特别说明 [https://blog.csdn.net/cnds123/article/details/115770008][https_blog.csdn.net_cnds123_article_details_115770008]

Python 之装饰器[http://www.ityouknow.com/python/2019/09/22/Python-decorator-020.html][http_www.ityouknow.com_python_2019_09_22_Python-decorator-020.html]

装饰器详解  [https://kanghaov.com/300.html][https_kanghaov.com_300.html]

【Python】装饰器图解 [https://blog.csdn.net/qq\_45978890/article/details/115282390][https_blog.csdn.net_qq_45978890_article_details_115282390]

视频讲解 Python装饰器(Decorator) [https://www.bilibili.com/video/av25698102][https_www.bilibili.com_video_av25698102]

[https_docs.python.org_zh-cn_3_glossary.html_term-decorator]: https://docs.python.org/zh-cn/3/glossary.html#term-decorator
[https_zhuanlan.zhihu.com_p_152408838]: https://zhuanlan.zhihu.com/p/152408838
[https_blog.csdn.net_cnds123_article_details_115770008]: https://blog.csdn.net/cnds123/article/details/115770008
[http_www.ityouknow.com_python_2019_09_22_Python-decorator-020.html]: http://www.ityouknow.com/python/2019/09/22/Python-decorator-020.html
[https_kanghaov.com_300.html]: https://kanghaov.com/300.html
[https_blog.csdn.net_qq_45978890_article_details_115282390]: https://blog.csdn.net/qq_45978890/article/details/115282390
[https_www.bilibili.com_video_av25698102]: https://www.bilibili.com/video/av25698102