class Example:
    def __new__(cls, *args, **kwargs):
        print("__new__被調(diào)用，創(chuàng)建實(shí)例")
        instance = super().__new__(cls)
        return instance
    
    def __init__(self, value):
        print("__init__被調(diào)用，初始化實(shí)例")
        self.value = value

# 正常創(chuàng)建過程
obj = Example(10)
# 輸出:
# __new__被調(diào)用，創(chuàng)建實(shí)例
# __init__被調(diào)用，初始化實(shí)例

class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day
        print("Date.__init__被調(diào)用")

# 不調(diào)用__init__創(chuàng)建實(shí)例
d = Date.__new__(Date)
print(f"實(shí)例已創(chuàng)建: wppm3vysvbp")
print(f"實(shí)例是否有year屬性: {hasattr(d, 'year')}")  # 輸出: False

# 手動(dòng)初始化屬性
data = {'year': 2023, 'month': 10, 'day': 4}
for key, value in data.items():
    setattr(d, key, value)

print(f"初始化后 - 年: {d.year}, 月: {d.month}, 日: {d.day}")

class AdvancedExample:
    def __new__(cls, *args, **kwargs):
        # 完全控制實(shí)例創(chuàng)建過程
        instance = super().__new__(cls)
        
        # 在__new__中完成本應(yīng)在__init__中的工作
        instance._created_by = "__new__"
        instance._initialized = True
        
        # 根據(jù)參數(shù)動(dòng)態(tài)設(shè)置屬性
        if args:
            instance.args = list(args)
        if kwargs:
            instance.kwargs = kwargs.copy()
            
        return instance
    
    # 注意：這里沒有定義__init__方法
    def display(self):
        print(f"創(chuàng)建方式: {getattr(self, '_created_by', '未知')}")
        print(f"參數(shù): {getattr(self, 'args', [])}")
        print(f"關(guān)鍵字參數(shù): {getattr(self, 'kwargs', {})}")

# 創(chuàng)建實(shí)例（不會(huì)調(diào)用__init__，因?yàn)闆]有定義）
obj = AdvancedExample("位置參數(shù)", key="關(guān)鍵字參數(shù)")
obj.display()

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print("Person.__init__被調(diào)用")
    
    @classmethod
    def from_birth_year(cls, name, birth_year):
        """通過出生年份創(chuàng)建Person實(shí)例的類方法"""
        from datetime import datetime
        current_year = datetime.now().year
        age = current_year - birth_year
        
        # 創(chuàng)建實(shí)例但不通過__init__
        instance = cls.__new__(cls)
        
        # 手動(dòng)設(shè)置屬性
        instance.name = name
        instance.age = age
        instance.birth_year = birth_year  # 額外信息
        
        return instance
    
    @classmethod
    def from_dict(cls, data_dict):
        """從字典創(chuàng)建Person實(shí)例"""
        instance = cls.__new__(cls)
        
        # 手動(dòng)設(shè)置屬性
        for key, value in data_dict.items():
            setattr(instance, key, value)
            
        return instance
    
    def __str__(self):
        return f"Person(name={self.name}, age={self.age})"

# 使用標(biāo)準(zhǔn)構(gòu)造函數(shù)
person1 = Person("Alice", 25)
print(person1)

# 使用類方法構(gòu)造函數(shù)（繞過__init__）
person2 = Person.from_birth_year("Bob", 1995)
print(f"{person2}, 出生年份: {getattr(person2, 'birth_year', '未知')}")

# 從字典創(chuàng)建
person3 = Person.from_dict({"name": "Charlie", "age": 30, "city": "Beijing"})
print(f"{person3}, 城市: {getattr(person3, 'city', '未知')}")

class ConfigObject:
    """配置對(duì)象，支持多種創(chuàng)建方式"""
    
    def __init__(self, settings=None):
        self.settings = settings or {}
        print("ConfigObject.__init__被調(diào)用")
    
    @classmethod
    def from_json(cls, json_str):
        """從JSON字符串創(chuàng)建配置對(duì)象"""
        import json
        data = json.loads(json_str)
        
        instance = cls.__new__(cls)
        instance.settings = data
        instance._source = "json"
        return instance
    
    @classmethod
    def from_env_vars(cls, prefix="APP_"):
        """從環(huán)境變量創(chuàng)建配置對(duì)象"""
        import os
        
        instance = cls.__new__(cls)
        instance.settings = {}
        instance._source = "env"
        
        # 收集環(huán)境變量
        for key, value in os.environ.items():
            if key.startswith(prefix):
                config_key = key[len(prefix):].lower()
                instance.settings[config_key] = value
                
        return instance
    
    @classmethod
    def merge_configs(cls, *configs):
        """合并多個(gè)配置源"""
        instance = cls.__new__(cls)
        instance.settings = {}
        instance._sources = []
        
        for config in configs:
            if hasattr(config, 'settings'):
                instance.settings.update(config.settings)
                if hasattr(config, '_source'):
                    instance._sources.append(config._source)
        
        return instance

# 使用各種工廠方法
json_config = ConfigObject.from_json('{"host": "localhost", "port": 8080}')
env_config = ConfigObject.from_env_vars("APP_")
merged = ConfigObject.merge_configs(json_config, env_config)

print(f"配置源: {getattr(merged, '_sources', ['unknown'])}")
print(f"配置內(nèi)容: {merged.settings}")

class Singleton:
    _instance = None
    
    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            # 創(chuàng)建實(shí)例但不調(diào)用__init__
            cls._instance = super().__new__(cls)
            # 手動(dòng)初始化單例實(shí)例
            cls._instance._initialized = False
            cls._instance._init_singleton()
        return cls._instance
    
    def _init_singleton(self):
        """單例專用初始化方法"""
        if not self._initialized:
            self.singleton_data = "單例數(shù)據(jù)"
            self.counter = 0
            self._initialized = True
            print("單例初始化完成")
    
    def increment(self):
        self.counter += 1
        return self.counter

# 測(cè)試單例行為
s1 = Singleton()
s2 = Singleton()

print(f"s1 is s2: {s1 is s2}")  # 輸出: True
print(f"s1計(jì)數(shù)器: {s1.increment()}")  # 輸出: 1
print(f"s2計(jì)數(shù)器: {s2.increment()}")  # 輸出: 2

import threading

class ThreadSafeSingleton:
    _instance = None
    _lock = threading.Lock()
    
    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            with cls._lock:
                # 雙重檢查鎖定
                if not cls._instance:
                    cls._instance = super().__new__(cls)
                    cls._instance._initialize_once()
        return cls._instance
    
    def _initialize_once(self):
        """確保只初始化一次"""
        if not hasattr(self, '_initialized'):
            self.data = {}
            self._initialized = True
            print("線程安全單例初始化完成")
    
    def set_data(self, key, value):
        self.data[key] = value
    
    def get_data(self, key):
        return self.data.get(key)

# 多線程測(cè)試
def test_singleton(thread_id):
    singleton = ThreadSafeSingleton()
    singleton.set_data(f"key_{thread_id}", f"value_{thread_id}")
    print(f"線程{thread_id}設(shè)置的數(shù)據(jù): {singleton.get_data(f'key_{thread_id}')}")

threads = []
for i in range(5):
    thread = threading.Thread(target=test_singleton, args=(i,))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

class InstanceControlMeta(type):
    """控制實(shí)例創(chuàng)建的元類"""
    
    def __call__(cls, *args, **kwargs):
        # 元類的__call__方法控制實(shí)例創(chuàng)建流程
        if kwargs.get('skip_init', False):
            # 跳過__init__的創(chuàng)建路徑
            instance = cls.__new__(cls, *args, **kwargs)
            
            # 可選的替代初始化邏輯
            if hasattr(cls, '_alternate_init'):
                cls._alternate_init(instance, *args, **kwargs)
                
            return instance
        else:
            # 正常的創(chuàng)建路徑
            return super().__call__(*args, **kwargs)

class ControlledClass(metaclass=InstanceControlMeta):
    def __init__(self, value):
        self.value = value
        self.initialized_by = "__init__"
        print("ControlledClass.__init__被調(diào)用")
    
    @classmethod
    def _alternate_init(cls, instance, value):
        """替代初始化方法"""
        instance.value = value
        instance.initialized_by = "alternate"
        instance.extra_info = "通過元類添加的額外信息"
        print("使用替代初始化方法")

# 正常創(chuàng)建（調(diào)用__init__）
normal_instance = ControlledClass("正常值")
print(f"初始化方式: {normal_instance.initialized_by}")

# 繞過__init__創(chuàng)建
skip_instance = ControlledClass("跳過值", skip_init=True)
print(f"初始化方式: {getattr(skip_instance, 'initialized_by', '未初始化')}")
print(f"額外信息: {getattr(skip_instance, 'extra_info', '無')}")

class ORMMeta(type):
    """ORM系統(tǒng)的元類"""
    
    def __call__(cls, *args, **kwargs):
        # 檢查是否是從數(shù)據(jù)庫加載的現(xiàn)有實(shí)例
        if kwargs.get('_from_db', False):
            # 創(chuàng)建實(shí)例但不初始化
            instance = cls.__new__(cls)
            
            # 直接設(shè)置數(shù)據(jù)庫狀態(tài)
            db_data = kwargs.get('_db_data', {})
            for key, value in db_data.items():
                setattr(instance, key, value)
                
            instance._from_database = True
            return instance
        else:
            # 正常創(chuàng)建新實(shí)例
            return super().__call__(*args, **kwargs)

class Model(metaclass=ORMMeta):
    def __init__(self, **kwargs):
        # 過濾掉元類使用的特殊參數(shù)
        init_kwargs = {k: v for k, v in kwargs.items() if not k.startswith('_')}
        
        for key, value in init_kwargs.items():
            setattr(self, key, value)
            
        self._from_database = False
        print("新模型實(shí)例已初始化")

# 創(chuàng)建新實(shí)例（正常初始化）
new_user = Model(name="Alice", email="alice@example.com")
print(f"來自數(shù)據(jù)庫: {new_user._from_database}")

# 模擬從數(shù)據(jù)庫加載（繞過__init__）
db_user = Model(
    _from_db=True,
    _db_data={'name': 'Bob', 'email': 'bob@example.com', 'id': 123}
)
print(f"用戶名: {db_user.name}, 來自數(shù)據(jù)庫: {db_user._from_database}")

from dataclasses import dataclass, field

@dataclass
class DataClassExample:
    name: str
    age: int = field(default=0)
    metadata: dict = field(default_factory=dict)
    
    def __post_init__(self):
        print("DataClassExample.__post_init__被調(diào)用")
        self.initialized = True

# 正常dataclass使用
normal_dc = DataClassExample("Alice", 25)
print(f"正常初始化: {normal_dc.initialized}")

# 繞過自動(dòng)生成的__init__
raw_dc = DataClassExample.__new__(DataClassExample)
raw_dc.name = "Bob"
raw_dc.age = 30
raw_dc.metadata = {"source": "manual"}
print(f"繞過初始化的實(shí)例: {raw_dc.name}")
print(f"是否有initialized屬性: {hasattr(raw_dc, 'initialized')}")

from pydantic import BaseModel, ValidationError
from typing import Optional

class User(BaseModel):
    name: str
    email: str
    age: Optional[int] = None
    
    class Config:
        validate_assignment = True

# 正常Pydantic模型創(chuàng)建
try:
    normal_user = User(name="Alice", email="alice@example.com")
    print(f"正常用戶: {normal_user.name}")
except ValidationError as e:
    print(f"驗(yàn)證錯(cuò)誤: {e}")

# 繞過驗(yàn)證的創(chuàng)建方式
raw_user = User.__new__(User)
# 直接設(shè)置屬性（跳過驗(yàn)證）
object.__setattr__(raw_user, 'name', "Bob")
object.__setattr__(raw_user, 'email', "invalid-email")  # 無效郵箱，但不會(huì)驗(yàn)證

print(f"繞過驗(yàn)證的用戶: {raw_user.name}")
print(f"郵箱: {raw_user.email}")  # 無效郵箱被接受

# 注意：這種用法違背了Pydantic的設(shè)計(jì)初衷，應(yīng)謹(jǐn)慎使用

import pickle
import json

class SerializableObject:
    def __init__(self, data, metadata=None):
        self.data = data
        self.metadata = metadata or {}
        self._version = 1.0
        print("SerializableObject初始化")
    
    @classmethod
    def from_serialized(cls, serialized_data, format='pickle'):
        """從序列化數(shù)據(jù)快速創(chuàng)建實(shí)例"""
        instance = cls.__new__(cls)
        
        if format == 'pickle':
            # 使用pickle快速恢復(fù)狀態(tài)
            state = pickle.loads(serialized_data)
            instance.__dict__.update(state)
        elif format == 'json':
            # 從JSON恢復(fù)
            state = json.loads(serialized_data)
            instance.__dict__.update(state)
        
        instance._deserialized = True
        return instance
    
    def serialize(self, format='pickle'):
        """序列化對(duì)象狀態(tài)"""
        if format == 'pickle':
            return pickle.dumps(self.__dict__)
        elif format == 'json':
            return json.dumps(self.__dict__)

# 創(chuàng)建并序列化對(duì)象
original = SerializableObject("重要數(shù)據(jù)", {"source": "測(cè)試"})
serialized = original.serialize('pickle')

# 反序列化（繞過__init__）
deserialized = SerializableObject.from_serialized(serialized, 'pickle')
print(f"反序列化數(shù)據(jù): {deserialized.data}")
print(f"是否反序列化標(biāo)記: {getattr(deserialized, '_deserialized', False)}")

import time
from dataclasses import dataclass

@dataclass
class PerformanceCritical:
    id: int
    data: list
    processed: bool = False
    
    def __init__(self, id, data):
        self.id = id
        self.data = data
        # 模擬昂貴的初始化操作
        time.sleep(0.001)  # 1毫秒延遲
        self.processed = True
        self._expensive_calculation()

    def _expensive_calculation(self):
        # 模擬耗時(shí)計(jì)算
        time.sleep(0.002)  # 2毫秒延遲

@classmethod
def create_lightweight(cls, id, data, skip_processing=False):
    """輕量級(jí)創(chuàng)建方法"""
    instance = cls.__new__(cls)
    instance.id = id
    instance.data = data
    instance.processed = not skip_processing
    
    if not skip_processing:
        instance._expensive_calculation()
    
    return instance

# 添加快捷方法到類
PerformanceCritical.create_lightweight = create_lightweight

# 性能測(cè)試
start_time = time.time()
normal_instances = [PerformanceCritical(i, [i*2]) for i in range(10)]
normal_time = time.time() - start_time

start_time = time.time()
lightweight_instances = [PerformanceCritical.create_lightweight(i, [i*2], True) for i in range(10)]
lightweight_time = time.time() - start_time

print(f"正常初始化時(shí)間: {normal_time:.4f}秒")
print(f"輕量級(jí)初始化時(shí)間: {lightweight_time:.4f}秒")
print(f"性能提升: {normal_time/lightweight_time:.1f}倍")

class SafeBypassExample:
    def __init__(self, required_param):
        self.required_param = required_param
        self._properly_initialized = True
        self._setup_critical_resources()
    
    def _setup_critical_resources(self):
        """設(shè)置關(guān)鍵資源"""
        self.critical_resource = "重要資源"
        print("關(guān)鍵資源已設(shè)置")
    
    @classmethod
    def safe_create(cls, required_param, *args, **kwargs):
        """安全的繞過創(chuàng)建方法"""
        instance = cls.__new__(cls)
        
        try:
            # 手動(dòng)執(zhí)行必要的初始化
            instance.required_param = required_param
            instance._properly_initialized = True
            instance._setup_critical_resources()
            
            # 處理額外參數(shù)
            for key, value in kwargs.items():
                setattr(instance, key, value)
                
        except Exception as e:
            # 初始化失敗時(shí)清理
            print(f"安全創(chuàng)建失敗: {e}")
            # 可以在這里添加資源清理邏輯
            raise
        
        return instance

# 安全創(chuàng)建實(shí)例
safe_instance = SafeBypassExample.safe_create("必需參數(shù)", extra_field="額外字段")
print(f"安全實(shí)例狀態(tài): {safe_instance._properly_initialized}")

# 對(duì)比直接繞過（可能不安全）
unsafe_instance = SafeBypassExample.__new__(SafeBypassExample)
# 缺少關(guān)鍵初始化，對(duì)象可能處于無效狀態(tài)
print(f"不安全實(shí)例狀態(tài): {hasattr(unsafe_instance, '_properly_initialized')}")

class MaintainableDesign:
    """展示可維護(hù)繞過設(shè)計(jì)的類"""
    
    # 使用常量提高可讀性
    CREATE_FLAGS = {
        'SKIP_INIT': 'skip_init',
        'FROM_EXTERNAL': 'from_external',
        'PARTIAL_INIT': 'partial_init'
    }
    
    def __init__(self, primary_data, secondary_data=None):
        self.primary = primary_data
        self.secondary = secondary_data or {}
        self._init_complete = True
    
    @classmethod
    def create_instance(cls, primary_data, creation_mode='normal', **kwargs):
        """可維護(hù)的創(chuàng)建接口"""
        
        if creation_mode == cls.CREATE_FLAGS['SKIP_INIT']:
            return cls._create_skip_init(primary_data, **kwargs)
        elif creation_mode == cls.CREATE_FLAGS['FROM_EXTERNAL']:
            return cls._create_from_external(primary_data, **kwargs)
        elif creation_mode == cls.CREATE_FLAGS['PARTIAL_INIT']:
            return cls._create_partial_init(primary_data, **kwargs)
        else:
            # 默認(rèn)正常初始化
            return cls(primary_data, **kwargs)
    
    @classmethod
    def _create_skip_init(cls, primary_data, **kwargs):
        """跳過初始化的實(shí)現(xiàn)細(xì)節(jié)"""
        instance = cls.__new__(cls)
        instance.primary = primary_data
        instance._init_complete = False
        instance._creation_mode = 'skip_init'
        return instance
    
    @classmethod
    def _create_from_external(cls, primary_data, external_source=None, **kwargs):
        """從外部源創(chuàng)建的實(shí)現(xiàn)細(xì)節(jié)"""
        instance = cls.__new__(cls)
        instance.primary = primary_data
        instance.external_source = external_source
        instance._init_complete = True
        instance._creation_mode = 'from_external'
        return instance

# 使用清晰的接口創(chuàng)建實(shí)例
normal = MaintainableDesign.create_instance("數(shù)據(jù)")
skipped = MaintainableDesign.create_instance("數(shù)據(jù)", 
    MaintainableDesign.CREATE_FLAGS['SKIP_INIT'])

print(f"正常實(shí)例狀態(tài): {normal._init_complete}")
print(f"跳過初始化實(shí)例狀態(tài): {skipped._init_complete}")