Python基础-16-Rust-与-Python-命令行输入输出对比笔记

2025-09-05 约 1706 字预计阅读 4 分钟

https://bing.ee123.net/img/rand?artid=151211432

【Python基础】 16 Rust 与 Python 命令行输入输出对比笔记

一、核心哲学差异

特性	Rust 🦀	Python 🐍
错误处理	显式处理 (`Result` 类型)，编译时强制检查	隐式异常，运行时抛出异常
性能	零成本抽象，无运行时开销	解释执行，有一定运行时开销
缓冲区	需要手动刷新 (`flush()`)	通常自动刷新，但也可手动控制
输入解析	需要显式解析字符串到具体类型	动态类型，输入即为字符串，需要时转换

二、基本输出对比

简单输出

// Rust 使用 println! 宏进行输出
fn main() {
    println!("Hello, World!");
    println!("Number: {}", 42);
    println!("Name: {}, Age: {}", "Alice", 30);
    
    // 使用 eprintln! 输出到标准错误
    eprintln!("This is an error message");
}

# Python 使用 print 函数进行输出
print("Hello, World!")
print("Number:", 42)
print(f"Name: {'Alice'}, Age: {30}")

# 使用 sys.stderr 输出到标准错误
import sys
print("This is an error message", file=sys.stderr)

格式化输出

// Rust 的格式化输出
fn main() {
    let name = "Bob";
    let age = 25;
    
    // 位置参数
    println!("{0} is {1} years old. {0} is a programmer.", name, age);
    
    // 命名参数
    println!("{name} is {age} years old", name = name, age = age);
    
    // 控制小数位数
    let pi = 3.1415926535;
    println!("Pi: {:.2}", pi); // 输出: Pi: 3.14
    
    // 填充和对齐
    println!("{:>10}", "right");   // 右对齐
    println!("{:^10}", "center");  // 居中对齐
    println!("{:<10}", "left");    // 左对齐
}

# Python 的格式化输出
name = "Bob"
age = 25

# 位置参数
print("{} is {} years old. {} is a programmer.".format(name, age, name))

# 命名参数
print("{name} is {age} years old".format(name=name, age=age))

# f-string (Python 3.6+)
print(f"{name} is {age} years old")

# 控制小数位数
pi = 3.1415926535
print(f"Pi: {pi:.2f}")  # 输出: Pi: 3.14

# 填充和对齐
print(f"{'right':>10}")   # 右对齐
print(f"{'center':^10}")  # 居中对齐
print(f"{'left':<10}")    # 左对齐

三、基本输入对比

简单输入

// Rust 的标准输入
use std::io;

fn main() -> io::Result<()> {
    let mut input = String::new();
    
    println!("Please enter your name:");
    io::stdin().read_line(&mut input)?;
    
    // 去除换行符
    let name = input.trim();
    println!("Hello, {}!", name);
    
    Ok(())
}

# Python 的标准输入
# Python 3
name = input("Please enter your name: ")
print(f"Hello, {name}!")

# Python 2 (已淘汰)
# name = raw_input("Please enter your name: ")

输入类型转换

// Rust 需要显式类型转换和错误处理
use std::io;

fn main() {
    let mut input = String::new();
    
    println!("Please enter your age:");
    io::stdin().read_line(&mut input).expect("Failed to read line");
    
    // 解析为数字，处理可能的错误
    match input.trim().parse::<i32>() {
        Ok(age) => {
            println!("You are {} years old", age);
            println!("Next year you'll be {}", age + 1);
        }
        Err(_) => {
            eprintln!("Please enter a valid number!");
        }
    }
    
    // 或者使用 unwrap (不推荐用于生产代码)
    // let age: i32 = input.trim().parse().unwrap();
}

# Python 的输入转换和错误处理
while True:
    try:
        age = int(input("Please enter your age: "))
        print(f"You are {age} years old")
        print(f"Next year you'll be {age + 1}")
        break
    except ValueError:
        print("Please enter a valid number!")

四、高级命令行特性对比

命令行参数

// Rust 使用 std::env::args()
use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    
    println!("Program name: {}", args[0]);
    
    if args.len() > 1 {
        println!("Arguments: {:?}", &args[1..]);
    } else {
        println!("No arguments provided");
    }
    
    // 或者使用 args().skip(1) 跳过程序名
    for (i, arg) in env::args().skip(1).enumerate() {
        println!("Argument {}: {}", i + 1, arg);
    }
}

# Python 使用 sys.argv
import sys

print(f"Program name: {sys.argv[0]}")

if len(sys.argv) > 1:
    print(f"Arguments: {sys.argv[1:]}")
else:
    print("No arguments provided")

# 或者使用 argparse 模块进行更复杂的参数解析
import argparse

parser = argparse.ArgumentParser(description='Example argument parser')
parser.add_argument('--name', help='Your name')
parser.add_argument('--age', type=int, help='Your age')
args = parser.parse_args()

if args.name and args.age:
    print(f"Hello {args.name}, you are {args.age} years old")

环境变量

// Rust 环境变量操作
use std::env;

fn main() {
    // 获取环境变量
    if let Ok(home) = env::var("HOME") {
        println!("Home directory: {}", home);
    }
    
    // 设置环境变量 (仅对当前进程有效)
    env::set_var("MY_VAR", "my_value");
    
    // 遍历所有环境变量
    for (key, value) in env::vars() {
        println!("{}: {}", key, value);
    }
}

# Python 环境变量操作
import os

# 获取环境变量
home = os.getenv('HOME')
if home:
    print(f"Home directory: {home}")

# 设置环境变量 (仅对当前进程有效)
os.environ['MY_VAR'] = 'my_value'

# 遍历所有环境变量
for key, value in os.environ.items():
    print(f"{key}: {value}")

五、错误处理对比

Rust 的错误处理模式

use std::io;
use std::num::ParseIntError;

fn get_number() -> Result<i32, ParseIntError> {
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Failed to read line");
    input.trim().parse()
}

fn main() {
    match get_number() {
        Ok(num) => println!("You entered: {}", num),
        Err(e) => eprintln!("Error: {}", e),
    }
    
    // 使用 ? 操作符传播错误
    fn process_input() -> io::Result<()> {
        let mut input = String::new();
        io::stdin().read_line(&mut input)?;
        println!("Read: {}", input.trim());
        Ok(())
    }
}

Python 的异常处理模式

def get_number():
    try:
        return int(input("Enter a number: "))
    except ValueError as e:
        print(f"Error: {e}")
        return None

def main():
    number = get_number()
    if number is not None:
        print(f"You entered: {number}")

if __name__ == "__main__":
    main()

六、性能与安全性考虑

特性	Rust 🦀	Python 🐍
内存安全	编译时保证，无缓冲区溢出风险	运行时检查，有GC保护但可能有其他问题
性能	接近C语言性能，无运行时开销	解释执行，相对较慢
并发安全	编译时保证线程安全	GIL限制，需要多进程或其他方式
错误处理	显式且强制，编译时检查	隐式异常，需要手动捕获

七、实用示例对比

简单的命令行计算器

use std::io;

fn main() -> io::Result<()> {
    println!("Simple Calculator");
    
    let mut input = String::new();
    
    println!("Enter first number:");
    io::stdin().read_line(&mut input)?;
    let num1: f64 = input.trim().parse().expect("Please enter a valid number");
    input.clear();
    
    println!("Enter second number:");
    io::stdin().read_line(&mut input)?;
    let num2: f64 = input.trim().parse().expect("Please enter a valid number");
    
    println!("{} + {} = {}", num1, num2, num1 + num2);
    println!("{} - {} = {}", num1, num2, num1 - num2);
    println!("{} * {} = {}", num1, num2, num1 * num2);
    
    if num2 != 0.0 {
        println!("{} / {} = {}", num1, num2, num1 / num2);
    } else {
        println!("Cannot divide by zero!");
    }
    
    Ok(())
}

print("Simple Calculator")

try:
    num1 = float(input("Enter first number: "))
    num2 = float(input("Enter second number: "))
    
    print(f"{num1} + {num2} = {num1 + num2}")
    print(f"{num1} - {num2} = {num1 - num2}")
    print(f"{num1} * {num2} = {num1 * num2}")
    
    if num2 != 0:
        print(f"{num1} / {num2} = {num1 / num2}")
    else:
        print("Cannot divide by zero!")
        
except ValueError:
    print("Please enter valid numbers!")

八、总结

方面	Rust 🦀	Python 🐍	推荐场景
安全性	⭐⭐⭐⭐⭐ (编译时保证)	⭐⭐⭐ (运行时检查)	需要高安全性的系统工具
性能	⭐⭐⭐⭐⭐ (原生性能)	⭐⭐ (解释执行)	高性能命令行工具
开发速度	⭐⭐ (需要更多代码)	⭐⭐⭐⭐⭐ (快速原型)	快速开发和小工具
错误处理	⭐⭐⭐⭐ (显式强制)	⭐⭐⭐ (异常机制)	需要健壮错误处理的程序
易用性	⭐⭐ (学习曲线陡峭)	⭐⭐⭐⭐⭐ (简单易学)	初学者或简单脚本

选择建议：

选择 Rust：需要高性能、内存安全、并发安全的系统级命令行工具
选择 Python：需要快速开发、原型验证、简单脚本或数据处理的场景

目录

Python基础-16-Rust-与-Python-命令行输入输出对比笔记

【Python基础】 16 Rust 与 Python 命令行输入输出对比笔记

一、核心哲学差异

二、基本输出对比

简单输出

格式化输出

三、基本输入对比

简单输入

输入类型转换

四、高级命令行特性对比

命令行参数

环境变量

五、错误处理对比

Rust 的错误处理模式

Python 的异常处理模式

六、性能与安全性考虑

七、实用示例对比

简单的命令行计算器

八、总结