5 分钟全面掌握 Python 装饰器

♚

做者：吉星高照， 网易游戏资深开发工程师，主要工做方向为网易游戏 CDN 自动化平台的设计和开发，脑洞比较奇特，喜欢在各类非主流的领域研究制做各类不走寻常路的东西。

！

Python的装饰器是面试的常客，由于其写法复杂多变，常常忘记什么地方应该写哪一种参数，新手学习起来也常常一头雾水，不怕不怕，看了这一篇你对装饰器的各类用法就全明白了。废话很少说，直接进入主题！

不带参数的函数，不带参数的装饰器

咱们先来写一个简单的装饰器，实现将函数运行先后的状况记录下来。

def dec1(func):
    print(func)
    def _wrap():
        print('before run')
        r = func()
        print('after run')
        return r
    return _wrap

@dec1
def f1():
    print('call f1')

上面只是定义了两个函数，运行后发现居然有输出：

<function f1 at 0x7fa1585f8488>

仔细看看，原来是第一个 print 语句的输出。这说明装饰的函数尚未实际运行的时候，装饰器就运行过了，由于 @dec1 至关于单独的一个语句：

dec1(f1)

那咱们来正式运行一下 f1 吧：

f1(1)

输出以下确实达到了预期的效果：

before run
call f1
after run

不带参数的函数，带空参数的装饰器

后面咱们还想要给装饰器加上参数呢，先试试用这个方式调用会发生什么状况：

@dec1()

输出了错误：

Traceback (most recent call last)
<ipython-input-268-01cf93cf6907> in <module>
      8     return _wrap
      9 
---> 10 @dec1()
     11 def f1():
     12     print('call f1')

TypeError: dec1() missing 1 required positional argument: 'func'

它说 dec1 须要接受 func 这个参数才行，那咱们改改，做为 f2 函数吧：

def dec2():
    def _wrap(func):
        print(func)
        print('before run')
        return func
    return _wrap

@dec2()
def f2():
    print('call f2')

f2()

这下能够了：

<function f2 at 0x7fa1585af2f0>
before run
call f2

但是这个结构和原来有点不一样了，并且， after run 要写在哪里呢？很愁人地又改了一版，把它叫作 f2x 吧，对比 dec1 ，又多了一层函数 dec2x_w ，开始有点晕：

def dec2x_w():
    def dec2x(func):
        print(func)
        def _wrap():
            print('before run')
            r = func()
            print('after run')
            return r
        return _wrap
    return dec2x

@dec2x_w()
def f2x():
    print('call f2x')

f2x()

运行一下看看，确实是想要的：

<function f2x at 0x7fa1585af950>
before run
call f2x
after run

后面咱们就不加 before/after run 了。

带参数的函数，不带参数的装饰器

函数 f2x 想要接受参数呢？咱们把它叫作 a 吧，比较简单，不就是 _wrap 的参数吗，加上就是了，并且又回到了只有两层函数就能够实现了：

def dec3(func):
    print(func)
    def _wrap(param):
        print(param)
        r = func(param)
        return r
    return _wrap

@dec3
def f3(a):
    print('call f3', a)

f3(1)

很争气地输出告终果：

<function f3 at 0x7fa158719620>
1
call f3 1

带参数的函数，带参数的装饰器

下面咱们实现一个装饰器，传入一个整数，和函数传入的参数作个加法：

def dec4_w(d_param):
    print(d_param)
    def dec4(func):
        print(func)
        def _wrap(param):
            print(param)
            r = func(param + d_param)
            return r
        return _wrap
    return dec4

@dec4_w(2)
def f4(a):
    print('call f4', a)

f4(1)

输出 1+2=3 ：

2
<function f4 at 0x7fa1585af598>
1
call f4 3

从调用的装饰器往里看，注意这三层函数的形参，第一层是装饰器的参数，第二层是函数，第三层是函数的参数，颇有规律的排列，先记一下这个规律（要考的）。带两个参数的也是同样的，接着写就能够了：

def dec5_w(d_param_1, d_param_2):
    print(d_param_1, d_param_2)
    def dec5(func):
        print(func)
        def _wrap(param):
            print(param)
            r = func(param + d_param_1 + d_param_2)
            return r
        return _wrap
    return dec5

@dec5_w(2, 3)
def f5(a):
    print('call f5', a)

f5(1)

输出 1+2+3=6 ：

2 3
<function f5 at 0x7fa1586237b8>
1
call f5 6

若是用不定数量的位置参数，就用 *args 做为形参吧：

def dec6_w(*args):
    d_param_1, d_param_2, = args
    print(d_param_1, d_param_2)
    def dec6(func):
        print(func)
        def _wrap(*args):
            param = args[0]
            print(param)
            r = func(param + d_param_1 + d_param_2)
            return r
        return _wrap
    return dec6

@dec6_w(2, 3)
def f6(a):
    print('call f6', a)

f6(1)
print(f6.__name__)

顺便输出了一下 f6 的函数名：

2 3
<function f6 at 0x7fa1586236a8>
1
call f6 6
_wrap

咦！怎么肥四！！！ f6 怎么是里面那个 _wrap 的名字呢？不怕不怕， functools 提供了一个 wraps 装饰器专治各类不服（在装饰器里面放上另外一个装饰器）：

from functools import wraps

def dec7_w(*args):
    d_param_1, d_param_2, = args
    print(d_param_1, d_param_2)
    def dec7(func):
        print(func)
        @wraps(func)
        def _wrap(*args):
            param = args[0]
            print(param)
            r = func(param + d_param_1 + d_param_2)
            return r
        return _wrap
    return dec7

@dec7_w(2, 3)
def f7(a):
    print('call f7', a)

f7(1)
print(f7.__name__)

这下正常输出 f7 了：

2 3
<function f7 at 0x7fa1585f8510>
1
call f7 6
f7

装饰器类（带参数的函数，带参数的装饰器）

用函数作装饰器局限性太多了，用相同的调用方法，把函数 f7 改为类怎么样？emmm…改造工程有点大，直接看当作品吧：

from functools import wraps

class dec8_c:
    def __init__(self, *args):
        self.d_param_1, self.d_param_2, = args
        print(self.d_param_1, self.d_param_2)
    def  __call__(self, func):
        print(func)
        @wraps(func)
        def _wrap(param):
            print(param)
            r = func(param + self.d_param_1 + self.d_param_2)
            return r
        return _wrap

@dec8_c(2, 3)
def f8(a):
    print('call f8', a)

f8(1)
print(f8.__name__)

看看是否是实现了同样的效果：

2 3
<function f8 at 0x7fa1585f8048>
1
call f8 6
f8

虽然使用了 __call__ ，但这里的 __init__ 不能省略（由于它须要知道参数个数），不然会出现这个错误：

Traceback (most recent call last)
<ipython-input-276-1634a47057a2> in <module>
     14         return dec8
     15 
---> 16 @dec8_c(2, 3)
     17 def f8(a):
     18     print('call f8', a)

TypeError: dec8_c() takes no arguments

同时还能够发现， __call__ 只须要两层函数了，去掉了第二层，直接把 _wrap 的函数体往上提了一层！

装饰器类（带参数的函数，不带参数的装饰器）

大概是吃饱了撑着，又想要实现一开始那个不带参数的装饰器了，那就继续敲敲打打一番看看：

class dec9_c:
    def  __init__(self, func):
        print(func)
        self.func = func
        self.__name__ = func.__name__
    def  __call__(self, param):
        print(param)
        func = self.func
        r = func(param)
        return r

@dec9_c
def f9(a):
    print('call f9', a)

f9(1)
print(f9.__name__)

赶快运行看看：

<function f9 at 0x7fa1585f8730>
1
call f9 1
f9

咦， f9 的函数名能够直接打印，这下都不用 @wraps 了呢！呃，再仔细看看，这写法好像有些不同啊：

• dec8_c 的 init 带的是装饰器的参数，但是 dec9_c 带的是装饰器函数本身！
• 因此实际调用的函数名也能够在 init 中传给它了哦！
• 并且 call 函数也简洁了不少，看来有没有参数真的有很大区别呢！

这里先作个总结，装饰器使用函数名形式（不带括号）和使用函数调用形式（带括号和参数）在实现上是不一样的，由于前者是函数自己，然后者是从装饰器函数中返回的函数。这也是 f2 相比 f1 缺乏了记录 after run 的缘由，由于 dec1 直接调用了 f2 ，而 dec2 先运行获得函数，再把函数返回去调用 f2 。用装饰器类就能够解决这个问题，由于它是对 __call__ 的调用，只须要本身定义一下就能够了。

上面的 f9 要写两个函数，能不能写得和 f1 同样简洁？固然是能够的，使用 __new__ 大法：

from functools import wraps

class dec9x_c:
    def  __new__(self, func):
        print(func)
        @wraps(func)
        def dec9x(param):
            print(param)
            r = func(param)
            return r
        return dec9x

@dec9x_c
def f9x(a):
    print('call f9x', a)

f9x(1)
print(f9x.__name__)

这样就避开了函数调用，不用打call了（定义 __call__ 函数），快看它来了：

<function f9x at 0x7fa158623bf8>
1
call f9x 1
f9x