---
author: Moshe Zadka
category: 软件开发
comments_data: []
count:
  commentnum: 0
  favtimes: 0
  likes: 0
  sharetimes: 0
  viewnum: 3104
date: '2023-05-26 16:34:24'
editorchoice: false
excerpt: Rust 和 Python 的优势互补。可以使用 Python 进行原型设计，然后将性能瓶颈转移到 Rust 上。
fromurl: https://opensource.com/article/23/3/python-loves-rust
id: 15846
islctt: true
largepic: /images/p/202305/26/163350snf627fx05ynz71j.jpg
permalink: /article-15846-1.html
pic: /images/p/202305/26/163350snf627fx05ynz71j.jpg.thumb.jpg
related: []
reviewer: wxy
selector: lkxed
summary: Rust 和 Python 的优势互补。可以使用 Python 进行原型设计，然后将性能瓶颈转移到 Rust 上。
tags:
- Rust
- Python
thumb: false
title: 结合使用 Python 和 Rust
titlepic: true
translator: ChatGPT
updated: '2023-05-26 16:34:24'
---

![](/images/p/202305/26/163350snf627fx05ynz71j.jpg)



> 
> Rust 和 Python 的优势互补。可以使用 Python 进行原型设计，然后将性能瓶颈转移到 Rust 上。
> 
> 
> 


Python 和 Rust 是非常不同的语言，但它们实际上非常搭配。但在讨论如何将 Python 与 Rust 结合之前，我想先介绍一下 Rust 本身。你可能已经听说了这种语言，但可能还没有了解过它的细节。


### 什么是 Rust？


Rust 是一种低级语言，这意味着程序员所处理的东西接近于计算机的 “真实” 运行方式。


例如，整数类型由字节大小定义，与 CPU 支持的类型相对应。虽然我们很想简单地说 Rust 中的 `a+b` 对应于一条机器指令，但实际上并不完全是这样！


Rust 编译器链非常复杂。作为第一种近似的方法，将这样的语句视为 “有点” 真实是有用的。


Rust 旨在实现零成本抽象，这意味着许多语言级别可用的抽象在运行时环境中会被编译去掉。


例如，除非明确要求，对象会在堆栈上分配。结果是，在 Rust 中创建本地对象没有运行时成本（尽管可能需要进行初始化）。


最后，Rust 是一种内存安全的语言。也有其他内存安全的语言和其他支持零成本抽象的语言。但通常这些是两类不同的语言。


内存安全并不意味着不可能在 Rust 中出现内存违规。它确实意味着只有两种方式可能导致内存违规：


* 编译器的错误。
* 显式声明为不安全（`unsafe`）的代码。


Rust 标准库代码有很多被标记为不安全的代码，虽然比许多人预期的少。这并不意味着该语句无意义。除了需要自己编写不安全代码的（罕见的）情况外，内存违规通常是由基础设施造成的。


### 为什么会有 Rust 出现？


为什么人们要创建 Rust？是哪些问题没有被现有编程语言解决吗？


Rust 被设计成既能高效运行，又保证内存安全。在现代的联网世界中，这是一个越来越重要的问题。


Rust 的典型应用场景是协议的低级解析。待解析的数据通常来自不受信任的来源，并且需要通过高效的方式进行解析。


如果你认为这听起来像 Web 浏览器所做的事情，那不是巧合。Rust 最初起源于 Mozilla 基金会，它是为了改进 Firefox 浏览器而设计的。


如今，需要保证安全和速度的不仅仅是浏览器。即使是常见的微服务架构也必须能够快速解析不受信任的数据，同时保证安全。


### 现实示例：统计字符


为了理解 “封装 Rust” 的例子，需要解决一个问题。这个问题需要满足以下要求：


* 足够容易解决。
* 能够写高性能循环来优化。
* 有一定的现实意义。


这个玩具问题的例子是判断一个字符在一个字符串中是否出现超过了 X 次。这个问题不容易通过高效的正则表达式解决。即使是专门的 Numpy 代码也可能不够快，因为通常没有必要扫描整个字符串。


你可以想象一些 Python 库和技巧的组合来解决这个问题。然而，如果在低级别的语言中实现直接的算法，它会非常快，并且更易于阅读。


为了使问题稍微有趣一些，以演示 Rust 的一些有趣部分，这个问题增加了一些变化。该算法支持在换行符处重置计数（意即：字符是否在一行中出现了超过 X 次？）或在空格处重置计数（意即：字符是否在单词中出现了超过 X 次？）。


这是唯一与 “现实性” 相关的部分。过多的现实性将使这个示例在教育上不再有用。


#### 支持枚举


Rust 支持使用枚举（`enum`）。你可以使用枚举做很多有趣的事情。


目前，只使用了一个简单的三选一的枚举，并没有其他的变形。这个枚举编码了哪种字符重置计数。



```
#[derive(Copy)]
enum Reset {
    NewlinesReset,
    SpacesReset,
    NoReset,
}

```

#### 支持结构


接下来的 Rust 组件更大一些：这是一个结构（`struct`）。Rust 的结构与 Python 的 `dataclass` 有些相似。同样，你可以用结构做更复杂的事情。



```
#[pyclass]
struct Counter {
    what: char,
    min_number: u64,
    reset: Reset, 
}

```

#### 实现块


你可以在 Rust 中使用一个单独的块，称为实现（`impl`）块，为结构添加一个方法。但具体细节超出了本文的范围。


在这个示例中，该方法调用了一个外部函数。这主要是为了分解代码。更复杂的用例将指示 Rust 编译器内联该函数，以便在不产生任何运行时成本的情况下提高可读性。



```
#[pymethods]
impl Counter {
    #[new]
    fn new(what: char, min_number: u64, reset: Reset) -> Self {
        Counter{what: what, min_number: min_number, reset: reset}
    }
    
    fn has_count(
        &self,
        data: &str,
    ) -> bool {
        has_count(self, data.chars())
    }
}

```

#### 函数


默认情况下，Rust 变量是常量。由于当前的计数（`current_count`）必须更改，因此它被声明为可变变量。



```
fn has_count(cntr: &Counter, chars: std::str::Chars) -> bool {
    let mut current_count : u64 = 0;
    for c in chars {
        if got_count(cntr, c, &mut current_count) {
            return true;
        }
    }
    false
}

```

该循环遍历字符并调用 `got_count` 函数。再次强调，这是为了将代码分解成幻灯片展示。它展示了如何向函数发送可变引用。


尽管 `current_count` 是可变的，但发送和接收站点都显式标记该引用为可变。这可以清楚地表明哪些函数可能修改一个值。


#### 计数


`got_count` 函数重置计数器，将其递增，然后检查它。Rust 的冒号分隔的表达式序列评估最后一个表达式的结果，即是否达到了指定的阈值。



```
fn got_count(cntr: &Counter, c: char, current_count: &mut u64) -> bool {
    maybe_reset(cntr, c, current_count);
    maybe_incr(cntr, c, current_count);
    *current_count >= cntr.min_number
}

```

#### 重置代码


`reset` 的代码展示了 Rust 中另一个有用的功能：模式匹配。对 Rust 中匹配的完整描述需要一个学期级别的课程，不适合在一个无关的演讲中讲解。这个示例匹配了该元组的两个选项之一。



```
fn maybe_reset(cntr: &Counter, c: char, current_count: &mut u64) -> () {
    match (c, cntr.reset) {
        ('\n', Reset::NewlinesReset) | (' ', Reset::SpacesReset)=> {
            *current_count = 0;
        }
        _ => {}
    };
}

```

#### 增量支持


增量将字符与所需字符进行比较，并在匹配时增加计数。



```
fn maybe_incr(cntr: &Counter, c: char, current_count: &mut u64) -> (){
    if c == cntr.what {
        *current_count += 1;
    };
}

```

请注意，我在本文中优化了代码以适合幻灯片。这不一定是 Rust 代码的最佳实践示例，也不是如何设计良好的 API 的示例。


### 为 Python 封装 Rust 代码


为了将 Rust 代码封装到 Python 中，你可以使用 PyO3。PyO3 Rust “crate”（即库）允许内联提示将 Rust 代码包装为 Python，使得修改两者更容易。


#### 包含 PyO3 crate 原语


首先，你必须包含 PyO3 crate 原语。



```
use pyo3::prelude::*;

```

#### 封装枚举


枚举需要被封装。`derive` 从句对于将枚举封装为 PyO3 是必需的，因为它们允许类被复制和克隆，使它们更容易在 Python 中使用。



```
#[pyclass]
#[derive(Clone)]
#[derive(Copy)]
enum Reset {
    /* ... */
}

```

#### 封装结构


结构同样需要被封装。在 Rust 中，这些被称为 “宏”，它们会生成所需的接口位。



```
#[pyclass]
struct Counter {
    /* ... */
}

```

#### 封装实现


封装实现（`impl`）更有趣。增加了另一个名为 `new` 的宏。此方法被标记为 `#[new]`，让 PyO3 知道如何为内置对象公开构造函数。



```
#[pymethods]
impl Counter {
    #[new]
    fn new(what: char, min_number: u64,
          reset: Reset) -> Self {
        Counter{what: what,
          min_number: min_number, reset: reset}
    }
    /* ... */
}

```

#### 定义模块


最后，定义一个初始化模块的函数。此函数具有特定的签名，必须与模块同名，并用 `#[pymodule]` 修饰。



```
#[pymodule]
fn counter(_py: Python, m: &PyModule
) -> PyResult<()> {
    m.add_class::<Counter>()?;
    m.add_class::<Reset>()?;
    Ok(())
}

```

`?` 显示此函数可能失败（例如，如果类没有正确配置）。 `PyResult` 在导入时转换为 Python 异常。


#### Maturin 开发


为了快速检查，用 `maturin develop` 构建并将库安装到当前虚拟环境中。这有助于快速迭代。



```
$ maturin develop

```

#### Maturin 构建


`maturin build` 命令构建一个 `manylinux` 轮子，它可以上传到 PyPI。轮子是特定于 CPU 架构的。


#### Python 库


从 Python 中使用库是最简单的部分。没有任何东西表明这与在 Python 中编写代码有什么区别。这其中的一个有用方面是，如果你优化了已经有单元测试的 Python 中的现有库，你可以使用 Python 单元测试来测试 Rust 库。


#### 导入


无论你是使用 `maturin develop` 还是 `pip install` 来安装它，导入库都是使用 `import` 完成的。



```
import counter

```

#### 构造函数


构造函数的定义正好使对象可以从 Python 构建。这并不总是如此。有时仅从更复杂的函数返回对象。



```
cntr = counter.Counter(
    'c',
    3,
    counter.Reset.NewlinesReset,
)

```

#### 调用函数


最终的收益终于来了。检查这个字符串是否至少有三个 “c” 字符：



```
>>> cntr.has_count("hello-c-c-c-goodbye")
True

```

添加一个换行符会触发剩余操作，这里没有插入换行符的三个 “c” 字符：



```
>>> cntr.has_count("hello-c-c-\nc-goodbye")
False

```

### 使用 Rust 和 Python 很容易


我的目标是让你相信将 Rust 和 Python 结合起来很简单。我编写了一些“粘合剂”代码。Rust 和 Python 具有互补的优点和缺点。


Rust 非常适合高性能、安全的代码。Rust 具有陡峭的学习曲线，对于快速原型解决方案而言可能有些笨拙。


Python 很容易入手，并支持非常紧密的迭代循环。Python 确实有一个“速度上限”。超过一定程度后，从 Python 中获得更好的性能就更难了。


将它们结合起来完美无缝。在 Python 中进行原型设计，并将性能瓶颈移至 Rust 中。


使用 Maturin，你的开发和部署流程更容易进行。开发、构建并享受这一组合吧！




---


via: <https://opensource.com/article/23/3/python-loves-rust>


作者：[Moshe Zadka](https://opensource.com/users/moshez) 选题：[lkxed](https://github.com/lkxed/) 译者：ChatGPT 校对：[wxy](https://github.com/wxy)


本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出