# 基本類型提示
def add(a: int, b: int) -> int:
    return a + b
# 列表類型提示
from typing import List
def process_numbers(numbers: List[int]) -> List[int]:
    return [n * 2 for n in numbers]
# 字典類型提示
from typing import Dict
def get_user_info(user_id: int) -> Dict[str, str]:
    return {"id": str(user_id), "name": "張三"}

# 安裝mypy
pip install mypy
# 檢查代碼
mypy your_code.py

from typing import get_type_hints, Union
import inspect
def type_check(func):
    """類型檢查裝飾器"""
    def wrapper(*args, **kwargs):
        # 獲取函數(shù)的類型提示
        type_hints = get_type_hints(func)
        # 檢查位置參數(shù)
        sig = inspect.signature(func)
        params = list(sig.parameters.values())
        # 檢查位置參數(shù)類型
        for i, (param_name, arg_value) in enumerate(zip(params, args)):
            if param_name in type_hints:
                expected_type = type_hints[param_name]
                if not isinstance(arg_value, expected_type):
                    raise TypeError(f"參數(shù) {param_name} 期望類型 {expected_type}，實際類型 {type(arg_value)}")
        # 檢查關(guān)鍵字參數(shù)類型
        for param_name, arg_value in kwargs.items():
            if param_name in type_hints:
                expected_type = type_hints[param_name]
                if not isinstance(arg_value, expected_type):
                    raise TypeError(f"參數(shù) {param_name} 期望類型 {expected_type}，實際類型 {type(arg_value)}")
        # 執(zhí)行函數(shù)
        result = func(*args, **kwargs)
        # 檢查返回值類型
        if 'return' in type_hints:
            expected_return_type = type_hints['return']
            if not isinstance(result, expected_return_type):
                raise TypeError(f"返回值期望類型 {expected_return_type}，實際類型 {type(result)}")
        return result
    return wrapper
# 使用裝飾器
@type_check
def add(a: int, b: int) -> int:
    return a + b
# 測試
print(add(1, 2))  # 正常運行
print(add(1, "2"))  # 拋出類型錯誤

from typing import get_type_hints, Union, List, Dict, Optional, TypeVar, Generic
import inspect
import typing
T = TypeVar('T')
class TypeChecker:
    """類型檢查器"""
    @staticmethod
    def is_instance(obj, expected_type):
        """檢查對象是否符合期望類型"""
        # 處理基本類型
        if isinstance(expected_type, type):
            return isinstance(obj, expected_type)
        # 處理Union類型
        if getattr(expected_type, '__origin__', None) is Union:
            return any(TypeChecker.is_instance(obj, arg) for arg in expected_type.__args__)
        # 處理List類型
        if getattr(expected_type, '__origin__', None) is list or getattr(expected_type, '__origin__', None) is List:
            if not isinstance(obj, list):
                return False
            item_type = expected_type.__args__[0]
            return all(TypeChecker.is_instance(item, item_type) for item in obj)
        # 處理Dict類型
        if getattr(expected_type, '__origin__', None) is dict or getattr(expected_type, '__origin__', None) is Dict:
            if not isinstance(obj, dict):
                return False
            key_type, value_type = expected_type.__args__
            return all(
                TypeChecker.is_instance(key, key_type) and TypeChecker.is_instance(value, value_type)
                for key, value in obj.items()
            )
        # 處理Optional類型
        if getattr(expected_type, '__origin__', None) is Optional:
            if obj is None:
                return True
            return TypeChecker.is_instance(obj, expected_type.__args__[0])
        return True
def type_check(func):
    """類型檢查裝飾器"""
    def wrapper(*args, **kwargs):
        # 獲取函數(shù)的類型提示
        type_hints = get_type_hints(func)
        # 檢查位置參數(shù)
        sig = inspect.signature(func)
        params = list(sig.parameters.values())
        # 檢查位置參數(shù)類型
        for i, (param_name, arg_value) in enumerate(zip(params, args)):
            if param_name in type_hints:
                expected_type = type_hints[param_name]
                if not TypeChecker.is_instance(arg_value, expected_type):
                    raise TypeError(f"參數(shù) {param_name} 期望類型 {expected_type}，實際類型 {type(arg_value)}")
        # 檢查關(guān)鍵字參數(shù)類型
        for param_name, arg_value in kwargs.items():
            if param_name in type_hints:
                expected_type = type_hints[param_name]
                if not TypeChecker.is_instance(arg_value, expected_type):
                    raise TypeError(f"參數(shù) {param_name} 期望類型 {expected_type}，實際類型 {type(arg_value)}")
        # 執(zhí)行函數(shù)
        result = func(*args, **kwargs)
        # 檢查返回值類型
        if 'return' in type_hints:
            expected_return_type = type_hints['return']
            if not TypeChecker.is_instance(result, expected_return_type):
                raise TypeError(f"返回值期望類型 {expected_return_type}，實際類型 {type(result)}")
        return result
    return wrapper
# 使用裝飾器
@type_check
def process_data(data: List[int]) -> Dict[str, Union[int, str]]:
    return {
        "sum": sum(data),
        "count": len(data),
        "status": "success"
    }
# 測試
print(process_data([1, 2, 3]))  # 正常運行
print(process_data([1, "2", 3]))  # 拋出類型錯誤

enum Result<T, E> {
    Ok(T),
    Err(E),
}

from typing import Generic, TypeVar, Union, Optional
T = TypeVar('T')
E = TypeVar('E')
class Result(Generic[T, E]):
    """Rust風(fēng)格的Result類型"""
    def __init__(self, value: Union[T, E], is_ok: bool):
        self.value = value
        self._is_ok = is_ok
    @classmethod
    def ok(cls, value: T) -> 'Result[T, E]':
        """創(chuàng)建成功的Result"""
        return cls(value, True)
    @classmethod
    def err(cls, error: E) -> 'Result[T, E]':
        """創(chuàng)建失敗的Result"""
        return cls(error, False)
    def is_ok(self) -> bool:
        """檢查是否成功"""
        return self._is_ok
    def is_err(self) -> bool:
        """檢查是否失敗"""
        return not self._is_ok
    def unwrap(self) -> T:
        """獲取成功值，如果失敗則拋出異常"""
        if self.is_ok():
            return self.value
        raise ValueError(f"Result is Err: {self.value}")
    def unwrap_err(self) -> E:
        """獲取錯誤值，如果成功則拋出異常"""
        if self.is_err():
            return self.value
        raise ValueError("Result is Ok")
    def unwrap_or(self, default: T) -> T:
        """獲取成功值，如果失敗則返回默認(rèn)值"""
        if self.is_ok():
            return self.value
        return default
# 使用Result類型
def divide(a: int, b: int) -> Result[int, str]:
    if b == 0:
        return Result.err("除數(shù)不能為零")
    return Result.ok(a // b)
# 測試
result = divide(10, 2)
if result.is_ok():
    print(f"結(jié)果: {result.unwrap()}")
else:
    print(f"錯誤: {result.unwrap_err()}")
result = divide(10, 0)
if result.is_ok():
    print(f"結(jié)果: {result.unwrap()}")
else:
    print(f"錯誤: {result.unwrap_err()}")

enum Option<T> {
    Some(T),
    None,
}

from typing import Generic, TypeVar, Optional
T = TypeVar('T')
class Option(Generic[T]):
    """Rust風(fēng)格的Option類型"""
    def __init__(self, value: Optional[T], is_some: bool):
        self.value = value
        self._is_some = is_some
    @classmethod
    def some(cls, value: T) -> 'Option[T]':
        """創(chuàng)建有值的Option"""
        return cls(value, True)
    @classmethod
    def none(cls) -> 'Option[T]':
        """創(chuàng)建無值的Option"""
        return cls(None, False)
    def is_some(self) -> bool:
        """檢查是否有值"""
        return self._is_some
    def is_none(self) -> bool:
        """檢查是否無值"""
        return not self._is_some
    def unwrap(self) -> T:
        """獲取值，如果無值則拋出異常"""
        if self.is_some():
            return self.value
        raise ValueError("Option is None")
    def unwrap_or(self, default: T) -> T:
        """獲取值，如果無值則返回默認(rèn)值"""
        if self.is_some():
            return self.value
        return default
# 使用Option類型
def find_user(user_id: int) -> Option[dict]:
    users = {1: {"id": 1, "name": "張三"}, 2: {"id": 2, "name": "李四"}}
    if user_id in users:
        return Option.some(users[user_id])
    return Option.none()
# 測試
user = find_user(1)
if user.is_some():
    print(f"用戶: {user.unwrap()}")
else:
    print("用戶不存在")
user = find_user(3)
if user.is_some():
    print(f"用戶: {user.unwrap()}")
else:
    print("用戶不存在")