当前位置：首页 > ds >正文

【学Python自动化】5.1 Python 与 Rust 数据结构对比学习笔记

ds 2025/9/2 9:30:57

一、列表 (Python) vs Vec (Rust)

1. 基本操作对比

操作	Python	Rust
创建	list = [1, 2, 3]	let vec = vec![1, 2, 3];
添加元素	list.append(4)	vec.push(4);
扩展	list.extend([5, 6])	vec.extend([5, 6]);
插入	list.insert(1, 99)	vec.insert(1, 99);
删除值	list.remove(2)	`vec.retain( &x x != 2);`
弹出	list.pop()	vec.pop()
清空	list.clear()	vec.clear();
查找索引	list.index(3)	vec.iter().position( &x x == 3)`
计数	list.count(2)	`vec.iter().filter( &&x x == 2).count()`
排序	list.sort()	vec.sort();
反转	list.reverse()	vec.reverse();

栈实现对比

Python:


stack = [3, 4, 5]
stack.append(6)  # 压栈
stack.append(7)
stack.pop()      # 出栈 → 7

Rust:


let mut stack = vec![3, 4, 5];
stack.push(6);   // 压栈
stack.push(7);
stack.pop();     // 出栈 → Some(7)

队列实现对比

Python (推荐):


from collections import deque
queue = deque(["Eric", "John", "Michael"])
queue.append("Terry")
queue.popleft()  # "Eric"

Rust (VecDeque):


use std::collections::VecDeque;
let mut queue = VecDeque::from(vec!["Eric", "John", "Michael"]);
queue.push_back("Terry");
queue.pop_front(); // Some("Eric")

列表推导式 vs 迭代器适配器

Python 列表推导式:


squares = [x**2 for x in range(10)]
even_squares = [x**2 for x in range(10) if x % 2 == 0]
pairs = [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]

Rust 迭代器适配器:


let squares: Vec<i32> = (0..10).map(|x| x * x).collect();
let even_squares: Vec<i32> = (0..10).filter(|x| x % 2 == 0).map(|x| x * x).collect();
let pairs: Vec<_> = [1,2,3].iter().flat_map(|&x| [3,1,4].iter().map(move |&y| (x, y))).filter(|&(x, y)| x != y).collect();

嵌套推导式对比

Python:


matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed = [[row[i] for row in matrix] for i in range(3)]
# [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

Rust:


let matrix = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]];
let transposed: Vec<Vec<i32>> = (0..3).map(|i| matrix.iter().map(|row| row[i]).collect()).collect();

二、del 语句 vs Rust 的所有权系统

Python del:


a = [-1, 1, 66.25, 333, 333, 1234.5]
del a[0]        # 删除索引0
del a[2:4]      # 删除切片
del a[:]        # 清空
del a           # 删除变量

Rust (所有权和作用域):


let mut a = vec![-1, 1, 66.25, 333.0, 333.0, 1234.5];
a.remove(0);    // 删除索引0
a.drain(2..4);  // 删除切片范围
a.clear();      // 清空
// 变量在作用域结束时自动丢弃

三、元组 (Python) vs 元组 (Rust)

元组操作对比

Python 元组:


t = 12345, 54321, 'hello!'  # 打包
x, y, z = t                 # 解包
empty = ()                  # 空元组
single = 'hello',           # 单元素元组

Rust 元组:


let t: (i32, i32, &str) = (12345, 54321, "hello!");  // 显式类型
let (x, y, z) = t;          // 解构
let empty: () = ();         // 单元类型
let single = ("hello",);    // 单元素元组

不可变性对比

Python (元组不可变，但可包含可变元素):


v = ([1, 2, 3], [3, 2, 1])
v[0][0] = 999  # 可以修改列表内容

Rust (完全的不可变性):


let v = (vec![1, 2, 3], vec![3, 2, 1]);
// v.0[0] = 999;  // 错误：元组不可变
let mut v = (vec![1, 2, 3], vec![3, 2, 1]);
v.0[0] = 999;    // 需要声明可变

四、集合 (Python) vs HashSet (Rust)

集合操作对比

Python 集合:


a = set('abracadabra')
b = set('alacazam')
print(a - b)  # 差集 {'r', 'd', 'b'}
print(a | b)  # 并集
print(a & b)  # 交集 {'a', 'c'}
print(a ^ b)  # 对称差集

Rust HashSet:


use std::collections::HashSet;let a: HashSet<_> = "abracadabra".chars().collect();
let b: HashSet<_> = "alacazam".chars().collect();// 差集
let diff: HashSet<_> = a.difference(&b).cloned().collect();
// 并集
let union: HashSet<_> = a.union(&b).cloned().collect();
// 交集
let intersection: HashSet<_> = a.intersection(&b).cloned().collect();
// 对称差集
let sym_diff: HashSet<_> = a.symmetric_difference(&b).cloned().collect();

五、字典 (Python) vs HashMap (Rust)

字典操作对比

Python 字典:


tel = {'jack': 4098, 'sape': 4139}
tel['guido'] = 4127          # 添加/更新
del tel['sape']              # 删除
value = tel.get('jack')      # 安全获取
keys = list(tel.keys())      # 所有键

Rust HashMap:


use std::collections::HashMap;let mut tel = HashMap::new();
tel.insert("jack", 4098);
tel.insert("sape", 4139);
tel.insert("guido", 4127);   // 添加/更新
tel.remove("sape");          // 删除
let value = tel.get("jack"); // 返回 Option<&i32>
let keys: Vec<_> = tel.keys().cloned().collect();

字典推导式对比

Python:


squares = {x: x**2 for x in (2, 4, 6)}
# {2: 4, 4: 16, 6: 36}

Rust:


let squares: HashMap<i32, i32> = [2, 4, 6].iter().map(|&x| (x, x * x)).collect();

六、循环技巧对比

字典遍历

Python:


knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():print(k, v)

Rust:


let knights = HashMap::from([("gallahad", "the pure"),("robin", "the brave")
]);
for (k, v) in &knights {println!("{} {}", k, v);
}

枚举遍历

Python:


for i, v in enumerate(['tic', 'tac', 'toe']):print(i, v)

Rust:


for (i, v) in ["tic", "tac", "toe"].iter().enumerate() {println!("{} {}", i, v);
}

并行遍历

Python:


questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):print(f'What is your {q}? It is {a}.')

Rust:


let questions = ["name", "quest", "favorite color"];
let answers = ["lancelot", "the holy grail", "blue"];
for (q, a) in questions.iter().zip(answers.iter()) {println!("What is your {}? It is {}.", q, a);
}

七、条件控制对比

链式比较

Python:


a < b == c  # 等价于 a < b and b == c

Rust:


a < b && b == c  // 需要明确写出

短路求值

Python:


string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
non_null = string1 or string2 or string3  # 'Trondheim'

Rust:


let string1 = "";
let string2 = "Trondheim";
let string3 = "Hammer Dance";
let non_null = string1.is_empty().then(|| string2).or_else(|| string2.is_empty().then(|| string3)).unwrap_or("");  // 更复杂的逻辑

八、序列比较对比

字典序比较

Python:


(1, 2, 3) < (1, 2, 4)        # True
'ABC' < 'C' < 'Pascal' < 'Python'  # True

Rust:


(1, 2, 3) < (1, 2, 4)        // true
"ABC" < "C" && "C" < "Pascal" && "Pascal" < "Python"  // 需要分开比较

九、🔑 核心差异总结

特性	Python	Rust
类型系统	动态，鸭子类型	静态，强类型
可变性	默认可变，可控制	默认不可变，需要 mut
所有权	引用计数	所有权系统
错误处理	异常	Result/Option
空值 None	Option
迭代器	推导式	迭代器适配器
方法链	有限支持	强大的方法链