Python学习--MetaClass(元类)详解②

class LoggingMeta(type):    """日志记录元类：自动为方法添加日志"""    def __new__(mcs, name, bases, attrs):        # 遍历所有方法        for attr_name, attr_value in attrs.items():            if callable(attr_value) and not attr_name.startswith('_'):                # 包装方法，添加日志                attrs[attr_name] = mcs.add_logging(attr_name, attr_value)        return super().__new__(mcs, name, bases, attrs)    @staticmethod    def add_logging(method_name, method):        """为方法添加日志装饰器"""        def wrapper(self, *args, **kwargs):            print(f"📝 [{self.__class__.__name__}.{method_name}] 开始执行")            print(f"   参数: args={args}, kwargs={kwargs}")            try:                result = method(self, *args, **kwargs)                print(f"   ✅ 执行成功，结果: {result}")                return result            except Exception as e:                print(f"   ❌ 执行失败，异常: {e}")                raise        # 复制原方法的名称和文档        wrapper.__name__ = method_name        wrapper.__doc__ = method.__doc__        return wrapperclass DataProcessor(metaclass=LoggingMeta):    """数据处理类（自动添加日志）"""    def process_data(self, data):        """处理数据"""        return [x * 2 for x in data if x > 0]    def validate(self, value, min_val, max_val):        """验证值是否在范围内"""        if min_val <= value <= max_val:            return True        raise ValueError(f"值 {value} 不在范围 [{min_val}, {max_val}] 内")    def _private_method(self):        """私有方法，不会添加日志"""        return "这是私有方法"# 使用print("自动日志记录演示:")print("=" * 50)processor = DataProcessor()print("\n1. 调用 process_data 方法:")result = processor.process_data([1, -2, 3, 0, 5])print(f"最终结果: {result}")print("\n2. 调用 validate 方法（成功）:")try:    processor.validate(5, 0, 10)except ValueError as e:    print(f"验证失败: {e}")print("\n3. 调用 validate 方法（失败）:")try:    processor.validate(15, 0, 10)except ValueError as e:    print(f"验证失败: {e}")print("\n4. 调用私有方法（无日志）:")result = processor._private_method()print(f"私有方法结果: {result}")

class ValidationMeta(type):    """验证元类：自动验证方法和属性"""    def __new__(mcs, name, bases, attrs):        # 添加验证规则        validation_rules = {}        for attr_name, attr_value in attrs.items():            # 收集验证器            if attr_name.endswith('_validator'):                field_name = attr_name[:-10]                validation_rules[field_name] = attr_value            # 为方法添加参数验证            elif callable(attr_value) and hasattr(attr_value, '_validators'):                attrs[attr_name] = mcs.wrap_with_validation(attr_value)        # 修改__init__，添加属性验证        if '__init__' in attrs:            original_init = attrs['__init__']            attrs['__init__'] = mcs.wrap_init(original_init, validation_rules)        return super().__new__(mcs, name, bases, attrs)    @staticmethod    def wrap_with_validation(method):        """包装方法，添加参数验证"""        def wrapper(self, *args, **kwargs):            # 获取验证规则            validators = getattr(method, '_validators', {})            # 验证位置参数            for i, (arg_name, validator) in enumerate(validators.items()):                if i < len(args):                    validator(args[i])                elif arg_name in kwargs:                    validator(kwargs[arg_name])            return method(self, *args, **kwargs)        wrapper.__name__ = method.__name__        wrapper.__doc__ = method.__doc__        return wrapper    @staticmethod    def wrap_init(original_init, validation_rules):        """包装__init__，添加属性验证"""        def wrapper(self, *args, **kwargs):            # 先调用原始__init__            original_init(self, *args, **kwargs)            # 验证所有属性            for field_name, validator in validation_rules.items():                if hasattr(self, field_name):                    value = getattr(self, field_name)                    if value is not None:                        validator(value)        wrapper.__name__ = original_init.__name__        wrapper.__doc__ = original_init.__doc__        return wrapper# 验证器函数def validate_int(value):    if not isinstance(value, int):        raise TypeError(f"必须是整数，得到 {type(value).__name__}")def validate_str(value):    if not isinstance(value, str):        raise TypeError(f"必须是字符串，得到 {type(value).__name__}")    if len(value.strip()) == 0:        raise ValueError("字符串不能为空")def validate_age(value):    validate_int(value)    if value < 0 or value > 150:        raise ValueError(f"年龄必须在0-150之间，得到 {value}")def validate_email(value):    validate_str(value)    if '@' not in value:        raise ValueError(f"邮箱格式不正确: {value}")# 参数验证装饰器def validate_param(**validators):    """方法参数验证装饰器"""    def decorator(method):        method._validators = validators        return method    return decorator# 使用元类的类class Person(metaclass=ValidationMeta):    """人员类（自动验证）"""    # 属性验证器    age_validator = validate_age    email_validator = validate_email    name_validator = validate_str    def __init__(self, name, age, email=None):        self.name = name        self.age = age        self.email = email    @validate_param(value=validate_int, min_val=validate_int, max_val=validate_int)    def is_between(self, value, min_val, max_val):        """检查值是否在范围内"""        return min_val <= value <= max_val# 使用print("自动验证演示:")print("=" * 50)print("\n1. 创建有效的Person:")try:    person = Person("张三", 25, "zhang@example.com")    print(f"  创建成功: {person.name}, {person.age}, {person.email}")except (ValueError, TypeError) as e:    print(f"  创建失败: {e}")print("\n2. 创建无效的Person（年龄错误）:")try:    person = Person("李四", -5, "li@example.com")    print(f"  创建成功")except (ValueError, TypeError) as e:    print(f"  创建失败: {e}")print("\n3. 创建无效的Person（邮箱错误）:")try:    person = Person("王五", 30, "invalid-email")    print(f"  创建成功")except (ValueError, TypeError) as e:    print(f"  创建失败: {e}")print("\n4. 使用方法验证:")try:    result = person.is_between(10, 0, 20)    print(f"  验证结果: {result}")except (ValueError, TypeError) as e:    print(f"  验证失败: {e}")print("\n5. 方法参数验证失败:")try:    result = person.is_between("not_a_number", 0, 20)    print(f"  验证结果: {result}")except (ValueError, TypeError) as e:    print(f"  验证失败: {e}")

class MetaA(type):    def __new__(mcs, name, bases, attrs):        print(f"【MetaA】创建类: {name}")        attrs['from_meta_a'] = True        return super().__new__(mcs, name, bases, attrs)class MetaB(type):    def __new__(mcs, name, bases, attrs):        print(f"【MetaB】创建类: {name}")        attrs['from_meta_b'] = True        return super().__new__(mcs, name, bases, attrs)# 元类组合（通过继承）class CombinedMeta(MetaA, MetaB):    """组合多个元类"""    def __new__(mcs, name, bases, attrs):        print(f"【CombinedMeta】创建类: {name}")        # 调用所有父元类        for base in mcs.__bases__:            if base is not type:                cls = base.__new__(base, name, bases, attrs)                attrs.update(cls.__dict__)        return super().__new__(mcs, name, bases, attrs)class MyClass(metaclass=CombinedMeta):    passprint(f"\nMyClass属性:")print(f"  from_meta_a: {getattr(MyClass, 'from_meta_a', False)}")print(f"  from_meta_b: {getattr(MyClass, 'from_meta_b', False)}")# 注意：多重继承元类要小心MRO问题print(f"\n元类MRO: {CombinedMeta.__mro__}")

import timedef test_metaclass_performance():    """测试元类性能"""    class SimpleMeta(type):        def __new__(mcs, name, bases, attrs):            return super().__new__(mcs, name, bases, attrs)    # 测试1：使用元类创建类    start = time.time()    for i in range(10000):        class_name = f"DynamicClass{i}"        DynamicClass = type(class_name, (), {})    time_type = time.time() - start    # 测试2：使用自定义元类创建类    start = time.time()    for i in range(10000):        class_name = f"MetaClass{i}"        MetaClass = SimpleMeta(class_name, (), {})    time_meta = time.time() - start    # 测试3：使用复杂元类创建类    class ComplexMeta(type):        def __new__(mcs, name, bases, attrs):            # 复杂操作            attrs['processed'] = True            for key in list(attrs.keys()):                if not key.startswith('_'):                    attrs[f'_{key}'] = attrs[key]            return super().__new__(mcs, name, bases, attrs)    start = time.time()    for i in range(10000):        class_name = f"ComplexClass{i}"        ComplexClass = ComplexMeta(class_name, (), {'x': i})    time_complex = time.time() - start    print("元类性能测试 (创建10000个类):")    print("=" * 50)    print(f"使用type():         {time_type:.4f}秒")    print(f"使用简单元类:       {time_meta:.4f}秒")    print(f"使用复杂元类:       {time_complex:.4f}秒")    print(f"\n性能比较:")    print(f"  简单元类 vs type:  {time_meta/time_type:.1f}倍")    print(f"  复杂元类 vs type:  {time_complex/time_type:.1f}倍")test_metaclass_performance()

"""✅ 适合使用元类的场景：1. 框架开发：ORM、Web框架、插件系统等2. API设计：自动注册、验证、序列化3. 代码生成：根据配置动态生成类4. 接口约束：强制子类实现特定方法5. 单例模式：确保类只有一个实例❌ 不适合使用元类的场景：1. 简单业务逻辑：普通类足够2. 性能敏感：元类有额外开销3. 团队协作：增加理解难度4. 过度设计：KISS原则（Keep It Simple, Stupid）📝 最佳实践：1. 提供清晰的文档和示例2. 保持元类简单和透明3. 优先使用类装饰器（如果可能）4. 考虑向后兼容性5. 充分测试元类行为"""