【学Python自动化】 9.1 Python 与 Rust 类机制对比学习笔记

一、类的基本概念

Python 类

Python 的类使用简洁的语法，支持面向对象编程的所有特性：

• 使用 class 关键字定义

• 支持多重继承

• 所有方法都是虚方法（virtual）

• 方法的第一个参数是 self（约定）

• 动态特性：运行时创建和修改

class MyClass:
    """一个简单的示例类"""
    i = 12345  # 类变量

    def f(self):
        return 'hello world'

Rust 结构体和实现

Rust 没有传统的"类"，但使用结构体（struct）和实现块（impl）实现类似功能：

• 使用 struct 定义数据结构

• 使用 impl 块定义方法

• 更严格的访问控制和所有权机制

• 支持特质（trait）实现多态

// 结构体定义
struct MyClass {
    i: i32,  // 实例字段
}

// 实现块
impl MyClass {
    // 关联函数（类似静态方法）
    fn new() -> Self {
        Self { i: 12345 }
    }
    
    // 方法，第一个参数是 &self
    fn f(&self) -> String {
        "hello world".to_string()
    }
}

### 二、命名空间和作用域
Python

+ 使用字典实现命名空间

+ 动态作用域解析

+ 支持 global 和 nonlocal 关键字

Rust

+ 静态作用域和生命周期管理

+ 模块系统提供命名空间

+ 无全局变量，使用静态项或常量

### 三、类定义和实例化
Python 实例化
```python

x = MyClass()  # 创建实例
x.i = 10       # 动态添加属性

Rust 实例化

let x = MyClass { i: 10 };  // 创建实例
// x.i = 20;  // 错误：默认不可变
let mut x = MyClass { i: 10 };  // 可变实例
x.i = 20;  // 允许修改

1 方法和属性

Python 方法

class MyClass:
    def __init__(self, value):  # 构造函数
        self.data = value
    
    def method(self):           # 实例方法
        return self.data

Rust 方法

struct MyClass {
    data: i32,
}

impl MyClass {
    // 关联函数（类似构造函数）
    fn new(value: i32) -> Self {
        Self { data: value }
    }
    
    // 方法，借用 self
    fn method(&self) -> i32 {
        self.data
    }
    
    // 可变方法，可变借用 self
    fn set_data(&mut self, value: i32) {
        self.data = value;
    }
    
    // 获取所有权的方法
    fn consume(self) -> i32 {
        self.data
    }
}

2 类和实例变量

Python 类变量和实例变量

class Dog:
    kind = 'canine'  # 类变量（所有实例共享）
    
    def __init__(self, name):
        self.name = name  # 实例变量

Rust 静态字段和实例字段

struct Dog {
    name: String,  // 实例字段
}

impl Dog {
    // 静态关联函数
    fn kind() -> &'static str {
        "canine"
    }
    
    fn new(name: &str) -> Self {
        Self { name: name.to_string() }
    }
}

三、继承和多态

Python 继承

class Base:
    def method(self):
        return "base method"

class Derived(Base):
    def method(self):
        return "derived method"

Rust 使用特质实现多态

// 定义特质
trait Base {
    fn method(&self) -> String;
}

// 为结构体实现特质
struct Derived;

impl Base for Derived {
    fn method(&self) -> String {
        "derived method".to_string()
    }
}

四、访问控制和私有性

Python 私有约定

class MyClass:
    def __init__(self):
        self._protected = "protected"  # 约定保护
        self.__private = "private"     # 名称改写

Rust 显式访问控制

mod my_module {
    pub struct MyClass {
        pub public_field: i32,    // 公开
        protected_field: i32,     // 模块内可见（默认）
    }
    
    impl MyClass {
        pub fn new() -> Self {
            Self { 
                public_field: 1, 
                protected_field: 2 
            }
        }
    }
}

五、迭代器和生成器

Python 迭代器和生成器

# 迭代器
class Reverse:
    def __init__(self, data):
        self.data = data
        self.index = len(data)
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index -= 1
        return self.data[self.index]

# 生成器
def reverse(data):
    for i in range(len(data)-1, -1, -1):
        yield data[i]

Rust 迭代器

// 实现迭代器特质
struct Reverse<'a> {
    data: &'a [char],
    index: usize,
}

impl<'a> Reverse<'a> {
    fn new(data: &'a [char]) -> Self {
        Self { data, index: data.len() }
    }
}

impl<'a> Iterator for Reverse<'a> {
    type Item = char;
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.index == 0 {
            None
        } else {
            self.index -= 1;
            Some(self.data[self.index])
        }
    }
}

六、关键差异总结

Rust 的面向对象编程更加显式和严格，强调编译时安全和性能，而 Python 提供了更大的灵活性和动态性。