【Python基础】 20 Rust 与 Python 循环语句完整对比笔记
一、基本循环结构对比
Rust 循环类型
// 1. loop - 无限循环
let mut count = 0;
loop {count += 1;if count >= 5 {break;}
}// 2. while - 条件循环
let mut number = 3;
while number != 0 {println!("{}!", number);number -= 1;
}// 3. for - 迭代循环
for i in 0..5 { // 范围 0-4println!("i = {}", i);
}
Python 循环类型
# 1. while - 条件循环
count = 0
while count < 5:print(count)count += 1# 2. for - 迭代循环
for i in range(5): # 范围 0-4print(f"i = {i}")# 3. 没有专门的无限循环语法，但可以用 while True
while True:break # 立即退出
二、范围迭代对比
Rust 范围迭代
// 基本范围
for i in 0..5 { // 0, 1, 2, 3, 4println!("{}", i);
}for i in 0..=5 { // 0, 1, 2, 3, 4, 5println!("{}", i);
}// 反向迭代
for i in (0..5).rev() { // 4, 3, 2, 1, 0println!("{}", i);
}// 带步长
for i in (0..10).step_by(2) { // 0, 2, 4, 6, 8println!("{}", i);
}
Python 范围迭代
# 基本范围
for i in range(5): // 0, 1, 2, 3, 4print(i)for i in range(0, 6): // 0, 1, 2, 3, 4, 5print(i)# 反向迭代
for i in range(4, -1, -1): // 4, 3, 2, 1, 0print(i)# 带步长
for i in range(0, 10, 2): // 0, 2, 4, 6, 8print(i)
三、集合迭代对比
Rust 集合迭代
let numbers = vec![1, 2, 3, 4, 5];// 值迭代（移动所有权）
for num in numbers { // numbers 所有权被移动println!("{}", num);
}
// println!("{:?}", numbers); // 错误！numbers 已移动// 引用迭代
let numbers2 = vec![1, 2, 3, 4, 5];
for num in &numbers2 { // 借用println!("{}", num);
}
println!("{:?}", numbers2); // 正常// 可变引用迭代
let mut numbers3 = vec![1, 2, 3];
for num in &mut numbers3 { // 可变借用*num *= 2;
}
println!("{:?}", numbers3); // [2, 4, 6]// 索引和值
for (index, value) in numbers2.iter().enumerate() {println!("Index: {}, Value: {}", index, value);
}
Python 集合迭代
numbers = [1, 2, 3, 4, 5]# 值迭代
for num in numbers:print(num)
print(numbers) # 列表仍然可用# 索引和值
for index, value in enumerate(numbers):print(f"Index: {index}, Value: {value}")# 字典迭代
person = {"name": "Alice", "age": 25}
for key, value in person.items():print(f"{key}: {value}")# 同时迭代多个序列
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
for name, age in zip(names, ages):print(f"{name} is {age} years old")
四、循环控制语句对比
break 语句对比
Rust break 语句
// 基本 break - 退出当前循环
for i in 0..10 {if i == 5 {break; // 退出循环}println!("{}", i); // 输出 0, 1, 2, 3, 4
}// break 返回值（Rust 特有）
let result = loop {let mut input = String::new();std::io::stdin().read_line(&mut input).unwrap();if input.trim() == "quit" {break "User quit"; // 返回字符串}println!("You entered: {}", input.trim());
};
println!("Result: {}", result);// 标签 break - 退出指定循环（Rust 特有）
'outer: for i in 0..3 {'inner: for j in 0..3 {if i * j == 4 {break 'outer; // 跳出外层循环}println!("i={}, j={}", i, j);}
}
Python break 语句
# break - 退出循环
for i in range(10):if i == 5:break # 退出循环print(i)# 没有 break 返回值功能
# 但可以用变量在循环外存储结果
result = None
while True:user_input = input("Enter something: ")if user_input == "quit":result = "User quit"breakprint(f"You entered: {user_input}")
print(f"Result: {result}")# Python 没有标签 break，但可以用标志变量
break_outer = False
for i in range(3):for j in range(3):if i == 1 and j == 1:break_outer = Truebreak # 退出内层循环print(f"i={i}, j={j}")if break_outer:break # 退出外层循环
continue 语句对比
Rust continue 语句
// continue - 跳过当前迭代
for i in 0..5 {if i % 2 == 0 {continue; // 跳过偶数}println!("{}", i); // 只打印 1, 3
}// 标签 continue - 跳到指定循环的下一次迭代（Rust 特有）
'outer: for i in 0..3 {'inner: for j in 0..3 {if j == 1 {continue 'outer; // 直接跳到外层循环的下一次}println!("i={}, j={}", i, j);}
}
Python continue 语句
# continue - 跳过当前迭代
for i in range(5):if i % 2 == 0:continue # 跳过偶数print(i) # 只打印 1, 3# Python 没有标签 continue，但可以用嵌套函数或其他逻辑
def process_number(i):for j in range(3):if j == 1:return # 相当于 continue outerprint(f"i={i}, j={j}")for i in range(3):process_number(i)
Python 特有的 else 子句
Python for-else 语句
# for-else: 循环正常完成时执行 else
numbers = [1, 2, 3, 4, 5]
for num in numbers:if num == 6:print("找到6!")break
else:print("没有找到6!") # 会执行，因为循环正常结束# for-else 在找到元素时退出
for num in numbers:if num == 3:print("找到3!")break
else:print("没有找到3!") # 不会执行，因为break退出了# 实用场景：检查是否找到元素
def find_number(target, numbers):for num in numbers:if num == target:print(f"找到 {target}!")breakelse:print(f"没有找到 {target}!")find_number(3, [1, 2, 3, 4]) # 找到 3!
find_number(6, [1, 2, 3, 4]) # 没有找到 6!
Python while-else 语句
# while-else: 循环条件为假时执行 else
count = 0
while count < 3:print(f"Count: {count}")count += 1
else:print("循环正常结束!") # 会执行# while-else 在 break 时跳过 else
count = 0
while count < 3:if count == 1:print("提前退出!")breakprint(f"Count: {count}")count += 1
else:print("这不会执行!") # 不会执行
五、迭代器和生成器对比
Rust 迭代器
// 链式迭代器操作
let numbers = vec![1, 2, 3, 4, 5];let result: Vec<i32> = numbers.iter().map(|x| x * 2) // 每个元素乘2.filter(|x| x > &5) // 过滤大于5的元素.take(2) // 取前2个.cloned() // 解引用.collect(); // 收集为Vecprintln!("{:?}", result); // [6, 8]// 自定义迭代器
struct Counter {count: u32,
}impl Counter {fn new() -> Counter {Counter { count: 0 }}
}impl Iterator for Counter {type Item = u32;fn next(&mut self) -> Option<Self::Item> {if self.count < 5 {self.count += 1;Some(self.count)} else {None}}
}for num in Counter::new() {println!("{}", num); // 1, 2, 3, 4, 5
}
Python 迭代器和生成器
# 生成器表达式
numbers = [1, 2, 3, 4, 5]
result = list(x * 2 for x in numbers if x * 2 > 5)[:2]
print(result) # [6, 8]# 生成器函数
def counter():count = 0while count < 5:count += 1yield countfor num in counter():print(num) # 1, 2, 3, 4, 5# 内置迭代器函数
numbers = [1, 2, 3, 4, 5]
doubled = map(lambda x: x * 2, numbers)
filtered = filter(lambda x: x > 5, doubled)
result = list(filtered)[:2]
print(result) # [6, 8]
六、性能优化对比
Rust 性能优化
// 使用迭代器避免边界检查
let numbers = vec![1, 2, 3, 4, 5];// 传统for循环（有边界检查）
for i in 0..numbers.len() {println!("{}", numbers[i]); // 运行时边界检查
}// 迭代器（无边界检查）
for num in &numbers {println!("{}", num); // 安全且高效
}// 使用 while let 处理迭代器
let mut iter = numbers.iter();
while let Some(num) = iter.next() {println!("{}", num);
}
Python 性能优化
# 使用列表推导式
numbers = [1, 2, 3, 4, 5]# 传统循环
result = []
for x in numbers:if x % 2 == 0:result.append(x * 2)
print(result)# 列表推导式（更快）
result = [x * 2 for x in numbers if x % 2 == 0]
print(result)# 使用内置函数
numbers = [1, 2, 3, 4, 5]
result = list(map(lambda x: x * 2, filter(lambda x: x % 2 == 0, numbers)))
print(result)
七、错误处理模式
Rust 循环中的错误处理
// Result 处理
let results = vec![Ok(1), Err("error"), Ok(3)];for result in results {match result {Ok(value) => println!("Success: {}", value),Err(error) => println!("Error: {}", error),}
}// 使用 ? 操作符传播错误
fn process_numbers(numbers: &[i32]) -> Result<(), &'static str> {for &num in numbers {if num < 0 {return Err("Negative number found");}println!("Processing: {}", num);}Ok(())
}
Python 循环中的错误处理
# try-except 在循环中
numbers = [1, -2, 3, 4, 5]for num in numbers:try:if num < 0:raise ValueError("Negative number")print(f"Processing: {num}")except ValueError as e:print(f"Error: {e}")# break # 可以选择退出循环# 使用 else 子句处理无错误情况
for i in range(3):try:result = 10 / i # i=0 时会除零错误except ZeroDivisionError:print("除零错误，跳过")continueelse:print(f"结果: {result}") # 只在无异常时执行
八、实用模式对比
Rust 实用模式
// 查找元素
let numbers = vec![1, 2, 3, 4, 5];
if let Some(found) = numbers.iter().find(|&&x| x == 3) {println!("Found: {}", found);
}// 所有元素满足条件
let all_positive = numbers.iter().all(|&x| x > 0);
println!("All positive: {}", all_positive);// 任何元素满足条件
let has_even = numbers.iter().any(|&x| x % 2 == 0);
println!("Has even: {}", has_even);// 折叠/reduce
let sum: i32 = numbers.iter().sum();
let product = numbers.iter().fold(1, |acc, &x| acc * x);
println!("Sum: {}, Product: {}", sum, product);
Python 实用模式
# 查找元素
numbers = [1, 2, 3, 4, 5]
found = next((x for x in numbers if x == 3), None)
if found is not None:print(f"Found: {found}")# 所有元素满足条件
all_positive = all(x > 0 for x in numbers)
print(f"All positive: {all_positive}")# 任何元素满足条件
has_even = any(x % 2 == 0 for x in numbers)
print(f"Has even: {has_even}")# 折叠/reduce
from functools import reduce
sum_result = sum(numbers)
product = reduce(lambda acc, x: acc * x, numbers, 1)
print(f"Sum: {sum_result}, Product: {product}")
九、综合使用示例
Rust 循环控制综合示例
// 查找第一个满足条件的元素
let numbers = vec![1, 2, 3, 4, 5];
let mut found = None;'search: for &num in &numbers {if num > 3 {found = Some(num);break 'search; // 找到后立即退出}
}match found {Some(n) => println!("找到第一个大于3的数: {}", n),None => println!("没有找到大于3的数"),
}// 使用 loop + break 实现重试机制
let mut attempts = 0;
let result = loop {attempts += 1;if attempts > 3 {break Err("超过最大重试次数");}// 模拟可能失败的操作let success = attempts == 2;if success {break Ok("操作成功");}println!("第{}次尝试失败", attempts);
};
Python 循环控制综合示例
# 使用 for-else 实现查找
numbers = [1, 2, 3, 4, 5]for num in numbers:if num > 3:print(f"找到第一个大于3的数: {num}")break
else:print("没有找到大于3的数")# 使用 for-else 实现重试机制
max_attempts = 3
for attempt in range(1, max_attempts + 1):# 模拟可能失败的操作success = attempt == 2if success:print(f"第{attempt}次尝试成功!")breakprint(f"第{attempt}次尝试失败")
else:print("所有尝试都失败了!")
十、总结对比
| 特性 | Rust 🦀 | Python 🐍 |
|---|---|---|
| 循环类型 | loop, while, for | while, for |
| 无限循环 | loop {} | while True: |
| 范围语法 | 0..5, 0..=5 | range(5), range(0, 6) |
| break 返回值 | 支持 | 不支持 |
| 标签控制 | 支持 break/continue | 不支持 |
| else 子句 | 无 | 有（for-else, while-else） |
| 所有权 | 严格的所有权规则 | 无所有权概念 |
| 迭代器 | 零成本抽象，编译时优化 | 运行时生成器 |
| 性能 | 接近原生性能 | 有解释器开销 |
| 错误处理 | Result 类型，编译时检查 | try-except，运行时 |
| 灵活性 | 相对严格，类型安全 | 非常灵活，动态类型 |
关键差异总结：
- Rust 有专门的
loop关键字，Python 用while True - Rust 的 break 可以返回值，Python 的 break 不能
- Rust 支持标签 break/continue，Python 不支持
- Python 有独特的 else 子句，Rust 没有对应功能
- Rust 的范围包含/排除语法更直观
- Rust 的迭代器是零成本抽象，Python 的生成器更灵活
- Rust 严格处理所有权，Python 无此概念
- Rust 编译时优化循环，Python 运行时解释
选择建议：
- 选择 Rust：需要高性能、内存安全、系统级编程、精细循环控制
- 选择 Python：需要快速开发、脚本编写、数据处理、灵活的条件判断
适用场景：
- Rust：系统编程、高性能应用、需要内存安全的场景
- Python：数据分析、机器学习、Web开发、快速原型开发