补充 ： 语法糖案例调用关系详解

装饰器案例

• 代码

def dec_a(func):
    print('111')

    def wrapper(*args, **kw):
        print('222')
        func(*args, **kw)
        print('333')

    return wrapper


def dec_b(func):
    print('aaa')

    def wrapper(*args, **kw):
        print('bbb')
        func(*args, **kw)
        print('ccc')

    return wrapper


@dec_a  
@dec_b 
def test():
    print('test')


test()

• 返回值结果

aaa
111
222
bbb
test
ccc
333

分析一：单层语法糖引入

• 首先我们要看最后的调用方法，要明白他的调用关系

@dec_a  
@dec_b 
def test():
    print('test')

• 我们看这行代码

• 我们都知道语法糖的本质就是替代了我们原本的返回内部函数调用内存地址的这一步

  • 即语法糖语法

    @dec_b 
    def test():
        print('test')
    test()
    

  • 正常语法

    test = dec_b(test)
    def test():
        print('test')
    test()
    

• 我们明白单层语法糖，其实多层语法糖也就变得简单了

• 我们只需要明白，每一层返回的语法糖，返回的是什么即可明白调用关系

单层语法糖的调用关系分析

• 代码

def dec_b(func):
    print('aaa')

    def wrapper(*args, **kw):
        print('bbb')
        func(*args, **kw)
        print('ccc')

    return wrapper


test = dec_b(test)
def test():
    print('test')
test()

• 返回值结果

aaa
bbb
test
ccc

• 分析
  • 调用 dec_b(test) 传进去 外部 test 的内存地址 拿到 返回的内存空间地址 赋给变量 test（返回的内存空间地址）
• 调用
  • 下一步的前提是已经过了一遍 装饰器 了 ，那也就是走完一遍装饰器内的函数了。也就是拿到了一个打印的 aaa
  • 调用 test（返回的内存空间地址） 得到 bbb
  • 遇到 func 执行外部的 test函数 得到 test
  • 执行剩下的函数 得到 ccc

分析二：多层语法糖调用关系

• 我们分析我们下面的调用关系的这行代码

@dec_a  
@dec_b 
def test():
    print('test')

• @dec_b

  • 我们先按正常语法分析

    dec_b返回的内存空间地址 = dec_b(test)
    

  • 本质上就是调用 dec_b 这个函数内部的调用函数的内存空间地址

• @dec_a

  • 我们也按正常语法分析

    dec_a返回的内存空间地址 = dec_a(参数？)
    

  • 到这里我们发现我们按照正常语法糖来说，是需要传入一个调用函数名进去，返回给我们一个内存空间地址的

  • 在这里如果没有第一层的 @dec_b 那一定是会报错的

  • 但是正因为有了第一层语法糖的调用，我们返回了一个待定的内存空间地址（在这步双层语法糖叠加我们没办法给我们返回的内存空间地址赋变量名，默认使用返回的变量名即 @dec_b 的 wrapper）

  • 那我们就将这个内存地址传回去

  • 最后我们需要一个变量名来接受最后的内存空间地址，没有则默认用调用函数的函数名即 test

分析三：多层语法糖的调用顺序

• 经过上面的分析我们已经知道了我们的多层语法糖的调用关系

  • 即

    @dec_a  # test（dec_a返回的wrapper）= dec_a(wrapper)
    @dec_b  # dec_b返回的wrapper = dec_b(text)
    def test():
        print('test')
    

• 那执行顺序，我们最后返回的是 test（dec_a的wrapper）

• 函数调用要从最后返回的地址往前返回（前提是我们要拿到内存空间地址）

  • 首先我们先执行第一层语法糖 @dec_b

  • 我们最先调用 dec_b(text) 拿到 dec_b返回的wrapper

    • 进入到 dec_b(text) 时，我们就打印了内部的 aaa

  • 接着我们调用第二层语法糖 @dec_a

  • 我们将 dec_b的wrapper 作为参数传进去，就有了 dec_a(dec_b返回的wrapper)

    • 进入到 dec_a(dec_b返回的wrapper) 就执行了内部的 111
    • 同时接收到返回的 dec_a的wrapper

  • 最后我们用我们默认的函数名来接受这个内存地址，也就是 test = dec_a(dec_b返回的wrapper)

分析四：多层语法糖的执行顺序

• 通过上面的分析我们现在的逻辑是

  • test = dec_a(dec_b返回的的wrapper)
  • dec_b返回的wrapper = dec_b(text)

• 执行test(其实这里的内存地址并不是原本的test，是已经被语法糖赋予新的内存地址的命名了)

  • 去调用 dec_a(wrapper) 得到 222
    • 遇到 dec_a内的 func()
      • 这时的 func 传进来接受到的其实是 dec_b的wrapper内存地址
  • 于是执行 dec_b 的 wrapper 得到 bbb
    • 此时我们又遇到了 dec_b 内部的 func()
      • 这时传进来的 func 传进来的接收到的其实是外部的 test的内存地址
  • 于是执行 test 得到 test
  • 最后我们要结束我们的调用关系
    • 这里其实是最绕的，不明白为什么 又 打印了 ccc 和 333

分析四：最后返回值的分析

• 当我们将我们的执行函数都执行完了以后，我们最后会发现，我们还打印了最后的返回值

  • ccc 和 333

• 我们反过来看，我们的执行顺序

  • test = dec_a(dec_b返回的的wrapper)
  • 执行 test 得到 222
    • 遇到 func 去执行 func函数
      • 这里我们注意，我们底下还有一个 print函数
      • 当我们调用完我们的 func函数 的时候，我们要走我们剩下的代码，这也就是 333的由来
  • 同理 ccc 也是这么来的

• 那为什么是先打印的 ccc 后 打印的 333 呢？

  • 这是因为我们在走到 dec_a 里的 func 也就是 dec_b 的wrapper
  • 转到了 dec_b 里的 func 也就是 外部的test
    • 结束 test 得到 外部的打印结果 test
    • 结束 dec_b 的 func 继续往下走将 func 执行完 得到 ccc
    • 结束 dec_b 回到刚才没结束的 dec_a 里的 func
    • 结束 dec_a 的 func 继续往下走 得到了最后的 333
    • 没有可调用函数关系，结束程序

• 返回值结果

aaa # 语法糖第一层 @dec_b的结果
111	# 语法糖第二层 @dec_a的结果
222 # dec_b 返回的 wrapper 函数调用结果（dec_a）内部的 wrapper 函数的执行结果
bbb # dec_a 返回的 wrapper 函数调用结果（dec_b）内部的 wrapper 函数的执行结果
test # 执行到 dec_a 遇到的 func 调用外部 test 函数执行的结果
ccc # 结束dec_b 内的 wrapper 函数调用后执行的结果
333 # 结束dec_a 内的 wrapper 函数调用后执行的结果