# 基本的TypeError示例
try:
    result = "Hello" + 5
except TypeError as e:
    print(f"捕獲到TypeError: {e}")

# 錯(cuò)誤的做法
try:
    age = 25
    message = "我今年" + age + "歲"
except TypeError as e:
    print(f"錯(cuò)誤: {e}")

# 正確的做法
age = 25
message = "我今年" + str(age) + "歲"
print(message)

# 或者使用f-string
message = f"我今年{age}歲"
print(message)

# 錯(cuò)誤的做法
number = 42
try:
    result = number()
except TypeError as e:
    print(f"錯(cuò)誤: {e}")

# 正確的做法
def get_number():
    return 42

result = get_number()
print(result)

# 列表不能直接減去另一個(gè)列表
list1 = [1, 2, 3]
list2 = [2, 3, 4]

try:
    result = list1 - list2
except TypeError as e:
    print(f"錯(cuò)誤: {e}")

# 正確的做法 - 使用集合操作
set1 = set(list1)
set2 = set(list2)
difference = set1 - set2
print(f"差集: {list(difference)}")

# 查看對(duì)象的類(lèi)型信息
class CustomNumber:
    def __init__(self, value):
        self.value = value
    
    def __str__(self):
        return str(self.value)

num = CustomNumber(10)
print(f"對(duì)象類(lèi)型: {type(num)}")
print(f"對(duì)象值: {num}")

# 嘗試進(jìn)行數(shù)學(xué)運(yùn)算
try:
    result = num + 5
except TypeError as e:
    print(f"運(yùn)算失敗: {e}")

class ImprovedNumber:
    def __init__(self, value):
        self.value = value
    
    def __add__(self, other):
        if isinstance(other, (int, float)):
            return ImprovedNumber(self.value + other)
        elif isinstance(other, ImprovedNumber):
            return ImprovedNumber(self.value + other.value)
        else:
            raise TypeError(f"不支持的運(yùn)算類(lèi)型: {type(other)}")
    
    def __str__(self):
        return str(self.value)

# 現(xiàn)在可以正確進(jìn)行運(yùn)算了
num1 = ImprovedNumber(10)
num2 = ImprovedNumber(5)

result = num1 + num2
print(f"結(jié)果: {result}")

result2 = num1 + 3
print(f"結(jié)果: {result2}")

def safe_concatenate(str1, str2):
    """安全地連接兩個(gè)字符串"""
    # 類(lèi)型檢查
    if not isinstance(str1, str):
        raise TypeError(f"第一個(gè)參數(shù)必須是字符串，得到的是 {type(str1)}")
    
    if not isinstance(str2, str):
        raise TypeError(f"第二個(gè)參數(shù)必須是字符串，得到的是 {type(str2)}")
    
    return str1 + str2

# 測(cè)試
try:
    result = safe_concatenate("Hello", "World")
    print(f"成功: {result}")
    
    result = safe_concatenate("Hello", 123)
except TypeError as e:
    print(f"錯(cuò)誤: {e}")

def process_data(data):
    """處理不同類(lèi)型的數(shù)據(jù)"""
    if isinstance(data, str):
        return data.upper()
    elif isinstance(data, (int, float)):
        return data * 2
    elif isinstance(data, list):
        return len(data)
    else:
        raise TypeError(f"不支持的數(shù)據(jù)類(lèi)型: {type(data)}")

# 測(cè)試不同類(lèi)型的輸入
test_cases = ["hello", 42, 3.14, [1, 2, 3], {"key": "value"}]

for case in test_cases:
    try:
        result = process_data(case)
        print(f"{case} ({type(case).__name__}) -> {result}")
    except TypeError as e:
        print(f"處理 {case} 時(shí)出錯(cuò): {e}")

def flexible_add(a, b):
    """靈活的加法函數(shù)，嘗試多種方式"""
    try:
        # 直接相加
        return a + b
    except TypeError:
        try:
            # 嘗試轉(zhuǎn)換為相同類(lèi)型后相加
            if isinstance(a, str) or isinstance(b, str):
                return str(a) + str(b)
            else:
                return float(a) + float(b)
        except (ValueError, TypeError):
            # 如果所有方法都失敗，返回詳細(xì)錯(cuò)誤信息
            raise TypeError(f"無(wú)法將 {a} ({type(a)}) 和  ({type(b)}) 相加")

# 測(cè)試各種情況
test_pairs = [
    (1, 2),
    ("Hello", "World"),
    (5, " apples"),
    ("Price: $", 99.99),
    ([1, 2], [3, 4])
]

for a, b in test_pairs:
    try:
        result = flexible_add(a, b)
        print(f"{a} +  = {result}")
    except TypeError as e:
        print(f"錯(cuò)誤: {e}")

class DataProcessor:
    """數(shù)據(jù)處理器類(lèi)"""
    
    def __init__(self):
        self.processed_count = 0
    
    def validate_input(self, data):
        """驗(yàn)證輸入數(shù)據(jù)的類(lèi)型"""
        if data is None:
            raise TypeError("輸入數(shù)據(jù)不能為None")
        
        if not hasattr(data, '__iter__'):
            raise TypeError(f"輸入數(shù)據(jù)必須是可迭代的，得到的是 {type(data)}")
        
        return True
    
    def process_numbers(self, numbers):
        """處理數(shù)字列表"""
        self.validate_input(numbers)
        
        # 檢查是否都是數(shù)字
        for i, num in enumerate(numbers):
            if not isinstance(num, (int, float)):
                raise TypeError(f"索引 {i} 處的元素必須是數(shù)字，得到的是 {type(num)}")
        
        # 計(jì)算平均值
        total = sum(numbers)
        average = total / len(numbers)
        self.processed_count += 1
        
        return {
            'total': total,
            'average': average,
            'count': len(numbers),
            'processed_count': self.processed_count
        }

# 使用示例
processor = DataProcessor()

# 正確的輸入
try:
    result = processor.process_numbers([1, 2, 3, 4, 5])
    print("正確處理:", result)
except TypeError as e:
    print(f"錯(cuò)誤: {e}")

# 錯(cuò)誤的輸入
test_inputs = [
    None,
    "not a list",
    [1, 2, "three", 4],
    []
]

for input_data in test_inputs:
    try:
        result = processor.process_numbers(input_data)
        print(f"處理 {input_data}: {result}")
    except TypeError as e:
        print(f"處理 {input_data} 時(shí)發(fā)生錯(cuò)誤: {e}")

from typing import List, Union, Optional

def calculate_average(numbers: List[Union[int, float]]) -> float:
    """
    計(jì)算數(shù)字列表的平均值
    
    Args:
        numbers: 數(shù)字列表
        
    Returns:
        平均值
        
    Raises:
        TypeError: 當(dāng)輸入不是列表或包含非數(shù)字元素時(shí)
        ValueError: 當(dāng)列表為空時(shí)
    """
    if not isinstance(numbers, list):
        raise TypeError(f"期望列表類(lèi)型，得到 {type(numbers)}")
    
    if len(numbers) == 0:
        raise ValueError("列表不能為空")
    
    for i, num in enumerate(numbers):
        if not isinstance(num, (int, float)):
            raise TypeError(f"索引 {i} 處的元素必須是數(shù)字，得到的是 {type(num)}")
    
    return sum(numbers) / len(numbers)

# 測(cè)試類(lèi)型注解函數(shù)
test_cases = [
    [1, 2, 3, 4, 5],           # 正確
    [1.5, 2.5, 3.5],          # 正確
    [1, 2, "3", 4],           # 錯(cuò)誤：包含字符串
    "not a list",             # 錯(cuò)誤：不是列表
    [],                       # 錯(cuò)誤：空列表
]

for case in test_cases:
    try:
        result = calculate_average(case)
        print(f"{case} 的平均值是 {result}")
    except (TypeError, ValueError) as e:
        print(f"處理 {case} 時(shí)出錯(cuò): {e}")

from functools import reduce
from typing import Callable, Any

def safe_apply(func: Callable, *args) -> Any:
    """
    安全地應(yīng)用函數(shù)到參數(shù)上
    
    Args:
        func: 要應(yīng)用的函數(shù)
        *args: 參數(shù)列表
        
    Returns:
        函數(shù)執(zhí)行結(jié)果
        
    Raises:
        TypeError: 當(dāng)func不是可調(diào)用對(duì)象時(shí)
    """
    if not callable(func):
        raise TypeError(f"第一個(gè)參數(shù)必須是可調(diào)用對(duì)象，得到的是 {type(func)}")
    
    try:
        return func(*args)
    except Exception as e:
        # 重新拋出原始異常，但添加上下文信息
        raise TypeError(f"調(diào)用函數(shù) {func.__name__} 時(shí)出錯(cuò): {str(e)}") from e

# 測(cè)試安全應(yīng)用函數(shù)
def multiply(x, y):
    return x * y

def greet(name):
    return f"Hello, {name}!"

# 正確的函數(shù)調(diào)用
try:
    result1 = safe_apply(multiply, 3, 4)
    print(f"multiply(3, 4) = {result1}")
    
    result2 = safe_apply(greet, "Alice")
    print(f"greet('Alice') = {result2}")
    
    # 錯(cuò)誤的調(diào)用
    result3 = safe_apply("not a function", 1, 2)
except TypeError as e:
    print(f"錯(cuò)誤: {e}")

# 在高階函數(shù)中的應(yīng)用
def apply_operations(operations: List[Callable], initial_value: Any) -> Any:
    """應(yīng)用一系列操作到初始值上"""
    if not all(callable(op) for op in operations):
        raise TypeError("所有操作必須是可調(diào)用對(duì)象")
    
    return reduce(lambda acc, op: safe_apply(op, acc), operations, initial_value)

# 示例：創(chuàng)建一個(gè)處理管道
def add_ten(x):
    return x + 10

def multiply_by_two(x):
    return x * 2

def to_string(x):
    return str(x)

operations = [add_ten, multiply_by_two, to_string]

try:
    result = apply_operations(operations, 5)
    print(f"處理結(jié)果: {result} (類(lèi)型: {type(result)})")
except TypeError as e:
    print(f"管道處理錯(cuò)誤: {e}")

import logging
from enum import Enum
from typing import Dict, Any

class ErrorSeverity(Enum):
    """錯(cuò)誤嚴(yán)重程度枚舉"""
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"

class TypeErrorHandler:
    """類(lèi)型錯(cuò)誤處理器"""
    
    def __init__(self):
        self.error_log = []
        self.setup_logging()
    
    def setup_logging(self):
        """設(shè)置日志記錄"""
        logging.basicConfig(level=logging.INFO)
        self.logger = logging.getLogger(__name__)
    
    def handle_type_error(self, error: TypeError, context: str = "", severity: ErrorSeverity = ErrorSeverity.MEDIUM) -> Dict[str, Any]:
        """
        處理TypeError并記錄相關(guān)信息
        
        Args:
            error: TypeError實(shí)例
            context: 錯(cuò)誤上下文描述
            severity: 錯(cuò)誤嚴(yán)重程度
            
        Returns:
            包含錯(cuò)誤詳情的字典
        """
        error_info = {
            'error_type': type(error).__name__,
            'message': str(error),
            'context': context,
            'severity': severity.value,
            'handled_at': __import__('datetime').datetime.now().isoformat()
        }
        
        self.error_log.append(error_info)
        
        # 根據(jù)嚴(yán)重程度采取不同行動(dòng)
        if severity == ErrorSeverity.HIGH:
            self.logger.error(f"嚴(yán)重類(lèi)型錯(cuò)誤 [{context}]: {error}")
        elif severity == ErrorSeverity.MEDIUM:
            self.logger.warning(f"中等類(lèi)型錯(cuò)誤 [{context}]: {error}")
        else:
            self.logger.info(f"輕微類(lèi)型錯(cuò)誤 [{context}]: {error}")
        
        return error_info
    
    def attempt_type_conversion(self, value: Any, target_type: type, context: str = "") -> Any:
        """
        嘗試類(lèi)型轉(zhuǎn)換，如果失敗則記錄錯(cuò)誤
        
        Args:
            value: 要轉(zhuǎn)換的值
            target_type: 目標(biāo)類(lèi)型
            context: 上下文信息
            
        Returns:
            轉(zhuǎn)換后的值
            
        Raises:
            TypeError: 轉(zhuǎn)換失敗時(shí)拋出
        """
        try:
            return target_type(value)
        except (TypeError, ValueError) as e:
            error_info = self.handle_type_error(
                TypeError(f"無(wú)法將 {value} ({type(value)}) 轉(zhuǎn)換為 {target_type}"),
                context=context,
                severity=ErrorSeverity.MEDIUM
            )
            raise TypeError(f"類(lèi)型轉(zhuǎn)換失敗: {error_info['message']}") from e

# 使用示例
handler = TypeErrorHandler()

# 測(cè)試類(lèi)型轉(zhuǎn)換
test_conversions = [
    ("123", int, "字符串轉(zhuǎn)整數(shù)"),
    ("3.14", float, "字符串轉(zhuǎn)浮點(diǎn)數(shù)"),
    (42, str, "整數(shù)轉(zhuǎn)字符串"),
    ("invalid", int, "無(wú)效字符串轉(zhuǎn)整數(shù)"),
    ([1, 2, 3], str, "列表轉(zhuǎn)字符串")
]

for value, target_type, context in test_conversions:
    try:
        result = handler.attempt_type_conversion(value, target_type, context)
        print(f"? {context}: {value} -> {result}")
    except TypeError as e:
        print(f"? {context}: {e}")

print(f"\n共記錄了 {len(handler.error_log)} 個(gè)錯(cuò)誤:")
for log in handler.error_log:
    print(f"  - {log['severity'].upper()}: {log['message']}")

import time
from typing import Union

def performance_comparison():
    """比較不同的錯(cuò)誤處理方式的性能"""
    
    def method1_with_checking(value):
        """帶類(lèi)型檢查的方法"""
        if not isinstance(value, (int, float)):
            raise TypeError(f"期望數(shù)字類(lèi)型，得到 {type(value)}")
        return value ** 2
    
    def method2_with_exception(value):
        """依賴(lài)異常處理的方法"""
        try:
            return value ** 2
        except TypeError:
            raise TypeError(f"無(wú)法計(jì)算 {value} 的平方")
    
    def method3_lbyl(value):
        """Look Before You Leap風(fēng)格"""
        if hasattr(value, '__pow__'):
            return value ** 2
        else:
            raise TypeError(f"對(duì)象 {value} 不支持冪運(yùn)算")
    
    # 測(cè)試數(shù)據(jù)
    test_data = [1, 2.5, 3, "invalid", 4.0, 5] * 1000
    
    methods = [
        ("類(lèi)型檢查", method1_with_checking),
        ("異常處理", method2_with_exception),
        ("屬性檢查", method3_lbyl)
    ]
    
    results = {}
    
    for name, method in methods:
        start_time = time.time()
        success_count = 0
        error_count = 0
        
        for item in test_data:
            try:
                result = method(item)
                success_count += 1
            except TypeError:
                error_count += 1
        
        end_time = time.time()
        results[name] = {
            'time': end_time - start_time,
            'success': success_count,
            'errors': error_count
        }
    
    # 輸出結(jié)果
    print("性能比較結(jié)果:")
    for name, stats in results.items():
        print(f"  {name}: {stats['time']:.4f}秒 "
              f"(成功:{stats['success']}, 錯(cuò)誤:{stats['errors']})")

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

# 使用typing模塊進(jìn)行靜態(tài)類(lèi)型檢查提示
from typing import Protocol, runtime_checkable

@runtime_checkable
class Numeric(Protocol):
    """數(shù)值類(lèi)型協(xié)議"""
    def __add__(self, other): ...
    def __mul__(self, other): ...

def process_numeric(value: Numeric) -> Numeric:
    """處理數(shù)值類(lèi)型"""
    if not isinstance(value, Numeric):
        raise TypeError(f"值 {value} 不符合Numeric協(xié)議")
    
    return value * 2

# 測(cè)試協(xié)議類(lèi)型檢查
test_values = [1, 2.5, "string", [1, 2, 3]]

for value in test_values:
    try:
        result = process_numeric(value)
        print(f"? {value} -> {result}")
    except TypeError as e:
        print(f"? {e}")

# 自定義類(lèi)型檢查裝飾器
def type_check(**expected_types):
    """類(lèi)型檢查裝飾器"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            # 檢查位置參數(shù)
            arg_names = func.__code__.co_varnames[:func.__code__.co_argcount]
            for i, (arg_name, arg_value) in enumerate(zip(arg_names, args)):
                if arg_name in expected_types:
                    expected_type = expected_types[arg_name]
                    if not isinstance(arg_value, expected_type):
                        raise TypeError(
                            f"參數(shù) '{arg_name}' 期望 {expected_type.__name__} 類(lèi)型，"
                            f"得到 {type(arg_value).__name__}"
                        )
            
            # 檢查關(guān)鍵字參數(shù)
            for kwarg_name, kwarg_value in kwargs.items():
                if kwarg_name in expected_types:
                    expected_type = expected_types[kwarg_name]
                    if not isinstance(kwarg_value, expected_type):
                        raise TypeError(
                            f"參數(shù) '{kwarg_name}' 期望 {expected_type.__name__} 類(lèi)型，"
                            f"得到 {type(kwarg_value).__name__}"
                        )
            
            return func(*args, **kwargs)
        return wrapper
    return decorator

# 使用類(lèi)型檢查裝飾器
@type_check(x=int, y=str, z=float)
def example_function(x, y, z=3.14):
    return f"x={x}, y={y}, z={z}"

# 測(cè)試裝飾器
try:
    result = example_function(1, "hello", 2.71)
    print(f"? 正確調(diào)用: {result}")
    
    result = example_function("wrong", "hello", 2.71)  # x應(yīng)該是int
except TypeError as e:
    print(f"? 類(lèi)型錯(cuò)誤: {e}")

class APIResponseHandler:
    """API響應(yīng)處理器"""
    
    def __init__(self):
        self.successful_responses = 0
        self.failed_responses = 0
    
    def parse_response(self, response_data):
        """解析API響應(yīng)數(shù)據(jù)"""
        # 檢查基本結(jié)構(gòu)
        if not isinstance(response_data, dict):
            raise TypeError(f"響應(yīng)數(shù)據(jù)必須是字典類(lèi)型，得到 {type(response_data)}")
        
        # 檢查必需字段
        required_fields = ['status', 'data']
        for field in required_fields:
            if field not in response_data:
                raise TypeError(f"缺少必需字段: {field}")
        
        # 檢查狀態(tài)字段類(lèi)型
        status = response_data['status']
        if not isinstance(status, str):
            raise TypeError(f"status字段必須是字符串，得到 {type(status)}")
        
        # 檢查數(shù)據(jù)字段
        data = response_data['data']
        if status == 'success' and data is None:
            raise TypeError("成功響應(yīng)的數(shù)據(jù)字段不能為None")
        
        self.successful_responses += 1
        return response_data
    
    def extract_user_info(self, response_data):
        """從響應(yīng)中提取用戶信息"""
        parsed_data = self.parse_response(response_data)
        
        if parsed_data['status'] != 'success':
            self.failed_responses += 1
            raise TypeError("無(wú)法從失敗的響應(yīng)中提取用戶信息")
        
        user_data = parsed_data['data']
        if not isinstance(user_data, dict):
            raise TypeError(f"用戶數(shù)據(jù)必須是字典類(lèi)型，得到 {type(user_data)}")
        
        # 驗(yàn)證必需的用戶字段
        user_fields = ['id', 'name', 'email']
        for field in user_fields:
            if field not in user_data:
                raise TypeError(f"用戶數(shù)據(jù)缺少字段: {field}")
            
            if not isinstance(user_data[field], str):
                raise TypeError(f"用戶字段 {field} 必須是字符串，得到 {type(user_data[field])}")
        
        return {
            'id': int(user_data['id']),  # 可能需要類(lèi)型轉(zhuǎn)換
            'name': user_data['name'],
            'email': user_data['email']
        }

# 測(cè)試API響應(yīng)處理器
handler = APIResponseHandler()

# 各種測(cè)試案例
test_responses = [
    # 正確的成功響應(yīng)
    {
        'status': 'success',
        'data': {
            'id': '123',
            'name': 'Alice',
            'email': 'alice@example.com'
        }
    },
    
    # 缺少必需字段
    {
        'status': 'success',
        'data': {
            'name': 'Bob'
            # 缺少id和email
        }
    },
    
    # 數(shù)據(jù)類(lèi)型錯(cuò)誤
    {
        'status': 'success',
        'data': 'not a dict'
    },
    
    # 響應(yīng)不是字典
    "invalid response format",
    
    # 失敗響應(yīng)
    {
        'status': 'error',
        'data': None
    }
]

for i, response in enumerate(test_responses):
    try:
        user_info = handler.extract_user_info(response)
        print(f"? 響應(yīng) {i+1}: 成功提取用戶信息 {user_info}")
    except TypeError as e:
        print(f"? 響應(yīng) {i+1}: 錯(cuò)誤 - {e}")

print(f"\n統(tǒng)計(jì): 成功 {handler.successful_responses}, 失敗 {handler.failed_responses}")

def demonstrate_exception_differences():
    """演示不同類(lèi)型異常的區(qū)別"""
    
    # TypeError vs ValueError
    print("=== TypeError vs ValueError ===")
    
    try:
        result = "123" + 456  # TypeError: 不同類(lèi)型相加
    except TypeError as e:
        print(f"TypeError: {e}")
    
    try:
        result = int("abc")  # ValueError: 正確類(lèi)型但無(wú)效值
    except ValueError as e:
        print(f"ValueError: {e}")
    
    # TypeError vs AttributeError
    print("\n=== TypeError vs AttributeError ===")
    
    class SimpleClass:
        pass
    
    obj = SimpleClass()
    
    try:
        result = obj + 5  # TypeError: 不支持的操作
    except TypeError as e:
        print(f"TypeError: {e}")
    
    try:
        result = obj.nonexistent_method()  # AttributeError: 屬性不存在
    except AttributeError as e:
        print(f"AttributeError: {e}")
    
    # TypeError vs IndexError
    print("\n=== TypeError vs IndexError ===")
    
    my_list = [1, 2, 3]
    
    try:
        result = my_list + "string"  # TypeError: 列表不能與字符串相加
    except TypeError as e:
        print(f"TypeError: {e}")
    
    try:
        result = my_list[10]  # IndexError: 索引超出范圍
    except IndexError as e:
        print(f"IndexError: {e}")

demonstrate_exception_differences()

class BestPracticesDemo:
    """最佳實(shí)踐演示類(lèi)"""
    
    @staticmethod
    def validate_and_convert(value, target_type, field_name=""):
        """
        驗(yàn)證并轉(zhuǎn)換類(lèi)型的最佳實(shí)踐
        
        Args:
            value: 要驗(yàn)證的值
            target_type: 目標(biāo)類(lèi)型
            field_name: 字段名稱(chēng)（用于錯(cuò)誤消息）
            
        Returns:
            轉(zhuǎn)換后的值
        """
        # 1. 提供清晰的錯(cuò)誤消息
        field_msg = f"字段 '{field_name}' " if field_name else ""
        
        # 2. 先檢查None值
        if value is None:
            raise TypeError(f"{field_msg}不能為None")
        
        # 3. 檢查目標(biāo)類(lèi)型
        if not isinstance(target_type, type):
            raise TypeError("target_type必須是一個(gè)類(lèi)型")
        
        # 4. 執(zhí)行類(lèi)型轉(zhuǎn)換
        try:
            return target_type(value)
        except (TypeError, ValueError) as e:
            raise TypeError(
                f"{field_msg}期望 {target_type.__name__} 類(lèi)型，"
                f"得到 {type(value).__name__}: {value}"
            ) from e
    
    @staticmethod
    def safe_operation(operation_func, *args, **kwargs):
        """
        安全執(zhí)行操作的包裝器
        
        Args:
            operation_func: 要執(zhí)行的操作函數(shù)
            *args: 位置參數(shù)
            **kwargs: 關(guān)鍵字參數(shù)
            
        Returns:
            操作結(jié)果
        """
        # 1. 驗(yàn)證函數(shù)可調(diào)用性
        if not callable(operation_func):
            raise TypeError(f"operation_func必須是可調(diào)用對(duì)象，得到 {type(operation_func)}")
        
        # 2. 執(zhí)行操作并處理異常
        try:
            return operation_func(*args, **kwargs)
        except TypeError as e:
            # 3. 提供更多上下文信息
            raise TypeError(
                f"執(zhí)行操作 '{operation_func.__name__}' 時(shí)發(fā)生類(lèi)型錯(cuò)誤: {e}"
            ) from e

# 演示最佳實(shí)踐
demo = BestPracticesDemo()

# 測(cè)試類(lèi)型驗(yàn)證和轉(zhuǎn)換
test_conversions = [
    ("123", int, "user_id"),
    (45.67, str, "price"),
    ("invalid", int, "quantity"),
    (None, str, "description")
]

print("=== 類(lèi)型驗(yàn)證和轉(zhuǎn)換 ===")
for value, target_type, field_name in test_conversions:
    try:
        result = demo.validate_and_convert(value, target_type, field_name)
        print(f"? {field_name}: {value} -> {result}")
    except TypeError as e:
        print(f"? {e}")

# 測(cè)試安全操作
print("\n=== 安全操作執(zhí)行 ===")

def divide(a, b):
    return a / b

def concatenate_strings(*strings):
    return "".join(strings)

safe_operations = [
    (divide, 10, 2),
    (divide, 10, 0),  # 這會(huì)引發(fā)ZeroDivisionError，不是TypeError
    (concatenate_strings, "Hello", " ", "World"),
    (concatenate_strings, "Hello", 123),  # TypeError
    ("not_a_function", 1, 2)  # TypeError: 不是可調(diào)用對(duì)象
]

for operation, *args in safe_operations:
    try:
        result = demo.safe_operation(operation, *args)
        print(f"? {operation.__name__ if callable(operation) else operation}{args} = {result}")
    except TypeError as e:
        print(f"? 類(lèi)型錯(cuò)誤: {e}")
    except Exception as e:
        print(f"? 其他錯(cuò)誤: {type(e).__name__}: {e}")