【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
英文地址，請注明出處：http://en.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