Pandas GroupBy 操作：高效处理列表数据的全面指南|极客教程

Pandas GroupBy 操作：高效处理列表数据的全面指南

Pandas是Python中强大的数据处理库，其中GroupBy操作是一个非常实用的功能，特别是在处理包含列表数据的DataFrame时。本文将全面介绍如何在Pandas中使用GroupBy操作处理列表数据，包括基本概念、常用方法、高级技巧以及实际应用场景。

1. GroupBy基础概念

在Pandas中，GroupBy操作允许我们将数据按照某个或某些列进行分组，然后对每个分组应用特定的操作。当涉及到列表数据时，GroupBy操作变得更加复杂和有趣。

让我们从一个简单的例子开始：

import pandas as pd

# 创建一个包含列表数据的DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David'],
    'scores': [[85, 90, 92], [78, 85, 88], [92, 95, 98], [88, 91, 93]],
    'subjects': ['Math,Science,English', 'Math,Science,English', 'Math,Science,English', 'Math,Science,English']
})

# 使用GroupBy对scores列进行操作
result = df.groupby('name')['scores'].apply(lambda x: [sum(scores) for scores in x])

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

在这个例子中，我们创建了一个DataFrame，其中’scores’列包含列表数据。我们使用GroupBy按’name’列分组，然后对’scores’列应用一个lambda函数，计算每个学生的总分。

2. 处理列表数据的常用GroupBy方法

2.1 聚合函数

Pandas提供了多种聚合函数，可以直接应用于列表数据。以下是一些常用的聚合函数：

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
})

# 计算每个组的列表长度
result_len = df.groupby('group')['values'].apply(lambda x: [len(lst) for lst in x])

# 计算每个组的列表总和
result_sum = df.groupby('group')['values'].apply(lambda x: [sum(lst) for lst in x])

# 计算每个组的列表平均值
result_mean = df.groupby('group')['values'].apply(lambda x: [np.mean(lst) for lst in x])

print("Length:", result_len)
print("Sum:", result_sum)
print("Mean:", result_mean)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何使用GroupBy操作计算列表的长度、总和和平均值。

2.2 自定义聚合函数

有时，内置的聚合函数可能无法满足我们的需求。在这种情况下，我们可以定义自己的聚合函数：

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
})

def custom_agg(x):
    flattened = [item for sublist in x for item in sublist]
    return {
        'min': min(flattened),
        'max': max(flattened),
        'range': max(flattened) - min(flattened)
    }

result = df.groupby('group')['values'].apply(custom_agg)

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

在这个例子中，我们定义了一个自定义聚合函数，它计算每个组中所有列表元素的最小值、最大值和范围。

3. 处理多列列表数据

有时，我们的DataFrame可能包含多个列表列。在这种情况下，我们可以同时对多个列进行GroupBy操作：

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values1': [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]],
    'values2': [[13, 14, 15], [16, 17, 18], [19, 20, 21], [22, 23, 24]]
})

result = df.groupby('group').agg({
    'values1': lambda x: [sum(lst) for lst in x],
    'values2': lambda x: [max(lst) for lst in x]
})

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何对多个列表列同时应用不同的聚合函数。

4. 展开列表数据

有时，我们可能需要将列表数据展开为单独的行。这可以通过结合GroupBy和explode方法来实现：

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
})

# 展开列表数据
df_exploded = df.explode('values')

# 对展开后的数据进行GroupBy操作
result = df_exploded.groupby('group')['values'].agg(['mean', 'sum', 'count'])

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何将列表数据展开，然后对展开后的数据进行GroupBy操作。

5. 处理嵌套列表

有时，我们可能遇到嵌套列表的情况。处理这种数据结构需要特殊的技巧：

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]], [[13, 14], [15, 16]]]
})

def flatten_and_sum(nested_list):
    return sum([sum(sublist) for sublist in nested_list])

result = df.groupby('group')['values'].apply(lambda x: [flatten_and_sum(nested) for nested in x])

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何处理包含嵌套列表的DataFrame，我们定义了一个辅助函数来展平和求和嵌套列表。

6. 使用GroupBy处理字符串列表

有时，列表可能以字符串形式存储在DataFrame中。在这种情况下，我们需要先将字符串转换为列表，然后再进行GroupBy操作：

import pandas as pd
import ast

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': ['[1, 2, 3]', '[4, 5, 6]', '[7, 8, 9]', '[10, 11, 12]']
})

# 将字符串转换为列表
df['values'] = df['values'].apply(ast.literal_eval)

result = df.groupby('group')['values'].apply(lambda x: [sum(lst) for lst in x])

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何处理以字符串形式存储的列表数据。我们使用ast.literal_eval函数将字符串安全地转换为Python对象。

7. 使用GroupBy处理不等长列表

在实际应用中，我们可能遇到列表长度不一致的情况。这时，我们需要特别小心处理：

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[1, 2, 3], [4, 5], [6, 7, 8, 9], [10]]
})

def safe_mean(lst):
    return sum(lst) / len(lst) if lst else None

result = df.groupby('group')['values'].apply(lambda x: [safe_mean(lst) for lst in x])

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何安全地处理不等长列表。我们定义了一个safe_mean函数来处理可能为空的列表。

8. 使用GroupBy进行列表元素频率统计

有时，我们可能需要统计列表中元素的出现频率：

import pandas as pd
from collections import Counter

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[1, 2, 2, 3], [2, 3, 3, 4], [3, 4, 4, 5], [4, 5, 5, 6]]
})

def count_elements(group):
    all_elements = [item for sublist in group['values'] for item in sublist]
    return dict(Counter(all_elements))

result = df.groupby('group').apply(count_elements)

print(result)

这个例子展示了如何使用GroupBy和Counter来统计每个组中列表元素的出现频率。

9. 使用GroupBy处理包含NaN的列表

在实际数据中，我们可能遇到包含NaN值的列表。处理这种情况需要特别注意：

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[1, 2, np.nan], [3, np.nan, 4], [5, 6, np.nan], [np.nan, 7, 8]]
})

def sum_ignore_nan(lst):
    return sum(x for x in lst if not pd.isna(x))

result = df.groupby('group')['values'].apply(lambda x: [sum_ignore_nan(lst) for lst in x])

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何处理包含NaN值的列表。我们定义了一个sum_ignore_nan函数来忽略NaN值并计算总和。

10. 使用GroupBy进行列表元素匹配

有时，我们可能需要在组内进行列表元素的匹配：

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values1': [[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]],
    'values2': [[2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7]]
})

def find_common_elements(group):
    set1 = set([item for sublist in group['values1'] for item in sublist])
    set2 = set([item for sublist in group['values2'] for item in sublist])
    return list(set1.intersection(set2))

result = df.groupby('group').apply(find_common_elements)

print(result)

这个例子展示了如何在每个组内找到两个列表列中的共同元素。

11. 使用GroupBy进行列表排序

我们可能需要对每个组内的列表进行排序：

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[3, 1, 2], [6, 4, 5], [9, 7, 8], [12, 10, 11]]
})

result = df.groupby('group')['values'].apply(lambda x: [sorted(lst) for lst in x])

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何对每个组内的列表进行排序。

12. 使用GroupBy进行列表去重

有时，我们可能需要去除列表中的重复元素：

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[1, 2, 2, 3], [2, 3, 3, 4], [3, 4, 4, 5], [4, 5, 5, 6]]
})

result = df.groupby('group')['values'].apply(lambda x: [list(set(lst)) for lst in x])

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何使用set来去除每个组内列表的重复元素。

13. 使用GroupBy进行列表拼接

在某些情况下，我们可能需要将同一组内的所有列表拼接在一起：

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
})

result = df.groupby('group')['values'].apply(lambda x: [item for sublist in x for item in sublist])

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何将同一组内的所有列表元素拼接成一个大列表。

14. 使用GroupBy进行列表元素过滤

有时，我们可能需要根据某些条件过滤列表中的元素：

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]
})

def filter_even(lst):
    return [x for x in lst if x % 2 == 0]

result = df.groupby('group')['values'].apply(lambda x: [filter_even(lst) for lst in x])

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何在每个组内过滤出偶数元素。

15. 使用GroupBy进行列表元素转换

我们可能需要对列表中的每个元素进行某种转换：

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
})

def square_elements(lst):
    return [x**2 for x in lst]

result = df.groupby('group')['values'].apply(lambda x: [square_elements(lst) for lst in x])

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何对每个组内的列表元素进行平方操作。

16. 使用GroupBy处理包含字典的列表

有时，我们的列表可能包含字典元素。这种情况下的GroupBy操作需要特别处理：

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[{'x': 1, 'y': 2}, {'x': 3, 'y': 4}],
               [{'x': 5, 'y': 6}, {'x': 7, 'y': 8}],
               [{'x': 9, 'y': 10}, {'x': 11, 'y': 12}],
               [{'x': 13, 'y': 14}, {'x': 15, 'y': 16}]]
})

def sum_dict_values(lst):
    return sum(d['x'] + d['y'] for d in lst)

result = df.groupby('group')['values'].apply(lambda x: [sum_dict_values(lst) for lst in x])

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何处理包含字典的列表，我们计算了每个字典中’x’和’y’键的值的总和。

17. 使用GroupBy进行列表元素的条件计数

我们可能需要统计列表中满足某个条件的元素数量：

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]
})

def count_greater_than(lst, threshold):
    return sum(1 for x in lst if x > threshold)

result = df.groupby('group')['values'].apply(lambda x: [count_greater_than(lst, 10) for lst in x])

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何统计每个列表中大于10的元素数量。

18. 使用GroupBy进行列表元素的累积操作

有时，我们可能需要对列表元素进行累积操作：

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
})

def cumulative_product(lst):
    result = [lst[0]]
    for i in range(1, len(lst)):
        result.append(result[-1] * lst[i])
    return result

result = df.groupby('group')['values'].apply(lambda x: [cumulative_product(lst) for lst in x])

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何计算每个列表的累积乘积。

19. 使用GroupBy进行列表元素的窗口操作

我们可能需要对列表元素进行滑动窗口操作：

import pandas as pd

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'values': [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]
})

def moving_average(lst, window_size=3):
    return [sum(lst[i:i+window_size]) / window_size for i in range(len(lst) - window_size + 1)]

result = df.groupby('group')['values'].apply(lambda x: [moving_average(lst) for lst in x])

print(result)

Output:

Pandas GroupBy 操作：高效处理列表数据的全面指南

这个例子展示了如何计算每个列表的移动平均值，使用了3个元素的滑动窗口。

20. 使用GroupBy处理包含日期的列表

最后，让我们看一个处理包含日期的列表的例子：

import pandas as pd
from datetime import datetime, timedelta

df = pd.DataFrame({
    'group': ['A', 'A', 'B', 'B'],
    'dates': [[datetime(2023, 1, 1), datetime(2023, 1, 2), datetime(2023, 1, 3)],
              [datetime(2023, 1, 4), datetime(2023, 1, 5), datetime(2023, 1, 6)],
              [datetime(2023, 1, 7), datetime(2023, 1, 8), datetime(2023, 1, 9)],
              [datetime(2023, 1, 10), datetime(2023, 1, 11), datetime(2023, 1, 12)]]
})

def date_range(dates):
    return (max(dates) - min(dates)).days

result = df.groupby('group')['dates'].apply(lambda x: [date_range(dates) for dates in x])

print(result)