---

使用内置统计方法聚合数据

实现数据拆分成组并分别计算平均数的操作

代码：

import pandas as pd
import numpy as npdf = pd.DataFrame({'key1': ['A', 'A', 'B', 'B', 'A'],'key2': ['one', 'two', 'one', 'two', 'one'],'data1': [2, 3, 4, 6, 8],'data2': [3, 5, np.nan, 3, 7]})
print(df.groupby('key1').mean())

输出结果：

         data1  data2
key1                 
A     4.333333    5.0
B     5.000000    3.0

可以看到的是，如果参与运算的数据中有NaN值，会自动将这些NaN值过滤掉

---

面向列的聚合方法

当内置方法无法满足聚合要求时，可以自定义一个函数，将它传给agg()方法（pandas 0.20版本后，aggregate()方法与agg()方法用法一样）。

aggregate()方法

aggregate(self, func=None, *args, **kwargs)

上述方法中部分参数表示的含义如下：

1. func：表示用于汇总数据的函数，可以为单个函数或函数列表
2. axis：表示函数作用于轴的方向，0或1，index或columns

通过aggregate()方法进行聚合时，func参数既可以接受Pandas中的内置方法，也可以接受自定义的函数，同时，这些方法与函数可以作用于每一列，也可以将多个函数或方法作用于同一列，还可以将不同函数或方法作用于不同的列。

---

对每一列数据应用同一个函数

创建测试对象：

df1 = DataFrame(np.arange(36).reshape(6, 6),columns=list('abcdef'))
df1['key'] = Series(list('aaabbb'), name='key')
print(df1)

输出结果：

 a   b   c   d   e   f key
0   0   1   2   3   4   5   a
1   6   7   8   9  10  11   a
2  12  13  14  15  16  17   a
3  18  19  20  21  22  23   b
4  24  25  26  27  28  29   b
5  30  31  32  33  34  35   b

---

接下来对测试对象以“key“列为分组键进行拆分，并通过字典的形式分别打印出每个分组的具体内容。

进行拆分

df1_group = df1.groupby(by='key')
print(dict([i for i in df1_group])['a'])
print(dict([i for i in df1_group])['b'])

输出结果：

 a   b   c   d   e   f key
0   0   1   2   3   4   5   a
1   6   7   8   9  10  11   a
2  12  13  14  15  16  17   aa   b   c   d   e   f key
3  18  19  20  21  22  23   b
4  24  25  26  27  28  29   b
5  30  31  32  33  34  35   b

上述过程中，先调用groupby()方法，按key一列的数据将df1对象进行分为a、b两组，然后使用列表推导式（[i for i in df1_group]）遍历分组对象df1_group，得到每个分组的列表，之后将装有分组的列表强转换为字典，其中字典中的键为a和b，字典的值分别为分组的具体内容。之后通过“字典[组名]”的形式，分别查看a、b组数据。

---

当然也可以用for循环直接两组一起输出

for i in df1_group:print(i)

输出结果

('a',     a   b   c   d   e   f key
0   0   1   2   3   4   5   a
1   6   7   8   9  10  11   a
2  12  13  14  15  16  17   a)
('b',     a   b   c   d   e   f key
3  18  19  20  21  22  23   b
4  24  25  26  27  28  29   b
5  30  31  32  33  34  35   b)

---

---

接下来，对每个分组的数据进行聚合运算。

调用内置的求和方法sum()：

print("sum:\n", df1_group.aggregate(sum))

输出结果：

sum:a   b   c   d   e   f
key                        
a    18  21  24  27  30  33
b    72  75  78  81  84  87

自定义一个实现求极差值（极差值 = 最大值 - 最小值）的函数，然后将其作为参数传入aggregate()方法中：

def range_df1_group(arr):return arr.max() - arr.min()print("极差值:\n", df1_group.aggregate(range_df1_group))

输出结果：

极差值:a   b   c   d   e   f
key                        
a    12  12  12  12  12  12
b    12  12  12  12  12  12

---

对某列数据应用不同的函数

如今要求不仅要求出每组数据的极差，还要计算出每组数据的和。这是可将两个函数的名称放在列表中，之后在调用aggregate()方法聚合时作为参数传入即可。

代码实现：

print("sum and 极差值:\n", df1_group.aggregate(func=[sum, range_df1_group]))

输出结果：

sum and 极差值:a                   b  ...               e   f                sum range_df1_group sum  ... range_df1_group sum range_df1_group
key                          ...                                    
a    18              12  21  ...              12  33              12
b    72              12  75  ...              12  87              12[2 rows x 12 columns]

从输出结果可以看出，生成的DataFrame对象具有两层索引，每个外层列索引包含两个内层列索引，分别以函数的名称range_df1_group和sum命名。

虽然每一列可以应用不同的函数，但是结果并不能很直观地辨别出每个函数代表的意义。为了更好地反映出每列对应地数据的信息， 可以使用“(name，function)”元组将function（函数名）替换为name（自定义名称）。

代码实现：

print("极差值 and sum:\n", 
df1_group.aggregate([("极差", range_df1_group), ("和", sum)]))

输出结果：

极差值 and sum:a       b       c       d       e       f    极差   和  极差   和  极差   和  极差   和  极差   和  极差   和
key                                                
a    12  18  12  21  12  24  12  27  12  30  12  33
b    12  72  12  75  12  78  12  81  12  84  12  87

区别其实就是不会出现列名过长导致的无法显示全的问题了

---

对不同列数据应用不同函数

如果希望实现对不同列数据应用不同函数，咋可以在aggregate()方法中传入一个{“列名”：“函数名”}格式的字典。

代码实现：

print("综合:\n", 
df1_group.aggregate({'a': 'sum', 'b': range_df1_group, 'c': 'mean'})

输出结果：

综合:a   b   c
key            
a    18  12   8
b    72  12  26

上例中，使用不同的函数对每个分组执行聚合运算，其中a列执行求和运算，b列执行求极差计算，c列执行求平均值计算。自定义函数不需要加引号。

---

aggregate()方法执行聚合操作时，会将一组标量值参与某些运算后转换为一个标量值。