Python闭包与装饰器零基础到实战：从函数嵌套到三大企业级装饰器

脚本专家

闭包和装饰器是Python进阶必须掌握的核心语法，也是理解Flask、Django等框架源码、实现日志、鉴权、缓存等功能的基石。很多开发者学了许久仍无法手写装饰器，根本原因在于没吃透闭包原理。本文从函数作为一等公民讲起，逐步拆解闭包三要素、装饰器本质、带参装饰器、多层装饰器执行顺序，最后给出三个可直接复用的企业级装饰器。所有代码均经过测试，可放心使用。

一、前置基础：函数是一等公民

Python中函数是一等对象，这意味着：
1. 函数可以赋值给变量
2. 函数可以作为参数或返回值
3. 函数可以嵌套定义

这种特性是闭包和装饰器成立的底层基础。例如：

2. def outer():
3.     def inner():
4.         print("内部函数执行")
5.     return inner
7. res = outer()
8. res()

复制代码

正是由于函数可以被嵌套并且作为返回值，才诞生了闭包这种结构。

二、闭包详解：定义、条件与原理

2.1 闭包的三大必要条件
同时满足以下三点即为闭包：
- 函数嵌套（外层函数 + 内层函数）
- 内层函数引用外层函数的局部变量
- 外层函数返回内层函数

2.2 闭包实战代码

2. def outer(num):
3.     def inner():
4.         print(f"传入数值：{num}")
5.     return inner
7. func = outer(100)
8. func()

复制代码

2.3 闭包核心特性：变量常驻
普通函数执行结束后，局部变量会被销毁。但闭包会保留外层函数的局部变量不被GC回收，从而实现状态保存和数据常驻。

2.4 经典场景：计数器

2. def count_factory():
3.     cnt = 0
4.     def counter():
5.         nonlocal cnt
6.         cnt += 1
7.         print(f"当前计数：{cnt}")
8.     return counter
10. c1 = count_factory()
11. c1()  # 输出：当前计数：1
12. c1()  # 输出：当前计数：2
13. c1()  # 输出：当前计数：3

复制代码

需注意nonlocal关键字用于在内层函数中修改外层函数的局部变量。

三、装饰器本质：基于闭包的语法糖

装饰器 = 高阶闭包 + @语法糖。核心作用：在不修改原函数代码、不改变调用方式的前提下，给函数新增功能，符合“开闭原则”（对扩展开放，对修改关闭）。

装饰器解决的问题包括：
- 避免重复代码（日志、计时、鉴权等通用逻辑复用）
- 业务代码与通用工具代码解耦
- 统一项目规范，便于维护

四、手写无参装饰器：日志统计实战

4.1 原生闭包写法（理解底层）

2. import time
4. def timer_decorator(func):
5.     def wrapper(*args, **kwargs):
6.         start = time.time()
7.         res = func(*args, **kwargs)
8.         end = time.time()
9.         print(f"函数【{func.__name__}】执行耗时：{end - start:.4f}s")
10.         return res
11.     return wrapper
13. @timer_decorator
14. def calc_sum(n):
15.     s = 0
16.     for i in range(n):
17.         s += i
18.     return s
20. calc_sum(100000)

复制代码

4.2 装饰器的执行流程
@timer_decorator 等价于 calc_sum = timer_decorator(calc_sum)。调用 calc_sum() 实际执行 wrapper()：先运行前置逻辑（记录开始时间），然后执行原函数，再运行后置逻辑（计算耗时），最后返回原函数结果。

4.3 解决函数信息被覆盖的问题
直接装饰会使原函数名、文档字符串被wrapper覆盖。使用 functools.wraps 修复：

2. from functools import wraps
4. def timer_decorator(func):
5.     @wraps(func)
6.     def wrapper(*args, **kwargs):
7.         start = time.time()
8.         res = func(*args, **kwargs)
9.         end = time.time()
10.         print(f"函数【{func.__name__}】执行耗时：{end - start:.4f}s")
11.         return res
12.     return wrapper

复制代码

五、进阶：带参数装饰器 + 多层装饰器

5.1 带参数装饰器
普通装饰器只能接收函数作为参数。带参装饰器可以自定义配置参数，实现功能开关等。例如实现一个可以控制是否输出日志的装饰器：

2. from functools import wraps
4. def log_decorator(switch=True):
5.     def decorator(func):
6.         @wraps(func)
7.         def wrapper(*args, **kwargs):
8.             if switch:
9.                 print(f"【日志】函数{func.__name__}开始执行")
10.             return func(*args, **kwargs)
11.         return wrapper
12.     return decorator
14. @log_decorator(switch=True)
15. def test_func():
16.     print("业务逻辑执行")
18. test_func()

复制代码

5.2 多层装饰器叠加执行顺序
加载顺序：自下而上（离函数最近的装饰器先加载）。执行顺序：自上而下（先执行最外层装饰器的前置逻辑）。口诀：先装饰的后执行，后装饰的先执行。

2. from functools import wraps
4. def deco1(func):
5.     @wraps(func)
6.     def wrapper():
7.         print("deco1 前置")
8.         func()
9.         print("deco1 后置")
10.     return wrapper
12. def deco2(func):
13.     @wraps(func)
14.     def wrapper():
15.         print("deco2 前置")
16.         func()
17.         print("deco2 后置")
18.     return wrapper
20. @deco1
21. @deco2
22. def hello():
23.     print("核心业务执行")
25. hello()
26. # 输出顺序：
27. # deco1 前置
28. # deco2 前置
29. # 核心业务执行
30. # deco2 后置
31. # deco1 后置

复制代码

六、企业级实战三大装饰器（可直接复用）

6.1 接口鉴权装饰器

2. from functools import wraps
4. def login_auth(func):
5.     @wraps(func)
6.     def wrapper(user_token, *args, **kwargs):
7.         if not user_token:
8.             return {"code": 401, "msg": "未登录，权限不足"}
9.         return func(user_token, *args, **kwargs)
10.     return wrapper
12. @login_auth
13. def get_user_info(token):
14.     return {"code": 200, "data": "用户信息数据"}
16. print(get_user_info(""))  # 返回401
17. print(get_user_info("valid_token"))  # 返回200

复制代码

6.2 简易缓存装饰器（避免重复计算）

2. from functools import wraps
4. def cache_decorator(func):
5.     cache = {}
6.     @wraps(func)
7.     def wrapper(*args):
8.         if args not in cache:
9.             cache[args] = func(*args)
10.         return cache[args]
11.     return wrapper
13. @cache_decorator
14. def fib(n):
15.     if n <= 2:
16.         return 1
17.     return fib(n-1) + fib(n-2)
19. print(fib(30))  # 首次计算递归后缓存结果，后续调用直接读取缓存

复制代码

此装饰器以函数参数为键存储结果，适合纯函数（相同输入永远得到相同输出）。

6.3 异常捕获装饰器（统一异常处理）

2. from functools import wraps
4. def exception_catch(func):
5.     @wraps(func)
6.     def wrapper(*args, **kwargs):
7.         try:
8.             return func(*args, **kwargs)
9.         except Exception as e:
10.             print(f"【函数异常】{func.__name__}执行失败：{str(e)}")
11.             return None
12.     return wrapper
14. @exception_catch
15. def divide(a, b):
16.     return a / b
18. print(divide(10, 0))  # 输出异常信息并返回None

复制代码

七、面试高频真题整理

Q1：什么是闭包？闭包的作用和缺点？
闭包是一种嵌套函数结构：外层函数返回内层函数，且内层函数引用了外层函数的局部变量。作用：保存函数执行状态、实现数据常驻、简化代码、实现装饰器。缺点：外层变量常驻内存不释放，长时间使用易导致内存泄漏。

Q2：装饰器的原理是什么？为什么不修改原代码？
装饰器基于闭包和高阶函数实现，通过包装原函数在调用前后扩展逻辑。符合开闭原则，使得业务逻辑与通用逻辑解耦，无需修改原函数内部实现。

Q3：wraps装饰器的作用？
functools.wraps 用于修复因装饰器导致的原函数信息丢失问题，保留原函数的 __name__、__doc__ 等属性。

Q4：多层装饰器的执行顺序？
加载顺序（装饰器声明顺序）自下而上，执行顺序自上而下。即最靠近函数的装饰器先被装饰，但执行时其前置逻辑最后执行。

通过以上系统讲解，闭包与装饰器的原理、手写方法、进阶用法及企业级实战已清晰呈现。建议读者动手运行每一个代码示例，加深理解。

热心网友5

楼主的教程写得非常清晰，从闭包原理到装饰器实战，逻辑层层递进，尤其喜欢“先装饰的后执行，后装饰的先执行”这个口诀，一下就把多层装饰器的执行顺序记住了。三个企业级装饰器也很实用，正好最近项目里要用日志和鉴权，直接参考代码能省不少排查时间。感谢分享！

热心网友5

非常感谢楼主的详细分享！从闭包的三条件到装饰器的语法糖，再到带参装饰器和多层执行顺序，逻辑很清晰，代码也都能直接跑通，对初学者理解底层原理特别有帮助。尤其是用 `nonlocal` 修改外层变量的计数器示例，把“变量常驻”这个特性讲得明明白白。另外 `functools.wraps` 的强调也很实用，很多人刚学时容易忽略这点。期待后面三个企业级装饰器的完整代码，方便的话能不能先透露下大概的应用场景？比如日志、鉴权和缓存吗？再次感谢！

热心网友5

非常感谢楼主这么详细的讲解！我一直对闭包的变量常驻机制有点模糊，看到计数器那个例子和 `nonlocal` 的用法瞬间就通了。装饰器部分把 `@wraps` 和多层执行顺序讲得特别清楚，之前踩过函数名被覆盖的坑，现在终于知道怎么修复了。想问一下，在实际企业项目里，日志、鉴权这类装饰器会写成类装饰器吗？还是像你给的这种函数嵌套写法就够用了？期待后续的三大企业级装饰器实战！