《深入Rust系统编程》11.2 编写Python/Ruby扩展

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 依赖：

1
2
3
4
5
6

[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 代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

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(())
}
代码说明
  1. #[pyfunction]：定义一个 Python 函数。
  2. #[pymodule]：定义一个 Python 模块。
  3. wrap_pyfunction!：将 Rust 函数包装为 Python 函数。
  4. m.add_function：将函数添加到 Python 模块中。

11.2.2.1.3 编译扩展

使用 cargo 编译扩展：

1

cargo build --release

11.2.2.1.4 在 Python 中使用扩展

在 Python 中使用编译好的扩展：

1
2
3
4

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：

1

pip install maturin

11.2.2.2.2 初始化项目

使用 maturin 初始化项目：

1

maturin init

11.2.2.2.3 编写 Rust 代码

在 src/lib.rs 中编写 Rust 代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

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 构建和发布扩展：

1
2

maturin build
maturin publish

11.2.2.2.5 在 Python 中使用扩展

在 Python 中使用发布的扩展：

1
2
3
4

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 依赖：

1
2
3
4
5
6

[lib]
name = "my_rust_module"
crate-type = ["cdylib"]

[dependencies]
rutie = "0.8"

11.2.3.1.2 编写 Rust 代码

在 src/lib.rs 中编写 Rust 代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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!")
}
代码说明
  1. #[no_mangle]：防止 Rust 编译器修改函数名。
  2. Init_my_rust_module：Ruby 扩展的初始化函数。
  3. Class::new：创建一个新的 Ruby 类。
  4. klass.def_self：定义一个类方法。
  5. RString::new_utf8：创建一个新的 Ruby 字符串。

11.2.3.1.3 编译扩展

使用 cargo 编译扩展：

1

cargo build --release

11.2.3.1.4 在 Ruby 中使用扩展

在 Ruby 中使用编译好的扩展：

1
2
3

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 依赖：

1
2
3
4
5
6

[lib]
name = "my_rust_module"
crate-type = ["cdylib"]

[dependencies]
helix = "0.7"

11.2.3.2.2 编写 Rust 代码

在 src/lib.rs 中编写 Rust 代码：

1
2
3
4
5
6
7
8

use helix::ruby;

#[ruby]
mod my_rust_module {
    fn add(a: i32, b: i32) -> i32 {
        a + b
    }
}
代码说明
  1. #[ruby]：定义一个 Ruby 模块。
  2. fn add：定义一个 Ruby 方法。

11.2.3.2.3 编译扩展

使用 cargo 编译扩展：

1

cargo build --release

11.2.3.2.4 在 Ruby 中使用扩展

在 Ruby 中使用编译好的扩展：

1
2
3

require 'my_rust_module'

puts MyRustModule.add(1, 2)  # 输出 3

11.2.4 总结

Rust 提供了强大的工具和特性来支持与 Python 和 Ruby 的互操作。本文详细介绍了如何使用 Rust 编写 Python 和 Ruby 扩展，涵盖基本概念、工具链配置、FFI 的使用、以及实际示例。通过编写 Python 和 Ruby 扩展，开发者可以在保持高性能的同时，利用 Python 和 Ruby 的灵活性和丰富的生态系统。