Pandas中使用groupby对两列进行分组操作的详细指南|极客教程

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:

Pandas中使用groupby对两列进行分组操作的详细指南

在这个例子中，我们创建了一个包含网站、类别、产品和销售额的数据框。然后，我们使用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:

Pandas中使用groupby对两列进行分组操作的详细指南

在这个例子中，我们对’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:

Pandas中使用groupby对两列进行分组操作的详细指南

在这个例子中，我们定义了一个自定义函数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:

Pandas中使用groupby对两列进行分组操作的详细指南

在这个例子中，我们使用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:

Pandas中使用groupby对两列进行分组操作的详细指南

在这个例子中，我们使用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:

Pandas中使用groupby对两列进行分组操作的详细指南

在这个例子中，我们首先对’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:

Pandas中使用groupby对两列进行分组操作的详细指南

在这个例子中，我们对’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:

Pandas中使用groupby对两列进行分组操作的详细指南

这个例子展示了如何使用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:

Pandas中使用groupby对两列进行分组操作的详细指南

在这个例子中，我们对’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:

Pandas中使用groupby对两列进行分组操作的详细指南

在这个例子中，我们使用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:

Pandas中使用groupby对两列进行分组操作的详细指南

在这个例子中，我们使用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:

Pandas中使用groupby对两列进行分组操作的详细指南

在这个例子中，我们使用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:

Pandas中使用groupby对两列进行分组操作的详细指南

在这个例子中，我们创建了一个包含全年每天销售数据的数据框。然后，我们使用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:

Pandas中使用groupby对两列进行分组操作的详细指南

这个例子展示了如何分析每个类别和产品的总销售额和平均订单量，以及如何找出每个类别中销售额最高的产品。

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)