Pandas GroupBy 和 Count Distinct 操作详解

Pandas GroupBy 和 Count Distinct 操作详解

参考：pandas groupby count distinct

Pandas是Python中用于数据分析和处理的强大库，其中GroupBy和Count Distinct是两个常用且重要的操作。本文将深入探讨这两个操作的使用方法、应用场景以及相关技巧，帮助您更好地掌握Pandas中的数据处理技能。

1. Pandas GroupBy 简介

GroupBy操作是数据分析中的一个核心概念，它允许我们将数据按照某个或某些列进行分组，然后对每个分组应用特定的操作。这种操作非常适合用于数据汇总、统计分析和数据转换等任务。

1.1 基本用法

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

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'],
    'city': ['New York', 'London', 'Paris', 'New York', 'London'],
    'sales': [100, 200, 300, 150, 250]
}
df = pd.DataFrame(data)

# 按name列进行分组并计算sales列的总和
result = df.groupby('name')['sales'].sum()
print("pandasdataframe.com - GroupBy结果:")
print(result)

Output:

在这个例子中，我们首先创建了一个包含姓名、城市和销售额的DataFrame。然后，我们使用groupby('name')按姓名进行分组，并计算每个人的总销售额。

1.2 多列分组

GroupBy操作也支持多列分组：

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'],
    'city': ['New York', 'London', 'Paris', 'New York', 'London'],
    'category': ['A', 'B', 'A', 'B', 'A'],
    'sales': [100, 200, 300, 150, 250]
}
df = pd.DataFrame(data)

# 按name和city列进行分组并计算sales列的平均值
result = df.groupby(['name', 'city'])['sales'].mean()
print("pandasdataframe.com - 多列GroupBy结果:")
print(result)

Output:

这个例子展示了如何按多个列（姓名和城市）进行分组，并计算每个组的平均销售额。

1.3 GroupBy后的聚合操作

GroupBy后可以执行多种聚合操作，如sum、mean、count等：

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'],
    'city': ['New York', 'London', 'Paris', 'New York', 'London'],
    'sales': [100, 200, 300, 150, 250]
}
df = pd.DataFrame(data)

# 按name列分组并执行多种聚合操作
result = df.groupby('name').agg({
    'sales': ['sum', 'mean', 'max', 'min'],
    'city': 'count'
})
print("pandasdataframe.com - GroupBy聚合结果:")
print(result)

Output:

这个例子展示了如何在GroupBy后使用agg方法执行多种聚合操作，包括计算销售额的总和、平均值、最大值和最小值，以及计算每个人出现的城市数量。

2. Count Distinct 操作

Count Distinct是一种特殊的聚合操作，用于计算某一列中不重复值的数量。这在数据分析中非常有用，例如计算独立用户数、不同产品种类数等。

2.1 基本用法

以下是一个简单的Count Distinct示例：

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob', 'Alice'],
    'city': ['New York', 'London', 'Paris', 'New York', 'London', 'Paris']
}
df = pd.DataFrame(data)

# 计算不同的城市数量
distinct_cities = df['city'].nunique()
print("pandasdataframe.com - 不同城市数量:", distinct_cities)

Output:

在这个例子中，我们使用nunique()方法来计算’city’列中不重复值的数量，即不同城市的数量。

2.2 结合GroupBy使用Count Distinct

Count Distinct经常与GroupBy操作结合使用，以计算每个组内的唯一值数量：

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob', 'Alice'],
    'city': ['New York', 'London', 'Paris', 'New York', 'London', 'Paris'],
    'product': ['A', 'B', 'C', 'B', 'A', 'C']
}
df = pd.DataFrame(data)

# 按name分组，计算每个人购买的不同产品数量
result = df.groupby('name')['product'].nunique()
print("pandasdataframe.com - 每个人购买的不同产品数量:")
print(result)

Output:

这个例子展示了如何按姓名分组，并计算每个人购买的不同产品数量。

3. 高级GroupBy技巧

3.1 自定义聚合函数

除了内置的聚合函数，我们还可以使用自定义函数进行聚合：

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'],
    'sales': [100, 200, 300, 150, 250]
}
df = pd.DataFrame(data)

# 自定义聚合函数
def sales_range(x):
    return x.max() - x.min()

# 应用自定义聚合函数
result = df.groupby('name')['sales'].agg(sales_range)
print("pandasdataframe.com - 自定义聚合函数结果:")
print(result)

Output:

这个例子定义了一个sales_range函数来计算每个人的销售额范围（最大值减最小值），并将其应用于GroupBy操作。

3.2 多列聚合

我们可以对多个列同时应用不同的聚合函数：

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'],
    'city': ['New York', 'London', 'Paris', 'New York', 'London'],
    'sales': [100, 200, 300, 150, 250],
    'units': [10, 20, 30, 15, 25]
}
df = pd.DataFrame(data)

# 多列聚合
result = df.groupby('name').agg({
    'sales': 'sum',
    'units': 'mean',
    'city': 'nunique'
})
print("pandasdataframe.com - 多列聚合结果:")
print(result)

Output:

这个例子展示了如何在一个GroupBy操作中对不同的列应用不同的聚合函数。

3.3 GroupBy与转换操作

GroupBy不仅可以用于聚合，还可以用于转换操作：

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'],
    'sales': [100, 200, 300, 150, 250]
}
df = pd.DataFrame(data)

# 计算每个人的销售额占该人总销售额的百分比
df['sales_percentage'] = df.groupby('name')['sales'].transform(lambda x: x / x.sum() * 100)
print("pandasdataframe.com - 销售额百分比:")
print(df)

Output:

这个例子使用transform方法计算每个人的销售额占该人总销售额的百分比。

4. Count Distinct的高级应用

4.1 条件Count Distinct

有时我们需要在特定条件下进行Count Distinct操作：

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob', 'Alice'],
    'city': ['New York', 'London', 'Paris', 'New York', 'London', 'Paris'],
    'sales': [100, 200, 300, 150, 250, 180]
}
df = pd.DataFrame(data)

# 计算销售额大于200的不同城市数量
high_sales_cities = df[df['sales'] > 200]['city'].nunique()
print("pandasdataframe.com - 销售额大于200的不同城市数量:", high_sales_cities)

Output:

这个例子展示了如何计算满足特定条件（销售额大于200）的不同城市数量。

4.2 Rolling Count Distinct

在时间序列数据中，我们可能需要计算滚动的唯一值数量：

import pandas as pd

# 创建示例数据
data = {
    'date': pd.date_range(start='2023-01-01', periods=10),
    'product': ['A', 'B', 'A', 'C', 'B', 'A', 'C', 'D', 'B', 'A']
}
df = pd.DataFrame(data)

# 计算3天滚动窗口内的不同产品数量
df['rolling_distinct_products'] = df.set_index('date')['product'].rolling('3D').agg(lambda x: x.nunique())
print("pandasdataframe.com - 滚动唯一产品数量:")
print(df)

这个例子展示了如何计算3天滚动窗口内的不同产品数量。

5. GroupBy和Count Distinct的性能优化

在处理大型数据集时，GroupBy和Count Distinct操作可能会变得很慢。以下是一些优化技巧：

5.1 使用分类数据类型

对于包含重复值的列，使用分类数据类型可以显著提高性能：

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'] * 1000,
    'city': ['New York', 'London', 'Paris', 'New York', 'London'] * 1000,
    'sales': [100, 200, 300, 150, 250] * 1000
}
df = pd.DataFrame(data)

# 将name和city列转换为分类类型
df['name'] = df['name'].astype('category')
df['city'] = df['city'].astype('category')

# 执行GroupBy操作
result = df.groupby(['name', 'city'])['sales'].sum()
print("pandasdataframe.com - 使用分类类型后的GroupBy结果:")
print(result.head())

这个例子展示了如何将字符串列转换为分类类型，这可以在大型数据集上显著提高GroupBy的性能。

5.2 使用Pandas的优化方法

对于Count Distinct操作，Pandas提供了一些优化的方法：

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'] * 1000,
    'product': ['A', 'B', 'C', 'A', 'B'] * 1000
}
df = pd.DataFrame(data)

# 使用优化的方法计算每个人购买的不同产品数量
result = df.groupby('name')['product'].nunique()
print("pandasdataframe.com - 优化后的Count Distinct结果:")
print(result)

Output:

nunique()方法是Pandas为Count Distinct操作优化的方法，比使用lambda函数更高效。

6. 实际应用场景

6.1 客户分析

GroupBy和Count Distinct在客户分析中非常有用：

import pandas as pd

# 创建示例客户数据
data = {
    'customer_id': [1, 2, 3, 1, 2, 3, 1, 2],
    'purchase_date': ['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04', '2023-01-05', '2023-01-06', '2023-01-07', '2023-01-08'],
    'product': ['A', 'B', 'C', 'B', 'A', 'C', 'D', 'B'],
    'amount': [100, 200, 150, 120, 180, 200, 90, 150]
}
df = pd.DataFrame(data)

# 分析每个客户的购买行为
customer_analysis = df.groupby('customer_id').agg({
    'purchase_date': 'count',
    'product': 'nunique',
    'amount': ['sum', 'mean']
})
customer_analysis.columns = ['purchase_count', 'unique_products', 'total_amount', 'average_amount']
print("pandasdataframe.com - 客户购买行为分析:")
print(customer_analysis)

Output:

这个例子展示了如何使用GroupBy和Count Distinct来分析客户的购买行为，包括购买次数、购买的不同产品数量、总消费金额和平均消费金额。

6.2 时间序列分析

在时间序列数据分析中，GroupBy和Count Distinct也很常用：

import pandas as pd

# 创建示例时间序列数据
data = {
    'date': pd.date_range(start='2023-01-01', periods=100),
    'product': ['A', 'B', 'C'] * 33 + ['A'],
    'sales': [100,200, 300] * 33 + [100]
}
df = pd.DataFrame(data)

# 按周分组，计算每周的销售总额和不同产品数量
weekly_analysis = df.groupby(pd.Grouper(key='date', freq='W')).agg({
    'sales': 'sum',
    'product': 'nunique'
})
weekly_analysis.columns = ['total_sales', 'unique_products']
print("pandasdataframe.com - 每周销售分析:")
print(weekly_analysis)

Output:

这个例子展示了如何使用GroupBy和Count Distinct来进行时间序列分析，包括计算每周的销售总额和不同产品数量。

7. 处理缺失值

在进行GroupBy和Count Distinct操作时，处理缺失值是一个常见的问题：

import pandas as pd
import numpy as np

# 创建包含缺失值的示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob', np.nan],
    'city': ['New York', 'London', 'Paris', np.nan, 'London', 'Paris'],
    'sales': [100, 200, 300, 150, np.nan, 250]
}
df = pd.DataFrame(data)

# 处理缺失值
result = df.groupby('name', dropna=False).agg({
    'city': lambda x: x.nunique(dropna=True),
    'sales': ['count', 'sum']
})
result.columns = ['unique_cities', 'sales_count', 'total_sales']
print("pandasdataframe.com - 处理缺失值后的结果:")
print(result)

Output:

这个例子展示了如何在GroupBy和Count Distinct操作中处理缺失值。dropna=False参数确保包含缺失值的组也被保留，而nunique(dropna=True)则在计算唯一值时忽略缺失值。

8. 高级GroupBy技巧

8.1 使用函数作为分组键

除了使用列名作为分组键，我们还可以使用函数来创建更复杂的分组：

import pandas as pd

# 创建示例数据
data = {
    'date': pd.date_range(start='2023-01-01', periods=100),
    'sales': [100, 200, 300, 400, 500] * 20
}
df = pd.DataFrame(data)

# 使用函数作为分组键
result = df.groupby(lambda x: df['date'][x].dayofweek).agg({
    'sales': ['mean', 'sum']
})
result.columns = ['avg_sales', 'total_sales']
result.index = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
print("pandasdataframe.com - 按星期几分组的销售数据:")
print(result)

Output:

这个例子展示了如何使用函数作为分组键，将数据按星期几进行分组并计算平均销售额和总销售额。

8.2 GroupBy与窗口函数

GroupBy可以与窗口函数结合使用，实现更复杂的数据分析：

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob', 'Charlie'],
    'date': pd.date_range(start='2023-01-01', periods=6),
    'sales': [100, 200, 300, 150, 250, 350]
}
df = pd.DataFrame(data)

# 计算每个人的累计销售额
df['cumulative_sales'] = df.groupby('name')['sales'].cumsum()

# 计算每个人的销售额移动平均
df['moving_avg_sales'] = df.groupby('name')['sales'].rolling(window=2).mean().reset_index(0, drop=True)

print("pandasdataframe.com - 累计销售额和移动平均:")
print(df)

Output:

这个例子展示了如何使用GroupBy结合窗口函数来计算累计销售额和移动平均销售额。

9. Count Distinct的替代方法

在某些情况下，使用其他方法来实现Count Distinct可能更高效或更方便：

9.1 使用set

对于小型数据集，使用Python的set可能是一个简单而高效的方法：

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob', 'Alice'],
    'product': ['A', 'B', 'C', 'B', 'A', 'C']
}
df = pd.DataFrame(data)

# 使用set计算每个人购买的不同产品数量
result = df.groupby('name')['product'].agg(lambda x: len(set(x)))
print("pandasdataframe.com - 使用set计算不同产品数量:")
print(result)

Output:

这个方法在处理小型数据集时可能比nunique()更快。

9.2 使用value_counts

对于某些场景，使用value_counts()可能更直观：

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob', 'Alice'],
    'city': ['New York', 'London', 'Paris', 'New York', 'London', 'Paris']
}
df = pd.DataFrame(data)

# 计算每个人去过的不同城市数量
result = df.groupby('name')['city'].value_counts().groupby(level=0).size()
print("pandasdataframe.com - 使用value_counts计算不同城市数量:")
print(result)

Output:

这个方法首先计算每个人在每个城市的出现次数，然后计算每个人有多少个不同的城市。

10. 性能优化技巧

在处理大型数据集时，优化GroupBy和Count Distinct操作的性能变得尤为重要：

10.1 使用索引

对于频繁进行GroupBy操作的列，将其设置为索引可以提高性能：

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie'] * 1000,
    'city': ['New York', 'London', 'Paris'] * 1000,
    'sales': [100, 200, 300] * 1000
}
df = pd.DataFrame(data)

# 将name列设置为索引
df.set_index('name', inplace=True)

# 执行GroupBy操作
result = df.groupby(level=0)['sales'].sum()
print("pandasdataframe.com - 使用索引后的GroupBy结果:")
print(result.head())

Output:

将频繁用于分组的列设置为索引可以显著提高GroupBy操作的性能。

10.2 使用Categoricals

对于包含有限且重复的值的列，使用Categorical数据类型可以提高性能和减少内存使用：

import pandas as pd

# 创建示例数据
data = {
    'name': ['Alice', 'Bob', 'Charlie'] * 1000,
    'city': ['New York', 'London', 'Paris'] * 1000,
    'sales': [100, 200, 300] * 1000
}
df = pd.DataFrame(data)

# 将name和city列转换为Categorical类型
df['name'] = pd.Categorical(df['name'])
df['city'] = pd.Categorical(df['city'])

# 执行GroupBy和Count Distinct操作
result = df.groupby('name').agg({
    'city': 'nunique',
    'sales': 'sum'
})
print("pandasdataframe.com - 使用Categorical后的结果:")
print(result)

使用Categorical类型可以显著提高GroupBy和Count Distinct操作的性能，特别是在处理大型数据集时。

结论

Pandas的GroupBy和Count Distinct操作是数据分析中不可或缺的工具。它们允许我们高效地对数据进行分组、聚合和计算唯一值，从而深入了解数据的结构和模式。通过本文介绍的各种技巧和优化方法，您可以更有效地处理各种规模的数据集，从简单的日常分析到复杂的大规模数据处理。

记住，选择正确的方法和优化技巧取决于您的具体数据和分析需求。随着经验的积累，您将能够更好地判断何时使用哪种方法，以及如何优化您的数据处理流程。持续学习和实践是掌握Pandas数据分析的关键。