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

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

1. 基本操作对比

2. 栈实现对比

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)

3. 队列实现对比

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

4. 列表推导式 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();

5. 嵌套推导式对比

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: 准备好面对所有权和类型系统的严格性

• 从 Rust 到 Python: 享受动态类型的灵活性，但要注意运行时错误

• 理解哲学差异: Python 追求开发效率，Rust 追求内存安全和性能

• 利用各自优势: 根据项目需求选择合适的语言

两种语言的数据结构设计反映了各自的设计哲学，理解这些差异有助于更好地使用这两种语言！