——3 个月从 0 到能用 Rust 写策略

今天就聊聊：Python 工程师，怎么快速上手 Rust 量化开发？

先说结论

Rust 确实有学习曲线，但没有你想的那么难。

为什么？

因为 Rust 有很多“Python 风格”的库——Polars 用起来和 Pandas 几乎一样，Rayon 并行和 Python 的 multiprocessing 类似，serde 序列化也 和 json.loads 差不多。

你不需要从零开始。

核心价值：为什么要费劲学 Rust？

在开始学之前，先想清楚一个问题：为什么要学？

价值一：5-10 倍的性能提升

同样的策略、同样的数据：

• • Python 跑 1 小时
• • Rust 跑 10 分钟

这不是吹牛，是真实的数据对比。

Polars（后面会专门讲）读取和处理数据的效率，比 Pandas 高 5-10 倍。加上 Rust 的多核并行能力，回测速度提升 5-10 倍是常态。

价值二：绕过 GIL，真正并行

Python 的 GIL 是所有并行计算的噩梦。

Rust 没有 GIL。你可以真正利用多核——8 核就真的是 8 倍性能，16 核就是 16 倍。

参数优化从 100 小时变成 10 小时，这不是梦想。

价值三：更安全的代码

Python 最头疼的问题是运行时错误——空指针、越界访问、内存泄漏，这些 bug 可能在测试环境没问题，到生产环境就崩。

Rust 的编译器在编译时就检查这些问题。写不出来有 bug 的代码，因为编译器会阻止你。

这对于交易系统来说尤其重要——谁也不想在凌晨三点收到报警说系统崩了。

第一个难点：Rust 基础（2-3 周）

这是最大的门槛。

环境搭建

1
2
3
4
5

# macOS / Linux
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Windows
# 去 rustup.rs 下载安装器

编辑器推荐 VS Code + rust-analyzer 插件，或者直接用 JetBrains CLion。

核心概念：理解这 3 个就够了

重点来了——Rust 最难的是所有权系统，但作为 Python 工程师，你只需要理解这 3 点：

1. 变量默认不可变

Python 变量可以随意改，Rust 不行：

1
2
3

# Python
x = 5
x = 10  # OK

1
2
3
4
5
6

// Rust
let x = 5;
// x = 10;  // 报错！

let mut x = 5;  // 加 mut 才能改
x = 10;  // OK

2. 赋值 = 移动（而非复制）

这是最需要适应的：

1
2
3
4
5

# Python
a = [1, 2, 3]
b = a  # 复制了一份
b.append(4)
print(a)  # [1, 2, 3]，a 不变

1
2
3
4
5
6
7
8
9
10

// Rust
let a = vec![1, 2, 3];
let b = a; // 移动了，a 不再可用！
// println!("{:?}", a);  // 报错！

// 如果真的需要复制
let mut a = vec![1, 2, 3];
let b = a.clone(); // 显式克隆
b.push(4);
println!("{:?}", a); // [1, 2, 3]，a 还在

3. 借用：引用但不拥有

这相当于 Python 的引用：

1
2
3

# Python
def get_first(lst):
    return lst[0]  # 借用，不影响原变量

1
2
3
4

// Rust
fn get_first(slice: &[i32]) -> &i32 {
    &slice[0]  // 借用，编译器保证安全
}

难点提示： 一开始不要纠结底层原理，知道怎么用就行。80% 的情况下，编译器会告诉你怎么改。

第二个难点：Polars 上手（1-2 周）

这是最爽的部分。

重点来了——Polars 的 API，几乎就是 Pandas 的 Rust 版本。

读取数据

1
2
3

# Python + Pandas
import pandas as pd
df = pd.read_csv("data.csv")

1
2
3
4
5
6

// Rust + Polars
use polars::prelude::*;
let df = CsvReader::from_path("data.csv")
    .unwrap()
    .finish()
    .unwrap();

基本操作

1
2
3
4

# Python
df.filter(df["price"] > 100)
df.group_by("symbol").agg({"volume": "sum"})
df.with_columns(df["close"].pct_change())

1
2
3
4
5

// Rust
df.filter(col("price").gt(100))?;
df.group_by(["symbol"])?
  .agg([col("volume").sum()])?
df.with_column(col("close").pct_change())?

价值提示：除了语法略有不同，逻辑完全一样。

LazyFrame：性能黑科技

这是 Polars 最强大的功能，也是和 Pandas 最大的区别。

难点提示：理解 LazyFrame 是性能的关键。

1
2
3

# Python：立即执行
df = pd.read_csv("data.csv")
result = df[df["price"] > 100]["volume"].sum()

1
2
3
4
5
6

// Rust：先构建查询 plan，最后一次性执行
let result = LazyCsvReader::new("data.csv")
    .finish()?
    .filter(col("price").gt(100))
    .select([col("volume").sum()])
    .collect()?;

区别：

• • Python：读一行、处理一行、再读下一行（逐步执行）
• • Rust：先规划好所有操作，然后一次性流水线执行（查询优化）

这就是 Polars 快 5-10 倍的原因。

第三个难点：量化实战（持续）

学会基础之后，就可以开始实战了。

读取金融数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

use polars::prelude::*;
use std::fs::File;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 读取 CSV
    let df = CsvReader::from_path("tick_data.csv")?
        .has_header(true)
        .finish()?;

    // 查看前几行
    println!("{:?}", df.head(Some(5)));

    // 基本统计
    println!("{:?}", df.describe());

    Ok(())
}

计算技术指标

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

use polars::prelude::*;
use polars::functions::ewm_mean;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let df = CsvReader::from_path("kline.csv")?
        .finish()?;

    // 计算 MA5, MA10, MA20, EMA
    let result = df.lazy()
        .with_columns([
            col("close").rolling_mean(5).alias("ma5"),
            col("close").rolling_mean(10).alias("ma10"),
            col("close").rolling_mean(20).alias("ma20"),
            ewm_mean(col("close"), 0.03, false).alias("ema"),
        ])
        .collect()?;

    println!("{:?}", result);

    Ok(())
}

并行回测

这是 Rust 的核心价值所在：

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

use rayon::prelude::*;

fn backtest_single(params: &Params) -> f64 {
    // 单次回测逻辑
    // ...
}

fn parallel_optimization(params_list: Vec<Params>) -> Vec<f64> {
    params_list
        .par_iter()  // 一行并行！自动利用所有 CPU 核心
        .map(|params| backtest_single(params))
        .collect()
}

价值提示：Rayon 只要加 .par_iter()，自动并行。100 组参数优化，10 分钟搞定。

Python + Rust 混用最佳实践

不建议纯 Rust 重写一切。

推荐模式：

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

┌─────────────────────────────────────┐
│           Python 层                 │
│  - 策略研究、回测框架               │
│  - 可视化、报告生成                 │
│  - 快速迭代、原型验证               │
└─────────────────┬───────────────────┘
                  │ PyO3 / pyo3
                  ▼
┌─────────────────────────────────────┐
│           Rust 层                   │
│  - 数据读取、清洗                   │
│  - 因子计算、指标计算               │
│  - 高频回测、信号生成               │
└─────────────────────────────────────┘

两种混用方式

方式一：Rust 编译成 Python 库

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

// lib.rs
use pyo3::prelude::*;

#[pyfunction]
fn calculate_ma(close: Vec<f64>, window: usize) -> Vec<f64> {
    // Rust 计算逻辑
    // ...
}

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

编译后直接 pip install quant_lib，Python 调用。

方式二：用 Polars 的 Python 版本

1
2
3
4
5

# 直接用 Python 版的 Polars
import polars as pl

df = pl.read_csv("data.csv")
result = df.lazy().filter(pl.col("price") > 100).collect()

重点：Polars 有完整的 Python binding，用法和性能几乎一样。

如果你暂时不想写 Rust，可以先从 Polars Python 版开始。

学习资源推荐

入门

• • Rust 官方教程：《The Rust Book》
• • 练习项目：Rustlings
• • Polars 官方文档

进阶

• • 《Rust for Rustaceans》
• • 《Programming Rust》

量化相关

• • Polars 官方示例
• • GitHub 上搜 "rust quant"

写在最后

Rust 不是洪水猛兽。

它只是比 Python 多了一层编译时的安全检查。

一开始会不习惯，但写多了你会爱上它——因为编译器帮你挡住了太多运行时错误。

而且，Polars 已经帮你解决了 80% 的问题。

你不需要从零写底层代码，只需要学会调用库函数。

现在开始学，3 个月后你就能用 Rust 写量化策略了。

这就是你超越同龄人的机会。

你们学到哪一步了？有什么问题评论区问～

下篇预告：《Polars 凭什么叫板 Pandas？量化工程师必看》

觉得有帮助，点个赞👍、在看👀！