class SimpleClass:
    pass

# 類(lèi)也是對(duì)象，有類(lèi)型、可傳遞
print(type(SimpleClass))  # <class 'type'>
print(isinstance(SimpleClass, type))  # True

# 1. 作為類(lèi)型檢查函數(shù)
num = 42
print(type(num))  # <class 'int'>

# 2. 作為所有類(lèi)的默認(rèn)元類(lèi)
class MyClass:
    pass
print(type(MyClass))  # <class 'type'>

# 3. 作為類(lèi)工廠(chǎng)函數(shù)，動(dòng)態(tài)創(chuàng)建類(lèi)
DynamicClass = type('DynamicClass', (object,), {'attr': 100})
instance = DynamicClass()
print(instance.attr)  # 100

class CustomNamespaceMeta(type):
    @classmethod
    def __prepare__(cls, name, bases, **kwargs):
        """返回一個(gè)自定義的映射對(duì)象，用于存儲(chǔ)類(lèi)屬性"""
        print(f"準(zhǔn)備命名空間 for {name}")
        # 返回OrderedDict而不是普通dict，保持屬性順序
        from collections import OrderedDict
        return OrderedDict()
    
    def __new__(cls, name, bases, namespace, **kwargs):
        print(f"創(chuàng)建類(lèi) {name}，屬性: {list(namespace.keys())}")
        return super().__new__(cls, name, bases, namespace)
    
    def __init__(self, name, bases, namespace, **kwargs):
        print(f"初始化類(lèi) {name}")
        super().__init__(name, bases, namespace)

class PreparedClass(metaclass=CustomNamespaceMeta):
    attribute1 = "first"
    attribute2 = "second"
    def method(self):
        return "method"

# 輸出顯示屬性按定義順序處理

def class_factory(class_name, attributes=None, bases=None, metaclass=type):
    """
    通用類(lèi)工廠(chǎng)函數(shù)：根據(jù)參數(shù)動(dòng)態(tài)創(chuàng)建類(lèi)
    
    參數(shù):
        class_name: 類(lèi)名
        attributes: 類(lèi)屬性和方法字典
        bases: 基類(lèi)元組
        metaclass: 使用的元類(lèi)
    """
    attributes = attributes or {}
    bases = bases or (object,)
    
    # 添加通用方法
    attributes.setdefault('__repr__', lambda self: f'<{class_name} {id(self)}>')
    attributes.setdefault('to_dict', lambda self: self.__dict__.copy())
    
    # 使用元類(lèi)創(chuàng)建類(lèi)
    return metaclass(class_name, bases, attributes)

# 使用類(lèi)工廠(chǎng)創(chuàng)建不同的類(lèi)
Person = class_factory('Person', {'species': 'human'})
Car = class_factory('Car', {'wheels': 4}, bases=(object,))

# 測(cè)試動(dòng)態(tài)創(chuàng)建的類(lèi)
john = Person()
john.name = 'John'  # 動(dòng)態(tài)添加屬性
print(john.species)  # human
print(john.to_dict())  # {'name': 'John'}

ford = Car()
print(ford.wheels)  # 4

class InterfaceMeta(type):
    """接口驗(yàn)證元類(lèi)：確保子類(lèi)實(shí)現(xiàn)必需的方法"""
    
    required_methods = ['save', 'delete', 'validate']  # 必需方法列表
    
    def __init__(cls, name, bases, namespace):
        # 跳過(guò)對(duì)基類(lèi)本身的檢查
        if bases != (object,) and name != 'BaseModel':
            missing_methods = []
            for method in cls.required_methods:
                if not hasattr(cls, method) or not callable(getattr(cls, method)):
                    missing_methods.append(method)
            
            if missing_methods:
                raise TypeError(f"類(lèi) {name} 必須實(shí)現(xiàn)方法: {', '.join(missing_methods)}")
        
        super().__init__(name, bases, namespace)

class BaseModel(metaclass=InterfaceMeta):
    """抽象基類(lèi)，定義接口但不實(shí)現(xiàn)"""
    pass

# 測(cè)試接口驗(yàn)證
try:
    class UserModel(BaseModel):
        # 缺少必需方法，應(yīng)該報(bào)錯(cuò)
        pass
except TypeError as e:
    print(f"預(yù)期錯(cuò)誤: {e}")

# 正確實(shí)現(xiàn)
class ProductModel(BaseModel):
    def save(self):
        print("保存產(chǎn)品")
    
    def delete(self):
        print("刪除產(chǎn)品")
    
    def validate(self):
        print("驗(yàn)證產(chǎn)品")
        return True

# 這個(gè)類(lèi)能正常創(chuàng)建
product_model = ProductModel()

class RegistryMeta(type):
    """自動(dòng)注冊(cè)元類(lèi)：將類(lèi)自動(dòng)添加到注冊(cè)表"""
    
    # 類(lèi)注冊(cè)表
    registry = {}
    
    def __init__(cls, name, bases, namespace):
        super().__init__(name, bases, namespace)
        
        # 跳過(guò)抽象基類(lèi)
        if not getattr(cls, '__abstract__', False):
            # 使用類(lèi)名作為鍵，但可自定義邏輯
            registry_key = getattr(cls, '__registry_key__', name)
            if registry_key in RegistryMeta.registry:
                raise KeyError(f"注冊(cè)鍵沖突: {registry_key}")
            
            RegistryMeta.registry[registry_key] = cls
            print(f"注冊(cè)類(lèi): {name} -> {registry_key}")

class PluginBase(metaclass=RegistryMeta):
    """插件基類(lèi)"""
    __abstract__ = True  # 標(biāo)記為抽象，不注冊(cè)

class DatabasePlugin(PluginBase):
    __registry_key__ = 'db'  # 自定義注冊(cè)鍵
    
    def execute(self, query):
        return f"執(zhí)行: {query}"

class APIPlugin(PluginBase):
    # 使用類(lèi)名作為注冊(cè)鍵
    def handle_request(self, request):
        return f"處理: {request}"

# 查看自動(dòng)注冊(cè)結(jié)果
print("注冊(cè)表內(nèi)容:", RegistryMeta.registry.keys())

# 通過(guò)注冊(cè)表使用類(lèi)
db_plugin = RegistryMeta.registry['db']()
result = db_plugin.execute("SELECT * FROM users")
print(result)

import sqlite3
from typing import Dict, Any, Optional

class ModelMeta(type):
    """ORM元類(lèi)：將類(lèi)屬性映射到數(shù)據(jù)庫(kù)字段"""
    
    def __new__(cls, name, bases, namespace):
        # 收集字段定義
        fields = {}
        for key, value in namespace.items():
            if isinstance(value, Field):
                fields[key] = value
                value.name = key  # 設(shè)置字段名
        
        # 添加元數(shù)據(jù)
        namespace['_fields'] = fields
        namespace['_tablename'] = namespace.get('__tablename__', name.lower())
        
        # 添加數(shù)據(jù)庫(kù)方法
        if 'save' not in namespace:
            namespace['save'] = cls._save_method
        if 'delete' not in namespace:
            namespace['delete'] = cls._delete_method
        
        return super().__new__(cls, name, bases, namespace)
    
    def _save_method(self):
        """自動(dòng)生成的save方法"""
        if getattr(self, 'id', None) is None:
            # INSERT操作
            field_names = [f for f in self._fields if getattr(self, f) is not None]
            placeholders = ', '.join(['?' for _ in field_names])
            columns = ', '.join(field_names)
            values = [getattr(self, f) for f in field_names]
            
            sql = f"INSERT INTO {self._tablename} ({columns}) VALUES ({placeholders})"
            print(f"執(zhí)行: {sql} with {values}")
            # 實(shí)際執(zhí)行數(shù)據(jù)庫(kù)操作...
            self.id = 1  # 模擬生成的ID
        else:
            # UPDATE操作
            updates = ', '.join([f"{f} = ?" for f in self._fields if getattr(self, f) is not None])
            values = [getattr(self, f) for f in self._fields if getattr(self, f) is not None]
            values.append(self.id)
            
            sql = f"UPDATE {self._tablename} SET {updates} WHERE id = ?"
            print(f"執(zhí)行: {sql} with {values}")
    
    def _delete_method(self):
        """自動(dòng)生成的delete方法"""
        if hasattr(self, 'id'):
            sql = f"DELETE FROM {self._tablename} WHERE id = ?"
            print(f"執(zhí)行: {sql} with [{self.id}]")

class Field:
    """字段描述符"""
    def __init__(self, field_type=str, required=True, default=None):
        self.field_type = field_type
        self.required = required
        self.default = default
        self.name = None  # 在元類(lèi)中設(shè)置
    
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__.get(self.name, self.default)
    
    def __set__(self, instance, value):
        if value is not None and not isinstance(value, self.field_type):
            raise TypeError(f"字段 {self.name} 必須是 {self.field_type} 類(lèi)型")
        instance.__dict__[self.name] = value

class Model(metaclass=ModelMeta):
    """模型基類(lèi)"""
    id = Field(int, required=False)

class User(Model):
    __tablename__ = 'users'  # 自定義表名
    
    name = Field(str)
    email = Field(str)
    age = Field(int, required=False, default=0)

# 使用ORM系統(tǒng)
user = User()
user.name = "張三"
user.email = "zhang@example.com"
user.age = 30

user.save()  # 自動(dòng)生成SQL

user.age = 31
user.save()  # 更新操作

print(f"用戶(hù)ID: {user.id}")

import inspect
from typing import Dict, Callable

class RouteMeta(type):
    """API路由元類(lèi)：自動(dòng)將方法映射到路由"""
    
    def __init__(cls, name, bases, namespace):
        super().__init__(name, bases, namespace)
        
        # 跳過(guò)基類(lèi)
        if name == 'BaseAPI':
            return
        
        # 收集路由信息
        cls.routes = []
        for attr_name, attr_value in namespace.items():
            if inspect.isfunction(attr_value) and hasattr(attr_value, '_route'):
                route_info = attr_value._route
                route_info['handler'] = attr_value
                route_info['method_name'] = attr_name
                cls.routes.append(route_info)
        
        print(f"類(lèi) {name} 注冊(cè)了 {len(cls.routes)} 個(gè)路由")

def route(path, methods=None):
    """路由裝飾器工廠(chǎng)"""
    if methods is None:
        methods = ['GET']
    
    def decorator(func):
        func._route = {
            'path': path,
            'methods': methods
        }
        return func
    
    return decorator

class BaseAPI(metaclass=RouteMeta):
    """API基類(lèi)"""
    pass

class UserAPI(BaseAPI):
    @route('/users', methods=['GET'])
    def list_users(self):
        return "用戶(hù)列表"
    
    @route('/users/<int:user_id>', methods=['GET'])
    def get_user(self, user_id):
        return f"用戶(hù) {user_id}"
    
    @route('/users', methods=['POST'])
    def create_user(self):
        return "創(chuàng)建用戶(hù)"

# 模擬路由注冊(cè)
for route_info in UserAPI.routes:
    print(f"注冊(cè)路由: {route_info['methods']} {route_info['path']} -> {route_info['method_name']}")

# 模擬請(qǐng)求處理
def handle_request(path, method):
    api_instance = UserAPI()
    for route_info in UserAPI.routes:
        if (path == route_info['path'] and 
            method in route_info['methods']):
            handler = route_info['handler']
            # 簡(jiǎn)化參數(shù)提取
            if '<int:user_id>' in path:
                user_id = path.split('/')[-1]  # 簡(jiǎn)化提取
                return handler(api_instance, int(user_id))
            return handler(api_instance)
    return "404 Not Found"

# 測(cè)試路由系統(tǒng)
print(handle_request('/users', 'GET'))  # 用戶(hù)列表
print(handle_request('/users/123', 'GET'))  # 用戶(hù) 123

import timeit
import time

class SimpleClass:
    """普通類(lèi)作為基準(zhǔn)"""
    def __init__(self, value):
        self.value = value

class MetaClass(type):
    """有基本功能的元類(lèi)"""
    def __new__(cls, name, bases, namespace):
        return super().__new__(cls, name, bases, namespace)
    
    def __init__(cls, name, bases, namespace):
        super().__init__(name, bases, namespace)

class ClassWithMeta(metaclass=MetaClass):
    """使用元類(lèi)的類(lèi)"""
    def __init__(self, value):
        self.value = value

def performance_benchmark():
    """性能基準(zhǔn)測(cè)試"""
    iterations = 100000
    
    # 測(cè)試類(lèi)創(chuàng)建開(kāi)銷(xiāo)
    simple_class_time = timeit.timeit(
        'class SimpleClass: pass', 
        number=iterations
    )
    
    meta_class_time = timeit.timeit(
        'class ClassWithMeta(metaclass=MetaClass): pass', 
        number=iterations,
        globals=globals()
    )
    
    # 測(cè)試實(shí)例化開(kāi)銷(xiāo)
    simple_instance_time = timeit.timeit(
        'SimpleClass(42)', 
        number=iterations,
        globals=globals()
    )
    
    meta_instance_time = timeit.timeit(
        'ClassWithMeta(42)', 
        number=iterations,
        globals=globals()
    )
    
    print("元類(lèi)性能開(kāi)銷(xiāo)分析 (100,000次操作):")
    print(f"類(lèi)定義 - 普通: {simple_class_time:.4f}s")
    print(f"類(lèi)定義 - 元類(lèi): {meta_class_time:.4f}s")
    print(f"類(lèi)定義開(kāi)銷(xiāo): {meta_class_time/simple_class_time:.2f}x")
    
    print(f"實(shí)例化 - 普通: {simple_instance_time:.4f}s")
    print(f"實(shí)例化 - 元類(lèi): {meta_instance_time:.4f}s")
    print(f"實(shí)例化開(kāi)銷(xiāo): {meta_instance_time/simple_instance_time:.2f}x")

# 運(yùn)行性能測(cè)試
performance_benchmark()

class LazyInitMeta(type):
    """惰性初始化元類(lèi)：延遲執(zhí)行昂貴操作"""
    def __init__(cls, name, bases, namespace):
        super().__init__(name, bases, namespace)
        # 不立即進(jìn)行復(fù)雜操作，而是設(shè)置標(biāo)記
        cls._initialized = False
    
    def __getattribute__(cls, name):
        # 首次訪(fǎng)問(wèn)時(shí)進(jìn)行完整初始化
        if not getattr(cls, '_initialized', True) and name != '_initialized':
            cls._complete_initialization()
        return super().__getattribute__(name)
    
    def _complete_initialization(cls):
        """執(zhí)行昂貴的初始化操作"""
        print(f"完成 {cls.__name__} 的初始化")
        # 模擬耗時(shí)操作
        time.sleep(0.01)
        cls._initialized = True

class OptimizedClass(metaclass=LazyInitMeta):
    pass

# 只有首次訪(fǎng)問(wèn)時(shí)才會(huì)觸發(fā)完整初始化
print("類(lèi)已定義，但未初始化")
obj = OptimizedClass()  # 此時(shí)觸發(fā)初始化

class CachingMeta(type):
    """實(shí)現(xiàn)緩存的元類(lèi)"""
    _class_cache = {}
    
    def __new__(cls, name, bases, namespace):
        # 創(chuàng)建緩存鍵
        cache_key = (name, tuple(bases), frozenset(namespace.items()))
        
        # 檢查緩存
        if cache_key in cls._class_cache:
            return cls._class_cache[cache_key]
        
        # 創(chuàng)建新類(lèi)并緩存
        new_class = super().__new__(cls, name, bases, namespace)
        cls._class_cache[cache_key] = new_class
        return new_class

class SelectiveMeta(type):
    """選擇性啟用功能的元類(lèi)"""
    
    def __new__(cls, name, bases, namespace, enable_validation=True, enable_registry=True):
        # 根據(jù)參數(shù)選擇性啟用功能
        if enable_validation:
            cls._validate_namespace(namespace)
        
        new_class = super().__new__(cls, name, bases, namespace)
        
        if enable_registry:
            cls._register_class(new_class)
        
        return new_class
    
    @classmethod
    def _validate_namespace(cls, namespace):
        """驗(yàn)證命名空間（可選）"""
        pass
    
    @classmethod
    def _register_class(cls, new_class):
        """注冊(cè)類(lèi)（可選）"""
        pass

class DescriptorMeta(type):
    """描述符友好的元類(lèi)：自動(dòng)設(shè)置描述符名稱(chēng)"""
    
    def __new__(cls, name, bases, namespace):
        # 在類(lèi)創(chuàng)建階段設(shè)置描述符的名稱(chēng)
        for key, value in namespace.items():
            if hasattr(value, '__set_name__') and not hasattr(value, '__name_set__'):
                value.__set_name__(cls, key)
                value.__name_set__ = True  # 避免重復(fù)設(shè)置
        
        return super().__new__(cls, name, bases, namespace)

class Validated:
    """支持驗(yàn)證的描述符"""
    def __set_name__(self, owner, name):
        self.name = name
        self.private_name = f"_{name}"
    
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return getattr(instance, self.private_name)
    
    def __set__(self, instance, value):
        self.validate(value)
        setattr(instance, self.private_name, value)
    
    def validate(self, value):
        """驗(yàn)證邏輯，由子類(lèi)實(shí)現(xiàn)"""
        raise NotImplementedError

class Email(Validated):
    """郵箱驗(yàn)證描述符"""
    def validate(self, value):
        if '@' not in value:
            raise ValueError(f"{self.name} 必須是有效的郵箱地址")

class Age(Validated):
    """年齡驗(yàn)證描述符"""
    def validate(self, value):
        if not isinstance(value, int) or not (0 <= value <= 150):
            raise ValueError(f"{self.name} 必須是0-150之間的整數(shù)")

class Person(metaclass=DescriptorMeta):
    email = Email()
    age = Age()
    
    def __init__(self, email, age):
        self.email = email
        self.age = age

# 測(cè)試描述符與元類(lèi)的協(xié)同
try:
    person = Person("invalid-email", 25)  # 應(yīng)該失敗
except ValueError as e:
    print(f"驗(yàn)證錯(cuò)誤: {e}")

valid_person = Person("test@example.com", 30)
print(f"郵箱: {valid_person.email}, 年齡: {valid_person.age}")

class MRMMeta(type):
    """方法解析順序元類(lèi)：自定義方法查找邏輯"""
    
    def mro(cls):
        """自定義方法解析順序"""
        # 獲取標(biāo)準(zhǔn)MRO
        standard_mro = super().mro()
        
        # 特殊處理：確保某些類(lèi)始終在最后
        special_classes = [c for c in standard_mro if hasattr(c, '__special__')]
        normal_classes = [c for c in standard_mro if not hasattr(c, '__special__')]
        
        # 特殊類(lèi)放在最后
        custom_mro = normal_classes + special_classes
        return custom_mro

class SpecialBase(metaclass=MRMMeta):
    __special__ = True

class NormalBase(metaclass=MRMMeta):
    pass

class A(SpecialBase):
    def method(self):
        return "A的方法"

class B(NormalBase):
    def method(self):
        return "B的方法"

class C(A, B):
    pass

# 查看自定義MRO
print("C類(lèi)的MRO:", [cls.__name__ for cls in C.mro()])

# 測(cè)試方法解析
c_instance = C()
print("方法調(diào)用:", c_instance.method())  # 根據(jù)自定義MRO解析

import os
import json
from typing import Any, Dict, Optional

class ConfigMeta(type):
    """配置元類(lèi)：支持環(huán)境變量、類(lèi)型檢查和自動(dòng)加載"""
    
    def __init__(cls, name, bases, namespace):
        super().__init__(name, bases, namespace)
        
        if name != 'BaseConfig':
            # 應(yīng)用環(huán)境變量覆蓋
            cls._apply_environment_overrides()
            
            # 驗(yàn)證必需配置
            cls._validate_required()
            
            # 自動(dòng)加載配置文件
            cls._load_config_file()
    
    def _apply_environment_overrides(cls):
        """應(yīng)用環(huán)境變量覆蓋"""
        for attr_name in dir(cls):
            if not attr_name.startswith('_') and not callable(getattr(cls, attr_name)):
                env_var = f"{cls.__name__.upper()}_{attr_name.upper()}"
                if env_var in os.environ:
                    env_value = os.environ[env_var]
                    # 類(lèi)型轉(zhuǎn)換
                    original_value = getattr(cls, attr_name)
                    if isinstance(original_value, bool):
                        # 布爾值特殊處理
                        setattr(cls, attr_name, env_value.lower() in ('true', '1', 'yes'))
                    elif isinstance(original_value, int):
                        setattr(cls, attr_name, int(env_value))
                    elif isinstance(original_value, float):
                        setattr(cls, attr_name, float(env_value))
                    else:
                        setattr(cls, attr_name, env_value)
                    print(f"配置覆蓋: {attr_name} = {env_value}")
    
    def _validate_required(cls):
        """驗(yàn)證必需配置"""
        for attr_name in dir(cls):
            if not attr_name.startswith('_') and not callable(getattr(cls, attr_name)):
                value = getattr(cls, attr_name)
                if value is None:
                    raise ValueError(f"必需配置 {attr_name} 不能為None")
    
    def _load_config_file(cls):
        """從配置文件自動(dòng)加載"""
        config_file = getattr(cls, '__config_file__', None)
        if config_file and os.path.exists(config_file):
            with open(config_file, 'r') as f:
                config_data = json.load(f)
            
            for key, value in config_data.items():
                if hasattr(cls, key):
                    setattr(cls, key, value)

class BaseConfig(metaclass=ConfigMeta):
    """配置基類(lèi)"""
    pass

class DatabaseConfig(BaseConfig):
    """數(shù)據(jù)庫(kù)配置"""
    __config_file__ = 'database.json'  # 可選配置文件
    
    host = 'localhost'
    port = 5432
    username = None  # 必需配置
    password = None  # 必需配置
    use_ssl = False

# 設(shè)置環(huán)境變量進(jìn)行測(cè)試
os.environ['DATABASECONFIG_PORT'] = '5433'
os.environ['DATABASECONFIG_USE_SSL'] = 'true'

# 創(chuàng)建配置實(shí)例
db_config = DatabaseConfig()
db_config.username = 'admin'  # 手動(dòng)設(shè)置必需配置
db_config.password = 'secret'

print(f"數(shù)據(jù)庫(kù)配置: {db_config.host}:{db_config.port}, SSL: {db_config.use_ssl}")

class DIContainerMeta(type):
    """依賴(lài)注入容器元類(lèi)"""
    
    _dependencies = {}
    
    def __init__(cls, name, bases, namespace):
        super().__init__(cls, name, bases, namespace)
        
        # 注冊(cè)服務(wù)
        if hasattr(cls, '__service__'):
            service_name = getattr(cls, '__service_name__', name.lower())
            cls._dependencies[service_name] = cls
    
    def resolve(cls, service_name):
        """解析依賴(lài)"""
        if service_name not in cls._dependencies:
            raise KeyError(f"未找到服務(wù): {service_name}")
        
        service_class = cls._dependencies[service_name]
        
        # 檢查依賴(lài)項(xiàng)
        dependencies = {}
        if hasattr(service_class, '__dependencies__'):
            for dep_name in service_class.__dependencies__:
                dependencies[dep_name] = cls.resolve(dep_name)
        
        # 創(chuàng)建實(shí)例
        return service_class(**dependencies)

class Service(metaclass=DIContainerMeta):
    __service__ = True

class DatabaseService(Service):
    __service_name__ = 'database'
    
    def __init__(self, connection_string="default"):
        self.connection_string = connection_string
    
    def query(self, sql):
        return f"執(zhí)行查詢(xún): {sql}"

class UserService(Service):
    __service_name__ = 'user'
    __dependencies__ = ['database']  # 聲明依賴(lài)
    
    def __init__(self, database):
        self.db = database
    
    def get_user(self, user_id):
        return self.db.query(f"SELECT * FROM users WHERE id = {user_id}")

class APIService(Service):
    __service_name__ = 'api'
    __dependencies__ = ['user']
    
    def __init__(self, user):
        self.user_service = user
    
    def handle_request(self):
        return self.user_service.get_user(1)

# 使用依賴(lài)注入容器
api_service = DIContainerMeta.resolve('api')
result = api_service.handle_request()
print(result)

class MetaA(type):
    pass

class MetaB(type):
    pass

class A(metaclass=MetaA):
    pass

class B(metaclass=MetaB):
    pass

# 直接繼承會(huì)報(bào)錯(cuò)
try:
    class C(A, B):  # 元類(lèi)沖突
        pass
except TypeError as e:
    print(f"元類(lèi)沖突: {e}")

# 解決方案：創(chuàng)建協(xié)同元類(lèi)
class CooperativeMeta(MetaA, MetaB):
    pass

class C(A, B, metaclass=CooperativeMeta):
    pass  # 現(xiàn)在可以正常工作

class SafeMeta(type):
    """避免無(wú)限遞歸的安全元類(lèi)"""
    
    def __getattribute__(cls, name):
        # 避免在獲取屬性時(shí)再次觸發(fā)__getattribute__
        if name == '_initializing':
            return super().__getattribute__(name)
        
        # 安全地訪(fǎng)問(wèn)屬性
        return super().__getattribute__(name)

class DebuggableMeta(type):
    """可調(diào)試的元類(lèi)：記錄詳細(xì)執(zhí)行信息"""
    
    def __new__(cls, name, bases, namespace):
        print(f"?? 元類(lèi) __new__ 開(kāi)始: 創(chuàng)建類(lèi) {name}")
        print(f"   基類(lèi): {bases}")
        print(f"   命名空間鍵: {list(namespace.keys())}")
        
        try:
            new_class = super().__new__(cls, name, bases, namespace)
            print(f"? 元類(lèi) __new__ 完成: {name}")
            return new_class
        except Exception as e:
            print(f"? 元類(lèi) __new__ 錯(cuò)誤: {e}")
            raise
    
    def __init__(self, name, bases, namespace):
        print(f"?? 元類(lèi) __init__ 開(kāi)始: 初始化類(lèi) {name}")
        try:
            super().__init__(name, bases, namespace)
            print(f"? 元類(lèi) __init__ 完成: {name}")
        except Exception as e:
            print(f"? 元類(lèi) __init__ 錯(cuò)誤: {e}")
            raise

class DebugClass(metaclass=DebuggableMeta):
    attribute = "值"
    
    def method(self):
        return "方法結(jié)果"

# 觀(guān)察詳細(xì)的創(chuàng)建過(guò)程