python修饰器（装饰器）以及wraps

• Z时代
• 2024-01-10
• 分类：综合

Python装饰器(decorator)是在程序开发中经常使用到的功能，合理使用装饰器，能让我们的程序如虎添翼。

装饰器的引入

初期及问题的诞生

假如现在在一个公司，有A B C三个业务部门，还有S一个基础服务部门，目前呢，S部门提供了两个函数，供其他部门调用，函数如下：

def f1():
    print('f1 called')
def f2():
    print('f2 called')

在初期，其他部门这样调用是没有问题的，随着公司业务的发展，现在S部门需要对函数调用假如权限验证，如果有权限的话，才能进行调用，否则调用失败。考虑一下，如果是我们，该怎么做呢？

方案集合
1、让调用方也就是ABC部门在调用的时候，先主动进行权限验证
2、S部门在对外提供的函数中，首先进行权限认证，然后再进行真正的函数操作
问题
　　　　方案一，将本不该暴露给外层的权限认证，暴露在使用方面前，同时如果有多个部门呢，要每个部门每个人都要周知到，你还不缺定别人一定会这么做，不靠谱。。。
　　　　方案二，看似看行，可是当S部门对外提供更多的需要进行权限验证方法时，每个函数都要调用权限验证，同样也实在费劲，不利于代码的维护性和扩展性

那么，有没有一种方法能够遵循代码的开放闭合原则，来完美的解决此问题呢？

装饰器引入
答案肯定是有的，不然真的是弱爆了。先看代码

def w1(func):
    def inner():
        print('...验证权限...')
        func()
    return inner
@w1
def f1():
    print('f1 called')
@w1
def f2():
    print('f2 called')
f1()
f2()

输出结果为

...验证权限...
f1 called
...验证权限...
f2 called

可以通过代码及输出看到，在调用f1 f2 函数时，成功进行了权限验证，那么是怎么做到的呢？其实这里就使用到了装饰器，通过定义一个闭包函数w1，在我们调用函数上通过关键词@w1，这样就对f1 f2函数完成了装饰。

装饰器原理
首先，开看我们的装饰器函数w1，该函数接收一个参数func，其实就是接收一个方法名，w1内部又定义一个函数inner，在inner函数中增加权限校验，并在验证完权限后调用传进来的参数func，同时w1的返回值为内部函数inner，其实就是一个闭包函数。

然后，再来看一下，在f1上增加@w1，那这是什么意思呢？当python解释器执行到这句话的时候，会去调用w1函数，同时将被装饰的函数名作为参数传入(此时为f1)，根据闭包一文分析，在执行w1函数的时候，此时直接把inner函数返回了，同时把它赋值给f1，此时的f1已经不是未加装饰时的f1了，而是指向了w1.inner函数地址。相当于f1=w1(f1)

接下来，在调用f1()的时候，其实调用的是w1.inner函数，那么此时就会先执行权限验证，然后再调用原来的f1()，该处的f1就是通过装饰传进来的参数f1。

这样下来，就完成了对f1的装饰，实现了权限验证。

装饰器知识点

执行时机

了解了装饰器的原理后，那么它的执行时机是什么样呢，接下来就来看一下。 
国际惯例，先上代码

def w1(fun):
    print('...装饰器开始装饰...')
    def inner():
        print('...验证权限...')
        fun()
    return inner
@w1
def test():
    print('test')
test()

输出结果为

...装饰器开始装饰...
...验证权限...
test

由此可以发现，当python解释器执行到@w1时，就开始进行装饰了，相当于执行了如下代码：

test = w1(test)

两个装饰器执行流程和装饰结果

当有两个或两个以上装饰器装饰一个函数时，那么执行流程和装饰结果是什么样的呢？同样，还是以代码来说明问题。

def makeBold(fun):
    print('----a----')
    def inner():
        print('----1----')
        return '<b>' + fun() + '</b>'
    return inner
def makeItalic(fun):
    print('----b----')
    def inner():
        print('----2----')
        return '<i>' + fun() + '</i>'
    return inner
@makeBold
@makeItalic
def test():
    print('----c----')
    print('----3----')
    return 'hello python decorator'
ret = test()
print(ret)

输出结果：

----b----
----a----
----1----
----2----
----c----
----3----
<b><i>hello python decorator</i></b>

可以发现，先用第二个装饰器(makeItalic)进行装饰，接着再用第一个装饰器(makeBold)进行装饰，而在调用过程中，先执行第一个装饰器(makeBold)，接着再执行第二个装饰器(makeItalic)。

为什么呢，分两步来分析一下。

1、装饰时机 通过上面装饰时机的介绍，我们可以知道，在执行到@makeBold的时候，需要对下面的函数进行装饰，此时解释器继续往下走，发现并不是一个函数名，而又是一个装饰器，这时候，@makeBold装饰器暂停执行，而接着执行接下来的装饰器@makeItalic，接着把test函数名传入装饰器函数，从而打印’b’，在makeItalic装饰完后，此时的test指向makeItalic的inner函数地址，这时候有返回来执行@makeBold，接着把新test传入makeBold装饰器函数中，因此打印了’a’。
2、在调用test函数的时候，根据上述分析，此时test指向makeBold.inner函数，因此会先打印‘1‘，接下来，在调用fun()的时候，其实是调用的makeItalic.inner()函数，所以打印‘2‘，在makeItalic.inner中，调用的fun其实才是我们最原声的test函数，所以打印原test函数中的‘c‘，‘3‘，所以在一层层调完之后，打印的结果为<b><i>hello python decorator</i></b> 。

对无参函数进行装饰

上面例子中的f1 f2都是对无参函数的装饰，不再单独举例

对有参数函数进行装饰

在使用中，有的函数可能会带有参数，那么这种如何处理呢？ 
代码优先：

def w_say(fun):
    """
    如果原函数有参数，那闭包函数必须保持参数个数一致，并且将参数传递给原方法
    """
    def inner(name):
        """
        如果被装饰的函数有行参，那么闭包函数必须有参数
        :param name:
        :return:
        """
        print('say inner called')
        fun(name)
    return inner
@w_say
def hello(name):
    print('hello ' + name)
hello('wangcai')

输出结果为：

say inner called
hello wangcai

具体说明代码注释已经有了，就不再单独说明了。 
此时，也许你就会问了，那是一个参数的，如果多个或者不定长参数呢，该如何处理呢？看看下面的代码你就秒懂了。

def w_add(func):
    def inner(*args, **kwargs):
        print('add inner called')
        func(*args, **kwargs)
    return inner
@w_add
def add(a, b):
    print('%d + %d = %d' % (a, b, a + b))
@w_add
def add2(a, b, c):
    print('%d + %d + %d = %d' % (a, b, c, a + b + c))
add(2, 4)
add2(2, 4, 6)

输出结果为：

add inner called
2 + 4 = 6
add inner called
2 + 4 + 6 = 12

利用python的可变参数轻松实现装饰带参数的函数。

对带有返回值的函数进行装饰

下面对有返回值的函数进行装饰，按照之前的写法，代码是这样的

def w_test(func):
    def inner():
        print('w_test inner called start')
        func()
        print('w_test inner called end')
    return inner
@w_test
def test():
    print('this is test fun')
    return 'hello'
ret = test()
print('ret value is %s' % ret)

输出结果为：

w_test inner called start
this is test fun
w_test inner called end
ret value is None

可以发现，此时，并没有输出test函数的‘hello’,而是None，那是为什么呢，可以发现，在inner函数中对test进行了调用，但是没有接受不了返回值，也没有进行返回，那么默认就是None了，知道了原因，那么来修改一下代码：

def w_test(func):
    def inner():
        print('w_test inner called start')
        str = func()
        print('w_test inner called end')
        return str
    return inner
@w_test
def test():
    print('this is test fun')
    return 'hello'
ret = test()
print('ret value is %s' % ret)

输出结果：

w_test inner called start
this is test fun
w_test inner called end
ret value is hello

这样就达到预期，完成对带返回值参数的函数进行装饰。

带参数的装饰器

介绍了对带参数的函数和有返回值的函数进行装饰，那么有没有带参数的装饰器呢，如果有的话，又有什么用呢？ 
答案肯定是有的，接下来通过代码来看一下吧。

def func_args(pre='xiaoqiang'):
    def w_test_log(func):
        def inner():
            print('...记录日志...visitor is %s' % pre)
            func()
        return inner
    return w_test_log
# 带有参数的装饰器能够起到在运行时，有不同的功能
# 先执行func_args('wangcai')，返回w_test_log函数的引用
# @w_test_log
# 使用@w_test_log对test_log进行装饰
@func_args('wangcai')
def test_log():
    print('this is test log')
test_log()

输出结果为：

...记录日志...visitor is wangcai
this is test log

简单理解，带参数的装饰器就是在原闭包的基础上又加了一层闭包，通过外层函数func_args的返回值w_test_log就看出来了，具体执行流程在注释里已经说明了。
好处就是可以在运行时，针对不同的参数做不同的应用功能处理。

通用装饰器
介绍了这么多，在实际应用中，如果针对没个类别的函数都要写一个装饰器的话，估计就累死了，那么有没有通用万能装饰器呢，答案肯定是有的，废话不多说，直接上代码。

def w_test(func):
    def inner(*args, **kwargs):
        ret = func(*args, **kwargs)
        return ret
    return inner
@w_test
def test():
    print('test called')
@w_test
def test1():
    print('test1 called')
    return 'python'
@w_test
def test2(a):
    print('test2 called and value is %d ' % a)
test()
test1()
test2(9)

输出结果为：

test called
test1 called
test2 called and value is 9 

把上面几种示例结合起来，就完成了通用装饰器的功能，原理都同上，就不过多废话了。

类装饰器

装饰器函数其实是一个接口约束，它必须接受一个callable对象作为参数，然后返回一个callable对象。 
在python中，一般callable对象都是函数，但是也有例外。比如只要某个对象重写了call方法，那么这个对象就是callable的。

当创建一个对象后，直接去执行这个对象，那么是会抛出异常的，因为他不是callable，无法直接执行，但进行修改后，就可以直接执行调用了，如下

class Test(object):
    def __call__(self, *args, **kwargs):
        print('call called')
t = Test()
print(t())

输出为：

call called

下面，引入正题，看一下如何用类装饰函数。

class Test(object):
    def __init__(self, func):
        print('test init')
        print('func name is %s ' % func.__name__)
        self.__func = func
    def __call__(self, *args, **kwargs):
        print('装饰器中的功能')
        self.__func()
@Test
def test():
    print('this is test func')
test()

输出结果为：

test init
func name is test 
装饰器中的功能
this is test func

和之前的原理一样，当python解释器执行到到@Test时，会把当前test函数作为参数传入Test对象，调用init方法，同时将test函数指向创建的Test对象，那么在接下来执行test()的时候，其实就是直接对创建的对象进行调用，执行其call方法。

在了解wraps修饰器之前，我们首先要了解partial和update_wrapper这两个函数，因为在wraps的代码中，用到了这两个函数。

partial

首先说partial函数，在官方文档的描述中，这个函数的声明如下：functools.partial(func, *args, **keywords)。它的作用就是返回一个partial对象，当这个partial对象被调用的时候，就像通过func(*args, **kwargs)的形式来调用func函数一样。如果有额外的 位置参数(args) 或者 关键字参数(*kwargs) 被传给了这个partial对象，那它们也都会被传递给func函数，如果一个参数被多次传入，那么后面的值会覆盖前面的值。

个人感觉这个函数很像C++中的bind函数，都是把某个函数的某个参数固定，从而构造出一个新的函数来。比如下面这个例子：

from functools import partial
def add(x, y):
    return x+y
# 这里创造了一个新的函数add2，只接受一个整型参数，然后将这个参数统一加上2
add2 = partial(add, y=2)
add2(3)  # 这里将会输出5

这个函数是使用C而不是Python实现的，但是官方文档中给出了Python实现的代码，如下所示，大家可以进行参考：

def partial(func, *args, **keywords):
    def newfunc(*fargs, **fkeywords):
        newkeywords = keywords.copy()
        newkeywords.update(fkeywords)
        return func(*args, *fargs, **newkeywords)
    newfunc.func = func
    newfunc.args = args
    newfunc.keywords = keywords
    return newfunc

update_wrapper

接下来，我们再来聊一聊update_wrapper这个函数，顾名思义，这个函数就是用来更新修饰器函数的，具体更新些什么呢，我们可以直接把它的源码搬过来看一下：

WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__qualname__', '__doc__',
                       '__annotations__')
WRAPPER_UPDATES = ('__dict__',)
def update_wrapper(wrapper,
                   wrapped,
                   assigned = WRAPPER_ASSIGNMENTS,
                   updated = WRAPPER_UPDATES):
    for attr in assigned:
        try:
            value = getattr(wrapped, attr)
        except AttributeError:
            pass
        else:
            setattr(wrapper, attr, value)
    for attr in updated:
        getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
    wrapper.__wrapped__ = wrapped
    return wrapper

大家可以发现，这个函数的作用就是从 被修饰的函数(wrapped) 中取出一些属性值来，赋值给 修饰器函数(wrapper) 。为什么要这么做呢，我们看下面这个例子。

自定义修饰器v1

首先我们写个自定义的修饰器，没有任何的功能，仅有文档字符串，如下所示：

def wrapper(f):
    def wrapper_function(*args, **kwargs):
        """这个是修饰函数"""
        return f(*args, **kwargs)
    return wrapper_function
@wrapper
def wrapped():
    """这个是被修饰的函数"""
    print('wrapped')
print(wrapped.__doc__)  # 输出`这个是修饰函数`
print(wrapped.__name__)  # 输出`wrapper_function`

从上面的例子我们可以看到，我想要获取wrapped这个被修饰函数的文档字符串，但是却获取成了wrapper_function的文档字符串，wrapped函数的名字也变成了wrapper_function函数的名字。这是因为给wrapped添加上@wrapper修饰器相当于执行了一句wrapped = wrapper(wrapped)，执行完这条语句之后，wrapped函数就变成了wrapper_function函数。遇到这种情况该怎么办呢，首先我们可以手动地在wrapper函数中更改wrapper_function的__doc__和__name__属性，但聪明的你肯定也想到了，我们可以直接用update_wrapper函数来实现这个功能。

自定义修饰器v2

我们对上面定义的修饰器稍作修改，添加了一句update_wrapper(wrapper_function, f)。

from functools import update_wrapper
def wrapper(f):
    def wrapper_function(*args, **kwargs):
        """这个是修饰函数"""
        return f(*args, **kwargs)
    update_wrapper(wrapper_function, f)  # <<  添加了这条语句
    return wrapper_function
@wrapper
def wrapped():
    """这个是被修饰的函数"""
    print('wrapped')
print(wrapped.__doc__)  # 输出`这个是被修饰的函数`
print(wrapped.__name__)  # 输出`wrapped`

此时我们可以发现，__doc__和__name__属性已经能够按我们预想的那样显示了，除此之外，update_wrapper函数也对__module__和__dict__等属性进行了更改和更新。

wraps修饰器

OK，至此，我们已经了解了partial和update_wrapper这两个函数的功能，接下来我们翻出wraps修饰器的源码：

WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__qualname__', '__doc__',
                       '__annotations__')
WRAPPER_UPDATES = ('__dict__',)
def wraps(wrapped,
          assigned = WRAPPER_ASSIGNMENTS,
          updated = WRAPPER_UPDATES):
    return partial(update_wrapper, wrapped=wrapped,
                   assigned=assigned, updated=updated)

没错，就是这么的简单，只有这么一句，我们可以看出，wraps函数其实就是一个修饰器版的update_wrapper函数，它的功能和update_wrapper是一模一样的。我们可以修改我们上面的自定义修饰器的例子，做出一个更方便阅读的版本。

自定义修饰器v3

from functools import wraps
def wrapper(f):
    @wraps(f)
    def wrapper_function(*args, **kwargs):
        """这个是修饰函数"""
        return f(*args, **kwargs)
    return wrapper_function
@wrapper
def wrapped():
    """这个是被修饰的函数
    """
    print('wrapped')
print(wrapped.__doc__)  # 输出`这个是被修饰的函数`
print(wrapped.__name__)  # 输出`wrapped`

至此，我想大家应该明白wraps这个修饰器的作用了吧，就是将 被修饰的函数(wrapped) 的一些属性值赋值给 修饰器函数(wrapper) ，最终让属性的显示更符合我们的直觉。

参考链接

https://segmentfault.com/a/1190000009398663

https://blog.csdn.net/u010358168/article/details/77773199

以上是 python修饰器（装饰器）以及wraps 的全部内容， 来源链接： utcz.com/z/387166.html