1. 技术文章
  2. Python数据分析-第5章Series(上)

Python数据分析-第5章Series(上)

由 不问归期 提交于 2020-04-06 08:04:40

系列(Series)是由一组数据（各种NumPy数据类型），以及一组与之相关的数据标签（索引）组成，系列不要求数据类型是相同的。

 

系列是一个一维数组，只有一个维度（或称作轴）是行（row），在访问系列时，只需要设置一个索引。pandas自动为系列创建了一个从0开始到N-1的序号，称作行的下标，行的位置。可以显式设置index参数，为每行设置标签，pandas把标签称作索引。用户可以通过索引、也可以通过位置来访问Series对象中的元素。

 

系列可以看作是索引到数据值的一个映射，一个索引对应一个数据值，这种结构就是有序的字典。

 

1.构造

pandas.Series(data=None, index=None, dtype=None, name=None, copy=False)
  • data：传递给系列的数据，可以是ndarray、list或字典
  • index：设置轴的索引，索引值的个数与data参数的长度相同。如果没有设置index参数，那么默认值是 np.arange(n)，或者 RangeIndex (0, 1, 2, …, n)。
  • dtype：设置系列元素的数据类型，如果没有设置，那么将推断数据类型
  • name：系列是一个多行的结构，name是系列的名称
  • copy：复制数据，默认值是false
 

1.1.使用ndarray或list创建系列

如果数据是ndarray，则传递的索引必须具有相同的长度。 如果没有传递索引值，那么默认的索引将是范围(n)，其中n是数组长度，即[0,1,2,3…. range(len(array))-1] - 1]。

In [1]: 
import numpy as np
import pandas as pd

data=np.array(['a','b','c','d'])
sd = pd.Series(data)
sd
Out[1]: 
0    a
1    b
2    c
3    d
dtype: object
 

1.2.显式传递index参数

In [2]: 
sd1 = pd.Series(data,index=['A','B','C','D'])
sd1
Out[2]: 
A    a
B    b
C    c
D    d
dtype: object
 

1.3.显式设置序列的name和index的name

系列是一维数组，只有一个维度，那就是row，在系列中为Index命名就是设置行轴的名称。
系列看起来像多行一列的数据集，但是他们之间有本质的区别，多行一列是二维数组，有行名称和列名称，需要使用两个索引值来访问单个cell的数据，而序列只需要一个索引就可以访问元素值。

In [3]: 
sd2=pd.Series(data,index=pd.Index(['A','B','C','D'],name='idx_name'),name='series_name')
sd2
Out[3]: 
idx_name
A    a
B    b
C    c
D    d
Name: series_name, dtype: object
 

1.4.从字典构造系列

通过字典来创建Series，字典的key作为序列的索引标签，value作为对应Key的数据值

In [13]: 
import pandas as pd
import numpy as np
data = {'a' : 0, 'b' : 1, 'c' : 2}
sd3 = pd.Series(data)
sd3
Out[13]: 
a    0
b    1
c    2
dtype: int64
 

1.5.从标量创建一个系列

如果数据是标量值，则必须提供索引。将重复该值以匹配索引的长度。

In [2]: 
import pandas as pd
import numpy as np
sd4 = pd.Series(5, index=[0, 1, 2, 3])
sd4
Out[2]: 
0    5
1    5
2    5
3    5
dtype: int64
 

2.属性

系列对象包含的属性：

  1. index：系列的索引
  2. shape：系列的形状，表示各个维度的数量
  3. array：把系列的数据值转换为Pandas数组
  4. values：把系列的数据值转换为numpy数组
  5. dtype：系列元素的数据类型
  6. hasnan：系列是否包含nan
  7. is_unique：系列的元素是否是唯一的
 

2.1.索引

In [8]: 
sd.index
Out[8]: 
RangeIndex(start=0, stop=4, step=1)
In [9]: 
sd1.index
Out[9]: 
Index(['A', 'B', 'C', 'D'], dtype='object')
 

2.2.shape

In [10]: 
sd.shape
Out[10]: 
(4,)
In [11]: 
sd1.shape
Out[11]: 
(4,)
 

2.3.PandasArray或ndarray数组

In [12]: 
sd.array
Out[12]: 
<PandasArray>
['a', 'b', 'c', 'd']
Length: 4, dtype: object
In [13]: 
sd.values
Out[13]: 
array(['a', 'b', 'c', 'd'], dtype=object)
 

3.系列数据的转换

 

转换系列数据值的类型：

Series.astype(self, dtype, copy=True, errors='raise', **kwargs)
In [9]: 
sd5=sd4.astype(dtype='float')
sd5
Out[9]: 
0    5.0
1    5.0
2    5.0
3    5.0
dtype: float64
 

把序列转换为NumPy数组：

Series.to_numpy(self, dtype=None, copy=False)
In [10]: 
sd6=sd4.to_numpy()
sd6
Out[10]: 
array([5, 5, 5, 5], dtype=int64)
 

把序列转换为list：

Series.to_list(self)
In [12]: 
sd7=sd4.to_list()
sd7
Out[12]: 
[5, 5, 5, 5]
 

4.访问系列的元素

系列元素的访问，可以通过索引和行标签，索引标签是在构造函数中通过index参数传递或构造的，而索引值（也可以称作序列的下标）是默认生成的，第一个元素的下标值是0，依次加1递增。

 

4.1.通过索引来访问系列

对于序列，通过索引来访问系列元素的格式是：Sereis[index]，索引可以是整数，也可以是字符类型的标签：

In [14]: 
sd3['a']
Out[14]: 
0
In [15]: 
sd3[0]
Out[15]: 
0
 

4.2.通过属性来访问系列的元素值

 

4.2.1.at和iat属性，用于访问系列的单个元素值

 
  • at属性通过索引访问单个系列值
In [18]: 
sd3.at['a']
Out[18]: 
0
 
  • iat属性表示通过位置访问系列的单个元素值
In [19]: 
sd3.iat[0]
Out[19]: 
0
 

4.2.2.loc和iloc通过系列的位置来访问元素

 
  • iloc：基于整数位置的索引，用于按位置选择序列元素
    1. 单个位置索引，比如sd.iloc[1]
    2. 位置索引的列表，比如 sd.iloc[[0,1]]
    3. 整数序列，比如，sd.iloc[0:2]
    4. 布尔值数组，sd.iloc[[True, False, True, False]]
In [20]: 
sd3.iloc[1]
Out[20]: 
1
In [25]: 
sd3.iloc[[1,2]]
Out[25]: 
b    1
c    2
dtype: int64
In [26]: 
sd3.iloc[0:2]
Out[26]: 
a    0
b    1
dtype: int64
In [28]: 
sd3.iloc[[True, False, True]]
Out[28]: 
a    0
c    2
dtype: int64
 
  • loc：通过索引标签和布尔值数组来选择序列的元素
In [29]: 
sd3.loc['a']
Out[29]: 
0
In [30]: 
sd3.loc[['a','b']]
Out[30]: 
a    0
b    1
dtype: int64
In [31]: 
sd3.loc[[True, False, True]]
Out[31]: 
a    0
c    2
dtype: int64
 

4.2.3.通过位置掩码（布尔索引数组）来访问序列的元素

 

在上面的例子中，['a','b']称作索引数组，如果索引数据的元素类型是布尔类型，并且索引数组的元素数量和序列相同，那么把这种索引数组称作位置掩码。当位置为True时，表示选择该元素；当位置为False，表示不选择该元素。

In [32]: 
sd3.iloc[[True, False, True]]
Out[32]: 
a    0
c    2
dtype: int64
In [33]: 
sd3.loc[[True, False, True]]
Out[33]: 
a    0
c    2
dtype: int64
 

4.2.4.迭代器

可以通过序列的__iter__()函数获得值的迭代器，也可以通过items()或iteritems()函数获得包含索引和值的元组的迭代器：

Series.__iter__(self)    #Return an iterator of the values.
Series.items(self)       #Lazily iterate over (index, value) tuples.
Series.iteritems(self)   #Lazily iterate over (index, value) tuples.
 

5.条件索引

按照条件选择序列的特定行，可以使用序列的loc或iloc属性，并使用布尔索引来筛选序列的数据行

In [39]: 
import numpy as np
import pandas as pd

data=[1,2,3,4]
index=['a','b','c','d']
sd11 = pd.Series(data=data,index=index)
sd11
Out[39]: 
a    1
b    2
c    3
d    4
dtype: int64
In [40]: 
sd11.loc[sd11>2]
Out[40]: 
c    3
d    4
dtype: int64
In [42]: 
sd11.loc[(sd11>1) & (sd11<4)]
Out[42]: 
b    2
c    3
dtype: int64
 
  • 查看序列的逻辑表达式的值
In [43]: 
(sd11>1) & (sd11<4)
Out[43]: 
a    False
b     True
c     True
d    False
dtype: bool
 

6.基本操作

 

6.1.删除元素

根据行标签删除制定的元素

Series.drop(self, labels=None)
In [46]: 
sd12=sd11.drop(labels='a')
sd12
Out[46]: 
b    2
c    3
d    4
dtype: int64
 

6.2.对系列元素执行条件查询

如果系列元素的值不满足cond条件，返回other的值；如果满足，返回元素的值

Series.where(self, cond, other=nan, inplace=False)
In [51]: 
sd13=sd11.where(sd11>2,other='edf')
sd13
Out[51]: 
a    edf
b    edf
c      3
d      4
dtype: object
 

6.3.把系列追加

把to_append系列追加到系列的末尾，设置ignore_index表示忽略原始系列的索引，重新创建一个索引：

Series.append(self, to_append, ignore_index=False, verify_integrity=False)
In [55]: 
sd14 = pd.Series([5,6],index=['e','f'])
sd15=sd11.append(sd14)
sd15
Out[55]: 
a    1
b    2
c    3
d    4
e    5
f    6
dtype: int64
 

6.4.重索引

重索引是指按照新的索引对序列的元素进行重新排列，如果某个索引值不存在，就形成一个空洞，默认情况下，在空洞处插入缺失值：

Series.reindex(self, index=None, **kwargs)

参数**kwargs表示数据不固定的参数，其中有：

  • method：表示插补缺失值的方法，有效值有{None, ‘backfill’/’bfill’, ‘pad’/’ffill’, ‘nearest’}
    1. None 表示插入缺失值nan
    2. ‘backfill’/’bfill’：表示使用空洞之后的最近的有效值来填充
    3. ‘pad’/’ffill’：表示使用空洞之前的最近的有效值来填充
    4. ‘nearest’：表示使用最靠近空洞的有效值来填充
  • fill_value：填充的值，默认值是nan
In [57]: 
sd16 = pd.Series([1,2,3,5,6],index=['a','b','c','e','f'])
sd16
Out[57]: 
a    1
b    2
c    3
e    5
f    6
dtype: int64
In [58]: 
sd16.reindex(index=['a','b','c','d','e','f'],method=None)
Out[58]: 
a    1.0
b    2.0
c    3.0
d    NaN
e    5.0
f    6.0
dtype: float64

更多文章，请关注：
    

标签
python数组
python函数
索引
python
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!