【Python基础】 18 Rust 与 Python print 函数完整对比笔记

一、Rust println! 宏

基本语法

// 基本输出
println!("Hello, World!");

// 格式化输出
let name = "Alice";
let age = 25;
println!("Name: {}, Age: {}", name, age);

// 带位置参数的输出
println!("{0} is {1} years old. {0} is a programmer.", name, age);

// 带命名参数的输出
println!("Name: {name}, Age: {age}", name = name, age = age);

格式化选项

let number = 42;
let float = 3.14159;
let text = "hello";

// 数字格式化
println!("Decimal: {}", number);          // 42
println!("Hex: {:x}", number);            // 2a
println!("Binary: {:b}", number);         // 101010
println!("Octal: {:o}", number);          // 52

// 浮点数格式化
println!("Float: {}", float);             // 3.14159
println!("2 decimals: {:.2}", float);     // 3.14
println!("Scientific: {:e}", float);      // 3.14159e0

// 字符串格式化
println!("Text: {}", text);               // hello
println!("Right align: {:>10}", text);    //      hello
println!("Left align: {:<10}", text);     // hello     
println!("Center: {:^10}", text);         //   hello   
println!("Fill: {:_<10}", text);          // hello_____

// 特殊格式
println!("Pointer: {:p}", &number);       // 内存地址
println!("Debug: {:?}", (number, text));  // (42, "hello")
println!("Pretty debug: {:#?}", vec![1, 2, 3]); // 格式化输出

错误输出

// 输出到标准错误
eprintln!("Error: Something went wrong!");
eprintln!("Error value: {}", 42);

二、Python print 函数

基本语法

# 基本输出
print("Hello, World!")

# 多个参数
name = "Alice"
age = 25
print("Name:", name, "Age:", age)

# 格式化输出
print(f"Name: {name}, Age: {age}")          # f-string (3.6+)
print("Name: {}, Age: {}".format(name, age)) # str.format()
print("Name: %s, Age: %d" % (name, age))    # %-formatting

参数详解

# sep 参数 - 分隔符
print("a", "b", "c")                 # a b c
print("a", "b", "c", sep="-")        # a-b-c
print("a", "b", "c", sep="")         # abc

# end 参数 - 结束符
print("Hello", end=" ")              # Hello (不换行)
print("World")                       # Hello World

# file 参数 - 输出到文件
with open("output.txt", "w") as f:
    print("Hello File", file=f)

# flush 参数 - 强制刷新缓冲区
import time
print("Loading", end="", flush=True)
time.sleep(1)
print("...Done")

格式化选项

number = 42
float_num = 3.14159
text = "hello"

# 数字格式化
print(f"Decimal: {number}")           # 42
print(f"Hex: {number:x}")             # 2a
print(f"Binary: {number:b}")          # 101010
print(f"Octal: {number:o}")           # 52

# 浮点数格式化
print(f"Float: {float_num}")          # 3.14159
print(f"2 decimals: {float_num:.2f}") # 3.14
print(f"Scientific: {float_num:e}")   # 3.141590e+00

# 字符串格式化
print(f"Text: {text}")                # hello
print(f"Right align: {text:>10}")     #      hello
print(f"Left align: {text:<10}")      # hello     
print(f"Center: {text:^10}")          #   hello   
print(f"Fill: {text:_<10}")           # hello_____

# 千分位分隔符
big_number = 123456789
print(f"With commas: {big_number:,}") # 123,456,789

错误输出

import sys

# 输出到标准错误
print("Error: Something went wrong!", file=sys.stderr)
sys.stderr.write("Error message\n")

三、转义字符列表

通用转义字符

Rust 特有转义字符

// 原始字符串 - 忽略转义字符
println!(r"C:\Windows\System32"); // C:\Windows\System32

// 多行原始字符串
println!(r#"
    This is a
    multi-line
    raw string
"#);

// Unicode 转义
println!("\u{1F600}"); // 😀
println!("\u{1F47E}"); // 👾

// 字节字符串
println!(b"Hello"); // 输出字节数组

Python 特有转义字符

# 原始字符串
print(r"C:\Windows\System32")  # C:\Windows\System32

# 多行字符串
print("""
Line 1
Line 2
Line 3
""")

# Unicode 转义
print("\N{GRINNING FACE}")     # 😀
print("\U0001F47E")            # 👾
print("\u03A9")                # Ω

# 其他转义
print("\a")  # 响铃 (可能不工作)
print("\f")  # 换页符
print("\v")  # 垂直制表符

四、高级用法对比

Rust 高级输出

use std::io::{self, Write};

// 手动刷新缓冲区
print!("Loading...");
io::stdout().flush().unwrap(); // 立即输出
std::thread::sleep(std::time::Duration::from_secs(1));
println!(" Done");

// 格式化复杂数据结构
#[derive(Debug)]
struct Person {
    name: String,
    age: u32,
}

let person = Person { name: "Bob".to_string(), age: 30 };
println!("{:#?}", person); // 漂亮打印

// 自定义格式化
use std::fmt;

impl fmt::Display for Person {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{} ({} years old)", self.name, self.age)
    }
}

println!("{}", person); // Bob (30 years old)

Python 高级输出

import json
from dataclasses import dataclass

# 输出到字符串
output = "Hello"
print(str(output))      # Hello
print(repr(output))     # 'Hello'

# JSON 格式化输出
data = {"name": "Alice", "age": 25}
print(json.dumps(data, indent=2))
# {
#   "name": "Alice",
#   "age": 25
# }

# 使用 dataclass
from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

person = Person("Bob", 30)
print(person)  # Person(name='Bob', age=30)

# 进度条效果
import time
for i in range(101):
    print(f"\rProgress: {i}%", end="", flush=True)
    time.sleep(0.1)
print()

五、性能考虑

Rust 性能优化

// 避免频繁分配 - 使用 write! 宏
use std::io::{self, Write};

let mut output = String::new();
write!(&mut output, "Hello, {}!", "world").unwrap();
println!("{}", output);

// 批量输出
let lines = vec!["Line 1", "Line 2", "Line 3"];
for line in lines {
    println!("{}", line);
}

// 或者使用 join
println!("{}", lines.join("\n"));

Python 性能优化

# 避免频繁的 print 调用
lines = ["Line 1", "Line 2", "Line 3"]

# 不好：多次 IO 操作
for line in lines:
    print(line)

# 更好：单次 IO 操作
print("\n".join(lines))

# 使用 StringIO 进行内存中的字符串构建
from io import StringIO
output = StringIO()
output.write("Hello, ")
output.write("world!")
print(output.getvalue())

六、跨平台注意事项

Rust 跨平台输出

// 处理不同平台的换行符
#[cfg(windows)]
const NEWLINE: &str = "\r\n";

#[cfg(not(windows))]
const NEWLINE: &str = "\n";

println!("Line 1{}Line 2", NEWLINE);

// 或者使用 std::env::consts::LINE_SEPARATOR

Python 跨平台输出

import os

# 跨平台换行符
print("Line 1", "Line 2", sep=os.linesep)

# 或者让 Python 自动处理
print("Line 1")
print("Line 2")

# 处理编码问题
import sys
if sys.stdout.encoding != 'UTF-8':
    sys.stdout.reconfigure(encoding='utf-8')

七、总结对比

选择建议：

• 选择 Rust：需要高性能、内存安全、系统级输出控制
• 选择 Python：需要快速开发、灵活格式化、简单脚本

关键记忆点：

• Rust 使用宏，Python 使用函数
• Rust 编译时检查格式化，Python 运行时检查
• 两者都支持相似的转义字符
• Python 有更多输出选项（sep, end, file, flush）
• Rust 有更好的性能特性