异常教程

python 装饰器（长文解析）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

什么是Python装饰器？

Python装饰器是一种用于修改或扩展函数或类行为的高级编程工具。它通过“包装”原函数的方式，在不修改原函数代码的前提下，为函数添加额外功能。装饰器的设计灵感来源于面向对象编程中的“装饰模式”，因此常被比喻为“为函数穿衣服”——就像我们给礼物包裹包装纸一样，装饰器让函数在保持核心功能的同时，获得新的外观或附加价值。

对于编程初学者，装饰器可能显得抽象，但掌握它能显著提升代码的复用性和可维护性。例如，日志记录、性能计时、权限验证等常见需求，都可以通过装饰器实现，避免代码重复。

装饰器的核心语法与基本示例

装饰器的基本语法

装饰器的本质是一个函数，其接收原函数作为参数，并返回一个新的函数。语法上，通过在目标函数前添加@decorator_name实现：

def my_decorator(func):
    def wrapper():
        print("装饰器开始执行")
        func()
        print("装饰器结束执行")
    return wrapper

@my_decorator
def say_hello():
    print("Hello, World!")

say_hello()

输出结果：

装饰器开始执行
Hello, World!
装饰器结束执行

装饰器的执行流程

  1. 定义装饰器函数my_decorator，它接受原函数func作为参数；
  2. 在装饰器内部定义wrapper函数，用于包裹原函数的调用逻辑；
  3. 返回wrapper函数作为装饰后的结果；
  4. 当调用say_hello()时，实际执行的是装饰器返回的wrapper函数。

通过这一过程，装饰器在不修改say_hello代码的情况下，为其添加了执行前后的打印功能。

装饰器的底层原理：闭包与函数对象

闭包（Closure）的作用

装饰器的核心依赖于Python的闭包特性。闭包是指能够记住并访问其定义时所在作用域的变量的函数。在装饰器中，wrapper函数通过闭包“记住”了原函数func，从而在调用时能够调用它。

例如，上述例子中，wrapper函数内部的func()即通过闭包访问到了原函数say_hello。

函数即对象（First-class Function）

在Python中，函数是对象，可以赋值给变量、作为参数传递，或作为返回值。装饰器正是利用这一特性，将原函数传递给装饰器函数，并返回新的函数对象。

装饰器的“语法糖”本质

@my_decorator的语法糖等价于：

say_hello = my_decorator(say_hello)

装饰器的通用模式与扩展

通用装饰器模板

为了使装饰器能适配任意函数（包括带参数和返回值的函数），需要使用*args和**kwargs：

def general_decorator(func):
    def wrapper(*args, **kwargs):
        print("装饰器开始执行")
        result = func(*args, **kwargs)
        print("装饰器结束执行")
        return result
    return wrapper

带返回值的函数示例

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

result = add(3, 5)
print(result)  # 输出8

带参数的装饰器：更灵活的功能扩展

问题：如何让装饰器接受参数？

例如，我们希望装饰器能根据参数控制日志的详细程度：

def log(level="INFO"):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(f"[{level}] 调用函数 {func.__name__}")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@log(level="DEBUG")
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")

输出结果：

[DEBUG] 调用函数 greet
Hello, Alice!

参数化装饰器的结构解析

  1. 最外层函数log接收参数level；
  2. 返回中间的装饰器函数decorator，该函数接收原函数func；
  3. 内部的wrapper函数实现具体逻辑，并通过闭包访问level参数；
  4. 调用@log(level="DEBUG")等价于： 
    greet = log(level="DEBUG")(greet)

类装饰器：用类实现装饰逻辑

类装饰器的设计思路

当需要维护装饰器的状态或使用类的特性时，可以用类实现装饰器。类装饰器需实现__call__方法，使其实例可作为函数调用：

class Counter:
    def __init__(self, func):
        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)

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

multiply(2, 3)  # 输出调用次数1
multiply(4, 5)  # 输出调用次数2

类装饰器的优势

  • 可以存储状态（如count计数器）；
  • 支持复杂的逻辑处理（如依赖数据库或配置文件）；
  • 适合需要初始化操作的场景。

装饰器的实际应用场景

场景1：性能计时

import time

def timer(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 compute_sum(n):
    return sum(range(n))

compute_sum(1000000)  # 输出实际耗时

场景2：权限验证

def permission_required(permission):
    def decorator(func):
        def wrapper(user, *args, **kwargs):
            if user.has_permission(permission):
                return func(user, *args, **kwargs)
            else:
                raise PermissionError("权限不足")
        return wrapper
    return decorator

class User:
    def __init__(self, permissions):
        self.permissions = permissions

    def has_permission(self, perm):
        return perm in self.permissions

@permission_required("admin")
def delete_resource(user):
    print("资源删除成功")

user = User(permissions=["admin"])
delete_resource(user)  # 成功

场景3：缓存优化

def memoize(func):
    cache = {}
    def wrapper(n):
        if n in cache:
            return cache[n]
        result = func(n)
        cache[n] = result
        return result
    return wrapper

@memoize
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

fibonacci(30)  # 通过缓存显著加速递归计算

装饰器的常见问题与调试技巧

问题1：装饰器导致函数元数据丢失

当使用装饰器后，原函数的__name__、__doc__等属性会被替换为装饰器内部函数的属性。可通过functools.wraps修复：

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        ...
    return wrapper

问题2：装饰器顺序影响行为

多个装饰器按从下到上的顺序叠加：

@dec1
@dec2
def my_func():
    pass

调试技巧

  • 在装饰器内部添加调试日志；
  • 使用pdb或断点逐步执行；
  • 对于复杂装饰器，拆分为多个小函数逐步测试。

总结：装饰器的价值与最佳实践

Python装饰器是代码抽象与复用的利器，其核心思想是“通过函数组合实现功能扩展”。无论是日志记录、性能监控，还是权限控制，装饰器都能以简洁的方式提升代码的可维护性。

最佳实践建议：

  1. 优先使用语法糖@decorator，保持代码可读性；
  2. 对于复杂逻辑，考虑参数化装饰器或类装饰器；
  3. 利用functools.wraps保留函数元数据；
  4. 通过单元测试验证装饰器的正确性。

掌握装饰器后，开发者可以更优雅地应对常见需求，同时为代码注入“模块化”与“可扩展性”的基因。

最新发布

查看更多文章