Rust Polars中操作DataFrame单个Series的惯用方法及代码优化建议

针对你这段存储容量字符串转TB的代码，有以下几个符合Polars惯用写法的改进方向：

1. 替换unwrap，优雅处理错误而非panic #

当前代码里的unwrap()会在数据格式异常时直接panic，导致整个DataFrame处理中断。在Polars中，应该返回Result或利用Option生成Null值，让异常数据转为Null而不是崩溃。

改进后的转换逻辑可以用Result封装错误，在map中返回Err，Polars会自动将其转为Null：

use polars::prelude::*;

fn transform_str_to_tb(s: Series) -> PolarsResult<Series> {
    let out: Vec<Option<f64>> = s.iter()
        .map(|v| {
            let value = v.to_string().replace([',', '"'], "");
            let mut parts = value.split_whitespace();
            let num_str = parts.next()?;
            let num = num_str.parse::<f64>().ok()?;
            let unit = parts.next()?;

            let tb_value = match unit {
                "KB" => num / 1e9,
                "MB" => num / 1e6,
                "GB" => num / 1e3,
                "TB" => num,
                "PB" => num * 1e3,
                _ => return None,
            };
            Some(tb_value)
        })
        .collect();

    Ok(Series::new("value_tb", out))
}

调用时同步调整为返回PolarsResult：

let df = df
    .lazy()
    .with_columns([col("value")
        .map(
            transform_str_to_tb,
            GetOutput::from_type(DataType::Float64),
        )
        .alias("value_tb")])
    .collect()?;

2. 使用Polars原生字符串函数，实现矢量化操作 #

手动逐元素迭代会丢失Polars的矢量化性能优势。可以直接用Polars提供的字符串处理API来批量处理，这也是Polars推荐的惯用写法：

use polars::prelude::*;

let df = df
    .lazy()
    .with_columns([
        // 清理字符串中的逗号和引号
        col("value").str().replace_all(r#"[,"]"#, "", false).alias("cleaned_value"),
        // 按空格拆分数字和单位，最多拆1次
        col("cleaned_value").str().split_exact(" ", 1).alias("split"),
        // 提取数字部分并转为f64
        col("split").arr().get(0).str().parse(DataType::Float64).alias("num"),
        // 提取单位部分
        col("split").arr().get(1).alias("unit"),
    ])
    // 根据单位计算TB值，异常情况返回Null
    .with_columns([
        when(col("unit") == "KB")
            .then(col("num") / 1e9)
            .when(col("unit") == "MB")
            .then(col("num") / 1e6)
            .when(col("unit") == "GB")
            .then(col("num") / 1e3)
            .when(col("unit") == "TB")
            .then(col("num"))
            .when(col("unit") == "PB")
            .then(col("num") * 1e3)
            .alias("value_tb")
    ])
    // 清理临时列
    .drop(["cleaned_value", "split", "num", "unit"])
    .collect()?;

3. 明确指定GetOutput类型 #

之前用GetOutput::default()依赖类型推断，容易出现意外错误。应该直接指定输出的DataType，让代码更清晰：

GetOutput::from_type(DataType::Float64)

4. 支持二进制前缀（可选） #

如果需要支持二进制单位（KiB、MiB等，以1024为基数），可以扩展匹配逻辑，同时把转换因子抽成常量提升可读性：

const CONVERSION_FACTORS: &[(&str, f64)] = &[
    // 十进制单位
    ("KB", 1e9),
    ("MB", 1e6),
    ("GB", 1e3),
    ("TB", 1.0),
    ("PB", 1e-3),
    // 二进制单位
    ("KiB", 1024.0 * 1024.0 * 1024.0),
    ("MiB", 1024.0 * 1024.0),
    ("GiB", 1024.0),
    ("TiB", 1.0),
    ("PiB", 1.0 / 1024.0),
];

// 在转换逻辑中使用：
let factor = CONVERSION_FACTORS.iter().find(|(u, _)| u == &unit)?;
let tb_value = num / factor.1;

5. 封装为可复用的表达式函数 #

如果这个转换逻辑会多次使用，可以把它封装成一个自定义的Expr函数，方便链式调用：

use polars::prelude::*;

fn str_to_tb(col: Expr) -> Expr {
    let cleaned = col.str().replace_all(r#"[,"]"#, "", false);
    let split = cleaned.str().split_exact(" ", 1);
    let num = split.arr().get(0).str().parse(DataType::Float64);
    let unit = split.arr().get(1);

    when(unit == "KB")
        .then(num / 1e9)
        .when(unit == "MB")
        .then(num / 1e6)
        .when(unit == "GB")
        .then(num / 1e3)
        .when(unit == "TB")
        .then(num)
        .when(unit == "PB")
        .then(num * 1e3)
        .alias("value_tb")
}

// 使用时：
let df = df
    .lazy()
    .with_columns([str_to_tb(col("value"))])
    .collect()?;

内容的提问来源于stack exchange，提问作者NotABot83