Pandas

Series结构

Series结构，也称Series序列，是Pandas常用的数据结构之一，它是一种类似于一维数组的结构，由一组数据值（value）和一组标签组成，其中标签与数据值具有对应关系。

标签不必是唯一的，但必须是可哈希类型（即不可变类型，如python中的整形、字符串、数值、浮点）。该对象既支持基于整数的索引，也支持基于标签的索引，并提供许多方法来执行涉及索引的操作。ndarray（数组）的统计方法已被覆盖，并自动排除缺失的数据（目前表示为NaN）

Series可以保存任何数据类型，比如整数、字符串、浮点数、Python对象等，它的标签默认为整数，从0开始依次递增。Series的结构图如下所示：

数据结构Series创建

import pandas as pd  #导入pandas模块

pd.Series(data=None,index=None,dtype=None,name=None,copy=False)

data输入的数据，可以是列表、常量、ndarray数组等，如果是字典，则保持参数顺序

index标签值，必须是可散列的（不可变数据类型（str、bytes和数值类型）），并且与数据具有相同的长度，允许使用非唯一标签值。如果未提供，将默认为RangeIndex（0，1，2，3，...，n）

dtypr输出系列的数据类型，例如原数据为浮点型，可在这改为整型使用。如未指定，将从数据中推断

name为Series定义一个名称

copy表示对data进行拷贝，默认为False，仅影响Series和ndarray数组

1、列表作为数据源创建Series

In [1]: ar_list=[3,10,3,4,5]  #定义一个列表

In [2]: import pandas as pd

In [3]: s1=pd.Series(ar_list)

In [4]: print(s1)  #左边是标签；右边是数据
0     3
1    10
2     3
3     4
4     5
dtype: int64

In [5]: print(type(s1))
<class 'pandas.core.series.Series'>

2、数组作为数据源创建Series

In [10]: import numpy as np

In [11]: np_rand=np.arange(1,6)  #使用numpy模块创建一个数组

In [12]: s1=pd.Series(np_rand)

In [13]: print(s1)
0    1
1    2
2    3
3    4
4    5
dtype: int32

通过index和values属性取得标签和值：

In [14]: s1  #刚刚创建的Series
Out[14]:
0    1
1    2
2    3
3    4
4    5
dtype: int32

In [15]: print(s1.index)  #默认的标签是一个RangeIndex对象，是可迭代类型的
RangeIndex(start=0, stop=5, step=1)

In [36]: print(type(s1.index))
<class 'pandas.core.indexes.range.RangeIndex'>

In [17]: print(list(s1.index))  #获取Series所有标签（可以将其转化为列表展示出来）
[0, 1, 2, 3, 4]

In [18]: print(s1.values)  #获取Series所有值
[1 2 3 4 5]

In [19]: print(type(s1.values))  #数据类型为ndarray
<class 'numpy.ndarray'>

注：numpy中的ndarray为多维数组，是numpy中最为重要也是python进行科学计算非常重要和基本的数据类型。numpy中基本的运算符进行了重载，算数运算符和逻辑运算符都是逐元素操作的，还有广播机制，使得一个标量与多维数组相互运算的时候也是逐元素运算。

通过标签查值、增值、改值：

In [21]: s1  #查看Series内容
Out[21]:
0    1
1    2
2    3
3    4
4    5
dtype: int32

In [22]: s1[1]  #查看标签为1的值是多少
Out[22]: 2

In [23]: s1[-1]=6  #增加一个标签为-1值为6的数据

In [24]: s1
Out[24]:
 0    1
 1    2
 2    3
 3    4
 4    5
-1    6
dtype: int32

In [26]: s1[3]=100  #修改标签3的值为100

In [27]: s1
Out[27]:
 0      1
 1      2
 2      3
 3    100
 4      5
-1      6
dtype: int32

In [28]: s1[9]=10  #增加一个标签为9值为10的数据

In [29]: s1
Out[29]:
 0      1
 1      2
 2      3
 3    100
 4      5
-1      6
 9     10
dtype: int32

In [30]: print(s1.index)  #打印此时的标签
Index([0, 1, 2, 3, 4, -1, 9], dtype='int64')

In [31]: print(type(s1.index))
<class 'pandas.core.indexes.base.Index'>

3、字典作为数据源创建Series

In [36]: d={'a':1,'b':2,'c':3}

In [37]: ser=pd.Series(d)

In [38]: ser
Out[38]:
a    1
b    2
c    3
dtype: int64

通过index和values属性取得标签和值：

In [39]: print(ser.index)
Index(['a', 'b', 'c'], dtype='object')

In [40]: print(ser.values)
[1 2 3]

通过标签查值、增值、改值：

In [41]: ser['a']
Out[41]: 1

In [42]: ser['d']=4

In [43]: ser
Out[43]:
a    1
b    2
c    3
d    4
dtype: int64

In [44]: ser['b']=100

In [45]: ser
Out[45]:
a      1
b    100
c      3
d      4
dtype: int64

4、index参数

使用“显式标签”的方法定义标签：

In [5]: data=['a','b','c','d']

In [6]: s=pd.Series(data,index=[100,101,102,103])

In [7]: s
Out[7]:
100    a
101    b
102    c
103    d
dtype: object

从指定标签的字典构造序列：

In [8]: d={'a':1,'b':2,'c':3}

In [9]: ser=pd.Series(d,index=['a','b','c'])

In [10]: ser1=pd.Series(d)

In [11]: ser
Out[11]:
a    1
b    2
c    3
dtype: int64

In [12]: ser1
Out[12]:
a    1
b    2
c    3
dtype: int64

当传递的标签值未匹配对应的字典key时，使用空NaN填充：

In [13]: d={'a':1,'b':2,'c':3}

In [14]: ser=pd.Series(d,index=['x','b','z'])  #字典中没有x、z两个key

In [15]: ser  #生成的结果中有x、z标签，但值为空
Out[15]:
x    NaN
b    2.0
z    NaN
dtype: float64

 通过匹配的索引值，改变创建Series数据的顺序：

In [16]: d={'a':1,'b':2,'c':3}

In [17]: ser=pd.Series(d,index=['c','b','a'])

In [18]: ser1=pd.Series(d,index=['a','b','c'])

In [19]: ser  #按照定义的index顺序 c b a排列
Out[19]:
c    3
b    2
a    1
dtype: int64

In [20]: ser1  ##按照定义的index顺序 a b c排列
Out[20]:
a    1
b    2
c    3
dtype: int64

5、name参数

我们可以给一个Series对象命名，也可以给一个Series数组中的标签列起一个名字，pandas为我们设计好了对象的属性，并在设置了name属性值用来进行名字的设定。

In [21]: dic_data1={
    ...: 'Beijing':2200,
    ...: 'Shanghai':2500,
    ...: 'Shenzhen':1700
    ...: }

In [22]: data1=pd.Series(dic_data1)

In [23]: data1
Out[23]:
Beijing     2200
Shanghai    2500
Shenzhen    1700
dtype: int64

In [24]: data1.name='City_Data'  #设置Series名字

In [25]: data1.index.name='City_Name'  #设置标签列名

In [26]: data1
Out[26]:
City_Name
Beijing     2200
Shanghai    2500
Shenzhen    1700
Name: City_Data, dtype: int64

序列的名称，如果是DataFrame的一部分，还包括列名，

如果用于形成数据帧，序列的名称将成为其标签或列名，每当使用解释器显示序列时，也会使用它：

In [27]: df=pd.DataFrame(data1)  #使用Series创建DataFrame类型

In [28]: print(df)
           City_Data
City_Name
Beijing         2200
Shanghai        2500
Shenzhen        1700

In [33]: print(df['City_Data'])  #输出City_Data列的数据
City_Name
Beijing     2200
Shanghai    2500
Shenzhen    1700
Name: City_Data, dtype: int64

6、copy参数

copy表示对data进行拷贝，默认False，仅影响Series和ndarray数组

In [34]: import numpy as np

In [35]: np_rand=np.arange(1,6)  #数组作为数据源

In [36]: s1=pd.Series(np_rand)  #使用数组创建Series

In [37]: s1
Out[37]:
0    1
1    2
2    3
3    4
4    5
dtype: int32

In [38]: s1[1]=50  #改变Series标签为1的值

In [39]: s1  #输出Series对象s1
Out[39]:
0     1
1    50
2     3
3     4
4     5
dtype: int32

In [40]: np_rand  #输出数组对象np_rand，发现源数据已被修改为50
Out[40]: array([ 1, 50,  3,  4,  5])

#当源数据非Series和ndarray类型时
In [41]: my_list=[1,2,3,4,5,6]  #列表作为数据源

In [42]: s2=pd.Series(my_list)  #使用列表创建Series

In [43]: s2
Out[43]:
0    1
1    2
2    3
3    4
4    5
5    6
dtype: int64

In [44]: s2[1]=50  #改变Series标签为1的值

In [45]: s2  #输出Series对象s2
Out[45]:
0     1
1    50
2     3
3     4
4     5
5     6
dtype: int64

In [46]: my_list  #输出列表，发现源数据未发生改变
Out[46]: [1, 2, 3, 4, 5, 6]

 Series切片

 Series标签仅切片比较实用，与python基本一致；Series标签的索引与Python不太一样，歧义较多，不常使用

In [53]: s=pd.Series([1,2,3,4,5,'x'],index=('a','b','c','d','e','100'))

In [54]: s
Out[54]:
a      1
b      2
c      3
d      4
e      5
100    x
dtype: object

In [55]: s[1:3]
Out[55]:
b    2
c    3
dtype: object

In [56]: s[:3]
Out[56]:
a    1
b    2
c    3
dtype: object

In [57]: s[-3:]
Out[57]:
d      4
e      5
100    x
dtype: object