极客笔记Pandas GroupBy和Unique Count操作：数据分组与唯一值统计详解
参考：pandas groupby unique count
Pandas是Python中强大的数据处理库，其中GroupBy和Unique Count操作是进行数据分析时常用的功能。本文将深入探讨Pandas中的GroupBy操作以及如何结合unique count进行数据统计，帮助读者更好地理解和应用这些功能。
1. Pandas GroupBy简介
GroupBy操作允许我们将数据按照某个或多个列进行分组，然后对每个分组应用特定的操作。这在数据分析中非常有用，可以帮助我们快速了解数据的结构和特征。
1.1 基本GroupBy操作
让我们从一个简单的例子开始：
import pandas as pd
# 创建示例数据
data = {
'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'],
'city': ['New York', 'London', 'Paris', 'New York', 'Paris'],
'sales': [100, 200, 300, 150, 250]
}
df = pd.DataFrame(data)
# 按name列进行分组并计算sales的总和
grouped = df.groupby('name')['sales'].sum()
print(grouped)
Output:
在这个例子中，我们创建了一个包含姓名、城市和销售额的DataFrame，然后按照姓名进行分组，并计算每个人的总销售额。
1.2 多列GroupBy
我们也可以按多个列进行分组：
import pandas as pd
# 创建示例数据
data = {
'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'],
'city': ['New York', 'London', 'Paris', 'New York', 'Paris'],
'category': ['A', 'B', 'A', 'B', 'A'],
'sales': [100, 200, 300, 150, 250]
}
df = pd.DataFrame(data)
# 按name和city列进行分组并计算sales的平均值
grouped = df.groupby(['name', 'city'])['sales'].mean()
print(grouped)
Output:
这个例子展示了如何按照姓名和城市进行分组，并计算每个组合的平均销售额。
2. GroupBy后的聚合操作
GroupBy后，我们可以进行各种聚合操作，如sum(), mean(), count()等。
2.1 多种聚合操作
import pandas as pd
# 创建示例数据
data = {
'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'],
'city': ['New York', 'London', 'Paris', 'New York', 'Paris'],
'sales': [100, 200, 300, 150, 250]
}
df = pd.DataFrame(data)
# 按name列进行分组并进行多种聚合操作
grouped = df.groupby('name').agg({
'sales': ['sum', 'mean', 'max', 'min'],
'city': 'count'
})
print(grouped)
Output:
这个例子展示了如何对分组后的数据进行多种聚合操作，包括销售额的总和、平均值、最大值和最小值，以及城市的计数。
2.2 自定义聚合函数
我们还可以使用自定义函数进行聚合：
import pandas as pd
# 创建示例数据
data = {
'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'],
'sales': [100, 200, 300, 150, 250]
}
df = pd.DataFrame(data)
# 自定义聚合函数
def range_diff(x):
return x.max() - x.min()
# 按name列进行分组并应用自定义聚合函数
grouped = df.groupby('name')['sales'].agg(range_diff)
print(grouped)
Output:
这个例子展示了如何创建一个自定义函数来计算每个组的销售额范围（最大值减最小值），并将其应用于分组后的数据。
3. Unique Count操作
Unique Count操作用于计算某一列中唯一值的数量。这在数据分析中非常有用，特别是当我们需要了解某个类别的多样性时。
3.1 基本Unique Count
import pandas as pd
# 创建示例数据
data = {
'category': ['A', 'B', 'A', 'C', 'B', 'A', 'C'],
'value': [1, 2, 3, 4, 5, 6, 7]
}
df = pd.DataFrame(data)
# 计算category列的唯一值数量
unique_count = df['category'].nunique()
print(f"Unique categories: {unique_count}")
Output:
这个例子展示了如何使用nunique()方法计算某一列中唯一值的数量。
3.2 结合GroupBy的Unique Count
我们可以将Unique Count操作与GroupBy结合使用：
import pandas as pd
# 创建示例数据
data = {
'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'],
'city': ['New York', 'London', 'Paris', 'London', 'Paris'],
'product': ['A', 'B', 'C', 'B', 'A']
}
df = pd.DataFrame(data)
# 按name分组并计算每个人访问的唯一城市数量
unique_cities = df.groupby('name')['city'].nunique()
print(unique_cities)
Output:
这个例子展示了如何按姓名分组，然后计算每个人访问的唯一城市数量。
4. 高级GroupBy和Unique Count操作
现在让我们探讨一些更高级的GroupBy和Unique Count操作。
4.1 GroupBy后的过滤
我们可以在GroupBy后应用过滤条件：
import pandas as pd
# 创建示例数据
data = {
'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'department': ['Sales', 'IT', 'Sales', 'Marketing', 'IT'],
'salary': [50000, 60000, 55000, 65000, 70000]
}
df = pd.DataFrame(data)
# 按department分组，计算平均工资，并只保留平均工资超过60000的部门
high_salary_depts = df.groupby('department')['salary'].mean().loc[lambda x: x > 60000]
print(high_salary_depts)
Output:
这个例子展示了如何按部门分组，计算平均工资，然后只保留平均工资超过60000的部门。
4.2 GroupBy与Transform
Transform方法允许我们在保持原始DataFrame结构的同时应用分组操作：
import pandas as pd
# 创建示例数据
data = {
'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'],
'sales': [100, 200, 300, 150, 250]
}
df = pd.DataFrame(data)
# 使用transform计算每个人的平均销售额
df['avg_sales'] = df.groupby('name')['sales'].transform('mean')
print(df)
Output:
这个例子展示了如何使用transform方法计算每个人的平均销售额，并将结果添加为新列。
4.3 复杂的Unique Count操作
我们可以结合多个操作来进行更复杂的分析：
import pandas as pd
# 创建示例数据
data = {
'date': ['2023-01-01', '2023-01-01', '2023-01-02', '2023-01-02', '2023-01-03'],
'user_id': [1, 2, 1, 3, 2],
'product': ['A', 'B', 'A', 'C', 'B']
}
df = pd.DataFrame(data)
# 计算每天的唯一用户数和唯一产品数
daily_stats = df.groupby('date').agg({
'user_id': 'nunique',
'product': 'nunique'
}).rename(columns={'user_id': 'unique_users', 'product': 'unique_products'})
print(daily_stats)
Output:
这个例子展示了如何计算每天的唯一用户数和唯一产品数，这在分析网站或应用的日常活跃度时非常有用。
5. 处理缺失值
在进行GroupBy和Unique Count操作时，处理缺失值是一个重要的考虑因素。
5.1 GroupBy时处理缺失值
import pandas as pd
# 创建包含缺失值的示例数据
data = {
'name': ['Alice', 'Bob', 'Charlie', 'Alice', None],
'sales': [100, 200, 300, 150, 250]
}
df = pd.DataFrame(data)
# 按name分组并计算销售总额，包括缺失值
grouped_with_na = df.groupby('name', dropna=False)['sales'].sum()
print("Including NA:")
print(grouped_with_na)
# 按name分组并计算销售总额，排除缺失值
grouped_without_na = df.groupby('name', dropna=True)['sales'].sum()
print("\nExcluding NA:")
print(grouped_without_na)
Output:
这个例子展示了如何在GroupBy操作中处理缺失值，可以选择包含或排除缺失值。
5.2 Unique Count时处理缺失值
import pandas as pd
# 创建包含缺失值的示例数据
data = {
'category': ['A', 'B', 'A', None, 'B', 'C', None],
'value': [1, 2, 3, 4, 5, 6, 7]
}
df = pd.DataFrame(data)
# 计算category列的唯一值数量，包括缺失值
unique_count_with_na = df['category'].nunique(dropna=False)
print(f"Unique categories (including NA): {unique_count_with_na}")
# 计算category列的唯一值数量，排除缺失值
unique_count_without_na = df['category'].nunique(dropna=True)
print(f"Unique categories (excluding NA): {unique_count_without_na}")
Output:
这个例子展示了如何在计算唯一值数量时处理缺失值，可以选择包含或排除缺失值。
6. 时间序列数据的GroupBy和Unique Count
处理时间序列数据时，GroupBy和Unique Count操作也非常有用。
6.1 按时间间隔分组
import pandas as pd
# 创建时间序列数据
data = {
'date': pd.date_range(start='2023-01-01', end='2023-12-31', freq='D'),
'sales': [100 + i for i in range(365)]
}
df = pd.DataFrame(data)
# 按月分组并计算每月的总销售额
monthly_sales = df.groupby(df['date'].dt.to_period('M'))['sales'].sum()
print(monthly_sales)
Output:
这个例子展示了如何将日期数据按月分组，并计算每月的总销售额。
6.2 滚动窗口的Unique Count
import pandas as pd
# 创建时间序列数据
data = {
'date': pd.date_range(start='2023-01-01', end='2023-01-10', freq='D'),
'user_id': [1, 2, 1, 3, 2, 4, 5, 1, 2, 3]
}
df = pd.DataFrame(data)
# 计算7天滚动窗口内的唯一用户数
df['rolling_unique_users'] = df.set_index('date')['user_id'].rolling('7D').nunique()
print(df)
这个例子展示了如何计算7天滚动窗口内的唯一用户数，这在分析用户活跃度趋势时非常有用。
7. 大数据集的优化
当处理大型数据集时，优化GroupBy和Unique Count操作的性能变得尤为重要。
7.1 使用分类数据类型
对于重复值较多的列，使用分类数据类型可以显著提高性能：
import pandas as pd
# 创建大型示例数据
data = {
'category': ['A', 'B', 'C'] * 1000000,
'value': range(3000000)
}
df = pd.DataFrame(data)
# 将category列转换为分类类型
df['category'] = df['category'].astype('category')
# 按category分组并计算平均值
grouped = df.groupby('category')['value'].mean()
print(grouped)
这个例子展示了如何将一个列转换为分类类型，这可以在大型数据集上显著提高GroupBy操作的性能。
7.2 使用Pandas的优化函数
对于某些特定操作，Pandas提供了优化的函数：
import pandas as pd
# 创建大型示例数据
data = {
'user_id': range(1000000),
'category': ['A', 'B', 'C'] * 333334
}
df = pd.DataFrame(data)
# 使用优化的value_counts函数计算每个类别的数量
category_counts = df['category'].value_counts()
print(category_counts)
这个例子展示了如何使用value_counts()函数，它比groupby().size()更快，特别是在大型数据集上。
8. 高级应用场景
让我们探讨一些更复杂的应用场景，这些场景结合了GroupBy和Unique Count操作。
8.1 客户购买行为分析
import pandas as pd
# 创建示例购数据
data = {
'customer_id': [1, 1, 2, 2, 3, 3, 3],
'product': ['A', 'B', 'A', 'C', 'B', 'C', 'D'],
'purchase_date': ['2023-01-01', '2023-01-02', '2023-01-01', '2023-01-03', '2023-01-02', '2023-01-04', '2023-01-05']
}
df = pd.DataFrame(data)
# 分析每个客户的购买行为
customer_analysis = df.groupby('customer_id').agg({
'product': 'nunique',
'purchase_date': ['count', 'min', 'max']
})
customer_analysis.columns = ['unique_products', 'total_purchases', 'first_purchase', 'last_purchase']
print(customer_analysis)
Output:
这个例子展示了如何分析每个客户的购买行为，包括购买的唯一产品数量、总购买次数、首次购买日期和最后购买日期。
8.2 员工考勤分析
import pandas as pd
# 创建示例考勤数据
data = {
'employee_id': [1, 1, 1, 2, 2, 3, 3, 3],
'date': ['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-01', '2023-01-03', '2023-01-01', '2023-01-02', '2023-01-03'],
'status': ['present', 'absent', 'present', 'present', 'present', 'present', 'present', 'absent']
}
df = pd.DataFrame(data)
# 分析每个员工的考勤情况
attendance_analysis = df.groupby('employee_id').agg({
'date': 'count',
'status': lambda x: (x == 'present').sum()
})
attendance_analysis.columns = ['total_days', 'days_present']
attendance_analysis['attendance_rate'] = attendance_analysis['days_present'] / attendance_analysis['total_days']
print(attendance_analysis)
Output:
这个例子展示了如何分析每个员工的考勤情况，包括总工作日数、出勤天数和出勤率。
9. 处理多层索引结果
GroupBy操作通常会产生多层索引的结果，处理这些结果需要一些特殊技巧。
9.1 重置索引
import pandas as pd
# 创建示例数据
data = {
'department': ['Sales', 'Sales', 'IT', 'IT', 'Marketing'],
'employee': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'salary': [50000, 52000, 60000, 62000, 55000]
}
df = pd.DataFrame(data)
# 按部门和员工分组
grouped = df.groupby(['department', 'employee'])['salary'].sum()
print("Original grouped data:")
print(grouped)
# 重置索引
reset_grouped = grouped.reset_index()
print("\nAfter resetting index:")
print(reset_grouped)
Output:
这个例子展示了如何重置多层索引，将其转换为普通的DataFrame格式。
9.2 使用unstack()方法
import pandas as pd
# 创建示例数据
data = {
'department': ['Sales', 'Sales', 'IT', 'IT', 'Marketing'],
'employee': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'salary': [50000, 52000, 60000, 62000, 55000]
}
df = pd.DataFrame(data)
# 按部门和员工分组，然后使用unstack()
grouped = df.groupby(['department', 'employee'])['salary'].sum().unstack()
print(grouped)
Output:
这个例子展示了如何使用unstack()方法将多层索引转换为更易读的表格形式。
10. 结合其他Pandas功能
GroupBy和Unique Count操作可以与其他Pandas功能结合使用，以进行更复杂的数据分析。
10.1 结合merge操作
import pandas as pd
# 创建员工数据
employees = pd.DataFrame({
'employee_id': [1, 2, 3, 4],
'name': ['Alice', 'Bob', 'Charlie', 'David'],
'department': ['Sales', 'IT', 'Sales', 'Marketing']
})
# 创建销售数据
sales = pd.DataFrame({
'employee_id': [1, 1, 2, 3, 3, 4],
'sale_amount': [100, 200, 150, 300, 250, 180]
})
# 计算每个员工的总销售额
employee_sales = sales.groupby('employee_id')['sale_amount'].sum().reset_index()
# 合并员工信息和销售信息
result = pd.merge(employees, employee_sales, on='employee_id')
# 计算每个部门的平均销售额
dept_avg_sales = result.groupby('department')['sale_amount'].mean()
print(dept_avg_sales)
Output:
这个例子展示了如何结合merge操作和GroupBy来分析员工销售数据。
10.2 使用pivot_table
import pandas as pd
# 创建示例数据
data = {
'date': ['2023-01-01', '2023-01-01', '2023-01-02', '2023-01-02', '2023-01-03'],
'product': ['A', 'B', 'A', 'B', 'C'],
'sales': [100, 150, 120, 180, 200]
}
df = pd.DataFrame(data)
# 使用pivot_table创建交叉表
pivot = pd.pivot_table(df, values='sales', index='date', columns='product', aggfunc='sum', fill_value=0)
print(pivot)
# 计算每个产品的累计销售额
pivot['Total'] = pivot.sum(axis=1)
pivot.loc['Total'] = pivot.sum()
print("\nWith totals:")
print(pivot)
Output:
这个例子展示了如何使用pivot_table创建交叉表，并计算总计和小计。
11. 处理时间序列数据
在处理时间序列数据时，GroupBy和Unique Count操作可以提供有价值的见解。
11.1 按时间间隔分组
import pandas as pd
# 创建时间序列数据
dates = pd.date_range(start='2023-01-01', end='2023-12-31', freq='D')
data = {
'date': dates,
'value': range(len(dates))
}
df = pd.DataFrame(data)
# 按月分组并计算每月的平均值
monthly_avg = df.groupby(df['date'].dt.to_period('M'))['value'].mean()
print(monthly_avg)
Output:
这个例子展示了如何按月分组时间序列数据并计算每月的平均值。
11.2 滚动窗口分析
import pandas as pd
# 创建时间序列数据
dates = pd.date_range(start='2023-01-01', end='2023-01-31', freq='D')
data = {
'date': dates,
'value': [100 + i * 10 for i in range(len(dates))]
}
df = pd.DataFrame(data)
# 计算7天滚动平均值
df['7d_rolling_avg'] = df['value'].rolling(window=7).mean()
# 计算7天滚动唯一值数量
df['7d_rolling_unique'] = df['value'].rolling(window=7).nunique()
print(df)
这个例子展示了如何计算滚动平均值和滚动唯一值数量，这在分析时间序列数据的趋势和变化时非常有用。
12. 高级GroupBy技巧
以下是一些高级的GroupBy技巧，可以帮助你更有效地处理复杂的数据分析任务。
12.1 使用自定义聚合函数
import pandas as pd
# 创建示例数据
data = {
'name': ['Alice', 'Bob', 'Charlie', 'Alice', 'Bob'],
'score': [85, 92, 78, 90, 88]
}
df = pd.DataFrame(data)
# 定义自定义聚合函数
def score_summary(x):
return pd.Series({
'mean': x.mean(),
'median': x.median(),
'range': x.max() - x.min()
})
# 应用自定义聚合函数
result = df.groupby('name')['score'].apply(score_summary)
print(result)
Output:
这个例子展示了如何创建和应用自定义聚合函数，以计算更复杂的统计信息。
12.2 使用transform进行组内操作
import pandas as pd
# 创建示例数据
data = {
'group': ['A', 'A', 'B', 'B', 'C'],
'value': [10, 20, 30, 40, 50]
}
df = pd.DataFrame(data)
# 使用transform计算每组的平均值
df['group_mean'] = df.groupby('group')['value'].transform('mean')
# 计算每个值与组平均值的差
df['diff_from_mean'] = df['value'] - df['group_mean']
print(df)
Output:
这个例子展示了如何使用transform方法进行组内操作，如计算每个值与其所在组平均值的差。
13. 处理大规模数据集
当处理大规模数据集时，优化GroupBy和Unique Count操作的性能变得尤为重要。
13.1 使用分类数据类型
import pandas as pd
import numpy as np
# 创建大规模示例数据
n = 1000000
data = {
'category': np.random.choice(['A', 'B', 'C', 'D'], n),
'value': np.random.randn(n)
}
df = pd.DataFrame(data)
# 将category列转换为分类类型
df['category'] = df['category'].astype('category')
# 按category分组并计算平均值
result = df.groupby('category')['value'].mean()
print(result)
这个例子展示了如何将分类列转换为分类数据类型，这可以显著提高大规模数据集上GroupBy操作的性能。
13.2 使用Dask进行并行处理
对于非常大的数据集，可以考虑使用Dask库进行并行处理：
import dask.dataframe as dd
# 假设我们有一个大型CSV文件
df = dd.read_csv('large_file.csv')
# 执行GroupBy操作
result = df.groupby('category')['value'].mean().compute()
print(result)
这个例子展示了如何使用Dask处理大型CSV文件并执行GroupBy操作。注意，这需要安装Dask库。
结论
Pandas的GroupBy和Unique Count操作是数据分析中强大而灵活的工具。通过本文的详细介绍和丰富的示例，我们深入探讨了这些操作的各种用法和技巧。从基本的分组和计数，到处理时间序列数据、优化大规模数据集的性能，以及结合其他Pandas功能进行复杂分析，这些知识将帮助你更有效地处理和分析数据。
记住，实践是掌握这些技能的关键。尝试将这些技巧应用到你自己的数据分析项目中，你会发现它们在解决实际问题时的强大威力。随着经验的积累，你将能够更加灵活和创造性地使用这些工具，从而更深入地理解你的数据，并从中获得有价值的见解。