Rust 与 Python：语法对比全景指南

像风一样自由2020

1242人浏览 · 2025-10-21 09:46:23

像风一样自由2020 · 2025-10-21 09:46:23 发布

Rust 与 Python：语法对比全景指南

在这里插入图片描述

写在前面

Rust 与 Python 分别代表现代系统语言与脚本语言的两大阵营，一个以零成本抽象和内存安全著称，另一个以快速迭代和极简语法闻名。本文聚焦语法与语言机制的核心差异与共同点，帮助团队在跨语言协作或技术选型时快速建立认知地图。

适用读者：已有任一语言基础，想理解另一语言语法特性或规划多语言栈的开发者。
阅读时间：≈15 分钟。

快速印象：设计哲学与核心特性

Rust：编译期保证内存与并发安全；零成本抽象；无垃圾回收；偏重显式约束。
Python：动态类型、解释执行；极简语法；拥有庞大标准库与社区生态；强调开发效率。
共同点：开放源代码；跨平台；强调可读性；都有良好的包管理工具与活跃社区。

Hello, world!

fn main() {
    println!("Hello, world!");
}

if __name__ == "__main__":
    print("Hello, world!")

Rust 入口函数是 main，编译后运行；Python 常以脚本作为入口，运行时判断是否为主模块。

变量绑定与类型系统

Rust：强类型、默认不可变

let 声明绑定，默认不可变，使用 let mut 开启可变性。
编译器强制类型一致，可通过 : 指定类型，也支持类型推断。
变量作用域由花括号块界定，离开作用域即释放资源。

let answer: i32 = 42;
let mut counter = 0;
counter += 1;

Python：动态类型、默认可变

赋值语句创建名称到对象的绑定，类型在运行期决定。
大多数内置容器为可变对象，需要以约定维护不变性。
作用域基于缩进块；函数即作用域边界，文件级作用域默认全局。

answer = 42
counter = 0
counter += 1

对比要点

Rust 编译期捕获类型错误，Python 倾向于运行期异常。
Rust 的可变性显式声明有助于并发安全，Python 通过约定与单线程 GIL 规避数据竞争。
两者都支持类型注解：Rust 原生语法；Python 通过 typing 模块提供可选静态分析。

常用数据结构语法

目的	Rust 写法	Python 写法	说明
可变序列	`let mut v = vec![1, 2, 3];`	`v = [1, 2, 3]`	Rust 标准库 `Vec<T>`；Python 列表内置。
不可变序列	`let tuple = (1, "hi");`	`tuple_ = (1, "hi")`	Rust 元组字段可混合类型，长度固定；Python 元组常用于不可变序列。
切片/视图	`let slice = &v[1..];`	`slice_ = v[1:]`	Rust 切片携带长度信息；Python 直接返回列表片段。
字典映射	`use std::collections::HashMap;` `hash_map.insert("k", "v");`	`mapping = {"k": "v"}`	Rust 需显式导入集合；Python 字典字面量。
字符串构建	`let s = format!("user: {}", name);`	`s = f"user: {name}"`	Rust 使用宏；Python 使用 f-string。

模式匹配与解构

Rust 拥有代数数据类型和 match，适合穷举处理；Python 3.10+ 引入结构化模式匹配。

enum Command {
    Move { x: i32, y: i32 },
    Quit,
}

fn handle(cmd: Command) {
    match cmd {
        Command::Move { x, y } => println!("move to {x}, {y}"),
        Command::Quit => println!("quit"),
    }
}

match cmd:
    case {"type": "move", "x": x, "y": y}:
        print(f"move to {x}, {y}")
    case {"type": "quit"}:
        print("quit")

Python 的匹配基于数据结构形状，缺乏编译期穷举校验；Rust 编译器强制处理所有分支。

控制流表达式

条件：Rust 的 if 是表达式，返回值可直接赋给变量；Python 的 if 为语句，需要借助三元表达式才能嵌入表达式。
循环：Rust 提供 loop/while/for，其中 for 基于 IntoIterator trait；Python for 迭代任何可迭代对象。
提早返回：Rust 使用 return 或在块尾表达式；Python 直接 return，支持多值返回（实为元组）。

let status = if is_ready() { "ready" } else { "pending" };
for item in items.iter() {
    process(item);
}

status = "ready" if is_ready() else "pending"
for item in items:
    process(item)

函数、闭包与泛型

Rust

函数签名需声明参数与返回值类型。
impl 块定义方法；trait 提供接口抽象。
闭包使用 |args| {} 语法，可捕获环境变量，需遵循所有权规则。
泛型通过尖括号与 trait bounds 限制能力。

fn max<T: Ord>(a: T, b: T) -> T {
    if a > b { a } else { b }
}

let add = |lhs: i32, rhs: i32| lhs + rhs;

Python

函数参数无类型限制，可使用类型注解辅助工具，如 def max(a: T, b: T) -> T。
闭包以 lambda 或内部函数实现，自由捕获外部变量。
泛型通过 typing.Generic 等协议在静态分析阶段起作用，运行期不强制约束。

from typing import TypeVar

T = TypeVar("T")

def max_(a: T, b: T) -> T:
    return a if a > b else b

add = lambda lhs, rhs: lhs + rhs

内存管理：所有权与垃圾回收

Rust：所有权模型保证资源在编译期可预测释放；借用检查器防止悬垂引用与数据竞争；Rc/Arc 提供引用计数。
Python：基于引用计数的垃圾回收，搭配循环检测；开发者无需手动管理内存，但需注意对象生命周期与性能。
影响：Rust 代码在设计阶段需考虑借用关系与生命周期；Python 更关注避免持有过多对象或循环引用。

Trait 与鸭子类型

Rust 通过 trait 显式声明能力，编译期实现多态；Python 遵循鸭子类型，只要对象提供需要的方法即可。

trait Summarize {
    fn summary(&self) -> String;
}

impl Summarize for Article {
    fn summary(&self) -> String {
        format!("{} - {}", self.author, self.title)
    }
}

class Article:
    def summary(self) -> str:
        return f"{self.author} - {self.title}"

def print_summary(item):
    print(item.summary())

Python 不要求 item 属于某个接口；Rust 需要为类型实现 Summarize 才能调用相关方法。

模块组织与依赖管理

Rust：使用 mod 定义模块，pub 控制可见性；项目由 Cargo 管理，Cargo.toml 描述依赖与构建目标。
Python：以文件和目录构成模块与包；依赖通过 requirements.txt、pipenv、poetry 等工具；解释器在运行期解析导入路径。
两者都支持虚拟环境/工具链管理（Rust 的 rustup，Python 的 venv/conda 等）。

错误处理风格

Rust 倾向显式返回 Result<T, E>，通过 ? 运算符向上传播错误；Python 使用异常机制，按需捕获处理。

fn read_config(path: &str) -> Result<String, std::io::Error> {
    let content = std::fs::read_to_string(path)?;
    Ok(content)
}

def read_config(path: str) -> str:
    with open(path, "r", encoding="utf-8") as f:
        return f.read()

Rust 编译器强制处理 Result，确保错误路径显式；Python 的异常若未捕获会在运行期抛出。

并发与异步模型

Rust：多线程通过 std::thread，共享数据需 Arc<Mutex<T>>；异步生态基于 async/await，常见执行器有 Tokio、async-std。
Python：多线程受 GIL 限制，常用于 I/O；多进程通过 multiprocessing；异步基于 asyncio/await，也有 Trio、Curio 等运行时。
差异：Rust 并发在编译期保证安全；Python 更强调易用性，性能依赖 C 扩展或多进程。

互操作与 FFI

Rust 可通过 pyo3、rust-numpy 将库导出为 Python 模块，实现性能热点加速。
Python 通过 ctypes、cffi、PyO3 或 maturin 调用 Rust/C 编写的扩展。
多语言栈常见模式：Rust 提供底层高性能逻辑，Python 负责数据管道与编排。

两者共享的语法与理念

模块化组织与包管理逐渐趋同，强调可重用性。
测试驱动文化：Rust 的 cargo test 与 Python 的 pytest 均鼓励单元测试。
文档友好：Rust 的 /// 文档注释与 cargo doc；Python 的 docstring 与 Sphinx。
社区倡导可读性：Rust 的 Clippy 与 Python 的 PEP 8/Lint 工具帮助保持代码风格一致。

技术选型建议

性能关键路径：优先选 Rust 或将 Rust 作为 Python 扩展模块，获取零成本抽象与内存安全优势。
快速原型/数据科学：Python 生态成熟，上手快，适合验证业务假设并快速迭代。
长期维护成本：Rust 前期学习曲线陡峭，但能减少运行时异常；Python 更依赖团队约束和测试覆盖。
多语言协作：使用统一的接口规范（如 gRPC、REST）和 CI 流程，同时在代码层约定类型协议或数据格式，降低胶水成本。

学习路线与资源

Rust：《The Rust Programming Language》《Rust By Example》《rustlings》练习集；社区资源如 Rust 官方博客、This Week in Rust。
Python：《Fluent Python》《Effective Python》《Python 官方文档》；实用课程如 Real Python、Talk Python。
组合使用：了解 pyo3、maturin、PyO3 Async 等桥接方案；关注 Polars、PyTorch 等项目如何在 Rust/Python 间分工。