Polars 中高效实现 DataFrame 逐行除法-Python教程-PHP中文网

polars 中高效实现 dataframe 逐行除法

本教程深入探讨了在 Polars 中如何高效地将 DataFrame 的每一行数据与一个单行 DataFrame 进行逐元素除法运算。文章首先分析了一种常见的、但效率低下的通过重复单行 DataFrame 来匹配主 DataFrame 行数的方法，随后重点介绍并演示了利用 with_columns 和列式操作实现性能优化的最佳实践，该方法显著避免了不必要的数据复制和内存消耗，是 Polars 处理此类运算的推荐方式。

1. Polars 中 DataFrame 逐行除法的挑战

在数据处理中，我们经常需要对 DataFrame 中的每一行数据应用一组特定的除数。例如，将一个多行 DataFrame 的每一行按列与一个单行 DataFrame 中的对应值进行除法运算。尽管在 Pandas 等库中，这可能通过 df.divide() 等方法直接实现，但在 Polars 中，由于其独特的设计哲学和性能优化策略，直接对齐不同高度的 DataFrame 进行逐元素运算需要特定的方法。

一个常见的误区是尝试通过复制单行 DataFrame 来使其与主 DataFrame 的行数匹配，从而进行直接的逐元素运算。

2. 低效的解决方案：通过重复构建大型除数 DataFrame

最初，开发者可能会尝试将单行除数 DataFrame 扩展成与被除数 DataFrame 相同大小，以实现逐元素除法。这种方法通常涉及使用 itertools.repeat 和 pl.concat 来创建重复的单行 DataFrame。

考虑以下示例：

from itertools import repeat
import polars as pl

# 待除的 DataFrame
data = {'a': [i for i in range(1, 5)],
        'b': [i for i in range(1, 5)],
        'c': [i for i in range(1, 5)],
        'd': [i for i in range(1, 5)]}
df = pl.DataFrame(data)

# 除数 DataFrame (单行)
divisors = pl.DataFrame({'d1': 1, 'd2': 10, 'd3': 100, 'd4': 1000})

print("原始 DataFrame (df):")
print(df)
print("\n除数 DataFrame (divisors):")
print(divisors)

# 低效方法：重复除数 DataFrame
divisors_as_big_as_df = pl.concat([item for item in repeat(divisors, len(df))])

print("\n重复后的除数 DataFrame (divisors_as_big_as_df):")
print(divisors_as_big_as_df)

# 执行除法
divided_df = df / divisors_as_big_as_df
print("\n除法结果 (divided_df):")
print(divided_df)

登录后复制

输出示例:

原始 DataFrame (df):
shape: (4, 4)
┌─────┬─────┬─────┬─────┐
│ a   ┆ b   ┆ c   ┆ d   │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ i64 ┆ i64 │
╞═════╪═════╪═════╪═════╡
│ 1   ┆ 1   ┆ 1   ┆ 1   │
│ 2   ┆ 2   ┆ 2   ┆ 2   │
│ 3   ┆ 3   ┆ 3   ┆ 3   │
│ 4   ┆ 4   ┆ 4   ┆ 4   │
└─────┴─────┴─────┴─────┘

除数 DataFrame (divisors):
shape: (1, 4)
┌─────┬─────┬─────┬──────┐
│ d1  ┆ d2  ┆ d3  ┆ d4   │
│ --- ┆ --- ┆ --- ┆ ---  │
│ i64 ┆ i64 ┆ i64 ┆ i64  │
╞═════╪═════╪═════╪══════╡
│ 1   ┆ 10  ┆ 100 ┆ 1000 │
└─────┴─────┴──────┴──────┘

重复后的除数 DataFrame (divisors_as_big_as_df):
shape: (4, 4)
┌─────┬─────┬─────┬──────┐
│ d1  ┆ d2  ┆ d3  ┆ d4   │
│ --- ┆ --- ┆ --- ┆ ---  │
│ i64 ┆ i64 ┆ i64 ┆ i64  │
╞═════╪═════╪═════╪══════╡
│ 1   ┆ 10  ┆ 100 ┆ 1000 │
│ 1   ┆ 10  ┆ 100 ┆ 1000 │
│ 1   ┆ 10  ┆ 100 ┆ 1000 │
│ 1   ┆ 10  ┆ 100 ┆ 1000 │
└─────┴─────┴──────┴──────┘

除法结果 (divided_df):
shape: (4, 4)
┌─────┬─────┬──────┬───────┐
│ a   ┆ b   ┆ c    ┆ d     │
│ --- ┆ --- ┆ ---  ┆ ---   │
│ f64 ┆ f64 ┆ f64  ┆ f64   │
╞═════╪═════╪══════╪═══════╡
│ 1.0 ┆ 0.1 ┆ 0.01 ┆ 0.001 │
│ 2.0 ┆ 0.2 ┆ 0.02 ┆ 0.002 │
│ 3.0 ┆ 0.3 ┆ 0.03 ┆ 0.003 │
│ 4.0 ┆ 0.4 ┆ 0.04 ┆ 0.004 │
└─────┴─────┴──────┴───────┘

登录后复制

尽管上述方法能够得到正确的结果，但其效率低下。当主 DataFrame 包含大量行时，重复单行 DataFrame 会导致创建非常大的中间 DataFrame，这不仅消耗大量内存，还会增加不必要的计算时间。

3. 推荐方案：利用 Polars 的列式操作优化除法

Polars 的设计理念是围绕高性能的列式操作。对于将 DataFrame 的每一列除以一个标量或单行 DataFrame 中对应的单个值，最佳实践是利用 with_columns 方法结合列选择器 pl.col()。这种方法避免了创建大型中间 DataFrame，而是直接对每列进行操作，效率显著提高。

话袋AI笔记

话袋AI笔记, 像聊天一样随时随地记录每一个想法，打造属于你的个人知识库，成为你的外挂大脑

195

查看详情

核心思想是遍历主 DataFrame 的所有列，然后将每一列除以 divisors DataFrame 中对应列的第一个（也是唯一一个）元素。

import polars as pl

# 待除的 DataFrame
data = {'a': [i for i in range(1, 5)],
        'b': [i for i in range(1, 5)],
        'c': [i for i in range(1, 5)],
        'd': [i for i in range(1, 5)]}
df = pl.DataFrame(data)

# 除数 DataFrame (单行)
divisors = pl.DataFrame({'d1': 1, 'd2': 10, 'd3': 100, 'd4': 1000})

print("原始 DataFrame (df):")
print(df)
print("\n除数 DataFrame (divisors):")
print(divisors)

# 推荐方法：利用 with_columns 进行列式除法
# 构建一个字典，键为原始列名，值为对应的除法表达式
# pl.col(col) 表示原始 DataFrame 中的当前列
# divisors[f"d{i+1}"] 表示除数 DataFrame 中对应的列（此处直接取其Series）
divided_df_optimized = df.with_columns(
    **{col: pl.col(col) / divisors[f"d{i+1}"] for (i, col) in enumerate(df.columns)}
)

print("\n优化后的除法结果 (divided_df_optimized):")
print(divided_df_optimized)

登录后复制

输出示例:

原始 DataFrame (df):
shape: (4, 4)
┌─────┬─────┬─────┬─────┐
│ a   ┆ b   ┆ c   ┆ d   │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ i64 ┆ i64 ┆ i64 │
╞═════╪═════╪═════╪═════╡
│ 1   ┆ 1   ┆ 1   ┆ 1   │
│ 2   ┆ 2   ┆ 2   ┆ 2   │
│ 3   ┆ 3   ┆ 3   ┆ 3   │
│ 4   ┆ 4   ┆ 4   ┆ 4   │
└─────┴─────┴─────┴─────┘

除数 DataFrame (divisors):
shape: (1, 4)
┌─────┬─────┬─────┬──────┐
│ d1  ┆ d2  ┆ d3  ┆ d4   │
│ --- ┆ --- ┆ --- ┆ ---  │
│ i64 ┆ i64 ┆ i64 ┆ i64  │
╞═════╪═════╪═════╪══════╡
│ 1   ┆ 10  ┆ 100 ┆ 1000 │
└─────┴─────┴──────┴──────┘

优化后的除法结果 (divided_df_optimized):
shape: (4, 4)
┌─────┬─────┬──────┬───────┐
│ a   ┆ b   ┆ c    ┆ d     │
│ --- ┆ --- ┆ ---  ┆ ---   │
│ f64 ┆ f64 ┆ f64  ┆ f64   │
╞═════╪═════╪══════╪═══════╡
│ 1.0 ┆ 0.1 ┆ 0.01 ┆ 0.001 │
│ 2.0 ┆ 0.2 ┆ 0.02 ┆ 0.002 │
│ 3.0 ┆ 0.3 ┆ 0.03 ┆ 0.003 │
│ 4.0 ┆ 0.4 ┆ 0.04 ┆ 0.004 │
└─────┴─────┴──────┴───────┘

登录后复制

解释：

df.with_columns(...): 这是 Polars 中用于添加或更新 DataFrame 列的强大方法。它接受一系列表达式，每个表达式都定义了如何计算新列或更新现有列。
**{col: ... for (i, col) in enumerate(df.columns)}: 这是一个字典推导式，用于动态地为 with_columns 构建参数。
- enumerate(df.columns): 遍历 df 的所有列名，并同时提供索引 i 和列名 col。
- col: pl.col(col) / divisors[f"d{i+1}"]: 对于 df 中的每一列 col，创建一个新的表达式。
  - pl.col(col): 引用 df 中名为 col 的列。
  - divisors[f"d{i+1}"]: 从 divisors DataFrame 中选择对应的除数列。由于 divisors 是一个单行 DataFrame，divisors[f"d{i+1}"] 返回的是一个包含单个值的 Series。Polars 在执行列与单值 Series 的运算时，会自动进行广播，将这个单值应用于 pl.col(col) 中的所有元素。

4. 性能考量与最佳实践

推荐的列式操作方法在性能上远优于通过 pl.concat 构造大型中间 DataFrame 的方法，主要原因有：

避免数据复制： 不需要创建与原始 DataFrame 同样大小的重复数据，显著减少内存消耗。
利用 Polars 的优化： Polars 内部对列式操作进行了高度优化，能够高效地处理广播和向量化运算。
惰性求值（Lazy Evaluation）： 在 Polars 的惰性上下文中，这些操作会被构建成一个查询计划，然后由底层的 Rust 引擎高效执行，进一步提升性能。

注意事项：

确保 df 的列数和 divisors 的列数相匹配，并且能够通过某种逻辑（例如示例中的 d1, d2 命名约定）进行对应。如果列名不规则，可能需要更复杂的映射逻辑。
除数 DataFrame 必须是单行。如果除数 DataFrame 有多行，Polars 不会自动进行逐行广播，需要根据具体业务逻辑采用不同的方法（例如 join 或 group_by）。

5. 总结

在 Polars 中，当需要将一个 DataFrame 的每一行按列除以一个单行 DataFrame 的对应值时，最推荐且最高效的方法是利用 df.with_columns() 结合列式操作。通过构建一个字典推导式，将主 DataFrame 的每一列与除数 DataFrame 中对应的单个值进行除法运算，可以充分利用 Polars 的性能优势，避免不必要的内存开销和计算负担。这种模式是 Polars 处理类似数据转换任务的通用且高效的范例。

以上就是Polars 中高效实现 DataFrame 逐行除法的详细内容，更多请关注php中文网其它相关文章！