Pandas库入门

Pandas是Python第三方库，提供高性能易用数据类型和分析工具。

Pandas库的引用

import pandas as pd

Pandas基于NumPy实现，常与NumPy和Matplotlib一同使用。

In [1]: import pandas as pd
 
In [2]: d=pd.Series(range(20))
 
In [3]: d
Out[3]:
0      0
1      1
2      2
3      3
4      4
……
17    17
18    18
19    19
dtype: int64
 
In [4]: d.cumsum()
Out[4]:
0       0
1       1
2       3
3       6
……
18    171
19    190
dtype: int64

Pandas中的主要两个数据类型：Series 和 DataFrame 。

基于上述数据类型的各类操作 基本操作、运算操作、特征类操作、关联类操作。

Series 类型由一组数据及与之相关的数据索引组成。

In [5]: b=pd.Series([9,8,7,6],index=['a','b','c','d'])

In [6]: b
Out[6]:
a    9
b    8
c    7
d    6
dtype: int64

Series 类型可以由如下类型创建：

• Python列表
• 标量值
• Python字典
• ndarray
• 其他函数

（1）从标量值创建

In [7]: s=pd.Series(25,index=['a','b','c'])
 
In [8]: s
Out[8]:
a    25
b    25
c    25
dtype: int64

此方法创建时，不能省略index

（2）从字典类型创建

In [9]: d=pd.Series({'a':9,'b':8,'c':7})
 
In [10]: d
Out[10]:
a    9
b    8
c    7
dtype: int64
 
In [11]: e=pd.Series({'a':9,'b':8,'c':7},index=['c','a','b','d'])
 
In [12]: e
Out[12]:
c    7.0
a    9.0
b    8.0
d    NaN
dtype: float64

index 从字典中进行选择操作。

（3）从ndarray类型创建

In [1]: import pandas as pd
 
In [2]: import numpy as np
 
In [3]: n=pd.Series(np.arange(5))
 
In [4]: n
Out[4]:
0    0
1    1
2    2
3    3
4    4
dtype: int32
 
In [5]: m=pd.Series(np.arange(5),index=np.arange(9,4,-1))
 
In [6]: n
Out[6]:
0    0
1    1
2    2
3    3
4    4
dtype: int32

Series类型的创建

Series类型可以由如下类型创建：

• Python列表，index与列表元素个数一致

• 标量值，index表达Series类型的尺寸

• Python字典，键值对中的“键”是索引，index从字典中进行选择操作

• ndarray，索引和数据都可以通过ndarray类型创建

• 其他函数，range()函数等

Series类型的基本操作（1）

Series 类型包括 index 和 values 两部分， Series 类型的操作类似ndarray类型和Python字典类型。

In [7]: b=pd.Series([9,8,7,6],['a','b','c','d'])
 
In [8]: b
Out[8]:
a    9
b    8
c    7
d    6
dtype: int64
 
In [9]: b.index
Out[9]: Index(['a', 'b', 'c', 'd'], dtype='object')
 
In [10]: b.values
Out[10]: array([9, 8, 7, 6], dtype=int64)
 
In [11]: b['b']
Out[11]: 8
 
In [12]: b[1]
Out[12]: 8
 
In [13]: b[['c','d',0]]
Out[13]:
c    7.0
d    6.0
0    NaN
dtype: float64
 
In [14]: b[['c','d','a']]
Out[14]:
c    7
d    6
a    9
dtype: int64

.index 获得索引
.values 获得数据

自动索引和自定义索引并存（注意：两套索引并存，但不能混用）

Series类型的基本操作（2）

Series 类型的操作类似 ndarray 类型：

• 索引方法相同，采用 []

• NumPy中运算和操作可用于 Series 类型

• 可以通过自定义索引的列表进行切片

• 可以通过自动索引进行切片，如果存在自定义索引，则一同被切片

In [16]: b[3]
Out[16]: 6
 
In [17]: b[:3]
Out[17]:
a    9
b    8
c    7
dtype: int64
 
In [18]: b[b>b.median()]
Out[18]:
a    9
b    8
dtype: int64
 
In [19]: np.exp(b)
Out[19]:
a    8103.083928
b    2980.957987
c    1096.633158
d     403.428793
dtype: float64

Series类型的基本操作（3）

Series类型的操作类似Python字典类型：

• 通过自定义索引访问
• 保留字in操作
• 使用.get()方法

In [21]: b['b']
Out[21]: 8
 
In [22]: 'c' in b
Out[22]: True
 
In [23]: 0 in b
Out[23]: False
 
In [24]: b.get('f',100)
Out[24]: 100
 
In [25]: a=pd.Series([1,2,3],['c','d','e'])
 
In [26]: a+b
Out[26]:
a    NaN
b    NaN
c    8.0
d    8.0
e    NaN
dtype: float64

Series类型在运算中会自动对齐不同索引的数据

Series类型的name属性

Series 对象和索引都可以有一个名字，存储在属性 .name 中。

In [27]: b.name
 
In [28]: b.name='Series对象'
 
In [29]: b.index.name='索引列'
 
In [30]: b
Out[30]:
a    9
b    8
c    7
d    6

Name: Series对象, dtype: int64

Series类型的修改

Series对象可以随时修改并即刻生效。

In [32]: b['a']=15
 
In [33]: b.name='Series'
 
In [34]: b
Out[34]:
索引列
a    15
b     8
c     7
d     6
Name: Series, dtype: int64
 
In [35]: b.name="New Series"
 
In [36]: b['b','c']=20
 
In [37]: b
Out[37]:
索引列
a    15
b    20
c    20
d     6
Name: New Series, dtype: int64

Series 是一维带 标签 数组

index_0 →  data_a

Series基本操作类似ndarray和字典，根据索引对齐。

DataFrame类型

DataFrame类型由共用相同索引的一组列组成。

index_0	→	 data_a	 	data_1	 	data_w
index_1	→	data_d	 	data_4	 	data_z
index_2	→	data_c	 	data_3	……	data_y
index_3	→	data_b	 	data_2	 	data_x
索引	 	 	 	多列数据	 

DataFrame是一个表格型的数据类型，每列值类型可以不同，DataFrame既有行索引、也有列索引，DataFrame常用于表达二维数据，但可以表达多维数据。

DataFrame类型可以由如下类型创建：

• 二维ndarray对象
• 由一维ndarray、列表、字典、元组或Series构成的字典
• Series类型
• 其他的DataFrame类型

（1）从二维ndarray对象创建

In [38]: d=pd.DataFrame(np.arange(10).reshape(2,5))
 
In [39]: d
Out[39]:
   0  1  2  3  4
0  0  1  2  3  4
1  5  6  7  8  9

最左侧为自动行索引；最顶端为自动列索引

（2）从一维ndarray对象字典创建

In [40]: dt={'one':pd.Series([1,2,3],index=['a','b','c']),
    ...: 'two':pd.Series([9,8,7,6],index=['a','b','c','d'])}
 
In [41]: d=pd.DataFrame(dt)
 
In [42]: d
Out[42]:
   one  two
a  1.0    9
b  2.0    8
c  3.0    7
d  NaN    6
 
In [43]: pd.DataFrame(dt,index=['b','c','d'],columns=['two','three'])
Out[43]:
   two three
b    8   NaN
c    7   NaN
d    6   NaN

（3）从列表类型的字典创建

In [43]: pd.DataFrame(dt,index=['b','c','d'],columns=['two','three'])
Out[43]:
   two three
b    8   NaN
c    7   NaN
d    6   NaN
 
In [44]: dl={'one':[1,2,3,4],'two':[9,8,7,6]}
 
In [45]: d=pd.DataFrame(dl,index=['a','b','c','d'])
 
In [46]: d
Out[46]:
   one  two
a    1    9
b    2    8
c    3    7
d    4    6

实例题：

In [47]: dl={'城市':['北京','上海','广州','深圳','沈阳'],
    ...: '环比':[101.5,101.5,101.3,102.0,100.1],
    ...: '同比':[120.7,127.3,119.4,140.9,101.4],
    ...: '定基':[121.4,127.8,120.0,145.5,101.6]}
 
In [48]: d=pd.DataFrame(dl,index=['c1','c2','c3','c4','c5'])
 
In [49]: d
Out[49]:
    城市     环比     同比     定基
c1  北京  101.5  120.7  121.4
c2  上海  101.5  127.3  127.8
c3  广州  101.3  119.4  120.0
c4  深圳  102.0  140.9  145.5
c5  沈阳  100.1  101.4  101.6
 
In [50]: d.index
Out[50]: Index(['c1', 'c2', 'c3', 'c4', 'c5'], dtype='object')
 
In [51]: d.columns
Out[51]: Index(['城市', '环比', '同比', '定基'], dtype='object')
 
In [52]: d.values
Out[52]:
array([['北京', 101.5, 120.7, 121.4],
       ['上海', 101.5, 127.3, 127.8],
       ['广州', 101.3, 119.4, 120.0],
       ['深圳', 102.0, 140.9, 145.5],
       ['沈阳', 100.1, 101.4, 101.6]], dtype=object)
 
In [53]: d['同比']
Out[53]:
c1    120.7
c2    127.3
c3    119.4
c4    140.9
c5    101.4
Name: 同比, dtype: float64
 
In [54]: d.ix['c2']
Out[54]:
城市     上海
环比    101.5
同比    127.3
定基    127.8
Name: c2, dtype: object
 
In [55]: d['同比']['c2']
Out[55]: 127.3

DataFrame 是二维带 标签 数组

 	    	column_0	column_1	column_i
index_0	→	data_a	    data_1	    data_w

Pandas库的数据类型操作

DataFrame基本操作类似Series，依据行列索引

如何改变Series和DataFrame对象？

增加或重排：重新索引

删除：drop

重新索引： .reindex()能够改变或重排Series和DataFrame索引

In [2]: import pandas as pd
 
In [3]: dl={'城市':['北京','上海','广州','深圳','沈阳'],
   ...: '环比':[101.5,101.2,101.3,102.0,100.1],
   ...: '同比':[120.7,127.3,119.4,140.9,101.4],
   ...: '定基':[121.4,127.8,120.0,145.5,101.6]}
 
In [4]: d=pd.DataFrame(dl,index=['c1','c2','c3','c4','c5'])
 
In [5]: d
Out[5]:
    城市     环比     同比     定基
c1  北京  101.5  120.7  121.4
c2  上海  101.2  127.3  127.8
c3  广州  101.3  119.4  120.0
c4  深圳  102.0  140.9  145.5
c5  沈阳  100.1  101.4  101.6
 
In [6]: d=d.reindex(index=['c5','c4','c3','c2','c1'])
 
In [7]: d
Out[7]:
    城市     环比     同比     定基
c5  沈阳  100.1  101.4  101.6
c4  深圳  102.0  140.9  145.5
c3  广州  101.3  119.4  120.0
c2  上海  101.2  127.3  127.8
c1  北京  101.5  120.7  121.4
 
In [8]: d=d.reindex(columns=['城市','同比','环比','定基'])
 
In [9]: d
Out[9]:
    城市     同比     环比     定基
c5  沈阳  101.4  100.1  101.6
c4  深圳  140.9  102.0  145.5
c3  广州  119.4  101.3  120.0
c2  上海  127.3  101.2  127.8
c1  北京  120.7  101.5  121.4

.reindex(index=None, columns=None, …) 的参数

参数	说明
index,columns	新的行列自定义索引
fill_value	重新索引中，用于填充缺失位置的值
method	填充方法,ffill当前值向前填充，bfill向后填充
limit	最大填充量
copy	默认True，生成新的对象，False时，新旧相等不复制

In [10]: newc=d.columns.insert(4,'新增')
 
In [11]: newd=d.reindex(columns=newc,fill_value=200)
 
In [12]: newd
Out[12]:
    城市     同比     环比     定基   新增
c5  沈阳  101.4  100.1  101.6  200
c4  深圳  140.9  102.0  145.5  200
c3  广州  119.4  101.3  120.0  200
c2  上海  127.3  101.2  127.8  200
c1  北京  120.7  101.5  121.4  200

索引类型

Series 和 DataFrame 的索引是 Index 类型 Index 对象是不可修改类型

In [13]: d.index
Out[13]: Index(['c5', 'c4', 'c3', 'c2', 'c1'], dtype='object')
 
In [14]: d.columns
Out[14]: Index(['城市', '同比', '环比', '定基'], dtype='object')

索引类型的常用方法

方法	说明
.append(idx)	连接另一个Index对象，产生新的Index对象
.diff(idx)	计算差集，产生新的Index对象
.intersection(idx)	计算交集
.union(idx)	计算并集
.delete(loc)	删除loc位置处的元素
.insert(loc,e)	在loc位置增加一个元素e

In [21]: nc=d.columns.delete(2)
 
In [22]: ni=d.index.insert(5,'c0')
 
In [40]: ni
Out[40]: Index(['c5', 'c4', 'c3', 'c2', 'c1', 'c0'], dtype='object')
 
In [42]: nd
Out[42]:
     城市     同比     定基
c5   沈阳  101.4  101.6
c4   深圳  140.9  145.5
c3   广州  119.4  120.0
c2   上海  127.3  127.8
c1   北京  120.7  121.4
c0  NaN    NaN    NaN

删除指定索引对象

.drop() 能够删除 Series 和 DataFrame 指定行或列索引。

In [45]: a=pd.Series([9,8,7,6],index=['a','b','c','d'])
 
In [46]: a
Out[46]:
a    9
b    8
c    7
d    6
dtype: int64
 
In [47]: a.drop(['b','c'])
Out[47]:
a    9
d    6
dtype: int64
 
In [48]: d
Out[48]:
    城市     同比     环比     定基
c5  沈阳  101.4  100.1  101.6
c4  深圳  140.9  102.0  145.5
c3  广州  119.4  101.3  120.0
c2  上海  127.3  101.2  127.8
c1  北京  120.7  101.5  121.4
 
In [49]: d.drop('c5')
Out[49]:
    城市     同比     环比     定基
c4  深圳  140.9  102.0  145.5
c3  广州  119.4  101.3  120.0
c2  上海  127.3  101.2  127.8
c1  北京  120.7  101.5  121.4
 
In [50]: d.drop('同比',axis=1)
Out[50]:
    城市     环比     定基
c5  沈阳  100.1  101.6
c4  深圳  102.0  145.5
c3  广州  101.3  120.0
c2  上海  101.2  127.8
c1  北京  101.5  121.4

Pandas库的数据类型运算

算术运算法则

算术运算根据行列索引，补齐后运算，运算默认产生浮点数。

补齐时缺项填充NaN (空值 ) 二维和一维、一维和零维间为广播运算。

采用 + ‐ * /符号进行的二元运算产生新的对象。

In [51]: import numpy as np
 
In [52]: a=pd.DataFrame(np.arange(12).reshape(3,4))
 
In [53]: a
Out[53]:
   0  1   2   3
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
 
In [54]: b=pd.DataFrame(np.arange(20).reshape(4,5))
 
In [55]: b
Out[55]:
    0   1   2   3   4
0   0   1   2   3   4
1   5   6   7   8   9
2  10  11  12  13  14
3  15  16  17  18  19
 
In [56]: a+b
Out[56]:
      0     1     2     3   4
0   0.0   2.0   4.0   6.0 NaN
1   9.0  11.0  13.0  15.0 NaN
2  18.0  20.0  22.0  24.0 NaN
3   NaN   NaN   NaN   NaN NaN
 
In [57]: a*b
Out[57]:
      0     1      2      3   4
0   0.0   1.0    4.0    9.0 NaN
1  20.0  30.0   42.0   56.0 NaN
2  80.0  99.0  120.0  143.0 NaN
3   NaN   NaN    NaN    NaN NaN

方法形式的运算

方法	说明
.add(d,**argws)	类型间加法运算，可选参数
.sub(d,**argws)	类型间减法运算，可选参数
.mul(d,**argws)	类型间乘法运算，可选参数
.div(d,**argws)	类型间除法运算，可选参数

In [58]: b.add(a,fill_value=100)
Out[58]:
       0      1      2      3      4
0    0.0    2.0    4.0    6.0  104.0
1    9.0   11.0   13.0   15.0  109.0
2   18.0   20.0   22.0   24.0  114.0
3  115.0  116.0  117.0  118.0  119.0
 
In [59]: a.mul(b,fill_value=0)
Out[59]:
      0     1      2      3    4
0   0.0   1.0    4.0    9.0  0.0
1  20.0  30.0   42.0   56.0  0.0
2  80.0  99.0  120.0  143.0  0.0
3   0.0   0.0    0.0    0.0  0.0
 
In [61]: c=pd.Series(np.arange(4))
 
In [62]: c
Out[62]:
0    0
1    1
2    2
3    3
dtype: int32
 
In [63]: c-10
Out[63]:
0   -10
1    -9
2    -8
3    -7
dtype: int32
 
In [64]: b-c
Out[64]:
      0     1     2     3   4
0   0.0   0.0   0.0   0.0 NaN
1   5.0   5.0   5.0   5.0 NaN
2  10.0  10.0  10.0  10.0 NaN
3  15.0  15.0  15.0  15.0 NaN
 
In [65]: b.sub(c,axis=0)
Out[65]:
    0   1   2   3   4
0   0   1   2   3   4
1   4   5   6   7   8
2   8   9  10  11  12
3  12  13  14  15  16

注意：
1、 fill_value 参数替代 NaN ，替代后参与运算
2、不同维度间为广播运算，一维 Series 默认在轴 1参与运算
3、使用运算方法可以令一维 Series 参与轴 0 运算

比较运算法则

比较运算只能比较相同索引的元素，不进行补齐

二维和一维、一维和零维间为广播运算

采用 > < >= <= == !=等符号进行的二元运算产生布尔对象

In [66]: d=pd.DataFrame(np.arange(12,0,-1).reshape(3,4))
 
In [68]: a<d
Out[68]:
       0      1      2      3
0   True   True   True   True
1   True   True  False  False
2  False  False  False  False
 
In [69]: a>d
Out[69]:
       0      1      2      3
0  False  False  False  False
1  False  False  False   True
2   True   True   True   True
 
In [70]: a==d
Out[70]:
       0      1      2      3
0  False  False  False  False
1  False  False   True  False
2  False  False  False  False
 
In [71]: a>c
Out[71]:
       0      1      2      3
0  False  False  False  False
1   True   True   True   True
2   True   True   True   True
 
In [72]: c>0
Out[72]:
0    False
1     True
2     True
3     True
dtype: bool

注意：
1、同维度运算，尺寸一致
2、不同维度，广播运算，默认在 1 轴