第046讲：函数（VI）- 装饰器

小古比鱼

本节首先回顾了闭包的原理，而后通过两个函数作为参数传递给另一个函数来调用的例子引入了装饰器的概念——所谓装饰器，就是在不修改原来代码的前提下增加新功能，拿函数作为参数，调用装饰器函数，实则还是利用了闭包的特性。“@+装饰器”其实是一个语法糖，等价于“函数 = 装饰器(函数)”；前者写法简单，使用起来更方便！此外，多个装饰器可以用在同一个函数上，还可以通过函数的多层嵌套调用给装饰器传递参数。尽管看上去很复杂，背后的原理很简单。作为一名程序员，只要掌握了装饰器的精髓，就再也不用担心产品经理给我们出难题啦！

fishcyou

装饰器可以实现在不修改原来代码的前提下增加新功能。

（通过将原来代码作为函数，传入装饰器，返回新的结果）

1. import time
   
2. 
   
3. def time_master(func):
   
4.     def call_func():
   
5.         print("开始运行程序...")
   
6.         start = time.time()
   
7.         func()
   
8.         stop  = time.time()
   
9.         print("结束程序运行...")
   
10.         print(f"一共耗费了 {(stop-start):.2f} 秒.")
    
11.     return call_func
    
12. 
    
13. @time_master
    
14. def myfunc():
    
15.     time.sleep(2)
    
16.     print("Hello Python.")
    
17. 
    
18. myfunc()
    
19. >>>
    
20. 开始运行程序...
    
21. Hello Python.
    
22. 结束程序运行...
    
23. 一共耗费了 2.13 秒.

复制代码

此外，多个装饰器可以用在同一个函数上，还可以通过函数的多层嵌套调用给装饰器传递参数。

（多个@装饰器时，执行顺序是从下往上）

1. def square(func):
   
2.     def inner():
   
3.         x = func()
   
4.         return x ** 2
   
5.     return inner
   
6. 
   
7. def add(func):
   
8.     def inner():
   
9.         x = func()
   
10.         return x + 3
    
11.     return inner
    
12. 
    
13. @square
    
14. @add
    
15. def test():
    
16.     return 2
    
17. 
    
18. print(test()) # 顺序为（2+3）** 2
    
19. >>>
    
20. 25

复制代码

装饰器也可以传入参数。

1. import time
   
2. 
   
3. def logger(msg):
   
4.     def time_master(func):
   
5.         def inner():
   
6.             start = time.time()
   
7.             func()
   
8.             stop  = time.time()
   
9.             print(f"[{msg}]一共耗费了 {(stop-start):.2f} 秒.")
   
10.         return inner
    
11.     return time_master
    
12. 
    
13. @logger(msg='A') # 等同于funA = logger(msg=‘A’)(funA)
    
14. def funA():
    
15.     print("正在运行程序funA...")
    
16.     time.sleep(1)
    
17. 
    
18. @logger(msg='B')
    
19. def funB():
    
20.     print("正在运行程序funB...")
    
21.     time.sleep(2)
    
22.    
    
23. funA()
    
24. funB()
    
25. >>>
    
26. 正在运行程序funA...
    
27. [A]一共耗费了 1.08 秒.
    
28. 正在运行程序funB...
    
29. [B]一共耗费了 2.03 秒.

复制代码

8245k

1. import time
   
2.    
   
3. def logger(msg):
   
4.     def time_master(func):
   
5.         def useless():
   
6.             
   
7.             def call_func():
   
8.                 start = time.time()
   
9.                 func()
   
10.                 stop = time.time()
    
11.                 print(f"[{msg}]一共耗费了 {(stop-start):.2f}")
    
12.             return call_func
    
13.         return useless()
    
14.     return time_master
    
15.    
    
16. @logger(msg="A")
    
17. def funA():
    
18.     time.sleep(1)
    
19.     print("正在调用funA...")
    
20.    
    
21. @logger(msg="B")
    
22. def funB():
    
23.     time.sleep(1)
    
24.     print("正在调用funB...")
    
25.    
    
26. funA()
    
27. funB()
    

复制代码

第三个知识点让我好奇，这个语法糖是否可以不断向内挖掘嵌套函数，直到挖到最底层函数，然后将这个最底层的函数赋值给原函数？
这里在在logger函数中间添加了一个useless用来检测，经过实践确实是这样的，我随后还试了试两个useless，也是同样的结果

1. 正在调用funA...
   
2. [A]一共耗费了 1.01
   
3. 正在调用funB...
   
4. [B]一共耗费了 1.00

复制代码

无言之梦

装饰器第一部分的闭包过程中不打 return call_func  为什么报错

炎凉来寻

需要注意的是   ‘return 函数名’   的后面是否加‘（）’

1. def cube(func):
   
2.     def inner():
   
3.         def a():
   
4.             def b():
   
5.                 x = func()
   
6.                 return x * x * x
   
7.             return b()
   
8.         return a()
   
9.     return inner
   
10.    
    
11. @cube
    
12. def test():
    
13.     return 2
    
14.    
    
15. print(test())
    

复制代码

等价于

1. def cube(func):
   
2.     def inner():
   
3.         def a():
   
4.             def b():
   
5.                 x = func()
   
6.                 return x * x * x
   
7.             return b
   
8.         return a
   
9.     return inner
   
10.    
    
11. @cube
    
12. def test():
    
13.     return 2
    
14.    
    
15. print(test()()())

复制代码

Free_num

我觉得可以这么理解语法糖
import time

def time_master(func):
    def call_func():
        print('开始运行程序...')
        start = time.time()
        func()                     # 函数嵌套调用   func是形参，myfunc是实参  因此这里会执行myfunc()函数
        stop = time.time()
        print('结束程序运行...')
        print(f'一共耗费了{(stop-start):.2f}秒')
    return call_func            # 嵌套函数的返回值 返回到>>>函数调用处

def myfunc():
    time.sleep(2)
    print('Python')
a = time_master(myfunc)   #这是函数调用处  》》也就是说 a = time_master(myfunc)就是call_func
a()                                   # 所以这里就是 call_func()

Free_num

8245k 发表于 2022-8-1 23:41
第三个知识点让我好奇，这个语法糖是否可以不断向内挖掘嵌套函数，直到挖到最底层函数，然后将这个最底层 ...

我认为是由于func()这个嵌套调用在最最内存函数call_func()中，所以最后实质上才是call_func()这个函数的实现

阿伟同学

8245k 发表于 2022-8-1 23:41
第三个知识点让我好奇，这个语法糖是否可以不断向内挖掘嵌套函数，直到挖到最底层函数，然后将这个最底层 ...

问题不在这，是您retrun useless() 加上括号了按小甲鱼等价的

1. funA = logger(msg = "A")(funA)

复制代码

你这个相当于还是返回call_func的引用，你要是把括号去了就大不一样了

chenjinchao

难成狗啊，我要多看几次才行，坚持把这吃透

foolwolf0068

装饰器，确实很强大， 但是理解起来确实比较费力，继续加油

墨墨在努力吖

滴滴滴~打卡

七钱五

测试函数不能带参数，不然会报错，这是为什么呢？比如只能funA()，而不能是funA(x)

CDra

8245k 发表于 2022-8-1 23:41
第三个知识点让我好奇，这个语法糖是否可以不断向内挖掘嵌套函数，直到挖到最底层函数，然后将这个最底层 ...

不会把，装饰器只会将函数作为参数传一次，你一直往下嵌套直到最底层，是因为你返回函数的时候加了（）

lymbwx

语法糖  很赞啊

lymbwx

装饰器相对于语法糖，但是看起来更简洁直接

migu_sm1

Learning...

Loafer0

七钱五 发表于 2022-10-16 16:47
测试函数不能带参数，不然会报错，这是为什么呢？比如只能funA()，而不能是funA(x)

我也遇到了同样的问题，想知道后面怎么解决了？

呱呱呱i

andyleesh

打卡