在Pandas中聚合并按指定顺序重排字符串元素

1. 问题背景与数据准备

在数据处理中，我们经常会遇到需要对非结构化或半结构化的字符串数据进行聚合和规范化的情况。例如，一个列可能包含由“&”符号连接的多个成员名称，我们需要按类别（CLASS）分组，收集所有成员，去除重复，并按照一个预设的特定顺序重新排列这些成员。

考虑以下Pandas DataFrame：

import pandas as pd

df = pd.DataFrame({'CLASS': ['A', 'B', 'A'],
                   'MEMBERS': ['foo & bar', 'bar & luz', 'baz']})

print(df)
#   CLASS    MEMBERS
# 0     A  foo & bar
# 1     B  bar & luz
# 2     A        baz

我们的目标是：

1. 按 CLASS 列进行分组。
2. 在每个组内，将 MEMBERS 列的所有字符串元素拆分，收集所有唯一的成员。
3. 将这些唯一的成员按照指定的顺序（例如 ['foo', 'bar', 'baz', 'luz']）进行排序。
4. 将排序后的成员重新用 & 连接起来。

期望的输出是：

# CLASS
# A    foo & bar & baz
# B          bar & luz
# Name: MEMBERS, dtype: object

2. 核心解决方案：利用 sorted 与自定义映射器

实现这一目标的通用方法是结合Pandas的 groupby().agg() 功能，并在聚合函数中使用Python内置的 sorted() 函数，辅以一个自定义的排序键。

Logome

AI驱动的Logo生成工具

133

查看详情

2.1 步骤解析

1. 拆分与去重: 对于每个组内的 MEMBERS 系列，首先需要将其所有字符串连接成一个大字符串，然后通过 split(' & ') 拆分成单个成员列表。接着，使用 set() 将这些成员去重，得到唯一的成员集合。
2. 定义排序顺序: 明确我们希望的成员排序顺序，例如 order = ['foo', 'bar', 'baz', 'luz']。
3. 创建映射器: 为了让 sorted() 函数能够按照我们定义的顺序进行排序，我们需要创建一个映射器（字典），将每个成员映射到其在 order 列表中的索引。这样，sorted() 就可以根据这些索引来决定元素的相对顺序。

   order = ['foo', 'bar', 'baz', 'luz']
   mapper = {k: i for i, k in enumerate(order)}
   # mapper 会是 {'foo': 0, 'bar': 1, 'baz': 2, 'luz': 3}

   登录后复制
4. 应用自定义排序: 在 agg 函数中，将去重后的成员集合传递给 sorted()，并将其 key 参数设置为 mapper.get。mapper.get 会返回成员对应的索引值，如果成员不在 mapper 中（即不在预设顺序中），get 方法默认返回 None，这通常会导致这些元素被放在排序的末尾（或根据Python版本和数据类型有其他默认行为）。
5. 重新连接: 最后，使用 " & ".join() 将排序后的成员重新连接成一个字符串。

2.2 示例代码

order = ['foo', 'bar', 'baz', 'luz']

# 创建一个映射字典，用于自定义排序
mapper = {k: i for i, k in enumerate(order)}

# 使用groupby和agg进行聚合和排序
out = (df.groupby('CLASS')['MEMBERS']
         .agg(lambda s: " & ".join(sorted(set(' & '.join(s).split(' & ')),
                                          key=mapper.get)))
      )

print(out)

输出结果：

CLASS
A    foo & bar & baz
B          bar & luz
Name: MEMBERS, dtype: object

3. 替代方案：结合 itertools.chain 和自定义函数

上述 lambda 表达式虽然简洁，但在处理复杂的字符串拆分和扁平化逻辑时，可能会显得不够清晰。Python的 itertools.chain 模块提供了一种更高效、更Pythonic 的方式来扁平化嵌套的迭代器。我们可以将整个逻辑封装在一个独立的函数中，提高代码的可读性和复用性。

3.1 步骤解析

1. 导入 itertools.chain: 用于高效地扁平化列表的列表。
2. 定义自定义函数: 创建一个名为 cust_join 的函数，它接收一个Pandas Series s 和 order 列表作为参数。
   • 在函数内部，使用 chain.from_iterable(x.split(' & ') for x in s) 来迭代Series中的每个字符串，将其拆分，并高效地将所有拆分后的成员扁平化到一个迭代器中。
   • 同样创建 mapper 字典。
   • 使用 set() 对扁平化后的成员进行去重。
   • 使用 sorted() 和 mapper.get 进行排序。
   • 使用 " & ".join() 重新连接。
3. 在 agg 中调用: 将 cust_join 函数作为 agg 的参数，并通过 order=... 传递额外的参数。

3.2 示例代码

from itertools import chain

def cust_join(s, order):
    """
    聚合Series中的字符串，提取唯一成员，并按指定顺序排序后重新连接。
    s: Pandas Series，包含要处理的字符串。
    order: 列表，指定成员的期望排序顺序。
    """
    # 创建映射字典用于自定义排序
    mapper = {k: i for i, k in enumerate(order)}

    # 使用itertools.chain扁平化所有成员，然后去重
    unique_members = set(chain.from_iterable(x.split(' & ') for x in s))

    # 根据mapper进行排序
    sorted_members = sorted(unique_members, key=mapper.get)

    # 重新连接成字符串
    return ' & '.join(sorted_members)

# 定义排序顺序
desired_order = ['foo', 'bar', 'baz', 'luz']

# 使用groupby和agg，并传入自定义函数和额外参数
out_alt = (df.groupby('CLASS')['MEMBERS']
             .agg(cust_join, order=desired_order)
          )

print(out_alt)

输出结果：

CLASS
A    foo & bar & baz
B          bar & luz
B          bar & luz
Name: MEMBERS, dtype: object

4. 注意事项与总结

• 字符串分隔符: 确保 split(' & ') 中的分隔符与原始数据中的分隔符完全匹配。
• 未知成员处理: mapper.get 方法在处理不在 order 列表中的成员时，默认返回 None。sorted() 函数会将 None 值（或其他非映射值）视为比数字更大的值，通常将其放在排序结果的末尾。如果需要对未知成员有特定的处理（例如，将其排除或按字母顺序排列在已知成员之后），需要调整 key 函数或在 set 之后进行过滤。
• 性能考量: 对于非常大的数据集，字符串操作（join 和 split）可能会成为性能瓶颈。然而，对于大多数常见用例，上述方法是高效且易于理解的。itertools.chain 在处理扁平化操作时通常比嵌套的列表推导式更节省内存。
• 代码可读性: 将复杂的逻辑封装在独立的函数中（如 cust_join）可以显著提高代码的可读性和维护性，尤其是在 agg 函数内部逻辑较多时。

通过本文介绍的两种方法，您可以在Pandas中灵活地对字符串元素进行分组、去重和自定义排序，以满足各种复杂的数据清洗和聚合需求。

以上就是在Pandas中聚合并按指定顺序重排字符串元素的详细内容，更多请关注php中文网其它相关文章！