Pandas分组聚合字符串排序教程

本文详细介绍了在 Pandas 中对字符串数据进行分组聚合与排序的实用技巧，旨在帮助读者高效处理数据清洗和整理需求。针对包含分隔符连接字符串的 DataFrame，文章提出了两种解决方案：一是利用 `sorted()` 函数结合自定义映射字典，实现按预定义顺序对分组后的唯一字符串元素进行排序和重组；二是结合 `itertools.chain` 优化字符串扁平化过程，并封装成自定义函数，提高代码可读性和复用性。两种方法均提供了详细的代码示例和解释，并针对分隔符一致性、未定义元素处理以及性能考量等问题提出了注意事项与最佳实践，助力读者灵活应对 Pandas 中复杂的字符串数据聚合与整理任务。

本教程详细介绍了如何在 Pandas DataFrame 中实现复杂的数据聚合任务：首先，根据指定列进行分组；然后，从另一列的字符串中提取所有唯一的子元素（例如，从“foo & bar”中提取“foo”和“bar”）；最后，将这些唯一的子元素重新组合成一个字符串，但要确保它们按照预定义的特定顺序排列。文章提供了两种有效的 Python 解决方案，并附带了详细的代码示例和解释，旨在帮助读者高效处理类似的数据清洗与整理需求。

在数据分析和处理中，我们经常会遇到需要对字符串类型数据进行聚合的情况。例如，某个列可能包含以特定分隔符连接的多个标签或成员名称。当我们需要根据某个分类列对这些成员进行分组，并汇总所有唯一的成员，同时要求这些成员按照预设的特定顺序进行排列时，标准的聚合方法可能无法直接满足需求。

考虑以下 Pandas DataFrame 作为示例：

import pandas as pd

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

print("原始 DataFrame:")
print(df)

输出：

原始 DataFrame:
  CLASS    MEMBERS
0     A  foo & bar
1     B  bar & luz
2     A        baz

我们的目标是：

1. 按 CLASS 列进行分组。
2. 在每个组内，从 MEMBERS 列中提取所有唯一的成员（例如，对于 CLASS 为 'A' 的组，成员有 'foo', 'bar', 'baz'）。
3. 将这些唯一的成员重新组合成一个字符串，但必须按照预定义的顺序 ['foo', 'bar', 'baz', 'luz'] 进行排列。

期望的输出结果如下：

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

解决方案一：使用 sorted() 结合自定义映射键

此方法的核心思想是利用 Python 内置的 sorted() 函数的 key 参数。通过为每个期望的成员定义一个数值顺序（即索引），我们可以创建一个映射字典。然后，sorted() 函数在排序时会根据这个映射字典中对应的值进行排序。

步骤详解：

1. 定义期望的排序顺序： 创建一个列表，其中包含所有可能的成员及其期望的排列顺序。
2. 创建映射字典： 将 order 列表中的每个成员映射到一个整数索引，这个索引将作为排序的依据。
3. 在 groupby().agg() 中应用自定义排序逻辑：
   • 对于每个分组，首先将 MEMBERS 列中的所有字符串连接成一个长字符串。
   • 然后，将这个长字符串按分隔符 ' & ' 拆分成单个成员。
   • 使用 set() 去除重复的成员，获取唯一的成员集合。
   • 最后，使用 sorted() 函数对这些唯一的成员进行排序，key=mapper.get 会让 sorted() 根据 mapper 字典中对应成员的索引值进行排序。
   • 将排序后的成员重新用 ' & ' 连接起来。

# 定义期望的排序顺序
order = ['foo', 'bar', 'baz', 'luz']

# 创建元素到索引的映射字典
# 例如：{'foo': 0, 'bar': 1, 'baz': 2, 'luz': 3}
mapper = {k: i for i, k in enumerate(order)}
print(f"\n元素排序映射字典: {mapper}")

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

print("\n解决方案一结果:")
print(result_sorted_key)

输出：

元素排序映射字典: {'foo': 0, 'bar': 1, 'baz': 2, 'luz': 3}

解决方案一结果:
CLASS
A    foo & bar & baz
B          bar & luz
Name: MEMBERS, dtype: object

解释： mapper.get 方法在作为 key 参数时，会为 sorted() 函数提供一个用于比较的值。例如，当 sorted() 比较 'foo' 和 'bar' 时，它会查找 mapper.get('foo') (即 0) 和 mapper.get('bar') (即 1)，由于 0 < 1，因此 'foo' 会排在 'bar' 之前，从而实现了自定义排序。

解决方案二：结合 itertools.chain 的函数封装

虽然第一个方案简洁有效，但在处理包含大量字符串或非常长的字符串的 DataFrame 时，' & '.join(s).split(' & ') 可能会创建巨大的中间字符串，这可能导致内存效率问题。itertools.chain.from_iterable 提供了一种更高效的方式来扁平化列表的列表，避免了创建大型中间字符串。此外，将逻辑封装在函数中可以提高代码的可读性和复用性。

步骤详解：

1. 导入 itertools.chain： 用于高效地扁平化可迭代对象。
2. 定义自定义聚合函数： 创建一个函数，该函数接受一个 Pandas Series（即当前分组的 MEMBERS 列）和 order_list 作为参数。
   • 函数内部同样创建 mapper 字典。
   • 使用列表推导式 (x.split(' & ') for x in series) 生成一个包含所有成员子列表的迭代器。
   • chain.from_iterable() 将这些子列表扁平化为一个单一的迭代器，从而高效地获取所有成员。
   • 其余的逻辑（set() 获取唯一值，sorted() 按 mapper.get 排序，' & '.join() 连接）与方案一相同。
3. 在 groupby().agg() 中调用自定义函数： 通过将函数名作为 agg() 的第一个参数，并将 order 列表作为额外的关键字参数传递，agg() 会自动将这些参数传递给自定义函数。

from itertools import chain

def custom_join_and_sort(series, order_list):
    """
    自定义函数，用于聚合字符串元素、提取唯一值并按指定顺序排序。

    参数:
    series (pd.Series): 待处理的字符串序列（当前分组的 MEMBERS 列）。
    order_list (list): 期望的元素排序顺序列表。

    返回:
    str: 聚合并排序后的字符串。
    """
    # 创建元素到索引的映射字典
    mapper = {k: i for i, k in enumerate(order_list)}

    # 提取所有成员并扁平化，然后获取唯一值
    # chain.from_iterable 效率更高，避免了大型中间字符串的创建
    all_members = set(chain.from_iterable(x.split(' & ') for x in series))

    # 按自定义顺序排序唯一成员
    # 注意：对于不在 order_list 中的元素，mapper.get() 将返回 None，
    # 它们通常会被排在列表的开头或末尾，取决于 Python 的默认 None 排序行为。
    sorted_members = sorted(all_members, key=mapper.get)

    # 将排序后的成员用 " & " 连接
    return ' & '.join(sorted_members)

# 定义期望的排序顺序
order = ['foo', 'bar', 'baz', 'luz']

# 使用自定义函数进行聚合
result_custom_func = (df.groupby('CLASS')['MEMBERS']
                      .agg(custom_join_and_sort, order_list=order)
                     )

print("\n解决方案二结果:")
print(result_custom_func)

输出：

解决方案二结果:
CLASS
A    foo & bar & baz
B          bar & luz
Name: MEMBERS, dtype: object

解释： itertools.chain.from_iterable 能够有效地处理多个可迭代对象（这里是每个 x.split(' & ') 返回的列表），将它们串联起来，而无需创建中间的列表来容纳所有元素。这对于内存管理和性能优化非常有益。将逻辑封装在函数中，也使得代码更模块化、易于测试和重用。

注意事项与最佳实践

• 分隔符一致性： 确保数据中的分隔符与 split() 和 join() 中使用的分隔符严格一致。如果存在多种分隔符，可能需要使用正则表达式（如 re.split()）来更灵活地解析字符串。
• 未定义元素的处理： 如果 MEMBERS 列中包含 order 列表中未定义的元素，mapper.get() 将返回 None。Python 默认的 None 排序行为可能不是您期望的（通常 None 会排在所有其他值之前或之后）。为避免这种情况，建议在 order 列表中包含所有可能的成员，或者在 sorted 函数中为 key 参数提供一个更健壮的 lambda 表达式，例如 key=lambda x: mapper.get(x, float('inf')) 将未定义的元素排在最后。
• 性能考量： 对于包含大量唯一元素或非常长的字符串的超大型数据集，字符串操作和集合操作可能会有显著的性能开销。在这些极端情况下，可以考虑使用 Numba 或 Cython 进行性能优化，或者探索更底层的 Pandas/NumPy 向量化操作（如果适用，但对于这种复杂的自定义排序通常需要 UDF）。
• 代码可读性与复用性： 第二种方案将核心逻辑封装在函数中，显著提高了代码的可读性和复用性，特别是在多个地方需要执行相同或类似操作时。

总结

本教程介绍了两种在 Pandas DataFrame 中实现分组聚合并按自定义顺序排序字符串元素的有效方法。第一种方法利用 sorted() 函数的 key 参数和自定义映射字典，简洁明了地解决了问题。第二种方法在此基础上，引入了 itertools.chain.from_iterable 来优化成员提取过程，并通过函数封装提高了代码的模块化和复用性。掌握这些技巧将使您能够更灵活、高效地处理 Pandas 中复杂的字符串数据聚合与整理任务。选择哪种方法取决于具体的数据规模、性能要求以及个人对代码可读性和模块化的偏好。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《Pandas分组聚合字符串排序教程》文章吧，也可关注golang学习网公众号了解相关技术文章。