Python 装饰器执行顺序迷思

6

探究多个装饰器执行顺序

装饰器是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 里的 funcf ,最后返回的是 f 调用的值,所以在最外面看起来就像直接再调用 f 一样。

疑问的解释

当理清上面两方面概念时,就可以清楚地看清最原始的例子中发生了什么。
当解释器执行下面这段代码时,实际上按照从下到上的顺序已经依次调用了 decorator_adecorator_b ,这是会输出对应的 Get in decorator_aGet in decorator_b 。 这时候 f 已经相当于 decorator_b 里的 inner_b 。但因为 f 并没有被调用,所以 inner_b 并没有调用,依次类推 inner_b 内部的 inner_a 也没有调用,所以 Get in inner_aGet 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

参考资料

  • 我的大脑和好奇心


如果觉得我的文章对你有用,请随意赞赏

你可能感兴趣的

DZL1943 · 2017年02月19日

总结一下就是,装饰顺序按靠近函数顺序执行,调用时由外而内,执行顺序和装饰顺序相反。

+2 回复

晨曦之光 · 5月9日

谢谢,讲的很好。

回复

ipigzhu · 7月17日

上面说的太复杂了,完全不知所云~~~~

只要记住就按实际的业务逻辑写

@登录没有判断
@权限判断
def fun():pass

你把顺序倒了肯定不对~~~

回复

jammywwh · 8月3日

def decorator_b(func):

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

def decorator_a(func):

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

@decorator_b
@decorator_a
def f(x):

print ('Get in f')           # 5
return x * 2

f # 分步骤来,这里很重要。这里会先后打印出Get in decorator_a 和Get in decorator_b

1、输入函数名f,意味着将函数f作为参数,传入装饰器a和b。 1.5、但是并未调用函数f(x),也就是f(x)函数并不会执行,因为没有传入参数。重点也就在这,函数和函数调用是不一样的。 2、f首先传入装饰器a,也就是装饰器a函数获得参数被调用,那么就执行打印,并同时返回函数inner_a。 2.5、当然,此时函数inner_a也没有被调用。因为同样没有参数传入。 3、inner_a传入装饰器b,也就是装饰器b函数获得参数被调用,那么也执行打印,并同时返回函数inner_b。 4、现在就是返回函数inner_b>inner_a>f

f(1) # 然后输入这段代码,会先后打印出Get in inner_b和Get in inner_a,以及Get in f

5、此时函数f获得参数1,即函数被调用,由于上面步骤4中最后返回函数是inner_b,那么最先调用最外层的函数,print先行,也就是先打印Get in inner_b,再返回inner_a函数; 6、进而调用inner_a函数,print先行,也就是先打印Get in inner_a,再返回f(1)函数; 7、最后调用f(1)函数,print先行,也就是先打印Get in f,再返回2。 8、这样顺序就理顺了,哈哈,我这么理解的。

回复

youyiqin · 9月17日

整个流程:

  • f(1)执行,装饰器decorator_b启动
  • print 'Get in decorator_a' 打印,并且return一个函数inner_a
  • 接着,这个函数inner_a被decorator_b装饰掉,于是
  • print 'Get in decorator_b' 打印,再次return一个函数inner_b
  • 因此,绕回来理解整个流程,f(1)调用了inner_b,打印了Get in inner_b
  • 再执行了函数inner_a,打印了Get in inner_a
  • 再执行了f函数,打印了Get in f

回复

0

我的理解,感谢作者分析

youyiqin · 9月17日
learn者 · 12月2日

装饰器由下到上依次立马执行,之后我们调用的f已经是被装饰器执行了之后的f了,此时是由上到下返回去依次调用。整个过程有点像先上楼梯(装饰过程),再下楼梯(调用函数)

回复

载入中...