pandas分组输出实战指南从基础语法到高级应用全面解决数据分析中的分组统计与结果展示问题助你提升数据处理效率

威震华夏关云长

引言

Pandas是Python数据分析的核心库之一，而分组（GroupBy）操作是数据分析中最常用、最强大的功能之一。通过分组操作，我们可以对数据集进行灵活的切片、切块、汇总等操作，从而揭示数据中隐藏的模式和关系。本文将从基础语法到高级应用，全面介绍pandas中的分组操作，帮助读者掌握这一重要技能，提升数据处理效率。

基础语法：groupby的基本用法

Pandas中的groupby操作遵循”拆分-应用-合并”的模式。首先，我们需要了解groupby方法的基本语法：

2. import pandas as pd
4. # 创建示例DataFrame
5. data = {
6.     'Department': ['HR', 'IT', 'HR', 'IT', 'Finance', 'Finance', 'HR', 'IT'],
7.     'Employee': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank', 'Grace', 'Henry'],
8.     'Salary': [70000, 80000, 75000, 90000, 85000, 82000, 72000, 95000],
9.     'Years': [3, 5, 4, 6, 7, 5, 2, 8]
10. }
11. df = pd.DataFrame(data)
13. # 按Department列分组
14. grouped = df.groupby('Department')
16. # 查看分组结果
17. print(grouped.groups)

复制代码

在这个例子中，我们首先创建了一个包含部门、员工、薪资和工作年限的DataFrame。然后使用groupby方法按’Department’列进行分组。grouped.groups会显示每个分组包含的行索引。

需要注意的是，groupby操作本身不会立即计算任何结果，而是创建一个GroupBy对象，这个对象包含了后续计算所需的所有信息。这种”惰性计算”的方式可以提高效率，特别是处理大型数据集时。

我们也可以按多列进行分组，只需将列名列表传递给groupby方法：

2. # 按Department和Years列分组
3. multi_grouped = df.groupby(['Department', 'Years'])
4. print(multi_grouped.groups)

复制代码

常用聚合函数：sum, mean, count等

分组后，我们通常需要对每个组应用聚合函数，如求和、平均值、计数等。pandas提供了多种内置聚合函数：

2. # 计算每个部门的平均薪资
3. avg_salary = df.groupby('Department')['Salary'].mean()
4. print("平均薪资：\n", avg_salary)
6. # 计算每个部门的薪资总和
7. total_salary = df.groupby('Department')['Salary'].sum()
8. print("\n薪资总和：\n", total_salary)
10. # 计算每个部门的员工数量
11. employee_count = df.groupby('Department')['Employee'].count()
12. print("\n员工数量：\n", employee_count)
14. # 计算每个部门的薪资最大值、最小值和标准差
15. salary_stats = df.groupby('Department')['Salary'].agg(['max', 'min', 'std'])
16. print("\n薪资统计：\n", salary_stats)

复制代码

这些聚合函数可以直接应用于GroupBy对象，也可以通过agg方法一次性应用多个函数。除了上述函数外，常用的聚合函数还包括：

• median(): 计算中位数
• var(): 计算方差
• first(): 获取第一个值
• last(): 获取最后一个值
• size(): 获取组的大小（包括NaN值）

2. # 计算每个部门的中位数薪资和工作年限
3. median_values = df.groupby('Department')[['Salary', 'Years']].median()
4. print("中位数薪资和工作年限：\n", median_values)
6. # 获取每个部门的第一位员工和薪资
7. first_values = df.groupby('Department').first()
8. print("\n每个部门的第一位员工：\n", first_values)
10. # 获取每个部门的大小（包括NaN值）
11. group_sizes = df.groupby('Department').size()
12. print("\n每个部门的大小：\n", group_sizes)

复制代码

多重分组：按多列分组

在实际数据分析中，我们经常需要按多个列进行分组，以获得更细粒度的分析结果。多重分组可以让我们从不同维度审视数据：

2. # 创建更详细的示例数据
3. data = {
4.     'Department': ['HR', 'IT', 'HR', 'IT', 'Finance', 'Finance', 'HR', 'IT', 'HR', 'IT'],
5.     'Team': ['Recruitment', 'Development', 'Training', 'Support', 'Accounting', 'Investment', 'Recruitment', 'Development', 'Training', 'Support'],
6.     'Employee': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank', 'Grace', 'Henry', 'Ivy', 'Jack'],
7.     'Salary': [70000, 80000, 75000, 90000, 85000, 82000, 72000, 95000, 78000, 92000],
8.     'Years': [3, 5, 4, 6, 7, 5, 2, 8, 3, 6],
9.     'Gender': ['F', 'M', 'M', 'M', 'F', 'M', 'F', 'M', 'F', 'M']
10. }
11. df = pd.DataFrame(data)
13. # 按部门和团队分组，计算平均薪资
14. dept_team_avg = df.groupby(['Department', 'Team'])['Salary'].mean()
15. print("部门和团队的平均薪资：\n", dept_team_avg)
17. # 按部门和性别分组，计算员工数量和平均工作年限
18. dept_gender_stats = df.groupby(['Department', 'Gender']).agg({
19.     'Employee': 'count',
20.     'Years': 'mean'
21. })
22. print("\n部门和性别的统计：\n", dept_gender_stats)

复制代码

多重分组的结果是一个具有多级索引的Series或DataFrame。我们可以使用unstack方法将多级索引转换为列，使数据更易于阅读和分析：

2. # 将部门和团队的分组结果转换为更易读的格式
3. dept_team_avg_unstacked = df.groupby(['Department', 'Team'])['Salary'].mean().unstack()
4. print("转换后的部门和团队平均薪资：\n", dept_team_avg_unstacked)
6. # 将部门和性别的统计结果转换为更易读的格式
7. dept_gender_stats_unstacked = df.groupby(['Department', 'Gender']).agg({
8.     'Employee': 'count',
9.     'Years': 'mean'
10. }).unstack()
11. print("\n转换后的部门和性别统计：\n", dept_gender_stats_unstacked)

复制代码

分组迭代：遍历分组对象

有时我们需要对每个分组执行特定的操作，这时可以通过遍历GroupBy对象来实现。GroupBy对象是可迭代的，每次迭代返回一个包含组名和对应DataFrame的元组：

2. # 遍历每个部门
3. for name, group in df.groupby('Department'):
4.     print(f"部门: {name}")
5.     print(group)
6.     print("\n")
8. # 遍历部门和团队
9. for (dept, team), group in df.groupby(['Department', 'Team']):
10.     print(f"部门: {dept}, 团队: {team}")
11.     print(group)
12.     print("\n")

复制代码

通过遍历分组，我们可以对每个组执行复杂的自定义操作：

2. # 计算每个部门的薪资范围
3. for name, group in df.groupby('Department'):
4.     salary_range = group['Salary'].max() - group['Salary'].min()
5.     print(f"{name}部门的薪资范围: {salary_range}")
7. # 找出每个部门薪资最高的员工
8. for name, group in df.groupby('Department'):
9.     highest_paid = group.loc[group['Salary'].idxmax()]
10.     print(f"{name}部门薪资最高的员工: {highest_paid['Employee']}, 薪资: {highest_paid['Salary']}")

复制代码

自定义聚合函数：使用agg和apply

虽然pandas提供了许多内置聚合函数，但有时我们需要使用自定义的聚合逻辑。这时可以使用agg和apply方法。

agg方法主要用于聚合操作，可以接受函数名、函数列表或字典：

2. # 使用自定义函数计算薪资范围
3. def salary_range(series):
4.     return series.max() - series.min()
6. # 对每个部门应用自定义聚合函数
7. dept_salary_range = df.groupby('Department')['Salary'].agg(salary_range)
8. print("每个部门的薪资范围：\n", dept_salary_range)
10. # 使用多个聚合函数，包括自定义函数
11. dept_stats = df.groupby('Department')['Salary'].agg(['mean', 'std', salary_range])
12. print("\n每个部门的薪资统计：\n", dept_stats)
14. # 对不同的列使用不同的聚合函数
15. multi_agg = df.groupby('Department').agg({
16.     'Salary': ['mean', 'max', salary_range],
17.     'Years': ['mean', 'min'],
18.     'Employee': 'count'
19. })
20. print("\n多重聚合：\n", multi_agg)

复制代码

apply方法更加灵活，可以应用任何函数到每个分组：

2. # 使用apply方法计算每个部门的薪资差异百分比
3. def salary_diff_pct(group):
4.     group['Salary_Pct_Diff'] = (group['Salary'] - group['Salary'].mean()) / group['Salary'].mean() * 100
5.     return group
7. # 应用函数并显示结果
8. df_with_pct = df.groupby('Department').apply(salary_diff_pct)
9. print("带有薪资差异百分比的数据：\n", df_with_pct[['Department', 'Employee', 'Salary', 'Salary_Pct_Diff']])
11. # 使用apply方法获取每个部门薪资排名前二的员工
12. def top_earners(group, n=2):
13.     return group.nlargest(n, 'Salary')
15. top_employees = df.groupby('Department').apply(top_earners)
16. print("\n每个部门薪资排名前二的员工：\n", top_employees[['Department', 'Employee', 'Salary']])

复制代码

分组转换：transform方法

transform方法与apply方法类似，但它返回一个与原始DataFrame形状相同的对象，这使得它非常适合于添加派生列：

2. # 计算每个部门的平均薪资，并将结果添加到每一行
3. df['Dept_Avg_Salary'] = df.groupby('Department')['Salary'].transform('mean')
4. print("带有部门平均薪资的数据：\n", df[['Department', 'Employee', 'Salary', 'Dept_Avg_Salary']])
6. # 计算每个员工薪资与部门平均薪资的差异
7. df['Salary_vs_Dept_Avg'] = df['Salary'] - df.groupby('Department')['Salary'].transform('mean')
8. print("\n薪资与部门平均的差异：\n", df[['Department', 'Employee', 'Salary', 'Salary_vs_Dept_Avg']])
10. # 计算每个员工在部门内的薪资排名
11. df['Salary_Rank_in_Dept'] = df.groupby('Department')['Salary'].rank(ascending=False)
12. print("\n部门内薪资排名：\n", df[['Department', 'Employee', 'Salary', 'Salary_Rank_in_Dept']].sort_values(['Department', 'Salary_Rank_in_Dept']))

复制代码

transform方法特别适用于数据标准化和归一化：

2. # 对每个部门的薪资进行标准化（Z-score）
3. def z_score(x):
4.     return (x - x.mean()) / x.std()
6. df['Salary_Z_Score'] = df.groupby('Department')['Salary'].transform(z_score)
7. print("薪资标准化（Z-score）：\n", df[['Department', 'Employee', 'Salary', 'Salary_Z_Score']])
9. # 对每个部门的薪资进行最小-最大归一化
10. def min_max_norm(x):
11.     return (x - x.min()) / (x.max() - x.min())
13. df['Salary_Normalized'] = df.groupby('Department')['Salary'].transform(min_max_norm)
14. print("\n薪资归一化（0-1）：\n", df[['Department', 'Employee', 'Salary', 'Salary_Normalized']])

复制代码

分组过滤：filter方法

filter方法允许我们根据分组级别的条件来过滤数据。它返回一个DataFrame，其中只包含满足条件的组：

2. # 只保留员工数量大于2的部门
3. large_depts = df.groupby('Department').filter(lambda x: len(x) > 2)
4. print("员工数量大于2的部门：\n", large_depts)
6. # 只保留平均薪资大于80000的部门
7. high_salary_depts = df.groupby('Department').filter(lambda x: x['Salary'].mean() > 80000)
8. print("\n平均薪资大于80000的部门：\n", high_salary_depts)
10. # 只保留有至少一名女性员工的部门
11. depts_with_female = df.groupby('Department').filter(lambda x: (x['Gender'] == 'F').any())
12. print("\n有女性员工的部门：\n", depts_with_female)

复制代码

filter方法也可以与自定义函数结合使用，实现更复杂的过滤逻辑：

2. # 自定义过滤函数：保留薪资标准差大于5000的部门
3. def high_salary_variance(group):
4.     return group['Salary'].std() > 5000
6. varied_depts = df.groupby('Department').filter(high_salary_variance)
7. print("薪资标准差大于5000的部门：\n", varied_depts)
9. # 自定义过滤函数：保留薪资和工作年限相关性大于0.5的部门
10. def high_corr(group):
11.     return group['Salary'].corr(group['Years']) > 0.5
13. corr_depts = df.groupby('Department').filter(high_corr)
14. print("\n薪资和工作年限相关性大于0.5的部门：\n", corr_depts)

复制代码

分组排序：sort_values在分组中的应用

在分组操作中，排序是一个常见需求。我们可以对分组后的结果进行排序，也可以在每个组内进行排序：

2. # 按部门分组后，按平均薪资降序排序
3. dept_avg_salary = df.groupby('Department')['Salary'].mean().sort_values(ascending=False)
4. print("按平均薪资降序排列的部门：\n", dept_avg_salary)
6. # 在每个部门内，按薪资降序排序
7. sorted_within_dept = df.groupby('Department', group_keys=False).apply(lambda x: x.sort_values('Salary', ascending=False))
8. print("\n每个部门内按薪资降序排列：\n", sorted_within_dept[['Department', 'Employee', 'Salary']])

复制代码

我们也可以使用rank方法在组内进行排名：

2. # 计算每个员工在部门内的薪资排名
3. df['Salary_Rank'] = df.groupby('Department')['Salary'].rank(ascending=False)
4. print("部门内薪资排名：\n", df[['Department', 'Employee', 'Salary', 'Salary_Rank']].sort_values(['Department', 'Salary_Rank']))
6. # 计算每个员工在部门内的工作年限排名（百分比）
7. df['Years_Pct_Rank'] = df.groupby('Department')['Years'].rank(pct=True)
8. print("\n部门内工作年限百分比排名：\n", df[['Department', 'Employee', 'Years', 'Years_Pct_Rank']].sort_values(['Department', 'Years']))

复制代码

高级应用：透视表和交叉表

透视表（pivot_table）和交叉表（crosstab）是pandas中强大的数据重塑工具，它们可以看作是分组操作的高级应用。

透视表允许我们以电子表格的方式查看数据，其中一个或多个字段作为行，一个或多个字段作为列，以及一个聚合函数填充值：

2. # 创建更复杂的示例数据
3. data = {
4.     'Department': ['HR', 'IT', 'HR', 'IT', 'Finance', 'Finance', 'HR', 'IT', 'HR', 'IT', 'Finance', 'HR'],
5.     'Team': ['Recruitment', 'Development', 'Training', 'Support', 'Accounting', 'Investment', 'Recruitment', 'Development', 'Training', 'Support', 'Accounting', 'Training'],
6.     'Employee': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank', 'Grace', 'Henry', 'Ivy', 'Jack', 'Kelly', 'Liam'],
7.     'Salary': [70000, 80000, 75000, 90000, 85000, 82000, 72000, 95000, 78000, 92000, 87000, 76000],
8.     'Years': [3, 5, 4, 6, 7, 5, 2, 8, 3, 6, 8, 4],
9.     'Gender': ['F', 'M', 'M', 'M', 'F', 'M', 'F', 'M', 'F', 'M', 'F', 'M'],
10.     'Performance': ['Good', 'Excellent', 'Good', 'Excellent', 'Excellent', 'Good', 'Average', 'Excellent', 'Good', 'Excellent', 'Excellent', 'Good']
11. }
12. df = pd.DataFrame(data)
14. # 创建透视表：部门为行，团队为列，值为平均薪资
15. pivot_dept_team = pd.pivot_table(df, values='Salary', index='Department', columns='Team', aggfunc='mean')
16. print("部门-团队平均薪资透视表：\n", pivot_dept_team)
18. # 创建透视表：部门和性别为行，绩效为列，值为员工数量
19. pivot_dept_gender_perf = pd.pivot_table(df, values='Employee', index=['Department', 'Gender'], columns='Performance', aggfunc='count', fill_value=0)
20. print("\n部门-性别-绩效员工数量透视表：\n", pivot_dept_gender_perf)
22. # 创建透视表：添加 margins 参数显示总计
23. pivot_with_margins = pd.pivot_table(df, values='Salary', index='Department', columns='Performance', aggfunc='mean', margins=True)
24. print("\n带总计的部门-绩效平均薪资透视表：\n", pivot_with_margins)

复制代码

交叉表是计算两个（或多个）因素之间频率的特殊透视表：

2. # 创建部门和性别的交叉表
3. cross_dept_gender = pd.crosstab(df['Department'], df['Gender'])
4. print("部门-性别交叉表：\n", cross_dept_gender)
6. # 创建部门和绩效的交叉表，并添加行和列的百分比
7. cross_dept_perf = pd.crosstab(df['Department'], df['Performance'], margins=True)
8. print("\n部门-绩效交叉表（带总计）：\n", cross_dept_perf)
10. # 创建部门和绩效的交叉表，并标准化为行百分比
11. cross_dept_perf_pct = pd.crosstab(df['Department'], df['Performance'], normalize='index')
12. print("\n部门-绩效交叉表（行百分比）：\n", cross_dept_perf_pct)

复制代码

性能优化：提高分组操作效率的技巧

当处理大型数据集时，分组操作可能会变得很慢。以下是一些提高分组操作效率的技巧：

2. # 创建更大的示例数据集
3. import numpy as np
4. np.random.seed(42)
6. n = 1000000  # 100万行数据
7. departments = ['HR', 'IT', 'Finance', 'Marketing', 'Operations']
8. teams = {
9.     'HR': ['Recruitment', 'Training', 'Compensation'],
10.     'IT': ['Development', 'Support', 'Infrastructure'],
11.     'Finance': ['Accounting', 'Investment', 'Analysis'],
12.     'Marketing': ['Digital', 'Content', 'Brand'],
13.     'Operations': ['Logistics', 'Quality', 'Production']
14. }
16. data = {
17.     'Department': np.random.choice(departments, n),
18.     'Team': [np.random.choice(teams[dept]) for dept in np.random.choice(departments, n)],
19.     'Salary': np.random.normal(75000, 15000, n).astype(int),
20.     'Years': np.random.randint(1, 20, n),
21.     'Gender': np.random.choice(['M', 'F'], n),
22.     'Performance': np.random.choice(['Average', 'Good', 'Excellent'], n, p=[0.2, 0.5, 0.3])
23. }
24. large_df = pd.DataFrame(data)
26. # 技巧1：使用category数据类型优化内存使用和性能
27. print("优化前的内存使用：")
28. print(large_df.memory_usage(deep=True))
30. # 将字符串列转换为category类型
31. for col in ['Department', 'Team', 'Gender', 'Performance']:
32.     large_df[col] = large_df[col].astype('category')
34. print("\n优化后的内存使用：")
35. print(large_df.memory_usage(deep=True))
37. # 技巧2：使用更高效的聚合方法
38. import time
40. # 方法1：使用agg
41. start_time = time.time()
42. result1 = large_df.groupby(['Department', 'Team'])['Salary'].agg(['mean', 'std'])
43. time1 = time.time() - start_time
44. print(f"\n使用agg方法的时间：{time1:.4f}秒")
46. # 方法2：使用多个单独的聚合
47. start_time = time.time()
48. result2_mean = large_df.groupby(['Department', 'Team'])['Salary'].mean()
49. result2_std = large_df.groupby(['Department', 'Team'])['Salary'].std()
50. result2 = pd.DataFrame({'mean': result2_mean, 'std': result2_std})
51. time2 = time.time() - start_time
52. print(f"使用多个单独聚合的时间：{time2:.4f}秒")
54. # 技巧3：避免在循环中使用groupby
55. # 不好的方法
56. start_time = time.time()
57. results = []
58. for dept in large_df['Department'].unique():
59.     dept_df = large_df[large_df['Department'] == dept]
60.     for team in dept_df['Team'].unique():
61.         team_df = dept_df[dept_df['Team'] == team]
62.         results.append({
63.             'Department': dept,
64.             'Team': team,
65.             'Avg_Salary': team_df['Salary'].mean()
66.         })
67. result3 = pd.DataFrame(results)
68. time3 = time.time() - start_time
69. print(f"\n在循环中使用groupby的时间：{time3:.4f}秒")
71. # 好的方法
72. start_time = time.time()
73. result4 = large_df.groupby(['Department', 'Team'])['Salary'].mean().reset_index()
74. result4.columns = ['Department', 'Team', 'Avg_Salary']
75. time4 = time.time() - start_time
76. print(f"直接使用groupby的时间：{time4:.4f}秒")
78. # 技巧4：使用numba加速自定义聚合函数
79. from numba import jit
81. @jit(nopython=True)
82. def weighted_mean_numba(values, weights):
83.     total = 0
84.     total_weights = 0
85.     for i in range(len(values)):
86.         total += values[i] * weights[i]
87.         total_weights += weights[i]
88.     return total / total_weights
90. # 创建一个加权平均的函数
91. def weighted_mean(group):
92.     return weighted_mean_numba(group['Salary'].values, group['Years'].values)
94. start_time = time.time()
95. result5 = large_df.groupby(['Department', 'Team']).apply(weighted_mean)
96. time5 = time.time() - start_time
97. print(f"\n使用numba加速的自定义聚合时间：{time5:.4f}秒")

复制代码

实战案例：综合应用分组操作解决实际问题

让我们通过一个综合案例来展示如何应用分组操作解决实际数据分析问题。假设我们是一家公司的数据分析师，需要分析员工数据，找出各部门的薪资分布、绩效差异以及潜在的不平等问题。

2. # 创建更真实的员工数据集
3. np.random.seed(42)
5. n = 5000
6. departments = ['HR', 'IT', 'Finance', 'Marketing', 'Operations', 'Sales', 'R&D']
7. genders = ['M', 'F']
8. education_levels = ['High School', 'Bachelor', 'Master', 'PhD']
10. # 创建数据
11. data = {
12.     'Employee_ID': range(1, n+1),
13.     'Department': np.random.choice(departments, n, p=[0.1, 0.2, 0.15, 0.15, 0.15, 0.15, 0.1]),
14.     'Gender': np.random.choice(genders, n),
15.     'Age': np.random.normal(40, 10, n).astype(int),
16.     'Education': np.random.choice(education_levels, n, p=[0.1, 0.5, 0.3, 0.1]),
17.     'Years_at_Company': np.random.randint(0, 20, n),
18.     'Performance': np.random.choice(['Below Average', 'Average', 'Good', 'Excellent'], n, p=[0.05, 0.2, 0.5, 0.25])
19. }
21. # 根据部门、教育程度、绩效和经验生成薪资
22. base_salaries = {
23.     'HR': 60000,
24.     'IT': 80000,
25.     'Finance': 85000,
26.     'Marketing': 75000,
27.     'Operations': 70000,
28.     'Sales': 65000,
29.     'R&D': 90000
30. }
32. education_bonus = {
33.     'High School': 1.0,
34.     'Bachelor': 1.2,
35.     'Master': 1.4,
36.     'PhD': 1.6
37. }
39. performance_bonus = {
40.     'Below Average': 0.8,
41.     'Average': 1.0,
42.     'Good': 1.2,
43.     'Excellent': 1.5
44. }
46. salaries = []
47. for i in range(n):
48.     dept = data['Department'][i]
49.     edu = data['Education'][i]
50.     perf = data['Performance'][i]
51.     years = data['Years_at_Company'][i]
52.    
53.     # 基础薪资
54.     base = base_salaries[dept]
55.    
56.     # 教育程度加成
57.     edu_factor = education_bonus[edu]
58.    
59.     # 绩效加成
60.     perf_factor = performance_bonus[perf]
61.    
62.     # 经验加成（每年增加2%）
63.     exp_factor = 1 + (years * 0.02)
64.    
65.     # 性别差异（模拟现实中的性别薪资差距）
66.     gender_factor = 1.0 if data['Gender'][i] == 'M' else 0.95
67.    
68.     # 计算最终薪资，添加一些随机性
69.     salary = base * edu_factor * perf_factor * exp_factor * gender_factor * np.random.normal(1.0, 0.05)
70.     salaries.append(int(salary))
72. data['Salary'] = salaries
73. employee_df = pd.DataFrame(data)
75. # 问题1：各部门的平均薪资和薪资范围
76. dept_salary_stats = employee_df.groupby('Department')['Salary'].agg(['mean', 'min', 'max', 'std'])
77. print("各部门薪资统计：\n", dept_salary_stats.sort_values('mean', ascending=False))
79. # 问题2：各部门的性别分布和性别薪资差距
80. gender_dist = employee_df.groupby(['Department', 'Gender']).size().unstack()
81. print("\n各部门性别分布：\n", gender_dist)
83. gender_pay_gap = employee_df.groupby(['Department', 'Gender'])['Salary'].mean().unstack()
84. gender_pay_gap['Gap'] = (gender_pay_gap['M'] - gender_pay_gap['F']) / gender_pay_gap['M'] * 100
85. print("\n各部门性别薪资差距（%）：\n", gender_pay_gap)
87. # 问题3：教育程度对薪资的影响
88. education_salary = employee_df.groupby(['Department', 'Education'])['Salary'].mean().unstack()
89. print("\n各部门不同教育程度的平均薪资：\n", education_salary)
91. # 问题4：绩效与薪资的关系
92. performance_salary = employee_df.groupby(['Department', 'Performance'])['Salary'].mean().unstack()
93. print("\n各部门不同绩效等级的平均薪资：\n", performance_salary)
95. # 问题5：识别潜在的薪资不平等
96. # 计算每个部门内相同教育程度、绩效和工作年限的员工的薪资差异
97. def identify_pay_inequality(group):
98.     # 按教育程度、绩效和工作年限分组
99.     subgroups = group.groupby(['Education', 'Performance', pd.cut(group['Years_at_Company'], bins=[0, 5, 10, 15, 20])])
100.    
101.     # 计算每个子组的薪资标准差
102.     subgroup_std = subgroups['Salary'].std().reset_index()
103.    
104.     # 找出标准差大于平均标准差的子组
105.     high_std_subgroups = subgroup_std[subgroup_std['Salary'] > subgroup_std['Salary'].mean()]
106.    
107.     # 如果有高差异的子组，返回它们
108.     if len(high_std_subgroups) > 0:
109.         return high_std_subgroups.assign(Department=group.name)
110.     else:
111.         return None
113. # 应用函数并合并结果
114. inequality_results = []
115. for dept, group in employee_df.groupby('Department'):
116.     result = identify_pay_inequality(group)
117.     if result is not None:
118.         inequality_results.append(result)
120. if inequality_results:
121.     inequality_df = pd.concat(inequality_results)
122.     print("\n潜在的薪资不平等领域：\n", inequality_df)
123. else:
124.     print("\n未发现明显的薪资不平等。")
126. # 问题6：创建一个综合的部门分析报告
127. def create_department_report(group):
128.     report = {}
129.    
130.     # 基本信息
131.     report['Department'] = group.name
132.     report['Employee_Count'] = len(group)
133.    
134.     # 薪资统计
135.     report['Mean_Salary'] = group['Salary'].mean()
136.     report['Median_Salary'] = group['Salary'].median()
137.     report['Salary_Std'] = group['Salary'].std()
138.     report['Salary_Range'] = group['Salary'].max() - group['Salary'].min()
139.    
140.     # 性别分布
141.     gender_counts = group['Gender'].value_counts()
142.     report['Male_Count'] = gender_counts.get('M', 0)
143.     report['Female_Count'] = gender_counts.get('F', 0)
144.     report['Female_Percentage'] = report['Female_Count'] / report['Employee_Count'] * 100
145.    
146.     # 性别薪资差距
147.     male_salary = group[group['Gender'] == 'M']['Salary'].mean()
148.     female_salary = group[group['Gender'] == 'F']['Salary'].mean()
149.     if male_salary and female_salary:
150.         report['Gender_Pay_Gap'] = (male_salary - female_salary) / male_salary * 100
151.     else:
152.         report['Gender_Pay_Gap'] = None
153.    
154.     # 绩效分布
155.     performance_counts = group['Performance'].value_counts(normalize=True) * 100
156.     for perf in ['Below Average', 'Average', 'Good', 'Excellent']:
157.         report[f'Perf_{perf.replace(" ", "_")}'] = performance_counts.get(perf, 0)
158.    
159.     # 教育程度分布
160.     education_counts = group['Education'].value_counts(normalize=True) * 100
161.     for edu in ['High School', 'Bachelor', 'Master', 'PhD']:
162.         report[f'Edu_{edu.replace(" ", "_")}'] = education_counts.get(edu, 0)
163.    
164.     # 平均工作年限
165.     report['Avg_Years'] = group['Years_at_Company'].mean()
166.    
167.     return pd.Series(report)
169. # 生成报告
170. department_reports = employee_df.groupby('Department').apply(create_department_report)
171. print("\n部门分析报告：\n", department_reports)

复制代码

这个实战案例展示了如何综合应用pandas的分组操作来解决实际的数据分析问题。我们通过分组和聚合分析了各部门的薪资情况、性别分布、教育程度影响、绩效与薪资关系，并识别了潜在的薪资不平等问题。最后，我们创建了一个综合的部门分析报告，提供了各部门的全面概览。

总结与展望

pandas的分组操作是数据分析中不可或缺的工具，它提供了强大而灵活的功能，使我们能够从不同维度审视和分析数据。本文从基础语法到高级应用，全面介绍了pandas中的分组操作，包括：

1. 基础的groupby语法和常用聚合函数
2. 多重分组和分组迭代
3. 自定义聚合函数和转换操作
4. 分组过滤和排序
5. 透视表和交叉表等高级应用
6. 性能优化技巧
7. 实战案例展示

通过掌握这些技术，数据分析师可以更高效地处理和分析数据，发现数据中隐藏的模式和关系，为决策提供有力支持。

展望未来，随着数据量的不断增长和分析需求的日益复杂，pandas的分组操作将继续发展和完善。我们可以期待更多性能优化、更丰富的聚合函数以及与其他数据处理工具（如Dask、Spark）的更好集成。同时，随着机器学习和人工智能在数据分析中的应用越来越广泛，分组操作也将与这些技术更紧密地结合，为数据科学家提供更强大的分析能力。

无论你是数据分析的初学者还是经验丰富的专业人士，掌握pandas的分组操作都将大大提升你的数据处理效率和分析能力。希望本文能成为你学习和应用pandas分组操作的有用指南。

版权声明

1、转载或引用本网站内容(pandas分组输出实战指南从基础语法到高级应用全面解决数据分析中的分组统计与结果展示问题助你提升数据处理效率)须注明原网址及作者(威震华夏关云长)，并标明本网站网址(https://www.pixtech.cc/)。

2、对于不当转载或引用本网站内容而引起的民事纷争、行政处理或其他损失，本网站不承担责任。

3、对不遵守本声明或其他违法、恶意使用本网站内容者，本网站保留追究其法律责任的权利。

本文地址: https://www.pixtech.cc/thread-40940-1-1.html