Series的层级索引

二层索引

  1. import pandas as pd
  2. import numpy as np
  4. ser = pd.Series(np.random.randn(6), index=[['a', 'a', 'b', 'b', 'c', 'c'],
  5.                                            [0, 1, 2, 0, 1, 2]])
  7. print(ser)
  8. '''
  9. a  0   -0.286195
  10.    1   -0.462873
  11. b  2   -0.697002
  12.    0   -0.354256
  13. c  1    0.704155
  14.    2   -0.343872
  15. dtype: float64
  16. '''
  18. print(type(ser.index))  
  19. # <class 'pandas.core.indexes.multi.MultiIndex'>
  21. # 外层选取
  22. print(ser['c'])
  23. '''
  24. 1    0.110106
  25. 2    0.000338
  26. dtype: float64
  27. '''
  29. # 内层选取
  30. print(ser[:, 2])
  31. '''
  32. b    0.505124
  33. c    1.036544
  34. dtype: float64
  35. '''

常用函数

  1. import pandas as pd
  2. import numpy as np
  4. ser = pd.Series(np.random.randn(6), index=[['a', 'a', 'b', 'b', 'c', 'c'],
  5.                                            [0, 1, 2, 0, 1, 2]])
  7. print(ser)
  8. '''
  9. a  0    0.664090
  10.    1    0.356893
  11. b  2    2.551393
  12.    0    0.674561
  13. c  1    1.029411
  14.    2   -0.492202
  15. dtype: float64
  16. '''
  18. print(ser.index.levels)  # [['a', 'b', 'c'], [0, 1, 2]]
  20. # swapleveal()：交换内层和外层索引
  21. print(ser.swaplevel())
  22. '''
  23. 0  a    0.664090
  24. 1  a    0.356893
  25. 2  b    2.551393
  26. 0  b    0.674561
  27. 1  c    1.029411
  28. 2  c   -0.492202
  29. dtype: float64
  30. '''
  32. # unstack()：将具有多层索引的Series转化为DataFrame，参数可以指定处理的层索引
  33. print(ser.unstack())
  34. '''
  35.           0         1         2
  36. a -2.094717  0.593266       NaN
  37. b -0.006563       NaN -3.098567
  38. c       NaN -0.790008 -0.603009
  39. '''
  40. ---------------------
  41. print(ser.unstack(0))
  42. '''
  43.           a         b         c
  44. 0 -2.094717 -0.006563       NaN
  45. 1  0.593266       NaN -0.790008
  46. 2       NaN -3.098567 -0.603009
  47. '''
  49. # stack()： 将DataFrame转化为具有多层索引的Series，参数可以指定处理的层索引
  50. print(ser.unstack(0).stack())
  51. '''
  52. 0  a   -1.176036
  53.    b    0.916851
  54. 1  a   -0.280411
  55.    c    0.015331
  56. 2  b   -0.962107
  57.    c    1.050720
  58. dtype: float64
  59. '''

统计计算

image.png

  1. import pandas as pd
  2. import numpy as np
  4. df = pd.DataFrame(np.random.randn(4, 3), columns=['a', 'b', 'c'])
  5. df.loc[0, 'a'] = np.nan
  7. print(df)
  8. '''
  9.           a         b         c
  10. 0       NaN -0.351020 -0.082929
  11. 1 -0.227825 -2.144045  1.403983
  12. 2 -0.491475  0.729788  2.318608
  13. 3 -0.693459  0.006438  1.203519
  14. '''
  16. print(df.min())
  17. '''
  18. a   -0.693459
  19. b   -2.144045
  20. c   -0.082929
  21. dtype: float64
  22. '''
  24. print(df.min(skipna=False))
  25. '''
  26. a         NaN
  27. b   -2.144045
  28. c   -0.082929
  29. dtype: float64
  30. '''

分组与聚合

基本概念

  • 在划分出来的组上应用一些统计函数，从而达到数据分析的目的，比如对分组数据进行聚合、转换、过滤，这个过程主要包含以下三步：
    • 拆分(Spliting)：对数据进行分组
    • 应用(Applying)：对分组数据应用聚合函数，进行相应计算
    • 合并(Combining)：汇总计算结果
  • groupby的过程就是将原有的DataFrame按照groupby的字段，划分为若干个分组DataFrame，被分为多少个组就有多少个分组DataFrame，而之后的一系列操作（比如agg、apply等），均是基于子DataFrame的操作

image.png

分组

分组对象包括 DataFrameGroupBy 和 SeriesGroupBy

分组操作

没有进行实际运算，只是包含分组的中间数据

  1. import pandas as pd
  2. import numpy as np
  4. var = {'key1': ['a', 'b', 'a', 'b'],
  5.        'key2': ['one', 'one', 'two', 'two'],
  6.        'data1': np.random.randn(4),
  7.        'data2': np.random.randn(4)}
  9. df = pd.DataFrame(var)
  10. print(df)
  11. '''
  12.   key1 key2     data1     data2
  13. 0    a  one -0.521521 -1.497652
  14. 1    b  one  0.671180 -1.394252
  15. 2    a  two -0.884387 -0.006109
  16. 3    b  two -0.047436 -0.876259
  17. '''
  19. print(type(df.groupby('key1')))
  20. # <class 'pandas.core.groupby.generic.DataFrameGroupBy'>
  22. print(type(df['data1'].groupby(df['key1'])))
  23. # <class 'pandas.core.groupby.generic.SeriesGroupBy'>

分组运算

对group对象进行分组运算，非数值数据不进行分组运算

  1. # size()返回每个分组的元素个数
  2. print(df.groupby('key1').size())
  3. '''
  4. key1
  5. a    2
  6. b    2
  7. dtype: int64
  8. '''
  10. print(df.groupby(['key1', 'key2']).size())
  11. '''
  12. key1  key2
  13. a     one     1
  14.       two     1
  15. b     one     1
  16.       two     1
  17. dtype: int64
  18. '''
  20. print(df['data1'].groupby(df['key1']).size())
  21. '''
  22. key1
  23. a    2
  24. b    2
  25. Name: data1, dtype: int64
  26. '''

聚合

内置的聚合函数

sum()、mean()、max()、min()、count()、size()、describe()等
image.png

自定义函数，传入agg方法中

  1. import pandas as pd
  2. import numpy as np
  4. var = {'key1': ['a', 'b', 'a', 'b'],
  5.        'key2': ['one', 'one', 'two', 'two'],
  6.        'data1': np.random.randn(4),
  7.        'data2': np.random.randn(4)}
  9. df = pd.DataFrame(var)
  10. print(df)
  11. '''
  12.   key1 key2     data1     data2
  13. 0    a  one -0.347282  0.826907
  14. 1    b  one -0.387571  1.319850
  15. 2    a  two -0.659646  0.543489
  16. 3    b  two  0.899404  0.508680
  17. '''
  19. def peak_range(g):
  20.     return g.max() - g.min()
  22. print(df.groupby('key1').agg(peak_range))
  23. print(df.groupby('key1').agg(lambda g: g.max() - g.min()))
  24. '''
  25.          data1     data2
  26. key1                    
  27. a     0.312364  0.283418
  28. b     1.286975  0.811170
  29. '''

使用多个聚合函数

  1. def peak_range(g):
  2.     return g.max() - g.min()
  4. print(df.groupby('key1').agg(['mean', 'count', peak_range]))
  5. '''
  6.          data1                      data2                 
  7.           mean count peak_range      mean count peak_range
  8. key1                                                      
  9. a    -0.411191     2   0.204956 -0.396638     2   1.254341
  10. b    -1.417198     2   0.579441 -1.376166     2   1.557887
  11. '''
  13. # 通过元组提供新的列名
  14. print(df.groupby('key1').agg(['mean', 'count', ('range', peak_range)]))
  15. '''
  16.          data1                     data2                
  17.           mean count     range      mean count     range
  18. key1                                                    
  19. a    -0.411191     2  0.204956 -0.396638     2  1.254341
  20. b    -1.417198     2  0.579441 -1.376166     2  1.557887
  21. '''

对不同的列使用不同的聚合函数

使用dict

  1. print(df.groupby('key1').agg({'data1': 'mean', 'data2': 'sum'}))
  2. '''
  3.          data1     data2
  4. key1                    
  5. a    -0.624912  1.954829
  6. b     1.062752 -1.502316
  7. '''
  9. print(df.groupby('key1').agg({'data1': ['mean', 'max'], 'data2': 'sum'}))
  10. '''
  11.          data1               data2
  12.           mean       max       sum
  13. key1                              
  14. a    -0.624912 -0.446746  1.954829
  15. b     1.062752  2.126030 -1.502316
  16. '''