深入 Python 元类：对象世界的「造物主」（从代码实例到底层原理，彻底搞懂 Python 的「元编程」魔法）

# 函数定义
def func_a(x: int):
    return x * 2

def func_b(x: int):
    z = 50
    res = func_a(z + x)
    return res

# 类继承与MRO
class A:
    def say(self):
        print("i'm A")

class B(A):
    def say(self):
        print("im B")

class C(A):
    def say(self):
        print('im C')

class D(B, C):
    def say(self):
        super().say()

# 运行结果
d = D()
d.say()  # 输出：im B？不！输出：im B？等下看MRO…
mro = D.mro()
print(mro)  # 输出：[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

d = D()  # d是D类的实例
x = func_a(10)  # x是func_a的返回值实例

# 验证：类本身是对象
print(type(D))  # 输出：<class 'type'>
print(isinstance(D, object))  # 输出：True

type(类名, 父类元组, 属性与方法字典)

# 创建基类A
A = type('A', (object,), {
    'say': lambda self: print("i'm A")
})

# 创建B类，继承自A
B = type('B', (A,), {
    'say': lambda self: print("im B")
})

# 创建C类，继承自A
C = type('C', (A,), {
    'say': lambda self: print('im C')
})

# 创建D类，继承自B和C
D = type('D', (B, C), {
    'say': lambda self: super().say()
})

# 测试
d = D()
d.say()  # 输出：im B
print(D.mro())  # 输出：[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

class MyMetaclass(type):
    # 在类创建前被调用
    def __new__(cls, name, bases, attrs):
        print(f"正在创建类：{name}")
        print(f"父类：{bases}")
        print(f"属性和方法：{attrs}")
        # 必须返回创建好的类
        return super().__new__(cls, name, bases, attrs)
    
    # 在类创建后被调用
    def __init__(cls, name, bases, attrs):
        print(f"已创建类：{cls}")
        # 可以在这里添加类的属性或方法
        cls.version = "1.0"
        super().__init__(name, bases, attrs)

# 使用自定义元类创建类
class MyClass(metaclass=MyMetaclass):
    def __init__(self, name):
        self.name = name
    
    def say(self):
        print(f"Hello, {self.name}")

# 测试
print(f"类版本：{MyClass.version}")  # 输出：类版本：1.0
obj = MyClass("Alice")
obj.say()  # 输出：Hello, Alice

class UppercaseMetaclass(type):
    def __new__(cls, name, bases, attrs):
        # 强制类名首字母大写
        if not name[0].isupper():
            raise ValueError(f"类名必须首字母大写，当前类名：{name}")
        return super().__new__(cls, name, bases, attrs)

# 正确的类名
class Person(metaclass=UppercaseMetaclass):
    pass

# 错误的类名（会抛出异常）
# class person(metaclass=UppercaseMetaclass):
#     pass

class RegistryMetaclass(type):
    # 类变量，用于存储所有子类
    registry = {}
    
    def __new__(cls, name, bases, attrs):
        # 创建类
        new_class = super().__new__(cls, name, bases, attrs)
        # 如果不是基类，则注册
        if bases:
            cls.registry[name] = new_class
        return new_class

# 基类
class BasePlugin(metaclass=RegistryMetaclass):
    def execute(self):
        pass

# 子类1
class PluginA(BasePlugin):
    def execute(self):
        print("PluginA执行")

# 子类2
class PluginB(BasePlugin):
    def execute(self):
        print("PluginB执行")

# 测试：自动注册
print(f"所有插件：{RegistryMetaclass.registry}")  # 输出：所有插件：{'PluginA': <class '__main__.PluginA'>, 'PluginB': <class '__main__.PluginB'>}

# 批量执行所有插件
for plugin_name, plugin_class in RegistryMetaclass.registry.items():
    plugin = plugin_class()
    plugin.execute()  # 输出：PluginA执行；PluginB执行

# 检查实例
print(isinstance(d, D))  # True
print(isinstance(d, B))  # True
print(isinstance(d, C))  # True
print(isinstance(d, A))  # True
print(isinstance(d, object))  # True

# 检查类
print(issubclass(D, B))  # True
print(issubclass(D, C))  # True
print(issubclass(D, A))  # True
print(issubclass(D, object))  # True
print(issubclass(B, C))  # False（B和C都是A的子类）

print(type(object))  # 输出：<class 'type'>
print(isinstance(type, object))  # 输出：True
print(isinstance(object, type))  # 输出：True