Rust 系统编程实战：11.2 编写 Python/Ruby 扩展
Rust 是一种高性能、内存安全的系统编程语言，而 Python 和 Ruby 是广泛使用的高级编程语言。通过将 Rust 与 Python/Ruby 集成，开发者可以在保持高性能的同时，利用 Python/Ruby 的灵活性和丰富的生态系统。本文将深入探讨如何使用 Rust 编写 Python 和 Ruby 扩展，涵盖基本概念、工具链配置、FFI（Foreign Function Interface）的使用、以及实际示例。
11.2.1 Rust 与 Python/Ruby 扩展概述
11.2.1.1 什么是扩展？
扩展是指通过编写原生代码（如 C/C++ 或 Rust）来增强高级语言（如 Python 或 Ruby）的功能。扩展通常用于性能关键的部分，或者与底层系统进行交互。
11.2.1.2 Rust 编写扩展的优势
- 高性能：Rust 生成的代码性能接近 C/C++，适用于性能关键的部分。
- 内存安全：Rust 的所有权系统避免了常见的内存错误，如空指针、缓冲区溢出等。
- 跨平台：Rust 支持多种平台，可以轻松编写跨平台的扩展。
11.2.2 编写 Python 扩展
11.2.2.1 使用 PyO3 编写 Python 扩展
PyO3 是一个用于编写 Python 扩展的 Rust 库，提供了与 Python 的互操作支持。以下是一个使用 PyO3 编写 Python 扩展的示例。
11.2.2.1.1 添加依赖
在 Cargo.toml 中添加 PyO3 依赖：
[lib]
name = "my_rust_module"
crate-type = ["cdylib"]
[dependencies]
pyo3 = { version = "0.15", features = ["extension-module"] }
11.2.2.1.2 编写 Rust 代码
在 src/lib.rs 中编写 Rust 代码：
use pyo3::prelude::*;
use pyo3::wrap_pyfunction;
#[pyfunction]
fn add(a: i32, b: i32) -> i32 {
a + b
}
#[pymodule]
fn my_rust_module(py: Python, m: &PyModule) -> PyResult<()> {
m.add_function(wrap_pyfunction!(add, m)?)?;
Ok(())
}
代码说明
#[pyfunction]：定义一个 Python 函数。#[pymodule]：定义一个 Python 模块。wrap_pyfunction!：将 Rust 函数包装为 Python 函数。m.add_function：将函数添加到 Python 模块中。
11.2.2.1.3 编译扩展
使用 cargo 编译扩展：
cargo build --release
11.2.2.1.4 在 Python 中使用扩展
在 Python 中使用编译好的扩展：
import my_rust_module
result = my_rust_module.add(1, 2)
print(result) # 输出 3
11.2.2.2 使用 maturin 构建和发布 Python 扩展
maturin 是一个用于构建和发布 Python 扩展的工具，支持 PyO3 和 setuptools-rust。以下是一个使用 maturin 构建和发布 Python 扩展的示例。
11.2.2.2.1 安装 maturin
使用 pip 安装 maturin：
pip install maturin
11.2.2.2.2 初始化项目
使用 maturin 初始化项目：
maturin init
11.2.2.2.3 编写 Rust 代码
在 src/lib.rs 中编写 Rust 代码：
use pyo3::prelude::*;
use pyo3::wrap_pyfunction;
#[pyfunction]
fn multiply(a: i32, b: i32) -> i32 {
a * b
}
#[pymodule]
fn my_rust_module(py: Python, m: &PyModule) -> PyResult<()> {
m.add_function(wrap_pyfunction!(multiply, m)?)?;
Ok(())
}
11.2.2.2.4 构建和发布扩展
使用 maturin 构建和发布扩展：
maturin build
maturin publish
11.2.2.2.5 在 Python 中使用扩展
在 Python 中使用发布的扩展：
import my_rust_module
result = my_rust_module.multiply(3, 4)
print(result) # 输出 12
11.2.3 编写 Ruby 扩展
11.2.3.1 使用 rutie 编写 Ruby 扩展
rutie 是一个用于编写 Ruby 扩展的 Rust 库，提供了与 Ruby 的互操作支持。以下是一个使用 rutie 编写 Ruby 扩展的示例。
11.2.3.1.1 添加依赖
在 Cargo.toml 中添加 rutie 依赖：
[lib]
name = "my_rust_module"
crate-type = ["cdylib"]
[dependencies]
rutie = "0.8"
11.2.3.1.2 编写 Rust 代码
在 src/lib.rs 中编写 Rust 代码：
use rutie::{Class, Object, RString, VM};
#[no_mangle]
pub extern "C" fn Init_my_rust_module() {
Class::new("MyRustModule", None).define(|klass| {
klass.def_self("greet", greet);
});
}
fn greet(_: &Class) -> RString {
RString::new_utf8("Hello from Rust!")
}
代码说明
#[no_mangle]：防止 Rust 编译器修改函数名。Init_my_rust_module：Ruby 扩展的初始化函数。Class::new：创建一个新的 Ruby 类。klass.def_self：定义一个类方法。RString::new_utf8：创建一个新的 Ruby 字符串。
11.2.3.1.3 编译扩展
使用 cargo 编译扩展：
cargo build --release
11.2.3.1.4 在 Ruby 中使用扩展
在 Ruby 中使用编译好的扩展：
require 'my_rust_module'
puts MyRustModule.greet # 输出 "Hello from Rust!"
11.2.3.2 使用 helix 编写 Ruby 扩展
helix 是一个用于编写 Ruby 扩展的 Rust 库，提供了与 Ruby 的互操作支持。以下是一个使用 helix 编写 Ruby 扩展的示例。
11.2.3.2.1 添加依赖
在 Cargo.toml 中添加 helix 依赖：
[lib]
name = "my_rust_module"
crate-type = ["cdylib"]
[dependencies]
helix = "0.7"
11.2.3.2.2 编写 Rust 代码
在 src/lib.rs 中编写 Rust 代码：
use helix::ruby;
#[ruby]
mod my_rust_module {
fn add(a: i32, b: i32) -> i32 {
a + b
}
}
代码说明
#[ruby]：定义一个 Ruby 模块。fn add：定义一个 Ruby 方法。
11.2.3.2.3 编译扩展
使用 cargo 编译扩展：
cargo build --release
11.2.3.2.4 在 Ruby 中使用扩展
在 Ruby 中使用编译好的扩展：
require 'my_rust_module'
puts MyRustModule.add(1, 2) # 输出 3
11.2.4 总结
Rust 提供了强大的工具和特性来支持与 Python 和 Ruby 的互操作。本文详细介绍了如何使用 Rust 编写 Python 和 Ruby 扩展，涵盖基本概念、工具链配置、FFI 的使用、以及实际示例。通过编写 Python 和 Ruby 扩展，开发者可以在保持高性能的同时，利用 Python 和 Ruby 的灵活性和丰富的生态系统。
继续阅读
探索更多技术文章
浏览归档，发现更多关于系统设计、工具链和工程实践的内容。