我有一个数据框,其中所有列中都包含“重复”数据,但名为源的列除外。我将每个来源的这些记录一对一地分组。 此类数据框的示例数据:
id,str,partition_number,source,type,state,quantity,price,m_group,m_status
1,s1_1,111,1,A,1,10,100.0,,0
2,s1_2,111,1,A,1,10,100.0,,0
3,s1_3,222,1,B,2,20,150.0,,0
4,s1_4,333,1,C,1,30,200.0,,0
5,s1_5,111,1,A,1,10,100.0,,0
6,s1_6,111,1,A,1,10,100.0,,0
7,s2_1,111,5,A,1,10,100.0,,0
8,s2_2,111,5,A,1,10,100.0,,0
9,s2_3,111,5,A,1,10,100.0,,0
10,s2_4,222,5,B,2,20,150.0,,0
11,s2_5,444,5,D,1,40,250.0,,0
12,s3_1,111,6,A,1,10,100.0,,0
13,s3_2,111,6,A,1,10,100.0,,0
14,s3_3,111,6,A,1,10,100.0,,0
15,s3_4,222,6,B,2,20,150.0,,0
16,s3_5,444,6,D,1,40,250.0,,0
17,s3_6,333,6,C,1,30,200.0,,0
加载到数据框中:
┌─────┬──────────┬──────────┬──────────┬────────┬──────┬──────────┬──────────┬──────────┬──────────┐
│ id ┆ str_id ┆ part_ ┆ source ┆ type ┆ stat ┆ quantity ┆ price ┆ m_group ┆ m_status │
│ --- ┆ ┆ number ┆ ┆ --- ┆ --- ┆ --- ┆ --- ┆ ┆ │
│ i64 ┆ --- ┆ --- ┆ --- ┆ str ┆ i64 ┆ i64 ┆ f64 ┆ --- ┆ --- │
│ ┆ str ┆ str ┆ i64 ┆ ┆ ┆ ┆ ┆ ┆ │
╞═════╪══════════╪══════════╪══════════╪══════╪══════╪══════════╪═════════╪═════════╪══════════╡
│ 1 ┆ s1_1 ┆ 111 ┆ 1 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 2 ┆ s1_2 ┆ 111 ┆ 1 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 3 ┆ s1_3 ┆ 222 ┆ 1 ┆ B ┆ 2 ┆ 20. ┆ 150.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 4 ┆ s1_4 ┆ 333 ┆ 1 ┆ C ┆ 1 ┆ 30. ┆ 200.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 5 ┆ s1_5 ┆ 111 ┆ 1 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 6 ┆ s1_6 ┆ 111 ┆ 1 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 7 ┆ s2_1 ┆ 111 ┆ 5 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 8 ┆ s2_2 ┆ 111 ┆ 5 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 9 ┆ s2_3 ┆ 111 ┆ 5 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 10 ┆ s2_4 ┆ 222 ┆ 5 ┆ B ┆ 2 ┆ 20. ┆ 150.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 11 ┆ s2_5 ┆ 444 ┆ 5 ┆ D ┆ 1 ┆ 40. ┆ 250.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 12 ┆ s3_1 ┆ 111 ┆ 6 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 13 ┆ s3_2 ┆ 111 ┆ 6 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 14 ┆ s3_3 ┆ 111 ┆ 6 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 15 ┆ s3_4 ┆ 222 ┆ 6 ┆ B ┆ 2 ┆ 20. ┆ 150.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 16 ┆ s3_5 ┆ 444 ┆ 6 ┆ D ┆ 1 ┆ 40. ┆ 250.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 17 ┆ s3_6 ┆ 333 ┆ 6 ┆ C ┆ 1 ┆ 30. ┆ 200.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
└─────┴──────────┴──────────┴──────────┴────────┴──────┴──────────┴──────────┴──────────┴──────────┘
匹配这些后,我有一个输出数据框,其中包含三列 [list] 类型,将 ids、str_ids 和源聚合到“重复”记录组中:
┌─────────────┬──────────────────────────┬────────────────┐
│ id ┆ str_id ┆ source │
│ --- ┆ --- ┆ --- │
│ list[i64] ┆ list[str] ┆ list[i64] │
╞═════════════╪══════════════════════════╪════════════════╡
│ [5, 9, 14] ┆ ["s1_5", "s2_3", "s3_3"] ┆ [1, 5, 6] │
│ [2, 8, 13] ┆ ["s1_2", "s2_2", "s3_2"] ┆ [1, 5, 6] │
│ [6] ┆ ["s1_6"] ┆ [1] │
│ [3, 10, 15] ┆ ["s1_3", "s2_4", "s3_4"] ┆ [1, 5, 6] │
│ [1, 7, 12] ┆ ["s1_1", "s2_1", "s3_1"] ┆ [1, 5, 6] │
│ [11, 16] ┆ ["s2_5", "s3_5"] ┆ [5, 6] │
│ [4, 17] ┆ ["s1_4", "s3_6"] ┆ [1, 6] │
└─────────────┴──────────────────────────┴────────────────┘
最佳的方法是什么:
更新原始数据框中 m_status 列的值,例如,对于组大小至少为 2 的每个记录,如果 source == 1,则将 m_status 的值设置为相反源的值,否则设置 m_status 的值如果组中存在源 1,则值为 1。
所以结果是:
┌─────┬──────────┬──────────┬──────────┬────────┬──────┬──────────┬──────────┬──────────┬──────────┐
│ id ┆ str_id ┆ part_ ┆ source ┆ type ┆ stat ┆ quantity ┆ price ┆ m_group ┆ m_status │
│ --- ┆ ┆ number ┆ ┆ --- ┆ --- ┆ --- ┆ --- ┆ ┆ │
│ i64 ┆ --- ┆ --- ┆ --- ┆ str ┆ i64 ┆ i64 ┆ f64 ┆ --- ┆ --- │
│ ┆ str ┆ str ┆ i64 ┆ ┆ ┆ ┆ ┆ ┆ │
╞═════╪══════════╪══════════╪══════════╪══════╪══════╪══════════╪═════════╪═════════╪══════════╡
│ 1 ┆ s1_1 ┆ 111 ┆ 1 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [5,6] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 2 ┆ s1_2 ┆ 111 ┆ 1 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [5,6] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 3 ┆ s1_3 ┆ 222 ┆ 1 ┆ B ┆ 2 ┆ 20. ┆ 150.0000 ┆ [] ┆ [5,6] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 4 ┆ s1_4 ┆ 333 ┆ 1 ┆ C ┆ 1 ┆ 30. ┆ 200.0000 ┆ [] ┆ [6] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 5 ┆ s1_5 ┆ 111 ┆ 1 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [5,6] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 6 ┆ s1_6 ┆ 111 ┆ 1 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 7 ┆ s2_1 ┆ 111 ┆ 5 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [1] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 8 ┆ s2_2 ┆ 111 ┆ 5 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [1] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 9 ┆ s2_3 ┆ 111 ┆ 5 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [1] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 10 ┆ s2_4 ┆ 222 ┆ 5 ┆ B ┆ 2 ┆ 20. ┆ 150.0000 ┆ [] ┆ [1] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 11 ┆ s2_5 ┆ 444 ┆ 5 ┆ D ┆ 1 ┆ 40. ┆ 250.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 12 ┆ s3_1 ┆ 111 ┆ 6 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [1] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 13 ┆ s3_2 ┆ 111 ┆ 6 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [1] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 14 ┆ s3_3 ┆ 111 ┆ 6 ┆ A ┆ 1 ┆ 10. ┆ 100.0000 ┆ [] ┆ [1] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 15 ┆ s3_4 ┆ 222 ┆ 6 ┆ B ┆ 2 ┆ 20. ┆ 150.0000 ┆ [] ┆ [1] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 16 ┆ s3_5 ┆ 444 ┆ 6 ┆ D ┆ 1 ┆ 40. ┆ 250.0000 ┆ [] ┆ [] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
│ 17 ┆ s3_6 ┆ 333 ┆ 6 ┆ C ┆ 1 ┆ 30. ┆ 200.0000 ┆ [] ┆ [1] │
│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 000 ┆ ┆ │
└─────┴──────────┴──────────┴──────────┴────────┴──────┴──────────┴──────────┴──────────┴──────────┘
以与上述相同的方式创建一个全新的数据帧(可以采用不同的顺序),其中包含 ids、str_ids 和 m_status。这样我就不必查找原始数据帧(但如果我有 ID,它应该不会很昂贵)并且可以迭代创建一个新数据帧。
到目前为止我的解决方案:
df_out = df_out.select("id", "str_id", "source")
m_status_mapping = {}
for ids, str_ids, sources in df_out.iter_rows():
for i, id_ in enumerate(ids):
opposite_sources = [str(rep) for j, s in enumerate(sources) if j != i]
m_status_mapping[id_] = ','.join(opposite_sources)
df = df_original.with_columns(
pl.col("id").replace(m_status_mapping).alias("m_status")
)
df = df.with_columns(pl.col("m_status").str.split(","))
df.select("id", "str_id", "m_status")
这会产生以下输出:
id str_id m_status
i64 str list[str]
1 "s1_1" ["5", "6"]
2 "s1_2" ["5", "6"]
3 "s1_3" ["5", "6"]
4 "s1_4" ["6"]
5 "s1_5" ["5", "6"]
6 "s1_6" [""]
7 "s2_1" ["1", "6"]
8 "s2_2" ["1", "6"]
9 "s2_3" ["1", "6"]
10 "s2_4" ["1", "6"]
11 "s2_5" ["6"]
12 "s3_1" ["1", "5"]
13 "s3_2" ["1", "5"]
14 "s3_3" ["1", "5"]
15 "s3_4" ["1", "5"]
16 "s3_5" ["5"]
17 "s3_6" ["1"]
它几乎可以工作,我在 m_status 中为 source != 1 的行获取了太多源。而且,从效率角度来看,这可能很糟糕,必须有更好的方法来做到这一点。
(
df.with_columns(
l = pl.col.source.len(),
has1 = pl.col.source.list.contains(1),
excl1 = pl.col.source.list.set_difference([1])
).explode(pl.col("id","str_id","source"))
.select(
pl.col("id","str_id","source"),
m_status =
pl.when(pl.col.l >= 2,pl.col.source == 1).then(pl.col.excl1)
.when(pl.col.l >= 2,pl.col.has1).then([1])
.otherwise([])
)
.sort("id")
)
┌─────┬────────┬────────┬───────────┐
│ id ┆ str_id ┆ source ┆ m_status │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ i64 ┆ list[i64] │
╞═════╪════════╪════════╪═══════════╡
│ 1 ┆ s1_1 ┆ 1 ┆ [6, 5] │
│ 2 ┆ s1_2 ┆ 1 ┆ [6, 5] │
│ 3 ┆ s1_3 ┆ 1 ┆ [6, 5] │
│ 4 ┆ s1_4 ┆ 1 ┆ [6] │
│ 5 ┆ s1_5 ┆ 1 ┆ [6, 5] │
│ 6 ┆ s1_6 ┆ 1 ┆ [] │
│ 7 ┆ s2_1 ┆ 5 ┆ [1] │
│ 8 ┆ s2_2 ┆ 5 ┆ [1] │
│ 9 ┆ s2_3 ┆ 5 ┆ [1] │
│ 10 ┆ s2_4 ┆ 5 ┆ [1] │
│ 11 ┆ s2_5 ┆ 5 ┆ [] │
│ 12 ┆ s3_1 ┆ 6 ┆ [1] │
│ 13 ┆ s3_2 ┆ 6 ┆ [1] │
│ 14 ┆ s3_3 ┆ 6 ┆ [1] │
│ 15 ┆ s3_4 ┆ 6 ┆ [1] │
│ 16 ┆ s3_5 ┆ 6 ┆ [] │
│ 17 ┆ s3_6 ┆ 6 ┆ [1] │
└─────┴────────┴────────┴───────────┘