Python 装饰器执行顺序迷思

探究多个装饰器执行顺序

装饰器是Python用于封装函数或代码的工具，网上能够搜到不少文章能够学习，我在这里要讨论的是多个装饰器执行顺序的一个迷思。

疑问

大部分涉及多个装饰器装饰的函数调用顺序时都会说明它们是自上而下的，好比下面这个例子:

def decorator_a(func):
    print 'Get in decorator_a'
    def inner_a(*args, **kwargs):
        print 'Get in inner_a'
        return func(*args, **kwargs)
    return inner_a

def decorator_b(func):
    print 'Get in decorator_b'
    def inner_b(*args, **kwargs):
        print 'Get in inner_b'
        return func(*args, **kwargs)
    return inner_b

@decorator_b
@decorator_a
def f(x):
    print 'Get in f'
    return x * 2

f(1)

上面代码先定义里两个函数: decotator_a, decotator_b, 这两个函数实现的功能是，接收一个函数做为参数而后返回建立的另外一个函数，在这个建立的函数里调用接收的函数(文字比代码绕人)。最后定义的函数 f 采用上面定义的 decotator_a, decotator_b 做为装饰函数。在当咱们以1为参数调用装饰后的函数 f 后， decotator_a, decotator_b 的顺序是什么呢（这里为了表示函数执行的前后顺序，采用打印输出的方式来查看函数的执行顺序）？

若是不假思索根据自下而上的原则来判断地话，先执行 decorator_a 再执行 decorator_b , 那么会先输出 Get in decotator_a, Get in inner_a 再输出 Get in decotator_b , Get in inner_b 。然而事实并不是如此。

实际上运行的结果以下:

Get in decorator_a
Get in decorator_b
Get in inner_b
Get in inner_a
Get in f

函数和函数调用的区别

为何是先执行 inner_b 再执行 inner_a 呢？为了完全看清上面的问题，得先分清两个概念:函数和函数调用。上面的例子中 f 称之为函数， f(1) 称之为函数调用，后者是对前者传入参数进行求值的结果。在Python中函数也是一个对象，因此 f 是指代一个函数对象，它的值是函数自己， f(1) 是对函数的调用，它的值是调用的结果，这里的定义下 f(1) 的值2。一样地，拿上面的 decorator_a 函数来讲，它返回的是个函数对象 inner_a ，这个函数对象是它内部定义的。在 inner_a 里调用了函数 func ，将 func 的调用结果做为值返回。

装饰器函数在被装饰函数定义好后当即执行

其次得理清的一个问题是，当装饰器装饰一个函数时，究竟发生了什么。如今简化咱们的例子，假设是下面这样的:

def decorator_a(func):
    print 'Get in decorator_a'
    def inner_a(*args, **kwargs):
        print 'Get in inner_a'
        return func(*args, **kwargs)
    return inner_a

@decorator_a
def f(x):
    print 'Get in f'
    return x * 2

正如不少介绍装饰器的文章里所说:

@decorator_a
def f(x):
    print 'Get in f'
    return x * 2

# 至关于
def f(x):
    print 'Get in f'
    return x * 2

f = decorator_a(f)

因此，当解释器执行这段代码时， decorator_a 已经调用了，它以函数 f 做为参数， 返回它内部生成的一个函数，因此此后 f 指代的是 decorater_a 里面返回的 inner_a 。因此当之后调用 f 时，实际上至关于调用 inner_a ,传给 f 的参数会传给 inner_a , 在调用 inner_a 时会把接收到的参数传给 inner_a 里的 func 即 f ,最后返回的是 f 调用的值，因此在最外面看起来就像直接再调用 f 同样。

疑问的解释

当理清上面两方面概念时，就能够清楚地看清最原始的例子中发生了什么。
当解释器执行下面这段代码时，实际上按照从下到上的顺序已经依次调用了 decorator_a 和 decorator_b ，这是会输出对应的 Get in decorator_a 和 Get in decorator_b 。 这时候 f 已经至关于 decorator_b 里的 inner_b 。但由于 f 并无被调用，因此 inner_b 并无调用，依次类推 inner_b 内部的 inner_a 也没有调用，因此 Get in inner_a 和 Get in inner_b 也不会被输出。

@decorator_b
@decorator_a
def f(x):
    print 'Get in f'
    return x * 2

而后最后一行当咱们对 f 传入参数1进行调用时， inner_b 被调用了，它会先打印 Get in inner_b ，而后在 inner_b 内部调用了 inner_a 因此会再打印 Get in inner_a, 而后再 inner_a 内部调用的原来的 f, 而且将结果做为最终的返回。这时候你该知道为何输出结果会是那样，以及对装饰器执行顺序实际发生了什么有必定了解了吧。

当咱们在上面的例子最后一行 f 的调用去掉，放到repl里演示，也能很天然地看出顺序问题:

➜  test git:(master) ✗ python
Python 2.7.11 (default, Jan 22 2016, 08:29:18)
[GCC 4.2.1 Compatible Apple LLVM 7.0.2 (clang-700.1.81)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import test13
Get in decorator_a
Get in decorator_b
>>> test13.f(1)
Get in inner_b
Get in inner_a
Get in f
2
>>> test13.f(2)
Get in inner_b
Get in inner_a
Get in f
4
>>>

在实际应用的场景中，当咱们采用上面的方式写了两个装饰方法好比先验证有没有登陆 @login_required ， 再验证权限够不够时 @permision_allowed 时，咱们采用下面的顺序来装饰函数:

@login_required
@permision_allowed
def f()
  # Do something
  return

参考资料

• 个人大脑和好奇心