当前位置：首页 > news >正文

【学Python自动化】 8.1 Python 与 Rust 错误处理对比学习笔记

news 2025/9/3 5:55:37

一、语法错误 vs 编译错误

Python 语法错误


while True print('Hello world')
# SyntaxError: invalid syntax

Rust 编译错误


fn main() {while true println!("Hello world");// 错误：期望 `{`，找到 `println`
}

关键差异：

Python：运行时解析错误
Rust：编译时检查，更早发现错误

二、异常 vs Result 类型

Python 异常处理


# 自动抛出异常
10 * (1/0)  # ZeroDivisionError
4 + spam*3  # NameError
'2' + 2     # TypeError

Rust 错误处理


// 显式处理可能失败的操作
let result: Result<i32, &str> = Ok(42);
let error: Result<i32, &str> = Err("Something went wrong");// 必须处理 Result 类型
match result {Ok(value) => println!("Value: {}", value),Err(e) => println!("Error: {}", e),
}

三、异常处理机制对比

Python try-except


while True:try:x = int(input("Please enter a number: "))breakexcept ValueError:print("Oops! That was no valid number. Try again...")except (RuntimeError, TypeError, NameError) as e:print(f"Other error: {e}")else:print("No exception occurred")finally:print("This always runs")

Rust Result 处理


use std::io;fn get_number() -> Result<i32, io::Error> {let mut input = String::new();loop {println!("Please enter a number: ");io::stdin().read_line(&mut input)?;match input.trim().parse() {Ok(num) => return Ok(num),Err(_) => {println!("Oops! That was no valid number. Try again...");input.clear();continue;}}}
}// 使用 ? 操作符传播错误
fn process() -> Result<(), io::Error> {let x = get_number()?;  // 自动传播错误println!("You entered: {}", x);Ok(())
}

四、抛出/引发异常对比

Python raise


def validate_age(age):if age < 0:raise ValueError("Age cannot be negative")return agetry:validate_age(-1)
except ValueError as e:print(f"Caught exception: {e}")

Rust Result 返回


fn validate_age(age: i32) -> Result<i32, &'static str> {if age < 0 {return Err("Age cannot be negative");}Ok(age)
}match validate_age(-1) {Ok(age) => println!("Valid age: {}", age),Err(e) => println!("Error: {}", e),
}

五、异常链 vs 错误转换

Python 异常链


try:open("database.sqlite")
except OSError as e:raise RuntimeError("Unable to handle error") from e

Rust 错误转换


use std::fs::File;
use std::io;fn open_database() -> Result<File, io::Error> {File::open("database.sqlite").map_err(|e| io::Error::new(io::ErrorKind::Other, "Unable to handle error"))
}

六、自定义异常/错误

Python 自定义异常


class MyError(Exception):def __init__(self, message, code):super().__init__(message)self.code = codetry:raise MyError("Something went wrong", 500)
except MyError as e:print(f"Error {e.code}: {e}")

Rust 自定义错误


use thiserror::Error;#[derive(Error, Debug)]
enum MyError {#[error("Something went wrong with code {0}")]WithCode(i32),#[error("IO error: {0}")]Io(#[from] std::io::Error),
}fn might_fail() -> Result<(), MyError> {if condition {Err(MyError::WithCode(500))} else {Ok(())}
}

七、清理操作对比

Python finally


try:f = open("file.txt")# 处理文件
finally:f.close()  # 总是执行

Rust Drop trait


struct FileWrapper {file: File,
}impl Drop for FileWrapper {fn drop(&mut self) {// 自动清理，类似 finally// 文件会在离开作用域时自动关闭}
}{let file_wrapper = FileWrapper { file: File::open("file.txt")? };// 使用文件
} // 这里自动调用 drop()

八、资源管理对比

Python with 语句


with open("myfile.txt") as f:for line in f:print(line, end="")
# 文件自动关闭

Rust RAII 模式


use std::fs::File;
use std::io::{BufRead, BufReader};{let file = File::open("myfile.txt")?;let reader = BufReader::new(file);for line in reader.lines() {println!("{}", line?);}
} // 文件自动关闭

九、批量错误处理对比

Python ExceptionGroup


excs = []
for test in tests:try:test.run()except Exception as e:excs.append(e)if excs:raise ExceptionGroup("Test Failures", excs)

Rust 错误收集


use anyhow::Result;let mut errors = Vec::new();
for test in tests {if let Err(e) = test.run() {errors.push(e);}
}if !errors.is_empty() {// 处理多个错误
}

十、错误注释/上下文

Python add_note()


try:raise TypeError('bad type')
except Exception as e:e.add_note('Additional context')raise

Rust 错误上下文


use anyhow::{Context, Result};fn process_file() -> Result<()> {let content = std::fs::read_to_string("file.txt").context("Failed to read file")?;Ok(())
}

十一、🔑 核心哲学差异

特性	Python	Rust
错误处理	异常机制	Result/Option 类型
错误发现	运行时	编译时
强制处理	可选	必须处理 Result
性能	异常堆栈跟踪有开销	零成本抽象
代码流程	控制流跳转	显式处理每个可能错误
资源清理	finally 或 with	RAII 和 Drop