pandas 构造 Series 的数据

之前介绍过 series 由四个重要的参数组成，它们分别是 data、index、name 和 dtype。那么，今天我们会重点介绍一下在 data 部分，看它能够传哪些内容来构造一个 Series。

Series 结构

以今天我们构造的这样的一个 Series 为例：

import pandas as pd

ser = pd.Series(data=[1, 2, 3],
                index=['a', 'b', 'b'],
                name='my_name',
                dtype=float
               )
ser
'''
a    1.0
b    2.0
b    3.0
Name: my_name, dtype: float64
'''

其中：

• data 是它数据的内容，这里是 1、2、3。
• index 是这个数据的索引，它可以重复，为 a、b、b。
• name 是这个 Series 的名称，我们这儿取名为 my_name
• dtype 是 Series 的类型，我们把它转为了一个 float 类型

我们会重点介绍一下在 data 部分，看它能够传哪些内容来构造一个 Series。

data 数据类型

来看一下从官方文档里面截取的关于 date 的定义。在参数 data 中的定义是有丰富的数据类型的传入。

pd.Series(
    data=None,
    index=None,
    dtype: 'Dtype | None' = None,
    name=None,
    copy: 'bool' = False,
    fastpath: 'bool' = False,
)
'''
Parameters
----------
data : array-like, Iterable, dict, or scalar value
    Contains data stored in Series. 
    If data is a dict, argument order is maintained.
...
'''

其中，比如说是 NumPy 里面的 array-like 类型，只要他的行为能够满足 NumPy 中 array 这样的数据类型的参数我们都可以传入，这个我们后面会介绍。array-like 是一个鸭子类型，表达的是它的行为是 array 类似的方法或者操作就可以。

Iterable 是可迭代的对象，如果是一个可以迭代的内容也可以传入。比如说我们的 range、列表、数组这样的一些可迭代的对象都可以传入，字典也可以传入。要注意的是，字符串虽然是可迭代对象，但会按标量处理，可以解包成列表再传入。

标量就是一个单一值，这个单一值利用 NumPy 的广播机制可以兼容单个值的 Series 和多个值的 Series。那如果是单一值，这单个值就会成为这个 Series 的所有值的同样的值。

array-like

关于 array-like 我们这里使用 NumPy 来构造一个等差数列的这样的一个 array 数组。等差数组它是从 0 到 6 我们把它直接传入到 Series 构造方法，可以得到这样的一个 Series。

import numpy as np

arr = np.arange(7)
arr
# array([0, 1, 2, 3, 4, 5, 6])

pd.Series(arr)
'''
0    0
1    1
2    2
3    3
4    4
5    5
6    6
dtype: int64
'''

数据类型会自动推导，以上推导为 int64 类型。我们还可以定义一个全为零的这样的一个 array，我们把它传入到 data 里，然后设置数据类型为 int：

arr2 = np.zeros(4)
arr2
# array([0., 0., 0., 0.])

pd.Series(arr2, dtype=int)
'''
0    0
1    0
2    0
3    0
dtype: int64
'''

就得到了一个所有值为零的 Series。

或者，我们直接构造一个 array，然后将这个 array 插入到 data 参数中，得到了一个新的 Series：

arr3 = np.array([8, 9, 10])
arr3
# array([ 8,  9, 10])

pd.Series(arr3)
'''
0     8
1     9
2    10
dtype: int64
'''

Iterable

关于可迭代对象，Python 支持非常多的可迭代对象。首先列表是一个原生的可迭代的对象，我们直接在这里可以传入一个列表，当然元组也是可以支持的。range 是一个内置可迭代对象。

pd.Series([6, 7, 3])
'''
0    6
1    7
2    3
dtype: int64
'''

pd.Series((4, 5, 6))
'''
0    4
1    5
2    6
dtype: int64
'''

pd.Series(range(3, 10, 2))
'''
0    3
1    5
2    7
3    9
dtype: int64
'''

下边是一个迭代生成表达式的例子：

foo = ['he', 'she', 'hey']
pd.Series(i[1] for i in foo)
'''
0    e
1    h
2    e
dtype: object
'''

这个案例中将列表 foo 中每个元素的第二位作为我们的 data 的内容，在这儿直接写了一个迭代生成器。

字典 dict

传入字典它也是一个可迭代的对象，不过在这里我们要注意的一点是，在字典构造 Series 的时候他的键会成为索引，而对应的值会成为 data 的值。

d = {"b": 1, "a": 0, "c": 2}
pd.Series(d)
'''
b    1
a    0
c    2
dtype: int64
'''

我们这里就非常方便地给出了索引，也给出了值。这个例子中将 b、a、c 成为索引，而它的 value 成为了值，数据类型也是按照值的情况进行推导的。

既然字典给出了键和值，就是索引和数值，那我们怎么样去重新的去定义一个索引的顺序呢？如果说在原有的这个字典中我们定义了索引，之后会出现什么样的情况？以这个例子我们来做一下演示：

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

在这个例子中 c 我们排在了第一位，b 排在第二位，d 在我们的字典中没有。执行结果按照我们索引给的顺序对这个字典的内容进行重新排序，对于没有的键给出了 NaN 这样的一个缺失值。

这里需要我们特别注意，字典从 Python 3.6 它具有了这样的一个顺序性，那我们在使用 pandas 的时候一定要使用比较高的 Python 版本来实现这样的一个特性。

标量 scalar

Series 的构造可以支持一个标量。所谓的标量是一个单一的值，这个单一的值就是这个 series 的一个唯一值。

pd.Series(10)
'''
0    10
dtype: int64
'''

我们可以看到在这一行代码中我们给出了一个标量，这个标量它是一个唯一的值。注意，虽然只有一个值，但它仍然是一个 Series，它也有索引。如果想对它转为一个标量，需要使用 squeeze() 方法：

pd.Series(10).squeeze()
# 10

一个标量如果给出多个索引，那这个索引是我们单独给出的，不是从取值上推导出来：

pd.Series('hello', index=['a', 'b', 'c'])
'''
a    hello
b    hello
c    hello
dtype: object
'''

以上给出了一个 hello 这样的一个标量，索引给出的是 a、b、c，执行结果看到了它还是有三行数据，这是根据 index 推导出来的，然而它的所有的值是同一个这样的一个标量 hello。就是说数据的长度不是由数据来唯一的去表示，同时还要看那 index 的长度。

好了，关于 Series 的构造数据的 data 参数我们就介绍完了。

更新时间：Aug. 30, 2022, 7:42 p.m. 标签：pandas series data 数据