数据分析之概要 Pandas库 北京理工大学嵩天老师慕课 学习笔记
Pandas库入门
Pandas库的介绍
Pandas是Python第三方库,提供高性能易用数据类型和分析工具
import pandas as pd
Pandas是基于Numpy实现,常与Numpy和Matplotlib一同使用
Pandas库小测
>>> import pandas as pd
>>> d = pd.Series(range(20))
>>> d
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
10 10
11 11
12 12
13 13
14 14
15 15
16 16
17 17
18 18
19 19
dtype: int64
>>> d.cumsum() # 计算前N项累加和
0 0
1 1
2 3
3 6
4 10
5 15
6 21
7 28
8 36
9 45
10 55
11 66
12 78
13 91
14 105
15 120
16 136
17 153
18 171
19 190
dtype: int64
Pandas库有两个数据类型:Series、DataFrame
基于上述数据类型的各类操作:
基本操作、运算操作、特征类操作、关联类操作。
NumPy:基本数据类型;关注数据的结构表达;维度:数据间关系
Pandas:扩展数据类型;关注数据的应用表达;数据与索引间关系
Pandas库的Series类型
Series类型由一组数据及与之相关的数据索引组成
index_0
→
\to
→ data_a
index_1
→
\to
→ data_b
index_2
→
\to
→ data_c
索引
→
\quad \to
→ 数据
>>> import pandas as pd
>>> a=pd.Series([9,8,7,6])
>>> a
0 9
1 8
2 7
3 6
dtype: int64
>>> b=pd.Series([9,8,7,6],index=['a','b','c','d']) # 可省略index=
>>> b
a 9
b 8
c 7
d 6
dtype: int64
Series类型
Series类型可以由如下类型创建:
- python列表
- 标量值
- python字典
- ndarray
- 其他函数
- 从标量值创建
>>> s=pd.Series(25,index=['a','b','c']) # 不可省略index
>>> s
a 25
b 25
c 25
dtype: int64
- 从字典类型创建
>>> d=pd.Series({'a':9,'b':8,'c':7})
>>> d
a 9
b 8
c 7
dtype: int64
>>> e=pd.Series({'a':9,'b':8,'c':7},index=['c','a','b','d']) # index从字典中进行选择操作
>>> e
c 7.0
a 9.0
b 8.0
d NaN
dtype: float64
- 从ndarray类型创建
>>> import numpy as np
>>> n=pd.Series(np.arange(5))
>>> n
0 0
1 1
2 2
3 3
4 4
dtype: int32
>>> m=pd.Series(np.arange(5),index=np.arange(9,4,-1))
>>> m
9 0
8 1
7 2
6 3
5 4
dtype: int32
Series类型可以由如下类型创建:
- python列表,index与列表元素个数一致
- 标量值,index表达Series类型的尺寸
- python字典,键值对中的“键”是索引,index从字典中进行选择操作
- ndarray,索引与数据都可以通过ndarray类型创建
- 其他函数,
range()
函数等
Series类型的基本操作
Series类型包括index和values两部分
Series类型的操作类似ndarray类型
Series类型的操作类似python字典类型
.index
获得索引
.values
获得数据
>>> import pandas as pd
>>> b=pd.Series([9,8,7,6],['a', 'b','c','d'])
>>> b
a 9
b 8
c 7
d 6
dtype: int64
>>> b.index
Index(['a', 'b', 'c', 'd'], dtype='object')
>>> b.values
array([9, 8, 7, 6], dtype=int64)
自动索引和自定义索引并存
>>> b['b']
8
>>> b[1]
8
两套索引并存,但不能混用,即b[['c','d',0]]
会报错
>>> b[['c','d','a']]
c 7
d 6
a 9
dtype: int64
Series类型的操作类似ndarray类型:
- 索引方法相同,采用[ ]
- numpy中运算和操作可用于Series类型
- 可以通过自定义索引的列表进行切片
- 可以通过自定索引进行切片,如果存在自定义索引,则一同被切片
>>> import pandas as pd
>>> b=pd.Series([9,8,7,6],['a','b','c','d'])
>>> b
a 9
b 8
c 7
d 6
dtype: int64
>>> b[3]
6
>>> b[:3]
a 9
b 8
c 7
dtype: int64
>>> b.median() # 中位数
7.5
>>> b[b>b.median()]
a 9
b 8
dtype: int64
>>> np.exp(b)
a 8103.083928
b 2980.957987
c 1096.633158
d 403.428793
dtype: float64
Series类型的操作类似python字典类型:
- 通过自定义索引访问
- 保留字
in
操作 - 使用
.get()
方法
>>> import pandas as pd
>>> n=pd.Series([9,8,7,6],['a','b','c','d'])
>>> b['b']
8
>>> 'c' in b # 判断是否在索引中
True
>>> 0 in b
False
>>> b.get('f',100) # 提取标签f对应的值,若不存在,则返回100
100
Series类型对齐操作
Series类型在运算中会自动对齐不同索引的数据
>>> import pandas as pd
>>> a=pd.Series([1,2,3],['c','d','e'])
>>> b=pd.Series([9,8,7,6],['a','b','c','d'])
>>> a+b
a NaN
b NaN
c 8.0
d 8.0
e NaN
dtype: float64
Series类型的name属性
Series对象和索引都可以有一个名字,存储在属性.name
中
>>> import pandas as pd
>>> b=pd.Series([9,8,7,6],['a','b','c','d'])
>>> b.name
>>> b.name='Series对象'
>>> b.index.name='索引列'
>>> b
索引列
a 9
b 8
c 7
d 6
Name: Series对象, dtype: int64
Series类型的修改
Series对象可以随时修改并即刻生效
>>> import pandas as pd
>>> b=pd.Series([9,8,7,6],['a','b','c','d'])
>>> b['a']=15
>>> b.name="Series"
>>> b
a 15
b 8
c 7
d 6
Name: Series, dtype: int64
>>> b.name="New Series"
>>> b['b','c']=20
b
a 15
b 20
c 20
d 6
Name: New Series, dtype: int64
Serise是一维带"标签"的数组
Series基本操作类似ndarray和字典,根据索引对齐
Pandas库的DataFrame类型
DataFrame类型由共用相同索引的一组列组成
index_0
→
\to
→ data_a
\quad
data_1
⋯
\quad\cdots\quad
⋯ data_w
index_1
→
\to
→ data_b
\quad
data_2
⋯
\quad\cdots\quad
⋯ data_x
index_2
→
\to
→ data_c
\quad
data_3
⋯
\quad\cdots\quad
⋯ data_y
index_3
→
\to
→ data_d
\quad
data_4
⋯
\quad\cdots\quad
⋯ data_z
索引 → \qquad\to → 多列数据
DataFrame是一个表格型的数据索引,每列值类型可以不同
DataFrame即有行索引index,也有列索引column
DataFrame常用于表达二维数据,但也可以表达多维数据
DataFrame类型可以由如下类型创建:
- 二维ndarray对象
- 由一维ndarray、列表、字典、元组或Series构成的字典
- Series类型
- 其他的DataFrame类型
- 由二维ndarray对象创建
>>> import pandas as pd
>>> import numpy as np
>>> d=pd.DataFrame(np.arange(10).reshape(2,5))
>>> d
0 1 2 3 4
0 0 1 2 3 4
1 5 6 7 8 9
- 由一维ndarray对象字典创建
>>> import pandas as pd
>>> dt={'one':pd.Series([1,2,3],index=['a','b','c']),
'two':pd.Series([9,8,7,6],index=['a','b','c','d'])}
>>> d=pd.DataFrame(dt)
>>> d
one two
a 1.0 9
b 2.0 8
c 3.0 7
d NaN 6
>>> pd.DataFrame(dt,index=['b','c','d'],columns=['two','three']) # 数据根据行列索引自动补齐
two three
b 8 NaN
c 7 NaN
d 6 NaN
- 从列表类型的字典创建
>>> import pandas as pd
>>> dl={'one':[1,2,3,4],'two':[9,8,7,6]}
>>> d=pd.DataFrame(dl,index=['a','b','c','d'])
>>> d
one two
a 1 9
b 2 8
c 3 7
d 4 6
>>> import pandas as pd
>>> dl={'城市':['北京','上海','广州','深圳','沈阳'],
'环比':[101.5,101.2,101.3,102,100.1],
'同比':[120.7,127.3,119.4,140.9,101.4],
'定基':[121.4,127.8,120.0,145.5,101.6]}
>>> d=pd.DataFrame(dl,index=['c1','c2','c3','c4','c5'])
>>> d
城市 环比 同比 定基
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
>>> d.index
Index(['c1', 'c2', 'c3', 'c4', 'c5'], dtype='object')
>>> d.columns
Index(['城市', '环比', '同比', '定基'], dtype='object')
>>> d.values
array([['北京', 101.5, 120.7, 121.4],
['上海', 101.2, 127.3, 127.8],
['广州', 101.3, 119.4, 120.0],
['深圳', 102.0, 140.9, 145.5],
['沈阳', 100.1, 101.4, 101.6]], dtype=object)
>>> d['同比']
c1 120.7
c2 127.3
c3 119.4
c4 140.9
c5 101.4
Name: 同比, dtype: float64
>>> d['同比']['c2']
127.3
DataFrame是二维带“标签”数组
\qquad
\qquad
column_0
\quad
column_1
\quad
column_i
index_0
→
\to
→ data_a
\qquad
data_1
\qquad
data_w
DataFrame基本操作类似Series,依据行列索引
Pandas库的数据类型操作
如何改变Series和DataFrame对象?
增加或重排:重新索引
删除:drop
.reindex()
能够改变或重排Series和DataFrame索引
>>> import pandas as pd
>>> dl={'城市':['北京','上海','广州','深圳','沈阳'],
'环比':[101.5,101.2,101.3,102,100.1],
'同比':[120.7,127.3,119.4,140.9,101.4],
'定基':[121.4,127.8,120.0,145.5,101.6]}
>>> d=pd.DataFrame(dl,index=['c1','c2','c3','c4','c5'])
>>> d
城市 环比 同比 定基
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
>>> d=d.reindex(index=['c5','c4','c3','c2','c1'])
>>> d
城市 环比 同比 定基
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
>>> d=d.reindex(columns=['城市','同比','环比','定基'])
>>> d
城市 同比 环比 定基
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,columes=None,...)
的参数
参数 | 说明 |
---|---|
index ,column | 新的行列自定义索引 |
fill_value | 重新索引中,用于填充缺失位置的值 |
method | 填充方法,ffill 当前值向前填充,bfill 向后填充 |
limit | 最大填充量 |
copy | 默认True,生成新的对象,False时,新旧相等不复制 |
>>> newc=d.columns.insert(4,'新增')
>>> newd=d.reindex(columns=newc,fill_value=200)
>>> newd
城市 同比 环比 定基 新增
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
索引类型
>>> d.index
Index(['c5', 'c4', 'c3', 'c2', 'c1'], dtype='object')
>>> d.columns
Index(['城市', '同比', '环比', '定基'], dtype='object')
Series和DataFrame的索引是Index类型
Index对象是不可修改类型
索引类型的常用方法
方法 | 说明 |
---|---|
.append(idx) | 连接另一个Index对象,产生新的Index对象 |
.diff(idx) | 计算差集,产生新的Index对象 |
.intersection(idx) | 计算交集 |
.union(idx) | 计算并集 |
.delete(loc) | 删除loc位置处的元素 |
.insert(loc,e) | 在loc位置增加一个元素e |
.drop()
能够删除Series和DataFrame指定行或列索引
>>> d
城市 同比 环比 定基
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
>>> d.drop('c5')
城市 同比 环比 定基
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
>>> d.drop('同比',axis=1)
城市 环比 定基
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(空值)
二维和一维、一维和零维间为广播运算(不同维度间运算低维的会作用到高维的每个元素上)
采用+ - * /
符号进行的二元运算产生新的对象
>>> import pandas as pd
>>> import numpy as np
>>> a=pd.DataFrame(np.arange(12).reshape(3,4))
>>> a
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
>>> b=pd.DataFrame(np.arange(20).reshape(4,5))
>>> b
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
>>> a+b
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
>>> a*b
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) | 类型间除法运算,可选参数 |
fill_value参数替代NaN,替代后参与运算
>>> b.add(a,fill_value=100)
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
>>> a.mul(b,fill_value=0)
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
不同维度间为广播运算,一维Series默认在轴1(行)参与运算
>>> c=pd.Series(np.arange(4))
>>> c-10
0 -10
1 -9
2 -8
3 -7
dtype: int32
>>> b-c
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
使用运算方法可以令一维Series参与轴0(列)运算
>>> b.sub(c,axis=0)
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
比较运算法则
比较运算只能比较相同索引的元素,不进行对齐
二维和一维、一维和零维间广播运算
采用< > <= >= == !=
等符号进行的二元运算产生布尔对象
同维度运算,尺寸一致
>>> import pandas as pd
>>> import numpy as np
>>> a=pd.DataFrame(np.arange(12).reshape(3,4))
>>> a
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
>>> d=pd.DataFrame(np.arange(12,0,-1).reshape(3,4))
>>> d
0 1 2 3
0 12 11 10 9
1 8 7 6 5
2 4 3 2 1
>>> a>d
0 1 2 3
0 False False False False
1 False False False True
2 True True True True
>>> a==d
0 1 2 3
0 False False False False
1 False False True False
2 False False False False
不同维度,广播运算,默认在1轴
>>> c=pd.Series(np.arange(4))
>>> a>c
0 1 2 3
0 False False False False
1 True True True True
2 True True True True
>>> c>0
0 False
1 True
2 True
3 True
dtype: bool
Pandas数据特征分析
数据的排序
.sort_index()
方法在指定轴上根据索引进行排序,默认升序
.sort_index(axis=0,ascending=True)
轴0是重新排列 行,轴1是重新排列 列
>>> import pandas as pd
>>> import numpy as np
>>> b=pd.DataFrame(np.arange(20).reshape(4,5),index=['c','a','d','b'])
>>> b
0 1 2 3 4
c 0 1 2 3 4
a 5 6 7 8 9
d 10 11 12 13 14
b 15 16 17 18 19
>>> b.sort_index()
0 1 2 3 4
a 5 6 7 8 9
b 15 16 17 18 19
c 0 1 2 3 4
d 10 11 12 13 14
>>> b.sort_index(ascending=False)
0 1 2 3 4
d 10 11 12 13 14
c 0 1 2 3 4
b 15 16 17 18 19
a 5 6 7 8 9
>>> c=b.sort_index(axis=1,ascending=False)
>>> c
4 3 2 1 0
c 4 3 2 1 0
a 9 8 7 6 5
d 14 13 12 11 10
b 19 18 17 16 15
>>> c=c.sort_index()
>>> c
4 3 2 1 0
a 9 8 7 6 5
b 19 18 17 16 15
c 4 3 2 1 0
d 14 13 12 11 10
.sort_values()
方法在指定轴上根据数值进行排序,默认升序
.Series.sort_values(axis=0,ascending=True)
DataFrame.sort_values(by,axis=0,ascending=True)
by:axis轴上的某个索引或索引列表
>>> import pandas as pd
>>> import numpy as np
>>> b=pd.DataFrame(np.arange(20).reshape(4,5),index=['c','a','d','b'])
>>> b
0 1 2 3 4
c 0 1 2 3 4
a 5 6 7 8 9
d 10 11 12 13 14
b 15 16 17 18 19
>>> c=b.sort_values(2,ascending=False) # 第二列按降序排列
>>> c
0 1 2 3 4
b 15 16 17 18 19
d 10 11 12 13 14
a 5 6 7 8 9
c 0 1 2 3 4
>>> c=c.sort_values('a',axis=1,ascending=False) # 第a行按降序排列
>>> c
4 3 2 1 0
b 19 18 17 16 15
d 14 13 12 11 10
a 9 8 7 6 5
c 4 3 2 1 0
NaN统一放到排序末尾
>>> import pandas as pd
>>> import numpy as np
>>> a=pd.DataFrame(np.arange(12).reshape(3,4),index=['a','b','c'])
>>>a
0 1 2 3
a 0 1 2 3
b 4 5 6 7
c 8 9 10 11
>>> b=pd.DataFrame(np.arange(20).reshape(4,5),index=['c','a','d','b'])
>>> b
0 1 2 3 4
c 0 1 2 3 4
a 5 6 7 8 9
d 10 11 12 13 14
b 15 16 17 18 19
>>> c=a+b
>>> c
0 1 2 3 4
a 5.0 7.0 9.0 11.0 NaN
b 19.0 21.0 23.0 25.0 NaN
c 8.0 10.0 12.0 14.0 NaN
d NaN NaN NaN NaN NaN
>>> c.sort_values(2,ascending=False)
0 1 2 3 4
b 19.0 21.0 23.0 25.0 NaN
c 8.0 10.0 12.0 14.0 NaN
a 5.0 7.0 9.0 11.0 NaN
d NaN NaN NaN NaN NaN
>>> c.sort_values(2,ascending=True)
0 1 2 3 4
a 5.0 7.0 9.0 11.0 NaN
c 8.0 10.0 12.0 14.0 NaN
b 19.0 21.0 23.0 25.0 NaN
d NaN NaN NaN NaN NaN
数据的基本统计分析
适用于Series和DataFrame类型
方法 | 说明 |
---|---|
.sum() | 计算数据的总和,按0轴计算(下同) |
.count() | 非NaN值的数量 |
.mean() .median() | 计算数据的算术平均值、算数中位数 |
.var() .std() | 计算数据的方差、标准差 |
.min() .max() | 计算数据的最小值、最大值 |
适用于Series类型
方法 | 说明 |
---|---|
.argmin() .argmax() | 计算数据最大值、最小值所在位置的索引位置(自动索引) |
.idxmin() .idxmax() | 计算数据最大值、最小值所在位置的索引(自定义索引) |
适用于Series和DataFrame类型
方法 | 说明 |
---|---|
.describe() | 针对0轴(各列)的统计汇总 |
>>> import pandas as pd
>>> a=pd.Series([9,8,7,6],index=['a','b','c','d'])
>>> a
a 9
b 8
c 7
d 6
dtype: int64
>>> a.describe()
count 4.000000
mean 7.500000
std 1.290994
min 6.000000
25% 6.750000
50% 7.500000
75% 8.250000
max 9.000000
dtype: float64
>>> type(a.describe())
<class 'pandas.core.series.Series'>
>>> a.describe()['count']
4.0
>>> a.describe()['max']
9.0
>>> import pandas as pd
>>> import numpy as np
>>> b=pd.DataFrame(np.arange(20).reshape(4,5),index=['c','a','d','b'])
b
0 1 2 3 4
c 0 1 2 3 4
a 5 6 7 8 9
d 10 11 12 13 14
b 15 16 17 18 19
>>> b.describe()
0 1 2 3 4
count 4.000000 4.000000 4.000000 4.000000 4.000000
mean 7.500000 8.500000 9.500000 10.500000 11.500000
std 6.454972 6.454972 6.454972 6.454972 6.454972
min 0.000000 1.000000 2.000000 3.000000 4.000000
25% 3.750000 4.750000 5.750000 6.750000 7.750000
50% 7.500000 8.500000 9.500000 10.500000 11.500000
75% 11.250000 12.250000 13.250000 14.250000 15.250000
max 15.000000 16.000000 17.000000 18.000000 19.000000
>>> type(b.describe())
<class 'pandas.core.frame.DataFrame'>
>>> b.describe()[2]
count 4.000000
mean 9.500000
std 6.454972
min 2.000000
25% 5.750000
50% 9.500000
75% 13.250000
max 17.000000
Name: 2, dtype: float64
数据的累计统计分析
适用于Series和DataFrame类型,累积计算
方法 | 说明 |
---|---|
.cumsum() | 依次给出前1、2、… 、n个数的和 |
.cumprod() | 依次给出前1、2、… 、n个数的积 |
.cummax() | 依次给出前1、2、… 、n个数的最大值 |
.cummin() | 依次给出前1、2、… 、n个数的最小值 |
>>> import pandas as pd
>>> import numpy as np
>>> b=pd.DataFrame(np.arange(20).reshape(4,5),index=['c','a','d','b'])
>>> b
0 1 2 3 4
c 0 1 2 3 4
a 5 6 7 8 9
d 10 11 12 13 14
b 15 16 17 18 19
>>> b.cumsum()
0 1 2 3 4
c 0 1 2 3 4
a 5 7 9 11 13
d 15 18 21 24 27
b 30 34 38 42 46
>>> b.cumprod()
0 1 2 3 4
c 0 1 2 3 4
a 0 6 14 24 36
d 0 66 168 312 504
b 0 1056 2856 5616 9576
>>> b.cummin()
0 1 2 3 4
c 0 1 2 3 4
a 0 1 2 3 4
d 0 1 2 3 4
b 0 1 2 3 4
>>> b.cummax()
0 1 2 3 4
c 0 1 2 3 4
a 5 6 7 8 9
d 10 11 12 13 14
b 15 16 17 18 19
适用于Series和DataFrame类型,滚动计算(窗口计算)
方法 | 说明 |
---|---|
.rolling(w).sum() | 依次计算相邻w个元素的和 |
.rolling(w).mean() | 依次计算相邻w个元素的算术平均值 |
.rolling(w).var() | 依次计算相邻w个元素的方差 |
.rolling(w).std() | 依次计算相邻w个元素的标准差 |
.rolling(w).min() .max() | 依次计算相邻w个元素的最小值和最大值 |
>>> import pandas as pd
>>> import numpy as np
>>> b=pd.DataFrame(np.arange(20).reshape(4,5),index=['c','a','d','b'])
>>> b
0 1 2 3 4
c 0 1 2 3 4
a 5 6 7 8 9
d 10 11 12 13 14
b 15 16 17 18 19
>>> b.rolling(2).sum()
0 1 2 3 4
c NaN NaN NaN NaN NaN
a 5.0 7.0 9.0 11.0 13.0
d 15.0 17.0 19.0 21.0 23.0
b 25.0 27.0 29.0 31.0 33.0
>>> b.rolling(3).sum()
0 1 2 3 4
c NaN NaN NaN NaN NaN
a NaN NaN NaN NaN NaN
d 15.0 18.0 21.0 24.0 27.0
b 30.0 33.0 36.0 39.0 42.0
数据的相关分析
相关性
- x增大,y增大,两个变量正相关
- x增大,y减小,两个变量负相关
- x增大,y无视,两个变量不相关
协方差:
c
o
v
(
X
,
Y
)
=
∑
i
=
1
n
(
X
i
−
X
ˉ
)
(
Y
i
−
Y
ˉ
)
n
−
1
cov(X,Y)=\dfrac{\sum_{i=1}^n(X_i-\bar{X})(Y_i-\bar{Y})}{n-1}
cov(X,Y)=n−1∑i=1n(Xi−Xˉ)(Yi−Yˉ)
- 协方差>0, X和Y正相关
- 协方差<0, X和Y负相关
- 协方差=0, X和Y独立无关
Pearson相关系数:
r = ∑ i = 1 n ( x i − x ˉ ) ( y i − y ˉ ) ∑ i = 1 n ( x i − x ˉ ) 2 ∑ i = 1 n ( y i − y ˉ ) 2 r=\dfrac{\sum_{i=1}^n(x_i-\bar{x})(y_i-\bar{y})}{\sqrt{\sum_{i=1}^n(x_i-\bar{x})^2}\sqrt{\sum_{i=1}^n(y_i-\bar{y})^2}} r=∑i=1n(xi−xˉ)2∑i=1n(yi−yˉ)2∑i=1n(xi−xˉ)(yi−yˉ)
r取值范围[-1,1]
- 0.8–1.0 极强相关
- 0.6–0.8 强相关
- 0.4–0.6 中等程度相关
- 0.2–0.4 弱相关
- 0.0–0.2 极弱相关或无相关
相关分析函数
适用于Series和DataFrame类型
方法 | 说明 |
---|---|
.cov() | 计算协方差矩阵 |
.corr() | 计算相关系数矩阵,Pearson、Spearman、Kendall等系数 |
实例:房价增幅与M2增幅的相关性
>>> import pandas as pd
>>> hprice=pd.Series([3.04,22.93,12.75,22.6,12.33],index=['2008','2009','2010','2011','2012'])
>>> m2=pd.Series([8.18,18.38,9.13,7.82,6.69],index=['2008','2009','2010','2011','2012'])
>>> hprice.corr(m2)
0.5239439145220387
小结
一组数据的摘要:
- 排序
.sort_index()
.sort_values()
- 基本统计函数
.describe()
- 累计统计函数
.cum*()
.rolling().*()
- 相关性分析
.corr()
.cov()