Pandas 数据结构简介

2023-10-18

字数统计: 2.9k字 | 阅读时长≈ 13分

原文地址：Pandas 中文网

数据结构简介

本节介绍 Pandas 基础数据结构，包括各类对象的数据类型，索引，轴标记，对齐等基础操作。

首先，导入 NumPy 和 Pandas
1
2
In [1]: import numpy as np
In [2]: import pandas as pd
数据对齐是内在的，这一原则是根本。除非显式指定，Pandas 不会断开标签和数据之间的连接。
下文先简单介绍数据结构，然后再分门别类介绍每种功能与方法。

Series

Series 是带标签的一维数组，可以存储整数，浮点数，字符串，Python 对象等类型的数据。轴标签统称为索引。调用 pd.Serise 函数即可创建 Series。

1	s = pd.Series(data, index=index)

上述代码中，data 支持一以下数据类型：

Python 字典
多维数组
标量值（如，5）

index 是轴标签列表。不同数据可分为以下几种情况：

多为数组

data 是多维数组时，index 长度必须与 data 长度一致。没有指定 index 参数时，创建数值型索引，即 [0, …, len(data) -1]。

In [3]: s = pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])

In [4]: s
Out[4]: 
a   -0.286039
b   -0.457342
c   -0.057657
d   -0.250386
e   -0.521256
dtype: float64

In [5]: s.index
Out[5]: Index([u'a', u'b', u'c', u'd', u'e'], dtype='object')

In [6]: pd.Series(np.random.randn(5))
Out[6]: 
0   -1.712299
1    1.032414
2    0.281086
3    0.691988
4   -0.645353
dtype: float64

注意：Pandas 的索引值可以重复。不支持重复索引值的操作会触发异常。其原因主要与性能有关，有很多计算实例，比如 GroupBy 操作就不用索引。

字典

Series 可以用字典实例化

In [10]: d = {'b': 1, 'a': 0, 'c': 2}

In [11]: pd.Series(d)
Out[11]: 
a    0
b    1
c    2
dtype: int64

注意：data 为字典，且未设置 index 参数时，如果 Python 版本 >= 3.6 且 Pandas 版本 >= 0.23, Series 按字典的插入顺序排序索引。
Python < 3.6 或 Pandas < 0.23，且未设置 index 参数时，Series 按字母顺序排序字典的键(key) 列表。

上例中，如果 Python < 3.6 或 Pandas < 0.23, Series 按字母排序字典的键，输出结果不是 [‘b’, ‘a’, ‘c’], 而是 [‘a’, ‘b’, ‘c’].
如果设置了 index 参数，则按照索引标签提取 data 里对应的值。

In [12]: d = {'a': 0., 'b': 1., 'c': 2.}

In [13]: pd.Series(d)
Out[13]: 
a    0.0
b    1.0
c    2.0
dtype: float64

In [14]: pd.Series(d, index=['b', 'c', 'd', 'a'])
Out[14]: 
b    1.0
c    2.0
d    NaN
a    0.0
dtype: float64

注意，Pandas 用 NaN（Not a Number）表示缺失数据。

标量值

data 是标量值时，必须提供索引。Series 按索引的长度重复该标量值。

In [15]: pd.Series(5., index=['a', 'b', 'c', 'd', 'e'])
Out[15]: 
a    5.0
b    5.0
c    5.0
d    5.0
e    5.0
dtype: float64

Series 类似多维数组

Series 操作与 ndarray 类似，支持大多数 NumPy 函数，还支持索引切片。

In [22]: s[0]
Out[22]: -0.2860392126572653

In [23]: s[:3]
Out[23]: 
a   -0.286039
b   -0.457342
c   -0.057657
dtype: float64

In [24]: s[s > s.median()]
Out[24]: 
c   -0.057657
d   -0.250386
dtype: float64

In [25]: s[[4, 3, 1]]
Out[25]: 
e   -0.521256
d   -0.250386
b   -0.457342
dtype: float64

In [26]: np.exp(s)
Out[26]: 
a    0.751233
b    0.632964
c    0.943974
d    0.778500
e    0.593775
dtype: float64

和 NumPy 数组一样，Series 也支持 dtype。

1 2	In [28]: s.dtype Out[28]: dtype('float64')

Series 的数据模型一般是 NumPy 数据类型。不过，Pandas 和第三方库在一些方面扩展了 NumPy 类型系统，即扩展数据类型。比如，Pandas 的类别型数据与可空整数数据类型。

Series.array 用于提取 Series 数组。

In [29]: s.array
Out[29]: 
<PandasArray>
[  -0.2860392126572653,   -0.4573423472578759, -0.057656619528707875,
  -0.25038614366094974,    -0.521255520340594]
Length: 5, dtype: float64

执行不用索引的操作时，如禁用自动对齐，访问数组非常有用。

Series.array 一般是扩展数组。简单说，扩展数组就是把 N 个 numpy.ndarray 包在一起的打包器。Pandas 知道怎么把扩展数组存储到 Series 或 DataFrame 的列里。
Series 只是类似于多维数组，提取真正的多维数组，要用 Series.to_numpy().

1 2	In [33]: s.to_numpy() Out[33]: array([-0.28603921, -0.45734235, -0.05765662, -0.25038614, -0.52125552])

Series 是扩展数组，Series.to_numpy() 返回的是 NumPy 多维数组。

Series 类似字典

Series 类似固定大小的字典，可以用索引标签提取值或设置值：

In [36]: s['a']
Out[36]: -0.2860392126572653

In [38]: s['e'] = 12.

In [39]: s
Out[39]: 
a    -0.286039
b    -0.457342
c    -0.057657
d    -0.250386
e    12.000000
dtype: float64

In [40]: 'e' in s
Out[40]: True

In [41]: 'f' in s
Out[41]: False

引用 Series 里没有的标签会触发异常：

1 2	In [42]: s['f'] KeyError: 'f'

get 方法可以提取 Series 里没有的标签，返回 None 或指定默认值

In [43]: s.get('f')

In [44]: s.get('f', np.nan)
Out[44]: nan

更多信息，请参阅属性访问

矢量操作与对齐 Series 标签

Series 和 NumPy 数组一样，都不用循环每个值，而且 Series 支持大多数 NumPy 多维数组的方法。

In [46]: s + s
Out[46]: 
a    -0.572078
b    -0.914685
c    -0.115313
d    -0.500772
e    24.000000
dtype: float64

In [47]: s * 2
Out[47]: 
a    -0.572078
b    -0.914685
c    -0.115313
d    -0.500772
e    24.000000
dtype: float64

In [48]: np.exp(s)
Out[48]: 
a         0.751233
b         0.632964
c         0.943974
d         0.778500
e    162754.791419
dtype: float64

Series 和多维数组的主要区别在于，Series 之间的操作会自动基于标签对齐数据。因此不用顾及执行计算操作的 Series 是否有相同的标签。

In [51]: s[1:] + s[:-1]
Out[51]: 
a         NaN
b   -0.914685
c   -0.115313
d   -0.500772
e         NaN
dtype: float64

操作未对齐索引的 Series，其计算结果是所有涉及索引的并集。如果在 Series 里找不到标签，运算结果标记为 NaN，即缺失值。编写无需显式对齐数据的代码，给交互数据分析和研究提供了巨大的自由度和灵活性。Pandas 数据结构集成的数据对齐功能，是 Pandas 区别于大多数标签型数据处理工具的重要特性。

注意：总之，让不同索引对象操作的默认结果生成索引并集，是为了避免信息丢失。就算缺失了数据，索引标签依然包含计算的重要信息。当然，也可以用 dropna 函数清除含有缺失值的标签。

名称属性

Series 支持 name 属性。

In [52]: s = pd.Series(np.random.randn(5), name='something')

In [53]: s
Out[53]: 
0   -0.085453
1    1.158561
2   -0.491950
3    1.118593
4    0.242162
Name: something, dtype: float64

In [54]: s.name
Out[54]: 'something'

一般情况下，Series 自动分配 name，特别是提取一维 DataFrame 切片时，详见下文

pandas.Series.rename() 方法用于重命名 Series。

In [55]: s2 = s.rename("different")

In [56]: s2.name
Out[56]: 'different'

注意，s 与 s2 指向不同的对象。

DataFrame

DataFrame 是由多种类型的列构成的二维标签数据结构，类似 Excel，SQL表，或 Series 对象构成的字典。DataFrame 是最常用的 Pandas 对象，与 Series 一样，DataFrame 支持多种类型的输入数据。

一维 ndarray，列表，字典，Series字典；
二维 numpy.ndarray;
结构多维数组或记录多维数组；
Series；
DataFrame

除了数据，还可以有选择地传递 index（行标签）和 columns（列标签）参数。传递了索引或列，就可以确保生成的 DataFrame 里包含索引或列。Series 字典加上指定索引时，会丢弃与传递的索引不匹配的所有数据。
没有传递轴标签时，按照常规依据输入数据进行构建。

注意：Python >= 3.6 且 Pandas >= 0.23，数据是字典，且未指定 columns 参数时，DataFrame 的列按字典的插入顺序排序；Python <= 3.6 或 Pandas <= 0.23，且未指定 columns 参数时，DataFrame 的列按字典键的字母排序。

用 Series 字典或字典生成 DataFrame

生成的索引是每个 Series 索引的并集。先把嵌套字典转换为 Series。如果没有指定列，DataFrame 的列就是字典键的有序列表。

In [3]: d = {'one': pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
   ...:      'two': pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}

In [4]: df = pd.DataFrame(d)

In [5]: df
Out[5]: 
   one  two
a  1.0  1.0
b  2.0  2.0
c  3.0  3.0
d  NaN  4.0

In [6]: pd.DataFrame(d, index=['d', 'b', 'a'])
Out[6]: 
   one  two
d  NaN  4.0
b  2.0  2.0
a  1.0  1.0

In [7]: pd.DataFrame(d, index=['d', 'b', 'a'], columns=['two', 'three'])
Out[7]: 
   two three
d  4.0   NaN
b  2.0   NaN
a  1.0   NaN

index 和 columns 属性分别用于访问行，列标签。

注意，指定列与数据字典一起传递时，传递的列会覆盖字典的键。

In [8]: df.index
Out[8]: Index([u'a', u'b', u'c', u'd'], dtype='object')

In [9]: df.columns
Out[9]: Index([u'one', u'two'], dtype='object')

用多为数组字典，列表字典生成 DataFrame

多维数组的长度必须相同。如果传递了索引参数，index 的长度必须与数组一致。如果没有传递索引参数，生成的结果是 range(n)，n 为数组的长度。

In [10]: d = {'one': [1., 2., 3., 4.],
    ...:      'two': [4., 3., 2., 1.]}

In [11]: pd.DataFrame(d)
Out[11]: 
   one  two
0  1.0  4.0
1  2.0  3.0
2  3.0  2.0
3  4.0  1.0

In [12]: pd.DataFrame(d, index=['a', 'b', 'c', 'd'])
Out[12]: 
   one  two
a  1.0  4.0
b  2.0  3.0
c  3.0  2.0
d  4.0  1.0

用结构多维数组或记录多维数组生成 DataFrame

本例与数组字典的操作方式相容

In [21]: data = np.zeros((2, ), dtype=[('A', 'i4'), ('B', 'f4'), ('C', 'a10')])

In [22]: data[:] = [(1, 2., 'Hello'), (2, 3., "World")]

In [23]: pd.DataFrame(data)
Out[23]: 
   A    B      C
0  1  2.0  Hello
1  2  3.0  World

In [24]: pd.DataFrame(data, index=['first', 'second'])
Out[24]: 
        A    B      C
first   1  2.0  Hello
second  2  3.0  World

In [25]: pd.DataFrame(data, columns=['C', 'A', 'B'])
Out[25]: 
       C  A    B
0  Hello  1  2.0
1  World  2  3.0

注意：DataFrame 的运作方式与 NumPy 二维数组不同。

用列表字典生成 DataFrame

In [26]: data2 = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}]

In [27]: pd.DataFrame(data2, index=['first', 'second'])
Out[27]: 
        a   b     c
first   1   2   NaN
second  5  10  20.0

In [28]: pd.DataFrame(data2, columns=['a', 'b'])
Out[28]:

用元组字典生成 DataFrame

元组字典可以自动创建多层索引 DataFrame

In [30]: pd.DataFrame({('a', 'b'): {('A', 'B'): 1, ('A', 'C'): 2},
    ...:               ('a', 'a'): {('A', 'C'): 3, ('A', 'B'): 4},
    ...:               ('a', 'c'): {('A', 'B'): 5, ('A', 'C'): 6},
    ...:               ('b', 'a'): {('A', 'C'): 7, ('A', 'B'): 8},
    ...:               ('b', 'a'): {('A', 'D'): 9, ('A', 'B'): 10}})
Out[30]: 
       a               b
       a    b    c     a
A B  4.0  1.0  5.0  10.0
  C  3.0  2.0  6.0   NaN
  D  NaN  NaN  NaN   9.0

用 Series 创建 DataFrame

生成的 DataFrame 继承了输入的 Series 的索引，如果没有指定列名，默认列名是输入 Series 的名称。

缺失数据

更多内容，详见缺失数据。DataFrame 里的缺失值用 np.nan 表示。DataFrame 构建器以 numpy.MaskedArray 为参数时，被屏蔽的条目为缺失数据。

内容未完，更多请参考官网

原文地址：Pandas 中文网