class SimpleClass:
    pass

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

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

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

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

class CustomNamespaceMeta(type):
    @classmethod
    def __prepare__(cls, name, bases, **kwargs):
        """返回一個自定義的映射對象，用于存儲類屬性"""
        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)建類 {name}，屬性: {list(namespace.keys())}")
        return super().__new__(cls, name, bases, namespace)
    
    def __init__(self, name, bases, namespace, **kwargs):
        print(f"初始化類 {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):
    """
    通用類工廠函數(shù)：根據(jù)參數(shù)動態(tài)創(chuàng)建類
    
    參數(shù):
        class_name: 類名
        attributes: 類屬性和方法字典
        bases: 基類元組
        metaclass: 使用的元類
    """
    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())
    
    # 使用元類創(chuàng)建類
    return metaclass(class_name, bases, attributes)

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

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

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

class InterfaceMeta(type):
    """接口驗證元類：確保子類實現(xiàn)必需的方法"""
    
    required_methods = ['save', 'delete', 'validate']  # 必需方法列表
    
    def __init__(cls, name, bases, namespace):
        # 跳過對基類本身的檢查
        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"類 {name} 必須實現(xiàn)方法: {', '.join(missing_methods)}")
        
        super().__init__(name, bases, namespace)

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

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

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

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

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

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

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

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

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

# 通過注冊表使用類
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元類：將類屬性映射到數(shù)據(jù)庫字段"""
    
    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ù)庫方法
        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):
        """自動生成的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}")
            # 實際執(zhí)行數(shù)據(jù)庫操作...
            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):
        """自動生成的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  # 在元類中設(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} 類型")
        instance.__dict__[self.name] = value

class Model(metaclass=ModelMeta):
    """模型基類"""
    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()  # 自動生成SQL

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

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

import inspect
from typing import Dict, Callable

class RouteMeta(type):
    """API路由元類：自動將方法映射到路由"""
    
    def __init__(cls, name, bases, namespace):
        super().__init__(name, bases, namespace)
        
        # 跳過基類
        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"類 {name} 注冊了 {len(cls.routes)} 個路由")

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

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

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

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

# 模擬請求處理
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']
            # 簡化參數(shù)提取
            if '<int:user_id>' in path:
                user_id = path.split('/')[-1]  # 簡化提取
                return handler(api_instance, int(user_id))
            return handler(api_instance)
    return "404 Not Found"

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

import timeit
import time

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

class MetaClass(type):
    """有基本功能的元類"""
    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):
    """使用元類的類"""
    def __init__(self, value):
        self.value = value

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

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

class LazyInitMeta(type):
    """惰性初始化元類：延遲執(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):
        # 首次訪問時進(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__} 的初始化")
        # 模擬耗時操作
        time.sleep(0.01)
        cls._initialized = True

class OptimizedClass(metaclass=LazyInitMeta):
    pass

# 只有首次訪問時才會觸發(fā)完整初始化
print("類已定義，但未初始化")
obj = OptimizedClass()  # 此時觸發(fā)初始化

class CachingMeta(type):
    """實現(xiàn)緩存的元類"""
    _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)建新類并緩存
        new_class = super().__new__(cls, name, bases, namespace)
        cls._class_cache[cache_key] = new_class
        return new_class

class SelectiveMeta(type):
    """選擇性啟用功能的元類"""
    
    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):
        """驗證命名空間（可選）"""
        pass
    
    @classmethod
    def _register_class(cls, new_class):
        """注冊類（可選）"""
        pass

class DescriptorMeta(type):
    """描述符友好的元類：自動設(shè)置描述符名稱"""
    
    def __new__(cls, name, bases, namespace):
        # 在類創(chuàng)建階段設(shè)置描述符的名稱
        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:
    """支持驗證的描述符"""
    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):
        """驗證邏輯，由子類實現(xiàn)"""
        raise NotImplementedError

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

class Age(Validated):
    """年齡驗證描述符"""
    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

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

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

class MRMMeta(type):
    """方法解析順序元類：自定義方法查找邏輯"""
    
    def mro(cls):
        """自定義方法解析順序"""
        # 獲取標(biāo)準(zhǔn)MRO
        standard_mro = super().mro()
        
        # 特殊處理：確保某些類始終在最后
        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__')]
        
        # 特殊類放在最后
        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類的MRO:", [cls.__name__ for cls in C.mro()])

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

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

class ConfigMeta(type):
    """配置元類：支持環(huán)境變量、類型檢查和自動加載"""
    
    def __init__(cls, name, bases, namespace):
        super().__init__(name, bases, namespace)
        
        if name != 'BaseConfig':
            # 應(yīng)用環(huán)境變量覆蓋
            cls._apply_environment_overrides()
            
            # 驗證必需配置
            cls._validate_required()
            
            # 自動加載配置文件
            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]
                    # 類型轉(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):
        """驗證必需配置"""
        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):
        """從配置文件自動加載"""
        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):
    """配置基類"""
    pass

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

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

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

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

class DIContainerMeta(type):
    """依賴注入容器元類"""
    
    _dependencies = {}
    
    def __init__(cls, name, bases, namespace):
        super().__init__(cls, name, bases, namespace)
        
        # 注冊服務(wù)
        if hasattr(cls, '__service__'):
            service_name = getattr(cls, '__service_name__', name.lower())
            cls._dependencies[service_name] = cls
    
    def resolve(cls, service_name):
        """解析依賴"""
        if service_name not in cls._dependencies:
            raise KeyError(f"未找到服務(wù): {service_name}")
        
        service_class = cls._dependencies[service_name]
        
        # 檢查依賴項
        dependencies = {}
        if hasattr(service_class, '__dependencies__'):
            for dep_name in service_class.__dependencies__:
                dependencies[dep_name] = cls.resolve(dep_name)
        
        # 創(chuàng)建實例
        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í)行查詢: {sql}"

class UserService(Service):
    __service_name__ = 'user'
    __dependencies__ = ['database']  # 聲明依賴
    
    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)

# 使用依賴注入容器
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

# 直接繼承會報錯
try:
    class C(A, B):  # 元類沖突
        pass
except TypeError as e:
    print(f"元類沖突: {e}")

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

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

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

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

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

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