// 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}")

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(())
    }
}

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()

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!")