如何在Polars中高效处理大量组合且避免内存过载？

我有一组共19个值的列表，需要生成所有可能的非空组合，将每个组合作为Polars DataFrame的过滤条件，迭代处理组合并执行相关函数，最终将结果存入新的DataFrame。但n=19时会产生2¹⁹-1=524287个非空组合，这会导致内存耗尽，无法完成迭代处理。请问如何高效处理该计算且不占用过多内存？能否通过减少内存占用或迭代处理（不一次性加载所有内容）来实现？有哪些针对Polars工作流的优化建议？

当前实现代码 #

import polars as pl
import itertools

states = ["a", "b", "c", "d"]

df = pl.DataFrame({
    "ID": [1, 2, 3, 4, 5, 6,7,8,9,10],
    "state": ["b", "b", "a", "d","a", "b", "c", "d","c", "d"],
    "Value" : [3,6,9,12,15,18,21,24,27,30],
})

all_combinations = []

for r in range(1,len(states)+1):
    all_combinations.extend(itertools.combinations(states, r))

def foo(df):
    return(
    df
    )

new_rows = []

for i in range(len(all_combinations)):
    df_filtered = df.filter(pl.col("state").is_in(all_combinations[i]))
    df_func = foo(df_filtered)
    x = df_func.shape[0]
    new_rows.append({"loop_index": i, "shape": x})
    
df_final = pl.DataFrame(new_rows)
df_final

编辑说明：感谢反馈！我已意识到当前方案并非最优，近期将发布包含完整上下文的新问题。
编辑补充：新问题内容：优化变量组合以最大化分类效果

优化方案与建议 #

1. 惰性迭代组合，避免预存所有结果 #

itertools.combinations本身是惰性迭代器，不需要把所有组合存入列表占用内存。直接在循环中逐一生成组合、处理、丢弃，仅保留最终结果即可：

import polars as pl
import itertools

states = ["a", "b", "c", "d"]

df = pl.DataFrame({
    "ID": [1, 2, 3, 4, 5, 6,7,8,9,10],
    "state": ["b", "b", "a", "d","a", "b", "c", "d","c", "d"],
    "Value" : [3,6,9,12,15,18,21,24,27,30],
})

def foo(df):
    return df

new_rows = []
loop_index = 0
# 直接迭代生成组合，不存储全部组合
for r in range(1, len(states)+1):
    for combo in itertools.combinations(states, r):
        df_filtered = df.filter(pl.col("state").is_in(combo))
        df_func = foo(df_filtered)
        new_rows.append({"loop_index": loop_index, "shape": df_func.shape[0]})
        loop_index += 1

df_final = pl.DataFrame(new_rows)

2. 预计算统计值，跳过重复过滤 #

如果你的业务逻辑只是统计行数这类简单操作，可以先预计算每个状态的基础统计值，直接通过组合求和得到结果，完全不需要重复过滤DataFrame：

# 预计算每个state的行数
state_counts = df.group_by("state").agg(pl.count().alias("count")).to_dict(as_series=False)
state_count_map = dict(zip(state_counts["state"], state_counts["count"]))

new_rows = []
loop_index = 0
for r in range(1, len(states)+1):
    for combo in itertools.combinations(states, r):
        # 直接求和组合内状态的行数，无需过滤DataFrame
        total = sum(state_count_map[s] for s in combo)
        new_rows.append({"loop_index": loop_index, "shape": total})
        loop_index += 1

df_final = pl.DataFrame(new_rows)

这种方式能把内存占用和计算时间降到最低，适合统计类场景。

3. Polars工作流专项优化 #

• 用延迟执行减少内存占用：将DataFrame转为LazyFrame，先构建完整计算计划再执行，避免生成大量中间DataFrame：

  lazy_df = df.lazy()
  # 在lazy_df上构建过滤、计算逻辑，最后collect()
  

• 转换为分类类型加速过滤：如果state列是字符串类型，转为pl.Categorical能大幅提升is_in操作的速度和内存效率：

  df = df.with_columns(pl.col("state").cast(pl.Categorical))
  

• 批量写入结果：如果最终结果数据量极大，不要用列表缓存所有行，可分批写入磁盘（比如用write_parquet的追加模式），避免内存堆积。

4. 超大规模组合的进阶处理 #

如果52万+组合仍超出处理能力：

• 并行处理：用concurrent.futures将组合分成批次并行处理，注意控制并发数避免内存过载；
• 提前剪枝：如果目标是找到满足特定条件的组合（比如最大化分类指标），可加入剪枝逻辑，跳过不可能符合要求的组合，减少迭代次数。

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