Monodyee

这个屌丝很懒，什么也没留下！

热门标签

[948]Pandas数据分组的函数应用（df.apply()、df.agg()、df.transform()、df.applymap()、df.groupby()）

作者：Monodyee | 2024-03-07 09:23:38

踩

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

输出结果如下所示：

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

性能比较

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出结果如下：

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

注意：当数据量很大时，对于简单的逻辑处理建议方法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))
<class 'pandas.core.series.Series'>
 
>>> df['score_math'].apply('mean')
86.33333333333333
>>> type(df['score_math'].apply(np.mean))
<class 'pandas.core.series.Series'>
 
#逐行求每个学生的平均分
>>> 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))
<class 'pandas.core.series.Series'>
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

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))
<class 'pandas.core.frame.DataFrame'>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

数据聚合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
1
2
3
4
5
6
7
8

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

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

数据转换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
1
2
3
4
5
6
7
8
9
10
11
12
13
14

当应用多个函数时，将返回于原始DataFrame大小不同的DataFrame，返回结果中：

在列索引上第一级别是原始列名
在第二级别上是转换的函数名

>>> df.transform([lambda x:x-x.mean(),lambda x:x/10])
  score_math          score_music
    <lambda> <lambda>    <lambda> <lambda>
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
1
2
3
4
5
6
7
8
9
10
11
12

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

从上述例子可以看出，applymap()操作实际上是对每列的Series对象进行了map()操作

通过以上分析我们可以看到，apply、agg、transform三种方法都可以对分组数据进行函数操作，但也各有特色，总结如下：

apply中自定义函数对每个分组数据单独进行处理，再将结果合并；整个DataFrame的函数输出可以是标量、Series或DataFrame；每个apply语句只能传入一个函数；
agg可以通过字典方式指定特征进行不同的函数操作，每一特征的函数输出必须为标量；
transform不可以通过字典方式指定特征进行不同的函数操作，但函数运算单位也是DataFrame的每一特征，每一特征的函数输出可以是标量或者Series，但标量会被广播。

groupby().apply()

Dataframe在行（axis=0）或列（axis=1）上进行分组，将一个函数应用到各个分组并产生一个新值，然后函数执行结果被合并到最终的结果对象中。

df.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, **kwargs)

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)
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

结果

  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)}
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

分组

df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar','foo', 'bar', 'foo', 'foo'],
                   'B' : ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
                   'C' : np.random.randn(8),
                   'D' : np.random.randn(8)})
print(df)
print('------')
 
print(df.groupby('A'), type(df.groupby('A')))
print('------')
# 直接分组得到一个groupby对象，是一个中间数据，没有进行计算
 
a = df.groupby('A').mean()
b = df.groupby(['A','B']).mean()
c = df.groupby(['A'])['D'].mean()  # 以A分组，算D的平均值
print("-----------------")
print(a,type(a),'\n',a.columns)
print()
print(b,type(b),'\n',b.columns)
print()
print(c,type(c))
# 通过分组后的计算，得到一个新的dataframe
# 默认axis = 0，以行来分组
# 可单个或多个（[]）列分组
#按A列分组求出A，B列的个数
grouped = df.groupby(["A"])
n = grouped.agg({"A": ["count", pd.Series.unique], "B": pd.Series.nunique})
print(n)
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

分组 - 可迭代对象

df = pd.DataFrame({'X' : ['A', 'B', 'A', 'B'], 'Y' : [1, 4, 3, 2]})
print(df)
print(df.groupby('X'), type(df.groupby('X')))
print('-----')
 
print(list(df.groupby('X')), '→ 可迭代对象，直接生成list\n')
print(list(df.groupby('X'))[0], '→ 以元祖形式显示\n')
for n,g in df.groupby('X'):
    print(n)
    print(g)
    print('###')
print('-----')
# n是组名，g是分组后的Dataframe
 
print(df.groupby(['X']).get_group('A'),'\n')
print(df.groupby(['X']).get_group('B'),'\n')
print('-----')
# .get_group()提取分组后的组
 
grouped = df.groupby(['X'])
print(grouped.groups)
print(grouped.groups['A'])  # 也可写：df.groupby('X').groups['A']
print('-----')
# .groups：将分组后的groups转为dict
# 可以字典索引方法来查看groups里的元素
 
sz = grouped.size()
print(sz,type(sz))
print('-----')
# .size()：查看分组后的长度
 
df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar','foo', 'bar', 'foo', 'foo'],
                   'B' : ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
                   'C' : np.random.randn(8),
                   'D' : np.random.randn(8)})
print(df)
print()
print(df.groupby(['A','B']))
print()
grouped = df.groupby(['A','B']).groups
 
print(grouped)
print()
print(grouped[('foo', 'three')])
# 按照两个列进行分组
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

其他轴上的分组

import pandas as pd
import numpy as np
 
df = pd.DataFrame({'data1':np.random.rand(2),
                  'data2':np.random.rand(2),
                  'key1':['a','b'],
                  'key2':['one','two']})
print(df)
print(df.dtypes)
print("-------------")
print(df.groupby(df.dtypes, axis=1))
print('-----')
print(list(df.groupby(df.dtypes, axis=1)))
print()
for n,p in df.groupby(df.dtypes, axis=1):
    print(n)
    print()
    print(p)
    print('##')
# 按照值类型分列
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

通过字典或者Series分组

df = pd.DataFrame(np.arange(16).reshape(4,4),
                  columns = ['a','b','c','d'])
print(df)
print('-----')
 
mapping = {'a':'one','b':'one','c':'two','d':'two','e':'three'}
by_column = df.groupby(mapping, axis = 1)
print(by_column.sum())
print('-----')
# mapping中，a、b列对应的为one，c、d列对应的为two，以字典来分组
 
s = pd.Series(mapping)
print(s,'\n')
print(s.groupby(s).count())
# s中，index中a、b对应的为one，c、d对应的为two，以Series来分组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

通过函数分组

df = pd.DataFrame(np.arange(16).reshape(4,4),
                  columns = ['a','b','c','d'],
                 index = ['abc','bcd','aa','b'])
print(df,'\n')
print(df.groupby(len).sum())
# 按照字母长度分组   
1
2
3
4
5
6

分组计算函数方法

s = pd.Series([1, 2, 3, 10, 20, 30], index = [1, 2, 3, 1, 2, 3])
grouped = s.groupby(level=0)  # 唯一索引用.groupby(level=0)，将同一个index的分为一组
print(grouped)
print(grouped.first(),'→ first：非NaN的第一个值\n')
print(grouped.last(),'→ last：非NaN的最后一个值\n')
print(grouped.sum(),'→ sum：非NaN的和\n')
print(grouped.mean(),'→ mean：非NaN的平均值\n')
print(grouped.median(),'→ median：非NaN的算术中位数\n')
print(grouped.count(),'→ count：非NaN的值\n')
print(grouped.min(),'→ min、max：非NaN的最小值、最大值\n')
print(grouped.std(),'→ std，var：非NaN的标准差和方差\n')
print(grouped.prod(),'→ prod：非NaN的积\n')
print(grouped.size()) # 获取分组后每组的数量
1
2
3
4
5
6
7
8
9
10
11
12
13

多函数计算：agg()

df = pd.DataFrame({'a':[1,1,2,2],
                  'b':np.random.rand(4),
                  'c':np.random.rand(4),
                  'd':np.random.rand(4),})
print(df)
print(df.groupby('a').agg(['mean',np.sum]))
print(df.groupby('a')['b'].agg({'result1':np.mean,
                               'result2':np.sum}))
# 函数写法可以用str，或者np.方法
# 可以通过list，dict传入，当用dict时，key名为columns
1
2
3
4
5
6
7
8
9
10

参考：https://www.cnblogs.com/Cheryol/p/13451562.html
https://www.cnblogs.com/mliu222/p/12003794.html
https://blog.csdn.net/spiral1221/article/details/76152002
https://www.cnblogs.com/feifeifeisir/p/13792217.html

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/204757