Python高级技术之：`Python`与`Rust`的集成：如何利用`PyO3`编写高性能的`Python`模块。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位朋友，晚上好！我是你们的老朋友，今天咱们来聊聊一个既有趣又实用的话题：Python 与 Rust 的结合，以及如何利用 PyO3 编写高性能的 Python 模块。

想象一下，你正在开发一个计算密集型的 Python 应用，比如图像处理、数据分析或者机器学习。虽然 Python 语法简洁易懂，开发效率高，但面对庞大的数据量和复杂的计算，它的执行效率就显得有些力不从心了。这时候，你就需要一个“秘密武器”来提升性能，而 Rust 就是一个不错的选择。

Rust 是一门系统编程语言，以其安全性、并发性和高性能而闻名。它可以让你编写出接近 C/C++ 性能的代码，同时避免了 C/C++ 常见的内存安全问题。而 PyO3 则是 Rust 的一个库，它提供了一套方便的工具，让你能够轻松地将 Rust 代码编译成 Python 模块，从而在 Python 中调用 Rust 函数，实现性能的飞跃。

那么，具体该怎么做呢？别着急，咱们一步一步来。

第一步：准备工作

首先，你需要确保你的系统上安装了 Rust 和 Python。

Rust: 你可以通过 Rust 的官方网站 (https://www.rust-lang.org/tools/install) 下载并安装 Rust。安装完成后，记得配置环境变量，确保 cargo 命令可以正常使用。cargo 是 Rust 的包管理器和构建工具，类似于 Python 的 pip。
Python: 如果你还没有安装 Python，可以从 Python 的官方网站 (https://www.python.org/downloads/) 下载并安装。建议使用 Python 3.6 或更高版本。

安装完成后，你需要安装 maturin。maturin 是一个用于构建和发布 Python 包的工具，它能够简化 Rust 扩展模块的构建过程。

pip install maturin

第二步：创建一个 Rust 项目

接下来，咱们创建一个新的 Rust 项目，用于编写我们的高性能模块。

cargo new --lib my_rust_module
cd my_rust_module

这条命令会创建一个名为 my_rust_module 的 Rust 库项目。

第三步：配置 Cargo.toml

打开 Cargo.toml 文件，这是 Rust 项目的配置文件。我们需要添加一些配置，告诉 cargo 我们的项目是一个 Python 扩展模块，并且使用 PyO3 库。

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

[lib]
name = "my_rust_module" # This should match the name in pyo3.
crate-type = ["cdylib"]

[dependencies]
pyo3 = { version = "0.20", features = ["extension-module"] } # Use a recent version of pyo3

crate-type = ["cdylib"] 指定了 crate 的类型为 cdylib，这是一种动态链接库，可以被 Python 加载。
pyo3 = { version = "0.20", features = ["extension-module"] } 添加了 PyO3 依赖，并启用了 extension-module 特性，这允许我们将 Rust 代码编译成 Python 扩展模块。请注意，pyo3 的版本需要根据最新的版本进行调整。

第四步：编写 Rust 代码

现在，咱们开始编写 Rust 代码，实现我们的高性能函数。打开 src/lib.rs 文件，这是 Rust 项目的源代码文件。

use pyo3::prelude::*;

#[pyfunction]
fn sum_list(list: Vec<i32>) -> PyResult<i32> {
    let mut sum = 0;
    for num in list {
        sum += num;
    }
    Ok(sum)
}

#[pyfunction]
fn fibonacci(n: i32) -> PyResult<i64> {
    if n <= 1 {
        Ok(n as i64)
    } else {
        let mut a: i64 = 0;
        let mut b: i64 = 1;
        for _ in 2..=n {
            let temp = a + b;
            a = b;
            b = temp;
        }
        Ok(b)
    }
}

#[pymodule]
fn my_rust_module(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(sum_list, m)?)?;
    m.add_function(wrap_pyfunction!(fibonacci, m)?)?;
    Ok(())
}

这段代码定义了两个函数：

sum_list: 接受一个整数列表作为参数，计算列表中所有元素的和，并返回结果。
fibonacci: 接受一个整数 n 作为参数，计算斐波那契数列的第 n 项，并返回结果。

代码中的关键部分是：

use pyo3::prelude::*;: 导入 PyO3 的 prelude 模块，它包含了一些常用的类型和宏。
#[pyfunction]: 这是一个宏，用于将 Rust 函数暴露给 Python。
#[pymodule]: 这是一个宏，用于定义 Python 模块。模块名需要和 Cargo.toml 文件中 [lib] 下的 name 字段保持一致。
wrap_pyfunction!(): 这是一个宏，用于将 Rust 函数转换为 Python 函数，并将其添加到模块中。

注意：函数参数类型必须与Python类型兼容，例如，Rust的i32对应Python的int，Vec<i32>对应Python的list[int]。返回值类型需要是 PyResult<T>，其中 T 是实际的返回值类型。

第五步：构建 Python 模块

现在，咱们使用 maturin 构建 Python 模块。

maturin develop

这条命令会在当前目录下创建一个 target 目录，并将编译好的 Python 模块放在该目录下。 maturin develop 会将编译好的模块安装到你的 Python 环境中，方便你进行测试。

如果你想要构建一个可以发布的 Python 包，可以使用以下命令：

maturin build --release

这条命令会构建一个优化过的 release 版本的 Python 包。

第六步：在 Python 中使用 Rust 模块

现在，你可以在 Python 中使用你编写的 Rust 模块了。创建一个 Python 文件，例如 main.py，并添加以下代码：

import my_rust_module

my_list = [1, 2, 3, 4, 5]
sum_result = my_rust_module.sum_list(my_list)
print(f"Sum of list: {sum_result}")

fibonacci_result = my_rust_module.fibonacci(10)
print(f"Fibonacci(10): {fibonacci_result}")

#测试大型列表求和性能
import time
large_list = list(range(1000000))

start_time = time.time()
sum_result_python = sum(large_list)
end_time = time.time()
print(f"Python sum time: {end_time - start_time:.4f} seconds")

start_time = time.time()
sum_result_rust = my_rust_module.sum_list(large_list)
end_time = time.time()
print(f"Rust sum time: {end_time - start_time:.4f} seconds")

运行这个 Python 文件：

python main.py

你应该能够看到以下输出：

Sum of list: 15
Fibonacci(10): 55
Python sum time: 0.0070 seconds
Rust sum time: 0.0015 seconds

可以看到，Rust版本的sum_list函数比Python版本的sum函数快很多。

进阶技巧：处理复杂数据类型

上面的例子只处理了简单的整数类型。如果我们需要处理更复杂的数据类型，例如字符串、结构体、甚至是 Python 对象，该怎么办呢？

PyO3 提供了强大的数据类型转换机制，可以让你在 Rust 和 Python 之间轻松地传递数据。

字符串: Rust 的 String 类型可以和 Python 的 str 类型相互转换。

use pyo3::prelude::*;

#[pyfunction]
fn greet(name: String) -> PyResult<String> {
    Ok(format!("Hello, {}!", name))
}

#[pymodule]
fn my_rust_module(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(greet, m)?)?;
    Ok(())
}

结构体: 你可以使用 #[pyclass] 宏将 Rust 结构体暴露给 Python。

use pyo3::prelude::*;

#[pyclass]
#[derive(Clone, Debug)]
struct Point {
    #[pyo3(get, set)]
    x: i32,
    #[pyo3(get, set)]
    y: i32,
}

#[pymethods]
impl Point {
    #[new]
    fn new(x: i32, y: i32) -> Self {
        Point { x, y }
    }

    fn distance(&self) -> f64 {
        ((self.x.pow(2) + self.y.pow(2)) as f64).sqrt()
    }
}

#[pyfunction]
fn create_point(x: i32, y: i32) -> PyResult<Point> {
    Ok(Point::new(x, y))
}

#[pymodule]
fn my_rust_module(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_class::<Point>()?;
    m.add_function(wrap_pyfunction!(create_point, m)?)?;
    Ok(())
}

在 Python 中，你可以像使用普通的 Python 类一样使用 Point 类。

import my_rust_module

point = my_rust_module.Point(3, 4)
print(f"Point: {point.x}, {point.y}")
print(f"Distance: {point.distance()}")

point.x = 5
print(f"Updated Point: {point.x}, {point.y}")

new_point = my_rust_module.create_point(10, 20)
print(f"Created point: {new_point.x}, {new_point.y}")

Python 对象: 你可以使用 PyObject 类型来处理 Python 对象。

use pyo3::prelude::*;

#[pyfunction]
fn print_python_object(obj: PyObject) -> PyResult<()> {
    Python::with_gil(|py| {
        println!("{:?}", obj.to_object(py));
        Ok(())
    })
}

#[pymodule]
fn my_rust_module(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(print_python_object, m)?)?;
    Ok(())
}

在 Python 中，你可以将任何 Python 对象传递给 print_python_object 函数。

import my_rust_module

my_rust_module.print_python_object([1, 2, 3])
my_rust_module.print_python_object({"name": "Alice", "age": 30})

一些建议和注意事项：

错误处理: 在 Rust 代码中，尽量使用 PyResult<T> 来处理错误。这可以让你将 Rust 的错误转换为 Python 的异常，方便 Python 代码进行处理。
GIL (Global Interpreter Lock): Python 的 GIL 限制了多线程的并行执行。如果你的 Rust 代码需要进行大量的并行计算，可以考虑使用 rayon 库，它可以在 Rust 中实现真正的并行。但是，需要注意的是，在调用 rayon 的并行代码时，你需要释放 GIL，否则可能会导致死锁。PyO3 提供了 Python::allow_threads(|| ...) 块来释放 GIL。
内存管理: Rust 的所有权系统可以帮助你避免内存泄漏和悬垂指针等问题。但是，在与 Python 交互时，你需要特别注意内存管理。确保你的 Rust 代码不会意外地释放 Python 对象占用的内存，也不会访问已经释放的 Python 对象。
性能测试: 在将 Rust 代码集成到 Python 应用之前，务必进行性能测试，确保你的 Rust 代码确实能够提升性能。可以使用 Python 的 timeit 模块或者 perf 工具来进行性能测试。

表格总结：Python 类型与 Rust 类型对应

Python 类型	Rust 类型	说明
`int`	`i32`, `i64` 等	根据实际数值范围选择合适的 Rust 整数类型。
`float`	`f32`, `f64`	根据精度要求选择合适的 Rust 浮点数类型。
`str`	`String`, `&str`	`String` 是拥有所有权的字符串，`&str` 是字符串切片。通常函数参数使用 `String`，函数内部使用 `&str`。
`bool`	`bool`
`list[T]`	`Vec<T>`	`T` 需要替换成 list 中元素的 Rust 类型。
`tuple[T1, T2]`	`(T1, T2)`	`T1`, `T2` 需要替换成 tuple 中对应位置元素的 Rust 类型。
`dict[K, V]`	`HashMap<K, V>`	需要 `use std::collections::HashMap;` `K` 和 `V` 需要替换成 key 和 value 的 Rust 类型。
Python 对象	`PyObject`	可以表示任何 Python 对象。需要使用 `Python::with_gil` 获取 GIL 才能安全地操作 `PyObject`。
`None`	`()`	Unit type

总而言之，PyO3 是一个强大的工具，可以让你充分利用 Rust 的高性能和 Python 的易用性。通过将计算密集型的任务交给 Rust 来处理，你可以显著提升 Python 应用的性能。当然，这需要你对 Rust 和 Python 都有一定的了解，并且需要仔细考虑数据类型转换、内存管理和错误处理等问题。

希望今天的讲座能够帮助你入门 Python 与 Rust 的集成。记住，实践是检验真理的唯一标准。赶快动手尝试一下，看看 Rust 能够为你的 Python 应用带来什么样的惊喜吧！

有问题随时提问，祝大家编程愉快！

发表回复 取消回复

发表回复取消回复