关于多个装饰器装饰一个函数执行顺序的问题

我们通过两个实例来解开我们的疑惑:

实例一:

def war1(func):
    def inner(*args, **kwargs):
        print("======war1 start=====")
        func(*args, **kwargs)
        print("======war1 end=====")
    return inner
def war2(func):
    def inner(*args,**kwargs):
        print("======war2 start=====")
        func(*args,**kwargs)
        print("======war2 end=====")
    return inner
@war1
@war2
def f():
    print("****self****")
f()

实际输出结果为:

======war1 start=====
======war2 start=====
****self****
======war2 end=====
======war1 end=====

好吧这个结果似乎有点出乎我们的意料:不是说好的谁近谁先来的嘛(我裤子都脱了,结果。。。)

我们自己臆想的结果:

======war2 start=====
======war2 end=====
======war1 start=====
======war1 end=====
****self****

那么首先我们知道我们为一个函数装饰其实就相当于:

f = war1(f)或者
f = war2(f)                ####这个时候f=inner,而不再是原来的函数。只是用户不知道而已。

那么问题来了:

当走到这一步的时候说明,两个inner函数已经执行了。

也就是他们发生在我们真正的调用之前,那么真正调用的时候才是我们按照我们的就近原则,也就是限制性war2中的代码,在执行war1中的代码。

实例二:

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)

实际执行结果为:

执行结果
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 一样。

那么对于实例一与实例二,还有一点不同的,哈哈哈,那就是被装饰函数的执行顺序,在两个实例中是不一样的,这是为什么呢?

这个就跟我们的装饰器没什么关系了:主要是因为inner函数的输出与函数的执行的一个先后顺序。

 

原文地址:https://www.cnblogs.com/zhangsanfeng/p/9135280.html

时间: 2024-10-09 16:39:57

关于多个装饰器装饰一个函数执行顺序的问题的相关文章

day14 带函数的装饰器、多个装饰器装饰一个函数

一.带参数的装饰器:------开关 __author__ = 'Administrator' F=True def outer(F): def wap(fun):#gg def inner(*args,**kwargs): if F: print("inner before") ret=fun(*args,**kwargs)#gg() print("inner after") else: ret=fun(*args,**kwargs) return ret ret

如何用python的装饰器定义一个像C++一样的强类型函数

Python作为一个动态的脚本语言,其函数在定义时是不需要指出参数的类型,也不需要指出函数是否有返回值.本文将介绍如何使用python的装饰器来定义一个像C++那样的强类型函数.接下去,先介绍python3中关于函数的定义. 0. python3中的函数定义 举个例子来说吧,比如如下的函数定义: 1 def fun(a:int, b=1, *c, d, e=2, **f) -> str: 2 pass 这里主要是说几点与python2中不同的点. 1)分号后面表示参数的annotation,这个

22_装饰器、带参数的装饰器、多个装饰器装饰一个函数

一.装饰器的执行流程 1 def wrapper(func): 2 def inner(*args,**kwargs): 3 ret = func(*args,**kwargs) 4 return ret 5 return inner 6 7 @wrapper #fun = wrapper(fun) 8 def fun(s): 9 print('666') 10 return s 11 12 fun('777') 13 print(fun('777')) 14 15 ''' 16 1.程序至上而

Python----多个装饰器装饰一个函数

#装饰器回顾: # def wrapper(f): #f= func1# def inner(*args,**kwargs):# print(333) #1. 333# ret=f(*args,**kwargs)# print(666)# return ret# return inner# @wrapper # func1=wrapper(func1)=inner# def func1(): # inner() 定义函数,将函数加载到内存中,但是不执行,等待被调用# print(111) #2.

带参数的装饰器,多个装饰器装饰一个函数,函数的有用信息。

带参数的装饰器.import time def timer_out(flag1): #falg1 = flag def timer(f): def inner(*args, **kwargs): if flag1: start_time = time.time() time.sleep(0.3) ret = f(*args, **kwargs) end_time = time.time() print('执行效率%s' % (end_time-start_time)) return ret el

Python全栈__函数的有用信息、带参数的装饰器、多个装饰器装饰一个函数

1.函数的有用信息 代码1: 1 def login(username, password): 2 """ 3 此函数需要用户名,密码两个参数,完成的是登录的功能. 4 :return: True 登录成功. False登录失败. 5 """ 6 print(login.__name__) 7 print(login.__doc__) 8 print('登录成功...') 9 return True 10 11 print(login.__nam

多个装饰器装饰一个函数

#!/usr/bin/env python # -*- coding:utf-8 -*- # 作者: Apollo # 邮箱: [email protected] # 博客: http://www.zgerji.online/ def wrapper1(func): # func = f def inner1(): print('wrapper1 ,before func') func() print('wrapper1 ,after func') return inner1 def wrapp

5.初识python装饰器 高阶函数+闭包+函数嵌套=装饰器

一.什么是装饰器? 实际上装饰器就是个函数,这个函数可以为其他函数提供附加的功能. 装饰器在给其他函数添加功能时,不会修改原函数的源代码,不会修改原函数的调用方式. 高阶函数+函数嵌套+闭包 = 装饰器 1.1什么是高阶函数? 1.1.1函数接收的参数,包涵一个函数名. 1.1.2 函数的返回值是一个函数名. 其实这两个条件都很好满足,下面就是一个高阶函数的例子. def test1(): print "hamasaki ayumi" def test2(func): return t

python 之装饰器(用装饰器给现有函数增加新功能)

#!/usr/bin/env python # -*- coding: utf-8 -*- """ Created on Mon Nov 14 01:01:29 2016 @author: toby """ #知识点:装饰器 ''' #一.小粒子: #要求1.假如产品经历要求在每个函数之上执行之前都添加一个验证的功能,当然这里只是模拟而已,别当真哈! #已写好的现有函数如下,有1000个函数 def func1():     print 'fun