# 查看類的類型
class MyClass:
    pass
obj = MyClass()
print(type(obj))      # <class '__main__.MyClass'>
print(type(MyClass))  # <class 'type'>

# 這兩者是等價(jià)的
# 方式1：class關(guān)鍵字
class MyClass:
    x = 1
    def method(self):
        return "hello"
# 方式2：直接調(diào)用type (不推薦日常用，但有助于理解原理)
MyClass = type('MyClass', (), {'x': 1, 'method': lambda self: "hello"})

class MyMeta(type):
    """最簡單的元類"""
    pass
# 使用元類創(chuàng)建類
class MyClass(metaclass=MyMeta):
    x = 1
print(type(MyClass))  # <class '__main__.MyMeta'>

class MyMeta(type):
    def __new__(mcs, name, bases, namespace, **kwargs):
        """控制類的創(chuàng)建"""
        print(f"1. __new__: 創(chuàng)建類 {name}")
        # 可以修改namespace（類的屬性和方法）
        namespace['created_by'] = 'MyMeta'
        return super().__new__(mcs, name, bases, namespace)
    def __init__(cls, name, bases, namespace, **kwargs):
        """初始化類"""
        print(f"2. __init__: 初始化類 {name}")
        super().__init__(name, bases, namespace)
    def __call__(cls, *args, **kwargs):
        """控制實(shí)例的創(chuàng)建"""
        print(f"3. __call__: 創(chuàng)建 {cls.__name__} 的實(shí)例")
        return super().__call__(*args, **kwargs)
class Person(metaclass=MyMeta):
    def __init__(self, name):
        self.name = name
# 輸出：
# 1. __new__: 創(chuàng)建類 Person
# 2. __init__: 初始化類 Person
p = Person("Alice")
# 輸出：
# 3. __call__: 創(chuàng)建 Person 的實(shí)例

class PluginMeta(type):
    """自動注冊插件的元類"""
    registry = {}
    def __new__(mcs, name, bases, namespace):
        cls = super().__new__(mcs, name, bases, namespace)
        if name != 'BasePlugin':  # 排除基類
            PluginMeta.registry[name] = cls
        return cls
class BasePlugin(metaclass=PluginMeta):
    pass
class EmailPlugin(BasePlugin):
    pass
class SMSPlugin(BasePlugin):
    pass
# 自動收集
print(PluginMeta.registry)
# {'EmailPlugin': <class '__main__.EmailPlugin'>, 
#  'SMSPlugin': <class '__main__.SMSPlugin'>}

class NamingConventionMeta(type):
    """強(qiáng)制類名使用駝峰命名法"""
    def __new__(mcs, name, bases, namespace):
        if name != name.title().replace('_', ''):
            raise ValueError(f"類名 '{name}' 不符合駝峰命名規(guī)范")
        return super().__new__(mcs, name, bases, namespace)
# 正確
class GoodName(metaclass=NamingConventionMeta):
    pass
# 錯(cuò)誤，會報(bào)錯(cuò)
# class bad_name(metaclass=NamingConventionMeta):
#     pass

class SingletonMeta(type):
    """單例元類"""
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]
class Database(metaclass=SingletonMeta):
    def __init__(self, connection_string):
        self.connection = connection_string
db1 = Database("mysql://localhost")
db2 = Database("postgresql://remote")
print(db1 is db2)  # True
print(db1.connection)  # mysql://localhost (第一次的值)

class Field:
    def __init__(self, name, field_type):
        self.name = name
        self.type = field_type
class ModelMeta(type):
    """ORM風(fēng)格的元類"""
    def __new__(mcs, name, bases, namespace):
        # 收集Field定義
        fields = {k: v for k, v in namespace.items() if isinstance(v, Field)}
        namespace['_fields'] = fields
        return super().__new__(mcs, name, bases, namespace)
class Model(metaclass=ModelMeta):
    pass
class User(Model):
    id = Field('id', 'INT')
    name = Field('name', 'VARCHAR')
    email = Field('email', 'VARCHAR')
print(User._fields)
# {'id': Field object, 'name': Field object, 'email': Field object}

# 裝飾器方式
@my_decorator
class MyClass:
    pass
# 元類方式（影響繼承鏈）
class MyClass(metaclass=MyMeta):
    pass
class Child(MyClass):  # 自動繼承MyMeta
    pass

class Meta1(type):
    pass
class Meta2(type):
    pass
class A(metaclass=Meta1):
    pass
class B(metaclass=Meta2):
    pass
# 會報(bào)錯(cuò)：TypeError: metaclass conflict
# class C(A, B):
#     pass

class UnifiedMeta(Meta1, Meta2):
    pass
class C(A, B, metaclass=UnifiedMeta):
    pass