【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-4
    println!("i = {}", i);
}

Python 循环类型

# 1. while - 条件循环
count = 0
while count < 5:
    print(count)
    count += 1

# 2. for - 迭代循环
for i in range(5):  # 范围 0-4
    print(f"i = {i}")

# 3. 没有专门的无限循环语法，但可以用 while True
while True:
    break  # 立即退出

二、范围迭代对比

Rust 范围迭代

// 基本范围
for i in 0..5 {        // 0, 1, 2, 3, 4
    println!("{}", i);
}

for i in 0..=5 {       // 0, 1, 2, 3, 4, 5
    println!("{}", i);
}

// 反向迭代
for i in (0..5).rev() { // 4, 3, 2, 1, 0
    println!("{}", i);
}

// 带步长
for i in (0..10).step_by(2) { // 0, 2, 4, 6, 8
    println!("{}", i);
}

Python 范围迭代

# 基本范围
for i in range(5):     // 0, 1, 2, 3, 4
    print(i)

for i in range(0, 6):  // 0, 1, 2, 3, 4, 5
    print(i)

# 反向迭代
for i in range(4, -1, -1):  // 4, 3, 2, 1, 0
    print(i)

# 带步长
for i in range(0, 10, 2):   // 0, 2, 4, 6, 8
    print(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"
        break
    print(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 = True
            break  # 退出内层循环
        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 outer
        print(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}!")
            break
    else:
        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("提前退出!")
        break
    print(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();            // 收集为Vec

println!("{:?}", 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 = 0
    while count < 5:
        count += 1
        yield count

for 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("除零错误，跳过")
        continue
    else:
        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 == 2
    if success:
        print(f"第{attempt}次尝试成功!")
        break
    print(f"第{attempt}次尝试失败")
else:
    print("所有尝试都失败了!")

十、总结对比

关键差异总结：

1. Rust 有专门的 loop 关键字，Python 用 while True
2. Rust 的 break 可以返回值，Python 的 break 不能
3. Rust 支持标签 break/continue，Python 不支持
4. Python 有独特的 else 子句，Rust 没有对应功能
5. Rust 的范围包含/排除语法更直观
6. Rust 的迭代器是零成本抽象，Python 的生成器更灵活
7. Rust 严格处理所有权，Python 无此概念
8. Rust 编译时优化循环，Python 运行时解释

选择建议：

• 选择 Rust：需要高性能、内存安全、系统级编程、精细循环控制
• 选择 Python：需要快速开发、脚本编写、数据处理、灵活的条件判断

适用场景：

• Rust：系统编程、高性能应用、需要内存安全的场景
• Python：数据分析、机器学习、Web开发、快速原型开发