《利用python进行数据分析》读书笔记--第九章 数据聚合与分组运算（一）

对数据进行分组并对各组应用一个函数，是数据分析的重要环节。数据准备好之后，通常的任务就是计算分组统计或生成透视表。groupby函数能高效处理数据，对数据进行切片、切块、摘要等操作。可以看出这跟SQL关系密切，但是可用的函数有很多。在本章中，可以学到：

• 根据一个或多个键（可以是函数、数组或DataFrame列名）拆分pandas对象
• 计算分组摘要统计，如计数、平均值、标准差、，或自定义函数
• 对DataFrame的列应用各种各样的函数
• 应用组内转换或其他运算，如规格化、线性回归、排名或选取子集等
• 计算透视表和交叉表
• 执行分位数分析以及其他分组分析

对时间数据的聚合也称重采样（resampling），在第十章介绍。

1、GroupBy技术

很多数据处理过程都经历“拆分-应用-合并”的过程。即根据一个或多个键进行分组、每一个应用函数、再进行合并。

分组键有多种形式：

• 列表或数组，长度与待分组的轴一样
• 表示DataFrame某个列明的值
• 字典或Series，给出待分组轴上的值与分组名之间的对应关系
• 函数，用于处理轴索引或索引中的各个标签

下面开始写例子。

• 简单实例

#-*- encoding: utf-8 –*-

#分组实例
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame

df =DataFrame({'key1':list('aabba'),'key2':['one','two','one','two','one'],
    'data1':np.random.randn(5),'data2':np.random.randn(5)})
print df,'\n'
#根据key1进行分组，并计算data1的均值。
#注意下面的方式，取出来进行分组，而不是在DataFrame中分组，这种方式很灵活
#可以看到这是一个GroupBy对象,具备了应用函数的基础
#这个过程是将Seri进行聚合，产生了新的Series
grouped = df['data1'].groupby(df['key1'])
print grouped,'\n'
print grouped.mean(),'\n'
means = df['data1'].groupby([df['key1'],df['key2']]).mean()
print means,'\n' #得到一个层次化索引的DataFrame
print means.unstack(),'\n'
#上面的分组键均为Series，实际上，分组键可以是任何长度适当的数组,很灵活
states = np.array(['Ohio','California','California','Ohio','Ohio'])
years = np.array([2005,2005,2006,2005,2006])
print df['data1'].groupby([states,years]).mean(),'\n'
#还可以用列名（可以是字符串、数字或其他python对象）用作分组键
print df.groupby('key1').mean(),'\n'  #这里将数值型的列都进行了mean,非数值型的忽略
print df.groupby(['key1','key2']).mean(),'\n'
#groupby以后可以应用一个很有用的size方法
print df.groupby(['key1','key2']).size(),'\n' #截止翻译版为止，分组键中的缺失值被排除在外

>>>

      data1     data2 key1 key2
0  1.489789 -1.548474    a  one
1 -1.000447 -0.187066    a  two
2  0.254255 -0.960017    b  one
3  1.279892  1.124993    b  two
4 -0.366753  0.139047    a  one 

<pandas.core.groupby.SeriesGroupBy object at 0x03A895B0>

key1
a       0.040863
b       0.767073

key1  key2
a     one     0.561518
      two    -1.000447
b     one     0.254255
      two     1.279892

key2       one       two
key1                   
a     0.561518 -1.000447
b     0.254255  1.279892

California  2005   -1.000447
            2006    0.254255
Ohio        2005    1.384841
            2006   -0.366753

         data1     data2
key1                   
a     0.040863 -0.532165
b     0.767073  0.082488

              data1     data2
key1 key2                   
a    one   0.561518 -0.704714
     two  -1.000447 -0.187066
b    one   0.254255 -0.960017
     two   1.279892  1.124993

key1  key2
a     one     2
      two     1
b     one     1
      two     1
[Finished in 0.7s]

• 对分组进行迭代

#-*- encoding: utf-8 -*-
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame

df =DataFrame({'key1':list('aabba'),'key2':['one','two','one','two','one'],
    'data1':np.random.randn(5),'data2':np.random.randn(5)})

#对分组进行迭代,groupby对象支持迭代
#下面是迭代？……不过就是将分组的结果分别赋值给两个量?不是这样的,下面的循环会打印两个one

print df.groupby('key1')
for name,group in df.groupby('key1'):
    print 'one'
    print name
    print group,'\n'

#多重键的情况，元组的第一个元素将会是由键值组成的元组,下面会打印四个two
#也就是说，下面的三个print是一个组合，打印key值这一点挺好
for (k1,k2),group in df.groupby(['key1','key2']):
    print 'two'
    print k1,k2
    print group,'\n'
#当然，可以对数据片段进行操作
#转换为字典，应该是比较有用的一个转换方式
print list(df.groupby('key1')),'\n'
pieces = dict(list(df.groupby('key1')))
#注意下面的字典中的每个值仍然是一个“含有名称的DataFrame”，可能不严谨，但是就是这意思
print pieces['a'],'\n'
print type(pieces['a'])
print pieces['a'][['data1','data2']],'\n'
#groupby默认在axis = 0上进行分组，可以设置在任何轴上分组
#下面用dtype对列进行分组
print df.dtypes,'\n'
grouped = df.groupby(df.dtypes,axis = 1)
print grouped,'\n'
print dict(list(grouped)) #有点像把不同数值类型的列选出来

>>>

<pandas.core.groupby.DataFrameGroupBy object at 0x0333CEB0>
one
a
      data1     data2 key1 key2
0 -0.984933  0.392220    a  one
1 -2.104506  4.120798    a  two
4 -0.267432 -1.825800    a  one 

one
b
      data1     data2 key1 key2
2  0.476850 -1.738739    b  one
3 -0.863738 -0.458431    b  two

two
a one
      data1    data2 key1 key2
0 -0.984933  0.39222    a  one
4 -0.267432 -1.82580    a  one

two
a two
      data1     data2 key1 key2
1 -2.104506  4.120798    a  two

two
b one
     data1     data2 key1 key2
2  0.47685 -1.738739    b  one

two
b two
      data1     data2 key1 key2
3 -0.863738 -0.458431    b  two

[('a',       data1     data2 key1 key2
0 -0.984933  0.392220    a  one
1 -2.104506  4.120798    a  two
4 -0.267432 -1.825800    a  one), ('b',       data1     data2 key1 key2
2  0.476850 -1.738739    b  one
3 -0.863738 -0.458431    b  two)]

      data1     data2 key1 key2
0 -0.984933  0.392220    a  one
1 -2.104506  4.120798    a  two
4 -0.267432 -1.825800    a  one

<class 'pandas.core.frame.DataFrame'>
      data1     data2
0 -0.984933  0.392220
1 -2.104506  4.120798
4 -0.267432 -1.825800

data1    float64
data2    float64
key1      object
key2      object

<pandas.core.groupby.DataFrameGroupBy object at 0x033F0190>

{dtype('object'):   key1 key2
0    a  one
1    a  two
2    b  one
3    b  two
4    a  one, dtype('float64'):       data1     data2
0 -0.984933  0.392220
1 -2.104506  4.120798
2  0.476850 -1.738739
3 -0.863738 -0.458431
4 -0.267432 -1.825800}
[Finished in 0.7s]

• 选取一个或一组列

#-*- encoding: utf-8 -*-
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame

df =DataFrame({'key1':list('aabba'),'key2':['one','two','one','two','one'],
    'data1':np.random.randn(5),'data2':np.random.randn(5)})
print df,'\n'

#对于由DataFrame产生的GroupBy对象，如果用一个或一组列名进行索引，就能实现选取部分列进行聚合的目的，即
#下面语法效果相同
print df.groupby('key1')['data1']  #又一次选取方式的区分，这条语句返回Series，下一条返回DataFrame
print df.groupby('key1')[['data1']]
#下面的
print df['data1'].groupby(df['key1'])
print df[['data1']].groupby(df['key1']),'\n'
#尤其对于大数据集，可能只是对部分列进行聚合。比如，想计算data2的均值并返回DataFrame
print df.groupby(['key1','key2'])[['data2']].mean(),'\n'

>>>

      data1     data2 key1 key2
0 -1.381889  0.919518    a  one
1 -0.186802  1.265642    a  two
2 -0.173303  0.866173    b  one
3  0.015841 -0.601375    b  two
4 -0.281338 -0.319804    a  one 

<pandas.core.groupby.SeriesGroupBy object at 0x039EB970>
<pandas.core.groupby.DataFrameGroupBy object at 0x039EB930>
<pandas.core.groupby.SeriesGroupBy object at 0x039EB930>
<pandas.core.groupby.DataFrameGroupBy object at 0x039EB950> 

              data2
key1 key2         
a    one   0.299857
     two   1.265642
b    one   0.866173
     two  -0.601375
[Finished in 0.7s]

• 通过字典或Series进行分组

#-*- encoding: utf-8 -*-
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame

people = DataFrame(np.random.randn(5,5),columns = ['a','b','c','d','e'],index = ['Joe','Steve','Wes','Jim','Travis'])
people.ix[2:3,['b','c']] = np.nan #加点NaN
print people,'\n'
#假设已经知道列的分组方式，现在需要利用这个信息进行分组统计：
mapping = {'a':'red','b':'red','c':'blue','d':'blue','e':'red','f':'orange'}
#下面为groupby传入一个已知信息的字典
by_column = people.groupby(mapping,axis = 1)
print by_column.sum(),'\n'  #注意得到的名字是 red 和 blue
#Series也有这样的功能，被看作一个固定大小的映射，可以用Series作为分组键，pandas会自动检查对齐
map_series = Series(mapping)
print map_series,'\n'
print people.groupby(map_series,axis = 1).count()

>>>

               a         b         c         d         e
Joe    -0.344808  0.716334  1.092892  0.824548  0.206477
Steve   0.457156 -0.207056 -0.447555 -0.378811 -0.581657
Wes    -0.739237       NaN       NaN -1.168591  0.876174
Jim     0.116797 -1.888764  2.072722  0.029644  0.919705
Travis -0.482019  1.479823  0.706617  0.697408 -0.914512 

            blue       red
Joe     1.917440  0.578003
Steve  -0.826367 -0.331557
Wes    -1.168591  0.136937
Jim     2.102366 -0.852261
Travis  1.404025  0.083292

a       red
b       red
c      blue
d      blue
e       red
f    orange

        blue  red
Joe        2    3
Steve      2    3
Wes        1    2
Jim        2    3
Travis     2    3
[Finished in 0.6s]

 

• 利用函数进行分组

#-*- encoding: utf-8 -*-
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame

#相较于字典或Series，python函数在定义分组映射关系时可以更有创意且更为抽象。
#函数会在各个索引值上调用一次，并根据结果进行分组。
people = DataFrame(np.random.randn(5,5),columns = ['a','b','c','d','e'],index = ['Joe','Steve','Wes','Jim','Travis'])
print people.groupby(len).sum()  #名字长度相同的人进行加和
#将函数、数组、字典、Series混用也ok，因为最终都会转换为数组
key_list = ['one','one','one','two','two']
print people.groupby([len,key_list]).min()

>>>

          a         b         c         d         e
3  0.528550  0.245731  1.187483 -1.086821  0.042086
5 -2.579143  0.152800 -0.911028  0.328152  0.627507
6  2.328199 -1.091351 -1.198069  0.571550  0.794774
              a         b         c         d         e
3 one -0.444315  0.559996 -1.486260  0.090243 -1.131864
  two -0.601314 -1.389457  1.616836 -1.366003  1.495320
5 one -2.579143  0.152800 -0.911028  0.328152  0.627507
6 two  2.328199 -1.091351 -1.198069  0.571550  0.794774
[Finished in 1.5s]

• 根据索引级别分组

#-*- encoding: utf-8 -*-
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame

#层次化索引数据集最方便的地方就在于它能够根据索引级别进行聚合。要实现该目的，只要通过level关键字传入级别编号或名称即可
columns = pd.MultiIndex.from_arrays([['US','US','US','JP','JP'],[1,3,5,1,3]],names = ['cty','tenor'])
hier_df = DataFrame(np.random.randn(4,5),columns = columns)
print hier_df,'\n'
print hier_df.groupby(level = 'cty',axis = 1).count(),'\n'
print hier_df.groupby(level = 'tenor',axis = 1).count(),'\n'
print hier_df.groupby(level = ['cty','tenor'],axis = 1).count()

>>>

cty          US                            JP          
tenor         1         3         5         1         3
0      0.211478  0.076928 -1.225755  0.080232  1.472201
1      0.159280  0.504315  0.741466  2.263926  0.771153
2     -0.759615  0.550016 -1.476229  1.838213 -0.509156
3      0.987656  0.238239  0.537588 -0.126640  0.252719 

cty  JP  US
0     2   3
1     2   3
2     2   3
3     2   3

tenor  1  3  5
0      2  2  1
1      2  2  1
2      2  2  1
3      2  2  1

cty    JP     US     
tenor   1  3   1  3  5
0       1  1   1  1  1
1       1  1   1  1  1
2       1  1   1  1  1
3       1  1   1  1  1
[Finished in 1.2s]

2、数据聚合

这里的数据聚合是说任何能够从数组产生标量值的过程。之前的例子已经用到了一些，比如mean()、count()、min()、max()等。常见的聚合运算都有就地计算数据集统计信息的优化实现。当然并不止这些，可以用自己定义的运算，还可以调用分组对象上已经定义好的任何方法。例如，quantile可以计算Series或DataFrame列的样本分位数。

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt


df =DataFrame({'key1':list('aabba'),'key2':['one','two','one','two','one'],
    'data1':np.random.randn(5),'data2':np.random.randn(5)})
#print df
grouped = df.groupby('key1')
#注意下面的quantile并没有直接实现于GroupBy，它是一个Series方法，故而能用，
#就是说，此过程实际上是groupby对df进行高效切片，然后对每个切片应用quantile
print grouped['data1'].quantile(0.9),'\n'
#对于自己定义的聚合函数，只需将其传入aggregate或agg即可
#注意下面是对每列都应用
def peak_to_peak(arr):
    return arr.max() - arr.min()
print grouped.agg(peak_to_peak),'\n'
#有些方法（describe）也是可以应用的。
print grouped.describe()
#自定义函数比经过优化的函数要慢得多，这是因为在构造中间分组数据块时存在非常大的开销（函数调用、数据重排等）
#下面说明更高级的聚合功能，用的是R语言reshape2包中的数据集tips，这数据是从R中自己导出来的
tips = pd.read_csv('E:\\tips.csv')
#增加小费占比一列
tips['tip_pct'] = tips['tip'] / tips['total_bill']
print tips.head()

>>>

key1
a       0.970028
b       0.642314 

         data1     data2
key1                   
a     1.502016  1.583056
b     0.495911  0.384405

               data1     data2
key1                         
a    count  3.000000  3.000000
     mean   0.304136  0.822614
     std    0.802148  0.792578
     min   -0.284158  0.007541
     25%   -0.152726  0.438623
     50%   -0.021293  0.869705
     75%    0.598283  1.230151
     max    1.217858  1.590597
b    count  2.000000  2.000000
     mean   0.443950  0.425535
     std    0.350662  0.271816
     min    0.195994  0.233332
     25%    0.319972  0.329433
     50%    0.443950  0.425535
     75%    0.567927  0.521636
     max    0.691905  0.617737
   total_bill   tip     sex smoker  day    time  size   tip_pct
0       16.99  1.01  Female  False  Sun  Dinner     2  0.059447
1       10.34  1.66    Male  False  Sun  Dinner     3  0.160542
2       21.01  3.50    Male  False  Sun  Dinner     3  0.166587
3       23.68  3.31    Male  False  Sun  Dinner     2  0.139780
4       24.59  3.61  Female  False  Sun  Dinner     4  0.146808
[Finished in 0.7s]

经过优化的GroupBy的方法，按作者的意思，这些函数是快的。

• 面向列的多函数应用

有时候需要对不同的列应用不同的函数，或者对一列应用不同的函数。下面是例子。

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt

#下面说明更高级的聚合功能，用的是R语言reshape2包中的数据集tips，这数据是从R中自己导出来的
tips = pd.read_csv('E:\\tips.csv')
#增加小费占比一列
tips['tip_pct'] = tips['tip'] / tips['total_bill']
print tips.head(),'\n'
grouped = tips.groupby(['sex','smoker'])
grouped_pct = grouped['tip_pct']
print grouped_pct.agg('mean'),'\n'
#若传入一组函数或函数名，得到的DataFrame的列就会以相应的函数命名
def peak_to_peak(arr):
    return arr.max() - arr.min()
#对比例这一列应用三个函数
print grouped_pct.agg(['mean','std',peak_to_peak]),'\n'
#上面有个问题就是列名是自动给出的，以函数名为列名，若传入元组
#（name，function）组成的列表，就会自动将第一个元素作为列名
print grouped_pct.agg([('foo','mean'),('bar',np.std)]),'\n'  #注意np.std不能加引号
#还可以对多列应用同一函数
functions = ['count','mean','max']
result = grouped['tip_pct','total_bill'].agg(functions)  #对两列都应用functions
print result,'\n'  #得到的结果的列名是层次化索引，可以直接用外层索引选取数据
print result['tip_pct'],'\n'
ftuples = [('DDD','mean'),('AAA',np.var)]
print grouped['tip_pct','total_bill'].agg(ftuples),'\n'
#如果想对不同的列应用不同的函数，具体的办法是向agg传入一个从列映射到函数的字典
print grouped.agg({'tip':np.max,'size':sum}),'\n'  #sum这样的函数可以加引号或者不加
print grouped.agg({'tip':['min','max','mean','std'],'size':sum})

>>>

   total_bill   tip     sex smoker  day    time  size   tip_pct
0       16.99  1.01  Female  False  Sun  Dinner     2  0.059447
1       10.34  1.66    Male  False  Sun  Dinner     3  0.160542
2       21.01  3.50    Male  False  Sun  Dinner     3  0.166587
3       23.68  3.31    Male  False  Sun  Dinner     2  0.139780
4       24.59  3.61  Female  False  Sun  Dinner     4  0.146808 

sex     smoker
Female  False     0.156921
        True      0.182150
Male    False     0.160669
        True      0.152771
Name: tip_pct

                   mean       std  peak_to_peak
sex    smoker                                 
Female False   0.156921  0.036421      0.195876
       True    0.182150  0.071595      0.360233
Male   False   0.160669  0.041849      0.220186
       True    0.152771  0.090588      0.674707

                    foo       bar
sex    smoker                   
Female False   0.156921  0.036421
       True    0.182150  0.071595
Male   False   0.160669  0.041849
       True    0.152771  0.090588

               tip_pct                      total_bill                 
                 count      mean       max       count       mean    max
sex    smoker                                                          
Female False        54  0.156921  0.252672          54  18.105185  35.83
       True         33  0.182150  0.416667          33  17.977879  44.30
Male   False        97  0.160669  0.291990          97  19.791237  48.33
       True         60  0.152771  0.710345          60  22.284500  50.81

               count      mean       max
sex    smoker                          
Female False      54  0.156921  0.252672
       True       33  0.182150  0.416667
Male   False      97  0.160669  0.291990
       True       60  0.152771  0.710345

                tip_pct            total_bill          
                    DDD       AAA         DDD        AAA
sex    smoker                                          
Female False   0.156921  0.001327   18.105185  53.092422
       True    0.182150  0.005126   17.977879  84.451517
Male   False   0.160669  0.001751   19.791237  76.152961
       True    0.152771  0.008206   22.284500  98.244673

               size   tip
sex    smoker           
Female False    140   5.2
       True      74   6.5
Male   False    263   9.0
       True     150  10.0

                tip                            size
                min   max      mean       std   sum
sex    smoker                                     
Female False   1.00   5.2  2.773519  1.128425   140
       True    1.00   6.5  2.931515  1.219916    74
Male   False   1.25   9.0  3.113402  1.489559   263
       True    1.00  10.0  3.051167  1.500120   150
[Finished in 0.7s]

• 以‘无索引’的方式返回聚合数据

到目前为止，示例中的聚合数据都是由唯一的分组键组成的索引（可能还是层次化的）。由于并不是总需要如此，可以向groupby传入as_index = False禁用该功能。

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt

tips = pd.read_csv('E:\\tips.csv')
#增加小费占比一列
tips['tip_pct'] = tips['tip'] / tips['total_bill']
print tips.head(),'\n'

print tips.groupby(['sex','smoker'],as_index = False).mean() #这里的形式可能有时候更好用

>>>

   total_bill   tip     sex smoker  day    time  size   tip_pct
0       16.99  1.01  Female  False  Sun  Dinner     2  0.059447
1       10.34  1.66    Male  False  Sun  Dinner     3  0.160542
2       21.01  3.50    Male  False  Sun  Dinner     3  0.166587
3       23.68  3.31    Male  False  Sun  Dinner     2  0.139780
4       24.59  3.61  Female  False  Sun  Dinner     4  0.146808 

      sex smoker  total_bill       tip      size   tip_pct
0  Female  False   18.105185  2.773519  2.592593  0.156921
1  Female   True   17.977879  2.931515  2.242424  0.182150
2    Male  False   19.791237  3.113402  2.711340  0.160669
3    Male   True   22.284500  3.051167  2.500000  0.152771
[Finished in 0.6s]

3、分组级运算和转换

聚合只是分组运算中的一种，它是数据转换的一个特例。也就是说，它只是接受能够将一维数组简化为标量值的函数。本节将介绍transform和apply方法，能够执行更多其他的分组运算。

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt

#下面为DataFrame添加一个用于存放各索引分组平均值的列。一个办法是先聚合在合并：
df =DataFrame({'key1':list('aabba'),'key2':['one','two','one','two','one'],
    'data1':np.random.randn(5),'data2':np.random.randn(5)})
#print df,'\n'
k1_means = df.groupby('key1').mean().add_prefix('mean_')
print k1_means,'\n'
#下面用左边的key1作为连接键，right_index是将右边的行索引作为连接键
print pd.merge(df,k1_means,left_on = 'key1',right_index = True)
#上面的方法虽然也行，但是不灵活。可以看作利用mean函数对数据的两列进行转换。

people = DataFrame(np.random.randn(5,5),columns = ['a','b','c','d','e'],index = ['Joe','Steve','Wes','Jim','Travis'])
print people,'\n'
key = ['one','two','one','two','one']
print people.groupby(key).mean(),'\n'
#看下面神奇的事情
print people.groupby(key).transform(np.mean),'\n'
#不难看出，transform会将一个函数应用到各个分组并将结果放置到适当的位置，
#如果各分组产生的是一个标量值，则改值就会被广播出去
#下面的例子很说明问题，很灵活
def demean(arr):
    return arr - arr.mean()
demeaned = people.groupby(key).transform(demean)
print demeaned,'\n'
#下面检查一下demeaned各组均值是否为0
print demeaned.groupby(key).mean()
>>>
      mean_data1  mean_data2
key1                        
a      -0.729610   -0.141770
b      -0.174505    0.484952 

      data1     data2 key1 key2  mean_data1  mean_data2
0 -2.082417  0.752055    a  one   -0.729610   -0.141770
1 -0.563339 -0.915167    a  two   -0.729610   -0.141770
4  0.456927 -0.262198    a  one   -0.729610   -0.141770
2 -0.173514  1.695344    b  one   -0.174505    0.484952
3 -0.175496 -0.725440    b  two   -0.174505    0.484952
               a         b         c         d         e
Joe    -1.109408 -0.379178 -0.666847  2.003109 -1.331988
Steve   0.316630 -1.801337 -0.479510  0.305003  1.641795
Wes     0.338475 -0.613742 -0.623375 -0.423722 -0.529741
Jim     0.206591 -0.876095  0.297528 -0.177179  0.208701
Travis -1.307377  0.144524  0.236289  0.382082  0.497277 

           a         b         c         d         e
one -0.69277 -0.282799 -0.351311  0.653823 -0.454817
two  0.26161 -1.338716 -0.090991  0.063912  0.925248 

              a         b         c         d         e
Joe    -0.69277 -0.282799 -0.351311  0.653823 -0.454817
Steve   0.26161 -1.338716 -0.090991  0.063912  0.925248
Wes    -0.69277 -0.282799 -0.351311  0.653823 -0.454817
Jim     0.26161 -1.338716 -0.090991  0.063912  0.925248
Travis -0.69277 -0.282799 -0.351311  0.653823 -0.454817 

               a         b         c         d         e
Joe    -0.416638 -0.096379 -0.315536  1.349286 -0.877171
Steve   0.055020 -0.462621 -0.388519  0.241091  0.716547
Wes     1.031245 -0.330943 -0.272064 -1.077544 -0.074924
Jim    -0.055020  0.462621  0.388519 -0.241091 -0.716547
Travis -0.614607  0.427322  0.587599 -0.271741  0.952094 

     a             b             c             d  e
one  0 -1.850372e-17 -3.700743e-17  1.850372e-17  0
two  0 -5.551115e-17  0.000000e+00  0.000000e+00  0
[Finished in 0.7s]

• apply:一般性的“拆分-应用-合并”

本节就是说apply函数很重要，是最一般化的GroupBy方法。跟aggregate一样，transform也是一个有着严格条件的特殊函数：传入的函数只能产生两种结果，要么是可以广播的标量，要么是产生一个相同大小的结果数组。apply函数将对象拆分为多个片段，对各个片段调用传入的函数，并尝试将各片段合到一起。

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt

tips = pd.read_csv('E:\\tips.csv')
#增加小费占比一列
tips['tip_pct'] = tips['tip'] / tips['total_bill']
#print tips.head(),'\n'
#下面找出指定列的最大的几个值，然后将所在行选出来
def top(df,n = 5,column = 'tip_pct'):
    return df.sort_index(by = column)[-n:]
print top(tips,n = 6),'\n'
#如果对smoker分组并用该函数调用apply
print tips.groupby('smoker').apply(top),'\n'
#上面实际上是在各个片段上调用了top，然后用pd.concat进行了连接，并以分组名称进行了标记，于是就形成了层次化索引
#当然可以向top函数传入参数
print tips.groupby(['smoker','day']).apply(top,n = 1,column = 'total_bill')
#需要说明的是：apply很强大，需要发挥想象力，它只需返回一个pandas对象或者标量值即可
#之前曾经这么做过：
result = tips.groupby('smoker')['tip_pct'].describe()
print result,'\n'
print result.unstack('smoker'),'\n'
#下面的方式,效果一样
f = lambda x : x.describe()
print tips.groupby('smoker')['tip_pct'].apply(f),'\n'
#对所有列都行
print tips.groupby('smoker').apply(f),'\n'
#看的出，上面自动生成了层次化索引，可以将分组键去掉
print tips.groupby('smoker',group_keys = False).apply(top),'\n'
#下面看得出，重新设置索引会去掉原来所有索引，并重置索引
print tips.groupby('smoker').apply(top).reset_index(drop = True),'\n'
#下面看的出来，as_index在这里并不管用
print tips.groupby('smoker',as_index = False).apply(top),'\n'
#下面看的出来，as_index在这里并不管用
print tips.groupby(['sex','smoker'],as_index = False).apply(top),'\n'

• 分位数和桶分析

第七章中的cut和qcut函数可以对数据进行拆分，现在将其与groupby集合起来会轻松实现对数据集的桶（bucket）（嗯，注意名字）或分位数（quantile）分析了。

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt

frame = DataFrame({'data1':np.random.randn(1000),'data2':np.random.randn(1000)})
print frame.head(),'\n'
factor = pd.cut(frame.data1,4)
print factor[:10],'\n'
#cut返回的对象可直接用于groupby（很合理）
def get_stats(group):
    return {'min':group.min(),'max':group.max(),'count':group.count(),'mean':group.mean()}
grouped = frame.data2.groupby(factor)
print grouped.apply(get_stats),'\n'
print grouped.apply(get_stats).unstack(),'\n'
#上面的桶是区间大小相等的桶，要想得到数据量相等的桶，用qcut即可。
grouping = pd.qcut(frame.data1,10)
#print grouping
#labels = False 标明只返回各个值所在的分组编号，而不是所在的各个分组，感觉这样更好
grouping = pd.qcut(frame.data1,10,labels = False)
#print grouping,'\n'
grouped = frame.data2.groupby(grouping)
print grouped.apply(get_stats).unstack()