Python类装饰器：给你的类穿上“皇帝的新装”

引言：当类也需要“美颜”

朋友们，今天我们来聊聊Python里的类装饰器。如果你觉得装饰器只能装饰函数，那你可就大错特错了！类也需要打扮得漂漂亮亮的好吗？想象一下，你的类穿着朴素的衣服去参加Python界的时尚派对，多尴尬啊！

类装饰器就像是类的私人造型师，可以在不改变类本身的情况下，给它添加新功能、新属性，或者干脆把它改头换面。让我们来看看这位“造型师”到底有什么魔法吧！

一、基础知识回顾：函数装饰器速成班

在进入正题之前，让我们花30秒回顾一下函数装饰器：

def 化妆师(func):
    def 化妆后():
        print("先打粉底")
        func()
        print("再涂口红")
    return 化妆后

@化妆师
def 我():
    print("我是素颜的我")

我()
# 输出：
# 先打粉底
# 我是素颜的我
# 再涂口红

简单说，装饰器就是一个函数，它接受一个函数，返回一个新函数。那么类装饰器呢？别急，马上揭晓！

二、类装饰器登场：类的“整容手术”

基础版：最简单的类装饰器

def 添加问好(类):
    """给类添加一个say_hello方法"""
    类.say_hello = lambda self: f"你好，我是{self.__class__.__name__}!"
    return 类

@添加问好
class 人类:
    pass

小明 = 人类()
print(小明.say_hello())  # 输出：你好，我是人类!

看到了吗？类装饰器接受一个类作为参数，然后返回一个修改后的类。就这么简单！

中级版：给类添加“超能力”

def 添加飞行能力(cls):
    """让任何类都能飞起来（至少在代码里）"""
    cls.可以飞 = True
    cls.飞行 = lambda self: f"{self.__class__.__name__}正在翱翔天际！"
    
    # 修改__init__，给所有实例添加翅膀
    原始初始化 = cls.__init__
    
    def 新初始化(self, *args, **kwargs):
        原始初始化(self, *args, **kwargs)
        self.翅膀数量 = 2
        print(f"{self.__class__.__name__}长出了{self.翅膀数量}只翅膀！")
    
    cls.__init__ = 新初始化
    return cls

@添加飞行能力
class 猪:
    def __init__(self, 名字):
        self.名字 = 名字
        print(f"{self.名字}出生了！")

飞天神猪 = 猪("佩奇")
print(飞天神猪.飞行())  # 输出：佩奇出生了！猪长出了2只翅膀！猪正在翱翔天际！
print(f"猪可以飞吗？{飞天神猪.可以飞}")  # 输出：猪可以飞吗？True

现在连猪都能飞了！这就是类装饰器的魔力。

三、带参数的类装饰器：更智能的造型师

有时候我们的造型师需要知道客户想要什么风格：

def 添加技能(*技能列表):
    """给类添加指定的技能"""
    def 装饰器(cls):
        for 技能 in 技能列表:
            setattr(cls, 技能, lambda self, s=技能: f"{self.名字}使用了{s}！")
        return cls
    return 装饰器

@添加技能("编程", "设计", "摸鱼")
class 程序员:
    def __init__(self, 名字):
        self.名字 = 名字

老王 = 程序员("老王")
print(老王.编程())  # 输出：老王使用了编程！
print(老王.摸鱼())  # 输出：老王使用了摸鱼！（老板：？？？）

这就叫“精准化妆”！根据参数决定给类添加什么功能。

四、类作为装饰器：身份的转变

最有趣的部分来了——类本身也可以作为装饰器！是的，你没听错，类也能“转行”当装饰器。

class 计数器:
    """统计类被实例化的次数"""
    def __init__(self, cls):
        self.cls = cls
        self.计数 = 0
    
    def __call__(self, *args, **kwargs):
        self.计数 += 1
        print(f"{self.cls.__name__}被第{self.计数}次实例化")
        return self.cls(*args, **kwargs)

@计数器
class 稀有物品:
    def __init__(self, 名称):
        self.名称 = 名称

物品1 = 稀有物品("黄金")  # 输出：稀有物品被第1次实例化
物品2 = 稀有物品("钻石")  # 输出：稀有物品被第2次实例化

关键点在于__call__方法！它让类的实例可以像函数一样被调用。

五、实际应用场景：类装饰器在现实中的工作

场景1：单例模式（Singleton）

def 单例模式(cls):
    """确保一个类只有一个实例"""
    实例库 = {}
    
    def 获取实例(*args, **kwargs):
        if cls not in 实例库:
            实例库[cls] = cls(*args, **kwargs)
        return 实例库[cls]
    
    return 获取实例

@单例模式
class 配置管理器:
    def __init__(self):
        self.配置 = {}
        print("配置管理器初始化")

管理器1 = 配置管理器()  # 输出：配置管理器初始化
管理器2 = 配置管理器()  # 没有输出，因为返回的是同一个实例
print(管理器1 is 管理器2)  # 输出：True

场景2：自动注册类

类注册表 = []

def 自动注册(cls):
    类注册表.append(cls)
    cls.注册ID = len(类注册表)
    return cls

@自动注册
class 用户:
    pass

@自动注册  
class 订单:
    pass

print(f"已注册的类：{[c.__name__ for c in 类注册表]}")
print(f"用户的注册ID：{用户.注册ID}")

场景3：给类添加“插件系统”

def 支持插件(cls):
    cls._插件列表 = []
    
    @classmethod
    def 注册插件(类, 插件):
        类._插件列表.append(插件)
    
    def 执行插件(self):
        for 插件 in self._插件列表:
            插件(self)
    
    cls.注册插件 = 注册插件
    cls.执行插件 = 执行插件
    return cls

@支持插件
class 编辑器:
    def __init__(self, 文件名):
        self.文件名 = 文件名

def 语法高亮(编辑器实例):
    print(f"正在对{编辑器实例.文件名}进行语法高亮...")

def 代码格式化(编辑器实例):
    print(f"正在格式化{编辑器实例.文件名}...")

编辑器.注册插件(语法高亮)
编辑器.注册插件(代码格式化)

我的编辑器 = 编辑器("test.py")
我的编辑器.执行插件()
# 输出：
# 正在对test.py进行语法高亮...
# 正在格式化test.py...

六、类装饰器 vs 元类：选择困难症？

你可能会问：“这和元类有什么区别？”好问题！让我用一个表格来总结：

特性 类装饰器 元类
语法难度 相对简单 较复杂
修改时机 类创建后立即执行 类创建过程中执行
灵活性 可以叠加多个装饰器 一个类只能有一个元类
适用场景 添加/修改类属性方法 控制类的创建过程
可读性 更直观，像“化妆” 更隐晦，像“基因改造”

简单来说：如果你只是想给类“化妆”，用装饰器；如果你想改变类的“DNA”，用元类。

七、注意事项：别踩这些坑！

  1. 顺序很重要：多个装饰器的执行顺序是从下往上的（最靠近类的先执行）
@装饰器1
@装饰器2
@装饰器3
class 我的类:
    pass
# 实际执行顺序：装饰器3 -> 装饰器2 -> 装饰器1
  1. 可能会丢失元信息：使用functools.wraps的类版本functools.update_wrapper
import functools

def 保留信息(cls):
    @functools.wraps(cls, updated=())
    class 包装类(cls):
        pass
    return 包装类
  1. 别过度使用：装饰器虽好，但太多层会让代码难以理解（就像化妆太浓反而不好看）

八、总结：类装饰器的精髓

类装饰器就像是Python世界里的“瑞士军刀”，小巧但功能强大。记住这几个核心点：

  1. 本质：接受一个类，返回一个类
  2. 时机：在类定义后立即执行
  3. 用途：修改、增强、包装类
  4. 优势：代码复用、关注点分离、可组合

最后送大家一句话：装饰器不是魔术，而是让你的代码更优雅的工具。 用得好，你的代码会像精心打扮的绅士淑女；用不好，就会像圣诞树——花哨但杂乱。

现在，去给你的类做个“造型”吧！