pandas库的引用
pandas是Python第三方库,提供高性能易用数据类型和分析工具
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
两个数据类型: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类型
Series类型的操作类似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和字典,根据索引对齐
Pandas库的DataFrame类型
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 |
DataFrame基本操作类似Series,依据行列索引
Pandas库的数据类型操作
数据类型操作
如何改变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 |
实例:(老师的例子中nd=d.reindex(index=ni,columns=nc,method='ffill',但是我加了这个参数就报错了,报错为索引必须是单调递增或递减的,但是c5~c0本来就是递减的,暂时不知道为怎么解决这个问题)
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指定行或列索引
实例:(可以看出drop()是不改变d的值的)
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 轴