2025-简单点-从0开始学Rust-更新

为什么 用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: 直接创建，直接修改
my_list = [1, 2, 3]
my_list.append(4)
my_list[0] = 99

// 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: 直接遍历
for element in my_list:
    print(element)

// 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
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)

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。

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: 创建、索引访问、解包
t = (1, "hello", True)
print(t[0]) # 索引访问
x, y, z = t # 解包

// 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)。