🐍闭包与装饰器 — 函数的"包装艺术"

🕐 预计用时：2-3 小时 ｜ 🎯 目标：掌握闭包原理、@decorator、带参装饰器、functools.wraps

📖 今日目录

1. 什么是闭包？
2. 闭包的原理与应用
3. 装饰器入门 — @ 语法糖
4. 装饰器的本质
5. 带参数的装饰器
6. functools.wraps — 保留原函数信息
7. 类作为装饰器
8. 装饰器模板
9. 实战：计时器装饰器
10. 实战：缓存装饰器
11. 今日小结

1. 什么是闭包？

闭包（Closure）= 内部函数 + 引用了外部函数的变量。简单说，就是函数里定义函数，内部函数"记住"了外部的变量。

# 最简单的闭包
def outer(msg):
    def inner():
        print(f"消息: {msg}")  # inner 引用了外部的 msg
    return inner

# 调用 outer，返回 inner 函数
greet = outer("你好")
greet()  # 消息: 你好

# outer 已经执行完了，但 msg 变量还"活着"！
hello = outer("Hello")
hello()  # 消息: Hello

# 闭包计数器
def make_counter(start=0):
    count = start

    def counter():
        nonlocal count  # 修改外部变量需要 nonlocal
        count += 1
        return count

    return counter

c1 = make_counter()
print(c1())  # 1
print(c1())  # 2
print(c1())  # 3

c2 = make_counter(100)
print(c2())  # 101（独立的计数器！）

💡 闭包三要素：
1. 有嵌套函数（函数里定义函数）
2. 内部函数引用了外部函数的变量
3. 外部函数返回内部函数

2. 闭包的原理与应用

闭包"记住"了什么？

def multiplier(factor):
    def multiply(number):
        return number * factor  # factor 被"记住"了
    return multiply

double = multiplier(2)
triple = multiplier(3)

print(double(5))   # 10
print(triple(5))   # 15

# 查看闭包变量
print(double.__closure__[0].cell_contents)  # 2
print(triple.__closure__[0].cell_contents)  # 3

闭包的经典陷阱

# ❌ 经典错误：循环中的闭包
funcs = []
for i in range(5):
    funcs.append(lambda: i)  # 所有 lambda 都引用同一个 i

for f in funcs:
    print(f(), end=" ")
# 输出: 4 4 4 4 4 （不是 0 1 2 3 4！）
# 因为 i 最终是 4，所有 lambda 都引用同一个 i

# ✅ 修复：用默认参数捕获当前值
funcs = []
for i in range(5):
    funcs.append(lambda x=i: x)  # x=i 把当前的 i 绑定到 x

for f in funcs:
    print(f(), end=" ")
# 输出: 0 1 2 3 4 ✅

闭包的实际应用

# 应用1：配置生成器
def make_formatter(template):
    def format_data(data):
        return template.format(**data)
    return format_data

csv_formatter = make_formatter("{name},{age},{city}")
json_formatter = make_formatter('{{"name":"{name}","age":{age}}}')

data = {"name": "张三", "age": 25, "city": "北京"}
print(csv_formatter(data))   # 张三,25,北京
print(json_formatter(data))  # {"name":"张三","age":25}

# 应用2：权限校验
def require_role(role):
    def decorator(func):
        def wrapper(user, *args, **kwargs):
            if user.get("role") != role:
                print(f"❌ 权限不足: 需要 {role}")
                return None
            return func(user, *args, **kwargs)
        return wrapper
    return decorator

@require_role("admin")
def delete_user(user, target):
    print(f"✅ {user['name']} 删除了 {target}")

delete_user({"name": "张三", "role": "admin"}, "李四")   # ✅ 张三 删除了 李四
delete_user({"name": "李四", "role": "user"}, "王五")    # ❌ 权限不足: 需要 admin

3. 装饰器入门 — @ 语法糖

装饰器（Decorator）就是在不修改原函数代码的前提下，给函数添加额外功能。

# 不用装饰器：手动"包装"
def say_hello():
    print("你好")

def add_logging(func):
    def wrapper():
        print("📝 函数开始执行...")
        func()
        print("📝 函数执行完毕!")
    return wrapper

say_hello = add_logging(say_hello)  # 手动包装
say_hello()
# 📝 函数开始执行...
# 你好
# 📝 函数执行完毕!

# 用装饰器：@ 语法糖
def add_logging(func):
    def wrapper():
        print("📝 函数开始执行...")
        func()
        print("📝 函数执行完毕!")
    return wrapper

@add_logging  # 等价于 say_hello = add_logging(say_hello)
def say_hello():
    print("你好")

say_hello()
# 📝 函数开始执行...
# 你好
# 📝 函数执行完毕!

💡 @ 语法糖的等价关系：
@decorator
def func(): ...
等价于：func = decorator(func)

4. 装饰器的本质

# 装饰器就是一个"函数的函数"
# 接收一个函数 → 返回一个新函数

def my_decorator(func):
    # 新函数（wrapper）包装了原函数
    def wrapper(*args, **kwargs):
        print(f"📞 调用 {func.__name__}")
        result = func(*args, **kwargs)  # 调用原函数
        print(f"✅ {func.__name__} 返回 {result}")
        return result
    return wrapper

@my_decorator
def add(a, b):
    return a + b

@my_decorator
def greet(name):
    return f"你好, {name}"

print(add(3, 5))
# 📞 调用 add
# ✅ add 返回 8
# 8

print(greet("张三"))
# 📞 调用 greet
# ✅ greet 返回 你好, 张三
# 你好, 张三

# 多个装饰器（从下往上包装，从上往下执行）
def bold(func):
    def wrapper():
        return f"<b>{func()}}</b>"
    return wrapper

def italic(func):
    def wrapper():
        return f"<i>{func()}</i>"
    return wrapper

@bold
@italic
def say():
    return "Hello"

# 等价于: say = bold(italic(say))
print(say())  # <b><i>Hello</i></b>

5. 带参数的装饰器

装饰器本身要接收参数？再包一层函数！

# 带参数的装饰器 = 三层嵌套
def repeat(times):
    """让函数重复执行 n 次"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            result = None
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("你好!")

say_hello()
# 你好!
# 你好!
# 你好!

# 带可选参数的装饰器
import time

def timer(func=None, *, prefix=""):
    """计时装饰器（支持带参和不带参）"""
    def decorator(f):
        def wrapper(*args, **kwargs):
            start = time.time()
            result = f(*args, **kwargs)
            elapsed = time.time() - start
            label = f"{prefix} " if prefix else ""
            print(f"⏱️ {label}{f.__name__}: {elapsed:.4f}秒")
            return result
        return wrapper

    if func is None:
        return decorator  # @timer(prefix="xxx")
    return decorator(func)  # @timer

# 不带参数
@timer
def slow_function():
    time.sleep(0.1)

slow_function()  # ⏱️ slow_function: 0.1003秒

# 带参数
@timer(prefix="任务A")
def another_function():
    time.sleep(0.05)

another_function()  # ⏱️ 任务A another_function: 0.0502秒

⚠️ 三层嵌套口诀：
外层接收装饰器参数 → 中间层接收函数 → 内层是实际执行的 wrapper

6. functools.wraps — 保留原函数信息

装饰器会"覆盖"原函数的名字和文档，用 @wraps 修复。

# ❌ 不用 wraps 的问题
def my_decorator(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def greet(name):
    """打招呼函数"""
    print(f"你好, {name}")

print(greet.__name__)   # wrapper（不是 greet！）
print(greet.__doc__)    # None（文档丢了！）

# ✅ 用 wraps 修复
from functools import wraps

def my_decorator(func):
    @wraps(func)  # 把 func 的信息复制到 wrapper
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def greet(name):
    """打招呼函数"""
    print(f"你好, {name}")

print(greet.__name__)   # greet ✅
print(greet.__doc__)    # 打招呼函数 ✅

⚠️ 每个装饰器都应该加 @wraps(func)！不加 wraps 的装饰器是"有 bug"的——调试时你看到的函数名全是 wrapper。

7. 类作为装饰器

# 用类实现装饰器（实现 __call__ 方法）
from functools import wraps

class CountCalls:
    """统计函数被调用次数的装饰器"""

    def __init__(self, func):
        wraps(func)(self)  # 复制原函数信息
        self.func = func
        self.count = 0

    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"📊 {self.func.__name__} 被调用了 {self.count} 次")
        return self.func(*args, **kwargs)

@CountCalls
def say_hello():
    print("你好!")

say_hello()  # 📊 say_hello 被调用了 1 次 / 你好!
say_hello()  # 📊 say_hello 被调用了 2 次 / 你好!
say_hello()  # 📊 say_hello 被调用了 3 次 / 你好!
print(f"总调用次数: {say_hello.count}")  # 3

8. 装饰器模板

"""装饰器万能模板（直接复制使用）"""
from functools import wraps
import time

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # ===== 前置逻辑 =====
        # 例如：日志、计时、权限检查

        start = time.time()

        result = func(*args, **kwargs)  # 调用原函数

        # ===== 后置逻辑 =====
        # 例如：记录结果、清理资源

        elapsed = time.time() - start
        print(f"⏱️ {func.__name__} 耗时 {elapsed:.4f}秒")

        return result
    return wrapper

@my_decorator
def my_function(a, b):
    """我的函数"""
    return a + b

print(my_function(3, 5))
print(my_function.__name__)  # my_function ✅
print(my_function.__doc__)   # 我的函数 ✅

9. 实战：计时器装饰器

import time
from functools import wraps

def timer(func):
    """精确计时装饰器"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        elapsed = end - start

        if elapsed < 0.001:
            time_str = f"{elapsed*1_000_000:.0f}μs"
        elif elapsed < 1:
            time_str = f"{elapsed*1000:.1f}ms"
        else:
            time_str = f"{elapsed:.2f}秒"

        print(f"⏱️ {func.__name__}: {time_str}")
        return result
    return wrapper

@timer
def slow_sum(n):
    """慢速求和"""
    total = 0
    for i in range(n):
        total += i
    return total

@timer
def fast_sum(n):
    """快速求和"""
    return sum(range(n))

result1 = slow_sum(1_000_000)
# ⏱️ slow_sum: 52.3ms

result2 = fast_sum(1_000_000)
# ⏱️ fast_sum: 15.2ms

10. 实战：缓存装饰器

from functools import wraps

def memoize(func):
    """缓存装饰器（记忆化）"""
    cache = {}

    @wraps(func)
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
            print(f"💾 {func.__name__}{args} → 计算并缓存")
        else:
            print(f"💾 {func.__name__}{args} → 命中缓存")
        return cache[args]

    wrapper.cache = cache  # 暴露缓存供外部查看
    return wrapper

@memoize
def fibonacci(n):
    """递归斐波那契（带缓存）"""
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(10))  # 55
print(f"缓存大小: {len(fibonacci.cache)}")  # 11

# Python 内置的缓存装饰器（推荐使用）
from functools import lru_cache

@lru_cache(maxsize=128)  # 最多缓存 128 个结果
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(50))  # 12586269025（瞬间完成！）
print(fibonacci.cache_info())
# CacheInfo(hits=48, misses=51, maxsize=128, currsize=51)

💡 lru_cache vs 自定义 memoize：
• @lru_cache → Python 内置，C 实现，性能最佳
• 自定义 memoize → 学习原理用，实际项目用 @lru_cache
• lru_cache 的参数必须是 hashable（不可变）

11. 今日小结

核心要点

• ✅ 闭包 = 嵌套函数 + 引用外部变量 + 返回内部函数
• ✅ 装饰器本质：接收函数，返回新函数
• ✅ @decorator 等价于 func = decorator(func)
• ✅ 带参装饰器需要三层嵌套
• ✅ 每个装饰器都必须加 @wraps(func)
• ✅ @lru_cache 是内置的缓存装饰器，实际项目优先使用

🎯 练习建议：
1. 写一个 @retry(times=3) 装饰器，函数出错时自动重试
2. 写一个 @validate_types(int, int) 装饰器，校验参数类型
3. 写一个 @deprecated 装饰器，调用时打印"此函数已废弃"警告

📚 Day34 完成！明天进入装饰器进阶 — 类装饰器、装饰器链与实战