# 從列表創(chuàng)建元組
list_data = [1, 2, 3, 4, 5]
tuple_from_list = tuple(list_data)
print(f"列表轉(zhuǎn)元組: {tuple_from_list}")  # 輸出: (1, 2, 3, 4, 5)

# 從字符串創(chuàng)建（字符元組）
string_data = "hello"
tuple_from_string = tuple(string_data)
print(f"字符串轉(zhuǎn)元組: {tuple_from_string}")  # 輸出: ('h', 'e', 'l', 'l', 'o')

# 從范圍對象創(chuàng)建
range_data = range(5)
tuple_from_range = tuple(range_data)
print(f"范圍轉(zhuǎn)元組: {tuple_from_range}")  # 輸出: (0, 1, 2, 3, 4)

# 空元組
empty_tuple = tuple()
print(f"空元組: {empty_tuple}")  # 輸出: ()

# 從字典創(chuàng)建（只獲取鍵）
dict_data = {'a': 1, 'b': 2, 'c': 3}
tuple_from_dict = tuple(dict_data)
print(f"字典鍵元組: {tuple_from_dict}")  # 輸出: ('a', 'b', 'c')

class DataProcessor:
    @staticmethod
    def get_coordinates():
        """返回坐標(biāo)（使用元組保護(hù)數(shù)據(jù)）"""
        return (10.5, 20.3)  # 不可修改的坐標(biāo)
    
    @staticmethod
    def get_student_info():
        """返回學(xué)生信息（多返回值）"""
        name = "張三"
        age = 20
        grade = 90.5
        return (name, age, grade)  # 打包返回
    
    @staticmethod
    def process_data(*args):
        """處理可變數(shù)量參數(shù)"""
        return tuple(args)  # 轉(zhuǎn)換為元組
    
    @staticmethod
    def create_immutable_config(config_dict):
        """創(chuàng)建不可變配置"""
        return tuple(config_dict.items())

# 使用示例
processor = DataProcessor()

# 獲取坐標(biāo)（不可修改）
coords = processor.get_coordinates()
print(f"坐標(biāo): {coords}")
print(f"X坐標(biāo): {coords[0]}")
print(f"Y坐標(biāo): {coords[1]}")

# 多返回值解包
name, age, grade = processor.get_student_info()
print(f"學(xué)生: {name}, 年齡: {age}, 成績: {grade}")

# 處理可變參數(shù)
data_tuple = processor.process_data(1, 2, 3, 4, 5)
print(f"處理結(jié)果: {data_tuple}")

# 不可變配置
config = {"host": "localhost", "port": 8080, "debug": True}
immutable_config = processor.create_immutable_config(config)
print(f"配置元組: {immutable_config}")

# 基本類型檢測
print(f"整數(shù)的類型: {type(42)}")          # 輸出: <class 'int'>
print(f"字符串的類型: {type('hello')}")    # 輸出: <class 'str'>
print(f"列表的類型: {type([1, 2, 3])}")    # 輸出: <class 'list'>
print(f"元組的類型: {type((1, 2, 3))}")   # 輸出: <class 'tuple'>

# 自定義類的類型
class Person:
    pass

person = Person()
print(f"自定義類的類型: {type(person)}")  # 輸出: <class '__main__.Person'>

# 與__class__比較
print(f"type與__class__相同: {type(person) == person.__class__}")  # 輸出: True

# 類型比較
num = 100
print(f"num是整數(shù): {type(num) == int}")      # 輸出: True
print(f"num是字符串: {type(num) == str}")    # 輸出: False

class TypeChecker:
    @staticmethod
    def safe_operation(value, operation):
        """安全的類型化操作"""
        value_type = type(value)
        
        if value_type in (int, float):
            return operation(value)
        else:
            return f"不支持的類型: {value_type}"
    
    @staticmethod
    def filter_by_type(data, target_type):
        """按類型過濾數(shù)據(jù)"""
        return [item for item in data if type(item) == target_type]
    
    @staticmethod
    def validate_input(value, expected_type, default=None):
        """驗(yàn)證輸入類型"""
        if type(value) == expected_type:
            return value
        elif default is not None:
            return default
        else:
            raise TypeError(f"期望類型: {expected_type}, 實(shí)際類型: {type(value)}")

# 使用示例
checker = TypeChecker()

# 安全操作
print(f"安全計(jì)算: {checker.safe_operation(10, lambda x: x * 2)}")
print(f"安全計(jì)算: {checker.safe_operation('text', lambda x: x * 2)}")

# 類型過濾
mixed_data = [1, "hello", 3.14, "world", 5, 6.28]
numbers_only = checker.filter_by_type(mixed_data, int)
floats_only = checker.filter_by_type(mixed_data, float)
print(f"整數(shù): {numbers_only}")
print(f"浮點(diǎn)數(shù): {floats_only}")

# 輸入驗(yàn)證
try:
    valid = checker.validate_input(100, int, 0)
    print(f"驗(yàn)證通過: {valid}")
    
    invalid = checker.validate_input("100", int, 0)
    print(f"驗(yàn)證結(jié)果: {invalid}")
except TypeError as e:
    print(f"驗(yàn)證失敗: {e}")

# 動(dòng)態(tài)創(chuàng)建簡單類
# 等效于: class Person: pass
Person = type('Person', (), {})
person1 = Person()
print(f"動(dòng)態(tài)創(chuàng)建的類: {Person}")
print(f"類名: {Person.__name__}")
print(f"實(shí)例: {person1}")

# 帶屬性的類
Student = type('Student', (), {
    'name': '張三',
    'age': 20,
    'greet': lambda self: f"你好，我是{self.name}"
})
student1 = Student()
print(f"學(xué)生姓名: {student1.name}")
print(f"問候: {student1.greet()}")

# 帶繼承的類
class Animal:
    def speak(self):
        return "動(dòng)物叫聲"

# 動(dòng)態(tài)創(chuàng)建繼承類
Dog = type('Dog', (Animal,), {
    'breed': '金毛',
    'bark': lambda self: f"{self.breed}在汪汪叫"
})
dog1 = Dog()
print(f"狗的品種: {dog1.breed}")
print(f"狗叫: {dog1.bark()}")
print(f"動(dòng)物方法: {dog1.speak()}")

class DynamicClassFactory:
    @staticmethod
    def create_class(class_name, base_classes=(), attributes=None, methods=None):
        """動(dòng)態(tài)創(chuàng)建類"""
        class_dict = {}
        
        # 添加屬性
        if attributes:
            class_dict.update(attributes)
        
        # 添加方法
        if methods:
            for method_name, method_func in methods.items():
                class_dict[method_name] = method_func
        
        # 創(chuàng)建類
        new_class = type(class_name, base_classes, class_dict)
        return new_class
    
    @staticmethod
    def create_data_class(class_name, field_names):
        """創(chuàng)建類似數(shù)據(jù)類的簡單類"""
        class_dict = {'__slots__': field_names}
        
        # 添加初始化方法
        def init_method(self, *args):
            for field, value in zip(field_names, args):
                setattr(self, field, value)
        
        class_dict['__init__'] = init_method
        
        # 添加字符串表示
        def repr_method(self):
            fields = ', '.join(f'{field}={getattr(self, field)}' 
                              for field in field_names)
            return f'{class_name}({fields})'
        
        class_dict['__repr__'] = repr_method
        
        return type(class_name, (), class_dict)
    
    @staticmethod
    def add_method_to_class(cls, method_name, method_func):
        """向現(xiàn)有類添加方法"""
        setattr(cls, method_name, method_func)
        return cls

# 使用示例
factory = DynamicClassFactory()

# 創(chuàng)建數(shù)據(jù)類
Point = factory.create_data_class('Point', ['x', 'y', 'z'])
point = Point(1, 2, 3)
print(f"點(diǎn)對象: {point}")
print(f"點(diǎn)坐標(biāo): ({point.x}, {point.y}, {point.z})")

# 創(chuàng)建復(fù)雜類
Calculator = factory.create_class(
    'Calculator',
    (),
    {
        'version': '1.0',
        'description': '簡單的計(jì)算器類'
    },
    {
        'add': lambda self, a, b: a + b,
        'multiply': lambda self, a, b: a * b
    }
)

calc = Calculator()
print(f"計(jì)算器版本: {calc.version}")
print(f"加法: {calc.add(5, 3)}")
print(f"乘法: {calc.multiply(5, 3)}")

# 動(dòng)態(tài)添加方法
def power_method(self, base, exp):
    return base ** exp

Calculator = factory.add_method_to_class(Calculator, 'power', power_method)
print(f"冪運(yùn)算: {calc.power(2, 3)}")

class TypeSafeConfig:
    def __init__(self):
        self._config = {}
        self._types = {}
    
    def set_config(self, key, value, value_type=None):
        """設(shè)置類型安全的配置"""
        if value_type is None:
            value_type = type(value)
        
        # 驗(yàn)證類型
        if not isinstance(value, value_type):
            raise TypeError(f"值類型不匹配: 期望{value_type}, 實(shí)際{type(value)}")
        
        self._config[key] = value
        self._types[key] = value_type
        
        # 創(chuàng)建屬性
        setattr(self, key, value)
    
    def get_config_as_tuple(self, *keys):
        """獲取配置為元組"""
        if not keys:
            return tuple(self._config.items())
        return tuple((key, self._config[key]) for key in keys)
    
    def validate_all(self):
        """驗(yàn)證所有配置類型"""
        for key, expected_type in self._types.items():
            actual_value = self._config[key]
            if not isinstance(actual_value, expected_type):
                return False, f"{key}類型錯(cuò)誤"
        return True, "所有配置類型正確"
    
    def __repr__(self):
        """配置表示"""
        items = [f"{k}={v}({self._types[k].__name__})" 
                for k, v in self._config.items()]
        return f"TypeSafeConfig({', '.join(items)})"

# 使用示例
config = TypeSafeConfig()

# 設(shè)置配置
config.set_config('app_name', 'MyApp', str)
config.set_config('port', 8080, int)
config.set_config('debug', True, bool)
config.set_config('timeout', 30.5, float)

print(f"配置信息: {config}")
print(f"配置元組: {config.get_config_as_tuple('app_name', 'port')}")

# 類型驗(yàn)證
is_valid, message = config.validate_all()
print(f"類型驗(yàn)證: {message}")

# 類型錯(cuò)誤示例
try:
    config.set_config('error', 'not_a_number', int)
except TypeError as e:
    print(f"類型錯(cuò)誤: {e}")

class APIBuilder:
    def __init__(self, base_name="DynamicAPI"):
        self.base_name = base_name
        self.endpoints = []
    
    def add_endpoint(self, endpoint_name, method_func, method_type='GET'):
        """添加API端點(diǎn)"""
        self.endpoints.append({
            'name': endpoint_name,
            'func': method_func,
            'type': method_type
        })
        return self
    
    def build(self, class_name=None):
        """構(gòu)建API類"""
        if class_name is None:
            class_name = self.base_name
        
        # 創(chuàng)建類字典
        class_dict = {
            '__doc__': f'動(dòng)態(tài)生成的API類: {class_name}',
            'endpoints': self.endpoints.copy()
        }
        
        # 為每個(gè)端點(diǎn)添加方法
        for endpoint in self.endpoints:
            method_name = f"{endpoint['type'].lower()}_{endpoint['name']}"
            
            def create_handler(func):
                def handler(self, *args, **kwargs):
                    return func(*args, **kwargs)
                handler.__name__ = method_name
                handler.__doc__ = f"{endpoint['type']} {endpoint['name']} endpoint"
                return handler
            
            class_dict[method_name] = create_handler(endpoint['func'])
        
        # 創(chuàng)建類
        api_class = type(class_name, (), class_dict)
        return api_class

# 使用示例
builder = APIBuilder()

# 定義處理函數(shù)
def get_users():
    return ["user1", "user2", "user3"]

def create_user(name, age):
    return {"id": 1, "name": name, "age": age}

def delete_user(user_id):
    return {"status": "deleted", "user_id": user_id}

# 添加端點(diǎn)
builder.add_endpoint('users', get_users, 'GET')
builder.add_endpoint('users', create_user, 'POST')
builder.add_endpoint('user', delete_user, 'DELETE')

# 構(gòu)建API類
UserAPI = builder.build('UserAPI')
api = UserAPI()

# 使用API
print(f"獲取用戶: {api.get_users()}")
print(f"創(chuàng)建用戶: {api.post_users('張三', 25)}")
print(f"刪除用戶: {api.delete_user(1)}")

# 檢查類信息
print(f"類名: {UserAPI.__name__}")
print(f"文檔: {UserAPI.__doc__}")
print(f"端點(diǎn)列表: {UserAPI.endpoints}")

class TupleAdvanced:
    @staticmethod
    def named_tuple_factory(field_names):
        """創(chuàng)建類似命名元組的結(jié)構(gòu)"""
        def create_named_tuple(*values):
            if len(values) != len(field_names):
                raise ValueError(f"需要{len(field_names)}個(gè)值，得到{len(values)}個(gè)")
            
            # 返回字典而不是元組，但可以通過字段名訪問
            class NamedTuple:
                def __init__(self, values):
                    for name, value in zip(field_names, values):
                        setattr(self, name, value)
                
                def __iter__(self):
                    return iter(getattr(self, name) for name in field_names)
                
                def __repr__(self):
                    fields = ', '.join(f'{name}={getattr(self, name)}' 
                                      for name in field_names)
                    return f'NamedTuple({fields})'
            
            return NamedTuple(values)
        
        return create_named_tuple
    
    @staticmethod
    def tuple_swap(a, b):
        """使用元組交換變量"""
        return (b, a)
    
    @staticmethod
    def unpack_nested(tuple_data):
        """解包嵌套元組"""
        result = []
        for item in tuple_data:
            if isinstance(item, tuple):
                result.extend(item)
            else:
                result.append(item)
        return tuple(result)

# 使用示例
advanced = TupleAdvanced()

# 類似命名元組
Point = advanced.named_tuple_factory(['x', 'y', 'z'])
point = Point(1, 2, 3)
print(f"點(diǎn)對象: {point}")
print(f"x坐標(biāo): {point.x}")
print(f"遍歷坐標(biāo): {[coord for coord in point]}")

# 變量交換
x, y = 10, 20
print(f"交換前: x={x}, y={y}")
x, y = advanced.tuple_swap(x, y)
print(f"交換后: x={x}, y={y}")

# 嵌套解包
nested = ((1, 2), 3, (4, 5, 6))
flattened = advanced.unpack_nested(nested)
print(f"嵌套元組: {nested}")
print(f"展開后: {flattened}")

class TypeSystem:
    @staticmethod
    def is_same_type(obj1, obj2):
        """檢查兩個(gè)對象是否為相同類型"""
        return type(obj1) is type(obj2)
    
    @staticmethod
    def get_type_hierarchy(cls):
        """獲取類的繼承層次"""
        hierarchy = []
        current = cls
        while current is not object:
            hierarchy.append(current.__name__)
            current = current.__base__
        hierarchy.append('object')
        return ' -> '.join(reversed(hierarchy))
    
    @staticmethod
    def create_type_checker(*allowed_types):
        """創(chuàng)建類型檢查器"""
        def type_checker(value):
            if not any(isinstance(value, t) for t in allowed_types):
                allowed_names = [t.__name__ for t in allowed_types]
                raise TypeError(f"只允許類型: {allowed_names}")
            return value
        return type_checker

# 使用示例
type_system = TypeSystem()

# 類型比較
print(f"相同類型檢查: {type_system.is_same_type(10, 20)}")
print(f"不同類型檢查: {type_system.is_same_type(10, '20')}")

# 繼承層次
class Animal: pass
class Mammal(Animal): pass
class Dog(Mammal): pass

hierarchy = type_system.get_type_hierarchy(Dog)
print(f"Dog的繼承層次: {hierarchy}")

# 類型檢查器
number_checker = type_system.create_type_checker(int, float)
try:
    result = number_checker(10)
    print(f"數(shù)字檢查通過: {result}")
    
    result = number_checker("text")
    print(f"檢查結(jié)果: {result}")
except TypeError as e:
    print(f"類型檢查失敗: {e}")