Python与Rust语法对比详解：从入门到精通

前言

Python和Rust作为当今最受关注的编程语言，分别代表了动态类型和静态类型语言的典型特征。本文将从语法层面深入对比这两种语言，帮助开发者理解它们的设计理念和使用场景。
在这里插入图片描述

1. 基础语法结构

1.1 Hello World 对比

Python:

print("Hello, World!")

Rust:

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

关键差异:

Python: 脚本式，直接执行
Rust: 需要main函数作为程序入口点
Rust: 使用宏 println! 而非函数

1.2 注释语法

Python:

# 单行注释
"""
多行注释
或文档字符串
"""

Rust:

// 单行注释
/* 多行注释 */
/// 文档注释（外部）
//! 文档注释（内部）

2. 变量与数据类型

2.1 变量声明

Python:

# 动态类型，无需声明类型
name = "Alice"
age = 30
height = 5.8
is_student = True# 可以重新赋值不同类型
name = 123  # 完全合法

Rust:

// 静态类型，默认不可变
let name = "Alice";           // 字符串字面量 &str
let age = 30;                 // 默认 i32
let height = 5.8;             // 默认 f64
let is_student = true;        // bool// 可变变量需要 mut 关键字
let mut counter = 0;
counter += 1;// 类型注解
let age: u32 = 30;
let name: String = String::from("Alice");

2.2 常量定义

Python:

# 约定大写表示常量，但可以修改
PI = 3.14159
MAX_SIZE = 100

Rust:

// 编译时常量，真正不可变
const PI: f64 = 3.14159;
const MAX_SIZE: usize = 100;// 静态变量
static GLOBAL_VAR: i32 = 42;

2.3 基本数据类型

Python:

# 数值类型
integer = 42
float_num = 3.14
complex_num = 1 + 2j# 字符串
text = "Hello"
multi_line = """
多行
字符串
"""# 布尔值
flag = True

Rust:

// 整数类型（有符号和无符号）
let signed: i32 = -42;
let unsigned: u32 = 42;
let byte: u8 = 255;
let long: i64 = 1000000;// 浮点类型
let float32: f32 = 3.14;
let float64: f64 = 3.141592653589793;// 字符和字符串
let character: char = 'A';
let string_slice: &str = "Hello";
let owned_string: String = String::from("Hello");// 布尔值
let flag: bool = true;

3. 集合数据类型

3.1 数组与列表

Python:

# 列表（动态数组）
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]  # 可以混合类型# 列表操作
numbers.append(6)
numbers.extend([7, 8])
first = numbers[0]
last = numbers[-1]
slice_data = numbers[1:4]

Rust:

// 数组（固定大小）
let numbers: [i32; 5] = [1, 2, 3, 4, 5];
let zeros = [0; 10];  // 10个0// 向量（动态数组）
let mut vec_numbers = vec![1, 2, 3, 4, 5];
vec_numbers.push(6);
vec_numbers.extend(&[7, 8]);// 访问元素
let first = vec_numbers[0];
let slice = &vec_numbers[1..4];// 所有元素必须是同一类型
// let mixed = vec![1, "hello"];  // 编译错误

3.2 字典与哈希映射

Python:

# 字典
person = {"name": "Alice","age": 30,"city": "New York"
}# 字典操作
person["job"] = "Engineer"
age = person.get("age", 0)
keys = list(person.keys())

Rust:

use std::collections::HashMap;// HashMap
let mut person = HashMap::new();
person.insert("name", "Alice");
person.insert("age", "30");
person.insert("city", "New York");// 或者使用宏创建
let person = [("name", "Alice"),("age", "30"),("city", "New York"),
].iter().cloned().collect::<HashMap<&str, &str>>();// 访问
let age = person.get("age").unwrap_or(&"0");

3.3 元组

Python:

# 元组
point = (10, 20)
person = ("Alice", 30, "Engineer")# 解包
x, y = point
name, age, job = person

Rust:

// 元组
let point: (i32, i32) = (10, 20);
let person: (&str, u32, &str) = ("Alice", 30, "Engineer");// 解构
let (x, y) = point;
let (name, age, job) = person;// 访问元素
let first = point.0;
let second = point.1;

4. 控制流结构

4.1 条件语句

Python:

# if-elif-else
if age < 18:print("Minor")
elif age < 65:print("Adult")
else:print("Senior")# 三元操作符
status = "adult" if age >= 18 else "minor"

Rust:

// if-else if-else
if age < 18 {println!("Minor");
} else if age < 65 {println!("Adult");
} else {println!("Senior");
}// if 表达式
let status = if age >= 18 { "adult" } else { "minor" };// match 表达式（更强大）
let status = match age {0..=17 => "minor",18..=64 => "adult",_ => "senior",
};

4.2 循环结构

Python:

# for 循环
for i in range(5):print(i)for item in [1, 2, 3]:print(item)for key, value in {"a": 1, "b": 2}.items():print(f"{key}: {value}")# while 循环
count = 0
while count < 5:print(count)count += 1# 列表推导
squares = [x**2 for x in range(10) if x % 2 == 0]

Rust:

// for 循环
for i in 0..5 {println!("{}", i);
}for item in &[1, 2, 3] {println!("{}", item);
}for (key, value) in &[("a", 1), ("b", 2)] {println!("{}: {}", key, value);
}// while 循环
let mut count = 0;
while count < 5 {println!("{}", count);count += 1;
}// loop 无限循环
let mut x = 0;
loop {if x > 10 { break; }x += 1;
}// 迭代器链式操作
let squares: Vec<i32> = (0..10).filter(|x| x % 2 == 0).map(|x| x * x).collect();

5. 函数定义

5.1 基本函数语法

Python:

# 基本函数
def greet(name):return f"Hello, {name}!"# 默认参数
def greet(name, greeting="Hello"):return f"{greeting}, {name}!"# 可变参数
def sum_all(*args):return sum(args)def print_info(**kwargs):for key, value in kwargs.items():print(f"{key}: {value}")# 类型提示（可选）
def add(a: int, b: int) -> int:return a + b

Rust:

// 基本函数
fn greet(name: &str) -> String {format!("Hello, {}!", name)
}// 默认参数需要通过重载或 Option 实现
fn greet_with_default(name: &str, greeting: Option<&str>) -> String {let greeting = greeting.unwrap_or("Hello");format!("{}, {}!", greeting, name)
}// 可变参数使用宏或 Vec
fn sum_all(numbers: &[i32]) -> i32 {numbers.iter().sum()
}// 泛型函数
fn add<T>(a: T, b: T) -> T 
where T: std::ops::Add<Output = T>,
{a + b
}

5.2 闭包与lambda

Python:

# lambda 表达式
square = lambda x: x * x
add = lambda a, b: a + b# 高阶函数
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
evens = list(filter(lambda x: x % 2 == 0, numbers))

Rust:

// 闭包
let square = |x| x * x;
let add = |a, b| a + b;// 高阶函数
let numbers = vec![1, 2, 3, 4, 5];
let squared: Vec<i32> = numbers.iter().map(|x| x * x).collect();
let evens: Vec<&i32> = numbers.iter().filter(|&x| x % 2 == 0).collect();// 闭包捕获环境
let multiplier = 2;
let multiply = |x| x * multiplier;

6. 面向对象编程

6.1 类与结构体

Python:

class Person:def __init__(self, name, age):self.name = nameself.age = ageself._private = "私有属性"def greet(self):return f"Hi, I'm {self.name}"@propertydef adult(self):return self.age >= 18@staticmethoddef species():return "Homo sapiens"# 继承
class Student(Person):def __init__(self, name, age, school):super().__init__(name, age)self.school = schooldef study(self):return f"{self.name} is studying at {self.school}"

Rust:

// 结构体
struct Person {name: String,age: u32,private_field: String,  // 私有性通过模块控制
}// 实现方法
impl Person {// 关联函数（类似静态方法）fn new(name: String, age: u32) -> Person {Person {name,age,private_field: String::from("私有"),}}// 方法fn greet(&self) -> String {format!("Hi, I'm {}", self.name)}fn is_adult(&self) -> bool {self.age >= 18}// 可变引用方法fn have_birthday(&mut self) {self.age += 1;}
}// Trait（类似接口）
trait Student {fn study(&self) -> String;
}impl Student for Person {fn study(&self) -> String {format!("{} is studying", self.name)}
}

6.2 枚举类型

Python:

from enum import Enumclass Color(Enum):RED = 1GREEN = 2BLUE = 3# 使用
color = Color.RED
if color == Color.RED:print("It's red!")

Rust:

// 枚举（功能更强大）
enum Color {Red,Green,Blue,
}// 带数据的枚举
enum IpAddr {V4(u8, u8, u8, u8),V6(String),
}// 使用
let color = Color::Red;
match color {Color::Red => println!("It's red!"),Color::Green => println!("It's green!"),Color::Blue => println!("It's blue!"),
}let ip = IpAddr::V4(127, 0, 0, 1);
match ip {IpAddr::V4(a, b, c, d) => println!("IPv4: {}.{}.{}.{}", a, b, c, d),IpAddr::V6(addr) => println!("IPv6: {}", addr),
}

3. 错误处理机制

3.1 异常 vs Result

Python:

# 异常处理
try:result = 10 / 0file = open("nonexistent.txt")
except ZeroDivisionError:print("除零错误")
except FileNotFoundError:print("文件未找到")
except Exception as e:print(f"其他错误: {e}")
finally:print("清理代码")# 抛出异常
def divide(a, b):if b == 0:raise ValueError("除数不能为零")return a / b

Rust:

use std::fs::File;
use std::io::ErrorKind;// Result 类型
fn divide(a: f64, b: f64) -> Result<f64, String> {if b == 0.0 {Err(String::from("除数不能为零"))} else {Ok(a / b)}
}// 使用 Result
match divide(10.0, 2.0) {Ok(result) => println!("结果: {}", result),Err(error) => println!("错误: {}", error),
}// ? 操作符用于错误传播
fn read_file() -> Result<String, std::io::Error> {let mut file = File::open("test.txt")?;  // 如果失败直接返回错误// 处理文件...Ok(String::from("文件内容"))
}// Option 类型处理可能为空的值
fn find_item(list: &[i32], target: i32) -> Option<usize> {for (index, &item) in list.iter().enumerate() {if item == target {return Some(index);}}None
}

4. 内存管理与所有权

4.1 内存管理对比

Python:

# 自动内存管理
def create_list():data = [1, 2, 3, 4, 5]return data  # Python 会自动管理内存list1 = create_list()
list2 = list1  # 两个变量指向同一对象
list2.append(6)
print(list1)  # [1, 2, 3, 4, 5, 6] - 共享数据

Rust:

// 所有权系统
fn create_vector() -> Vec<i32> {let data = vec![1, 2, 3, 4, 5];data  // 所有权转移给调用者
}let vec1 = create_vector();
let vec2 = vec1;  // vec1 的所有权转移给 vec2
// println!("{:?}", vec1);  // 编译错误！vec1 不再有效// 借用（引用）
let vec1 = vec![1, 2, 3];
let vec2 = &vec1;  // 借用，不转移所有权
println!("{:?}", vec1);  // 仍然有效// 可变借用
let mut vec1 = vec![1, 2, 3];
{let vec2 = &mut vec1;  // 可变借用vec2.push(4);
}  // 可变借用结束
println!("{:?}", vec1);  // 现在可以再次使用

4.2 引用与生命周期

Python:

# Python 中引用是透明的
def get_first_word(text):return text.split()[0]sentence = "Hello world"
word = get_first_word(sentence)
print(word)  # "Hello"

Rust:

// 明确的引用和生命周期
fn get_first_word(text: &str) -> &str {text.split_whitespace().next().unwrap_or("")
}// 生命周期注解（当编译器无法推断时）
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {if x.len() > y.len() {x} else {y}
}let sentence = String::from("Hello world");
let word = get_first_word(&sentence);
println!("{}", word);

5. 模式匹配

5.1 解构赋值

Python:

# 序列解包
point = (10, 20)
x, y = point# 字典解包
person = {"name": "Alice", "age": 30}
# Python 3.5+
def greet(**kwargs):print(f"Hello {kwargs.get('name', 'stranger')}")greet(**person)# 列表解包
first, *middle, last = [1, 2, 3, 4, 5]

Rust:

// 元组解构
let point = (10, 20);
let (x, y) = point;// 结构体解构
struct Point { x: i32, y: i32 }
let p = Point { x: 10, y: 20 };
let Point { x, y } = p;// 枚举匹配
enum Message {Quit,Move { x: i32, y: i32 },Write(String),
}let msg = Message::Move { x: 10, y: 20 };
match msg {Message::Quit => println!("退出"),Message::Move { x, y } => println!("移动到 ({}, {})", x, y),Message::Write(text) => println!("写入: {}", text),
}// 守卫条件
let number = 13;
match number {n if n < 0 => println!("负数"),n if n == 0 => println!("零"),n if n < 10 => println!("个位数"),_ => println!("两位数或更多"),
}

6. 字符串处理

6.1 字符串操作

Python:

# 字符串基本操作
name = "Alice"
greeting = f"Hello, {name}!"  # f-string
old_style = "Hello, %s!" % name
format_style = "Hello, {}!".format(name)# 字符串方法
text = "  Hello World  "
cleaned = text.strip().lower()
words = text.split()
joined = "-".join(words)# 多行字符串
multi = """
这是一个
多行字符串
"""

Rust:

// 字符串类型
let name = "Alice";  // &str (字符串切片)
let owned_name = String::from("Alice");  // String (拥有的字符串)// 字符串格式化
let greeting = format!("Hello, {}!", name);
let formatted = format!("Name: {}, Age: {}", name, 30);// 字符串操作
let text = "  Hello World  ";
let cleaned: String = text.trim().to_lowercase();
let words: Vec<&str> = text.split_whitespace().collect();
let joined = ["Hello", "World"].join("-");// 可变字符串操作
let mut sentence = String::from("Hello");
sentence.push_str(", World!");
sentence.push('!');// 原始字符串
let raw = r#"
这是一个
"原始"字符串
包含引号
"#;

7. 高级特性对比

7.1 泛型与模板

Python:

from typing import TypeVar, Generic, ListT = TypeVar('T')class Stack(Generic[T]):def __init__(self):self._items: List[T] = []def push(self, item: T) -> None:self._items.append(item)def pop(self) -> T:return self._items.pop()# 使用
int_stack = Stack[int]()
int_stack.push(42)

Rust:

// 泛型结构体
struct Stack<T> {items: Vec<T>,
}impl<T> Stack<T> {fn new() -> Stack<T> {Stack { items: Vec::new() }}fn push(&mut self, item: T) {self.items.push(item);}fn pop(&mut self) -> Option<T> {self.items.pop()}
}// 泛型约束
use std::fmt::Display;fn print_info<T: Display>(item: T) {println!("Info: {}", item);
}// 使用
let mut int_stack = Stack::new();
int_stack.push(42);

7.2 装饰器与属性宏

Python:

# 装饰器
def timer(func):import timedef wrapper(*args, **kwargs):start = time.time()result = func(*args, **kwargs)end = time.time()print(f"{func.__name__} took {end - start:.2f}s")return resultreturn wrapper@timer
def slow_function():import timetime.sleep(1)return "完成"# 属性装饰器
class Circle:def __init__(self, radius):self._radius = radius@propertydef area(self):return 3.14159 * self._radius ** 2@area.setterdef area(self, value):self._radius = (value / 3.14159) ** 0.5

Rust:

// 属性宏（需要外部crate）
#[derive(Debug, Clone, PartialEq)]
struct Point {x: i32,y: i32,
}// 自定义derive宏示例
#[derive(Debug)]
struct Circle {radius: f64,
}impl Circle {fn new(radius: f64) -> Circle {Circle { radius }}fn area(&self) -> f64 {std::f64::consts::PI * self.radius * self.radius}
}// 条件编译
#[cfg(debug_assertions)]
fn debug_print(msg: &str) {println!("DEBUG: {}", msg);
}#[cfg(not(debug_assertions))]
fn debug_print(_msg: &str) {// 在release模式下不打印
}

8. 并发编程

8.1 线程与异步

Python:

import threading
import asyncio
from concurrent.futures import ThreadPoolExecutor# 线程
def worker(name):print(f"Worker {name} starting")time.sleep(2)print(f"Worker {name} finished")thread = threading.Thread(target=worker, args=("Alice",))
thread.start()
thread.join()# 异步编程
async def fetch_data(url):await asyncio.sleep(1)  # 模拟网络请求return f"Data from {url}"async def main():tasks = [fetch_data(f"url{i}") for i in range(3)]results = await asyncio.gather(*tasks)print(results)asyncio.run(main())

Rust:

use std::thread;
use std::time::Duration;// 线程
fn main() {let handle = thread::spawn(|| {println!("Worker starting");thread::sleep(Duration::from_secs(2));println!("Worker finished");});handle.join().unwrap();
}// 异步编程（需要 tokio crate）
#[tokio::main]
async fn main() {let tasks = (0..3).map(|i| fetch_data(format!("url{}", i)));let results = futures::future::join_all(tasks).await;println!("{:?}", results);
}async fn fetch_data(url: String) -> String {tokio::time::sleep(Duration::from_secs(1)).await;format!("Data from {}", url)
}// 通道通信
use std::sync::mpsc;let (tx, rx) = mpsc::channel();
thread::spawn(move || {tx.send("Hello from thread").unwrap();
});
let received = rx.recv().unwrap();

9. 包管理与模块系统

9.1 模块导入

Python:

# 导入模块
import os
import sys
from collections import defaultdict
from typing import List, Dict, Optional# 相对导入
from .utils import helper_function
from ..config import settings# 别名
import numpy as np
import pandas as pd# 包结构
# myproject/
#   __init__.py
#   main.py
#   utils/
#     __init__.py
#     helpers.py

Rust:

// 使用外部crate
use std::collections::HashMap;
use std::fs::File;
use std::io::prelude::*;// 模块声明和使用
mod utils {pub fn helper_function() -> String {String::from("Helper")}
}use utils::helper_function;// 外部crate（在Cargo.toml中声明）
use serde::{Serialize, Deserialize};
use tokio::time::Duration;// 模块结构
// src/
#   main.rs
#   lib.rs
#   utils/
#     mod.rs
#     helpers.rs

9.2 包配置文件

Python - requirements.txt / pyproject.toml:

[build-system]
requires = ["setuptools", "wheel"][project]
name = "myproject"
version = "0.1.0"
dependencies = ["requests>=2.25.0","numpy>=1.20.0",
]

Rust - Cargo.toml:

[package]
name = "myproject"
version = "0.1.0"
edition = "2021"[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1.0", features = ["full"] }
reqwest = "0.11"[dev-dependencies]
assert_cmd = "2.0"

10. 性能与安全特性

10.1 内存安全

Python:

# 运行时检查，可能出现错误
def access_list(items, index):return items[index]  # 可能 IndexError# 内存泄漏可能（循环引用）
class Node:def __init__(self, value):self.value = valueself.children = []self.parent = None# 手动解决循环引用
import weakref
class Node:def __init__(self, value):self.value = valueself.children = []self._parent = None@property def parent(self):return self._parent() if self._parent else None@parent.setterdef parent(self, value):self._parent = weakref.ref(value) if value else None

Rust:

// 编译时保证内存安全
fn access_vector(items: &Vec<i32>, index: usize) -> Option<&i32> {items.get(index)  // 安全访问，返回 Option
}// 防止悬垂指针
fn dangling_reference() -> &str {let s = String::from("hello");&s  // 编译错误！返回对局部变量的引用
}// 智能指针解决复杂所有权
use std::rc::{Rc, Weak};
use std::cell::RefCell;struct Node {value: i32,children: RefCell<Vec<Rc<Node>>>,parent: RefCell<Weak<Node>>,
}impl Node {fn new(value: i32) -> Rc<Node> {Rc::new(Node {value,children: RefCell::new(vec![]),parent: RefCell::new(Weak::new()),})}
}

11. 宏系统

11.1 代码生成

Python:

# 元类和装饰器实现代码生成
def auto_str(cls):"""自动生成 __str__ 方法"""def __str__(self):attrs = ', '.join(f"{k}={v}" for k, v in self.__dict__.items())return f"{cls.__name__}({attrs})"cls.__str__ = __str__return cls@auto_str
class Person:def __init__(self, name, age):self.name = nameself.age = agep = Person("Alice", 30)
print(p)  # Person(name=Alice, age=30)

Rust:

// 声明宏
macro_rules! vec_of_strings {($($x:expr),*) => {vec![$(String::from($x)),*]};
}let strings = vec_of_strings!["hello", "world", "rust"];// 复杂宏示例
macro_rules! create_function {($func_name:ident, $return_type:ty, $body:expr) => {fn $func_name() -> $return_type {$body}};
}create_function!(get_answer, i32, 42);
println!("{}", get_answer());  // 输出: 42// 过程宏（Procedural Macros）
#[derive(Debug, Serialize, Deserialize)]
struct User {name: String,email: String,
}

12. 测试框架

12.1 单元测试

Python:

import unittest
import pytest# unittest 框架
class TestMath(unittest.TestCase):def test_addition(self):self.assertEqual(2 + 2, 4)def test_division(self):with self.assertRaises(ZeroDivisionError):1 / 0# pytest 框架
def test_addition():assert 2 + 2 == 4def test_division():with pytest.raises(ZeroDivisionError):1 / 0# 参数化测试
@pytest.mark.parametrize("a,b,expected", [(2, 2, 4),(3, 3, 9),(4, 4, 16),
])
def test_square(a, b, expected):assert a * b == expected

Rust:

// 内置测试框架
#[cfg(test)]
mod tests {use super::*;#[test]fn test_addition() {assert_eq!(2 + 2, 4);}#[test]#[should_panic]fn test_division_by_zero() {let _result = 1 / 0;}#[test]fn test_result() -> Result<(), String> {if 2 + 2 == 4 {Ok(())} else {Err(String::from("Math is broken"))}}
}// 文档测试
/// 这个函数将两个数相加
/// 
/// # Examples
/// 
/// ```
/// assert_eq!(add(2, 2), 4);
/// ```
fn add(a: i32, b: i32) -> i32 {a + b
}// 基准测试（需要 nightly Rust）
#[bench]
fn bench_addition(b: &mut test::Bencher) {b.iter(|| {(0..1000).fold(0, |acc, x| acc + x)});
}

13. 设计哲学对比

13.1 Python: “简单胜过复杂”

# Python 之禅体现的设计理念
import this# 简洁表达
numbers = [1, 2, 3, 4, 5]
squared = [x**2 for x in numbers]# 鸭子类型
def process_items(items):for item in items:print(item)  # 只要有 __str__ 就能工作process_items([1, 2, 3])
process_items("abc")
process_items({"a": 1, "b": 2})

13.2 Rust: “安全、速度、并发”

// 零成本抽象
let numbers = vec![1, 2, 3, 4, 5];
let squared: Vec<i32> = numbers.iter().map(|x| x * x).collect();// 类型安全
trait Printable {fn print(&self);
}impl Printable for i32 {fn print(&self) {println!("{}", self);}
}fn process_items<T: Printable>(items: Vec<T>) {for item in items {item.print();}
}// 编译时保证类型安全
// process_items(vec![1, "string"]);  // 编译错误