Pandas DataFrame中字符串组合的唯一聚合与自定义排序教程

在数据处理和分析中，我们经常需要对字符串数据进行聚合操作。一个常见的场景是，某一列包含由分隔符连接的多个字符串元素，我们需要按某个键进行分组，然后将这些元素合并，同时去除重复项，并按照特定的顺序排列。

1. 问题描述与初始数据

假设我们有以下Pandas DataFrame，其中CLASS列表示类别，MEMBERS列包含由" & "连接的成员：

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']的顺序。

期望的输出结果如下：

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

2. 核心挑战：唯一聚合与自定义排序

首先，我们可以通过groupby()和agg()函数实现初步的唯一聚合。关键在于如何将每个MEMBERS字符串拆分，获取所有独立的成员，然后去重，最后再重新连接。

一个初步的解决方案是：

# 步骤1: 拆分所有成员并去重
# ' & '.join(s) 将一个组内的所有MEMBERS字符串连接成一个长字符串
# .split(' & ') 将这个长字符串拆分成单个成员列表
# set(...) 对列表进行去重
# ' & '.join(...) 将去重后的成员重新连接
aggregated_members = df.groupby('CLASS')['MEMBERS'].agg(
    lambda s: " & ".join(set(' & '.join(s).split(' & ')))
)

print(aggregated_members)
# CLASS
# A    foo & baz & bar
# B          luz & bar
# Name: MEMBERS, dtype: object

可以看到，虽然实现了唯一聚合，但成员的顺序是随机的（因为set是无序的）。接下来，我们需要引入自定义排序逻辑。

3. 解决方案一：利用 sorted() 与自定义键

Python的内置函数sorted()允许我们通过key参数指定一个函数，该函数将应用于列表中的每个元素，并返回一个用于排序的值。我们可以创建一个映射字典，将我们期望的排序顺序编码为整数，然后将其作为key传递给sorted()。

自由画布

百度文库和百度网盘联合开发的AI创作工具类智能体

73

查看详情

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

# 创建一个映射字典，将每个成员映射到其在排序列表中的索引
# 例如：{'foo': 0, 'bar': 1, 'baz': 2, 'luz': 3}
mapper = {k: i for i, k in enumerate(order)}

# 应用到DataFrame
result_df = (df.groupby('CLASS')['MEMBERS']
             .agg(lambda s: " & ".join(sorted(set(' & '.join(s).split(' & ')),
                                              key=mapper.get)))
            )

print(result_df)
# CLASS
# A    foo & bar & baz
# B          bar & luz
# Name: MEMBERS, dtype: object

代码解析：

• order = ['foo', 'bar', 'baz', 'luz']：定义了我们希望的最终排序顺序。
• mapper = {k: i for i, k in enumerate(order)}：这是一个字典推导式，创建了一个映射器。例如，'foo'映射到0，'bar'映射到1，以此类推。当sorted()函数需要比较两个成员时，它会调用mapper.get(member)来获取对应的整数值，然后根据这些整数值进行排序。
• set(' & '.join(s).split(' & '))：这部分与之前的逻辑相同，负责将一个组内的所有MEMBERS字符串连接成一个长字符串，然后拆分并去重，得到一个包含所有唯一成员的集合。
• sorted(..., key=mapper.get)：这是核心部分。sorted()函数接收这个唯一成员的集合，并使用mapper.get作为排序键。对于集合中的每个成员，mapper.get()会返回其在order列表中对应的索引。如果某个成员不在mapper中（例如，如果原始数据中出现了order中没有的新成员），mapper.get()默认会返回None，这可能导致排序行为不确定。为了更健壮，可以考虑为mapper.get()提供一个默认值，例如key=lambda x: mapper.get(x, float('inf'))，将未知的成员排到最后。
• " & ".join(...)：最后将排序后的成员列表用" & "重新连接成一个字符串。

4. 解决方案二：使用 itertools.chain 优化

当MEMBERS列中的字符串数量非常多，或者每个字符串包含的成员数量很大时，反复调用' & '.join(s).split(' & ')可能会创建大型的中间字符串和列表，效率不高。itertools.chain可以更有效地处理迭代器，避免创建大的中间数据结构。

我们可以定义一个辅助函数来封装聚合和排序逻辑：

from itertools import chain

def custom_join_and_sort(series, order_list):
    """
    对Series中的字符串进行拆分、去重、按指定顺序排序并重新连接。

    Args:
        series (pd.Series): 包含字符串的Series，字符串通过' & '分隔。
        order_list (list): 期望的排序顺序列表。

    Returns:
        str: 排序并连接后的字符串。
    """
    # 创建映射字典
    mapper = {k: i for i, k in enumerate(order_list)}

    # 使用itertools.chain.from_iterable高效地扁平化所有成员
    # x.split(' & ') 将每个字符串拆分成列表
    # chain.from_iterable 将所有这些列表扁平化为一个迭代器
    all_members = chain.from_iterable(x.split(' & ') for x in series)

    # 去重并排序
    # 注意：如果成员不在mapper中，mapper.get(x)将返回None，
    # 可能会导致排序问题。可以考虑添加默认值，如 mapper.get(x, float('inf'))
    # 将未知成员排到最后。
    sorted_unique_members = sorted(set(all_members), key=lambda x: mapper.get(x, float('inf')))

    # 重新连接
    return ' & '.join(sorted_unique_members)

# 应用到DataFrame
result_df_optimized = (df.groupby('CLASS')['MEMBERS']
                       .agg(custom_join_and_sort, order_list=['foo', 'bar', 'baz', 'luz'])
                      )

print(result_df_optimized)
# CLASS
# A    foo & bar & baz
# B          bar & luz
# Name: MEMBERS, dtype: object

代码解析：

• from itertools import chain：导入itertools.chain模块。
• chain.from_iterable(x.split(' & ') for x in series)：这是优化点。它不再将所有字符串连接成一个巨大的字符串，而是对Series中的每个字符串调用x.split(' & ')生成一个列表，然后chain.from_iterable将这些列表的迭代器“链接”起来，形成一个单一的、扁平化的成员迭代器。这避免了不必要的中间字符串和列表的创建，对于内存和性能有益。
• key=lambda x: mapper.get(x, float('inf'))：这里对mapper.get()增加了默认值float('inf')。这意味着如果order_list中没有包含某个成员，它将被赋予一个非常大的排序值，从而被排到结果字符串的末尾。这增加了代码的健壮性。

5. 注意事项

• 性能考量：对于非常大的数据集和复杂的字符串操作，itertools.chain通常比' & '.join().split()更高效，因为它处理的是迭代器而不是创建完整的中间列表。
• 未知成员的处理：在定义mapper和使用sorted(key=...)时，务必考虑如果原始数据中出现order列表中未定义的成员，它们的排序行为。如上所示，使用mapper.get(x, float('inf'))是一个稳健的策略，可以将未知成员排到已知成员之后。
• 分隔符的一致性：确保MEMBERS列中的分隔符始终一致，本教程中是" & "。如果存在多种分隔符，需要更复杂的解析逻辑。
• 空值处理：如果MEMBERS列可能包含NaN或其他非字符串值，在split(' & ')之前可能需要添加类型检查或空值处理，例如str(x).split(' & ')或x if isinstance(x, str) else ''。

6. 总结

本教程详细介绍了如何在Pandas DataFrame中实现字符串组合的唯一聚合和自定义排序。我们首先展示了如何通过groupby()和agg()结合set进行基本的去重聚合。接着，通过引入sorted()函数和自定义的key（基于映射字典），解决了自定义排序的问题。最后，为了提高效率和健壮性，我们展示了如何使用itertools.chain优化成员的扁平化处理，并讨论了处理未知成员的策略。这些技术在处理复杂的文本数据聚合场景中非常实用。

以上就是Pandas DataFrame中字符串组合的唯一聚合与自定义排序教程的详细内容，更多请关注php中文网其它相关文章！