官方文档

1. 安装Pandas

  1. windos下cmd：pip install pandas
  3. 导入pandas包：import pandas as pd

2. Series对象

带索引的一维数组

  1. 创建：
  2. s = pd.Series([12,-4,7,9])
  3. print (s)
  4. 0    12
  5. 1    -4
  6. 2     7
  7. 3     9
  8. dtype: int64
  10. s = pd.Series([12,-4,7,9], index = ['a', 'b', 'c', 'd'])
  11. print (s)
  12. a    12
  13. b    -4
  14. c     7
  15. d     9
  16. dtype: int64
  18. 查看元素
  19. print(s.values)
  20. [12 -4  7  9]
  22. 查看索引标签
  23. print(s.index)
  24. Index(['a', 'b', 'c', 'd'], dtype='object')
  26. 使用NumPy数组定义Series对象
  27. >>> arr = np.array([1,2,3,4])
  28. >>> s3 = pd.Series(arr)
  29. >>> s3
  30. 0    1
  31. 1    2
  32. 2    3
  33. 3    4
  34. dtype: int32
  36. 使用Series对象也可以定义NumPy数组
  37. >>> arr = np.array(s)
  38. >>> arr
  39. array([12, -4,  7,  9], dtype=int64)
  41. Series对象当做字典
  42. >>> dict = {'red':200, 'blue':20, 'orange':10}
  43. >>> s = pd.Series(dict)
  44. >>> s
  45. blue       20
  46. orange     10
  47. red       200
  48. dtype: int64
  49. >>> dict
  50. {'red': 200, 'orange': 10, 'blue': 20}
  52. 在上例的基础上
  53. >>> dict = {'red':100, 'blue':30, 'black':50}
  54. >>> ss = pd.Series(dict)
  55. >>> ss + s
  56. black       NaN
  57. blue       50.0
  58. orange      NaN
  59. red       300.0
  60. dtype: float64
  61. >>> ss - s
  62. black       NaN
  63. blue       10.0
  64. orange      NaN
  65. red      -100.0
  66. dtype: float64
  67. 说明Series对象相运算都是取索引的标签的交集进行运算，没有交集的值为NaN

2. DataFrame对象

类似于Excel表。设计初衷是将Series由一维拓展到多维。

2.1. 定义

  1. >>> data = {'color' : ['blue','green','yellow','red','white'],
  2. ... 'object' : ['ball','pen','pencil','paper','mug'],
  3. ... 'price' : [1.2,1.0,0.6,0.9,1.7]}
  4. >>> frame = pd.DataFrame(data)
  5. >>> frame
  6.     color  object  price
  7. 0    blue    ball    1.2
  8. 1   green     pen    1.0
  9. 2  yellow  pencil    0.6
  10. 3     red   paper    0.9
  11. 4   white     mug    1.7
  13. 可以只创建部分的列
  14. >>> frame2 = pd.DataFrame(data, columns=['object','price'])
  15. >>> frame2
  16.    object  price
  17. 0    ball    1.2
  18. 1     pen    1.0
  19. 2  pencil    0.6
  20. 3   paper    0.9
  21. 4     mug    1.7
  23. 和Series一样可以指明索引的标签
  24. >>> frame3 = pd.DataFrame(data, index = ['a', 'b', 'c', 'd', 'e'])
  25. >>> frame3
  26.     color  object  price
  27. a    blue    ball    1.2
  28. b   green     pen    1.0
  29. c  yellow  pencil    0.6
  30. d     red   paper    0.9
  31. e   white     mug    1.7
  33. 使用np.array快速创建
  34. >>> frame4 = pd.DataFrame(np.arange(16).reshape((4,4)), index = ['red', 'blue', 'yellow', 'white'], columns = ['ball', 'pen', 'pencil', 'paper'])
  35. >>> frame4
  36.         ball  pen  pencil  paper
  37. red        0    1       2      3
  38. blue       4    5       6      7
  39. yellow     8    9      10     11
  40. white     12   13      14     15
  42. 使用嵌套字典创建(可以看出列是一级字典的键值,索引标签是二级字典的键值)
  43. >>> dict = {'red' : {1000: 1, 2000: 2}, 'blue' : {3000: 3, 4000: 4}, 'orange' : {1000: 10, 3000: 30}}
  44. >>> frame = pd.DataFrame(dict)
  45. >>> frame
  46.       blue  orange  red
  47. 1000   NaN    10.0  1.0
  48. 2000   NaN     NaN  2.0
  49. 3000   3.0    30.0  NaN
  50. 4000   4.0     NaN  NaN

2.2. 选取元素

  1. 和Series类似，多了一个查看列名
  2. >>> frame4.columns
  3. Index(['ball', 'pen', 'pencil', 'paper'], dtype='object')
  4. >>> frame4.index
  5. Index(['red', 'blue', 'yellow', 'white'], dtype='object')
  6. >>> frame4.values
  7. array([[ 0,  1,  2,  3],
  8.        [ 4,  5,  6,  7],
  9.        [ 8,  9, 10, 11],
  10.        [12, 13, 14, 15]])
  12. 查看列信息
  13. >>> frame4['pencil']
  14. red        2
  15. blue       6
  16. yellow    10
  17. white     14
  18. Name: pencil, dtype: int32
  20. 查看行信息
  21. >>> frame4.ix[2]
  22. ball       8
  23. pen        9
  24. pencil    10
  25. paper     11
  26. Name: yellow, dtype: int32
  28. 同时可以使用切片来查询行信息
  29. >>> frame4[1:3]
  30.         ball  pen  pencil  paper
  31. blue       4    5       6      7
  32. yellow     8    9      10     11
  34. 查找具体的元素，用索引和用索引的标签都是一样的（这里应该先用列再用行..本来都是习惯先行再列的）
  35. >>> frame4['pencil'][1]
  36. 6
  37. >>> frame4['pencil']['blue']
  38. 6

2.3. 赋值和删除

  1. 给index和columns设置标签
  2. >>> frame4.index.name = '茵蒂克丝'(我只是个魔禁粉)
  3. >>> frame4.columns.name = '考拉能丝'(为了协调)
  4. >>> frame4
  5. 考拉能丝    ball  pen  pencil  paper
  6. 茵蒂克丝
  7. red        0    1       2      3
  8. blue       4    5       6      7
  9. yellow     8    9      10     11
  10. white     12   13      14     15
  12. 添加新的列
  13. >>> frame4['new'] = [101, 102, 103, 104]
  14. >>> frame4
  15. 考拉能丝    ball  pen  pencil  paper  new
  16. 茵蒂克丝
  17. red        0    1       2      3  101
  18. blue       4    5       6      7  102
  19. yellow     8    9      10     11  103
  20. white     12   13      14     15  104
  21. >>> frame4['newnew'] = 1000
  22. >>> frame4
  23. 考拉能丝    ball  pen  pencil  paper  new  newnew
  24. 茵蒂克丝
  25. red        0    1       2      3  101    1000
  26. blue       4    5       6      7  102    1000
  27. yellow     8    9      10     11  103    1000
  28. white     12   13      14     15  104    1000
  30. 删除一列
  31. >>> del frame4['new']
  32. >>> frame4
  33. 考拉能丝    ball  pen  pencil  paper  newnew
  34. 茵蒂克丝
  35. red        0    1       2      3    1000
  36. blue       4    5       6      7    1000
  37. yellow     8    9      10     11    1000
  38. white     12   13      14     15    1000

2.4. 转置

  1. 很强大，把列变成行，行变成列
  2. >>> frame4.T
  3. 茵蒂克丝     red  blue  yellow  white
  4. 考拉能丝
  5. ball       0     4       8     12
  6. pen        1     5       9     13
  7. pencil     2     6      10     14
  8. paper      3     7      11     15
  9. newnew  1000  1000    1000   1000

3. Index对象

3.1. Index的tips

  1. 索引是可以重复的
  2. >>> s = pd.Series(range(6), index = ['white', 'blue', 'white', 'green', 'green', 'orange'])
  3. >>> s
  4. white     0
  5. blue      1
  6. white     2
  7. green     3
  8. green     4
  9. orange    5
  10. dtype: int32
  11. 一个标签对应多个元素，会得到一个Series对象。(DataFrame同理)
  12. >>> s['green']
  13. green    3
  14. green    4
  15. dtype: int32

3.2. Index的一些方法

  1. 返回索引值最大和最小的元素
  2. >>> s.idxmax()
  3. 'orange'
  4. >>> s.idxmin()
  5. 'white'
  7. 判断数据结构中是否存在重复的索引项
  8. >>> s.index.is_unique
  9. False

3.3. 更换索引

  1. 虽然数据结构一旦声明，Index对象不能改变，但是可以通过reindex方法改变索引标签。
  2. >>> s = pd.Series([2,5,7,4], index = ['a', 'b', 'c', 'd'])
  3. >>> s
  4. a    2
  5. b    5
  6. c    7
  7. d    4
  8. dtype: int64
  9. >>> s.reindex(['b', 'a', 'd', 'e'])
  10. b    5.0
  11. a    2.0
  12. d    4.0
  13. e    NaN
  14. dtype: float64
  15. 这个例子可以看出，可以更换索引标签的顺序，新的标签会赋值为NaN。
  17. 自动完成索引
  18. >>> s = pd.Series([1,5,6,3], index = [0,3,5,6])
  19. >>> s
  20. 0    1
  21. 3    5
  22. 5    6
  23. 6    3
  24. dtype: int64
  25. >>> s.reindex(range(7), method = 'ffill')
  26. 0    1
  27. 1    1
  28. 2    1
  29. 3    5
  30. 4    5
  31. 5    6
  32. 6    3
  33. dtype: int64
  34. >>> s.reindex(range(7), method = 'bfill')
  35. 0    1
  36. 1    5
  37. 2    5
  38. 3    5
  39. 4    6
  40. 5    6
  41. 6    3
  42. dtype: int64
  43. range(7)代表索引的值为0~6，method代表填充的方式.
  44. 'ffill'是新插入的索引，其元素为索引编号比它小的那一项的元素，例如索引1就使用索引0的元素，索引2使用索引1的元素。
  45. 'bfill'是新插入的索引，其元素为索引编号比它大的那一项的元素。

3.4. 删除

  1. 使用drop()方法删除。
  2. >>> s
  3. 0    1
  4. 3    5
  5. 5    6
  6. 6    3
  7. dtype: int64
  8. >>> s.drop(3)
  9. 0    1
  10. 5    6
  11. 6    3
  12. dtype: int64
  13. >>> s.drop([0,6])
  14. 3    5
  15. 5    6
  16. dtype: int64
  18. 删除DataFrame中的元素，需要指定元素两个轴的轴标签。
  19. >>> frame = pd.DataFrame(np.arange(16).reshape(4, 4), index = ['red', 'blue', 'yellow', 'white'], columns = ['ball', 'pen', 'pencil', 'paper'])
  20. >>> frame
  21.         ball  pen  pencil  paper
  22. red        0    1       2      3
  23. blue       4    5       6      7
  24. yellow     8    9      10     11
  25. white     12   13      14     15
  26. 删除行只需要指明行的标签
  27. >>> frame.drop(['blue', 'white'])
  28.         ball  pen  pencil  paper
  29. red        0    1       2      3
  30. yellow     8    9      10     11
  31. 删除列还要指明从哪个轴删除元素。
  32. >>> frame.drop(['pen', 'pencil'], axis = 1)
  33.         ball  paper
  34. red        0      3
  35. blue       4      7
  36. yellow     8     11
  37. white     12     15

4. DataFrame和Series之间的运算

  1. >>> frame
  2.         ball  pen  pencil  paper
  3. red        0    1       2      3
  4. blue       4    5       6      7
  5. yellow     8    9      10     11
  6. white     12   13      14     15
  7. >>> s = pd.Series(np.arange(4), ['ball', 'pen', 'pencil', 'paper'])
  8. 按照frame的列名生成Series
  9. >>> s
  10. ball      0
  11. pen       1
  12. pencil    2
  13. paper     3
  14. dtype: int32
  15. >>> frame - s
  16.         ball  pen  pencil  paper
  17. red        0    0       0      0
  18. blue       4    4       4      4
  19. yellow     8    8       8      8
  20. white     12   12      12     12
  21. 一一对应相减
  22. 调整一些s中'paper'和'pencil'的位置
  23. >>> s = pd.Series(np.arange(4), ['ball', 'pen', 'paper', 'pencil'])
  24. >>> frame - s
  25.         ball  paper  pen  pencil
  26. red        0      1    0      -1
  27. blue       4      5    4       3
  28. yellow     8      9    8       7
  29. white     12     13   12      11
  30. 发现还是可以一一对应
  31. 新增一列'mug'
  32. >>> s['mug'] = 10
  33. >>> s
  34. ball       0
  35. pen        1
  36. paper      2
  37. pencil     3
  38. mug       10
  39. dtype: int64
  40. >>> frame - s
  41.         ball  mug  paper  pen  pencil
  42. red        0  NaN      1    0      -1
  43. blue       4  NaN      5    4       3
  44. yellow     8  NaN      9    8       7
  45. white     12  NaN     13   12      11
  46. 发现会增加一列'mug‘但是元素值为NaN

5. 函数运用和映射

5.1. 按行或者列执行操作的函数

  1. >>> frame
  2.         ball  pen  pencil  paper
  3. red        0    1       2      3
  4. blue       4    5       6      7
  5. yellow     8    9      10     11
  6. white     12   13      14     15
  8. 返回标量的apply()函数
  9. >>> f = lambda x : x.max() - x.min()
  10. 用apply()函数在DataFrame对象上调用函数
  11. 默认是对列使用
  12. >>> frame.apply(f)
  13. ball      12
  14. pen       12
  15. pencil    12
  16. paper     12
  17. dtype: int64
  18. 对行使用需要将axis选项设置为1
  19. >>> frame.apply(f, axis = 1)
  20. red       3
  21. blue      3
  22. yellow    3
  23. white     3
  24. dtype: int64
  26. 返回Series对象的apply()函数
  27. >>> def f(x):
  28. ...   return pd.Series([x.min(), x.max()], index = ['min', 'max']) (index对应了DataFrame的index)
  29. ...
  30. >>> frame.apply(f)
  31.      ball  pen  pencil  paper
  32. min     0    1       2      3
  33. max    12   13      14     15
  34. >>> frame.apply(f, axis = 1)
  35.         min  max
  36. red       0    3
  37. blue      4    7
  38. yellow    8   11
  39. white    12   15
  40. 我的理解：这里其实就是对每一列都跑一次f函数，对每一列都返回一个函数的值，如果指明axis = 1，就是对每一行都跑一次f函数，对每一行返回一个函数值。

5.2. 统计函数

  1. >>> frame
  2.         ball  pen  pencil  paper
  3. red        0    1       2      3
  4. blue       4    5       6      7
  5. yellow     8    9      10     11
  6. white     12   13      14     15
  7. >>> frame.sum()
  8. ball      24
  9. pen       28
  10. pencil    32
  11. paper     36
  12. dtype: int64
  13. >>> frame.mean()
  14. ball      6.0
  15. pen       7.0
  16. pencil    8.0
  17. paper     9.0
  18. dtype: float64
  19. >>> frame.describe()
  20.             ball        pen     pencil      paper
  21. count   4.000000   4.000000   4.000000   4.000000 (返回不为NaN的元素个数)
  22. mean    6.000000   7.000000   8.000000   9.000000 (返回平均值)
  23. std     5.163978   5.163978   5.163978   5.163978 (返回标准差)
  24. min     0.000000   1.000000   2.000000   3.000000
  25. 25%     3.000000   4.000000   5.000000   6.000000
  26. 50%     6.000000   7.000000   8.000000   9.000000
  27. 75%     9.000000  10.000000  11.000000  12.000000
  28. max    12.000000  13.000000  14.000000  15.000000 (剩下的都能看懂)

6. 排序函数

6.1. 对Series排序

  1. >>> s = pd.Series([5,0,3,8,4], index = ['red', 'blue', 'yellow', 'white', 'green'])
  2. >>> s
  3. red       5
  4. blue      0
  5. yellow    3
  6. white     8
  7. green     4
  8. dtype: int64
  10. 按照索引名的字典序排序
  11. >>> s.sort_index()
  12. blue      0
  13. green     4
  14. red       5
  15. white     8
  16. yellow    3
  17. dtype: int64
  18. >>> s.sort_index(ascending=False) (降序)
  19. yellow    3
  20. white     8
  21. red       5
  22. green     4
  23. blue      0
  24. dtype: int64
  26. 按照值进行排序
  27. >>> s.sort_values()
  28. blue      0
  29. yellow    3
  30. green     4
  31. red       5
  32. white     8
  33. dtype: int64
  34. >>> s.sort_values(ascending=False)
  35. white     8
  36. red       5
  37. green     4
  38. yellow    3
  39. blue      0
  40. dtype: int64
  41. 书上写的是s.order()，但是自己实现起来出现错误，上网找了是sort_values()方法。
  43. 排位次操作(按照元素的值排位)
  44. >>> s.rank()
  45. red       4.0
  46. blue      1.0
  47. yellow    2.0
  48. white     5.0
  49. green     3.0
  50. dtype: float64
  51. >>> s.rank(ascending=False)
  52. red       2.0
  53. blue      5.0
  54. yellow    4.0
  55. white     1.0
  56. green     3.0
  57. dtype: float64

6.2. 对DataFrame排序

  1. >>> frame
  2.         ball  pen  pencil  paper
  3. red        0    1       2      3
  4. blue       4    5       6      7
  5. yellow     8    9      10     11
  6. white     12   13      14     15
  8. 按照索引和列名排序
  9. >>> frame.sort_index()
  10.         ball  pen  pencil  paper
  11. blue       4    5       6      7
  12. red        0    1       2      3
  13. white     12   13      14     15
  14. yellow     8    9      10     11
  15. >>> frame.sort_index(axis=1)
  16.         ball  paper  pen  pencil
  17. red        0      3    1       2
  18. blue       4      7    5       6
  19. yellow     8     11    9      10
  20. white     12     15   13      14
  21. 注意这里都是对索引标签和对列名进行排序的，而不是按元素大小
  23. 按照值排序
  24. 按照列进行排序
  25. >>> frame.sort_values(by='pen')
  26.         ball  pen  pencil  paper
  27. red        0    1       2      3
  28. blue       4    5       6      7
  29. yellow     8    9      10     11
  30. white     12   13      14     15
  31. 按照行进行排序
  32. >>> frame.sort_values(by='blue', axis = 1)
  33.         ball  pen  pencil  paper
  34. red        0    1       2      3
  35. blue       4    5       6      7
  36. yellow     8    9      10     11
  37. white     12   13      14     15
  38. 这里书上应该是版本过旧，写的是sort_index()而不是sort_values()

7. 相关性和协方差

概念

相关性(correlation)

指两个变量之间的关系（或依赖关系）。

线性相关是指两个变量之间的直接关系。

相关性可以在-1（完全负相关）和+1（完美正相关）之间，0表示无线性关系。

协方差(covariance)

从直观上来看，协方差表示的是两个变量总体误差的期望。

如果两个变量的变化趋势一致，也就是说如果其中一个大于自身的期望值时另外一个也大于自身的期望值，那么两个变量之间的协方差就是正值；如果两个变量的变化趋势相反，即其中一个变量大于自身的期望值时另外一个却小于自身的期望值，那么两个变量之间的协方差就是负值。

二者关系

\[r_{ξ,η} = \frac{Cov(ξ,η)}{\sqrt{Dξ}\sqrt{Dη}}
\]

其中r为相关性，Cov为协方差。

知乎上的解释

相关性和协方差的解释

  1. >>> frame
  2.         ball  pen  pencil  paper
  3. red        0    1       2      3
  4. blue       4    5       6      7
  5. yellow     8    9      10     11
  6. white     12   13      14     15
  8. 用cov()和corr()计算协方差和相关系数
  9. 这个是书上写的，并不是很懂意义
  10. >>> frame.corr()
  11.         ball  pen  pencil  paper
  12. ball     1.0  1.0     1.0    1.0
  13. pen      1.0  1.0     1.0    1.0
  14. pencil   1.0  1.0     1.0    1.0
  15. paper    1.0  1.0     1.0    1.0
  16. >>> frame.cov()
  17.              ball        pen     pencil      paper
  18. ball    26.666667  26.666667  26.666667  26.666667
  19. pen     26.666667  26.666667  26.666667  26.666667
  20. pencil  26.666667  26.666667  26.666667  26.666667
  21. paper   26.666667  26.666667  26.666667  26.666667
  23. 计算某列和某列的相关系数和协方差：
  24. >>> frame.ball.corr(frame.pen)
  25. 1.0
  26. >>> frame.pen.cov(frame.ball)
  27. 26.666666666666664
  29. 用corrwith()计算DataFrame的列（axis=0，默认）或行（axis=1)跟另外一个Series或DataFrame之间的相关系数
  30. >>> frame.corrwith(frame.pen)
  31. ball      1.0
  32. pen       1.0
  33. pencil    1.0
  34. paper     1.0
  35. dtype: float64
  36. >>> frame.corrwith(frame.ix[0], axis = 1)
  37. red       1.0
  38. blue      1.0
  39. yellow    1.0
  40. white     1.0
  41. dtype: float64

8. NaN数据

8.1. 为元素赋值NaN

  1. 使用np.NaN
  2. >>> s = pd.Series([0,1,2,np.NaN,9], index = ['red', 'blue', 'yellow', 'white', 'green'])
  3. >>> s
  4. red       0.0
  5. blue      1.0
  6. yellow    2.0
  7. white     NaN
  8. green     9.0
  9. dtype: float64
  10. >>> s['white']
  11. nan

8.2. 过滤NaN

  1. 删除Series中的NaN
  2. 使用dropna()函数或者使用notnull()筛选
  3. >>> s.dropna()
  4. red       0.0
  5. blue      1.0
  6. yellow    2.0
  7. green     9.0
  8. dtype: float64
  9. >>> s[s.notnull()]
  10. red       0.0
  11. blue      1.0
  12. yellow    2.0
  13. green     9.0
  14. dtype: float64
  16. 删除DataFrame中的NaN
  17. >>> frame = pd.DataFrame([[6, np.NaN, 6], [np.NaN, np.NaN, np.NaN], [2, np.NaN, 5]], index = ['blue', 'green', 'red'], columns = ['ball', 'mug', 'pen'])
  18. >>> frame
  19.        ball  mug  pen
  20. blue    6.0  NaN  6.0
  21. green   NaN  NaN  NaN
  22. red     2.0  NaN  5.0
  23. 使用dropna()只要行或列有一个NaN，该行或列就会被删除
  25. >>> frame.dropna()
  26. Empty DataFrame
  27. Columns: [ball, mug, pen]
  28. Index: []
  29. 可以发现因为每一行都有NaN，因此把每一行都删除了
  31. 用how指定值为'all'，告知dropna()函数只删除所有元素均为NaN的行货列
  32. >>> frame.dropna(how='all')
  33.       ball  mug  pen
  34. blue   6.0  NaN  6.0
  35. red    2.0  NaN  5.0
  36. >>> frame.dropna(how='all', axis = 1)
  37.        ball  pen
  38. blue    6.0  6.0
  39. green   NaN  NaN
  40. red     2.0  5.0

8.3. 为NaN元素填充其他值

  1. >>> frame
  2.        ball  mug  pen
  3. blue    6.0  NaN  6.0
  4. green   NaN  NaN  NaN
  5. red     2.0  NaN  5.0
  7. 对所有NaN都填充0
  8. >>> frame.fillna(0)
  9.        ball  mug  pen
  10. blue    6.0  0.0  6.0
  11. green   0.0  0.0  0.0
  12. red     2.0  0.0  5.0
  14. 指定列填充元素
  15. >>> frame.fillna({'ball':1, 'mug':10, 'pen':0})
  16.        ball   mug  pen
  17. blue    6.0  10.0  6.0
  18. green   1.0  10.0  0.0
  19. red     2.0  10.0  5.0
  21. 貌似无法指定行填充元素，如果有错请务必告诉我
  22. >>> frame.fillna({'blue':1, 'green':100, 'red':0}, axis = 1)
  23. Traceback (most recent call last):
  24.   File "<stdin>", line 1, in <module>
  25.   File "E:\Python\Python3\lib\site-packages\pandas\core\frame.py", line 2754, in fillna
  26.     downcast=downcast, **kwargs)
  27.   File "E:\Python\Python3\lib\site-packages\pandas\core\generic.py", line 3639, in fillna
  28.     raise NotImplementedError('Currently only can fill '
  29. NotImplementedError: Currently only can fill with dict/Series column by column
  30. >>> frame.fillna({'blue':1, 'green':100, 'red':0})
  31.        ball  mug  pen
  32. blue    6.0  NaN  6.0
  33. green   NaN  NaN  NaN
  34. red     2.0  NaN  5.0

9. 等级索引和分级

  1. 多级索引
  2. >>> s = pd.Series(np.random.rand(8), index = [['white', 'white', 'white', 'blue', 'blue', 'red', 'blue', 'red'], ['up', 'down', 'right', 'up', 'down', 'up', 'left', 'left']])
  3. >>> s
  4. white  up       0.683135
  5.        down     0.206419
  6.        right    0.616636
  7. blue   up       0.010939
  8.        down     0.419153
  9. red    up       0.632491
  10. blue   left     0.060663
  11. red    left     0.713318
  12. dtype: float64
  14. >>> s.index
  15. MultiIndex(levels=[['blue', 'red', 'white'], ['down', 'left', 'right', 'up']],
  16.            labels=[[2, 2, 2, 0, 0, 1, 0, 1], [3, 0, 2, 3, 0, 3, 1, 1]])
  18. 指明第一列索引
  19. >>> s['blue']
  20. up      0.010939
  21. down    0.419153
  22. left    0.060663
  23. dtype: float64
  25. 指明第二列索引要类似切片用[:,第二列名]，直接用[第二列名]会报错
  26. >>> s[:,'up']
  27. white    0.683135
  28. blue     0.010939
  29. red      0.632491
  30. dtype: float64
  32. >>> s['white','up']
  33. 0.68313456001550599
  35. 使用unstack()将使用等级索引的Series对象转换为一个DataFrame对象，把第二列索引转换为相应的列
  36. >>> s.unstack()
  37.            down      left     right        up
  38. blue   0.419153  0.060663       NaN  0.010939
  39. red         NaN  0.713318       NaN  0.632491
  40. white  0.206419       NaN  0.616636  0.683135
  42. 逆操作，使用stack()将DataFrame对象转换为Series对象，列名为第二列索引
  43. >>> frame
  44.        ball  mug  pen
  45. blue    6.0  NaN  6.0
  46. green   NaN  NaN  NaN
  47. red     2.0  NaN  5.0
  48. >>> frame.stack()
  49. blue  ball    6.0
  50.       pen     6.0
  51. red   ball    2.0
  52.       pen     5.0
  53. dtype: float64
  55. 对DataFrame，为行和列都定义等级索引。
  56. >>> frame1 = pd.DataFrame(np.random.rand(16).reshape(4, 4), index = [['white', 'white', 'red', 'red'], ['up', 'down', 'up', 'down']], columns = [['pen', 'pen', 'paper', 'paper'], [1, 2, 1, 2]])
  57. >>> frame1
  58.                  pen               paper
  59.                    1         2         1         2
  60. white up    0.461711  0.907535  0.720078  0.706302
  61.       down  0.105371  0.673227  0.118255  0.401674
  62. red   up    0.339669  0.307175  0.831875  0.699694
  63.       down  0.946733  0.014064  0.716693  0.243006

9.1. 重新调整顺序和为层级排序

  1. >>> frame1.columns.names = ['objects', 'id']
  2. >>> frame1.index.names = ['colors', 'status']
  3. >>> frame1
  4. objects             pen               paper
  5. id                    1         2         1         2
  6. colors status
  7. white  up      0.461711  0.907535  0.720078  0.706302
  8.        down    0.105371  0.673227  0.118255  0.401674
  9. red    up      0.339669  0.307175  0.831875  0.699694
  10.        down    0.946733  0.014064  0.716693  0.243006
  12. 交换层级
  13. >>> frame1.swaplevel('colors', 'status')
  14. objects             pen               paper
  15. id                    1         2         1         2
  16. status colors
  17. up     white   0.461711  0.907535  0.720078  0.706302
  18. down   white   0.105371  0.673227  0.118255  0.401674
  19. up     red     0.339669  0.307175  0.831875  0.699694
  20. down   red     0.946733  0.014064  0.716693  0.243006
  22. 对某个层级的数据排序
  23. 书上用sortlevel()方法，应该还是旧版本原因
  24. 文档用的是sort_index()方法
  25. >>> frame1.sort_index(level = 'colors')
  26. objects             pen               paper
  27. id                    1         2         1         2
  28. colors status
  29. red    down    0.946733  0.014064  0.716693  0.243006
  30.        up      0.339669  0.307175  0.831875  0.699694
  31. white  down    0.105371  0.673227  0.118255  0.401674
  32.        up      0.461711  0.907535  0.720078  0.706302
  33. >>> frame1.sort_index(level = 'objects', axis = 1)
  34. objects           paper                 pen
  35. id                    1         2         1         2
  36. colors status
  37. white  up      0.720078  0.706302  0.461711  0.907535
  38.        down    0.118255  0.401674  0.105371  0.673227
  39. red    up      0.831875  0.699694  0.339669  0.307175
  40.        down    0

9.2. 按层级统计数据

  1. 对指定的层级进行统计
  2. >>> frame1.sum(level='status')
  3. objects       pen               paper
  4. id              1         2         1         2
  5. status
  6. down     1.052105  0.687291  0.834948  0.644681
  7. up       0.801380  1.214710  1.551954  1.405997
  8. >>> frame1.sum(level='id', axis=1)
  9. id                    1         2
  10. colors status
  11. white  up      1.181789  1.613837
  12.        down    0.223626  1.074902
  13. red    up      1.171545  1.006870
  14.        down    1.663426  0.257070

Python之Pandas库学习（一）：简介的更多相关文章

  1. Python之Pandas库学习（二）：数据读写

    1. I/O API工具 读取函数 写入函数 read_csv to_csv read_excel to_excel read_hdf to_hdf read_sql to_sql read_json ...

  2. python的pandas库学习笔记

    导入: import pandas as pd from pandas import Series,DataFrame 1.两个主要数据结构:Series和DataFrame (1)Series是一种 ...

  3. Python之Pandas库学习（三）：数据处理

    1. 合并 可以将其理解为SQL中的JOIN操作,使用一个或多个键把多行数据结合在一起. 1.1. 简单合并 参数on表示合并依据的列,参数how表示用什么方式操作(默认是内连接). >> ...

  4. Python之Pandas库常用函数大全（含注释）

    前言:本博文摘抄自中国慕课大学上的课程<Python数据分析与展示>,推荐刚入门的同学去学习,这是非常好的入门视频. 继续一个新的库,Pandas库.Pandas库围绕Series类型和D ...

  5. pandas库学习笔记（二）DataFrame入门学习

    Pandas基本介绍——DataFrame入门学习 前篇文章中,小生初步介绍pandas库中的Series结构的创建与运算,今天小生继续“死磕自己”为大家介绍pandas库的另一种最为常见的数据结构D ...

  6. python爬虫解析库学习

    一.xpath库使用: 1.基本规则: 2.将文件转为HTML对象: html = etree.parse('./test.html', etree.HTMLParser()) result = et ...

  7. Python数据分析Pandas库方法简介

    Pandas 入门 Pandas简介 背景:pandas是一个Python包,提供快速,灵活和富有表现力的数据结构,旨在使“关系”或“标记”数据的使用既简单又直观.它旨在成为在Python中进行实际, ...

  8. Python html.parser库学习小结

    分类路径:/Datazen/DataMining/Crawler/   前段时间,一朋友让我做个小脚本,抓一下某C2C商城上竞争对手的销售/价格数据,好让他可以实时调整自己的营销策略.自己之前也有过写 ...

  9. Python之matplotlib库学习

    matplotlib 是python最著名的绘图库,它提供了一整套和matlab相似的命令API,十分适合交互式地进行制图.而且也可以方便地将它作为绘图控件,嵌入GUI应用程序中. 它的文档相当完备, ...

随机推荐

  1. Altera公司高速PCB布线指南

    来至Altera公司的高速PCB布线指南,该文档言简意赅,深入浅出,对于日常高速PCB布局布线中经常碰到的一些问题进行了解析.例如:板材的选择,介电常数及损耗因子对高速高频线路的影响,传输线,阻抗控制 ...

  2. 日志文件 清理or压缩

    1.操作前请断开所有数据库连接. 2.分离数据库 分离数据库:企业管理器->服务器->数据库->cwbase1->右键->分离数据库 分离后,cwbase1数据库被删除, ...

  3. JS 密码弱中强显示

    <!DOCTYPE html><html><head>    <meta http-equiv="Content-Type" conten ...

  4. js div的显示和隐藏

    <head>    <title></title>    <style type="text/css">        div    ...

  5. 用MVVM模式开发中遇到的零散问题总结（5）——将动态加载的可视元素保存为图片的控件，Binding刷新的时机

    原文:用MVVM模式开发中遇到的零散问题总结(5)--将动态加载的可视元素保存为图片的控件,Binding刷新的时机 在项目开发中经常会遇到这样一种情况,就是需要将用户填写的信息排版到一张表单中,供打 ...

  6. Gradle离线配置

    原文:Gradle离线配置 1. 先在Gradle官网下载最新的离线zip压缩包. https://gradle.org/ 2. 将下载的zip压缩包,保存到本地磁盘下的目录中. 3. 修改(grad ...

  7. 从PRISM开始学WPF（八）导航Navigation？

    原文:从PRISM开始学WPF(八)导航Navigation? 0x6Navigation Basic Navigation Prism中的Navigation提供了一种类似导航的功能,他可以根据用户 ...

  8. Win10《芒果TV》商店版更新v3.2.6：修复后台任务故障，优化推送频次

    2017湖南卫视大型音乐竞技节目<歌手>,2017年1月21日晚首播第一期,7位歌手惊艳亮嗓,<芒果TV>UWP版迅速更新v3.2.6版,主要是修复后台任务故障,优化推送频次, ...

  9. 处理 Windows Phone 应用中的“后退”按钮 (XAML)

    与电脑不同,所有 Windows Phone 设备都有“后退”按钮,它允许用户在应用的页面之间向后导航.如果用户在转到应用的第一页时再次按“后退”按钮,操作系统会挂起你的应用并将用户导航到应用启动前的 ...

  10. mysql启动脚本

    一台服务器上安装多个MySQL实例之后,实例的启动关闭不能再用service mysqld start/stop/restart命令,所以编写如下脚本用于启动关闭对应端口的实例. 这个脚本适用于多实例 ...