知识点回顾

1. 类的装饰器
2. 装饰器思想的进一步理解：外部修改、动态
3. 类方法的定义：内部定义和外部定义

作业：复习类和函数的知识点，写下自己过去29天的学习心得，如对函数和类的理解，对python这门工具的理解等，未来再过几个专题部分我们即将开启深度学习部分。

一、类的装饰器

①为类添加版本信息

def add_version(cls):
    cls.version = "1.0.0"
    return cls

@add_version
class MyClass:
    pass

print(MyClass.version)  # 输出：1.0.0

②强制检查类方法实现

def check_interface(cls):
    required = ['save', 'load']
    for method in required:
        if not hasattr(cls, method):
            raise NotImplementedError(f"{method}() 必须被实现")
    return cls

@check_interface
class DataProcessor:
    def save(self):
        pass

    # 若未实现load()，装饰器会抛出异常
    def load(self):
        pass

③单例模式装饰器

def singleton(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class AppConfig:
    def __init__(self):
        print("配置初始化")

c1 = AppConfig()  # 输出：配置初始化
c2 = AppConfig()
print(c1 is c2)   # 输出：True

二、装饰器思想：外部修改与动态特性

①动态日志记录

def log_creation(cls):
    original_init = cls.__init__
    def new_init(self, *args, **kwargs):
        print(f"创建 {cls.__name__} 实例")
        original_init(self, *args, **kwargs)
    cls.__init__ = new_init
    return cls

@log_creation
class User:
    def __init__(self, name):
        self.name = name

u = User("Alice")  # 输出：创建 User 实例

②条件性装饰器应用

DEBUG = True

def debug_decorator(cls):
    if DEBUG:
        cls.debug_mode = True
        print(f"{cls.__name__} 进入调试模式")
    return cls

@debug_decorator
class DataLoader:
    pass

print(DataLoader.debug_mode)  # 输出：True

三、类方法的定义方式

①内部定义类方法

class Calculator:
    @classmethod
    def add(cls, a, b):
        return a + b

print(Calculator.add(3,5))  # 输出：8

②外部添加类方法

def multiply(cls, a, b):
    return a * b

Calculator.multiply = classmethod(multiply)
print(Calculator.multiply(3,5))  # 输出：15

③外部添加实例方法

def power(self, exponent):
    return self.value ** exponent

class Number:
    def __init__(self, value):
        self.value = value

Number.power = power

n = Number(2)
print(n.power(3))  # 输出：8

四、综合应用

# 装饰器：自动注册子类
class ProcessorRegistry:
    registry = {}
    
    @classmethod
    def register(cls, name):
        def decorator(subclass):
            cls.registry[name] = subclass
            return subclass
        return decorator

@ProcessorRegistry.register("csv")
class CSVProcessor:
    @classmethod
    def process(cls, data):
        return f"处理CSV数据: {data}"

# 外部添加处理方法
def json_process(cls, data):
    return f"处理JSON数据: {data}"

@ProcessorRegistry.register("json")
class JSONProcessor:
    process = classmethod(json_process)

# 使用处理器
print(ProcessorRegistry.registry["csv"].process("test.csv"))  # 处理CSV数据
print(ProcessorRegistry.registry["json"].process("data.json")) # 处理JSON数据

关键点总结：

1. 类装饰器：通过包装类实现批量功能注入

2. 装饰器优势：非侵入式修改、动态组合功能

3. 方法扩展：

   • 内部定义：标准方式，结构清晰

   • 外部添加：灵活扩展，适合框架开发

4. 动态特性：运行时决定功能组合，提升代码适应性

通过合理运用这些特性，可以构建出高扩展性和低耦合度的程序架构。