极客教程Pandas中使用groupby对两列进行分组操作的详细指南
Pandas是Python中用于数据分析和处理的强大库，其中groupby功能是一个非常实用的工具，可以帮助我们对数据进行分组和聚合操作。本文将详细介绍如何在Pandas中使用groupby对两列进行分组操作，包括基本概念、常用方法、高级技巧以及实际应用场景。
1. groupby的基本概念
在Pandas中，groupby操作允许我们根据一个或多个列的值将数据分成不同的组，然后对每个组应用聚合函数或其他操作。当我们使用两列进行分组时，实际上是创建了一个层次化的索引，每个组由这两列的唯一组合定义。
让我们从一个简单的例子开始：
import pandas as pd
# 创建示例数据
data = {
'website': ['pandasdataframe.com', 'pandasdataframe.com', 'pandasdataframe.com', 'pandasdataframe.com'],
'category': ['A', 'B', 'A', 'B'],
'product': ['X', 'Y', 'Z', 'X'],
'sales': [100, 150, 200, 120]
}
df = pd.DataFrame(data)
# 对'category'和'product'列进行分组
grouped = df.groupby(['category', 'product'])
# 打印分组结果
print(grouped.groups)
Output:
在这个例子中，我们创建了一个包含网站、类别、产品和销售额的数据框。然后，我们使用groupby函数对’category’和’product’列进行分组。grouped.groups会显示每个唯一组合及其对应的行索引。
2. 对分组后的数据进行聚合操作
分组后，我们通常会对每个组应用一些聚合函数，如求和、平均值、计数等。Pandas提供了多种方法来实现这些操作。
2.1 使用agg()函数
agg()函数允许我们对分组后的数据应用一个或多个聚合函数。
import pandas as pd
data = {
'website': ['pandasdataframe.com'] * 6,
'category': ['A', 'A', 'B', 'B', 'C', 'C'],
'product': ['X', 'Y', 'X', 'Y', 'X', 'Y'],
'sales': [100, 150, 200, 120, 80, 250]
}
df = pd.DataFrame(data)
# 对'category'和'product'列进行分组，然后计算sales的总和和平均值
result = df.groupby(['category', 'product'])['sales'].agg(['sum', 'mean'])
print(result)
Output:
在这个例子中，我们对’category’和’product’列进行分组，然后计算每个组’sales’列的总和和平均值。agg()函数接受一个列表，其中包含我们想要应用的聚合函数。
2.2 使用自定义聚合函数
除了内置的聚合函数，我们还可以使用自定义函数进行聚合操作。
import pandas as pd
import numpy as np
data = {
'website': ['pandasdataframe.com'] * 8,
'category': ['A', 'A', 'B', 'B', 'A', 'A', 'B', 'B'],
'product': ['X', 'Y', 'X', 'Y', 'X', 'Y', 'X', 'Y'],
'sales': [100, 150, 200, 120, 80, 250, 300, 180]
}
df = pd.DataFrame(data)
# 自定义聚合函数：计算销售额的中位数和标准差
def custom_agg(x):
return pd.Series({
'median_sales': x.median(),
'sales_std': x.std()
})
result = df.groupby(['category', 'product'])['sales'].apply(custom_agg)
print(result)
Output:
在这个例子中，我们定义了一个自定义函数custom_agg，它计算销售额的中位数和标准差。然后，我们使用apply()方法将这个函数应用到分组后的数据上。
3. 处理分组后的数据
分组后，我们可以对每个组进行更复杂的操作，比如筛选、转换等。
3.1 使用filter()函数筛选组
filter()函数允许我们根据某些条件筛选整个组。
import pandas as pd
data = {
'website': ['pandasdataframe.com'] * 8,
'category': ['A', 'A', 'B', 'B', 'C', 'C', 'D', 'D'],
'product': ['X', 'Y', 'X', 'Y', 'X', 'Y', 'X', 'Y'],
'sales': [100, 150, 200, 120, 80, 250, 300, 180]
}
df = pd.DataFrame(data)
# 筛选出平均销售额大于150的组
filtered = df.groupby(['category', 'product']).filter(lambda x: x['sales'].mean() > 150)
print(filtered)
Output:
在这个例子中，我们使用filter()函数筛选出平均销售额大于150的组。lambda函数定义了筛选条件，只有满足条件的组会被保留。
3.2 使用transform()函数进行组内转换
transform()函数允许我们对每个组应用一个函数，并将结果广播回原始数据框的形状。
import pandas as pd
data = {
'website': ['pandasdataframe.com'] * 8,
'category': ['A', 'A', 'B', 'B', 'A', 'A', 'B', 'B'],
'product': ['X', 'Y', 'X', 'Y', 'X', 'Y', 'X', 'Y'],
'sales': [100, 150, 200, 120, 80, 250, 300, 180]
}
df = pd.DataFrame(data)
# 计算每个组的销售额占该组总销售额的百分比
df['sales_percentage'] = df.groupby(['category', 'product'])['sales'].transform(lambda x: x / x.sum() * 100)
print(df)
Output:
在这个例子中，我们使用transform()函数计算每个销售额占其所在组总销售额的百分比。结果会被添加为一个新列’sales_percentage’。
4. 处理多级索引
当我们对两列进行分组时，结果通常会产生一个多级索引。处理多级索引需要一些特殊的技巧。
4.1 使用unstack()函数重塑数据
unstack()函数可以将多级索引的数据框转换为更易读的形式。
import pandas as pd
data = {
'website': ['pandasdataframe.com'] * 8,
'category': ['A', 'A', 'B', 'B', 'A', 'A', 'B', 'B'],
'product': ['X', 'Y', 'X', 'Y', 'X', 'Y', 'X', 'Y'],
'sales': [100, 150, 200, 120, 80, 250, 300, 180]
}
df = pd.DataFrame(data)
# 对'category'和'product'列进行分组，计算sales的平均值
result = df.groupby(['category', 'product'])['sales'].mean().unstack()
print(result)
Output:
在这个例子中，我们首先对’category’和’product’列进行分组并计算sales的平均值，然后使用unstack()函数将结果转换为一个更易读的表格形式，其中’category’作为行索引，’product’作为列索引。
4.2 使用reset_index()函数重置索引
有时候，我们可能想要将多级索引转换回普通的列。这时可以使用reset_index()函数。
import pandas as pd
data = {
'website': ['pandasdataframe.com'] * 8,
'category': ['A', 'A', 'B', 'B', 'A', 'A', 'B', 'B'],
'product': ['X', 'Y', 'X', 'Y', 'X', 'Y', 'X', 'Y'],
'sales': [100, 150, 200, 120, 80, 250, 300, 180]
}
df = pd.DataFrame(data)
# 对'category'和'product'列进行分组，计算sales的总和，然后重置索引
result = df.groupby(['category', 'product'])['sales'].sum().reset_index()
print(result)
Output:
在这个例子中，我们对’category’和’product’列进行分组并计算sales的总和，然后使用reset_index()函数将多级索引转换为普通的列。
5. 高级分组技巧
除了基本的分组操作，Pandas还提供了一些高级技巧，可以帮助我们更灵活地处理数据。
5.1 使用groupby对象的方法
groupby对象本身提供了许多有用的方法，如first()、last()、nth()等。
import pandas as pd
data = {
'website': ['pandasdataframe.com'] * 10,
'category': ['A', 'A', 'B', 'B', 'A', 'A', 'B', 'B', 'A', 'B'],
'product': ['X', 'Y', 'X', 'Y', 'X', 'Y', 'X', 'Y', 'Z', 'Z'],
'sales': [100, 150, 200, 120, 80, 250, 300, 180, 220, 190],
'date': pd.date_range(start='2023-01-01', periods=10)
}
df = pd.DataFrame(data)
# 获取每个组的第一条记录
first_records = df.groupby(['category', 'product']).first()
print("First records of each group:")
print(first_records)
# 获取每个组的最后一条记录
last_records = df.groupby(['category', 'product']).last()
print("\nLast records of each group:")
print(last_records)
# 获取每个组的第二条记录（如果存在）
second_records = df.groupby(['category', 'product']).nth(1)
print("\nSecond records of each group (if exists):")
print(second_records)
Output:
这个例子展示了如何使用groupby对象的first()、last()和nth()方法来获取每个组的特定记录。
5.2 使用agg()函数应用多个聚合函数
我们可以使用agg()函数同时应用多个聚合函数，甚至可以对不同的列应用不同的函数。
import pandas as pd
data = {
'website': ['pandasdataframe.com'] * 10,
'category': ['A', 'A', 'B', 'B', 'A', 'A', 'B', 'B', 'A', 'B'],
'product': ['X', 'Y', 'X', 'Y', 'X', 'Y', 'X', 'Y', 'Z', 'Z'],
'sales': [100, 150, 200, 120, 80, 250, 300, 180, 220, 190],
'quantity': [10, 15, 20, 12, 8, 25, 30, 18, 22, 19]
}
df = pd.DataFrame(data)
# 对不同的列应用不同的聚合函数
result = df.groupby(['category', 'product']).agg({
'sales': ['sum', 'mean', 'max'],
'quantity': ['sum', 'min']
})
print(result)
Output:
在这个例子中，我们对’sales’列应用了sum、mean和max函数，对’quantity’列应用了sum和min函数。结果是一个具有多级列索引的数据框。
5.3 使用named aggregation
Pandas 0.25.0版本引入了named aggregation，这使得我们可以为聚合结果指定自定义的列名。
import pandas as pd
data = {
'website': ['pandasdataframe.com'] * 10,
'category': ['A', 'A', 'B', 'B', 'A', 'A', 'B', 'B', 'A', 'B'],
'product': ['X', 'Y', 'X', 'Y', 'X', 'Y', 'X', 'Y', 'Z', 'Z'],
'sales': [100, 150, 200, 120, 80, 250, 300, 180, 220, 190],
'quantity': [10, 15, 20, 12, 8, 25, 30, 18, 22, 19]
}
df = pd.DataFrame(data)
# 使用named aggregation
result = df.groupby(['category', 'product']).agg(
total_sales=('sales', 'sum'),
avg_sales=('sales', 'mean'),
total_quantity=('quantity', 'sum')
)
print(result)
Output:
在这个例子中，我们使用named aggregation为聚合结果指定了自定义的列名，使得结果更加清晰易读。
6. 处理缺失值
在进行分组操作时，我们可能会遇到缺失值（NaN）的情况。Pandas提供了多种方法来处理这些缺失值。
6.1 使用dropna()函数删除包含缺失值的组
import pandas as pd
import numpy as np
data = {
''website': ['pandasdataframe.com'] * 10,
'category': ['A', 'A', 'B', 'B', 'A', 'A', 'B', 'B', 'A', 'B'],
'product': ['X', 'Y', 'X', 'Y', 'X', 'Y', 'X', 'Y', 'Z', 'Z'],
'sales': [100, 150, np.nan, 120, 80, 250, 300, 180, 220, np.nan],
'quantity': [10, 15, 20, 12, 8, 25, 30, 18, 22, 19]
}
df = pd.DataFrame(data)
# 删除包含缺失值的组
result = df.groupby(['category', 'product']).agg({
'sales': 'sum',
'quantity': 'sum'
}).dropna()
print(result)
在这个例子中，我们首先对数据进行分组和聚合，然后使用dropna()函数删除包含缺失值的组。这样，最终的结果中将不包含任何缺失值。
6.2 使用fillna()函数填充缺失值
有时，我们可能不想删除包含缺失值的组，而是想用某个值来填充这些缺失值。
import pandas as pd
import numpy as np
data = {
'website': ['pandasdataframe.com'] * 10,
'category': ['A', 'A', 'B', 'B', 'A', 'A', 'B', 'B', 'A', 'B'],
'product': ['X', 'Y', 'X', 'Y', 'X', 'Y', 'X', 'Y', 'Z', 'Z'],
'sales': [100, 150, np.nan, 120, 80, 250, 300, 180, 220, np.nan],
'quantity': [10, 15, 20, 12, 8, 25, 30, 18, 22, 19]
}
df = pd.DataFrame(data)
# 用0填充缺失值
result = df.groupby(['category', 'product']).agg({
'sales': 'sum',
'quantity': 'sum'
}).fillna(0)
print(result)
Output:
在这个例子中，我们使用fillna(0)将所有缺失值填充为0。这样，我们就保留了所有的组，只是将缺失的销售额视为0。
7. 高级分组操作
除了基本的分组和聚合操作，Pandas还提供了一些高级的分组操作，可以帮助我们更灵活地处理数据。
7.1 使用transform()进行组内标准化
有时，我们可能想要对每个组内的数据进行标准化处理。例如，我们可能想要计算每个销售额相对于其所在组平均值的偏差。
import pandas as pd
data = {
'website': ['pandasdataframe.com'] * 10,
'category': ['A', 'A', 'B', 'B', 'A', 'A', 'B', 'B', 'A', 'B'],
'product': ['X', 'Y', 'X', 'Y', 'X', 'Y', 'X', 'Y', 'Z', 'Z'],
'sales': [100, 150, 200, 120, 80, 250, 300, 180, 220, 190]
}
df = pd.DataFrame(data)
# 计算每个销售额与其所在组平均值的差
df['sales_diff'] = df.groupby(['category', 'product'])['sales'].transform(lambda x: x - x.mean())
print(df)
Output:
在这个例子中，我们使用transform()函数计算每个销售额与其所在组平均值的差。结果被添加为一个新的列’sales_diff’。
7.2 使用apply()进行复杂的组操作
当我们需要对每个组进行更复杂的操作时，可以使用apply()函数。
import pandas as pd
data = {
'website': ['pandasdataframe.com'] * 10,
'category': ['A', 'A', 'B', 'B', 'A', 'A', 'B', 'B', 'A', 'B'],
'product': ['X', 'Y', 'X', 'Y', 'X', 'Y', 'X', 'Y', 'Z', 'Z'],
'sales': [100, 150, 200, 120, 80, 250, 300, 180, 220, 190]
}
df = pd.DataFrame(data)
def group_summary(group):
return pd.Series({
'total_sales': group['sales'].sum(),
'avg_sales': group['sales'].mean(),
'sales_range': group['sales'].max() - group['sales'].min(),
'num_products': group['product'].nunique()
})
result = df.groupby('category').apply(group_summary)
print(result)
在这个例子中，我们定义了一个group_summary函数，它计算每个组的总销售额、平均销售额、销售额范围和产品数量。然后，我们使用apply()函数将这个自定义函数应用到每个组。
7.3 使用groupby进行时间序列分析
当我们的数据包含时间信息时，我们可以使用groupby进行时间序列分析。
import pandas as pd
import numpy as np
# 创建一个包含日期的数据框
dates = pd.date_range(start='2023-01-01', end='2023-12-31', freq='D')
data = {
'website': ['pandasdataframe.com'] * len(dates),
'date': dates,
'sales': np.random.randint(100, 1000, size=len(dates))
}
df = pd.DataFrame(data)
# 按月份分组并计算每月的总销售额
monthly_sales = df.groupby(df['date'].dt.to_period('M'))['sales'].sum()
print(monthly_sales)
Output:
在这个例子中，我们创建了一个包含全年每天销售数据的数据框。然后，我们使用groupby和日期的to_period('M')方法按月份对数据进行分组，并计算每月的总销售额。
8. 性能优化
当处理大量数据时，groupby操作可能会变得很慢。以下是一些提高性能的技巧：
8.1 使用categoricals
如果你的分组键是字符串或其他对象类型，将它们转换为categoricals可以显著提高性能。
import pandas as pd
import numpy as np
# 创建一个大数据集
n = 1000000
data = {
'website': ['pandasdataframe.com'] * n,
'category': np.random.choice(['A', 'B', 'C', 'D'], n),
'product': np.random.choice(['X', 'Y', 'Z'], n),
'sales': np.random.randint(100, 1000, n)
}
df = pd.DataFrame(data)
# 将category和product列转换为categorical类型
df['category'] = df['category'].astype('category')
df['product'] = df['product'].astype('category')
# 进行分组操作
result = df.groupby(['category', 'product'])['sales'].mean()
print(result)
在这个例子中，我们创建了一个包含100万行的大数据集，并将’category’和’product’列转换为categorical类型。这可以显著提高groupby操作的性能。
8.2 使用numba加速
对于一些自定义的聚合函数，我们可以使用numba来加速计算。
import pandas as pd
import numpy as np
from numba import jit
@jit(nopython=True)
def custom_agg(x):
return np.mean(x) * np.std(x)
data = {
'website': ['pandasdataframe.com'] * 1000000,
'category': np.random.choice(['A', 'B', 'C', 'D'], 1000000),
'product': np.random.choice(['X', 'Y', 'Z'], 1000000),
'sales': np.random.randint(100, 1000, 1000000)
}
df = pd.DataFrame(data)
result = df.groupby(['category', 'product'])['sales'].agg(custom_agg)
print(result)
在这个例子中，我们使用numba的@jit装饰器来编译我们的自定义聚合函数。这可以显著提高复杂聚合操作的性能。
9. 实际应用场景
让我们来看几个使用groupby对两列进行分组的实际应用场景。
9.1 销售数据分析
假设我们有一个电子商务网站的销售数据，我们想要分析不同类别和产品的销售情况。
import pandas as pd
import numpy as np
# 创建示例数据
np.random.seed(0)
n = 10000
data = {
'website': ['pandasdataframe.com'] * n,
'date': pd.date_range(start='2023-01-01', end='2023-12-31', periods=n),
'category': np.random.choice(['Electronics', 'Clothing', 'Books', 'Home'], n),
'product': np.random.choice(['A', 'B', 'C', 'D', 'E'], n),
'sales': np.random.randint(10, 1000, n),
'quantity': np.random.randint(1, 10, n)
}
df = pd.DataFrame(data)
# 分析每个类别和产品的总销售额和平均订单量
result = df.groupby(['category', 'product']).agg({
'sales': 'sum',
'quantity': 'mean'
}).rename(columns={'sales': 'total_sales', 'quantity': 'avg_order_size'})
print(result)
# 找出每个类别中销售额最高的产品
top_products = df.groupby(['category', 'product'])['sales'].sum().groupby(level=0).nlargest(1)
print("\nTop selling product in each category:")
print(top_products)
Output:
这个例子展示了如何分析每个类别和产品的总销售额和平均订单量，以及如何找出每个类别中销售额最高的产品。
9.2 客户行为分析
假设我们有一个网站的用户行为数据，我们想要分析不同年龄组和性别的用户行为。
import pandas as pd
import numpy as np
# 创建示例数据
np.random.seed(0)
n = 10000
data = {
'website': ['pandasdataframe.com'] * n,
'user_id': range(n),
'age_group': np.random.choice(['18-25', '26-35', '36-45', '46+'], n),
'gender': np.random.choice(['Male', 'Female'], n),
'time_spent': np.random.randint(1, 120, n),
'pages_visited': np.random.randint(1, 20, n)
}
df = pd.DataFrame(data)
# 分析不同年龄组和性别的平均访问时间和页面数
result = df.groupby(['age_group', 'gender']).agg({
'time_spent': 'mean',
'pages_visited': 'mean'
}).rename(columns={'time_spent': 'avg_time_spent', 'pages_visited': 'avg_pages_visited'})
print(result)
# 找出每个年龄组中访问页面最多的性别
most_active = df.groupby(['age_group', 'gender'])['pages_visited'].mean().groupby(level=0).nlargest(1)
print("\nMost active gender in each age group:")
print(most_active)
Output:
这个例子展示了如何分析不同年龄组和性别的平均访问时间和页面数，以及如何找出每个年龄组中访问页面最多的性别。
10. 总结
在本文中，我们详细探讨了Pandas中使用groupby对两列进行分组的各种方法和技巧。我们从基本概念开始，逐步深入到高级技巧和实际应用场景。通过使用groupby，我们可以轻松地对数据进行分组、聚合、转换和分析，从而获得有价值的洞察。
关键点总结：
- 使用
df.groupby(['col1', 'col2'])可以对两列进行分组。 - 可以使用多种聚合函数，如
sum()、mean()、count()等，也可以使用agg()函数应用多个聚合函数。 transform()和apply()函数允许我们对分组后的数据进行更复杂的操作。- 处理多级索引时，可以使用
unstack()和reset_index()函数来重塑数据。 - 在处理大数据集时，使用categoricals和numba可以提高性能。
- groupby可以与时间序列数据结合使用，进行时间相关的分析。
- 在实际应用中，groupby可以用于销售数据分析、客户行为分析等多种场景。
通过掌握这些技巧，你将能够更有效地处理和分析复杂的数据集，从而做出更好的数据驱动决策。记住，实践是掌握这些技能的关键，所以不要犹豫，立即开始在你自己的数据集上尝试这些技巧吧！