# Python 数据分析三剑客之 Pandas（一）：认识 Pandas 及其 Series、DataFrame 对象

TRHX

2020-06-11

Python 数据分析 / Pandas

字数统计:

5,461字

阅读时长≈

25分

Pandas 系列文章：

- Python 数据分析三剑客之 Pandas（一）：认识 Pandas 及其 Series、DataFrame 对象
- Python 数据分析三剑客之 Pandas（二）：Index 索引对象以及各种索引操作
- Python 数据分析三剑客之 Pandas（三）：算术运算与缺失值的处理
- Python 数据分析三剑客之 Pandas（四）：函数应用、映射、排序和层级索引
- Python 数据分析三剑客之 Pandas（五）：统计计算与统计描述
- Python 数据分析三剑客之 Pandas（六）：GroupBy 数据分裂、应用与合并
- Python 数据分析三剑客之 Pandas（七）：合并数据集
- Python 数据分析三剑客之 Pandas（八）：数据重塑、重复数据处理与数据替换
- Python 数据分析三剑客之 Pandas（九）：时间序列
- Python 数据分析三剑客之 Pandas（十）：数据读写

专栏：

【NumPy 专栏】【Pandas 专栏】【Matplotlib 专栏】

推荐学习资料与网站：

【NumPy 中文网】【Pandas 中文网】【Matplotlib 中文网】【NumPy、Matplotlib、Pandas 速查表】

    1
    2
    3
    4
    5

    这里是一段防爬虫文本，请读者忽略。
    本文原创首发于 CSDN，作者 TRHX。
    博客首页：https://itrhx.blog.csdn.net/
    本文链接：https://itrhx.blog.csdn.net/article/details/106676693
    未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离剽窃！

## 【01x00】了解 Pandas

Pandas 是 Python 的一个数据分析包，是基于 NumPy 构建的，最初由 AQR Capital Management 于 2008 年 4 月开发，并于 2009 年底开源出来，目前由专注于 Python 数据包开发的 PyData 开发团队继续开发和维护，属于 PyData 项目的一部分。

Pandas 最初被作为金融数据分析工具而开发出来，因此，Pandas 为时间序列分析提供了很好的支持。Pandas 的名称来自于面板数据（panel data）和 Python 数据分析（data analysis）。panel data 是经济学中关于多维数据集的一个术语，在 Pandas 中也提供了 panel 的数据类型。

Pandas 经常和其它工具一同使用，如数值计算工具 NumPy 和 SciPy，分析库 statsmodels 和 scikit-learn，数据可视化库 Matplotlib 等，虽然 Pandas 采用了大量的 NumPy 编码风格，但二者最大的不同是 Pandas 是专门为处理表格和混杂数据设计的。而 NumPy 更适合处理统一的数值数组数据。

【以下对 Pandas 的解释翻译自官方文档：https://pandas.pydata.org/docs/getting_started/overview.html#package-overview】

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

Pandas 适用于处理以下类型的数据：

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

Pandas 的主要数据结构是 Series（一维数据）与 DataFrame（二维数据），这两种数据结构足以处理- 金融、统计、社会科学、工程等领域里的大多数典型用例。对于 R 语言用户，DataFrame 提供了比 R 语言 `data.frame` 更丰富的功能。Pandas 基于 NumPy 开发，可以与其它第三方科学计算支持库完美集成。

Pandas 就像一把万能瑞士军刀，下面仅列出了它的部分优势 ：

- 处理浮点与非浮点数据里的缺失数据，表示为 NaN；
- 大小可变：插入或删除 DataFrame 等多维对象的列；
- 自动、显式数据对齐：显式地将对象与一组标签对齐，也可以忽略标签，在 Series、DataFrame 计算时自动与数据对齐；
- 强大、灵活的分组（group by）功能：拆分-应用-组合数据集，聚合、转换数据；
- 把 Python 和 NumPy 数据结构里不规则、不同索引的数据轻松地转换为 DataFrame 对象；
- 基于智能标签，对大型数据集进行切片、花式索引、子集分解等操作；
- 直观地合并和连接数据集；
- 灵活地重塑和旋转数据集；
- 轴支持分层标签（每个刻度可能有多个标签）；
- 强大的 IO 工具，读取平面文件（CSV 等支持分隔符的文件）、Excel 文件、数据库等来源的数据，以及从超快 HDF5 格式保存 / 加载数据；
- 时间序列：支持日期范围生成、频率转换、移动窗口统计、移动窗口线性回归、日期位移等时间序列功能。

这些功能主要是为了解决其它编程语言、科研环境的痛点。处理数据一般分为几个阶段：数据整理与清洗、数据分析与建模、数据可视化与制表，Pandas 是处理数据的理想工具。

其它说明：

- Pandas 速度很快。Pandas 的很多底层算法都用 Cython 优化过。然而，为了保持通用性，必然要牺牲一些性能，如果专注某一功能，完全可以开发出比 Pandas 更快的专用工具。
- Pandas 是 statsmodels 的依赖项，因此，Pandas 也是 Python 中统计计算生态系统的重要组成部分。
- Pandas 已广泛应用于金融领域。

## 【02x00】Pandas 数据结构

Pandas 的主要数据结构是 Series（带标签的一维同构数组）与 DataFrame（带标签的，大小可变的二维异构表格）。

Pandas 数据结构就像是低维数据的容器。比如，DataFrame 是 Series 的容器，Series 则是标量的容器。使用这种方式，可以在容器中以字典的形式插入或删除对象。

此外，通用 API 函数的默认操作要顾及时间序列与截面数据集的方向。当使用 Ndarray 存储二维或三维数据时，编写函数要注意数据集的方向，这对用户来说是一种负担；如果不考虑 C 或 Fortran 中连续性对性能的影响，一般情况下，不同的轴在程序里其实没有什么区别。Pandas 里，轴的概念主要是为了给数据赋予更直观的语义，即用更恰当的方式表示数据集的方向。这样做可以让用户编写数据转换函数时，少费点脑子。

处理 DataFrame 等表格数据时，对比 Numpy，index（行）或 columns（列）比 axis 0 和 axis 1 更直观。用这种方式迭代 DataFrame 的列，代码更易读易懂：

    1
    2
    3

    for col in df.columns:
        series = df[col]
        # do something with series

## 【03x00】Series 对象

Series 是带标签的一维数组，可存储整数、浮点数、字符串、Python 对象等类型的数据。轴标签统称为索引。调用 pandas.Series 函数即可创建 Series，基本语法如下：

`pandas.Series(data=None[, index=None, dtype=None, name=None, copy=False, fastpath=False])`

参数 | 描述
--- | ---
data | 数组类型，可迭代的，字典或标量值，存储在序列中的数据
index | 索引（数据标签），值必须是可哈希的，并且具有与数据相同的长度， 允许使用非唯一索引值。如果未提供，将默认为RangeIndex（0，1，2，…，n）
dtype | 输出系列的数据类型。可选项，如果未指定，则将从数据中推断，具体参考官网 dtypes 介绍
name | str 类型，可选项，给 Series 命名
copy | bool 类型，可选项，默认 False，是否复制输入数据

<fancybox>
</fancybox>

### 【03x01】通过 list 构建 Series

一般情况下我们只会用到 data 和 index 参数，可以通过 list（列表） 构建 Series，示例如下：

    1
    2
    3
    4
    5
    6
    7
    8

    >>> import pandas as pd
    >>> obj = pd.Series([1, 5, -8, 2])
    >>> obj
    0    1
    1    5
    2   -8
    3    2
    dtype: int64

由于我们没有为数据指定索引，于是会自动创建一个 0 到 N-1（N 为数据的长度）的整数型索引，左边一列是自动创建的索引（index），右边一列是数据（data）。

此外，还可以自定义索引（index）：

    1
    2
    3
    4
    5
    6
    7
    8

    >>> import pandas as pd
    >>> obj = pd.Series([1, 5, -8, 2], index=['a', 'b', 'c', 'd'])
    >>> obj
    a    1
    b    5
    c   -8
    d    2
    dtype: int64

索引（index）也可以通过赋值的方式就地修改：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15

    >>> import pandas as pd
    >>> obj = pd.Series([1, 5, -8, 2], index=['a', 'b', 'c', 'd'])
    >>> obj
    a    1
    b    5
    c   -8
    d    2
    dtype: int64
    >>> obj.index = ['Bob', 'Steve', 'Jeff', 'Ryan']
    >>> obj
    Bob      1
    Steve    5
    Jeff    -8
    Ryan     2
    dtype: int64

### 【03x02】通过 dict 构建 Series

通过 字典（dict） 构建 Series，字典的键（key）会作为索引（index），字典的值（value）会作为数据（data），示例如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9

    >>> import pandas as pd
    >>> data = {'Beijing': 21530000, 'Shanghai': 24280000, 'Wuhan': 11210000, 'Zhejiang': 58500000}
    >>> obj = pd.Series(data)
    >>> obj
    Beijing     21530000
    Shanghai    24280000
    Wuhan       11210000
    Zhejiang    58500000
    dtype: int64

如果你想按照某个特定的顺序输出结果，可以传入排好序的字典的键以改变顺序：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

    >>> import pandas as pd
    >>> data = {'Beijing': 21530000, 'Shanghai': 24280000, 'Wuhan': 11210000, 'Zhejiang': 58500000}
    >>> cities = ['Guangzhou', 'Wuhan', 'Zhejiang', 'Shanghai']
    >>> obj = pd.Series(data, index=cities)
    >>> obj
    Guangzhou           NaN
    Wuhan        11210000.0
    Zhejiang     58500000.0
    Shanghai     24280000.0
    dtype: float64

注意：data 为字典，且未设置 index 参数时：

- 如果 Python >= 3.6 且 Pandas >= 0.23，Series 按字典的插入顺序排序索引。
- 如果 Python < 3.6 或 Pandas < 0.23，Series 按字母顺序排序索引。

### 【03x03】获取其数据和索引

我们可以通过 Series 的 values 和 index 属性获取其数据和索引对象：

    1
    2
    3
    4
    5
    6

    >>> import pandas as pd
    >>> obj = pd.Series([1, 5, -8, 2], index=['a', 'b', 'c', 'd'])
    >>> obj.values
    array([ 1,  5, -8,  2], dtype=int64)
    >>> obj.index
    Index(['a', 'b', 'c', 'd'], dtype='object')

### 【03x04】通过索引获取数据

与普通 NumPy 数组相比，Pandas 可以通过索引的方式选取 Series 中的单个或一组值，获取一组值时，传入的是一个列表，列表中的元素是索引值，另外还可以通过索引来修改其对应的值：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

    >>> import pandas as pd
    >>> obj = pd.Series([1, 5, -8, 2], index=['a', 'b', 'c', 'd'])
    >>> obj
    a    1
    b    5
    c   -8
    d    2
    dtype: int64
    >>> obj['a']
    1
    >>> obj['a'] = 3
    >>> obj[['a', 'b', 'c']]
    a    3
    b    5
    c   -8
    dtype: int64

### 【03x05】使用函数运算

在 Pandas 中可以使用 NumPy 函数或类似 NumPy 的运算（如根据布尔型数组进行过滤、标量乘法、应用数学函数等）：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20

    >>> import pandas as pd
    >>> import numpy as np
    >>> obj = pd.Series([1, 5, -8, 2], index=['a', 'b', 'c', 'd'])
    >>> obj[obj > 0]
    a    1
    b    5
    d    2
    dtype: int64
    >>> obj * 2
    a     2
    b    10
    c   -16
    d     4
    dtype: int64
    >>> np.exp(obj)
    a      2.718282
    b    148.413159
    c      0.000335
    d      7.389056
    dtype: float64

除了这些运算函数以外，还可以将 Series 看成是一个定长的有序字典，因为它是索引值到数据值的一个映射。它可以用在许多原本需要字典参数的函数中：

    1
    2
    3
    4
    5
    6

    >>> import pandas as pd
    >>> obj = pd.Series([1, 5, -8, 2], index=['a', 'b', 'c', 'd'])
    >>> 'a' in obj
    True
    >>> 'e' in obj
    False

和 NumPy 类似，Pandas 中也有 NaN（即非数字，not a number），在 Pandas 中，它用于表示缺失值，Pandas 的 isnull 和 notnull 函数可用于检测缺失数据：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33

    >>> import pandas as pd
    >>> import numpy as np
    >>> obj = pd.Series([np.NaN, 5, -8, 2], index=['a', 'b', 'c', 'd'])
    >>> obj
    a    NaN
    b    5.0
    c   -8.0
    d    2.0
    dtype: float64
    >>> pd.isnull(obj)
    a     True
    b    False
    c    False
    d    False
    dtype: bool
    >>> pd.notnull(obj)
    a    False
    b     True
    c     True
    d     True
    dtype: bool
    >>> obj.isnull()
    a     True
    b    False
    c    False
    d    False
    dtype: bool
    >>> obj.notnull()
    a    False
    b     True
    c     True
    d     True
    dtype: bool

### 【03x06】name 属性

可以在 `pandas.Series` 方法中为 Series 对象指定一个 name：

    1
    2
    3
    4
    5
    6
    7
    8
    9

    >>> import pandas as pd
    >>> data = {'Beijing': 21530000, 'Shanghai': 24280000, 'Wuhan': 11210000, 'Zhejiang': 58500000}
    >>> obj = pd.Series(data, name='population')
    >>> obj
    Beijing     21530000
    Shanghai    24280000
    Wuhan       11210000
    Zhejiang    58500000
    Name: population, dtype: int64

也可以通过 name 和 index.name 属性为 Series 对象和其索引指定 name：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

    >>> import pandas as pd
    >>> data = {'Beijing': 21530000, 'Shanghai': 24280000, 'Wuhan': 11210000, 'Zhejiang': 58500000}
    >>> obj = pd.Series(data)
    >>> obj.name = 'population'
    >>> obj.index.name = 'cities'
    >>> obj
    cities
    Beijing     21530000
    Shanghai    24280000
    Wuhan       11210000
    Zhejiang    58500000
    Name: population, dtype: int64

    1
    2
    3
    4
    5

    这里是一段防爬虫文本，请读者忽略。
    本文原创首发于 CSDN，作者 TRHX。
    博客首页：https://itrhx.blog.csdn.net/
    本文链接：https://itrhx.blog.csdn.net/article/details/106676693
    未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离剽窃！

## 【04x00】DataFrame 对象

DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame 既有行索引也有列索引，它可以被看做由 Series 组成的字典（共用同一个索引）。DataFrame 中的数据是以一个或多个二维块存放的（而不是列表、字典或别的一维数据结构）。

- 类似多维数组/表格数据 (如Excel、R 语言中的 data.frame)；
- 每列数据可以是不同的类型；
- 索引包括列索引和行索引

基本语法如下：

`pandas.DataFrame(data=None, index: Optional[Collection] = None, columns: Optional[Collection] = None, dtype: Union[str, numpy.dtype, ExtensionDtype, None] = None, copy: bool = False)`

参数 | 描述
--- | ---
data | ndarray 对象（结构化或同类的）、可迭代的或者字典形式，存储在序列中的数据
index | 数组类型，索引（数据标签），如果未提供，将默认为 RangeIndex（0，1，2，…，n）
columns | 列标签。如果未提供，则将默认为 RangeIndex（0、1、2、…、n）
dtype | 输出系列的数据类型。可选项，如果未指定，则将从数据中推断，具体参考官网 dtypes 介绍
copy | bool 类型，可选项，默认 False，是否复制输入数据，仅影响 DataFrame/2d ndarray 输入

<fancybox>
</fancybox>

### 【03x01】通过 ndarray 构建 DataFrame

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17

    >>> import numpy as np
    >>> import pandas as pd
    >>> data = np.random.randn(5,3)
    >>> data
    array([[-2.16231157,  0.44967198, -0.73131523],
           [ 1.18982913,  0.94670798,  0.82973421],
           [-1.57680831, -0.99732066,  0.96432   ],
           [-0.77483149, -1.23802881,  0.44061227],
           [ 1.77666419,  0.24931983, -1.12960153]])
    >>> obj = pd.DataFrame(data)
    >>> obj
              0         1         2
    0 -2.162312  0.449672 -0.731315
    1  1.189829  0.946708  0.829734
    2 -1.576808 -0.997321  0.964320
    3 -0.774831 -1.238029  0.440612
    4  1.776664  0.249320 -1.129602

指定索引（index）和列标签（columns），和 Series 对象类似，可以在构建的时候添加索引和标签，也可以直接通过赋值的方式就地修改：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23

    >>> import numpy as np
    >>> import pandas as pd
    >>> data = np.random.randn(5,3)
    >>> index = ['a', 'b', 'c', 'd', 'e']
    >>> columns = ['A', 'B', 'C']
    >>> obj = pd.DataFrame(data, index, columns)
    >>> obj
              A         B         C
    a -1.042909 -0.238236 -1.050308
    b  0.587079  0.739683 -0.233624
    c -0.451254 -0.638496  1.708807
    d -0.620158 -1.875929 -0.432382
    e -1.093815  0.396965 -0.759479
    >>>
    >>> obj.index = ['A1', 'A2', 'A3', 'A4', 'A5']
    >>> obj.columns = ['B1', 'B2', 'B3']
    >>> obj
              B1        B2        B3
    A1 -1.042909 -0.238236 -1.050308
    A2  0.587079  0.739683 -0.233624
    A3 -0.451254 -0.638496  1.708807
    A4 -0.620158 -1.875929 -0.432382
    A5 -1.093815  0.396965 -0.759479

### 【03x02】通过 dict 构建 DataFrame

通过 字典（dict） 构建 DataFrame，字典的键（key）会作为列标签（columns），字典的值（value）会作为数据（data），示例如下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13

    >>> import pandas as pd
    >>> data = {'city': ['Wuhan', 'Wuhan', 'Wuhan', 'Beijing', 'Beijing', 'Beijing'],
    		'year': [2017, 2018, 2019, 2017, 2018, 2019],
            'people': [10892900, 11081000, 11212000, 21707000, 21542000, 21536000]}
    >>> obj = pd.DataFrame(data)
    >>> obj
          city  year    people
    0    Wuhan  2017  10892900
    1    Wuhan  2018  11081000
    2    Wuhan  2019  11212000
    3  Beijing  2017  21707000
    4  Beijing  2018  21542000
    5  Beijing  2019  21536000

如果指定了列序列，则 DataFrame 的列就会按照指定顺序进行排列，如果传入的列在数据中找不到，就会在结果中产生缺失值（NaN）：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28

    >>> import pandas as pd
    >>> data = {'city': ['Wuhan', 'Wuhan', 'Wuhan', 'Beijing', 'Beijing', 'Beijing'],
    		'year': [2017, 2018, 2019, 2017, 2018, 2019],
            'people': [10892900, 11081000, 11212000, 21707000, 21542000, 21536000]}
    >>> pd.DataFrame(data)
          city  year    people
    0    Wuhan  2017  10892900
    1    Wuhan  2018  11081000
    2    Wuhan  2019  11212000
    3  Beijing  2017  21707000
    4  Beijing  2018  21542000
    5  Beijing  2019  21536000
    >>> pd.DataFrame(data, columns=['year', 'city', 'people'])
       year     city    people
    0  2017    Wuhan  10892900
    1  2018    Wuhan  11081000
    2  2019    Wuhan  11212000
    3  2017  Beijing  21707000
    4  2018  Beijing  21542000
    5  2019  Beijing  21536000
    >>> pd.DataFrame(data, columns=['year', 'city', 'people', 'money'])
       year     city    people money
    0  2017    Wuhan  10892900   NaN
    1  2018    Wuhan  11081000   NaN
    2  2019    Wuhan  11212000   NaN
    3  2017  Beijing  21707000   NaN
    4  2018  Beijing  21542000   NaN
    5  2019  Beijing  21536000   NaN

注意：data 为字典，且未设置 columns 参数时：

- Python > = 3.6 且 Pandas > = 0.23，DataFrame 的列按字典的插入顺序排序。
- Python < 3.6 或 Pandas < 0.23，DataFrame 的列按字典键的字母排序。

### 【03x03】获取其数据和索引

和 Series 一样，DataFrame 也可以通过其 values 和 index 属性获取其数据和索引对象：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15

    >>> import numpy as np
    >>> import pandas as pd
    >>> data = {'city': ['Wuhan', 'Wuhan', 'Wuhan', 'Beijing', 'Beijing', 'Beijing'],
    	'year': [2017, 2018, 2019, 2017, 2018, 2019],
            'people': [10892900, 11081000, 11212000, 21707000, 21542000, 21536000]}
    >>> obj = pd.DataFrame(data)
    >>> obj.index
    RangeIndex(start=0, stop=6, step=1)
    >>> obj.values
    array([['Wuhan', 2017, 10892900],
           ['Wuhan', 2018, 11081000],
           ['Wuhan', 2019, 11212000],
           ['Beijing', 2017, 21707000],
           ['Beijing', 2018, 21542000],
           ['Beijing', 2019, 21536000]], dtype=object)

### 【03x04】通过索引获取数据

通过类似字典标记的方式或属性的方式，可以将 DataFrame 的列获取为一个 Series 对象；

行也可以通过位置或名称的方式进行获取，比如用 loc 属性；

对于特别大的 DataFrame，有一个 head 方法可以选取前五行数据。

用法示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49

    >>> import numpy as np
    >>> import pandas as pd
    >>> data = {'city': ['Wuhan', 'Wuhan', 'Wuhan', 'Beijing', 'Beijing', 'Beijing'],
    	'year': [2017, 2018, 2019, 2017, 2018, 2019],
            'people': [10892900, 11081000, 11212000, 21707000, 21542000, 21536000]}
    >>> obj = pd.DataFrame(data)
    >>> obj
          city  year    people
    0    Wuhan  2017  10892900
    1    Wuhan  2018  11081000
    2    Wuhan  2019  11212000
    3  Beijing  2017  21707000
    4  Beijing  2018  21542000
    5  Beijing  2019  21536000
    >>>
    >>> obj['city']
    0      Wuhan
    1      Wuhan
    2      Wuhan
    3    Beijing
    4    Beijing
    5    Beijing
    Name: city, dtype: object
    >>>
    >>> obj.year
    0    2017
    1    2018
    2    2019
    3    2017
    4    2018
    5    2019
    Name: year, dtype: int64
    >>>
    >>> type(obj.year)
    <class 'pandas.core.series.Series'>
    >>>
    >>> obj.loc[2]
    city         Wuhan
    year          2019
    people    11212000
    Name: 2, dtype: object
    >>>
    >>> obj.head()
          city  year    people
    0    Wuhan  2017  10892900
    1    Wuhan  2018  11081000
    2    Wuhan  2019  11212000
    3  Beijing  2017  21707000
    4  Beijing  2018  21542000

### 【03x05】修改列的值

列可以通过赋值的方式进行修改。在下面示例中，分别给”money”列赋上一个标量值和一组值：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35

    >>> import pandas as pd
    >>> import numpy as np
    >>> data = {'city': ['Wuhan', 'Wuhan', 'Wuhan', 'Beijing', 'Beijing', 'Beijing'],
    		'year': [2017, 2018, 2019, 2017, 2018, 2019],
            'people': [10892900, 11081000, 11212000, 21707000, 21542000, 21536000],
            'money':[np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN]}
    >>> obj = pd.DataFrame(data, index=['A', 'B', 'C', 'D', 'E', 'F'])
    >>> obj
          city  year    people  money
    A    Wuhan  2017  10892900    NaN
    B    Wuhan  2018  11081000    NaN
    C    Wuhan  2019  11212000    NaN
    D  Beijing  2017  21707000    NaN
    E  Beijing  2018  21542000    NaN
    F  Beijing  2019  21536000    NaN
    >>>
    >>> obj['money'] = 6666666666
    >>> obj
          city  year    people       money
    A    Wuhan  2017  10892900  6666666666
    B    Wuhan  2018  11081000  6666666666
    C    Wuhan  2019  11212000  6666666666
    D  Beijing  2017  21707000  6666666666
    E  Beijing  2018  21542000  6666666666
    F  Beijing  2019  21536000  6666666666
    >>>
    >>> obj['money'] = np.arange(100000000, 700000000, 100000000)
    >>> obj
          city  year    people      money
    A    Wuhan  2017  10892900  100000000
    B    Wuhan  2018  11081000  200000000
    C    Wuhan  2019  11212000  300000000
    D  Beijing  2017  21707000  400000000
    E  Beijing  2018  21542000  500000000
    F  Beijing  2019  21536000  600000000

将列表或数组赋值给某个列时，其长度必须跟 DataFrame 的长度相匹配。如果赋值的是一个 Series，就会精确匹配 DataFrame 的索引：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26

    >>> import pandas as pd
    >>> import numpy as np
    >>> data = {'city': ['Wuhan', 'Wuhan', 'Wuhan', 'Beijing', 'Beijing', 'Beijing'],
    		'year': [2017, 2018, 2019, 2017, 2018, 2019],
            'people': [10892900, 11081000, 11212000, 21707000, 21542000, 21536000],
            'money':[np.NaN, np.NaN, np.NaN, np.NaN, np.NaN, np.NaN]}
    >>> obj = pd.DataFrame(data, index=['A', 'B', 'C', 'D', 'E', 'F'])
    >>> obj
          city  year    people  money
    A    Wuhan  2017  10892900    NaN
    B    Wuhan  2018  11081000    NaN
    C    Wuhan  2019  11212000    NaN
    D  Beijing  2017  21707000    NaN
    E  Beijing  2018  21542000    NaN
    F  Beijing  2019  21536000    NaN
    >>>
    >>> new_data = pd.Series([5670000000, 6890000000, 7890000000], index=['A', 'C', 'E'])
    >>> obj['money'] = new_data
    >>> obj
          city  year    people         money
    A    Wuhan  2017  10892900  5.670000e+09
    B    Wuhan  2018  11081000           NaN
    C    Wuhan  2019  11212000  6.890000e+09
    D  Beijing  2017  21707000           NaN
    E  Beijing  2018  21542000  7.890000e+09
    F  Beijing  2019  21536000           NaN

### 【03x06】增加 / 删除列

为不存在的列赋值会创建出一个新列，关键字 del 用于删除列：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33

    >>> import pandas as pd
    >>> data = {'city': ['Wuhan', 'Wuhan', 'Wuhan', 'Beijing', 'Beijing', 'Beijing'],
    	'year': [2017, 2018, 2019, 2017, 2018, 2019],
            'people': [10892900, 11081000, 11212000, 21707000, 21542000, 21536000]}
    >>> obj = pd.DataFrame(data)
    >>> obj
          city  year    people
    0    Wuhan  2017  10892900
    1    Wuhan  2018  11081000
    2    Wuhan  2019  11212000
    3  Beijing  2017  21707000
    4  Beijing  2018  21542000
    5  Beijing  2019  21536000
    >>>
    >>> obj['northern'] = obj['city'] == 'Beijing'
    >>> obj
          city  year    people  northern
    0    Wuhan  2017  10892900     False
    1    Wuhan  2018  11081000     False
    2    Wuhan  2019  11212000     False
    3  Beijing  2017  21707000      True
    4  Beijing  2018  21542000      True
    5  Beijing  2019  21536000      True
    >>>
    >>> del obj['northern']
    >>> obj
          city  year    people
    0    Wuhan  2017  10892900
    1    Wuhan  2018  11081000
    2    Wuhan  2019  11212000
    3  Beijing  2017  21707000
    4  Beijing  2018  21542000
    5  Beijing  2019  21536000

### 【03x07】name 属性

可以通过 index.name 和 columns.name 属性设置索引（index）和列标签（columns）的 name，注意 DataFrame 对象是没有 name 属性的：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16

    >>> import pandas as pd
    >>> data = {'city': ['Wuhan', 'Wuhan', 'Wuhan', 'Beijing', 'Beijing', 'Beijing'],
    		'year': [2017, 2018, 2019, 2017, 2018, 2019],
            'people': [10892900, 11081000, 11212000, 21707000, 21542000, 21536000]}
    >>> obj = pd.DataFrame(data)
    >>> obj.index.name = 'index'
    >>> obj.columns.name = 'columns'
    >>> obj
    columns     city  year    people
    index
    0          Wuhan  2017  10892900
    1          Wuhan  2018  11081000
    2          Wuhan  2019  11212000
    3        Beijing  2017  21707000
    4        Beijing  2018  21542000
    5        Beijing  2019  21536000

    1
    2
    3
    4
    5

    这里是一段防爬虫文本，请读者忽略。
    本文原创首发于 CSDN，作者 TRHX。
    博客首页：https://itrhx.blog.csdn.net/
    本文链接：https://itrhx.blog.csdn.net/article/details/106676693
    未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离剽窃！

您的喜欢是作者写作最大的动力！❤️

- PayPal
- AliPay
- WeChatPay
- QQPay

Donate

最后更新于 2020年8月6日

Pandas

Series

DataFrame

###### 上一页

#### Python 数据分析三剑客之 Pandas（二）：Index 索引对象以及各种索引操作

###### 索引 Pandas Index

###### 下一页

#### Python 数据分析三剑客之 Matplotlib（十一）：最常用最有价值的 50 个图表【译文】

###### Matplotlib

#### 评论

## ๑۩ﺴ TRHX ﺴ۩๑

本文目录
欢迎光临

Hexo QQ 交流群 Telegram 交流群

CSDN 内容合伙人

文章分类

- BLOG
  (4)
- CDN
  (1)
- Hexo
  (9)
- Java
  (1)
- Linux
  (2)
- Markdown
  (2)
- Python 数据分析
  (27)
- Matplotlib
  (11)
- NumPy
  (6)
- Pandas
  (10)
- Python3 学习笔记
  (41)
- 基础学习
  (9)
- 学习经验
  (4)
- 爬虫学习
  (18)
- 爬虫实战
  (10)
- VPS
  (1)
- WEB前端
  (2)
- 图床
  (1)

热门标签
12306 3D图 58同城 Ajax BLOG Beautiful Soup CDN Coding Pages DataFrame Deepin Elicpse GitHub Pages Github Github Pages GroupBy HTTPS Hexo ICP备案 IO操作 Index JDBC JS 预加载 LaTeX Markdown Material X Matplotlib MongoDB MySQL NumPy PEP8 Pandas PicGo Pygame Python Redis SEO SQL Server 2012 SSR Selenium Series Ubuntu User-Agent VMware VPS XPath if语句 input()函数 instant.page jsDelivr lxml matplotibrc pyspider requests spfk urllib while循环 主题个性化 代理 位运算 公安备案 函数 函数应用 分割 切片 列表 判断函数 前程无忧 变量 合并数据集 哔哩哔哩 图例 图床 图形验证码 垃圾 备份 子图 字典 字符串函数 安居客 层级索引 年终总结 广播 异常 技巧 拼接 排序 排序函数 操作列表 散点图 数学函数 数据分裂 数据可视化 数据合并 数据替换 数据类型 数据读写 数据重塑 数组 文件 文件储存 无界面浏览器 时间序列 映射 条件函数 条形图 极区图 极坐标图 柱状图 模块 正则表达式 滑动验证码 点触验证码 爬虫 猫眼电影 瓜子二手车 画布 直方图 矩阵 等值线图 等高线图 算术函数 算术运算 类 索引 线性代数 线性图 统计函数 统计描述 统计计算 继承 编辑器 缺失值 网格 肺炎疫情 虎扑论坛 补丁 豆瓣电影 迭代 雷达图 饼状图
最近在听