Python 在round函数中使用列值

您可能会这样做:

df.with_columns(
    (
        pl.col('reverse_rate_from_euro') * 
        pl.lit(10).pow(pl.col('sig_figs_len'))
    ).round() * 
    pl.lit(0.1).pow(pl.col('sig_figs_len'))
)

┌───────────────┬──────────────┬────────────────────────┐
│ exchange_rate ┆ sig_figs_len ┆ reverse_rate_from_euro │
│ ---           ┆ ---          ┆ ---                    │
│ f64           ┆ i64          ┆ f64                    │
╞═══════════════╪══════════════╪════════════════════════╡
│ 6.4881        ┆ 3            ┆ 0.154                  │
│ 6.5196        ┆ 4            ┆ 0.1534                 │
└───────────────┴──────────────┴────────────────────────┘

或者，如果你知道不同的sig_figs_len值的数量并不多，你可以枚举超过unique()个值，然后用coalesce()和when()创建结果:

df.with_columns(
    pl.coalesce(
        pl.when(pl.col("sig_figs_len") == x)
        .then(pl.col("reverse_rate_from_euro").round(x))
        for x in df['sig_figs_len'].unique()
    ).alias('reverse_rate_to_euro_rounded_sig_figs')
)

┌───────────────┬──────────────┬────────────────────────┬───────────────────────────────────┐
│ exchange_rate ┆ sig_figs_len ┆ reverse_rate_from_euro ┆ reverse_rate_to_euro_rounded_sig… │
│ ---           ┆ ---          ┆ ---                    ┆ ---                               │
│ f64           ┆ i64          ┆ f64                    ┆ f64                               │
╞═══════════════╪══════════════╪════════════════════════╪═══════════════════════════════════╡
│ 6.4881        ┆ 3            ┆ 0.154128               ┆ 0.154                             │
│ 6.5196        ┆ 4            ┆ 0.153384               ┆ 0.1534                            │
└───────────────┴──────────────┴────────────────────────┴───────────────────────────────────┘

本质上，我们在这里所做的是创建一个Iterable[IntoExpr]，你可以看到它是一个列的列表，其中每一列只包含四舍五入到某个sig_figs_len值的值:

df.with_columns(
    pl.when(pl.col("sig_figs_len") == x)
    .then(pl.col("reverse_rate_from_euro").round(x)).name.suffix(f"_{x}")
     for x in df['sig_figs_len'].unique()
))

┌───────────────┬──────────────┬─────────────────────┬─────────────────────┬─────────────────────┬─────────────────────┐
│ exchange_rate ┆ sig_figs_len ┆ reverse_rate_from_e ┆ reverse_rate_from_e ┆ reverse_rate_from_e ┆ reverse_rate_from_e │
│ ---           ┆ ---          ┆ uro                 ┆ uro_3               ┆ uro_4               ┆ uro_5               │
│ f64           ┆ i64          ┆ ---                 ┆ ---                 ┆ ---                 ┆ ---                 │
│               ┆              ┆ f64                 ┆ f64                 ┆ f64                 ┆ f64                 │
╞═══════════════╪══════════════╪═════════════════════╪═════════════════════╪═════════════════════╪═════════════════════╡
│ 6.4881        ┆ 5            ┆ 0.154128            ┆ null                ┆ null                ┆ 0.15413             │
│ 6.5196        ┆ 5            ┆ 0.153384            ┆ null                ┆ null                ┆ 0.15338             │
│ 6.4527        ┆ 5            ┆ 0.154974            ┆ null                ┆ null                ┆ 0.15497             │
│ 6.41          ┆ 3            ┆ 0.156006            ┆ 0.156               ┆ null                ┆ null                │
│ 6.425         ┆ 4            ┆ 0.155642            ┆ null                ┆ 0.1556              ┆ null                │
└───────────────┴──────────────┴─────────────────────┴─────────────────────┴─────────────────────┴─────────────────────┘

然后我们使用pl.coalesce()接受Expr的可迭代性来获得第一个非空列