Python 之 Pandas Series 数据结构
文章目录
- 一、Series 结构
- 二、数据结构 Series 创建
-
- 1. 创建
-
- 1.1 列表/数组作为数据源创建 Series
- 1.2 字典作为数据源创建 Series
- 1.3 通过标量创建
- 2. 参数说明
-
- 2.1 index 参数
- 2.2 name 参数
- 2.3 copy 参数
- 三、Series 的索引/切片
-
- 1. 下标索引
- 2. 标签索引
- 3. 切片
- 四、Series 数据结构的基本技巧
-
- 1. 查看前几条和后几条数据
- 2. 重新索引：reindex
- 3. 对齐运算
- 4. 删除和添加
一、Series 结构
- Series 结构，也称 Series 序列，是 Pandas 常用的数据结构之一，它是一种类似于一维数组的结构，由一组数据值（value）和一组标签组成，其中标签与数据值具有对应关系。
- 标签不必是唯一的，但必须是可哈希类型（也就是不可变类型，就像整型、字符串型等）。该对象既支持基于整数的索引，也支持基于标签的索引，并提供了许多方法来执行涉及索引的操作。ndarray 的统计方法已被覆盖，以自动排除缺失的数据（目前表示为 NaN）。
- Series 可以保存任何数据类型，比如整数、字符串、浮点数、Python 对象等，它的标签默认为整数，从 0 开始依次递增。
- Series 的结构图，如下所示：
- 通过标签我们可以更加直观地查看数据所在的索引位置。
- 在这里，我们引入 numpy 和 pandas 库，便于后续的操作。
import numpy as np
import pandas as pd
二、数据结构 Series 创建
- Series 的语法模板如下：
pd.Series(data=None, index=None, dtype=None, name=None, copy=False)
- 其参数含义如下：
- data 表示输入的数据，可以是列表、常量、ndarray 数组等,如果是字典,则保持参数顺序。
- index 表示索引值，必须是可散列的（也就是不可变数据类型，就像 str，bytes 和数值类型)，并且与数据具有相同的长度，允许使用非唯一索引值。如果未提供，将默认为 RangeIndex（0，1，2，…，n）。
- dtype 表示输出系列的数据类型。如果未指定，将从数据中推断数据类型。
- name 是给 Series 定义一个名称。
- copy 表示对 data 进行拷贝，默认为 False，仅影响 Series 和 ndarray 数组。
1. 创建
1.1 列表/数组作为数据源创建 Series
- （1） 以列表作为数据创建 Series。
ar_list = [3,10,3,4,5]
print(type(ar_list))
s1 = pd.Series(ar_list)
print(s1)
print(type(s1))
#- （2） 以数组作为数据创建 Series。
np_rand = np.arange(1,6)
s1 = pd.Series(np_rand)
s1
#0 1
#1 2
#2 3
#3 4
#4 5
#dtype: int32
- （3） 通过 index 和 values 属性取得对应的标签和值。
- 我们可以取出 Series 当中的所有标签值，默认为 RangeIndex（0，1，2，…，n）。
s1.index
#RangeIndex(start=0, stop=5, step=1)
- 当然，我们可以强制转化为列表输出。
list(s1.index)
#[0, 1, 2, 3, 4]
- 我们也取出 Series 的所有数据值，他们的数据类型为 ndarray。
print(s1.values, type(s1.values))
#[1 2 3 4 5] - （4） 通过标签取得对应的值，或者修改对应的值。
- 我们可以输出 s1 当中索引为 1 的数据。
s1[1]
#2
- 我们也可以修改 s1 当中索引为 2 的数据。
s1[2] = 50
s1
#0 1
#1 2
#2 50
#3 4
#4 5
#dtype: int32
- 如果我们直接以负数作为索引值对 s1 进行操作，会直接报错，但可以通过新增索引和数据值进行操作。
- （5） 和列表索引区别。
- （a） 默认的索引 RangeIndex，不能使用负值，来表示从后往前找元素。
s1[-1] = 20
s1
# 0 1
# 1 2
# 2 50
# 3 4
# 4 5
#-1 20
#dtype: int64
- （b） 获取不存在的索引值对应数据，会报错，但是可以赋值，相当于新增数据。
s1[-1] = 20
print(s1)
print(s1.index)
# 0 1
# 1 2
# 2 50
# 3 4
# 4 5
#-1 20
#dtype: int64
#Int64Index([0, 1, 2, 3, 4, -1], dtype='int64')
- （c） 可以新增不同类型索引的数据，新增不同类型索引的数据，索引的类型会发生自动变化。
s1["a"] = 40
s1.index
#Index([0, 1, 2, 3, 4, -1, 'a'], dtype='object')
1.2 字典作为数据源创建 Series
- （1） 以字典作为数据创建 Series。
d = {'a': 1, 'b': 2, 'c': 3}
ser = pd.Series(data=d)
ser
#a 1
#b 2
#c 3
#dtype: int64
- （2） 通过 index 和 values 属性取得对应的标签和值。
- 具体可见如下例子。
ser.index
ser.values
#Index(['a', 'b', 'c'], dtype='object')
#array([1, 2, 3], dtype=int64)
- （3） 通过标签取得对应的值，或者修改对应的值。
- 和使用列表、数组创建 Series 一样，我们可以通过调用标签得到对应的数据。
ser['a']
#1
- 通过标签修改对应的数据。
ser["s"] = 50
#a 1
#b 2
#c 3
#s 50
#dtype: int64
- 如果标签非数值型，我们既可以用标签获取值，也可以用标签的下标获取值。
ser[0]
#1
- 负数表示从后往前进行索引。
ser[-1]
#50
- 也可以直接全部进行修改。
d = {'a': 1, 5: 2, 'c': 3}
ser1 = pd.Series(data=d)
ser1
#a 1
#5 2
#c 3
#dtype: int64
- 那么，当标签存在数值型的数据，就不可以使用标签的下标获取值，不然会直接报错。
- （4） 取得数据时，先进行标签的检查，如果标签中没有，再进行索引的检查，都不存在则报错。
1.3 通过标量创建
s = pd.Series(100,index=range(5))
s
#0 100
#1 100
#2 100
#3 100
#4 100
#dtype: int64
2. 参数说明
2.1 index 参数
- 索引值，必须是可散列的(不可变数据类型，例如 str，bytes 和数值类型)，并且与数据具有相同的长度，允许使用非唯一索引值。如果未提供，将默认为 RangeIndex（0，1，2，…，n）。
- （1） 使用显式索引的方法定义索引标签。
- 当我们自定义索引标签（即显示索引）时，需要和数据长度一致。
data = np.array(['a','b','c','d'])
s = pd.Series(data,index=[100,101,102,103])
s
#100 a
#101 b
#102 c
#103 d
#dtype: object
（2） 从指定索引的字典构造序列。
d = {'a': 1, 'b': 2, 'c': 3}
ser = pd.Series(d, index=['a', 'b', 'c'])
ser
#a 1
#b 2
#c 3
#dtype: int64
- （3） 当传递的索引值未匹配对应的字典键时，使用 NaN（非数字）填充。
d = {'a': 1, 'b': 2, 'c': 3}
ser = pd.Series(data=d, index=['x', 'b', 'z'])
ser
#x NaN
#b 2.0
#z NaN
#dtype: float64
- 这里需要注意的是，索引是首先使用字典中的键构建的。在此之后，用给定的索引值对序列重新编制索引，因此我们得到所有 NaN。
- （4） 通过匹配的索引值，改变创建 Series 数据的顺序。
d = {'a': 1, 'b': 2, 'c': 3}
ser = pd.Series(data=d, index=['c', 'b', 'a'])
ser
#c 3
#b 2
#a 1
#dtype: int64
2.2 name 参数
- 我们可以给一个 Series 对象命名，也可以给一个 Series 数组中的索引列起一个名字，pandas 为我们设计好了对象的属性，并在设置了 name 属性值用来进行名字的设定。以下程序可以用来完成该操作。
dict_data1 = {
"Beijing":2200,
"Shanghai":2500,
"Shenzhen":1700
}
data1 = pd.Series(dict_data1)
data1.name = "City_Data"
data1.index.name = "City_Name"
data1
#City_Name
#Beijing 2200
#Shanghai 2500
#Shenzhen 1700
#Name: City_Data, dtype: int64
- 序列的名称，如果是 DataFrame 的一部分，还包括列名。
- 如果用于形成数据帧，序列的名称将成为其索引或列名。每当使用解释器显示序列时，也会使用它。
2.3 copy 参数
- copy 表示对 data 进行拷贝，默认为 False，仅影响 Series 和 ndarray 数组。
- 我们以数组作为数据源，使用数组创建 Series。
np_rand = np.arange(1,6)
s1 = pd.Series(np_rand)
s1
#0 1
#1 2
#2 3
#3 4
#4 5
#dtype: int32
- 然后，我们改变 Series 标签为 1 的值，并在输出 Series 的对象 s1 的同时，输出数组对象 np_rand。
s1[1] = 50
print("s1:",s1)
print("np_rand:",np_rand)
#s1: 0 1
#1 50
#2 3
#3 4
#4 5
#dtype: int32
#np_rand: [ 1 50 3 4 5]
- 当源数据不是 Series 和 ndarray 类型时，我们以列表作为数据源，使用列表创建 Series。
my_list = [1,2,3,4,5,6]
s2 = pd.Series(my_list)
s2
#0 1
#1 2
#2 3
#3 4
#4 5
#5 6
#dtype: int64
- 然后，我们改变 Series 标签为 1 的值，并在输出 Series 的对象 s2 的同时，输出数组对象 my_list。
s2[1] = 50
print("s2:",s2)
print("my_list:",my_list)
#s2: 0 1
#1 50
#2 3
#3 4
#4 5
#5 6
#dtype: int64
#my_list: [1, 2, 3, 4, 5, 6]
三、Series 的索引/切片
1. 下标索引
- 下标索引类似于列表索引。
s = pd.Series(np.random.rand(5))
print(s)
print(s[3], type(s[3]), s[3].dtype)
#0 0.777657
#1 0.622071
#2 0.348129
#3 0.756216
#4 0.287849
#dtype: float64
#0.7562162366628223 float64
- 上面的位置索引和标签索引刚好一致，会使用标签索引。
- 当使用负值时，实际并不存在负数的标签索引。
2. 标签索引
- 当索引为 object 类型时，既可以使用标签索引也可以使用位置索引。
- Series 类似于固定大小的 dict，把 index 中的索引标签当做 key，而把 Series 序列中的元素值当做 value，然后通过 index 索引标签来访问或者修改元素值。
- 使用索标签访问单个元素值。
s = pd.Series(np.random.rand(5),index=list("abcde"))
print(s["b"], type(s["b"]), s["b"].dtype)
#0.26319645172526607 float64
- 使用索引标签访问多个元素值，注意需要选择多个标签的值，用 [[]] 来表示（相当于 [] 中包含一个列表）。
s = pd.Series([6,7,8,9,10],index = ['a','b','c','d','e'])
print(s)
print(s[['a','c','d']])
#a 6
#b 7
#c 8
#d 9
#e 10
#dtype: int64
#a 6
#c 8
#d 9
#dtype: int64
- 多标签会创建一个新的数组。
s1 = s[["b","a","e"]]
s1["b"] = 10
print("s1:",s1)
print("s源数据:",s)
#s1: b 10
#a 6
#e 10
#dtype: int64
#s源数据: a 6
#b 7
#c 8
#d 9
#e 10
#dtype: int64
3. 切片
- Series 使用标签切片运算与普通的 Python 切片运算不同，Series 使用标签切片时，其末端是包含的。
- Series 使用 python 切片运算即使用位置数值切片，其末端是不包含。
- 通过下标切片的方式访问 Series 序列中的数据，示例如下：
s = pd.Series(np.random.rand(10))
s
#0 0.927452
#1 0.235768
#2 0.516178
#3 0.277643
#4 0.697771
#5 0.273533
#6 0.133503
#7 0.185826
#8 0.687192
#9 0.316528
#dtype: float64
- 位置索引和标签索引刚好一致，使用切片时，如果是数值会认为是 python 切片运算，不包含末端。
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
print(s)
print(s[1:4])
#a 1
#b 2
#c 3
#d 4
#e 5
#dtype: int64
#b 2
#c 3
#d 4
#dtype: int64
- 如果想要获取最后三个元素，也可以使用下面的方式：
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
print(s[-3:])
#c 3
#d 4
#e 5
#dtype: int64
- 通过标签切片的方式访问 Series 序列中的数据，示例如下：
- 当 Series 使用标签切片时，其末端是包含的。
s1= pd.Series([6,7,8,9,10],index = ['a','b','c','d','e'])
s1["b":"d"]
#b 7
#c 8
#d 9
#dtype: int64
- 如果首尾端一致的话，就是该元素本身。
s1= pd.Series([6,7,8,9,10],index = ['e','d','a','b','a'])
s1
#c 8
#dtype: int64
- 在上面的索引方式，我们知道了位置索引和标签索引在 index 为数值类型时候的不同。
- 当 index 为数值类型的时候，使用位置索引会抛出 keyerror 的异常，也就是说当 index 为数值类型的时候，索引使用的是名称索引。
- 但是在切片的时候，有很大的不同，如果 index 为数值类型的时候，切片使用的是位置切片。
- 总的来说，当 index 为数值类型的时候：
- 进行索引的时候，相当于使用的是名称索引。
- 进行切片的时候，相当于使用的是位置切片。
四、Series 数据结构的基本技巧
1. 查看前几条和后几条数据
s = pd.Series(np.random.rand(15))
s
#0 0.819404
#1 0.552555
#2 0.792454
#3 0.215595
#4 0.824303
#5 0.970804
#6 0.997465
#7 0.519955
#8 0.354990
#9 0.758266
#dtype: float64
- s.head() 默认查看前 5 条数据，（其余的看括号内的数字）。
print(s.head())
print(s.head(1))
#0 0.819404
#1 0.552555
#2 0.792454
#3 0.215595
#4 0.824303
#dtype: float64
#0 0.819404
#dtype: float64
- s.tail() 默认查看后 5 条数据（其余的看括号内的数字）。
print(s.tail())
#5 0.970804
#6 0.997465
#7 0.519955
#8 0.354990
#9 0.758266
#dtype: float64
2. 重新索引：reindex
- 使用可选填充逻辑，使 Series 符合新索引。
- 将 NaN 放在上一个索引中没有值的位置。除非新索引等同于当前索引，并且生成新对象。
- 当新索引在上一个索引中不存在，生成新对象时，对应的值，设置为 NaN。
s = pd.Series(np.random.rand(5),index=list("abcde"))
s1 = s.reindex(list("cde"))
print("============s1=========")
print(s1)
print("============s=========")
print(s)
#============s1=========
#c 0.525886
#d 0.859566
#e 0.767330
#dtype: float64
#============s=========
#a 0.148972
#b 0.934014
#c 0.525886
#d 0.859566
#e 0.767330
#dtype: float64
3. 对齐运算
- 对其运算是数据清洗的重要过程，可以按索引对齐进行运算，如果没对齐的位置则补 NaN，最后也可以填充 NaN。
s1 = pd.Series(np.random.rand(3), index=["Kelly","Anne","T-C"])
s2 = pd.Series(np.random.rand(3), index=["Anne","Kelly","LiLy"])
print("==========s1=========")
print(s1)
print("==========s2=========")
print(s2)
print("==========s1+s2=========")
print(s1+s2)
#==========s1=========
#Kelly 0.481159
#Anne 0.066326
#T-C 0.916705
#dtype: float64
#==========s2=========
#Anne 0.090194
#Kelly 0.150472
#LiLy 0.220991
#dtype: float64
#==========s1+s2=========
#Anne 0.156520
#Kelly 0.631632
#LiLy NaN
#T-C NaN
#dtype: float64
4. 删除和添加
- s.drop() 是返回删除后的值，原值不改变，默认 inplace=False。
s = pd.Series(np.random.rand(5),index=list("abcde"))
s1 = s.drop("a")
print(s1)
print(s)
#b 0.918685
#c 0.613762
#d 0.142165
#e 0.309032
#dtype: float64
#a 0.630504
#b 0.918685
#c 0.613762
#d 0.142165
#e 0.309032
#dtype: float64
- 当 inplace 参数设置为 True 时，原值发生变化，返回 None。
s = pd.Series(np.random.rand(5),index=list("abcde"))
s1 = s.drop("a",inplace=True)
print(s1)
print(s)
#None
#b 0.946778
#c 0.733088
#d 0.793721
#e 0.681853
#dtype: float64
- 添加操作时，如果对应的标签没有就是添加，有就是修改。
s1 = pd.Series(np.random.rand(5),index=list("abcde"))
print(s1)
s1["s"] = 100
print(s1)
#a 0.743596
#b 0.778193
#c 0.036640
#d 0.324620
#e 0.282358
#dtype: float64
#a 0.743596
#b 0.778193
#c 0.036640
#d 0.324620
#e 0.282358
#s 100.000000
#dtype: float64