【数据处理包Pandas】分组及相关操作_pandas filter函数的用法

---

 

准备工作

import numpy as np
import pandas as pd
%matplotlib inline
1
2
3

数据集team.xlsx下载地址：
链接：https://pan.quark.cn/s/9e3b2a933510
提取码：7i2y

df = pd.read_excel("team.xlsx")
df.head()
1
2

# 分组前总体统计情况
df.describe()
1
2

一、初步认识分组并查看分组信息

按team列分组，team列中值相同的记录构成一组，但是不做聚合计算或其他操作，看不到分组结果。

df.groupby('team')
1

df.groupby('team')等价于df.groupby(df['team'])或者df.groupby(df.team)（当列名是字符串时两者等价）。

<pandas.core.groupby.DataFrameGroupBy object at 0x000001BAC3370668>
1

（一）通过聚合函数查看分组信息

df.groupby('team').mean()
1

可见分组信息类似于 DataFrame，但其实它是 DataFrameGroupBy 对象。它以分组字段作为行索引，而列索引则包含所有可以求均值的那些列（name字段不能求均值，被舍弃了）。

tm = df.groupby('team').mean()
tm.plot()
1
2

<matplotlib.axes._subplots.AxesSubplot at 0xba3ba58>
1

查看每组前2条记录：

df.groupby('team').head(2)
1

查看每组后2条记录：

df.groupby('team').tail(2)
1

（二）转换成列表查看所有组的信息

每一组信息形成列表中的一个元组，元组的第一个元素是组名，第2个元素是一个包含数据的 DataFrame。

list(df.groupby('team'))
1

[('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)]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

再通过索引得到第一组的数据：

list(df.groupby('team'))[0][1]
1

此示例中每一组数据的类型都是一个 DataFrame，其他情况下也有可能是 Series。

type(list(df.groupby('team'))[0][1])
1

pandas.core.frame.DataFrame
1

（三）通过循环查看各组的名称和组中的数据信息

也可以通过循环查看各组的名称和组中的数据信息（每个分组其实形成了一个包含组名和组信息的元组，见上面示例）。

for group_name,group_info in df.groupby('team'):
    print(group_name)
    print(group_info.head())
1
2
3

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

（四）通过get_group()方法直接获得一组数据

df.groupby('team').get_group('E').tail()
1

二、分组再认识

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
1

{'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')}
1
2
3
4
5
6
7
8
9
10
11
12
13

三、分组的执行过程

分组的执行过程——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()
1

注意：此时的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)}
1
2

{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班'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

按字典分组：先产生分组字典，再进行分组。

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()
1
2
3
4
5
6
7
8
9
10
11

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()
1
2
3
4

4、按Numpy数组分组

先产生作为分组标准的 Numpy 数组，再进行分组。分组时将df的行索引与 Numpy 数组的索引相匹配。

n = np.array(s)
df.groupby(n).mean()
1
2

试试as_index=False的效果：

df.groupby(n,as_index=False).mean()
1

5、按函数值分组

list(df.groupby(lambda x:x[0]=='Q',axis='columns'))   # axis='columns'等价于axis=1
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])]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

split阶段的几种做法如下：

（1）先分组再选择列最后计算：

推荐此种做法，便于与agg/transform/apply等应用阶段的写法相统一。

print(type(df.groupby('team')[['Q1','Q2']]))  # groupby之后没有做计算还是DataFrameGroupBy对象
df.groupby('team')[['Q1','Q2']].mean()   
1
2

注意：上面的[['Q1','Q2']]不能写成['Q1':'Q2']这种切片形式，要使用切片就得写成.loc[:,'Q1':'Q2']的形式。

（2）先分组再计算最后选择列：

print(type(df.groupby('team').mean()))   # groupby之后做了计算，就变成了DataFrame对象
df.groupby('team').mean()[['Q1','Q2']]
1
2

（3）先选择列再分组最后计算：

当groupby中给出分组键是字符串时，选择的列一定要包含分组键涉及的字段。

df[['team','Q1','Q2']].groupby('team').mean()  
1

与上面一句完全等价，但groupby中给出分组键的不是字符串而是 Series，此时选择列时可以不包含分组键。

df[['Q1','Q2']].groupby(df['team']).mean()   
1

（二）应用阶段：对数据进行必要的处理和变换

分组后，可以对组对象应用多种聚合函数，实现对每组数据的统计计算。所谓聚合，是指任何能够从数组产生标量值的数据转换过程。

常见的聚合函数包括：

注意size与count的区别：前者计数时包含NaN值，而后者计数则不包含NaN值

df.groupby('team').nth(0)   # 返回每组的第1个，注意从0开始,等价于df.groupby('team').first() 
1

df.groupby('team').describe()    # 每组记录数、均值、标准差、最小值、分位数和最大值
1

四、重点学习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函数，直接调用聚合函数
1
2
3

相比于直接调用聚合函数，agg函数更强大之处在于：

（1）允许同时做多种计算

此时agg的参数是列表，计算结果会产生多级的列索引，并且索引名一般用列表中的函数名（或与之相关）。

df.groupby('team').agg([np.max,np.min])  # 结果中的amax表示np.array中的max
1

不想使用自动提供的列名，而希望自定义列名，可以把agg参数中的列表元素改成元组，计算结果同样会产生多级的列索引。
元组的第1个元素是自定义的列名（作为第2级列索引出现），第2个元素是函数名,给出了要对分组后的该列数据所做的运算。

df.groupby('team').agg([('max_test','max'),('min_test',np.min)])
1

agg函数更强大之处在于：

（2）允许同时对不同的列做不同的计算，此时agg的参数是字典

使用rename函数对结果列重命名：

df.groupby('team').agg({'Q1':np.sum,'Q3':np.mean}).rename(columns={'Q1':'sum(Q1)','Q3':'mean(Q3)'})
1

等价的写法：如果不用np为前缀的聚合函数，则要使用字符串。

df.groupby('team').agg({'Q1':'sum','Q3':'mean'}).rename(columns={'Q1':'sum(Q1)','Q3':'mean(Q3)'})
1

agg函数更强大之处在于：

（3）允许自定义函数实现对每组对象进行聚合操作，此时agg的参数是自定义的聚合函数

df.groupby('team').agg(lambda x: x.median()-x.mean())  # 中位数(50%)减去均值
1

注意：
（1）agg函数返回的是一个聚合后的标量值
（2）虽然agg允许调用用户自定义的聚合函数，但如果能用已有的聚合函数，尽量用已有的，因为做过性能优化！

（二）filter函数的用法

filter函数用于对分组进行过滤（类似于SQL中的having子句），返回满足过滤条件的分组中的记录，其参数必须是函数。

注意：当组对象存在多列时，filter的过滤条件要求显式的指定某一列。

df.groupby('team').filter(lambda x: x['Q1'].sum()>1000)
1

（三）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)
1

因为是按列进行的，因此上述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()
1
2
3
4

（四）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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

进一步理解agg：是把返回值作用到每一列上去

grouped = df.groupby('team')
grouped.agg(lambda x:print(x))
1
2

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630

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')
1
2
3
4
5
6

2、apply不应用于分组：DataFrame.apply的使用

apply应用于 DataFrame 时，默认是axis=0，即每次会把 DataFrame 的一列作为一个 Series 对象传递给函数。

https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.apply.html?highlight=apply#pandas.DataFrame.apply

def top2(col,n=5):
    return col.sort_values()[-n:]
df.loc[:,'Q1':'Q4'].apply(top2,n=5)
1
2
3

apply应用于 DataFrame 时，当axis=1时，每次会把 DataFrame 的一行作为一个 Series 对象传递给函数。

df.loc[:,'Q1':'Q4'].apply(top2,n=2,axis=1).head()
1

3、map函数的使用

map函数只能应用到 Series 对象上，对 Series 对象中的每个元素值进行变换。

change_teams = {'A':'1组','B':'2组','C':'3组','D':'4组','E':'5组'}
df['team'].map(change_teams).head(10)
1
2

0    5组
1    3组
2    1组
3    3组
4    4组
5    3组
6    2组
7    1组
8    4组
9    1组
Name: team, dtype: object
1
2
3
4
5
6
7
8
9
10
11

4、applymap函数的使用

applymap函数应用到 DataFrame 对象上，对 DataFrame 对象中的每个元素值进行相同的变换。

df.loc[:,'Q1':'Q4'].applymap(lambda x: str(x)+'$').head()
1