主页 / coding / 问题 / 79077774
Accepted
Kazdegotepu
Asked: 2024-10-11 18:13:29 +0800 CST

嵌套的 polars.col() [重复]

  • 772

我想从另一列中获取名称所在的列的值。

我的表中有很多列，因此这样做pl.when().then()不是一个选择。

作为输入，我们有这个数据框：

富 foo_count 酒吧 条形计数 巴兹 baz_count 最大的
1 23 4 43 5 64 巴兹
2 四十五 6 四十五 1 43 酒吧
3 234 9 453 15 231 巴兹
4 55 2 67 3 94 富

并希望将其转换为with_columns()：

富 foo_count 酒吧 条形计数 巴兹 baz_count 最大的 最大计数
1 23 4 43 5 64 巴兹 64
2 四十五 6 四十五 1 43 酒吧 四十五
3 234 9 453 15 231 巴兹 231
4 55 2 67 3 94 富 4

这个（伪）代码说明了我的想法（但当然这不起作用）

df = pl.DataFrame({"foo" : [1, 2, 3, 4],
                   "foo_count" : [23, 45 ,234, 55],
                   "bar" : [4 ,6 ,9, 2],
                   "bar_count" : [43, 45 ,453, 67],
                   "baz": [5,1,15, 3],
                   "baz_count" : [64, 43 ,231, 94],
                   "largest" : ["baz", "bar", "baz", "foo"]})

df.with_columns(
    pl.col(f"{pl.col('largest')}_count").alias("largest_count")
)
python-polars

2 个回答

  1. Best Answer

    这是一个简单的方法。首先，我们使用when-then表达式生成器为屏蔽列创建表达式。然后，我们依靠pl.coalesce来组合屏蔽列。仍然有一个针对largest中唯一元素的简单 Python 循环。

    df.with_columns(
    pl.coalesce(
        pl.when(pl.col("largest") == col).then(f"{col}_count")
        for col in df.get_column("largest").unique()
    ).alias("largest_count")
)

    shape: (4, 8)
┌─────┬───────────┬─────┬───────────┬─────┬───────────┬─────────┬───────────────┐
│ foo ┆ foo_count ┆ bar ┆ bar_count ┆ baz ┆ baz_count ┆ largest ┆ largest_count │
│ --- ┆ ---       ┆ --- ┆ ---       ┆ --- ┆ ---       ┆ ---     ┆ ---           │
│ i64 ┆ i64       ┆ i64 ┆ i64       ┆ i64 ┆ i64       ┆ str     ┆ i64           │
╞═════╪═══════════╪═════╪═══════════╪═════╪═══════════╪═════════╪═══════════════╡
│ 1   ┆ 23        ┆ 4   ┆ 43        ┆ 5   ┆ 64        ┆ baz     ┆ 64            │
│ 2   ┆ 45        ┆ 6   ┆ 45        ┆ 1   ┆ 43        ┆ bar     ┆ 45            │
│ 3   ┆ 234       ┆ 9   ┆ 453       ┆ 15  ┆ 231       ┆ baz     ┆ 231           │
│ 4   ┆ 55        ┆ 2   ┆ 67        ┆ 3   ┆ 94        ┆ foo     ┆ 55            │
└─────┴───────────┴─────┴───────────┴─────┴───────────┴─────────┴───────────────┘
    • 3

  2. 这是一种即使列数非常多也能扩展的方法。我们可以只提取计数列：

    counts = df.select(pl.col("^.*_count$").name.map(lambda c: c.removesuffix("_count")))

    shape: (4, 3)
┌─────┬─────┬─────┐
│ foo ┆ bar ┆ baz │
│ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ i64 │
╞═════╪═════╪═════╡
│ 23  ┆ 43  ┆ 64  │
│ 45  ┆ 45  ┆ 43  │
│ 234 ┆ 453 ┆ 231 │
│ 55  ┆ 67  ┆ 94  │
└─────┴─────┴─────┘

    然后创建一个带有索引的规范化表：

    norm_counts = counts.with_row_index().unpivot(index="index")

    shape: (12, 3)
┌───────┬──────────┬───────┐
│ index ┆ variable ┆ value │
│ ---   ┆ ---      ┆ ---   │
│ u32   ┆ str      ┆ i64   │
╞═══════╪══════════╪═══════╡
│ 0     ┆ foo      ┆ 23    │
│ 1     ┆ foo      ┆ 45    │
│ 2     ┆ foo      ┆ 234   │
│ 3     ┆ foo      ┆ 55    │
│ 0     ┆ bar      ┆ 43    │
│ …     ┆ …        ┆ …     │
│ 3     ┆ bar      ┆ 67    │
│ 0     ┆ baz      ┆ 64    │
│ 1     ┆ baz      ┆ 43    │
│ 2     ┆ baz      ┆ 231   │
│ 3     ┆ baz      ┆ 94    │
└───────┴──────────┴───────┘

    然后我们可以使用临时索引将标准化计数连接到原始数据框：

    out = (
    df
    .with_row_index()
    .join(norm_counts,
          left_on=["index", "largest"],
          right_on=["index", "variable"],
          how="left")
    .rename({"value": "largest_count"})
    .drop("index")
)

    shape: (4, 8)
┌─────┬───────────┬─────┬───────────┬─────┬───────────┬─────────┬───────────────┐
│ foo ┆ foo_count ┆ bar ┆ bar_count ┆ baz ┆ baz_count ┆ largest ┆ largest_count │
│ --- ┆ ---       ┆ --- ┆ ---       ┆ --- ┆ ---       ┆ ---     ┆ ---           │
│ i64 ┆ i64       ┆ i64 ┆ i64       ┆ i64 ┆ i64       ┆ str     ┆ i64           │
╞═════╪═══════════╪═════╪═══════════╪═════╪═══════════╪═════════╪═══════════════╡
│ 1   ┆ 23        ┆ 4   ┆ 43        ┆ 5   ┆ 64        ┆ baz     ┆ 64            │
│ 2   ┆ 45        ┆ 6   ┆ 45        ┆ 1   ┆ 43        ┆ bar     ┆ 45            │
│ 3   ┆ 234       ┆ 9   ┆ 453       ┆ 15  ┆ 231       ┆ baz     ┆ 231           │
│ 4   ┆ 55        ┆ 2   ┆ 67        ┆ 3   ┆ 94        ┆ foo     ┆ 55            │
└─────┴───────────┴─────┴───────────┴─────┴───────────┴─────────┴───────────────┘
    • 1

相关问题