【学Python自动化】 7.1 Python 与 Rust 输入输出对比学习笔记

一、输出格式化对比

字符串格式化方法对比

1 f-字符串 vs format! 宏

Python f-字符串:

name = "Alice"
age = 30
print(f"Name: {name}, Age: {age}")
# 格式化控制
import math
print(f"Pi: {math.pi:.3f}")  # Pi: 3.142

Rust format! 宏:

let name = "Alice";
let age = 30;
println!("Name: {}, Age: {}", name, age);
// 格式化控制
use std::f64::consts::PI;
println!("Pi: {:.3}", PI);  // Pi: 3.142

2 调试输出对比

Python repr() vs str():

s = "Hello\nWorld"
print(str(s))   # Hello World
print(repr(s))  # 'Hello\nWorld'

value = ("answer", 42)
print(repr(value))  # ('answer', 42)

Rust Debug vs Display trait:

let s = "Hello\nWorld";
println!("{}", s);        // Hello World
println!("{:?}", s);      // "Hello\nWorld"

let value = ("answer", 42);
println!("{:?}", value);  // ("answer", 42)

二、文件操作对比

文件打开模式对比
| 模式 | Python | Rust |
| 读取 | open(“file.txt”, “r”) | File::open(“file.txt”) |
| 写入 | open(“file.txt”, “w”) | File::create(“file.txt”) |
| 追加 | open(“file.txt”, “a”) | OpenOptions::new().append(true) |
| 读写 | open(“file.txt”, “r+”) | OpenOptions::new().read(true).write(true) |
| 二进制 | open(“file.bin”, “rb”) | File::open(“file.bin”) |

1 文件读写基本操作

Python (推荐使用 with):

# 读取文件
with open("file.txt", "r", encoding="utf-8") as f:
    content = f.read()
    # 或者逐行读取
    for line in f:
        print(line, end="")

# 写入文件
with open("output.txt", "w", encoding="utf-8") as f:
    f.write("Hello World\n")
    f.write("Second line\n")

Rust (使用 ? 处理错误):

use std::fs::File;
use std::io::{Read, Write, BufReader, BufRead};

// 读取文件
let mut file = File::open("file.txt")?;
let mut content = String::new();
file.read_to_string(&mut content)?;

// 或者逐行读取
let file = File::open("file.txt")?;
let reader = BufReader::new(file);
for line in reader.lines() {
    println!("{}", line?);
}

// 写入文件
let mut file = File::create("output.txt")?;
file.write_all(b"Hello World\n")?;
file.write_all(b"Second line\n")?;

2 文件定位和二进制操作

Python 二进制操作:

# 二进制读写
with open("file.bin", "rb+") as f:
    f.write(b"0123456789abcdef")
    f.seek(5)  # 移动到第6个字节
    data = f.read(1)  # b'5'
    f.seek(-3, 2)  # 移动到倒数第3个字节
    data = f.read(1)  # b'd'

Rust 二进制操作:

use std::io::{Seek, SeekFrom};

let mut file = File::create("file.bin")?;
file.write_all(b"0123456789abcdef")?;
file.seek(SeekFrom::Start(5))?;  // 移动到第6个字节
let mut buffer = [0; 1];
file.read_exact(&mut buffer)?;   // [53] (ASCII '5')

file.seek(SeekFrom::End(-3))?;   // 移动到倒数第3个字节
file.read_exact(&mut buffer)?;   // [100] (ASCII 'd')

3 JSON 序列化对比

JSON 基本操作

Python json 模块:

import json

# 序列化
data = {"name": "Alice", "age": 30, "scores": [95, 88, 92]}
json_str = json.dumps(data, indent=2)

# 写入文件
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, indent=2)

# 反序列化
with open("data.json", "r", encoding="utf-8") as f:
    loaded_data = json.load(f)

Rust serde_json 库:

use serde::{Deserialize, Serialize};
use std::fs::File;

#[derive(Serialize, Deserialize, Debug)]
struct Person {
    name: String,
    age: u32,
    scores: Vec<u32>,
}

// 序列化
let data = Person {
    name: "Alice".to_string(),
    age: 30,
    scores: vec![95, 88, 92],
};
let json_str = serde_json::to_string_pretty(&data)?;

// 写入文件
let file = File::create("data.json")?;
serde_json::to_writer_pretty(file, &data)?;

// 反序列化
let file = File::open("data.json")?;
let loaded_data: Person = serde_json::from_reader(file)?;

错误处理对比

Python (异常):

try:
    with open("file.txt", "r") as f:
        content = f.read()
except FileNotFoundError:
    print("文件不存在")
except IOError as e:
    print(f"IO错误: {e}")

Rust (Result 类型):

use std::io;

fn read_file() -> io::Result<String> {
    let mut file = File::open("file.txt")?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}

// 使用 match 处理错误
match read_file() {
    Ok(content) => println!("内容: {}", content),
    Err(e) => match e.kind() {
        io::ErrorKind::NotFound => println!("文件不存在"),
        _ => println!("IO错误: {}", e),
    },
}

三、🔑 核心差异总结

四、💡 实用技巧对比

路径处理

Python pathlib:

from pathlib import Path

path = Path("data") / "file.txt"
if path.exists():
    content = path.read_text(encoding="utf-8")

Rust Path:

use std::path::Path;

let path = Path::new("data").join("file.txt");
if path.exists() {
    let content = std::fs::read_to_string(path)?;
}

临时文件

Python tempfile:

import tempfile

with tempfile.NamedTemporaryFile(mode='w', delete=False) as f:
    f.write("临时内容")
    temp_name = f.name

Rust tempfile:

use tempfile::NamedTempFile;

let mut temp_file = NamedTempFile::new()?;
writeln!(temp_file, "临时内容")?;
let temp_path = temp_file.path().to_path_buf();

五、🎯 学习建议

1. 从 Python 到 Rust: 准备好面对显式的错误处理和所有权问题

2. 从 Rust 到 Python: 享受异常处理的简洁性，但要注意捕获具体异常

3. 理解哲学差异:

• Python: “请求宽恕比请求许可容易”

• Rust: “编译时发现错误比运行时好”

4. 资源管理: Python 用 with，Rust 用所有权和 Drop trait

两种语言的IO处理都很有特色，Python 更简洁，Rust 更安全！