pandas 终极版4：DataFrame统计、合并、分组操作

padndas提供了丰富的统计、合并、分组、缺失值等操作函数。

1.统计函数

1. df.count() #非空元素计算
2. df.min() #最小值
3. df.max() #最大值
4. df.idxmin() #最小值的位置，类似于R中的which.min函数
5. df.idxmax() #最大值的位置，类似于R中的which.max函数
6. df.quantile(0.1) #10%分位数
7. df.sum() #求和
8. df.mean() #均值
9. df.median() #中位数
10. df.mode() #众数
11. df.var() #方差
12. df.std() #标准差
13. df.mad() #平均绝对偏差
14. df.skew() #偏度
15. df.kurt() #峰度
16. df.describe() #一次性输出多个描述性统计指标

2.分组group by

对于”group by”操作，我们通常是指以下一个或多个操作步骤：

Splitting:按照一些规则将数据分为不同的组；

Applying:对于每组数据分别执行一个函数；

Combining:将结果组合到一个数据结构中；

（1）按sex分组，显示每个分组第一个【first()】并求和[sum()]。最后一个【last()】

In [22]: df
Out[22]: 
       B         C         D  height  name sex  weight
0    one  1.077877 -0.316243     160   jia   F      50
1    two  0.843750 -1.133218     180    yi   M      60
2  three  0.422464 -0.034921     120  bing   F      45
3    two -0.381719 -0.763121     200  ding   F      78
4    one  1.085882 -0.281334     186    wu   M      68
5   thee  0.619578  2.333398     170    ji   M      76
6    two  1.447991 -0.579820     165  geng   F      58
7  three  0.031053  0.168869     155   xin   M      39

In [23]: df.groupby('sex').first()
Out[23]: 
       B         C         D  height name  weight
sex                                              
F    one  1.077877 -0.316243     160  jia      50
M    two  0.843750 -1.133218     180   yi      60

In [24]: df.groupby('sex').sum()
Out[24]: 
            C         D  height  weight
sex                                    
F    2.566612 -1.694106     645     231
M    2.580262  1.087714     691     243

（2）通过多个列进行分组形成一个层次索引，然后执行函数：

In [25]: df.groupby(['sex','B']).last()
Out[25]: 
                  C         D  height  name  weight
sex B                                              
F   one    1.077877 -0.316243     160   jia      50
    three  0.422464 -0.034921     120  bing      45
    two    1.447991 -0.579820     165  geng      58
M   one    1.085882 -0.281334     186    wu      68
    thee   0.619578  2.333398     170    ji      76
    three  0.031053  0.168869     155   xin      39
    two    0.843750 -1.133218     180    yi      60

In [26]: df.groupby(['sex','B']).sum()
Out[26]: 
                  C         D  height  weight
sex B                                        
F   one    1.077877 -0.316243     160      50
    three  0.422464 -0.034921     120      45
    two    1.066271 -1.342941     365     136
M   one    1.085882 -0.281334     186      68
    thee   0.619578  2.333398     170      76
    three  0.031053  0.168869     155      39
    two    0.843750 -1.133218     180      60

3.合并

Pandas提供了大量的方法能够轻松的对Series，DataFrame和Panel对象进行各种符合各种逻辑关系的合并操作

（1）Concat

   result = pd.concat(objs, axis=1, join='inner')

objs: series，dataframe或者是panel构成的序列lsit 
axis： 需要合并链接的轴，0是行，1是列 ,当axis = 1的时候，concat就是行对齐，然后将不同列名称的两张表合并
join：连接的方式 inner，或者outer ,如果为’inner’得到的是两表的交集，如果是outer，得到的是两表的并集。

 

随机生产两个df1和df2

In [27]: df1 = pd.DataFrame(np.random.randint(100,size=(2,2)))

In [28]: df2 = pd.DataFrame(np.random.randint(100,size=(3,3)))

In [29]: df1
Out[29]: 
    0   1
0  56  27
1  54  32

In [30]: df2
Out[30]: 
    0   1   2
0  54  62   5
1  88  91  43
2  25  34  40

pd.concat([df1,df2])，pd.concat([df1,df2],axis=1)

In [31]: pd.concat([df1,df2])
Out[31]: 
    0   1     2
0  56  27   NaN
1  54  32   NaN
0  54  62   5.0
1  88  91  43.0
2  25  34  40.0

In [32]: pd.concat([df1,df2],axis=1)
Out[32]: 
      0     1   0   1   2
0  56.0  27.0  54  62   5
1  54.0  32.0  88  91  43
2   NaN   NaN  25  34  40

inner’得到的是两表的交集，如果是outer，得到的是两表的并集。

In [36]: pd.concat([df1,df2],join='inner')
Out[36]: 
    0   1
0  56  27
1  54  32
0  54  62
1  88  91
2  25  34

In [37]: pd.concat([df1,df2],join='outer')
Out[37]: 
    0   1     2
0  56  27   NaN
1  54  32   NaN
0  54  62   5.0
1  88  91  43.0
2  25  34  40.0

（2） Append：无视index的concat
，如果两个表的index都没有实际含义，使用ignore_index参数，置true，合并的两个表就睡根据列字段对齐，然后合并。最后再重新整理一个新的index。 

In [49]: df1
Out[49]: 
    0   1
0  56  27
1  54  32

In [50]: s = pd.Series(np.random.randint(100,size=5))

In [51]: s
Out[51]: 
0     3
1    72
2    64
3    57
4     5
dtype: int64

In [52]: df1.append(s,ignore_index=True)
Out[52]: 
    0   1     2     3    4
0  56  27   NaN   NaN  NaN
1  54  32   NaN   NaN  NaN
2   3  72  64.0  57.0  5.0

In [56]: df2
Out[56]: 
    0   1   2
0  54  62   5
1  88  91  43
2  25  34  40

In [57]: df1.append(df2,ignore_index=True)
Out[57]: 
    0   1     2
0  56  27   NaN
1  54  32   NaN
2  54  62   5.0
3  88  91  43.0
4  25  34  40.0

（3）merge的参数

on：列名，join用来对齐的那一列的名字，用到这个参数的时候一定要保证左表和右表用来对齐的那一列都有相同的列名。
left_on：左表对齐的列，可以是列名，也可以是和dataframe同样长度的arrays。
right_on：右表对齐的列，可以是列名，也可以是和dataframe同样长度的arrays。
left_index/ right_index: 如果是True的haunted以index作为对齐的key
how：数据融合的方法。(left,right,inner,outer)，默认是inner
sort：根据dataframe合并的keys按字典顺序排序，默认是，如果置false可以提高表现。

In [21]: left
Out[21]: 
    A   B key1 key2
0  A0  B0   K0   K0
1  A1  B1   K0   K1
2  A2  B2   K1   K0
3  A3  B3   K2   K1

In [22]: right
Out[22]: 
    C   D key1 key2
0  C0  D0   K0   K0
1  C1  D1   K1   K0
2  C2  D2   K1   K0
3  C3  D3   K2   K0

In [23]: result = pd.merge(left, right, on=['key1', 'key2'])

In [24]: result
Out[24]: 
    A   B key1 key2   C   D
0  A0  B0   K0   K0  C0  D0
1  A2  B2   K1   K0  C1  D1
2  A2  B2   K1   K0  C2  D2