01. Pandas介绍

1.1 Pandas的基本认识

  • Pandas以NumPy为基础，为数据分析、数据挖掘、数据清洗提供了业务逻辑操作的支持。

  • Pandas中有两种常见的数据结构：

    • Series：一维数据结构。
    • DataFrame：二维数据结构，类似于表格。

      1.2 Pandas的安装与导入

  • Anaconda中默认带有Pandas库，因此Anaconda环境无需再次手动下载Pandas，直接导入即可。

  • 普通Python环境中可以通过pip命令来安装Pandas。

    1. pip install pandas

  • Pandas导入：

    1. import numpy as np
    2. import pandas as pd
    3. from pandas import Series, DataFrame

    02. Series

    2.1 Series的基本介绍

  • Series是一个类似于一维数组的一维数据对象，有显式索引和隐式索引两种访问值的方式。

  • Series除了可以用下标索引标记元素外，每个元素还有自己独特的标记，这个标记类似于字典的键。
    • 对于列表而言，它可以存储值，也可以通过索引访问值，但却无法表示每个值的含义。如一个成绩列表[77, 67, 89, 65, 49]，可以通过索引快速定位元素，但无法直观的表达每个成绩是谁的成绩。

1659342579078.jpg

  • Series就很好的解决了这个问题，根据上述例子，可以将姓名作为键，将实际的成绩作为值，存储到Series中后，不仅可以通过姓名（键）访问成绩（值），还可以通过下标访问成绩。

1659342742821.jpg

  • 这里的键被称之为显式索引，下标则被称之为隐式索引。

    2.2 Series的创建

    2.2.1 一维数组+自定义显式索引的方式创建

  • 创建结构：s = Series(data=一维数组, index=显式索引[, name=series的名称])
    • 注意：显式索引的个数要与一维数组中数据的个数一致。

  • 示例：根据2.1中的数据创建Series对象。

    1. >>> data = np.array([77, 67, 89, 65, 49])
    2. >>> index = np.array(["明明", "乐乐", "花花", "欢欢", "西西"])
    3. >>> s = Series(data=data, index=index, name="Student Score")
    4. >>> s
    5. 明明    77
    6. 乐乐    67
    7. 花花    89
    8. 欢欢    65
    9. 西西    49
    10. Name: Student Score, dtype: int32

  • 若没有手动指定显式索引，则默认使用隐式索引（下标）的数据作为显式索引。

    1. >>> data = np.array([77, 67, 89, 65, 49])
    2. >>> s = Series(data=data, name="Student Score")
    3. >>> s
    4. 0    77
    5. 1    67
    6. 2    89
    7. 3    65
    8. 4    49
    9. Name: Student Score, dtype: int32

    2.2.2 通过字典的方式创建

  • 创建结构：s = Series(data=字典对象[, index=显式索引][, name=series的名称])

    • 字典的键会作为显式索引，字典的值会作为一维数组的数据。

  • 示例：根据2.1中的数据，使用字典的形式创建Series对象。

    1. >>> score_data = {
    2. ...     "明明": 77,
    3. ...     "乐乐": 67,
    4. ...     "花花": 89,
    5. ...     "欢欢": 65,
    6. ...     "西西": 49
    7. ... }
    8. >>> s = Series(data=score_data)
    9. >>> s
    10. 明明    77
    11. 乐乐    67
    12. 花花    89
    13. 欢欢    65
    14. 西西    49
    15. dtype: int64

  • 通过字典的方式构建Series不推荐自行定义显式索引，但也可以自行定义显式索引。

  • 但若自定定义显式索引，则会和字典中的键进行匹配。

    • 若字典中有这个键，则用字典中键对应的值，否则就为空值。
    • 若字典中有的键值对，但显式索引中没有，则该键值对也不会被添加到Series中。
      1. >>> s = Series(data=score_data, index=["凯凯", "乐乐", "西西", "冬冬"])
      2. >>> s
      3. 凯凯     NaN
      4. 乐乐    67.0
      5. 西西    49.0
      6. 冬冬     NaN
      7. dtype: float64

      2.3 Series常用属性

      2.3.1 实验数据构建

      1. >>> data = np.array([77, 67, 77, 65, 77])
      2. >>> index = np.array(["明明", "乐乐", "花花", "欢欢", "西西"])
      3. >>> s = Series(data=data, index=index, name="Student Score")

      2.3.2 name获取Series的名称

  • Series对象.name属性可以获取Series对象的名称，若Series对象没有设置名称，则为None。

    1. >>> s.name
    2. 'Student Score'

    2.3.3 index获取显式索引

  • Series对象.index属性可以获取Series对象的显示索引的数据。

    1. >>> s.index
    2. Index(['明明', '乐乐', '花花', '欢欢', '西西'], dtype='object')

    2.3.4 values获取所有数据值

  • Series对象.values属性可以获取Series对象的所有数据值。

    1. >>> s.values
    2. array([77, 67, 77, 65, 77])

    2.4 Series常用函数

    2.4.1 value_counts()值频统计

  • Series对象.value_counts()函数可以统计Series对象中每个值出现的次数。

    1. >>> s.value_counts()
    2. 77    3
    3. 67    1
    4. 65    1
    5. Name: Student Score, dtype: int64

    2.4.2 head()获取前几条数据

  • Series对象.head()函数可以获取前几条数据，当head()函数空参数时，默认获取前5条数据。

    1. >>> s.head()
    2. 明明    77
    3. 乐乐    67
    4. 花花    77
    5. 欢欢    65
    6. 西西    77
    7. Name: Student Score, dtype: int32

  • 采用Series对象.head(n)的形式可以获取前n条数据。 ```python

    获取前1条数据。

    s.head(1) 明明 77 Name: Student Score, dtype: int32

获取前3条数据。

s.head(3) 明明 77 乐乐 67 花花 77 Name: Student Score, dtype: int32 ```

2.4.3 tail()获取后几条数据

  • Series对象.tail()函数可以获取后几条数据，使用方式与head()函数基本一致。 ```python

    默认获取后五条数据。

    s.tail() 明明 77 乐乐 67 花花 77 欢欢 65 西西 77 Name: Student Score, dtype: int32

获取后两条数据。

s.tail(2) 欢欢 65 西西 77 Name: Student Score, dtype: int32 ```

2.4.4 sort_values()根据值排序

  • Series对象.sort_values([ascending=排序方式])函数根据数组的值进行排序。
    • 参数ascending用于指定排序的方式。
    • ascending的缺省值为True，即升序排序；False为降序排序。 ```python

      根据成绩进行升序排序。

      s.sort_values() 欢欢 65 乐乐 67 明明 77 花花 77 西西 77 Name: Student Score, dtype: int32

根据成绩进行降序排序。

s.sort_values(ascending=False) 明明 77 花花 77 西西 77 乐乐 67 欢欢 65 Name: Student Score, dtype: int32 ```

2.4.5 sort_index根据显式索引排序

  • Series对象.sort_index([ascending=排序方式])函数根据数组的显式索引进行排序，用法与sort_values()函数基本一致。
    • sort_index()是根据显式索引中每个字符的十进制数据进行排序的。 ```python

      按照显式索引升序排序。

      s.sort_index() 乐乐 67 明明 77 欢欢 65 花花 77 西西 77 Name: Student Score, dtype: int32

按照显式索引降序排序。

s.sort_index(ascending=False) 西西 77 花花 77 欢欢 65 明明 77 乐乐 67 Name: Student Score, dtype: int32 ```

2.5 Series的索引与切片

2.3.1 实验数据构建

  • 显式索引为26个英文字母，值在50到70之间随机生成。

    1. >>> data = np.random.randint(50, 70, size=26)
    2. >>> index = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
    3. >>> s = Series(data=data, index=index, name="随机数据")
    4. >>> s
    5. A    66
    6. B    57
    7. C    54
    8. D    60
    9. E    61
    10. F    67
    11. G    59
    12. H    59
    13. I    61
    14. J    51
    15. K    61
    16. L    69
    17. M    68
    18. N    59
    19. O    58
    20. P    61
    21. Q    60
    22. R    59
    23. S    57
    24. T    58
    25. U    60
    26. V    52
    27. W    65
    28. X    65
    29. Y    66
    30. Z    51
    31. Name: 随机数据, dtype: int32

    2.5.2 索引

  • Series有显式索引和隐式索引两种索引。

  • 显示索引：

    • 方式一：Series对象[显式索引名]

      1. >>> s["D"]
      2. 60

    • 方式二：Series对象.显式索引名

      1. >>> s.D
      2. 60

    • 方式三：Series对象.loc[显式索引名]（推荐使用）

      1. >>> s.loc["D"]
      2. 60

    • 当要索引多个数据时，可以将多个索引封装成一个列表，然后用方式一或者方式三索引数据。 ```python

      方式一：

      s[[“D”, “G”, “J”]] D 60 G 59 J 51 Name: 随机数据, dtype: int32

方式三：

s.loc[[“D”, “G”, “J”]] D 60 G 59 J 51 Name: 随机数据, dtype: int32 ```

  • 隐式索引：Series对象.iloc[下标] ```python

    索引单个元素。

    s.iloc[3] 60

索引多个元素。

s.iloc[[0, 2, 3]] A 66 C 54 D 60 Name: 随机数据, dtype: int32 ```

  • 布尔索引：Series对象.loc[布尔序列]
    • 布尔序列中元素的个数要与Series对象中元素的个数相同。
    • True对应的元素会被保留，False对应的元素会被移除。 ```python

      随机选择26个布尔类型的值组成数组

      bool_flag = np.random.choice([True, False], size=26) bool_flag array([False, False, True, True, True, False, True, True, False, True, True, False, False, True, True, False, False, True, False, False, False, True, True, False, False, True])

根据布尔数组索引值。

s.loc[bool_flag] C 54 D 60 E 61 G 59 H 59 J 51 K 61 N 59 O 58 R 59 V 52 W 65 Z 51 Name: 随机数据, dtype: int32 ```

2.5.2 切片

  • 由于索引有显式索引和隐式索引两种，因此切片也可以通过显式索引和隐式索引两种方式实现。

  • 显式索引切片：（显式索引包含结束元素）

    • 方法一：Series对象.loc[显式索引1:显示索引2:步长] 

      1. >>> s.loc['A':'Z':3]
      2. A    66
      3. D    60
      4. G    59
      5. J    51
      6. M    68
      7. P    61
      8. S    57
      9. V    52
      10. Y    66
      11. Name: 随机数据, dtype: int32

    • 方法二：Series对象[显式索引1:显示索引2:步长] 

      1. >>> s["J":"P":2]
      2. J    51
      3. L    69
      4. N    59
      5. P    61
      6. Name: 随机数据, dtype: int32
      7. # ["J":"P":2]的结果包含P是因为显式索引切片结果中会包含结束元素

  • 隐式索引切片：Series对象.iloc[下标1:下标2:步长] （隐式索引不包含结束位置元素）

    1. >>> s.iloc[3:10]
    2. D    60
    3. E    61
    4. F    67
    5. G    59
    6. H    59
    7. I    61
    8. J    51
    9. Name: 随机数据, dtype: int32

    2.6 Series的相关运算与判断

    2.6.1 运算概述与数据准备

  • Pandas中的数据运算是基于NumPy的，因此NumPy中有的运算Pandas中也是有的。

  • Series中的运算实际上就是矢量化运算。

  • 数据准备：

    1. >>> score_data = {
    2. ...     "明明": 77,
    3. ...     "乐乐": 67,
    4. ...     "花花": 89,
    5. ...     "西西": 49
    6. ... }
    7. >>> s = Series(data=score_data, index=["凯凯", "乐乐", "西西", "冬冬"])
    8. >>> s
    9. 凯凯     NaN
    10. 乐乐    67.0
    11. 西西    49.0
    12. 冬冬     NaN
    13. dtype: float64

    2.6.2 Series的矢量化运算

  • 给所有值进行加一操作。（与NumPy中一样，NaN为缺失值，缺失值运算后还是缺失值）

    1. >>> s + 1
    2. 凯凯     NaN
    3. 乐乐    68.0
    4. 西西    50.0
    5. 冬冬     NaN
    6. dtype: float64

  • 但是NaN可以参与逻辑运算。 ```python

    判断成绩是否大于60分，NaN > 60 is False

    s > 60 凯凯 False 乐乐 True 西西 False 冬冬 False dtype: bool

筛选出成绩大于60的数据。

s[s > 60] 乐乐 67.0 dtype: float64 ```

2.6.3 Series的集合函数

  • Pandas是基于NumPy的，因此NumPy中的聚合函数Pandas中也都有。 ```python

    求和

    s.sum() 116.0

求最大值

s.max() 67.0 ```

2.6.4 isnull()判断数据是否为空值

  • Series对象.isnull()函数可以判断Series对象中的每个数据是否是空值，若为空值则True，否则为False。

    1. >>> s.isnull()
    2. 凯凯     True
    3. 乐乐    False
    4. 西西    False
    5. 冬冬     True
    6. dtype: bool

    2.6.5 any()判断是否有空值数据

  • Series对象.isnull().any()函数会根据isnull()函数的结果进行判断，结果中只要有一个True就为True，表示Series对象中存在空值。

    1. >>> s.isnull().any()
    2. True

    03. DataFrame

    3.1 DataFrame介绍

  • DataFrame是一个二维数据结构，类似于Excel表格。

  • DataFrame可以看做是一个由多个Series数据构成的集合。

  • DataFrame的数据可以分为三部分：数据区、行索引、列索引。

    3.2 DataFrame的创建

  • 构建语法：df = DataFrame(data=数据, index=行索引序列, columns=列索引序列)

  • 示例：生成以下表格。

image.png

  • 代码实现：

    1. row_index = ["小明", "小张", "小东", "小李", "小慧", "小凯"]
    2. column_index = ["语文", "数学", "英语", "政治", "历史", "地理", "生物"]
    3. datas = [
    4.   [89, 54, 92, 92, 64, 90, 93],
    5.   [61, 99, 86, 95, 96, 67, 78],
    6.   [76, 56, 72, 91, 68, 99, 60],
    7.   [55, 64, 53, 98, 86, 80, 99],
    8.   [51, 98, 58, 84, 80, 51, 90],
    9.   [54, 73, 58, 69, 94, 84, 52]
    10. ]
    11. df = DataFrame(data=datas, index=row_index, columns=column_index)
    12. df

  • 若没有声明显式索引，则会使用隐式索引所谓索引。

    1. df = DataFrame(data=datas)
    2. df

    image.png

    3.3 DataFrame的相关属性

    3.3.1 数据准备

  • 使用中第一个df作为实验数据。

    1. row_index = ["小明", "小张", "小东", "小李", "小慧", "小凯"]
    2. column_index = ["语文", "数学", "英语", "政治", "历史", "地理", "生物"]
    3. datas = [
    4.   [89, 54, 92, 92, 64, 90, 93],
    5.   [61, 99, 86, 95, 96, 67, 78],
    6.   [76, 56, 72, 91, 68, 99, 60],
    7.   [55, 64, 53, 98, 86, 80, 99],
    8.   [51, 98, 58, 84, 80, 51, 90],
    9.   [54, 73, 58, 69, 94, 84, 52]
    10. ]
    11. df = DataFrame(data=datas, index=row_index, columns=column_index)

    3.3.2 index获取行索引

  • DataFrame对象.index属性可以获取DataFrame对象的行索引。

    1. >>> df.index
    2. Index(['小明', '小张', '小东', '小李', '小慧', '小凯'], dtype='object')

    3.3.3 columns获取列索引

  • DataFrame对象.columns属性可以获取DataFrame对象的列索引。

    1. >>> df.columns
    2. Index(['语文', '数学', '英语', '政治', '历史', '地理', '生物'], dtype='object')

    3.3.3 values获取数据

  • DataFrame对象.values属性可以获取DataFrame对象的数据值。

    1. >>> df.values
    2. array([[89, 54, 92, 92, 64, 90, 93],
    3.      [61, 99, 86, 95, 96, 67, 78],
    4.      [76, 56, 72, 91, 68, 99, 60],
    5.      [55, 64, 53, 98, 86, 80, 99],
    6.      [51, 98, 58, 84, 80, 51, 90],
    7.      [54, 73, 58, 69, 94, 84, 52]], dtype=int64)

    3.4 DataFrame索引

  • DataFrame是一个二维的表结构，有行索引和列索引两种。对于这两种索引也分为显示索引和隐式索引两类。

    3.4.1 列索引

  • DataFrame对象.列名可以索引单列数据，其结果是一个Series结构的数据。

    1. >>> df.语文
    2. 小明    89
    3. 小张    61
    4. 小东    76
    5. 小李    55
    6. 小慧    51
    7. 小凯    54
    8. Name: 语文, dtype: int64

  • DataFrame对象[列名]是索引单列数据的另一种方式。

    1. >>> df['数学']
    2. 小明    54
    3. 小张    99
    4. 小东    56
    5. 小李    64
    6. 小慧    98
    7. 小凯    73
    8. Name: 数学, dtype: int64

  • DataFrame对象[[列名1, 列名2, 列名3, …]]可以获取多列数据。其结果是一个DataFrame结构的数据。

    1. df[['英语', '历史', '生物']]

    image.png

    3.4.2 行索引

  • DataFrame对象.loc[行标题]可以索引单行数据，其结果是一个Series结构的数据。

    1. >>> df.loc['小明']
    2. 语文    89
    3. 数学    54
    4. 英语    92
    5. 政治    92
    6. 历史    64
    7. 地理    90
    8. 生物    93
    9. Name: 小明, dtype: int64

  • DataFrame对象.loc[[行标题1, 行标题2, 行标题3, …]]可以获取多行数据。其结果是一个DataFrame结构的数据。

    1. df.loc[['小明', '小李', '小东']]

    image.png

    3.4.3 行列复合索引

  • 行列复合索引的格式为：DataFrame对象.loc[行索引, 列索引]

  • 一个单元格由确定的行与确定的列组成，比如要查询小明的语文成绩，代码为：

    1. >>> df.loc['小明', '语文']
    2. 89

  • 行列复合索引还可以从指定多行中获取指定多列的数据，如要查询小明、小李、小东这三个人的英语、历史、生物这三门课的成绩。

    1. df.loc[['小明', '小李', '小东'], ['英语', '历史', '生物']]

    image.png

    3.4.4 DataFrame隐式索引

  • DataFrame中隐式索引使用的依旧是下标，语法格式为：DataFrame对象.iloc[行索引, 列索引]

  • 示例：返回第0、2、4行的第1、3、6列数据。

    1. df.iloc[[0, 2, 4], [1, 3, 6]]

    image.png

    3.5 DataFrame切片

  • DataFrame的切片也分为显示索引切片（包含结束位置）以及隐式索引切片（不包含结束位置）。

    3.5.1 行切片

  • 使用显示索引来实现行切片的语法格式为：DataFrame对象.loc[起始行索引:结束行索引:步长]

    1. df.loc["小张":"小慧"]

    image.png

    1. df.loc["小张":"小慧":2]

    image.png

    1. df.loc[::2]

    image.png

  • 使用隐式索引来实现行切片的语法格式为：DataFrame对象.iloc[起始下标:结束下标:步长]

    1. df.iloc[1::2]

    image.png

    3.5.2 列切片

  • 显示索引列切片：DataFrame对象.loc[行切片, 起始列索引:结束列索引:步长]

    1. >>> df.loc['小明', '数学':'地理':2]
    2. 数学    54
    3. 政治    92
    4. 地理    90
    5. Name: 小明, dtype: int64
    1. df.loc[:, '数学'::2]  # 行切片为“:”，则表示在所有行中切列。

    image.png

  • 隐式索引列切片：DataFrame对象.iloc[行下标切片, 起始下标:结束下标:步长]

    1. df.iloc[1::2, 2:6:2]

    image.png

    3.6 DF描述性操作

    3.6.1 describe()获取数据描述

  • DataFrame对象.describe()可实现对数据对象进行简单的数学描述，描述指标包括：

    • count：数据的个数（即该列共有几行数据）。
    • mean：该列数据的平均值。
    • std：该列数据的标准差。
    • min：该列数据的最小值。
    • 25%（Q1）：该列数据的下四分位数。
    • 50%（Q2）：该列数据的中位数。
    • 75%（Q3）：该列数据的上四分位数。
    • max：该列数据的最大值。
      1. df.describe()
      image.png

      3.6.2 info()列信息描述

  • DataFrame对象.describe()是对表的总体数据进行数学指标层面的描述。

  • DataFrame对象.info()可实现在表规格上对数据表进行描述。
    • Index：描述数据的行规模，包含数据表的总函数、起始行索引、结束行索引。
    • Data columns：描述数据的列规模，即数据的总列数。

    • ：列的隐式索引，即下标。

    • Column：列的显示索引。
    • Non-Null Count：该列的非空行统计。即02. Pandas基本操作 - 图16即可得到该列中有几个空值。
    • Dtype：该列的数据类型。 ```python

      df.info() Index: 6 entries, 小明 to 小凯 Data columns (total 7 columns):

      Column Non-Null Count Dtype

0 语文 6 non-null int64 1 数学 6 non-null int64 2 英语 6 non-null int64 3 政治 6 non-null int64 4 历史 6 non-null int64 5 地理 6 non-null int64 6 生物 6 non-null int64 dtypes: int64(7) memory usage: 556.0+ bytes

  1. <a name="ikxz8"></a>
  2. #### 3.6.3 count()获取个数
  4. - `DataFrame对象.count()`可以获取每个字段的数据个数。
  5. ```python
  6. >>> df.count()
  7. 语文    6
  8. 数学    6
  9. 英语    6
  10. 政治    6
  11. 历史    6
  12. 地理    6
  13. 生物    6
  14. dtype: int64

3.6.4 T转置

  • DataFrame对象.T可实现数据对象的行列互换。

    • 由于DF对象是一个二维数据矩阵，因此行列互换的本质是矩阵的转置。
    • 在线性代数中。矩阵的行列转置被称为矩阵的T转置。
      1. df
      image.png
      1. df.T
      image.png

      3.7 DF表排序操作

      3.7.1 sort_index()根据索引排序

  • DataFrame对象.sort_index()可以将数据表根据行索引或列索引进行排序。

    • axis：0根据行索引排序（缺省值），1根据列索引排序。
    • ascending：True升序排序（缺省值），False降序排序。
    • inplace：是否修改原数据。
      • 默认为False，即不会修改原数据，而是把排序后的结果直接返回。
      • True：会修改原数据，且不会返回任何内容。

  • 示例1：根据行索引降序排序，不修改原数据。

    1. df.sort_index(ascending=False)
    2. # 结果会直接返回

    image.png

  • 示例2：再根据列索引升序排序，并修改原数据。

    1. df.sort_index(axis=1, inplace=True)
    2. df  # 修改原数据后不会有返回，因此需要手动调用df查看内容。

    image.png

    3.7.2 sort_values()根据数据值排序

  • DataFrame对象.sort_values()可以将数据表根据行索引或列索引进行排序。

    • by：指定数据基于哪个字段进行排序，可以是一个字符串；当涉及到多字段排序时，by的值是由多个字段名构成的一个列表。
      • 当by的值为一个列表时，会先按照列表中第0个字段排序。
      • 若第0个字段值相同，则按照第1个字段排序，以此类推，直到排序完成。
    • axis：0根据行索引排序（缺省值），1根据列索引排序。
    • ascending：True升序排序（缺省值），False降序排序。
    • inplace：是否修改原数据。
      • 默认为False，即不会修改原数据，而是把排序后的结果直接返回。
      • True：会修改原数据，且不会返回任何内容。

  • 示例1：根据生物成绩，对学生进行降序排序。

    1. df.sort_values(by='生物', ascending=False)

    image.png

  • 示例2：根据政治成绩以及数学成绩，对学生进行升序排序。

    1. df.sort_values(by=['政治', '数学'])

    image.png

  • 示例3：将小慧的考试科目按照从大到小的顺序排序。

    • 将科目按照成绩从大到小排序是一个基于列的降序操作。
    • 排序结果中只有小慧的成绩是有序的，其他行的数据会根据小慧的排序结果进行排列。
      1. df.sort_values(by='小慧', axis=1, ascending=False)
      image.png

      3.8 DF增删数据

      3.8.1 添加一行数据

  • DataFrame对象.loc[新行索引] = 数据值可以在DF对象中添加一行数据。

    • 数据值中数据的个数需要与DF的列数相同。
    • 空值可以使用np.nan填充。

  • 示例：在数据表中添加小郑的成绩。

    1. data = np.array([50, 91, 73, 77, 93, 97, 80])
    2. df.loc['小郑'] = data
    3. df

    image.png

    3.8.2 添加一列数据

  • DataFrame对象.loc[:, 新列索引] = 数据值可以在DF对象中添加一列数据。

    • 数据值中数据的个数需要与DF的行数相同。
    • 空值可以使用np.nan填充。

  • 示例1：增加一列化学成绩。

    1. df.loc[:, '化学'] = np.array([89, 66, 54, 67, 87, 94, 89])
    2. df

    image.png

  • 示例2：增加一列总成绩。（总成绩可以通过df.sum(axis=1)计算得到）

    1. df.loc[:, '总成绩'] = df.sum(axis=1)
    2. df

    image.png

    3.8.3 drop()删除数据

  • DataFrame对象.drop()可以在DF对象中删除指定的数据。

    • labels：要删除的标题（可以是行标题也可以是列标题），要删除多行或多列时可以封装成列表。
    • axis：0删除行（默认值），1删除列。

  • 示例1：删除小东的数据。

    1. df.drop(labels='小东')

    image.png

  • 示例2：删除政治、历史的数据。

    1. df.drop(labels=['政治', '历史'], axis=1)

    image.png

    3.9 DF运算操作

  • 示例1：查找出语文成绩大于70分的学生信息。

    • 首先：索引出语文的所有数据。

      1. >>> df['语文']
      2. 小明    89
      3. 小张    61
      4. 小东    76
      5. 小李    55
      6. 小慧    51
      7. 小凯    54
      8. 小郑    80
      9. Name: 语文, dtype: int64

    • 然后判断语文成绩是否大于70分。

      1. >>> df['语文'] > 70
      2. 小明     True
      3. 小张    False
      4. 小东     True
      5. 小李    False
      6. 小慧    False
      7. 小凯    False
      8. 小郑     True
      9. Name: 语文, dtype: bool

    • 最后，用第二步中得到的布尔值过滤出语文大于70的学生数据。

      1. df[df['语文'] > 70]

      image.png

  • 示例2：过滤出语文在70分以上，化学在80分以上的学生信息。

    1. df[(df['语文'] > 70) & (df['化学'] > 80)]

    image.png

  • 示例3：判断数据表中哪些成绩是合格的。

    • 首先，判断整张表中所有的数据是否大于等于60。

      1. df >= 60

      image.png

    • 接着，用布尔索引过滤数据，此时False对应的数据会变成np.nan。

      1. df[df >= 60]

      image.png