Day 9 · 装饰器(Decorator)

Week 2 · Day 9 / 56 · 预计 1.5-2 小时 · 返回大纲

一、什么是装饰器

装饰器是一种不修改原函数代码的前提下,给函数增加额外功能的方式。

JavaScript
// JS 装饰器(实验性)
function log(target, name, descriptor) {
  const original = descriptor.value;
  descriptor.value = function(...args) {
    console.log(`调用 ${name},参数:`, args);
    return original.apply(this, args);
  };
  return descriptor;
}

class Calculator {
  @log
  add(a, b) {
    return a + b;
  }
}
Python
# Python 装饰器
def log(func):
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__name__},参数:", args)
        return func(*args, **kwargs)
    return wrapper

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

add(1, 2)
# 输出:调用 add,参数: (1, 2)
# 返回:3
💡 前端类比:装饰器 ≈ React 的 HOC(高阶组件)或 Vue 的 mixin——给函数/组件加功能,但不侵入原代码。

二、为什么需要装饰器

2.1 问题:重复代码

# 没有装饰器:每个函数都要手动加日志
def add(a, b):
    print(f"调用 add,参数: {a}, {b}")  # 重复代码
    result = a + b
    print(f"add 返回: {result}")       # 重复代码
    return result

def multiply(a, b):
    print(f"调用 multiply,参数: {a}, {b}")  # 重复代码
    result = a * b
    print(f"multiply 返回: {result}")       # 重复代码
    return result

# 10 个函数就重复 10 遍

2.2 解决方案:装饰器

# 写一次,到处用
def log(func):
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__name__},参数: {args}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} 返回: {result}")
        return result
    return wrapper

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

@log
def multiply(a, b):
    return a * b

# 原函数代码完全没变

三、装饰器的本质

3.1 函数是一等公民

Python 里函数可以:

# 函数作为参数
def say_hello():
    return "Hello"

def call_func(func):
    return func()  # 调用传入的函数

print(call_func(say_hello))  # Hello

# 函数作为返回值
def get_func():
    def inner():
        return "Inner"
    return inner

f = get_func()
print(f())  # Inner

3.2 装饰器 = 语法糖

# 这两种写法完全等价

# 写法 1:用 @
@log
def add(a, b):
    return a + b

# 写法 2:手动调用
def add(a, b):
    return a + b
add = log(add)  # 把 add 替换成 log 返回的 wrapper

四、完整装饰器写法

4.1 基础装饰器

def log(func):
    def wrapper(*args, **kwargs):
        # 前置逻辑
        print(f"⏰ {func.__name__} 开始执行")
        
        # 执行原函数
        result = func(*args, **kwargs)
        
        # 后置逻辑
        print(f"✅ {func.__name__} 执行完毕")
        
        return result
    return wrapper

@log
def greet(name):
    return f"Hello, {name}!"

greet("Alice")
# ⏰ greet 开始执行
# ✅ greet 执行完毕
# 'Hello, Alice!'

4.2 带参数的装饰器

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for i in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(times=3)
def say_hi():
    print("Hi!")

say_hi()
# Hi!
# Hi!
# Hi!

4.3 保留原函数信息

from functools import wraps

def log(func):
    @wraps(func)  # 关键:保留原函数的元信息
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@log
def add(a, b):
    """两数相加"""
    return a + b

print(add.__name__)  # add(而不是 wrapper)
print(add.__doc__)   # 两数相加

五、实际应用场景

5.1 计时装饰器

import time
from functools import wraps

def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"⏱️ {func.__name__} 耗时: {end - start:.4f}秒")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    return "Done"

slow_function()
# ⏱️ slow_function 耗时: 1.0012秒

5.2 权限校验装饰器

from functools import wraps

def admin_required(func):
    @wraps(func)
    def wrapper(user, *args, **kwargs):
        if not user.get('is_admin'):
            raise PermissionError("需要管理员权限")
        return func(user, *args, **kwargs)
    return wrapper

@admin_required
def delete_user(user, user_id):
    return f"删除用户 {user_id}"

# 测试
admin = {'name': 'Alice', 'is_admin': True}
guest = {'name': 'Bob', 'is_admin': False}

delete_user(admin, 123)   # 正常执行
delete_user(guest, 123)   # 抛出 PermissionError

5.3 缓存装饰器

from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(50))  # 瞬间算出,因为有缓存

六、装饰器叠加

@timer
@log
def complex_calculation(n):
    return sum(i**2 for i in range(n))

# 执行顺序:
# 1. timer 先执行(最外层)
# 2. log 后执行
# 3. 原函数 complex_calculation
装饰器执行顺序作用
@timer第 1 个计时
@log第 2 个日志
原函数第 3 个实际逻辑

七、类装饰器

class CountCalls:
    def __init__(self, func):
        self.func = func
        self.count = 0

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

@CountCalls
def say_hello():
    print("Hello!")

say_hello()  # 第 1 次调用 say_hello
say_hello()  # 第 2 次调用 say_hello
say_hello()  # 第 3 次调用 say_hello

八、练习

练习 1:重试装饰器

写一个装饰器,函数失败时自动重试最多 n 次。

from functools import wraps
import random

def retry(max_times=3):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for i in range(max_times):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    print(f"第 {i+1} 次失败: {e}")
                    if i == max_times - 1:
                        raise
        return wrapper
    return decorator

@retry(max_times=3)
def unstable_api():
    if random.random() < 0.7:
        raise ConnectionError("网络错误")
    return "成功"

print(unstable_api())

练习 2:类型检查装饰器

写一个装饰器,检查函数参数类型是否匹配。

from functools import wraps
import inspect

def type_check(**expected_types):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # 获取函数签名,把位置参数和关键字参数统一成名字
            sig = inspect.signature(func)
            bound = sig.bind(*args, **kwargs)
            bound.apply_defaults()
            
            # 检查所有参数
            for name, expected in expected_types.items():
                if name in bound.arguments:
                    value = bound.arguments[name]
                    if not isinstance(value, expected):
                        raise TypeError(
                            f"参数 {name} 期望 {expected.__name__},"
                            f"实际 {type(value).__name__} = {value!r}"
                        )
            return func(*args, **kwargs)
        return wrapper
    return decorator

@type_check(age=int, name=str)
def greet(name, age):
    return f"{name} 今年 {age} 岁"

# 位置参数调用
print(greet("Alice", 25))       # 正常
print(greet("Bob", "25"))        # 抛出 TypeError: 参数 age 期望 int,实际 str

# 关键字参数调用
print(greet(name="Charlie", age=30))  # 正常
print(greet(name=42, age=30))         # 抛出 TypeError: 参数 name 期望 str,实际 int

练习 3:路由装饰器

模拟 Flask 的路由装饰器,把 URL 和函数关联起来。

routes = {}

def route(url):
    def decorator(func):
        routes[url] = func
        return func
    return decorator

@route('/home')
def home():
    return "首页"

@route('/about')
def about():
    return "关于我们"

# 模拟请求
def handle_request(url):
    if url in routes:
        return routes[url]()
    return "404 Not Found"

print(handle_request('/home'))   # 首页
print(handle_request('/about'))  # 关于我们
print(handle_request('/xxx'))   # 404 Not Found

练习 4:异步装饰器

写一个装饰器,给异步函数加日志。

import asyncio
from functools import wraps

def async_log(func):
    @wraps(func)
    async def wrapper(*args, **kwargs):
        print(f"开始异步任务: {func.__name__}")
        result = await func(*args, **kwargs)
        print(f"完成异步任务: {func.__name__}")
        return result
    return wrapper

@async_log
async def fetch_data(url):
    await asyncio.sleep(1)  # 模拟网络请求
    return f"数据来自 {url}"

# 运行
asyncio.run(fetch_data('https://api.example.com'))

九、打卡验收

理解了装饰器的本质:func = decorator(func) 的语法糖
会写基础装饰器,理解 *args, **kwargs 的作用
会写带参数的装饰器,理解三层嵌套
知道 @wraps(func) 的作用,会保留原函数元信息
能写出计时、日志、权限校验等实际装饰器
理解装饰器叠加的执行顺序(最外层先执行)
知道 @lru_cache 等内置装饰器的用法
完成了至少 2 个练习,代码能跑通
打卡方式: 全部勾选后,告诉我 "Day 9 打卡",并贴出你的代码,我帮你检查。
明天预告(Day 10): 错误和异常处理——try/except/finally、自定义异常、Pythonic 的错误处理方式。