目录
准备工作
import numpy as np
import pandas as pd
%matplotlib inline
数据集team.xlsx下载地址：
链接：https://pan.quark.cn/s/9e3b2a933510
提取码：7i2y
df = pd.read_excel("team.xlsx")
df.head()
# 分组前总体统计情况
df.describe()
一、初步认识分组并查看分组信息
按team列分组，team列中值相同的记录构成一组，但是不做聚合计算或其他操作，看不到分组结果。
df.groupby('team')
df.groupby('team')等价于df.groupby(df['team'])或者df.groupby(df.team)（当列名是字符串时两者等价）。
<pandas.core.groupby.DataFrameGroupBy object at 0x000001BAC3370668>
（一）通过聚合函数查看分组信息
df.groupby('team').mean()
可见分组信息类似于 DataFrame，但其实它是 DataFrameGroupBy 对象。它以分组字段作为行索引，而列索引则包含所有可以求均值的那些列（name字段不能求均值，被舍弃了）。
tm = df.groupby('team').mean()
tm.plot()
<matplotlib.axes._subplots.AxesSubplot at 0xba3ba58>
查看每组前2条记录：
df.groupby('team').head(2)
查看每组后2条记录：
df.groupby('team').tail(2)
（二）转换成列表查看所有组的信息
每一组信息形成列表中的一个元组，元组的第一个元素是组名，第2个元素是一个包含数据的 DataFrame。
list(df.groupby('team'))
[('A', name team Q1 Q2 Q3 Q4
2 Ack A 57 60 18 84
7 Lfie A 9 10 99 37
9 Oscar A 77 9 26 67
16 Joshua A 63 4 80 30
17 Henry A 91 15 75 17
20 Lucas A 60 41 77 62
22 Arthur A 44 53 42 40
34 Reggie1 A 30 12 23 9
40 Toby A 52 27 17 68
42 Dylan A 86 87 65 20
51 Hugo0 A 28 25 14 71
67 Caleb A 64 34 46 88
70 Nathan A 87 77 62 13
71 Blake A 78 23 93 9
75 Stanley A 69 71 39 97
79 Tyler A 75 16 44 63
88 Aaron A 96 75 55 8), ('B', name team Q1 Q2 Q3 Q4
6 Acob B 61 95 94 8
10 Leo B 17 4 33 79
11 Logan B 9 89 35 65
14 Thomas B 80 48 56 41
25 Harrison B 89 13 18 75
30 Edward B 57 38 86 87
35 Samuel B 9 38 88 66
38 Elijah B 97 89 15 46
39 Harley B 2 99 12 13
50 Jenson B 66 77 88 74
53 Frankie B 18 62 52 33
56 David B 21 47 99 2
58 Lewis B 4 34 77 28
60 Ronnie B 53 13 34 99
64 Harvey2 B 43 76 87 90
77 Michael B 89 21 59 92
78 Elliott B 9 31 33 60
83 Albert0 B 85 38 41 17
84 Kai B 66 45 13 48
85 Liam B 2 80 24 25
92 Grayson7 B 59 84 74 33
93 Jamie0 B 39 97 84 55), ('C', name team Q1 Q2 Q3 Q4
1 Arry C 36 37 37 57
3 Eorge C 93 96 71 78
5 Harlie C 24 13 87 43
12 Archie C 83 89 59 68
13 Theo C 51 86 87 27
18 William C 80 68 3 26
28 Daniel C 50 50 72 61
32 Alexander C 91 76 26 79
33 Adam C 90 32 47 39
37 Sebastian C 1 14 68 48
46 Tommy C 29 44 28 76
47 Jake3 C 69 23 11 40
54 Ollie3 C 10 76 30 36
62 Matthew C 44 33 41 98
73 Elliot C 15 17 76 22
81 Ellis C 34 34 77 42
86 Calum C 14 91 16 82
87 Louis2 C 13 94 51 22
91 Connor C 62 38 63 46
95 Gabriel C 48 59 87 74
96 Austin7 C 21 31 30 43
97 Lincoln4 C 98 93 1 20), ('D', name team Q1 Q2 Q3 Q4
4 Oah D 65 49 61 86
8 Reddie D 64 93 57 72
21 Ethan D 79 45 89 88
23 Mason D 80 96 26 49
27 Finley D 62 73 84 68
44 Benjamin D 15 88 52 25
48 Louie D 24 84 54 11
49 Carter7 D 57 52 77 50
52 Bobby1 D 50 55 60 59
57 Albie1 D 79 82 56 96
59 Luca D 5 40 91 83
63 Alex D 14 70 55 87
65 Reuben D 70 72 76 56
66 Jayden6 D 64 21 10 21
68 Hunter3 D 38 80 82 40
69 Theodore3 D 43 7 68 80
72 Luke6 D 15 97 95 99
89 Ezra D 16 56 86 61
94 Aiden D 20 31 62 68), ('E', name team Q1 Q2 Q3 Q4
0 Liver E 89 21 24 64
15 James E 48 77 52 11
19 Max E 97 75 41 3
24 Isaac E 74 23 28 65
26 Teddy E 71 91 21 48
29 Riley E 35 26 59 83
31 Joseph E 67 87 87 93
36 Jaxon E 88 98 19 98
41 Arlo8 E 48 34 52 51
43 Jude E 8 45 13 65
45 Rory9 E 8 12 58 27
55 Zachary E 12 71 85 93
61 Jackson5 E 6 10 15 33
74 Roman E 73 1 25 44
76 Dexter E 73 94 53 20
80 Ryan E 92 70 64 31
82 Finn E 4 1 55 32
90 Leon E 38 60 31 7
98 Eli E 11 74 58 91
99 Ben E 21 43 41 74)]
再通过索引得到第一组的数据：
list(df.groupby('team'))[0][1]
此示例中每一组数据的类型都是一个 DataFrame，其他情况下也有可能是 Series。
type(list(df.groupby('team'))[0][1])
pandas.core.frame.DataFrame
（三）通过循环查看各组的名称和组中的数据信息
也可以通过循环查看各组的名称和组中的数据信息（每个分组其实形成了一个包含组名和组信息的元组，见上面示例）。
for group_name,group_info in df.groupby('team'):
print(group_name)
print(group_info.head())
A
name team Q1 Q2 Q3 Q4
2 Ack A 57 60 18 84
7 Lfie A 9 10 99 37
9 Oscar A 77 9 26 67
16 Joshua A 63 4 80 30
17 Henry A 91 15 75 17
B
name team Q1 Q2 Q3 Q4
6 Acob B 61 95 94 8
10 Leo B 17 4 33 79
11 Logan B 9 89 35 65
14 Thomas B 80 48 56 41
25 Harrison B 89 13 18 75
C
name team Q1 Q2 Q3 Q4
1 Arry C 36 37 37 57
3 Eorge C 93 96 71 78
5 Harlie C 24 13 87 43
12 Archie C 83 89 59 68
13 Theo C 51 86 87 27
D
name team Q1 Q2 Q3 Q4
4 Oah D 65 49 61 86
8 Reddie D 64 93 57 72
21 Ethan D 79 45 89 88
23 Mason D 80 96 26 49
27 Finley D 62 73 84 68
E
name team Q1 Q2 Q3 Q4
0 Liver E 89 21 24 64
15 James E 48 77 52 11
19 Max E 97 75 41 3
24 Isaac E 74 23 28 65
26 Teddy E 71 91 21 48
（四）通过get_group()方法直接获得一组数据
df.groupby('team').get_group('E').tail()
二、分组再认识
The abstract definition of grouping is to provide a mapping of labels to group names
from: https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html
分组本质上提供了标签（行索引）到组名的一个映射， 利用groups属性可以看到这种多对一的映射关系。
df.groupby('team').groups
{'A': Int64Index([2, 7, 9, 16, 17, 20, 22, 34, 40, 42, 51, 67, 70, 71, 75, 79, 88], dtype='int64'),
'B': Int64Index([ 6, 10, 11, 14, 25, 30, 35, 38, 39, 50, 53, 56, 58, 60, 64, 77, 78,
83, 84, 85, 92, 93],
dtype='int64'),
'C': Int64Index([ 1, 3, 5, 12, 13, 18, 28, 32, 33, 37, 46, 47, 54, 62, 73, 81, 86,
87, 91, 95, 96, 97],
dtype='int64'),
'D': Int64Index([4, 8, 21, 23, 27, 44, 48, 49, 52, 57, 59, 63, 65, 66, 68, 69, 72,
89, 94],
dtype='int64'),
'E': Int64Index([0, 15, 19, 24, 26, 29, 31, 36, 41, 43, 45, 55, 61, 74, 76, 80, 82,
90, 98, 99],
dtype='int64')}
三、分组的执行过程
分组的执行过程——Group by: split-apply-combine
- split：按照某一原则（groupby字段）进行拆分，相同属性分为一组
- apply：对拆分后的各组执行相应的转换操作
- combine：输出汇总转换后的各组结果
图片来源：Pandas之超好用的Groupby用法详解(https://zhuanlan.zhihu.com/p/101284491?utm_source=wechat_session)
使用的重点在于 split 和 apply
（一）split阶段：创建分组的常见形式
groupby方法的原型：
DataFrame.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=<object object>, observed=False, dropna=True)
- by：指定分组标准，可以是字符串、字符串列表、字典或者 Series、Numpy 数组或函数
- axis：指定分组方向是按行分组还是按列分组，默认是按行分组（对记录分组）
- level：在包含多级索引的 DataFrame 分组时，用于指定使用哪一级索引进行分组
- as_index：是否把分组键（就是分组的标准）作为分组后的组索引，默认为
True - sort：分组后是否按分组键的顺序对分组结果进行排序，默认为
True - group_keys：在应用阶段（apply）是否把分组键加入到索引中，默认为
True - dropna：在分组时是否把键值为 NA 的行或列丢弃，默认为
True
1、按字符串列表分组
按团队和姓名首字母分组，会产生多级索引。
df.groupby(['team',df['name'].str[0]]).mean()
注意：此时的df['name']不能简化成'name'，但可以写成df.name。
2、字典作为分组的标准
假设把上述 Excel 记录看成是学生信息，其中0至9号学生属于1班，20至39号属于2班…同一班的学生可以属于不同的team。下面首先通过字典推导式建立1班对应的字典。
i = 0
{j:str(i+1)+'班' for j in range(i*20,(i+1)*20)}
{0: '1班',
1: '1班',
2: '1班',
3: '1班',
4: '1班',
5: '1班',
6: '1班',
7: '1班',
8: '1班',
9: '1班',
10: '1班',
11: '1班',
12: '1班',
13: '1班',
14: '1班',
15: '1班',
16: '1班',
17: '1班',
18: '1班',
19: '1班'}
按字典分组：先产生分组字典，再进行分组。
g = []
# 以连续的20条记录的索引为键值对应一个班，产生一个包含5个班的列表，每个班对应一个字典
for i in range(5):
g.append({j:str(i+1)+'班' for j in range(i*20,(i+1)*20)})
# 将列表中的5个字典合并成一个大字典
d = {}
for i in range(5):
d.update(g[i])
# print(d)
# 用这个大字典进行分组，每一条记录的行索引通过字典的键映射到相应的组
df.groupby(d).mean()
3、按Series分组
先产生作为分组标准的 Series 对象，再进行分组。
s = pd.Series(index=np.arange(100))
for i in range(5):
s[i*20:(i+1)*20]=str(i+1)+'班'
df.groupby(s).mean()
4、按Numpy数组分组
先产生作为分组标准的 Numpy 数组，再进行分组。分组时将df的行索引与 Numpy 数组的索引相匹配。
n = np.array(s)
df.groupby(n).mean()
试试as_index=False的效果：
df.groupby(n,as_index=False).mean()
5、按函数值分组
list(df.groupby(lambda x:x[0]=='Q',axis='columns')) # axis='columns'等价于axis=1
[(False, name team
0 Liver E
1 Arry C
2 Ack A
3 Eorge C
4 Oah D
5 Harlie C
6 Acob B
7 Lfie A
8 Reddie D
9 Oscar A
10 Leo B
11 Logan B
12 Archie C
13 Theo C
14 Thomas B
15 James E
16 Joshua A
17 Henry A
18 William C
19 Max E
20 Lucas A
21 Ethan D
22 Arthur A
23 Mason D
24 Isaac E
25 Harrison B
26 Teddy E
27 Finley D
28 Daniel C
29 Riley E
.. ... ...
70 Nathan A
71 Blake A
72 Luke6 D
73 Elliot C
74 Roman E
75 Stanley A
76 Dexter E
77 Michael B
78 Elliott B
79 Tyler A
80 Ryan E
81 Ellis C
82 Finn E
83 Albert0 B
84 Kai B
85 Liam B
86 Calum C
87 Louis2 C
88 Aaron A
89 Ezra D
90 Leon E
91 Connor C
92 Grayson7 B
93 Jamie0 B
94 Aiden D
95 Gabriel C
96 Austin7 C
97 Lincoln4 C
98 Eli E
99 Ben E
[100 rows x 2 columns]), (True, Q1 Q2 Q3 Q4
0 89 21 24 64
1 36 37 37 57
2 57 60 18 84
3 93 96 71 78
4 65 49 61 86
5 24 13 87 43
6 61 95 94 8
7 9 10 99 37
8 64 93 57 72
9 77 9 26 67
10 17 4 33 79
11 9 89 35 65
12 83 89 59 68
13 51 86 87 27
14 80 48 56 41
15 48 77 52 11
16 63 4 80 30
17 91 15 75 17
18 80 68 3 26
19 97 75 41 3
20 60 41 77 62
21 79 45 89 88
22 44 53 42 40
23 80 96 26 49
24 74 23 28 65
25 89 13 18 75
26 71 91 21 48
27 62 73 84 68
28 50 50 72 61
29 35 26 59 83
.. .. .. .. ..
70 87 77 62 13
71 78 23 93 9
72 15 97 95 99
73 15 17 76 22
74 73 1 25 44
75 69 71 39 97
76 73 94 53 20
77 89 21 59 92
78 9 31 33 60
79 75 16 44 63
80 92 70 64 31
81 34 34 77 42
82 4 1 55 32
83 85 38 41 17
84 66 45 13 48
85 2 80 24 25
86 14 91 16 82
87 13 94 51 22
88 96 75 55 8
89 16 56 86 61
90 38 60 31 7
91 62 38 63 46
92 59 84 74 33
93 39 97 84 55
94 20 31 62 68
95 48 59 87 74
96 21 31 30 43
97 98 93 1 20
98 11 74 58 91
99 21 43 41 74
[100 rows x 4 columns])]
split阶段的几种做法如下：
（1）先分组再选择列最后计算：
推荐此种做法，便于与agg/transform/apply等应用阶段的写法相统一。
print(type(df.groupby('team')[['Q1','Q2']])) # groupby之后没有做计算还是DataFrameGroupBy对象
df.groupby('team')[['Q1','Q2']].mean()
注意：上面的[['Q1','Q2']]不能写成['Q1':'Q2']这种切片形式，要使用切片就得写成.loc[:,'Q1':'Q2']的形式。
（2）先分组再计算最后选择列：
print(type(df.groupby('team').mean())) # groupby之后做了计算，就变成了DataFrame对象
df.groupby('team').mean()[['Q1','Q2']]
（3）先选择列再分组最后计算：
当groupby中给出分组键是字符串时，选择的列一定要包含分组键涉及的字段。
df[['team','Q1','Q2']].groupby('team').mean()
与上面一句完全等价，但groupby中给出分组键的不是字符串而是 Series，此时选择列时可以不包含分组键。
df[['Q1','Q2']].groupby(df['team']).mean()
（二）应用阶段：对数据进行必要的处理和变换
分组后，可以对组对象应用多种聚合函数，实现对每组数据的统计计算。所谓聚合，是指任何能够从数组产生标量值的数据转换过程。
常见的聚合函数包括：
注意size与count的区别：前者计数时包含NaN值，而后者计数则不包含NaN值
df.groupby('team').nth(0) # 返回每组的第1个，注意从0开始,等价于df.groupby('team').first()
df.groupby('team').describe() # 每组记录数、均值、标准差、最小值、分位数和最大值
四、重点学习agg、filter、transform和apply函数的使用
（一）agg函数的用法
agg（等价于aggregation）函数的用法：对各组应用特定的聚合函数
以下三种写法等价：
df.groupby('team').agg(np.mean) # 调用np.mean()函数，相当于每组记录看成一个Numpy数组，agg对数组应用特定的函数
# df.groupby('team').agg('mean') # 使用字符串
# df.groupby('team').mean() # 不使用agg函数，直接调用聚合函数
相比于直接调用聚合函数，agg函数更强大之处在于：
（1）允许同时做多种计算
此时agg的参数是列表，计算结果会产生多级的列索引，并且索引名一般用列表中的函数名（或与之相关）。
df.groupby('team').agg([np.max,np.min]) # 结果中的amax表示np.array中的max
不想使用自动提供的列名，而希望自定义列名，可以把agg参数中的列表元素改成元组，计算结果同样会产生多级的列索引。
元组的第1个元素是自定义的列名（作为第2级列索引出现），第2个元素是函数名,给出了要对分组后的该列数据所做的运算。
df.groupby('team').agg([('max_test','max'),('min_test',np.min)])
agg函数更强大之处在于：
（2）允许同时对不同的列做不同的计算，此时agg的参数是字典
使用rename函数对结果列重命名：
df.groupby('team').agg({'Q1':np.sum,'Q3':np.mean}).rename(columns={'Q1':'sum(Q1)','Q3':'mean(Q3)'})
等价的写法：如果不用np为前缀的聚合函数，则要使用字符串。
df.groupby('team').agg({'Q1':'sum','Q3':'mean'}).rename(columns={'Q1':'sum(Q1)','Q3':'mean(Q3)'})
agg函数更强大之处在于：
（3）允许自定义函数实现对每组对象进行聚合操作，此时agg的参数是自定义的聚合函数
df.groupby('team').agg(lambda x: x.median()-x.mean()) # 中位数(50%)减去均值
注意：
（1）agg函数返回的是一个聚合后的标量值
（2）虽然agg允许调用用户自定义的聚合函数，但如果能用已有的聚合函数，尽量用已有的，因为做过性能优化！
（二）filter函数的用法
filter函数用于对分组进行过滤（类似于SQL中的having子句），返回满足过滤条件的分组中的记录，其参数必须是函数。
注意：当组对象存在多列时，filter的过滤条件要求显式的指定某一列。
df.groupby('team').filter(lambda x: x['Q1'].sum()>1000)
（三）transform函数的用法
transform函数的作用可以概括为：基于所属组的统计信息对组中的每条记录进行变换，其参数也要求是函数
参考：https://zhuanlan.zhihu.com/p/101284491
transform函数常用于分组进行数据标准化以及缺失值填充
参考：https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html
transform执行时是对分组块（Excel 筛选功能可以更直观看到每个分组块）逐列进行的，返回的结果与分组块的大小相同
df.groupby('team').transform(lambda x: x.mean()).head(10)
因为是按列进行的，因此上述lambda函数的参数x应该理解为表示分组块的每一列，所以函数体中不应该再出现列名。
示例：假设原始数据表示每人四个季度的奖金情况，要求依据每组Q4均值的1.2倍设置每人的年终奖金。
df['reward']=df.groupby('team')['Q4'].transform(lambda x: 1.2*x.mean())
# 注意不能写成下面的形式，不允许列名出现在函数体内部
# df['reward']=df.groupby('team').transform(lambda x: 1.2*x['Q4'].mean())
df.head()
（四）apply函数的用法
1、apply应用于分组：GroupBy.apply的使用
apply函数的功能更为强大，它也要求参数是函数。分组后应用apply函数，其实是在 split 得到的每一个 DataFrame 对象上应用指定的函数（分组是先 split 再 apply）。
示例：要求计算下半年比上半年增加的量，返回值是一个 Series。
# 做法1：
# grouped = df.groupby('team')
# delta = grouped.apply(lambda x:x['Q3'].sum()+x['Q4'].sum()-x['Q1'].sum()-x['Q2'].sum())
# 做法2：使用apply一次处理一条分组后的记录（是一个Series对象）
grouped = df.loc[:,'Q1':'Q4'].groupby(df['team']).sum() # grouped已经是一个DataFrameGroupBy对象
delta = grouped.apply(lambda x:x['Q3']+x['Q4']-x['Q1']-x['Q2'],axis=1) # axis=1表明一次传入的是一条行记录
# 做法3：使用pipe函数把lambda函数应用到整个组对象上（Apply function to the full GroupBy object instead of to each group）
# grouped = df.loc[:,'team':'Q4'].groupby('team').sum() # grouped已经是一个DataFrameGroupBy对象
# delta = grouped.pipe(lambda x:x['Q3']+x['Q4']-x['Q1']-x['Q2'])
# grouped.reset_index().concat(delta)
# grouped.agg(lambda x:x['Q3'].sum()+x['Q4'].sum()-x['Q1'].sum()-x['Q2'].sum())
# 对比：如果不用apply而使用agg,看看是什么结果
# grouped = df.groupby('team')
# delta = grouped.agg(lambda x:x['Q3'].sum()+x['Q4'].sum()-x['Q1'].sum()-x['Q2'].sum())
delta.name = 'delta' # 设置Series对象的name，之后与DataFrame拼接就可以变成列名了
pd.concat([grouped,delta],axis=1)
进一步理解agg：是把返回值作用到每一列上去
grouped = df.groupby('team')
grouped.agg(lambda x:print(x))
2 Ack
7 Lfie
9 Oscar
16 Joshua
17 Henry
20 Lucas
22 Arthur
34 Reggie1
40 Toby
42 Dylan
51 Hugo0
67 Caleb
70 Nathan
71 Blake
75 Stanley
79 Tyler
88 Aaron
Name: name, dtype: object
6 Acob
10 Leo
11 Logan
14 Thomas
25 Harrison
30 Edward
35 Samuel
38 Elijah
39 Harley
50 Jenson
53 Frankie
56 David
58 Lewis
60 Ronnie
64 Harvey2
77 Michael
78 Elliott
83 Albert0
84 Kai
85 Liam
92 Grayson7
93 Jamie0
Name: name, dtype: object
1 Arry
3 Eorge
5 Harlie
12 Archie
13 Theo
18 William
28 Daniel
32 Alexander
33 Adam
37 Sebastian
46 Tommy
47 Jake3
54 Ollie3
62 Matthew
73 Elliot
81 Ellis
86 Calum
87 Louis2
91 Connor
95 Gabriel
96 Austin7
97 Lincoln4
Name: name, dtype: object
4 Oah
8 Reddie
21 Ethan
23 Mason
27 Finley
44 Benjamin
48 Louie
49 Carter7
52 Bobby1
57 Albie1
59 Luca
63 Alex
65 Reuben
66 Jayden6
68 Hunter3
69 Theodore3
72 Luke6
89 Ezra
94 Aiden
Name: name, dtype: object
0 Liver
15 James
19 Max
24 Isaac
26 Teddy
29 Riley
31 Joseph
36 Jaxon
41 Arlo8
43 Jude
45 Rory9
55 Zachary
61 Jackson5
74 Roman
76 Dexter
80 Ryan
82 Finn
90 Leon
98 Eli
99 Ben
Name: name, dtype: object
2 57
7 9
9 77
16 63
17 91
20 60
22 44
34 30
40 52
42 86
51 28
67 64
70 87
71 78
75 69
79 75
88 96
Name: Q1, dtype: int64
6 61
10 17
11 9
14 80
25 89
30 57
35 9
38 97
39 2
50 66
53 18
56 21
58 4
60 53
64 43
77 89
78 9
83 85
84 66
85 2
92 59
93 39
Name: Q1, dtype: int64
1 36
3 93
5 24
12 83
13 51
18 80
28 50
32 91
33 90
37 1
46 29
47 69
54 10
62 44
73 15
81 34
86 14
87 13
91 62
95 48
96 21
97 98
Name: Q1, dtype: int64
4 65
8 64
21 79
23 80
27 62
44 15
48 24
49 57
52 50
57 79
59 5
63 14
65 70
66 64
68 38
69 43
72 15
89 16
94 20
Name: Q1, dtype: int64
0 89
15 48
19 97
24 74
26 71
29 35
31 67
36 88
41 48
43 8
45 8
55 12
61 6
74 73
76 73
80 92
82 4
90 38
98 11
99 21
Name: Q1, dtype: int64
2 60
7 10
9 9
16 4
17 15
20 41
22 53
34 12
40 27
42 87
51 25
67 34
70 77
71 23
75 71
79 16
88 75
Name: Q2, dtype: int64
6 95
10 4
11 89
14 48
25 13
30 38
35 38
38 89
39 99
50 77
53 62
56 47
58 34
60 13
64 76
77 21
78 31
83 38
84 45
85 80
92 84
93 97
Name: Q2, dtype: int64
1 37
3 96
5 13
12 89
13 86
18 68
28 50
32 76
33 32
37 14
46 44
47 23
54 76
62 33
73 17
81 34
86 91
87 94
91 38
95 59
96 31
97 93
Name: Q2, dtype: int64
4 49
8 93
21 45
23 96
27 73
44 88
48 84
49 52
52 55
57 82
59 40
63 70
65 72
66 21
68 80
69 7
72 97
89 56
94 31
Name: Q2, dtype: int64
0 21
15 77
19 75
24 23
26 91
29 26
31 87
36 98
41 34
43 45
45 12
55 71
61 10
74 1
76 94
80 70
82 1
90 60
98 74
99 43
Name: Q2, dtype: int64
2 18
7 99
9 26
16 80
17 75
20 77
22 42
34 23
40 17
42 65
51 14
67 46
70 62
71 93
75 39
79 44
88 55
Name: Q3, dtype: int64
6 94
10 33
11 35
14 56
25 18
30 86
35 88
38 15
39 12
50 88
53 52
56 99
58 77
60 34
64 87
77 59
78 33
83 41
84 13
85 24
92 74
93 84
Name: Q3, dtype: int64
1 37
3 71
5 87
12 59
13 87
18 3
28 72
32 26
33 47
37 68
46 28
47 11
54 30
62 41
73 76
81 77
86 16
87 51
91 63
95 87
96 30
97 1
Name: Q3, dtype: int64
4 61
8 57
21 89
23 26
27 84
44 52
48 54
49 77
52 60
57 56
59 91
63 55
65 76
66 10
68 82
69 68
72 95
89 86
94 62
Name: Q3, dtype: int64
0 24
15 52
19 41
24 28
26 21
29 59
31 87
36 19
41 52
43 13
45 58
55 85
61 15
74 25
76 53
80 64
82 55
90 31
98 58
99 41
Name: Q3, dtype: int64
2 84
7 37
9 67
16 30
17 17
20 62
22 40
34 9
40 68
42 20
51 71
67 88
70 13
71 9
75 97
79 63
88 8
Name: Q4, dtype: int64
6 8
10 79
11 65
14 41
25 75
30 87
35 66
38 46
39 13
50 74
53 33
56 2
58 28
60 99
64 90
77 92
78 60
83 17
84 48
85 25
92 33
93 55
Name: Q4, dtype: int64
1 57
3 78
5 43
12 68
13 27
18 26
28 61
32 79
33 39
37 48
46 76
47 40
54 36
62 98
73 22
81 42
86 82
87 22
91 46
95 74
96 43
97 20
Name: Q4, dtype: int64
4 86
8 72
21 88
23 49
27 68
44 25
48 11
49 50
52 59
57 96
59 83
63 87
65 56
66 21
68 40
69 80
72 99
89 61
94 68
Name: Q4, dtype: int64
0 64
15 11
19 3
24 65
26 48
29 83
31 93
36 98
41 51
43 65
45 27
55 93
61 33
74 44
76 20
80 31
82 32
90 7
98 91
99 74
Name: Q4, dtype: int64
2 55.270588
7 55.270588
9 55.270588
16 55.270588
17 55.270588
20 55.270588
22 55.270588
34 55.270588
40 55.270588
42 55.270588
51 55.270588
67 55.270588
70 55.270588
71 55.270588
75 55.270588
79 55.270588
88 55.270588
Name: reward, dtype: float64
6 61.963636
10 61.963636
11 61.963636
14 61.963636
25 61.963636
30 61.963636
35 61.963636
38 61.963636
39 61.963636
50 61.963636
53 61.963636
56 61.963636
58 61.963636
60 61.963636
64 61.963636
77 61.963636
78 61.963636
83 61.963636
84 61.963636
85 61.963636
92 61.963636
93 61.963636
Name: reward, dtype: float64
1 61.472727
3 61.472727
5 61.472727
12 61.472727
13 61.472727
18 61.472727
28 61.472727
32 61.472727
33 61.472727
37 61.472727
46 61.472727
47 61.472727
54 61.472727
62 61.472727
73 61.472727
81 61.472727
86 61.472727
87 61.472727
91 61.472727
95 61.472727
96 61.472727
97 61.472727
Name: reward, dtype: float64
4 75.726316
8 75.726316
21 75.726316
23 75.726316
27 75.726316
44 75.726316
48 75.726316
49 75.726316
52 75.726316
57 75.726316
59 75.726316
63 75.726316
65 75.726316
66 75.726316
68 75.726316
69 75.726316
72 75.726316
89 75.726316
94 75.726316
Name: reward, dtype: float64
0 61.98
15 61.98
19 61.98
24 61.98
26 61.98
29 61.98
31 61.98
36 61.98
41 61.98
43 61.98
45 61.98
55 61.98
61 61.98
74 61.98
76 61.98
80 61.98
82 61.98
90 61.98
98 61.98
99 61.98
Name: reward, dtype: float64
apply的一个经典应用，在调用函数的同时还可以给它传递参数（agg也可以通过args给函数传参数）
示例：求每一组特定列的前几名
排序操作不是聚合，聚合是返回1个标量，排序会返回多个值，因此只能用apply而不能用agg。
def top(df,n=5,column=None):
if not column:
column=df.columns[0]
return df.sort_values(by=column)[-n:]
# top(df,n=6,column='Q1')
df.groupby('team').apply(top,n=5,column='Q1')
2、apply不应用于分组：DataFrame.apply的使用
apply应用于 DataFrame 时，默认是axis=0，即每次会把 DataFrame 的一列作为一个 Series 对象传递给函数。
def top2(col,n=5):
return col.sort_values()[-n:]
df.loc[:,'Q1':'Q4'].apply(top2,n=5)
apply应用于 DataFrame 时，当axis=1时，每次会把 DataFrame 的一行作为一个 Series 对象传递给函数。
df.loc[:,'Q1':'Q4'].apply(top2,n=2,axis=1).head()
3、map函数的使用
map函数只能应用到 Series 对象上，对 Series 对象中的每个元素值进行变换。
change_teams = {'A':'1组','B':'2组','C':'3组','D':'4组','E':'5组'}
df['team'].map(change_teams).head(10)
0 5组
1 3组
2 1组
3 3组
4 4组
5 3组
6 2组
7 1组
8 4组
9 1组
Name: team, dtype: object
4、applymap函数的使用
applymap函数应用到 DataFrame 对象上，对 DataFrame 对象中的每个元素值进行相同的变换。
df.loc[:,'Q1':'Q4'].applymap(lambda x: str(x)+'$').head()
3586
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
