【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, forwhile, for
无限循环loop {}while True:
范围语法0..5, 0..=5range(5), range(0, 6)
break 返回值支持不支持
标签控制支持 break/continue不支持
else 子句无有（for-else, while-else）
所有权严格的所有权规则无所有权概念
迭代器零成本抽象，编译时优化运行时生成器
性能接近原生性能有解释器开销
错误处理Result 类型，编译时检查try-except，运行时
灵活性相对严格，类型安全非常灵活，动态类型
关键差异总结：
  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开发、快速原型开发

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若转载，请注明出处：http://www.pswp.cn/pingmian/95683.shtml
繁体地址，请注明出处：http://hk.pswp.cn/pingmian/95683.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Redis 在互联网高并发场景下的应用--个人总结

Redis 在互联网高并发场景下的应用--个人总结

在现代互联网系统中&#xff0c;高并发已经成为常态。无论是电商的秒杀场景、社交平台的热点推荐&#xff0c;还是支付接口的风控&#xff0c;系统需要同时应对成千上万的请求。这时候&#xff0c;Redis 作为一个高性能的内存数据库&#xff0c;凭借其极快的读写速度和丰富的数…
阅读更多...
C++笔记之软件设计原则总结

C++笔记之软件设计原则总结

C++笔记之软件设计原则总结 code review 文章目录 C++笔记之软件设计原则总结 1.软件设计的六大原则 2.高内聚与低耦合 2.1.高内聚（High Cohesion） 2.2.低耦合（Low Coupling） 2.3.高内聚与低耦合的关系与重要性 3.DRY（Dont Repeat Yourself）原则 3.1.定义 3.2.好处 3.3.示…
阅读更多...
ThreadLocal 深度解析：原理、应用场景与最佳实践

ThreadLocal 深度解析：原理、应用场景与最佳实践

一、ThreadLocal 核心概念与设计哲学​1.1 ThreadLocal 的基本概念​ThreadLocal 是 Java 中提供线程局部变量的类&#xff0c;它允许每个线程创建自己的变量副本&#xff0c;从而实现线程封闭&#xff08;Thread Confinement&#xff09;。简单来说&#xff0c;ThreadLocal 为…
阅读更多...
AMD显卡运行GPT-OSS全攻略

AMD显卡运行GPT-OSS全攻略

AMD显卡运行GPT-OSS全攻略 本文介绍如何在Windows系统上使用AMD显卡&#xff08;以RX 7900XTX为例&#xff09;运行开源GPT-OSS模型。 前置要求 硬件&#xff1a;AMD显卡&#xff08;如RX 7900XTX&#xff0c;具体支持型号参考ROCm文档&#xff09;。软件&#xff1a; Ollam…
阅读更多...
【Sharding-JDBC】​Spring/Spring Boot 集成 Sharding-JDBC，分表策略与 API、YAML 配置实践​

【Sharding-JDBC】​Spring/Spring Boot 集成 Sharding-JDBC，分表策略与 API、YAML 配置实践​

文章目录环境准备Spring框架Sharding-JDBC 4.x版本api实现Sharding-JDBC 5.4.x版本yaml实现Springboot框架Sharding-JDBC 5.4.x版本yaml实现分库、加密、读写分离基于yaml的配置示例更多相关内容可查看需求&#xff1a;按月分区&#xff0c;按年分表&#xff0c;找不到对应年份…
阅读更多...
单片机和PLC有哪些区别?揭秘单片机MCU的常见应用

单片机和PLC有哪些区别?揭秘单片机MCU的常见应用

单片机&#xff08;MCU&#xff09;和可编程逻辑控制器&#xff08;PLC&#xff09;作为电子控制系统中的两大核心组件&#xff0c;分别在不同的领域发挥着重要作用。然而&#xff0c;尽管它们都属于自动化控制领域的关键设备&#xff0c;但它们的设计理念、应用场景和性能特点…
阅读更多...
ElementUI之Upload 上传的使用

ElementUI之Upload 上传的使用

文章目录说明SSM使用引入依赖在spring-mvc.xml中加入配置创建上传工具类AliOssUtil响应工具类ResultJSON编写controller自动上传代码编写结果如下演示手动上传前端代码编写后端代码编写结果演示如下说明 为了方便演示&#xff0c;前后端代码一起写了 关于对象存储请看我另一篇博…
阅读更多...
Langchain4j 整合MongoDB 实现会话持久化存储详解

Langchain4j 整合MongoDB 实现会话持久化存储详解

目录 一、前言 二、大模型会话记忆介绍 2.1 AI 大模型会话记忆是什么 2.2 大模型会话记忆常用实现方案 2.3 LangChain4j 会话记忆介绍 三、大模型常用会话存储数据库介绍 3.1 常用的会话存储数据库 3.2 MongoDB 简介 3.2.1 MongoDB 是什么 3.3 为什么选择MongoDB 作为…
阅读更多...
SQL 常用 OVER() 窗口函数介绍

SQL 常用 OVER() 窗口函数介绍

1. sum() over() 做组内数据累加在 SQL 中想实现不同分组内数据累加&#xff0c;可以通过 sum() over() PARTITION BY ORDER BY 结合实现。这种方式能同时满足多维度分组且组内累加的需求&#xff0c;示例如下&#xff1a;假设我们有一张 sales 表&#xff0c;表中存储着…
阅读更多...
OpenRouter：一站式 AI 模型调用平台，免费畅享千问、DeepSeek 等顶级模型

OpenRouter：一站式 AI 模型调用平台，免费畅享千问、DeepSeek 等顶级模型

欢迎来到我的博客&#xff0c;代码的世界里&#xff0c;每一行都是一个故事&#x1f38f;&#xff1a;你只管努力&#xff0c;剩下的交给时间 &#x1f3e0; &#xff1a;小破站 OpenRouter&#xff1a;一站式 AI 模型调用平台&#xff0c;免费畅享千问、DeepSeek 等顶级模型前…
阅读更多...
SpringBoot 整合 Kafka 的实战指南

SpringBoot 整合 Kafka 的实战指南

引言&#xff1a; 本文总字数&#xff1a;约 9800 字预计阅读时间&#xff1a;40 分钟 为什么 Kafka 是高吞吐场景的首选&#xff1f; 在当今的分布式系统中&#xff0c;消息队列已成为不可或缺的基础设施。面对不同的业务场景&#xff0c;选择合适的消息队列至关重要。目前…
阅读更多...
OpenCV 实战篇——如何测算出任一副图片中的物体的实际尺寸？传感器尺寸与像元尺寸的关系？

OpenCV 实战篇——如何测算出任一副图片中的物体的实际尺寸？传感器尺寸与像元尺寸的关系？

文章目录1 如何测算出任一副图片中的物体的实际尺寸2 传感器尺寸与像元尺寸的关系3 Max Frame Rate最大帧率4 为什么要进行相机标定?相机标定有何意义?5 基于相机模型的单目测距--普通相机1 如何测算出任一副图片中的物体的实际尺寸 物体尺寸测量的思路是找一个确定尺寸的物…
阅读更多...
Java并发锁相关

Java并发锁相关

锁相关 ​1. 什么是可重入锁&#xff1f;Java 中如何实现&#xff1f;​​ ​答​&#xff1a; 可重入锁允许一个线程多次获取同一把锁&#xff08;即递归调用时无需重新竞争锁&#xff09;。 ​关键点​&#xff1a;防止死锁&#xff0c;避免线程因重复请求已持有的锁而阻塞。…
阅读更多...
Pie Menu Editor V1.18.7.exe 怎么安装？详细安装教程（附安装包）​

Pie Menu Editor V1.18.7.exe 怎么安装？详细安装教程（附安装包）​

​​Pie Menu Editor V1.18.7.exe​ 是一款用于创建和编辑 ​饼图菜单&#xff08;Pie Menu&#xff09;​​ 的工具软件&#xff0c;通常用于游戏开发、UI设计、3D建模&#xff08;如 Blender 等&#xff09;、或自定义软件操作界面。 一、准备工作 ​下载文件​ 下载了 ​Pi…
阅读更多...
基于Spark的中文文本情感分析系统研究

基于Spark的中文文本情感分析系统研究

引言 1.1 研究背景与意义 随着互联网的普及和社交媒体的兴起、特别是自媒体时代的来临&#xff0c;网络文本数据呈现爆炸式增长。这些文本数据蕴含着丰富的用户情感信息&#xff0c;如何有效地挖掘和利用这些信息&#xff0c;对于了解舆情动态、改进客户服务、辅助决策分析具…
阅读更多...
Simulink子系统、变体子系统及封装知识

Simulink子系统、变体子系统及封装知识

1.引言 文章三相新能源并网系统序阻抗模型——序阻抗分析器IMAnalyzer介绍了一种用于分析和扫描序阻抗的软件。其中&#xff0c;在序阻抗扫频操作过程中&#xff0c;用到了一个扰动注入、测量和运算工具【IMtool】&#xff0c;它外表长这样&#xff1a; 内部长这样&#xff1a…
阅读更多...
高阶组件介绍

高阶组件介绍

高阶组件约定俗成以with开头 import React, { useEffect } from react; import { TouchableOpacity, Image, StyleSheet } from react-native;type IReactComponent React.ClassicComponentClass| React.ComponentClass| React.FunctionComponent| React.ForwardRefExoticComp…
阅读更多...
C++ STL系列-02.泛型入门

C++ STL系列-02.泛型入门

C STL系列-02.泛型入门C中的泛型编程主要通过模板&#xff08;template&#xff09;实现。模板允许我们编写与类型无关的代码&#xff0c;是一种将类型作为参数进行编程的方式。在C中&#xff0c;模板分为函数模板和类模板。 1. 函数模板函数模板允许我们定义一个函数&#xff…
阅读更多...
高效管理网络段和端口集合的工具之ipset

高效管理网络段和端口集合的工具之ipset

目录 1. 核心命令速查 2. 集合类型 3. 实战案例&#xff1a;使用 ipset 封禁 IP 案例 1&#xff1a;基础黑名单封禁&#xff08;手动添加&#xff09; 案例 2&#xff1a;自动过期和解封 案例 3&#xff1a;封禁 IP 和端口组合 案例 4&#xff1a;白名单模式 案例 5&am…
阅读更多...
实例和对象的区别

实例和对象的区别

对象&#xff08;Object&#xff09;是一个概念&#xff0c;它表示“某个类的一个成员”&#xff0c;是“逻辑上的个体”。实例&#xff08;Instance&#xff09;是一个现实&#xff0c;指的是在内存中真正分配了空间的对象。实例一定是对象&#xff0c;但对象不一定是实例。例…
阅读更多...
最新文章

Copyright @ 2022~2023