Python与Rust语法对比详解：从入门到精通

Python与Rust语法对比详解：从入门到精通

前言

Python和Rust作为当今最受关注的编程语言，分别代表了动态类型和静态类型语言的典型特征。本文将从语法层面深入对比这两种语言，帮助开发者理解它们的设计理念和使用场景。

1. 基础语法结构

1.1 Hello World 对比

Python:

print("Hello, World!")

Rust:

fn main() {
    println!("Hello, World!");
}

关键差异:

• Python: 脚本式，直接执行
• Rust: 需要main函数作为程序入口点
• Rust: 使用宏 println! 而非函数

1.2 注释语法

Python:

# 单行注释
"""
多行注释
或文档字符串
"""

Rust:

// 单行注释
/* 多行注释 */
/// 文档注释（外部）
//! 文档注释（内部）

2. 变量与数据类型

2.1 变量声明

Python:

# 动态类型，无需声明类型
name = "Alice"
age = 30
height = 5.8
is_student = True

# 可以重新赋值不同类型
name = 123  # 完全合法

Rust:

// 静态类型，默认不可变
let name = "Alice";           // 字符串字面量 &str
let age = 30;                 // 默认 i32
let height = 5.8;             // 默认 f64
let is_student = true;        // bool

// 可变变量需要 mut 关键字
let mut counter = 0;
counter += 1;

// 类型注解
let age: u32 = 30;
let name: String = String::from("Alice");

2.2 常量定义

Python:

# 约定大写表示常量，但可以修改
PI = 3.14159
MAX_SIZE = 100

Rust:

// 编译时常量，真正不可变
const PI: f64 = 3.14159;
const MAX_SIZE: usize = 100;

// 静态变量
static GLOBAL_VAR: i32 = 42;

2.3 基本数据类型

Python:

# 数值类型
integer = 42
float_num = 3.14
complex_num = 1 + 2j

# 字符串
text = "Hello"
multi_line = """
多行
字符串
"""

# 布尔值
flag = True

Rust:

// 整数类型（有符号和无符号）
let signed: i32 = -42;
let unsigned: u32 = 42;
let byte: u8 = 255;
let long: i64 = 1000000;

// 浮点类型
let float32: f32 = 3.14;
let float64: f64 = 3.141592653589793;

// 字符和字符串
let character: char = 'A';
let string_slice: &str = "Hello";
let owned_string: String = String::from("Hello");

// 布尔值
let flag: bool = true;

3. 集合数据类型

3.1 数组与列表

Python:

# 列表（动态数组）
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]  # 可以混合类型

# 列表操作
numbers.append(6)
numbers.extend([7, 8])
first = numbers[0]
last = numbers[-1]
slice_data = numbers[1:4]

Rust:

// 数组（固定大小）
let numbers: [i32; 5] = [1, 2, 3, 4, 5];
let zeros = [0; 10];  // 10个0

// 向量（动态数组）
let mut vec_numbers = vec![1, 2, 3, 4, 5];
vec_numbers.push(6);
vec_numbers.extend(&[7, 8]);

// 访问元素
let first = vec_numbers[0];
let slice = &vec_numbers[1..4];

// 所有元素必须是同一类型
// let mixed = vec![1, "hello"];  // 编译错误

3.2 字典与哈希映射

Python:

# 字典
person = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

# 字典操作
person["job"] = "Engineer"
age = person.get("age", 0)
keys = list(person.keys())

Rust:

use std::collections::HashMap;

// HashMap
let mut person = HashMap::new();
person.insert("name", "Alice");
person.insert("age", "30");
person.insert("city", "New York");

// 或者使用宏创建
let person = [
    ("name", "Alice"),
    ("age", "30"),
    ("city", "New York"),
].iter().cloned().collect::<HashMap<&str, &str>>();

// 访问
let age = person.get("age").unwrap_or(&"0");

3.3 元组

Python:

# 元组
point = (10, 20)
person = ("Alice", 30, "Engineer")

# 解包
x, y = point
name, age, job = person

Rust:

// 元组
let point: (i32, i32) = (10, 20);
let person: (&str, u32, &str) = ("Alice", 30, "Engineer");

// 解构
let (x, y) = point;
let (name, age, job) = person;

// 访问元素
let first = point.0;
let second = point.1;

4. 控制流结构

4.1 条件语句

Python:

# if-elif-else
if age < 18:
    print("Minor")
elif age < 65:
    print("Adult")
else:
    print("Senior")

# 三元操作符
status = "adult" if age >= 18 else "minor"

Rust:

// if-else if-else
if age < 18 {
    println!("Minor");
} else if age < 65 {
    println!("Adult");
} else {
    println!("Senior");
}

// if 表达式
let status = if age >= 18 { "adult" } else { "minor" };

// match 表达式（更强大）
let status = match age {
    0..=17 => "minor",
    18..=64 => "adult",
    _ => "senior",
};

4.2 循环结构

Python:

# for 循环
for i in range(5):
    print(i)

for item in [1, 2, 3]:
    print(item)

for key, value in {"a": 1, "b": 2}.items():
    print(f"{key}: {value}")

# while 循环
count = 0
while count < 5:
    print(count)
    count += 1

# 列表推导
squares = [x**2 for x in range(10) if x % 2 == 0]

Rust:

// for 循环
for i in 0..5 {
    println!("{}", i);
}

for item in &[1, 2, 3] {
    println!("{}", item);
}

for (key, value) in &[("a", 1), ("b", 2)] {
    println!("{}: {}", key, value);
}

// while 循环
let mut count = 0;
while count < 5 {
    println!("{}", count);
    count += 1;
}

// loop 无限循环
let mut x = 0;
loop {
    if x > 10 { break; }
    x += 1;
}

// 迭代器链式操作
let squares: Vec<i32> = (0..10)
    .filter(|x| x % 2 == 0)
    .map(|x| x * x)
    .collect();

5. 函数定义

5.1 基本函数语法

Python:

# 基本函数
def greet(name):
    return f"Hello, {name}!"

# 默认参数
def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

# 可变参数
def sum_all(*args):
    return sum(args)

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# 类型提示（可选）
def add(a: int, b: int) -> int:
    return a + b

Rust:

// 基本函数
fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

// 默认参数需要通过重载或 Option 实现
fn greet_with_default(name: &str, greeting: Option<&str>) -> String {
    let greeting = greeting.unwrap_or("Hello");
    format!("{}, {}!", greeting, name)
}

// 可变参数使用宏或 Vec
fn sum_all(numbers: &[i32]) -> i32 {
    numbers.iter().sum()
}

// 泛型函数
fn add<T>(a: T, b: T) -> T 
where 
    T: std::ops::Add<Output = T>,
{
    a + b
}

5.2 闭包与lambda

Python:

# lambda 表达式
square = lambda x: x * x
add = lambda a, b: a + b

# 高阶函数
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
evens = list(filter(lambda x: x % 2 == 0, numbers))

Rust:

// 闭包
let square = |x| x * x;
let add = |a, b| a + b;

// 高阶函数
let numbers = vec![1, 2, 3, 4, 5];
let squared: Vec<i32> = numbers.iter().map(|x| x * x).collect();
let evens: Vec<&i32> = numbers.iter().filter(|&x| x % 2 == 0).collect();

// 闭包捕获环境
let multiplier = 2;
let multiply = |x| x * multiplier;

6. 面向对象编程

6.1 类与结构体

Python:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self._private = "私有属性"
    
    def greet(self):
        return f"Hi, I'm {self.name}"
    
    @property
    def adult(self):
        return self.age >= 18
    
    @staticmethod
    def species():
        return "Homo sapiens"

# 继承
class Student(Person):
    def __init__(self, name, age, school):
        super().__init__(name, age)
        self.school = school
    
    def study(self):
        return f"{self.name} is studying at {self.school}"

Rust:

// 结构体
struct Person {
    name: String,
    age: u32,
    private_field: String,  // 私有性通过模块控制
}

// 实现方法
impl Person {
    // 关联函数（类似静态方法）
    fn new(name: String, age: u32) -> Person {
        Person {
            name,
            age,
            private_field: String::from("私有"),
        }
    }
    
    // 方法
    fn greet(&self) -> String {
        format!("Hi, I'm {}", self.name)
    }
    
    fn is_adult(&self) -> bool {
        self.age >= 18
    }
    
    // 可变引用方法
    fn have_birthday(&mut self) {
        self.age += 1;
    }
}

// Trait（类似接口）
trait Student {
    fn study(&self) -> String;
}

impl Student for Person {
    fn study(&self) -> String {
        format!("{} is studying", self.name)
    }
}

6.2 枚举类型

Python:

from enum import Enum

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

# 使用
color = Color.RED
if color == Color.RED:
    print("It's red!")

Rust:

// 枚举（功能更强大）
enum Color {
    Red,
    Green,
    Blue,
}

// 带数据的枚举
enum IpAddr {
    V4(u8, u8, u8, u8),
    V6(String),
}

// 使用
let color = Color::Red;
match color {
    Color::Red => println!("It's red!"),
    Color::Green => println!("It's green!"),
    Color::Blue => println!("It's blue!"),
}

let ip = IpAddr::V4(127, 0, 0, 1);
match ip {
    IpAddr::V4(a, b, c, d) => println!("IPv4: {}.{}.{}.{}", a, b, c, d),
    IpAddr::V6(addr) => println!("IPv6: {}", addr),
}

3. 错误处理机制

3.1 异常 vs Result

Python:

# 异常处理
try:
    result = 10 / 0
    file = open("nonexistent.txt")
except ZeroDivisionError:
    print("除零错误")
except FileNotFoundError:
    print("文件未找到")
except Exception as e:
    print(f"其他错误: {e}")
finally:
    print("清理代码")

# 抛出异常
def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为零")
    return a / b

Rust:

use std::fs::File;
use std::io::ErrorKind;

// Result 类型
fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err(String::from("除数不能为零"))
    } else {
        Ok(a / b)
    }
}

// 使用 Result
match divide(10.0, 2.0) {
    Ok(result) => println!("结果: {}", result),
    Err(error) => println!("错误: {}", error),
}

// ? 操作符用于错误传播
fn read_file() -> Result<String, std::io::Error> {
    let mut file = File::open("test.txt")?;  // 如果失败直接返回错误
    // 处理文件...
    Ok(String::from("文件内容"))
}

// Option 类型处理可能为空的值
fn find_item(list: &[i32], target: i32) -> Option<usize> {
    for (index, &item) in list.iter().enumerate() {
        if item == target {
            return Some(index);
        }
    }
    None
}

4. 内存管理与所有权

4.1 内存管理对比

Python:

# 自动内存管理
def create_list():
    data = [1, 2, 3, 4, 5]
    return data  # Python 会自动管理内存

list1 = create_list()
list2 = list1  # 两个变量指向同一对象
list2.append(6)
print(list1)  # [1, 2, 3, 4, 5, 6] - 共享数据

Rust:

// 所有权系统
fn create_vector() -> Vec<i32> {
    let data = vec![1, 2, 3, 4, 5];
    data  // 所有权转移给调用者
}

let vec1 = create_vector();
let vec2 = vec1;  // vec1 的所有权转移给 vec2
// println!("{:?}", vec1);  // 编译错误！vec1 不再有效

// 借用（引用）
let vec1 = vec![1, 2, 3];
let vec2 = &vec1;  // 借用，不转移所有权
println!("{:?}", vec1);  // 仍然有效

// 可变借用
let mut vec1 = vec![1, 2, 3];
{
    let vec2 = &mut vec1;  // 可变借用
    vec2.push(4);
}  // 可变借用结束
println!("{:?}", vec1);  // 现在可以再次使用

4.2 引用与生命周期

Python:

# Python 中引用是透明的
def get_first_word(text):
    return text.split()[0]

sentence = "Hello world"
word = get_first_word(sentence)
print(word)  # "Hello"

Rust:

// 明确的引用和生命周期
fn get_first_word(text: &str) -> &str {
    text.split_whitespace().next().unwrap_or("")
}

// 生命周期注解（当编译器无法推断时）
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

let sentence = String::from("Hello world");
let word = get_first_word(&sentence);
println!("{}", word);

5. 模式匹配

5.1 解构赋值

Python:

# 序列解包
point = (10, 20)
x, y = point

# 字典解包
person = {"name": "Alice", "age": 30}
# Python 3.5+
def greet(**kwargs):
    print(f"Hello {kwargs.get('name', 'stranger')}")

greet(**person)

# 列表解包
first, *middle, last = [1, 2, 3, 4, 5]

Rust:

// 元组解构
let point = (10, 20);
let (x, y) = point;

// 结构体解构
struct Point { x: i32, y: i32 }
let p = Point { x: 10, y: 20 };
let Point { x, y } = p;

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

let msg = Message::Move { x: 10, y: 20 };
match msg {
    Message::Quit => println!("退出"),
    Message::Move { x, y } => println!("移动到 ({}, {})", x, y),
    Message::Write(text) => println!("写入: {}", text),
}

// 守卫条件
let number = 13;
match number {
    n if n < 0 => println!("负数"),
    n if n == 0 => println!("零"),
    n if n < 10 => println!("个位数"),
    _ => println!("两位数或更多"),
}

6. 字符串处理

6.1 字符串操作

Python:

# 字符串基本操作
name = "Alice"
greeting = f"Hello, {name}!"  # f-string
old_style = "Hello, %s!" % name
format_style = "Hello, {}!".format(name)

# 字符串方法
text = "  Hello World  "
cleaned = text.strip().lower()
words = text.split()
joined = "-".join(words)

# 多行字符串
multi = """
这是一个
多行字符串
"""

Rust:

// 字符串类型
let name = "Alice";  // &str (字符串切片)
let owned_name = String::from("Alice");  // String (拥有的字符串)

// 字符串格式化
let greeting = format!("Hello, {}!", name);
let formatted = format!("Name: {}, Age: {}", name, 30);

// 字符串操作
let text = "  Hello World  ";
let cleaned: String = text.trim().to_lowercase();
let words: Vec<&str> = text.split_whitespace().collect();
let joined = ["Hello", "World"].join("-");

// 可变字符串操作
let mut sentence = String::from("Hello");
sentence.push_str(", World!");
sentence.push('!');

// 原始字符串
let raw = r#"
这是一个
"原始"字符串
包含引号
"#;

7. 高级特性对比

7.1 泛型与模板

Python:

from typing import TypeVar, Generic, List

T = TypeVar('T')

class Stack(Generic[T]):
    def __init__(self):
        self._items: List[T] = []
    
    def push(self, item: T) -> None:
        self._items.append(item)
    
    def pop(self) -> T:
        return self._items.pop()

# 使用
int_stack = Stack[int]()
int_stack.push(42)

Rust:

// 泛型结构体
struct Stack<T> {
    items: Vec<T>,
}

impl<T> Stack<T> {
    fn new() -> Stack<T> {
        Stack { items: Vec::new() }
    }
    
    fn push(&mut self, item: T) {
        self.items.push(item);
    }
    
    fn pop(&mut self) -> Option<T> {
        self.items.pop()
    }
}

// 泛型约束
use std::fmt::Display;

fn print_info<T: Display>(item: T) {
    println!("Info: {}", item);
}

// 使用
let mut int_stack = Stack::new();
int_stack.push(42);

7.2 装饰器与属性宏

Python:

# 装饰器
def timer(func):
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end - start:.2f}s")
        return result
    return wrapper

@timer
def slow_function():
    import time
    time.sleep(1)
    return "完成"

# 属性装饰器
class Circle:
    def __init__(self, radius):
        self._radius = radius
    
    @property
    def area(self):
        return 3.14159 * self._radius ** 2
    
    @area.setter
    def area(self, value):
        self._radius = (value / 3.14159) ** 0.5

Rust:

// 属性宏（需要外部crate）
#[derive(Debug, Clone, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

// 自定义derive宏示例
#[derive(Debug)]
struct Circle {
    radius: f64,
}

impl Circle {
    fn new(radius: f64) -> Circle {
        Circle { radius }
    }
    
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
}

// 条件编译
#[cfg(debug_assertions)]
fn debug_print(msg: &str) {
    println!("DEBUG: {}", msg);
}

#[cfg(not(debug_assertions))]
fn debug_print(_msg: &str) {
    // 在release模式下不打印
}

8. 并发编程

8.1 线程与异步

Python:

import threading
import asyncio
from concurrent.futures import ThreadPoolExecutor

# 线程
def worker(name):
    print(f"Worker {name} starting")
    time.sleep(2)
    print(f"Worker {name} finished")

thread = threading.Thread(target=worker, args=("Alice",))
thread.start()
thread.join()

# 异步编程
async def fetch_data(url):
    await asyncio.sleep(1)  # 模拟网络请求
    return f"Data from {url}"

async def main():
    tasks = [fetch_data(f"url{i}") for i in range(3)]
    results = await asyncio.gather(*tasks)
    print(results)

asyncio.run(main())

Rust:

use std::thread;
use std::time::Duration;

// 线程
fn main() {
    let handle = thread::spawn(|| {
        println!("Worker starting");
        thread::sleep(Duration::from_secs(2));
        println!("Worker finished");
    });
    
    handle.join().unwrap();
}

// 异步编程（需要 tokio crate）
#[tokio::main]
async fn main() {
    let tasks = (0..3).map(|i| fetch_data(format!("url{}", i)));
    let results = futures::future::join_all(tasks).await;
    println!("{:?}", results);
}

async fn fetch_data(url: String) -> String {
    tokio::time::sleep(Duration::from_secs(1)).await;
    format!("Data from {}", url)
}

// 通道通信
use std::sync::mpsc;

let (tx, rx) = mpsc::channel();
thread::spawn(move || {
    tx.send("Hello from thread").unwrap();
});
let received = rx.recv().unwrap();

9. 包管理与模块系统

9.1 模块导入

Python:

# 导入模块
import os
import sys
from collections import defaultdict
from typing import List, Dict, Optional

# 相对导入
from .utils import helper_function
from ..config import settings

# 别名
import numpy as np
import pandas as pd

# 包结构
# myproject/
#   __init__.py
#   main.py
#   utils/
#     __init__.py
#     helpers.py

Rust:

// 使用外部crate
use std::collections::HashMap;
use std::fs::File;
use std::io::prelude::*;

// 模块声明和使用
mod utils {
    pub fn helper_function() -> String {
        String::from("Helper")
    }
}

use utils::helper_function;

// 外部crate（在Cargo.toml中声明）
use serde::{Serialize, Deserialize};
use tokio::time::Duration;

// 模块结构
// src/
#   main.rs
#   lib.rs
#   utils/
#     mod.rs
#     helpers.rs

9.2 包配置文件

Python - requirements.txt / pyproject.toml:

[build-system]
requires = ["setuptools", "wheel"]

[project]
name = "myproject"
version = "0.1.0"
dependencies = [
    "requests>=2.25.0",
    "numpy>=1.20.0",
]

Rust - Cargo.toml:

[package]
name = "myproject"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1.0", features = ["full"] }
reqwest = "0.11"

[dev-dependencies]
assert_cmd = "2.0"

10. 性能与安全特性

10.1 内存安全

Python:

# 运行时检查，可能出现错误
def access_list(items, index):
    return items[index]  # 可能 IndexError

# 内存泄漏可能（循环引用）
class Node:
    def __init__(self, value):
        self.value = value
        self.children = []
        self.parent = None

# 手动解决循环引用
import weakref
class Node:
    def __init__(self, value):
        self.value = value
        self.children = []
        self._parent = None
    
    @property 
    def parent(self):
        return self._parent() if self._parent else None
    
    @parent.setter
    def parent(self, value):
        self._parent = weakref.ref(value) if value else None

Rust:

// 编译时保证内存安全
fn access_vector(items: &Vec<i32>, index: usize) -> Option<&i32> {
    items.get(index)  // 安全访问，返回 Option
}

// 防止悬垂指针
fn dangling_reference() -> &str {
    let s = String::from("hello");
    &s  // 编译错误！返回对局部变量的引用
}

// 智能指针解决复杂所有权
use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Node {
    value: i32,
    children: RefCell<Vec<Rc<Node>>>,
    parent: RefCell<Weak<Node>>,
}

impl Node {
    fn new(value: i32) -> Rc<Node> {
        Rc::new(Node {
            value,
            children: RefCell::new(vec![]),
            parent: RefCell::new(Weak::new()),
        })
    }
}

11. 宏系统

11.1 代码生成

Python:

# 元类和装饰器实现代码生成
def auto_str(cls):
    """自动生成 __str__ 方法"""
    def __str__(self):
        attrs = ', '.join(f"{k}={v}" for k, v in self.__dict__.items())
        return f"{cls.__name__}({attrs})"
    cls.__str__ = __str__
    return cls

@auto_str
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

p = Person("Alice", 30)
print(p)  # Person(name=Alice, age=30)

Rust:

// 声明宏
macro_rules! vec_of_strings {
    ($($x:expr),*) => {
        vec![$(String::from($x)),*]
    };
}

let strings = vec_of_strings!["hello", "world", "rust"];

// 复杂宏示例
macro_rules! create_function {
    ($func_name:ident, $return_type:ty, $body:expr) => {
        fn $func_name() -> $return_type {
            $body
        }
    };
}

create_function!(get_answer, i32, 42);
println!("{}", get_answer());  // 输出: 42

// 过程宏（Procedural Macros）
#[derive(Debug, Serialize, Deserialize)]
struct User {
    name: String,
    email: String,
}

12. 测试框架

12.1 单元测试

Python:

import unittest
import pytest

# unittest 框架
class TestMath(unittest.TestCase):
    def test_addition(self):
        self.assertEqual(2 + 2, 4)
    
    def test_division(self):
        with self.assertRaises(ZeroDivisionError):
            1 / 0

# pytest 框架
def test_addition():
    assert 2 + 2 == 4

def test_division():
    with pytest.raises(ZeroDivisionError):
        1 / 0

# 参数化测试
@pytest.mark.parametrize("a,b,expected", [
    (2, 2, 4),
    (3, 3, 9),
    (4, 4, 16),
])
def test_square(a, b, expected):
    assert a * b == expected

Rust:

// 内置测试框架
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_addition() {
        assert_eq!(2 + 2, 4);
    }

    #[test]
    #[should_panic]
    fn test_division_by_zero() {
        let _result = 1 / 0;
    }

    #[test]
    fn test_result() -> Result<(), String> {
        if 2 + 2 == 4 {
            Ok(())
        } else {
            Err(String::from("Math is broken"))
        }
    }
}

// 文档测试
/// 这个函数将两个数相加
/// 
/// # Examples
/// 
/// ```
/// assert_eq!(add(2, 2), 4);
/// ```
fn add(a: i32, b: i32) -> i32 {
    a + b
}

// 基准测试（需要 nightly Rust）
#[bench]
fn bench_addition(b: &mut test::Bencher) {
    b.iter(|| {
        (0..1000).fold(0, |acc, x| acc + x)
    });
}

13. 设计哲学对比

13.1 Python: "简单胜过复杂"

# Python 之禅体现的设计理念
import this

# 简洁表达
numbers = [1, 2, 3, 4, 5]
squared = [x**2 for x in numbers]

# 鸭子类型
def process_items(items):
    for item in items:
        print(item)  # 只要有 __str__ 就能工作

process_items([1, 2, 3])
process_items("abc")
process_items({"a": 1, "b": 2})

13.2 Rust: "安全、速度、并发"

// 零成本抽象
let numbers = vec![1, 2, 3, 4, 5];
let squared: Vec<i32> = numbers.iter().map(|x| x * x).collect();

// 类型安全
trait Printable {
    fn print(&self);
}

impl Printable for i32 {
    fn print(&self) {
        println!("{}", self);
    }
}

fn process_items<T: Printable>(items: Vec<T>) {
    for item in items {
        item.print();
    }
}

// 编译时保证类型安全
// process_items(vec![1, "string"]);  // 编译错误

14. 实际应用场景选择

14.1 Python 更适合的场景

• 数据科学: NumPy, Pandas, Matplotlib 生态系统
• 机器学习: TensorFlow, PyTorch, scikit-learn
• Web 开发: Django, Flask, FastAPI
• 脚本自动化: 系统管理、数据处理
• 原型开发: 快速验证想法

14.2 Rust 更适合的场景

• 系统编程: 操作系统、驱动程序
• 高性能服务: Web 服务器、数据库
• 区块链: 加密货币、智能合约
• WebAssembly: 浏览器高性能计算
• 嵌入式开发: IoT 设备、微控制器

总结

Python 和 Rust 在语法上存在根本性差异，这些差异源于它们不同的设计目标：

Python 追求简洁性和开发效率：

• 动态类型系统提供灵活性
• 简洁的语法降低学习门槛
• 丰富的标准库和第三方生态系统
• 适合快速原型开发和数据处理

Rust 追求安全性和性能：

• 静态类型系统在编译时捕获错误
• 所有权系统保证内存安全
• 零成本抽象提供高性能
• 适合系统级编程和性能关键应用

选择哪种语言应该基于项目需求、团队技能和性能要求。对于大多数应用开发，Python 提供了足够的性能和极佳的开发体验；对于需要极致性能和内存安全的场景，Rust 是更好的选择。

两种语言都在各自的领域内表现卓越，理解它们的语法差异有助于开发者根据具体需求做出明智的技术选择。