数据的分组运算和聚合

在将数据集加载、融合、准备好之后，通常就是计算分组统计或⽣成透视表， pandas提供了
⼀个灵活⾼效的groupby功能，它使你能以⼀种⾃然的⽅式对数据集进⾏切⽚、切块、摘要等
操作

1. 分组机制 -- GroupBy

分组运算"split-apply-combine"（拆分－应⽤－合并）。第⼀个阶段，pandas对象
（⽆论是Series、DataFrame还是其他的）中的数据会根据你所提供的⼀个或多个键被拆分
（split）为多组。拆分操作是在对象的特定轴上执⾏的。例如，DataFrame可以在其⾏
（axis=0）或列（axis=1）上进⾏分组。然后，将⼀个函数应⽤（apply）到各个分组并产
 ⽣⼀个新值。最后，所有这些函数的执⾏结果会被合并（combine）到最终的结果对象中

 df = pd.DataFrame({'key1' : ['a', 'a', 'b', 'b', 'a'],
 ....: 'key2' : ['one', 'two', 'one', 'two', 'one'],
 ....: 'data1' : np.random.randn(5),
 ....: 'data2' : np.random.randn(5)})
 grouped = df['data1'].groupby(df['key1'])
  变量grouped是⼀个GroupBy对象。它实际上还没有进⾏任何计算，只是含有⼀些有关分组键df[‘key1’]的中间数据⽽已
 grouped.mean()  # 对分组的数据求平均值，索引是key1列去重后的值
 means = df['data1'].groupby([df['key1'], df['key2']]).mean()  # ⼀次传⼊多个数组的列表，外层索引为key1，内层索引为key2,数据为data1的平均值
 means.unstack() # 转置，默认把外层索引变为列索引，传入参数1默认将内层索引变为列索引

GroupBy的size⽅法，它可以返回⼀个含有分组⼤⼩的Series（填充数据为每一组包含的原始数据个数）

df.groupby(['key1', 'key2']).size()

2.对分组进行迭代：

GroupBy对象⽀持迭代，可以产⽣⼀组⼆元元组（由分组名和数据块组成）

a. 单一分组键情况：
    for name, group in df.groupby('key1'):
    ....: print(name)
    ....: print(group)
    
    输出如下：
    a
     data1 data2 key1 key2
    0 -0.204708 1.393406 a one
    1  0.478943 0.092908 a two
    4  1.965781 1.246435 a one
    b
     data1 data2 key1 key2
    2 -0.519439 0.281746 b one
    3 -0.555730 0.769023 b two

b. 多重分组键情况（元组的第⼀个元素将会是由键值组成的元组）：
     for (k1, k2), group in df.groupby(['key1', 'key2']):
     ....: print((k1, k2))
     ....: print(group)
    
    输出如下：
    ('a', 'one')
     data1 data2 key1 key2
    0 -0.204708 1.393406 a one
    4  1.965781  1.246435 a one
    ('a', 'two')
     data1 data2 key1 key2
    1 0.478943 0.092908 a two
    ('b', 'one')
     data1 data2 key1 key2
    2 -0.519439 0.281746 b one
    ('b', 'two')
     data1 data2 key1 key2
    3 -0.55573 0.769023 b two

pieces = dict(list(df.groupby('key1'))) # 将分组后的数据做成一个字典（只能是一个分组键）
pieces['b'] # 通过key1的值拿到相应片段的数据集

3. 根据dtypes对列进行分组--df.dtypes输出字段对应数据类型（float64,object等）

     grouped = df.groupby(df.dtypes, axis=1)
     for dtype, group in grouped:
     ....: print(dtype)
     ....: print(group)
    
    输出如下：
    
    float64
     data1 data2
    0 -0.204708 1.393406
    1 0.478943 0.092908
    2 -0.519439 0.281746
    3 -0.555730 0.769023
    4 1.965781 1.246435
    object
     key1 key2
    0 a one
    1 a two
    2 b one
    3 b two
    4 a one

4. 分组后选取分组的一列或者列的子集（默认是按行分组）

df.groupby('key1')['data1'] # 取一列（结果还是分组对象）
df.groupby('key1')[['data1'，'data2']] # 取多列（结果还是分组对象）
df.groupby(['key1', 'key2'])[['data2']].mean() # 分组后取data2列的数据，按组求每一组data2的平均，返回一个dataframe（两层索引，key1和key2）

5.根据字典或者Sreies分组

 people = pd.DataFrame(np.random.randn(5, 5),
 ....: columns=['a', 'b', 'c', 'd', 'e'],
 ....: index=['Joe', 'Steve', 'Wes', 'Jim', 'Travis'])

 mapping = {'a': 'red', 'b': 'red', 'c': 'blue',
 ....: 'd': 'blue', 'e': 'red', 'f' : 'orange'}
 根据字典分组,再对每组求和（默认按行分组，如果设置axis=1按列分组，那么就按列求和）：
 by_dict = people.groupby(mapping, axis=1).sum()
 根据Series分组（按列分组，那么就按列求和）
 map_series = pd.Series(mapping)
 by_series = people.groupby(map_series, axis=1).count()

6.通过函数进行分组：

使⽤Python函数是⼀种更原⽣的⽅法定义分组映射。任何被当做分组键的函数都会在各个索引值上被调⽤⼀次，其返回值就会被⽤作分组名称

people.groupby(len).sum()  # 根据people的行索引的长度分组，再对每组每列所有行数据求和
key_list = ['one', 'one', 'one', 'two', 'two']
people.groupby([len, key_list]).min() # 根据行索引长度和key_list来分组再取分组后每组每列所有行中的最小值作为填充数据（外层索引len的返回值的去重值，内层索引key_list去重的值）

7.通过索引级别来分组：

层次化索引数据集最⽅便的地⽅就在于它能够根据轴索引的⼀个级别进⾏聚合，要根据级别分组，使⽤level关键字传递级别序号或名字

 columns = pd.MultiIndex.from_arrays([['US', 'US', 'US', 'JP', 'JP'],
 ....: [1, 3, 5, 1, 3]],
 ....: names=['cty', 'tenor']) # 创建名字为为cty外层索引，名字为tenor的内层索引
 hier_df = pd.DataFrame(np.random.randn(4, 5), columns=columns) # 创建dataframe,列索引为columns
 hier_df.groupby(level='cty', axis=1).count() # 分组键为cty层索引，按列分组，再统计每组每行的列数

数据的聚合

聚合指的是任何能够从数组产⽣标量值的数据转换过程，⽐如mean、count、min以及sum等

1. 聚合函数：

第一种.pandas内置聚合函数：
    count         分组中非NA值的数量
    sum           非NA值的和
    mean          非NA值的平均值
    median        非NA值的算术中位数
    std、var      无偏（分母为n-1）标准差和方差
    min、max      非NA值的最小和最大值
    prod          非NA值的极
    first、last   第一个和最后一个非NA值
第二种.自定义聚合函数（传入aggregate或者agg方法）：
     def peak_to_peak(arr):
     ....: return arr.max() - arr.min()
     grouped.agg(peak_to_peak)

2. 面向列的多函数应用（默认将作为分组条件的列变为行索引，多个条件列则变为层次化索引）

tips = pd.read_csv('examples/tips.csv')
tips['tip_pct'] = tips['tip'] / tips['total_bill']
grouped = tips.groupby(['day', 'smoker'])
grouped_pct = grouped['tip_pct']
grouped_pct.agg('mean') # 每个分组对tip_pct数据求平均，输出两层行索引和一列数据（共3列）

传⼊⼀组函数或函数名，得到的DataFrame的列就会以相应的函数命名：
grouped_pct.agg(['mean', 'std', peak_to_peak]) # 输出两层索引和三列数据（共5列）

传⼊的是⼀个由(name,function)元组组成的列表，则各元组的第⼀个元素就会被⽤作DataFrame的列名：
grouped_pct.agg([('foo', 'mean'), ('bar', np.std)])

对两列数据计算三个统计数据：
result = grouped['tip_pct', 'total_bill'].agg(['count', 'mean', 'max'])
result['tip_pct'] # 取出tip_pct数据的统计信息，返回一个dataframe

传入元祖自定义默认的统计名（函数名）
grouped['tip_pct', 'total_bill'].agg([('Dur', 'mean'),('Abw', np.var)])

对⼀个列或不同的列应⽤不同的函数，向agg传⼊⼀个从列名映射到函数的字典
grouped.agg({'tip' : np.max, 'size' : 'sum'})
grouped.agg({'tip_pct' : ['min', 'max', 'mean', 'std'],'size' : 'sum'})

传入as_index=False 阻止将作为分组条件的列变为索引，保留为数据；对结果调⽤reset_index也能
得到这种形式的结果。但使⽤as_index=False⽅法可以避免⼀些不必要的计算
tips.groupby(['day', 'smoker'], as_index=False).mean()