Python函数之语法糖

装饰器案例：

代码：

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()

• 正常语法：

@dec_b 
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_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(test)拿到dec_b返回的wrapper

    • 进入到dec_b(test)时，我们就打印了内部的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 函数调用后执行的结果