为什么 用Rust ?
安全 + 快
对比python的基本数据结构
| Python 结构 | Rust 对应结构 | 核心相似点 | 关键差异 (Rust 视角) |
|---|---|---|---|
list |
Vec<T> |
动态数组，支持在尾部高效增删(append/push)、索引访问 |
1. 类型统一 : Vec内所有元素必须是同一类型T 6 。 2. 可变性控制 : 默认不可变，需let mut声明才可修改 3 。 3. 所有权机制 : 赋值或传参可能转移所有权，原变量会失效 6 。 |
collections.deque |
VecDeque<T> |
双端队列，支持在两端高效增删(appendleft/push_front) |
底层实现 : Rust使用环形缓冲区 ，因此能实现O(1)的随机访问 ，而Python的deque基于双向链表，随机访问是O(n) 4 。 |
dict |
HashMap<K, V> |
键值对映射，基于键快速查找值 9 | 1. 类型明确 : 必须指定键K和值V的类型 3 。 2. 键所有权 : 插入键时，默认会转移其所有权到HashMap中 9 。 3. 无序性 : 不保证遍历顺序（与Python 3.7之前版本类似） 3 。 |
tuple |
tuple |
固定长度、可存放不同类型数据的异构集合 7 | 1. 访问方式 : 通过点号加索引（如t.0）访问成员 7 8 。 2. 不可遍历 : 未实现Iteratortrait，不能直接循环遍历 6 。 3. 类型签名 : 类型是其所有成员类型组合，如(i32, &str, bool) 8 。 |
set |
HashSet<T> |
不重复元素的无序集合 1 | 类似HashMap，只有键没有值，元素类型必须一致且遵守所有权规则 1 。 |
列表（List）与向量（Vec）
Python的list是一个"万能"的动态数组，而Rust的Vec是功能最接近的对应物，但在使用时有一些重要区别。
创建与修改
在Python中，列表默认可变。在Rust中，Vec默认是不可变的，你需要使用 mut关键字声明可变绑定后才能修改它
python
# Python: 直接创建，直接修改
my_list = [1, 2, 3]
my_list.append(4)
my_list[0] = 99
rust
// Rust: 默认不可变，需`mut`才可修改
let mut my_vec = vec![1, 2, 3]; // 使用宏创建Vec
my_vec.push(4); // 正确：因为my_vec是mut的
// my_vec[0] = 99; // 错误：不能直接通过索引修改，会移动所有权
my_vec[0] = 99; // 正确：但需要确保索引未越界，通常用get方法更安全遍历元素
两者都支持方便的遍历操作。
python
# Python: 直接遍历
for element in my_list:
print(element)
rust
// Rust: 通过迭代器遍历。注意遍历方式取决于是否想获取所有权。
for element in &my_vec { // 使用不可变引用，不获取所有权
println!("{}", element);
}
// 或者使用into_iter()消耗掉vec，获取所有权
for element in my_vec { // 此后my_vec将失效
println!("{}", element);
}🔑 字典（Dict）与哈希映射（HashMap）
Python的dict和Rust的HashMap<K, V>都是键值对映射结构，但Rust在类型安全、所有权和可变性上更为严格。
基本操作对比
python
# Python
tel = {'jack': 4098, 'sape': 4139}
tel['guido'] = 4127 # 插入或更新
value = tel.get('jack', 0) # 安全获取，可设默认值
del tel['sape'] # 删除
for k, v in tel.items(): # 遍历
print(k, v)
rust
use std::collections::HashMap;
// Rust
let mut tel = HashMap::new();
tel.insert("jack", 4098);
tel.insert("sape", 4139);
tel.insert("guido", 4127); // 插入或更新
// 安全获取，返回Option<&V>
let value = tel.get("jack"); // Some(&4098)
if let Some(v) = value {
println!("{}", v);
}
tel.remove("sape"); // 删除
for (k, v) in &tel { // 使用引用遍历，不获取所有权
println!("{}: {}", k, v);
}一个关键区别：所有权的转移
当你将一个不具备Copytrait的类型（如String）插入HashMap时，所有权会转移给HashMap。
rust
let key = "my_key".to_string();
let value = "my_value".to_string();
let mut map = HashMap::new();
map.insert(key, value); // key和value的所有权被移动到map中
// println!("{}", key); // 错误！key的所有权已经转移，不能再使用
// println!("{}", value); // 错误！value的所有权也已经转移元组（Tuple）
元组在两种语言中都是固定长度、可存放不同类型数据的复合类型。主要区别在于访问和遍历方式。
创建与访问
python
# Python: 创建、索引访问、解包
t = (1, "hello", True)
print(t[0]) # 索引访问
x, y, z = t # 解包
rust
// Rust: 创建、点号索引访问、解构
let t: (i32, &str, bool) = (1, "hello", true); // 类型注解可选
println!("{}", t.0); // 通过点号加索引访问[7,8](@ref)
let (x, y, z) = t; // 模式匹配解构[7](@ref)
// for element in t { ... } // 错误！Rust中的元组不能直接遍历[6](@ref)。