[948]Pandas数据分组的函数应用（df.apply()、df.agg()、df.transform()、df.applymap()、df.groupby().apply()）
文章目录
-
-
- apply()
- 数据聚合agg()
- 数据转换transform()
- applymap()
- groupby().apply()
-
将自己定义的或其他库的函数应用于Pandas对象：
apply()：逐行或逐列应用该函数
agg()和transform()：聚合和转换
applymap()：逐元素应用函数
groupby().apply()：聚合之后应用于某个函数
apply()
- 介绍
apply函数是pandas里面所有函数中自由度最高的函数。该函数如下：
DataFrame.apply(func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds)
该函数最有用的是第一个参数，这个参数是函数，相当于C/C++的函数指针。
这个函数需要自己实现，函数的传入参数根据axis来定，比如axis = 1，就会把一行数据作为Series的数据 结构传入给自己实现的函数中，我们在函数中实现对Series不同属性之间的计算，返回一个结果，则apply函数 会自动遍历每一行DataFrame的数据，最后将所有结果组合成一个Series数据结构并返回。
- 样例
import numpy as np
import pandas as pd
if __name__ == '__main__':
f = lambda x : x.max() - x.min()
df = pd.DataFrame(np.random.randn(4, 3), columns=list('bde'), index=['utah', 'ohio', 'texas', 'oregon']) #columns表述列标， index表述行标
print(df)
t1 = df.apply(f) #df.apply(function, axis=0)，默认axis=0，表示将一列数据作为Series的数据结构传入给定的function中
print(t1)
t2 = df.apply(f, axis=1)
print(t2)
输出结果如下所示：
b d e
utah 1.950737 0.318299 0.387724
ohio 1.584464 -0.082965 0.984757
texas 0.477283 -2.774454 -0.532181
oregon -0.851359 -0.654882 1.026698
b 2.802096
d 3.092753
e 1.558879
dtype: float64
utah 1.632438
ohio 1.667428
texas 3.251737
oregon 1.878057
dtype: float64
- 性能比较
import numpy as np
import pandas as pd
def my_test(a, b):
return a + b
if __name__ == '__main__':
df = pd.DataFrame({'a':np.random.randn(6),
'b':['foo', 'bar'] * 3,
'c':np.random.randn(6)})
print(df)
df['value1'] = df.apply(lambda row: my_test(row['a'], row['c']), axis=1)
print(df)
df['vaule2'] = df['a'] + df['c']
print(df)
输出结果如下：
a b c
0 -1.745471 foo 0.723341
1 -0.378998 bar 0.229188
2 -1.468866 foo 0.788046
3 -1.323347 bar 0.323051
4 -1.894372 foo 2.216768
5 -0.649059 bar 0.858149
a b c value1
0 -1.745471 foo 0.723341 -1.022130
1 -0.378998 bar 0.229188 -0.149810
2 -1.468866 foo 0.788046 -0.680820
3 -1.323347 bar 0.323051 -1.000296
4 -1.894372 foo 2.216768 0.322396
5 -0.649059 bar 0.858149 0.209089
a b c value1 vaule2
0 -1.745471 foo 0.723341 -1.022130 -1.022130
1 -0.378998 bar 0.229188 -0.149810 -0.149810
2 -1.468866 foo 0.788046 -0.680820 -0.680820
3 -1.323347 bar 0.323051 -1.000296 -1.000296
4 -1.894372 foo 2.216768 0.322396 0.322396
5 -0.649059 bar 0.858149 0.209089 0.209089
注意：当数据量很大时，对于简单的逻辑处理建议方法2（个人处理几百M数据集时，方法1花时200s左右，方法2花时10s）
其中：设置axis = 1参数，可以逐行进行操作；默认axis=0，即逐列进行操作；
对于常见的描述性统计方法，可以直接使用一个字符串进行代替，例df.apply(‘mean’)等价于df.apply(np.mean)；
>>> df = pd.read_excel('./input/class.xlsx)
>>> df = df[['score_math','score_music']]
>>> df
score_math score_music
0 95 79
1 96 90
2 85 85
3 93 92
4 84 90
5 88 70
6 59 89
7 88 86
8 89 74
#对音乐课和数学课逐列求成绩平均分
>>> df.apply(np.mean)
score_math 86.333333
score_music 83.888889
dtype: float64
>>> type(df.apply(np.mean))
>>> df['score_math'].apply('mean')
86.33333333333333
>>> type(df['score_math'].apply(np.mean))
#逐行求每个学生的平均分
>>> df.apply(np.mean,axis=1)
0 87.0
1 93.0
2 85.0
3 92.5
4 87.0
5 79.0
6 74.0
7 87.0
8 81.5
dtype: float64
>>> type(df.apply(np.mean,axis=1))
apply()的返回结果与所用的函数是相关的：
- 返回结果是Series对象：如上述例子应用的均值函数，就是每一行或每一列返回一个值；
- 返回大小相同的DataFrame：如下面自定的lambda函数。
#其中的x可以看作是每一类的Series对象
>>> df.apply(lambda x: x - 5)
score_math score_music
0 90 74
1 91 85
2 80 80
3 88 87
4 79 85
5 83 65
6 54 84
7 83 81
8 84 69
>>> type(df.apply(lambda x: x - 5))
数据聚合agg()
- 数据聚合agg()指任何能够从数组产生标量值的过程；
- 相当于apply()的特例，可以对pandas对象进行逐行或逐列的处理；
- 能使用agg()的地方，基本上都可以使用apply()代替。
例：
1）对两门课逐列求平均分
>>> df.agg('mean')
score_math 86.333333
score_music 83.888889
dtype: float64
>>> df.apply('mean')
score_math 86.333333
score_music 83.888889
dtype: float64
2）应用多个函数，可将函数放于一个列表中；
例：对两门课分别求最高分与最低分
>>> df.agg(['max','min'])
score_math score_music
max 96 92
min 59 70
>>> df.apply([np.max,'min'])
score_math score_music
amax 96 92
min 59 70
3）使用字典可以对特定列应用特定及多个函数；
例：对数学成绩求均值和最小值，对音乐课求最大值
>>> df.agg({'score_math':['mean','min'],'score_music':'max'})
score_math score_music
max NaN 92.0
mean 86.333333 NaN
min 59.000000 NaN
数据转换transform()
特点：使用一个函数后，返回相同大小的Pandas对象
与数据聚合agg()的区别：
- 数据聚合agg()返回的是对组内全量数据的缩减过程；
- 数据转换transform()返回的是一个新的全量数据。
注意：df.transform(np.mean)将报错，转换是无法产生聚合结果的
#将成绩减去各课程的平均分，使用apply、agg、transfrom都可以实现
>>> df.transform(lambda x:x-x.mean())
>>> df.apply(lambda x:x-x.mean())
>>> df.agg(lambda x:x-x.mean())
score_math score_music
0 8.666667 -4.888889
1 9.666667 6.111111
2 -1.333333 1.111111
3 6.666667 8.111111
4 -2.333333 6.111111
5 1.666667 -13.888889
6 -27.333333 5.111111
7 1.666667 2.111111
8 2.666667 -9.888889
当应用多个函数时，将返回于原始DataFrame大小不同的DataFrame，返回结果中：
- 在列索引上第一级别是原始列名
- 在第二级别上是转换的函数名
>>> df.transform([lambda x:x-x.mean(),lambda x:x/10])
score_math score_music
0 8.666667 9.5 -4.888889 7.9
1 9.666667 9.6 6.111111 9.0
2 -1.333333 8.5 1.111111 8.5
3 6.666667 9.3 8.111111 9.2
4 -2.333333 8.4 6.111111 9.0
5 1.666667 8.8 -13.888889 7.0
6 -27.333333 5.9 5.111111 8.9
7 1.666667 8.8 2.111111 8.6
8 2.666667 8.9 -9.888889 7.4
applymap()
applymap()对pandas对象逐元素应用某个函数，成为元素级函数应用；
与map()的区别：
- applymap()是DataFrame的实例方法
- map()是Series的实例方法
例：对成绩保留小数后两位
>>> df.applymap(lambda x:'%.2f'%x)
score_math score_music
0 95.00 79.00
1 96.00 90.00
2 85.00 85.00
3 93.00 92.00
4 84.00 90.00
5 88.00 70.00
6 59.00 89.00
7 88.00 86.00
8 89.00 74.00
>>> df['score_math'].map(lambda x:'%.2f'%x)
0 95.00
1 96.00
2 85.00
3 93.00
4 84.00
5 88.00
6 59.00
7 88.00
8 89.00
Name: score_math, dtype: object
从上述例子可以看出，applymap()操作实际上是对每列的Series对象进行了map()操作
通过以上分析我们可以看到，apply、agg、transform三种方法都可以对分组数据进行函数操作，但也各有特色，总结如下：
- apply中自定义函数对每个分组数据单独进行处理，再将结果合并；整个DataFrame的函数输出可以是标量、Series或DataFrame；每个apply语句只能传入一个函数；
- agg可以通过字典方式指定特征进行不同的函数操作，每一特征的函数输出必须为标量；
- transform不可以通过字典方式指定特征进行不同的函数操作，但函数运算单位也是DataFrame的每一特征，每一特征的函数输出可以是标量或者Series，但标量会被广播。
groupby().apply()
import numpy as np
import pandas as pd
data = pd.DataFrame({'key1':list('aabba'),
'key2': ['one','two','one','two','one'],
'data1': np.random.randn(5),
'data2': np.random.randn(5)})
def f(group):
group['sum'] = group.data1.sum()
return group
aa = data.groupby(['key1','key2']).apply(f)
print(data)
print('*'*30)
print(aa)
bb = data.groupby(['key1','key2'])['data1'].apply(lambda x:x)
print('*'*30)
print(bb)
cc=data.groupby(['key1','key2']).indices
print('*'*30)
print(cc)
结果
key1 key2 data1 data2
0 a one -1.065003 0.775987
1 a two -0.106187 -0.024468
2 b one 1.079181 -0.499718
3 b two -0.224642 0.213094
4 a one 0.771805 1.877397
******************************
key1 key2 data1 data2 sum
0 a one -1.065003 0.775987 -0.293198
1 a two -0.106187 -0.024468 -0.106187
2 b one 1.079181 -0.499718 1.079181
3 b two -0.224642 0.213094 -0.224642
4 a one 0.771805 1.877397 -0.293198
******************************
0 -1.065003
1 -0.106187
2 1.079181
3 -0.224642
4 0.771805
Name: data1, dtype: float64
******************************
{('a', 'one'): array([0, 4], dtype=int64),
('a', 'two'): array([1], dtype=int64),
('b', 'one'): array([2], dtype=int64),
('b', 'two'): array([3], dtype=int64)}
参考：https://www.cnblogs.com/Cheryol/p/13451562.html
https://www.cnblogs.com/mliu222/p/12003794.html
https://blog.csdn.net/spiral1221/article/details/76152002