Python实现简单的Rust风格类型检查

宋时安

发布时间：2026-10-12| 3人浏览过

原创

本文介绍如何在Python中实现类似Rust的静态类型检查机制。通过结合mypy进行编译时检查与自定义装饰器实现运行时校验，文章详细展示了Result和Option类型的Python实现方案，帮助开发者在保持Python灵活性的同时提升代码可靠性与可维护性。

前言

作为一名正在学习Rust的转行初学者，我对Rust严谨的类型系统印象深刻。近期开始接触Python时，我发现其动态类型虽然提供了极高的灵活性，但也容易引发运行时的类型错误。本文旨在分享一种在Python中模拟Rust风格类型检查的方法，以平衡灵活性与安全性。

一、Rust类型系统的优势

1.1 Rust类型系统的特点

Rust的类型系统具备以下核心特征：

静态类型：在编译阶段完成类型检查
类型推断：编译器能够自动推导变量类型
所有权系统：借助所有权机制和借用检查器，在编译期杜绝内存错误
模式匹配：提供强大的模式匹配功能

1.2 Python类型系统的特点

Python的类型系统呈现以下特点：

动态类型：类型检查发生在运行阶段
类型提示：自Python 3.5版本起支持类型提示功能
灵活性：变量在运行过程中可随时改变类型
简洁性：代码编写更加简洁且易于阅读

二、Python中的类型提示

2.1 基本类型提示

从Python 3.5版本开始，可以使用类型提示来标注变量和函数的类型：

# 基本类型提示
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": "张三"}

2.2 类型提示的局限性

尽管Python引入了类型提示，但仍存在以下局限性：

可选性：类型提示仅为建议，不影响代码的实际执行
运行时检查：默认情况下，类型提示不会在运行时进行强制校验
复杂类型：处理复杂数据结构时，类型提示的定义可能变得繁琐

三、实现Rust风格的类型检查

3.1 使用mypy进行静态类型检查

mypy是一款静态类型检查工具，能够在代码编译前检查Python代码的类型一致性：

# 安装mypy
pip install mypy
# 检查代码
mypy your_code.py

3.2 实现运行时类型检查

我们可以通过定义装饰器来实现运行时的类型校验：

from typing import get_type_hints, Union
import inspect
def type_check(func):
    """类型检查装饰器"""
    def wrapper(*args, **kwargs):
        # 获取函数的类型提示
        type_hints = get_type_hints(func)
        # 检查位置参数
        sig = inspect.signature(func)
        params = list(sig.parameters.values())
        # 检查位置参数类型
        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"参数 {param_name} 期望类型 {expected_type}，实际类型 {type(arg_value)}")
        # 检查关键字参数类型
        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"参数 {param_name} 期望类型 {expected_type}，实际类型 {type(arg_value)}")
        # 执行函数
        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"))  # 抛出类型错误

3.3 实现更复杂的类型检查

进一步扩展类型检查装饰器，以支持更复杂的类型结构：

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):
        # 获取函数的类型提示
        type_hints = get_type_hints(func)
        # 检查位置参数
        sig = inspect.signature(func)
        params = list(sig.parameters.values())
        # 检查位置参数类型
        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"参数 {param_name} 期望类型 {expected_type}，实际类型 {type(arg_value)}")
        # 检查关键字参数类型
        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"参数 {param_name} 期望类型 {expected_type}，实际类型 {type(arg_value)}")
        # 执行函数
        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]))  # 抛出类型错误

四、实现Rust风格的Result类型

4.1 Rust的Result类型

在Rust中，Result类型用于封装可能失败的操作结果：

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

4.2 在Python中实现Result类型

我们可以在Python中构建类似的Result类型：

from typing import Generic, TypeVar, Union, Optional
T = TypeVar('T')
E = TypeVar('E')
class Result(Generic[T, E]):
    """Rust风格的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]':
        """创建成功的Result"""
        return cls(value, True)
    @classmethod
    def err(cls, error: E) -> 'Result[T, E]':
        """创建失败的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:
        """获取成功值，如果失败则返回默认值"""
        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("除数不能为零")
    return Result.ok(a // b)
# 测试
result = divide(10, 2)
if result.is_ok():
    print(f"结果: {result.unwrap()}")
else:
    print(f"错误: {result.unwrap_err()}")
result = divide(10, 0)
if result.is_ok():
    print(f"结果: {result.unwrap()}")
else:
    print(f"错误: {result.unwrap_err()}")

五、实现Rust风格的Option类型

5.1 Rust的Option类型

在Rust中，Option类型用于表示可能存在也可能不存在的值：

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

5.2 在Python中实现Option类型

我们可以在Python中实现对应的Option类型：

from typing import Generic, TypeVar, Optional
T = TypeVar('T')
class Option(Generic[T]):
    """Rust风格的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]':
        """创建有值的Option"""
        return cls(value, True)
    @classmethod
    def none(cls) -> 'Option[T]':
        """创建无值的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:
        """获取值，如果无值则返回默认值"""
        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("用户不存在")