【Python基础】 19 Rust 与 Python if 语句对比笔记

一、基本语法对比

Rust if 语句

// 基本形式
let number = 7;

if number < 5 {
    println!("condition was true");
} else {
    println!("condition was false");
}

// 多条件 else if
if number % 4 == 0 {
    println!("number is divisible by 4");
} else if number % 3 == 0 {
    println!("number is divisible by 3");
} else if number % 2 == 0 {
    println!("number is divisible by 2");
} else {
    println!("number is not divisible by 4, 3, or 2");
}

Python if 语句

# 基本形式
number = 7

if number < 5:
    print("condition was true")
else:
    print("condition was false")

# 多条件 elif
if number % 4 == 0:
    print("number is divisible by 4")
elif number % 3 == 0:
    print("number is divisible by 3")
elif number % 2 == 0:
    print("number is divisible by 2")
else:
    print("number is not divisible by 4, 3, or 2")

二、条件表达式差异

布尔值处理

// Rust - 必须显式布尔值
let x = 5;

// 编译错误：if 条件必须是 bool 类型
// if x {
//     println!("x is truthy");
// }

if x != 0 {
    println!("x is not zero");  // 正确
}

if true {  // 必须使用布尔值
    println!("This will always execute");
}

# Python - 支持真值测试
x = 5

# Python 会进行真值测试
if x:  # x 非零，为真
    print("x is truthy")  # 会执行

# 各种真值情况
if 0:           # False
    pass
if "":          # False
    pass  
if []:          # False
    pass
if None:        # False
    pass
if "hello":     # True
    pass
if [1, 2, 3]:   # True
    pass

比较运算符

// Rust 比较运算符
let a = 5;
let b = 10;

if a == b {  // 相等
    println!("equal");
}
if a != b {  // 不等
    println!("not equal");
}
if a < b {   // 小于
    println!("less");
}
if a > b {   // 大于
    println!("greater");
}
if a <= b {  // 小于等于
    println!("less or equal");
}
if a >= b {  // 大于等于
    println!("greater or equal");
}

# Python 比较运算符
a = 5
b = 10

if a == b:    # 相等
    print("equal")
if a != b:    # 不等
    print("not equal") 
if a < b:     # 小于
    print("less")
if a > b:     # 大于
    print("greater")
if a <= b:    # 小于等于
    print("less or equal")
if a >= b:    # 大于等于
    print("greater or equal")

# Python 还支持链式比较
if 1 <= a <= 10:  # 1 ≤ a ≤ 10
    print("a is between 1 and 10")

三、逻辑运算符对比

Rust 逻辑运算符

let age = 25;
let has_license = true;

// && - 逻辑与
if age >= 18 && has_license {
    println!("Can drive");
}

// || - 逻辑或  
if age < 18 || !has_license {
    println!("Cannot drive");
}

// ! - 逻辑非
if !has_license {
    println!("No license");
}

// 短路求值
let mut count = 0;
if false && { count += 1; true } {
    // 不会执行，因为短路
}
println!("Count: {}", count); // 0

Python 逻辑运算符

age = 25
has_license = True

# and - 逻辑与
if age >= 18 and has_license:
    print("Can drive")

# or - 逻辑或
if age < 18 or not has_license:
    print("Cannot drive")

# not - 逻辑非
if not has_license:
    print("No license")

# 短路求值
count = 0
if False and (count := count + 1):  # 使用海象运算符
    pass
print(f"Count: {count}")  # 0

四、模式匹配（Rust 特有）

match 表达式

let number = 13;

match number {
    1 => println!("One"),
    2 | 3 | 5 | 7 | 11 => println!("Prime"),
    13..=19 => println!("Teen"),
    _ => println!("Other"),
}

// 匹配并提取值
let some_value = Some(5);
match some_value {
    Some(x) if x > 0 => println!("Positive: {}", x),
    Some(0) => println!("Zero"),
    Some(_) => println!("Negative"),
    None => println!("No value"),
}

if let 语法

let some_number = Some(7);

// 传统 match
match some_number {
    Some(i) => println!("Matched {}", i),
    _ => {}, // 必须处理所有情况
}

// 使用 if let 简化
if let Some(i) = some_number {
    println!("Matched {}", i);
}

// 带条件的 if let
if let Some(i) = some_number && i > 5 {
    println!("Number is greater than 5: {}", i);
}

五、条件赋值对比

Rust 条件表达式

// if 是表达式，可以返回值
let condition = true;
let number = if condition {
    5
} else {
    6
};

println!("The value of number is: {}", number);

// 必须返回相同类型
// let result = if condition {
//     5       // i32
// } else {
//     "six"   // &str - 编译错误！
// };

// 复杂条件赋值
let x = 10;
let category = if x < 0 {
    "negative"
} else if x == 0 {
    "zero" 
} else {
    "positive"
};

println!("Category: {}", category);

Python 条件表达式

# 三元运算符
condition = True
number = 5 if condition else 6
print(f"The value of number is: {number}")

# 可以返回不同类型
result = 5 if condition else "six"
print(f"Result: {result}")

# 传统多行写法
x = 10
if x < 0:
    category = "negative"
elif x == 0:
    category = "zero"
else:
    category = "positive"

print(f"Category: {category}")

六、作用域和变量遮蔽

Rust 作用域

let number = 5;

if number > 0 {
    let message = "Positive";  // 块内变量
    println!("{}", message);
} // message 离开作用域

// println!("{}", message); // 错误：message 未定义

// 变量遮蔽
let x = 5;
if x > 0 {
    let x = x * 2;  // 遮蔽外部 x
    println!("Inside: {}", x);  // 10
}
println!("Outside: {}", x);  // 5

Python 作用域

number = 5

if number > 0:
    message = "Positive"  # 在 if 块内定义
    print(message)

print(message)  # 仍然可以访问！Python 没有块级作用域

# 避免意外修改
x = 5
if x > 0:
    x = x * 2  # 修改外部变量
    print(f"Inside: {x}")  # 10

print(f"Outside: {x}")  # 10 - 已被修改

七、高级模式匹配

Rust 复杂模式匹配

// 匹配元组
let pair = (0, -2);
match pair {
    (0, y) => println!("First is 0, y = {}", y),
    (x, 0) => println!("x = {}, second is 0", x),
    _ => println!("No zeros"),
}

// 匹配枚举
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

let msg = Message::ChangeColor(0, 160, 255);
match msg {
    Message::Quit => println!("Quit"),
    Message::Move { x, y } => println!("Move to ({}, {})", x, y),
    Message::Write(text) => println!("Text message: {}", text),
    Message::ChangeColor(r, g, b) => {
        println!("Change color to RGB({}, {}, {})", r, g, b)
    },
}

// @ 绑定
let value = Some(10);
match value {
    Some(x @ 1..=5) => println!("Small number: {}", x),
    Some(x @ 6..=10) => println!("Medium number: {}", x),
    Some(x) => println!("Large number: {}", x),
    None => println!("No number"),
}

八、错误处理模式

Rust 错误处理

// 使用 Result 和 match
let result: Result<i32, &str> = Ok(42);

match result {
    Ok(value) => println!("Success: {}", value),
    Err(error) => println!("Error: {}", error),
}

// 使用 if let 处理 Option
let optional_value: Option<i32> = Some(5);

if let Some(value) = optional_value {
    println!("Got value: {}", value);
} else {
    println!("No value");
}

Python 错误处理

# 使用 try-except
try:
    result = 10 / 0
    print(f"Success: {result}")
except ZeroDivisionError as e:
    print(f"Error: {e}")

# 使用 if 检查 None
optional_value = 5  # 或者 None

if optional_value is not None:
    print(f"Got value: {optional_value}")
else:
    print("No value")

九、性能考虑

Rust 性能特性

// 编译时优化 - match 会被优化为跳转表
let x = 3;
match x {
    1 => println!("One"),
    2 => println!("Two"), 
    3 => println!("Three"),
    _ => println!("Other"),
}

// 无运行时开销的模式匹配
let opt: Option<i32> = Some(42);
if let Some(x) = opt {  // 编译时检查
    println!("{}", x);
}

Python 性能考虑

# 避免深层嵌套的 if-elif
value = 42

# 不好：深层嵌套
if value == 1:
    pass
elif value == 2:
    pass
elif value == 3:
    pass
# ... 很多个 elif

# 更好：使用字典分发
def handle_1():
    pass

def handle_2():
    pass

handlers = {
    1: handle_1,
    2: handle_2,
    # ...
}

if value in handlers:
    handlers[value]()

十、总结对比

特性	Rust 🦀	Python 🐍
语法	if condition { }	if condition:
布尔要求	必须显式 bool	支持真值测试
作用域	块级作用域	函数级作用域
返回值	表达式，可返回值	语句，无返回值
模式匹配	强大的 match	无内置模式匹配
类型安全	编译时检查	运行时检查
性能	零成本抽象	有运行时开销
灵活性	相对严格	非常灵活

选择建议：

• 选择 Rust：需要类型安全、高性能、模式匹配
• 选择 Python：需要快速开发、灵活的条件判断

关键记忆点：

• Rust 的 if 是表达式，Python 的 if 是语句
• Rust 需要显式布尔值，Python 支持真值测试
• Rust 有强大的模式匹配，Python 依赖 if-elif 链
• Rust 有块级作用域，Python 是函数级作用域
• Rust 的 match 编译时优化，Python 的 if 运行时评估