200_Python元编程metaclass¶

# type是万物之源
print(type(42))        # <class 'int'>
print(type(int))       # <class 'type'>
print(type(type))      # <class 'type'>

# type动态创建类
# type(name, bases, attrs) 等价于 class语句
MyClass = type('MyClass', (object,), {
    'x': 42,
    'greet': lambda self: f"Hello from {self.__class__.__name__}"
})

obj = MyClass()
print(obj.greet())  # Hello from MyClass

# 等价的class语句
class MyClass:
    x = 42
    def greet(self):
        return f"Hello from {self.__class__.__name__}"

class ValidatedMeta(type):
    """验证类定义的元类"""

    def __new__(mcs, name, bases, namespace):
        # 在类创建时执行验证
        # 要求所有方法都有文档字符串
        for key, value in namespace.items():
            if callable(value) and not key.startswith('_'):
                if not getattr(value, '__doc__', None):
                    raise TypeError(f"方法 {name}.{key} 缺少文档字符串")

        cls = super().__new__(mcs, name, bases, namespace)
        return cls

class MyAPI(metaclass=ValidatedMeta):
    def fetch_data(self):
        """获取数据"""  # 有文档字符串，OK
        return []

# class BadAPI(metaclass=ValidatedMeta):
#     def fetch_data(self):  # 没有文档字符串，会报TypeError
#         return []

# 注册模式元类
class PluginRegistry(type):
    """自动注册所有子类"""
    _plugins = {}

    def __new__(mcs, name, bases, namespace):
        cls = super().__new__(mcs, name, bases, namespace)
        if bases:  # 不注册基类本身
            mcs._plugins[name] = cls
        return cls

    @classmethod
    def get_plugins(mcs):
        return dict(mcs._plugins)

class Plugin(metaclass=PluginRegistry):
    pass

class CSVPlugin(Plugin):
    def load(self): return "CSV data"

class JSONPlugin(Plugin):
    def load(self): return "JSON data"

print(PluginRegistry.get_plugins())
# {'CSVPlugin': <class 'CSVPlugin'>, 'JSONPlugin': <class 'JSONPlugin'>}

class Registrable:
    """使用__init_subclass__自动注册子类"""
    _registry = {}

    def __init_subclass__(cls, register_as=None, **kwargs):
        super().__init_subclass__(**kwargs)
        name = register_as or cls.__name__
        Registrable._registry[name] = cls

    @classmethod
    def create(cls, name, *args, **kwargs):
        return cls._registry[name](*args, **kwargs)

class TextHandler(Registrable, register_as="text"):
    def process(self): return "Processing text"

class ImageHandler(Registrable, register_as="image"):
    def process(self): return "Processing image"

handler = Registrable.create("text")
print(handler.process())  # Processing text
print(Registrable._registry)  # {'text': TextHandler, 'image': ImageHandler}

class Field:
    def __init__(self, field_type, required=True, default=None):
        self.field_type = field_type
        self.required = required
        self.default = default

class ModelMeta(type):
    def __new__(mcs, name, bases, namespace):
        fields = {}
        for key, value in namespace.items():
            if isinstance(value, Field):
                fields[key] = value

        namespace['_fields'] = fields
        cls = super().__new__(mcs, name, bases, namespace)
        return cls

class Model(metaclass=ModelMeta):
    def __init__(self, **kwargs):
        for name, field in self._fields.items():
            value = kwargs.get(name, field.default)
            if field.required and value is None:
                raise ValueError(f"字段 {name} 是必填的")
            if value is not None and not isinstance(value, field.field_type):
                raise TypeError(f"字段 {name} 期望 {field.field_type.__name__}")
            setattr(self, name, value)

    def to_dict(self):
        return {name: getattr(self, name) for name in self._fields}

class User(Model):
    name = Field(str, required=True)
    age = Field(int, required=False, default=0)
    email = Field(str, required=True)

user = User(name="Alice", age=30, email="alice@example.com")
print(user.to_dict())  # {'name': 'Alice', 'age': 30, 'email': 'alice@example.com'}

# 动态创建类
MyClass = type('MyClass', (BaseClass,), {'method': lambda self: 42})

# 元类
class Meta(type):
    def __new__(mcs, name, bases, ns): return super().__new__(mcs, name, bases, ns)
class MyClass(metaclass=Meta): pass

# 现代替代：__init_subclass__
class Base:
    def __init_subclass__(cls, **kwargs): print(f"New subclass: {cls.__name__}")

# 抽象基类
from abc import ABC, abstractmethod
class Interface(ABC):
    @abstractmethod
    def method(self): ...