[已解决]装饰器相关问题

熊熊学python

萌新 ，刚听课到装饰器~课程中的代码如下：

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("I love FishC.")
    
17.    
    
18. myfunc()

复制代码

call_func用到了闭包函数，但是我在写的时候并没有加call_func，代码如下：

1. import time
   
2. def time_master(func):
   
3.     print("开始运行...")
   
4.     start = time.time()
   
5.     func()
   
6.     stop = time.time()
   
7.     print("结束啦...")
   
8.     print(f'一共耗费了{(stop-start):.2f}秒。')
   
9. 
   
10. @time_master
    
11. def myfunc():
    
12.     time.sleep(1)
    
13.     print("helloworld")
    
14. 
    
15. myfunc

复制代码

同样能运行，就是想问问用不用闭包函数会有什么区别？

最佳答案

月排行榜 / 总排行榜

FishC

昨天 16:17

你好！很高兴看到你在学习装饰器，这是一个很重要的概念。我来帮你解答关于闭包函数在装饰器中的作用区别。

首先，你的第二段代码之所以“能运行”，是因为装饰器 @time_master 在定义时就会立即执行，而不是在调用函数时。但这其实有一个问题：它破坏了原函数的功能。下面我来详细解释一下。

标准装饰器（使用闭包）的工作原理：
- 装饰器应该返回一个函数，这样原函数才能被“包装”并延迟执行。
- 在你的第一段代码中，time_master 返回了内部函数 call_func，所以当调用 myfunc() 时，实际上执行的是装饰后的版本（包括计时功能）。
- 示例代码：

1. 
   
2. import time
   
3. 
   
4. def time_master(func):
   
5.     def call_func():
   
6.         print("开始运行程序...")
   
7.         start = time.time()
   
8.         func()  # 这里调用原函数
   
9.         stop = time.time()
   
10.         print("结束程序运行...")
    
11.         print(f"一共耗费了 {(stop-start):.2f} 秒。")
    
12.     return call_func  # 返回内部函数
    
13. 
    
14. @time_master
    
15. def myfunc():
    
16.     time.sleep(2)
    
17.     print("I love FishC.")
    
18. 
    
19. myfunc()  # 正确调用，会输出计时信息
    

复制代码

你的第二段代码的问题：
- 你的代码中没有使用闭包（内部函数），而是直接在装饰器中执行了原函数。
- 这会导致装饰器在定义时立即运行原函数，并且将 myfunc 替换为 None（因为装饰器没有返回任何值）。
- 示例代码：

1. 
   
2. import time
   
3. 
   
4. def time_master(func):
   
5.     print("开始运行...")  # 装饰器定义时立即执行
   
6.     start = time.time()
   
7.     func()  # 立即调用原函数
   
8.     stop = time.time()
   
9.     print("结束啦...")
   
10.     print(f'一共耗费了{(stop-start):.2f}秒。')
    
11.     # 没有返回任何值，所以 myfunc 变成 None
    
12. 
    
13. @time_master  # 这里会立即执行 time_master(myfunc)
    
14. def myfunc():
    
15.     time.sleep(1)
    
16.     print("helloworld")
    
17. 
    
18. # 此时 myfunc 是 None，如果你写 myfunc() 会报错
    
19. myfunc  # 这行代码只是引用变量，不会执行任何操作
    

复制代码

- 结果：当Python解释器遇到 @time_master 时，会立即运行 time_master(myfunc)，所以你会看到输出，但之后 myfunc 不再是函数，而是 None。如果你尝试调用 myfunc()，会报错（例如 TypeError）。

主要区别总结：
- 使用闭包：装饰器返回一个新函数，原函数的调用被“延迟”到实际调用时，并且原功能被保留和增强。
- 不使用闭包：装饰器在定义时立即执行原函数，破坏原函数的可调用性，后续无法正常使用。

建议：
始终在装饰器中使用闭包（内部函数），这样才能正确包装原函数，实现装饰器的目的（如计时、日志等），而不影响函数的正常调用。

如果还有疑问，欢迎继续讨论！加油学习！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

跳转到最佳答案楼层

FishC

你好！很高兴看到你在学习装饰器，这是一个很重要的概念。我来帮你解答关于闭包函数在装饰器中的作用区别。

首先，你的第二段代码之所以“能运行”，是因为装饰器 @time_master 在定义时就会立即执行，而不是在调用函数时。但这其实有一个问题：它破坏了原函数的功能。下面我来详细解释一下。

标准装饰器（使用闭包）的工作原理：
- 装饰器应该返回一个函数，这样原函数才能被“包装”并延迟执行。
- 在你的第一段代码中，time_master 返回了内部函数 call_func，所以当调用 myfunc() 时，实际上执行的是装饰后的版本（包括计时功能）。
- 示例代码：

1. 
   
2. import time
   
3. 
   
4. def time_master(func):
   
5.     def call_func():
   
6.         print("开始运行程序...")
   
7.         start = time.time()
   
8.         func()  # 这里调用原函数
   
9.         stop = time.time()
   
10.         print("结束程序运行...")
    
11.         print(f"一共耗费了 {(stop-start):.2f} 秒。")
    
12.     return call_func  # 返回内部函数
    
13. 
    
14. @time_master
    
15. def myfunc():
    
16.     time.sleep(2)
    
17.     print("I love FishC.")
    
18. 
    
19. myfunc()  # 正确调用，会输出计时信息
    

复制代码

你的第二段代码的问题：
- 你的代码中没有使用闭包（内部函数），而是直接在装饰器中执行了原函数。
- 这会导致装饰器在定义时立即运行原函数，并且将 myfunc 替换为 None（因为装饰器没有返回任何值）。
- 示例代码：

1. 
   
2. import time
   
3. 
   
4. def time_master(func):
   
5.     print("开始运行...")  # 装饰器定义时立即执行
   
6.     start = time.time()
   
7.     func()  # 立即调用原函数
   
8.     stop = time.time()
   
9.     print("结束啦...")
   
10.     print(f'一共耗费了{(stop-start):.2f}秒。')
    
11.     # 没有返回任何值，所以 myfunc 变成 None
    
12. 
    
13. @time_master  # 这里会立即执行 time_master(myfunc)
    
14. def myfunc():
    
15.     time.sleep(1)
    
16.     print("helloworld")
    
17. 
    
18. # 此时 myfunc 是 None，如果你写 myfunc() 会报错
    
19. myfunc  # 这行代码只是引用变量，不会执行任何操作
    

复制代码

- 结果：当Python解释器遇到 @time_master 时，会立即运行 time_master(myfunc)，所以你会看到输出，但之后 myfunc 不再是函数，而是 None。如果你尝试调用 myfunc()，会报错（例如 TypeError）。

主要区别总结：
- 使用闭包：装饰器返回一个新函数，原函数的调用被“延迟”到实际调用时，并且原功能被保留和增强。
- 不使用闭包：装饰器在定义时立即执行原函数，破坏原函数的可调用性，后续无法正常使用。

建议：
始终在装饰器中使用闭包（内部函数），这样才能正确包装原函数，实现装饰器的目的（如计时、日志等），而不影响函数的正常调用。

如果还有疑问，欢迎继续讨论！加油学习！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

gpa5031

学习