Pandas 是 Python 的核心数据分析支持库，提供了快速、灵活、明确的数据结构，旨在简单、直观地处理关系型、标记型数据。Pandas 的目标是成为 Python 数据分析实践与实战的必备高级工具，其长远目标是成为最强大、最灵活、可以支持任何语言的开源数据分析工具。经过多年不懈的努力，Pandas 离这个目标已经越来越近了。
Pandas 适用于处理以下类型的数据：

  • 与 SQL 或 Excel 表类似的，含异构列的表格数据;
  • 有序和无序（非固定频率）的时间序列数据;
  • 带行列标签的矩阵数据，包括同构或异构型数据;
  • 任意其它形式的观测、统计数据集, 数据转入 Pandas 数据结构时不必事先标记。

image.png

数据结构

维数 名称 描述
1 Series 带标签的一维同构数组
2 DataFrame 带标签的，大小可变的，二维异构表格

Series数据结构

  1. # Series 是带有标签的一维数组，可以保存任何数据类型（整数，字符串，浮点数，Python对象等）,轴标签统称为索引
  3. import numpy as np
  4. import pandas as pd  
  5. # 导入numpy、pandas模块
  7. ar = np.random.rand(5)
  8. print(ar)
  9. s = pd.Series(ar)
  10. print(s)
  11. print(type(s))
  12. # 查看数据、数据类型
  14. print(s.index,type(s.index))
  15. print(s.values,type(s.values))
  16. # .index查看series索引，类型为rangeindex
  17. # .values查看series值，类型是ndarray
  19. # 核心：series相比于ndarray，是一个自带索引index的数组 → 一维数组 + 对应索引
  20. # 所以当只看series的值的时候，就是一个ndarray
  21. # series和ndarray较相似，索引切片功能差别不大
  22. # series和dict相比，series更像一个有顺序的字典（dict本身不存在顺序），其索引原理与字典相似（一个用key，一个用index）
  24. ------------------------------------
  26. [0.57879139 0.74160843 0.96094125 0.51813092 0.47592715]
  27. 0    0.578791
  28. 1    0.741608
  29. 2    0.960941
  30. 3    0.518131
  31. 4    0.475927
  32. dtype: float64
  33. <class 'pandas.core.series.Series'>
  34. RangeIndex(start=0, stop=5, step=1) <class 'pandas.core.indexes.range.RangeIndex'>
  35. [0.57879139 0.74160843 0.96094125 0.51813092 0.47592715] <class 'numpy.ndarray'>

创建数据

pd.Series()
参数

  • data ： 类似数组的、可迭代的、dict或标量值包含按序列存储的数据。
  • index: 类数组或索引(1d)

值必须是hashable和有相同的长度的“数据”。允许使用非唯一索引值。将默认为RangeIndex(0,1,2，…， n)如果未提供。如果字典和索引都是，则索引将覆盖在字典

  • dtype:
  • name：name为Series的一个参数，创建一个数组的 名称
  • copy：


  1. # Series 名称属性：name
  3. s1 = pd.Series(np.random.randn(5))
  4. print(s1)
  5. print('-----')
  6. s2 = pd.Series(np.random.randn(5),name = 'test')
  7. print(s2)
  8. print(s1.name, s2.name,type(s2.name))
  9. # name为Series的一个参数，创建一个数组的 名称
  10. # .name方法：输出数组的名称，输出格式为str，如果没用定义输出名称，输出为None
  12. s3 = s2.rename('hehehe')
  13. print(s3)
  14. print(s3.name, s2.name)
  15. # .rename()重命名一个数组的名称，并且新指向一个数组，原数组不变
  17. --------------------------------------
  19. 0   -0.403084
  20. 1    1.369383
  21. 2    1.134319
  22. 3   -0.635050
  23. 4    1.680211
  24. dtype: float64
  25. -----
  26. 0   -0.120014
  27. 1    1.967648
  28. 2    1.142626
  29. 3    0.234079
  30. 4    0.761357
  31. Name: test, dtype: float64
  32. None test <class 'str'>
  33. 0   -0.120014
  34. 1    1.967648
  35. 2    1.142626
  36. 3    0.234079
  37. 4    0.761357
  38. Name: hehehe, dtype: float64
  39. hehehe test

Series 创建方法一：由字典创建，字典的key就是index，values就是values

  1. dic = {'a':1 ,'b':2 , 'c':3, '4':4, '5':5}
  2. s = pd.Series(dic)
  3. print(s)
  4. # 注意：key肯定是字符串，假如values类型不止一个会怎么样？ → dic = {'a':1 ,'b':'hello' , 'c':3, '4':4, '5':5}
  6. -------------------------------------
  8. 4    4
  9. 5    5
  10. a    1
  11. b    2
  12. c    3
  13. dtype: int64

Series 创建方法二：由数组创建(一维数组)

  1. arr = np.random.randn(5)
  2. s = pd.Series(arr)
  3. print(arr)
  4. print(s)
  5. # 默认index是从0开始，步长为1的数字
  7. s = pd.Series(arr, index = ['a','b','c','d','e'],dtype = np.object)
  8. print(s)
  9. # index参数：设置index，长度保持一致
  10. # dtype参数：设置数值类型
  12. -------------------------------------
  14. [ 0.11206121  0.1324684   0.59930544  0.34707543 -0.15652941]
  15. 0    0.112061
  16. 1    0.132468
  17. 2    0.599305
  18. 3    0.347075
  19. 4   -0.156529
  20. dtype: float64
  21. a    0.112061
  22. b    0.132468
  23. c    0.599305
  24. d    0.347075
  25. e   -0.156529
  26. dtype: object

Series 创建方法三：由标量创建

  1. s = pd.Series(10, index = range(4))
  2. print(s)
  3. # 如果data是标量值，则必须提供索引。该值会重复，来匹配索引的长度
  5. ---------------------------
  7. 0    10
  8. 1    10
  9. 2    10
  10. 3    10
  11. dtype: int64


下标索引

位置下标，类似序列

  1. s = pd.Series(np.random.rand(5))
  2. print(s)
  3. print(s[0],type(s[0]),s[0].dtype)
  4. print(float(s[0]),type(float(s[0])))
  5. #print(s[-1])
  6. # 位置下标从0开始
  7. # 输出结果为numpy.float格式，
  8. # 可以通过float()函数转换为python float格式
  9. # numpy.float与float占用字节不同
  10. # s[-1]结果如何？
  12. -----------------------------
  14. 0    0.924575
  15. 1    0.988654
  16. 2    0.426333
  17. 3    0.216504
  18. 4    0.453570
  19. dtype: float64
  20. 0.924575004833 <class 'numpy.float64'> float64
  21. 0.9245750048328816 <class 'float'>

标签索引

  1. # 
  3. s = pd.Series(np.random.rand(5), index = ['a','b','c','d','e'])
  4. print(s)
  5. print(s['a'],type(s['a']),s['a'].dtype)
  6. # 方法类似下标索引，用[]表示，内写上index，注意index是字符串
  8. sci = s[['a','b','e']]
  9. print(sci,type(sci))
  10. # 如果需要选择多个标签的值，用[[]]来表示（相当于[]中包含一个列表）
  11. # 多标签索引结果是新的数组
  13. --------------------------
  15. a    0.714630
  16. b    0.213957
  17. c    0.172188
  18. d    0.972158
  19. e    0.875175
  20. dtype: float64
  21. 0.714630383451 <class 'numpy.float64'> float64
  22. a    0.714630
  23. b    0.213957
  24. e    0.875175
  25. dtype: float64 <class 'pandas.core.series.Series'>

切片索引

  1. s1 = pd.Series(np.random.rand(5))
  2. s2 = pd.Series(np.random.rand(5), index = ['a','b','c','d','e'])
  3. print(s1[1:4],s1[4])
  4. print(s2['a':'c'],s2['c'])
  5. print(s2[0:3],s2[3])
  6. print('-----')
  7. # 注意：用index做切片是末端包含
  9. print(s2[:-1])
  10. print(s2[::2])
  11. # 下标索引做切片，和list写法一样
  13. -----------------------------------
  15. 1    0.865967
  16. 2    0.114500
  17. 3    0.369301
  18. dtype: float64 0.411702342342
  19. a    0.717378
  20. b    0.642561
  21. c    0.391091
  22. dtype: float64 0.39109096261
  23. a    0.717378
  24. b    0.642561
  25. c    0.391091
  26. dtype: float64 0.998978363818
  27. -----
  28. a    0.717378
  29. b    0.642561
  30. c    0.391091
  31. d    0.998978
  32. dtype: float64
  33. a    0.717378
  34. c    0.391091
  35. e    0.957639
  36. dtype: float64

布尔索引

  1. s = pd.Series(np.random.rand(3)*100)
  2. s[4] = None  # 添加一个空值
  3. print(s)
  4. bs1 = s > 50
  5. bs2 = s.isnull()
  6. bs3 = s.notnull()
  7. print(bs1, type(bs1), bs1.dtype)
  8. print(bs2, type(bs2), bs2.dtype)
  9. print(bs3, type(bs3), bs3.dtype)
  10. print('-----')
  11. # 数组做判断之后，返回的是一个由布尔值组成的新的数组
  12. # .isnull() / .notnull() 判断是否为空值 (None代表空值，NaN代表有问题的数值，两个都会识别为空值)
  14. print(s[s > 50])
  15. print(s[bs3])
  16. # 布尔型索引方法：用[判断条件]表示，其中判断条件可以是 一个语句，或者是 一个布尔型数组！
  18. --------------------------------------
  20. 0    2.03802
  21. 1    40.3989
  22. 2    25.2001
  23. 4       None
  24. dtype: object
  25. 0    False
  26. 1    False
  27. 2    False
  28. 4    False
  29. dtype: bool <class 'pandas.core.series.Series'> bool
  30. 0    False
  31. 1    False
  32. 2    False
  33. 4     True
  34. dtype: bool <class 'pandas.core.series.Series'> bool
  35. 0     True
  36. 1     True
  37. 2     True
  38. 4    False
  39. dtype: bool <class 'pandas.core.series.Series'> bool
  40. -----
  41. Series([], dtype: object)
  42. 0    2.03802
  43. 1    40.3989
  44. 2    25.2001
  45. dtype: object

数据查看

重新索引reindex

numpy.reindex将会根据索引重新排序，如果当前索引不存在，则引入缺失值

  1. s = pd.Series(np.random.rand(3), index = ['a','b','c'])
  2. print(s)
  3. s1 = s.reindex(['c','b','a','d'])
  4. print(s1)
  5. # .reindex()中也是写列表
  6. # 这里'd'索引不存在，所以值为NaN
  8. s2 = s.reindex(['c','b','a','d'], fill_value = 0)
  9. print(s2)
  10. # fill_value参数：填充缺失值的值
  12. -----------------------------------
  14. a    0.343718
  15. b    0.322228
  16. c    0.746720
  17. dtype: float64
  18. c    0.746720
  19. b    0.322228
  20. a    0.343718
  21. d         NaN
  22. dtype: float64
  23. c    0.746720
  24. b    0.322228
  25. a    0.343718
  26. d    0.000000
  27. dtype: float64

Series对齐

  1. s1 = pd.Series(np.random.rand(3), index = ['Jack','Marry','Tom'])
  2. s2 = pd.Series(np.random.rand(3), index = ['Wang','Jack','Marry'])
  3. print(s1)
  4. print(s2)
  5. print(s1+s2)
  6. # Series 和 ndarray 之间的主要区别是，Series 上的操作会根据标签自动对齐
  7. # index顺序不会影响数值计算，以标签来计算
  8. # 空值和任何值计算结果扔为空值
  10. --------------------------------------
  12. Jack     0.753732
  13. Marry    0.180223
  14. Tom      0.283704
  15. dtype: float64
  16. Wang     0.309128
  17. Jack     0.533997
  18. Marry    0.626126
  19. dtype: float64
  20. Jack     1.287729
  21. Marry    0.806349
  22. Tom           NaN
  23. Wang          NaN
  24. dtype: float64

删除Drop

  1. s = pd.Series(np.random.rand(5), index = list('ngjur'))
  2. print(s)
  3. s1 = s.drop('n')
  4. s2 = s.drop(['g','j'])
  5. print(s1)
  6. print(s2)
  7. print(s)
  8. # drop 删除元素之后返回副本(inplace=False)
  10. ----------------------------------------
  12. n    0.876587
  13. g    0.594053
  14. j    0.628232
  15. u    0.360634
  16. r    0.454483
  17. dtype: float64
  18. g    0.594053
  19. j    0.628232
  20. u    0.360634
  21. r    0.454483
  22. dtype: float64
  23. n    0.876587
  24. u    0.360634
  25. r    0.454483
  26. dtype: float64
  27. n    0.876587
  28. g    0.594053
  29. j    0.628232
  30. u    0.360634
  31. r    0.454483
  32. dtype: float64


添加

  1. s1 = pd.Series(np.random.rand(5))
  2. s2 = pd.Series(np.random.rand(5), index = list('ngjur'))
  3. print(s1)
  4. print(s2)
  5. s1[5] = 100
  6. s2['a'] = 100
  7. print(s1)
  8. print(s2)
  9. print('-----')
  10. # 直接通过下标索引/标签index添加值
  12. s3 = s1.append(s2)
  13. print(s3)
  14. print(s1)
  15. # 通过.append方法，直接添加一个数组
  16. # .append方法生成一个新的数组，不改变之前的数组
  18. ----------------------------------
  20. 0    0.516447
  21. 1    0.699382
  22. 2    0.469513
  23. 3    0.589821
  24. 4    0.402188
  25. dtype: float64
  26. n    0.615641
  27. g    0.451192
  28. j    0.022328
  29. u    0.977568
  30. r    0.902041
  31. dtype: float64
  32. 0      0.516447
  33. 1      0.699382
  34. 2      0.469513
  35. 3      0.589821
  36. 4      0.402188
  37. 5    100.000000
  38. dtype: float64
  39. n      0.615641
  40. g      0.451192
  41. j      0.022328
  42. u      0.977568
  43. r      0.902041
  44. a    100.000000
  45. dtype: float64
  46. -----
  47. 0      0.516447
  48. 1      0.699382
  49. 2      0.469513
  50. 3      0.589821
  51. 4      0.402188
  52. 5    100.000000
  53. n      0.615641
  54. g      0.451192
  55. j      0.022328
  56. u      0.977568
  57. r      0.902041
  58. a    100.000000
  59. dtype: float64
  60. 0      0.516447
  61. 1      0.699382
  62. 2      0.469513
  63. 3      0.589821
  64. 4      0.402188
  65. 5    100.000000
  66. dtype: float64

修改

  1. s = pd.Series(np.random.rand(3), index = ['a','b','c'])
  2. print(s)
  3. s['a'] = 100
  4. s[['b','c']] = 200
  5. print(s)
  6. # 通过索引直接修改，类似序列
  8. ----------------------------
  10. a    0.873604
  11. b    0.244707
  12. c    0.888685
  13. dtype: float64
  14. a    100.0
  15. b    200.0
  16. c    200.0
  17. dtype: float64

DataFrame

Dataframe 数据结构
Dataframe是一个表格型的数据结构，“带有标签的二维数组”。
Dataframe带有index（行标签）和columns（列标签）

  1. data = {'name':['Jack','Tom','Mary'],
  2.         'age':[18,19,20],
  3.        'gender':['m','m','w']}
  4. frame = pd.DataFrame(data)
  5. print(frame)  
  6. print(type(frame))
  7. print(frame.index,'\n该数据类型为：',type(frame.index))
  8. print(frame.columns,'\n该数据类型为：',type(frame.columns))
  9. print(frame.values,'\n该数据类型为：',type(frame.values))
  10. # 查看数据，数据类型为dataframe
  11. # .index查看行标签
  12. # .columns查看列标签
  13. # .values查看值，数据类型为ndarray
  15. -----------------------------------------------
  17.    age gender  name
  18. 0   18      m  Jack
  19. 1   19      m   Tom
  20. 2   20      w  Mary
  21. <class 'pandas.core.frame.DataFrame'>
  22. RangeIndex(start=0, stop=3, step=1) 
  23. 该数据类型为： <class 'pandas.indexes.range.RangeIndex'>
  24. Index(['age', 'gender', 'name'], dtype='object') 
  25. 该数据类型为： <class 'pandas.indexes.base.Index'>
  26. [[18 'm' 'Jack']
  27.  [19 'm' 'Tom']
  28.  [20 'w' 'Mary']] 
  29. 该数据类型为： <class 'numpy.ndarray'>

基本查询

image.png

排序

语法

  1. df.sort_values(by="Count_AnimalName",ascending=True)

by为以Count_AnimalName名字的列排序 ascending：排列顺序，默认为True升序，反之为降序

索引

选择行与列

取行或列的注意

  • 方括号写数组，表示取行，对行进行操作
  • 方括号写字符串，表示的取列索引，对列进行操作

还有更多的经过pandas优化过的选择方式：

  • df.loc 通过标签索引行数据
  • df.iloc 通过位置获取行数据赋值更改数据的过程： ```python df = pd.DataFrame(np.random.rand(12).reshape(3,4)*100,
    1.              index = ['one','two','three'],
    2.              columns = ['a','b','c','d'])
    print(df) print(‘——-‘)

data1 = df[‘a’] data2 = df[[‘a’,’c’]] print(data1,type(data1)) print(data2,type(data2)) print(‘——-‘)

按照列名选择列，只选择一列输出Series，选择多列输出Dataframe

data3 = df.loc[‘one’] data4 = df.loc[[‘one’,’two’]] print(data2,type(data3)) print(data3,type(data4))

按照index选择行，只选择一行输出Series，选择多行输出Dataframe

  1.            a          b          c          d

one 72.615321 49.816987 57.485645 84.226944 two 46.295674 34.480439 92.267989 17.111412

three 14.699591 92.754997 39.683577 93.255880

one 72.615321 two 46.295674 three 14.699591 Name: a, dtype: float64 a c one 72.615321 57.485645 two 46.295674 92.267989

three 14.699591 39.683577 

  1.            a          c

one 72.615321 57.485645 two 46.295674 92.267989 three 14.699591 39.683577 a 72.615321 b 49.816987 c 57.485645 d 84.226944 Name: one, dtype: float64 

  1. <a name="PJjUO"></a>
  2. #### df[] - 选择列
  3. 一般用于选择列，也可以选择行
  4. ```python
  5. df = pd.DataFrame(np.random.rand(12).reshape(3,4)*100,
  6.                    index = ['one','two','three'],
  7.                    columns = ['a','b','c','d'])
  8. print(df)
  9. print('-----')
  11. data1 = df['a']
  12. data2 = df[['b','c']]  # 尝试输入 data2 = df[['b','c','e']]
  13. print(data1)
  14. print(data2)
  15. # df[]默认选择列，[]中写列名（所以一般数据colunms都会单独制定，不会用默认数字列名，以免和index冲突）
  16. # 单选列为Series，print结果为Series格式
  17. # 多选列为Dataframe，print结果为Dataframe格式
  19. data3 = df[:1]
  20. #data3 = df[0]
  21. #data3 = df['one']
  22. print(data3,type(data3))
  23. # df[]中为数字时，默认选择行，且只能进行切片的选择，不能单独选择（df[0]）
  24. # 输出结果为Dataframe，即便只选择一行
  25. # df[]不能通过索引标签名来选择行(df['one'])
  27. # 核心笔记：df[col]一般用于选择列，[]中写列名
  29. -----------------------------------
  31.                a          b          c          d
  32. one    88.490183  93.588825   1.605172  74.610087
  33. two    45.905361  49.257001  87.852426  97.490521
  34. three  95.801001  97.991028  74.451954  64.290587
  35. -----
  36. one      88.490183
  37. two      45.905361
  38. three    95.801001
  39. Name: a, dtype: float64
  40.                b          c
  41. one    93.588825   1.605172
  42. two    49.257001  87.852426
  43. three  97.991028  74.451954
  44.              a          b         c          d
  45. one  88.490183  93.588825  1.605172  74.610087 <class 'pandas.core.frame.DataFrame'>

df.loc[] - 按index选择行

  1. df1 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
  2.                    index = ['one','two','three','four'],
  3.                    columns = ['a','b','c','d'])
  4. df2 = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
  5.                    columns = ['a','b','c','d'])
  6. print(df1)
  7. print(df2)
  8. print('-----')
  10. data1 = df1.loc['one']
  11. data2 = df2.loc[1]
  12. print(data1)
  13. print(data2)
  14. print('单标签索引\n-----')
  15. # 单个标签索引，返回Series
  17. data3 = df1.loc[['two','three','five']]
  18. data4 = df2.loc[[3,2,1]]
  19. print(data3)
  20. print(data4)
  21. print('多标签索引\n-----')
  22. # 多个标签索引，如果标签不存在，则返回NaN
  23. # 顺序可变
  25. data5 = df1.loc['one':'three']
  26. data6 = df2.loc[1:3]
  27. print(data5)
  28. print(data6)
  29. print('切片索引')
  30. # 可以做切片对象
  31. # 末端包含
  33. # 核心笔记：df.loc[label]主要针对index选择行，同时支持指定index，及默认数字index
  35. --------------------------------
  37.                a          b          c          d
  38. one    73.070679   7.169884  80.820532  62.299367
  39. two    34.025462  77.849955  96.160170  55.159017
  40. three  27.897582  39.595687  69.280955  49.477429
  41. four   76.723039  44.995970  22.408450  23.273089
  42.            a          b          c          d
  43. 0  93.871055  28.031989  57.093181  34.695293
  44. 1  22.882809  47.499852  86.466393  86.140909
  45. 2  80.840336  98.120735  84.495414   8.413039
  46. 3  59.695834   1.478707  15.069485  48.775008
  47. -----
  48. a    73.070679
  49. b     7.169884
  50. c    80.820532
  51. d    62.299367
  52. Name: one, dtype: float64
  53. a    22.882809
  54. b    47.499852
  55. c    86.466393
  56. d    86.140909
  57. Name: 1, dtype: float64
  58. 单标签索引
  59. -----
  60.                a          b          c          d
  61. two    34.025462  77.849955  96.160170  55.159017
  62. three  27.897582  39.595687  69.280955  49.477429
  63. five         NaN        NaN        NaN        NaN
  64.            a          b          c          d
  65. 3  59.695834   1.478707  15.069485  48.775008
  66. 2  80.840336  98.120735  84.495414   8.413039
  67. 1  22.882809  47.499852  86.466393  86.140909
  68. 多标签索引
  69. -----
  70.                a          b          c          d
  71. one    73.070679   7.169884  80.820532  62.299367
  72. two    34.025462  77.849955  96.160170  55.159017
  73. three  27.897582  39.595687  69.280955  49.477429
  74.            a          b          c          d
  75. 1  22.882809  47.499852  86.466393  86.140909
  76. 2  80.840336  98.120735  84.495414   8.413039
  77. 3  59.695834   1.478707  15.069485  48.775008
  78. 切片索引

df.iloc[] - 按照整数位置（从轴的0到length-1）选择行

类似list的索引，其顺序就是dataframe的整数位置，从0开始计

  3. df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
  4.                    index = ['one','two','three','four'],
  5.                    columns = ['a','b','c','d'])
  6. print(df)
  7. print('------')
  9. print(df.iloc[0])
  10. print(df.iloc[-1])
  11. #print(df.iloc[4])
  12. print('单位置索引\n-----')
  13. # 单位置索引
  14. # 和loc索引不同，不能索引超出数据行数的整数位置
  16. print(df.iloc[[0,2]])
  17. print(df.iloc[[3,2,1]])
  18. print('多位置索引\n-----')
  19. # 多位置索引
  20. # 顺序可变
  22. print(df.iloc[1:3])
  23. print(df.iloc[::2])
  24. print('切片索引')
  25. # 切片索引
  26. # 末端不包含
  28. ---------------------------------------
  30.                a          b          c          d
  31. one    21.848926   2.482328  17.338355  73.014166
  32. two    99.092794   0.601173  18.598736  61.166478
  33. three  87.183015  85.973426  48.839267  99.930097
  34. four   75.007726  84.208576  69.445779  75.546038
  35. ------
  36. a    21.848926
  37. b     2.482328
  38. c    17.338355
  39. d    73.014166
  40. Name: one, dtype: float64
  41. a    75.007726
  42. b    84.208576
  43. c    69.445779
  44. d    75.546038
  45. Name: four, dtype: float64
  46. 单位置索引
  47. -----
  48.                a          b          c          d
  49. one    21.848926   2.482328  17.338355  73.014166
  50. three  87.183015  85.973426  48.839267  99.930097
  51.                a          b          c          d
  52. four   75.007726  84.208576  69.445779  75.546038
  53. three  87.183015  85.973426  48.839267  99.930097
  54. two    99.092794   0.601173  18.598736  61.166478
  55. 多位置索引
  56. -----
  57.                a          b          c          d
  58. two    99.092794   0.601173  18.598736  61.166478
  59. three  87.183015  85.973426  48.839267  99.930097
  60.                a          b          c          d
  61. one    21.848926   2.482328  17.338355  73.014166
  62. three  87.183015  85.973426  48.839267  99.930097
  63. 切片索引

布尔型索引

和Series原理相同

  1. df = pd.DataFrame(np.random.rand(16).reshape(4,4)*100,
  2.                    index = ['one','two','three','four'],
  3.                    columns = ['a','b','c','d'])
  4. print(df)
  5. print('------')
  7. b1 = df < 20
  8. print(b1,type(b1))
  9. print(df[b1])  # 也可以书写为 df[df < 20]
  10. print('------')
  11. # 不做索引则会对数据每个值进行判断
  12. # 索引结果保留 所有数据：True返回原数据，False返回值为NaN
  14. b2 = df['a'] > 50
  15. print(b2,type(b2))
  16. print(df[b2])  # 也可以书写为 df[df['a'] > 50]
  17. print('------')
  18. # 单列做判断
  19. # 索引结果保留 单列判断为True的行数据，包括其他列
  21. b3 = df[['a','b']] > 50
  22. print(b3,type(b3))
  23. print(df[b3])  # 也可以书写为 df[df[['a','b']] > 50]
  24. print('------')
  25. # 多列做判断
  26. # 索引结果保留 所有数据：True返回原数据，False返回值为NaN
  28. b4 = df.loc[['one','three']] < 50
  29. print(b4,type(b4))
  30. print(df[b4])  # 也可以书写为 df[df.loc[['one','three']] < 50]
  31. print('------')
  32. # 多行做判断
  33. # 索引结果保留 所有数据：True返回原数据，False返回值为NaN
  35. -------------------------------
  37.                a          b          c          d
  38. one    19.185849  20.303217  21.800384  45.189534
  39. two    50.105112  28.478878  93.669529  90.029489
  40. three  35.496053  19.248457  74.811841  20.711431
  41. four   24.604478  57.731456  49.682717  82.132866
  42. ------
  43.            a      b      c      d
  44. one     True  False  False  False
  45. two    False  False  False  False
  46. three  False   True  False  False
  47. four   False  False  False  False <class 'pandas.core.frame.DataFrame'>
  48.                a          b   c   d
  49. one    19.185849        NaN NaN NaN
  50. two          NaN        NaN NaN NaN
  51. three        NaN  19.248457 NaN NaN
  52. four         NaN        NaN NaN NaN
  53. ------
  54. one      False
  55. two       True
  56. three    False
  57. four     False
  58. Name: a, dtype: bool <class 'pandas.core.series.Series'>
  59.              a          b          c          d
  60. two  50.105112  28.478878  93.669529  90.029489
  61. ------
  62.            a      b
  63. one    False  False
  64. two     True  False
  65. three  False  False
  66. four   False   True <class 'pandas.core.frame.DataFrame'>
  67.                a          b   c   d
  68. one          NaN        NaN NaN NaN
  69. two    50.105112        NaN NaN NaN
  70. three        NaN        NaN NaN NaN
  71. four         NaN  57.731456 NaN NaN
  72. ------
  73.           a     b      c     d
  74. one    True  True   True  True
  75. three  True  True  False  True <class 'pandas.core.frame.DataFrame'>
  76.                a          b          c          d
  77. one    19.185849  20.303217  21.800384  45.189534
  78. two          NaN        NaN        NaN        NaN
  79. three  35.496053  19.248457        NaN  20.711431
  80. four         NaN        NaN        NaN        NaN
  81. ------

多重索引：比如同时索引行和列

先选择列再选择行 —— 相当于对于一个数据，先筛选字段，再选择数据量