Pandas常用方法

发表于 更新于 分类于
采集自中国慕课的视频教程，数据处理的最后章，前两章是Numpy和Matplotlib

Pandas常用方法

课程地址：Python数据分析与展示

官方文档：快速入门 | Pandas 中文 (pypandas.cn)

前言

搞数据分析处理的。索引很方便。

安装

直连的情况下，直接 pip install pandas可能报错超时，可以

pip --default-time=100 install pandas等久一点,从默认源安装。

也可在操作修改pip镜像为国内源

pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple

如想永久修改镜像地址，需要在当前对用户目录下（C:\Users\用户\pip）创建一个 pip.ini，然后在pip.ini文件中输入以下内容：

1
2
3
4
[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
[install]
trusted-host = pypi.tuna.tsinghua.edu.cn

介绍

Pandas库提供了两个数据类型Serious DataFrame

基于这两个数据类型，Pandas提供 基本操作、运算操作、特征类操作、关联类操作

对比Numpy和Pandas

Numpy Pandas
基础数据类型 扩展数据类型
关注数据的结构表达 关注数据的应用表达
数据与维度间关系 数据与索引间关系

Series类型

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

Serious创建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
>>> import pandas as pd
"""从列表创建"""
>>> pd.Series(range(5)) 
0    0
1    1
2    2
3    3
4    4
dtype: int64 
"""自定义索引，用'a','b','c','d'作为1,2,3,4索引"""
>>> pd.Series([1,2,3,4],['a','b','c','d'])
# [1,2],['a','b','c','d']会报错，也可以写成这样：
>>> pd.Series([1,2,3,4],index=['a','b','c','d'])
a    1
b    2
c    3
d    4
dtype: int64
"""从一个标量做索引"""
>>> pd.Series(4,['a','b','c','d'])
a    4
b    4
c    4
d    4
dtype: int64
"""从字典创建"""
>>> pd.Series({'a':1,'b':2,'c':3,'d':4})
a    1
b    2
c    3
d    4
dtype: int64
"""从字典创建，然后用自定义的索引给series做索引"""
>>> pd.Series({'a':1,'b':2,'c':3,'d':4},index=['d','c','b','a','e'])
d    4.0
c    3.0
b    2.0
a    1.0
e    NaN
dtype: float64 # 是浮点数
"""从ndarray创建"""
>>> import numpy as np
>>> pd.Series(np.arange(5))
0    0
1    1
2    2
3    3
4    4
dtype: int32
"""从ndrange创建，然后用自定义的索引给series做索引"""
>>> pd.Series(np.arange(5),index=np.arange(0,10,2))
0    0
2    1
4    2
6    3
8    4
dtype: int64

Series索引

和字典类似

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
>>> a=pd.Series(np.arange(4),['a','b','c','d'])
"""获取索引"""
>>> a.index
Index(['a', 'b', 'c', 'd'], dtype='object') # 索引存在自建立类型
"""获取数据"""
>>> a.values
array([0, 1, 2, 3])
"""用户自定义索引"""
>>> a['b']
1
"""多个自定义索引并用"""
>>> a[['a','b']]
a    0
b    1
dtype: int32
"""自动索引"""
>>> a[0]
0
"""多个自动索引并用"""
>>> a[[0,1]]
a    0
b    1
dtype: int32
"""用户自定义索引 和 自动索引 不能混用"""
>>> a[[0,'a']]
Traceback (most recent call last):
KeyError: "Passing list-likes to .loc or [] with any missing labels is no longer supported. "
"The following labels were missing: Index([0, 1], dtype='object'). "

Series切片

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

  • NumPy中对ndarray的运算和操作可用于Series类型。

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
>>> a=pd.Series([1,2,3,4],['a','b','c','d'])
"""通过自动索引进行切片"""
>>> a[:4]
a    1
b    2
c    3
d    4
dtype: int64
"""对ndarray的运算和操作可用于Series类型"""
>>> a[a>a.median()]
c    3
d    4
dtype: int64
"""对ndarray的运算和操作可用于Series类型"""
>>> np.exp(a)
a     2.718282
b     7.389056
c    20.085537
d    54.598150
dtype: float64

Series基础方法

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>> a=pd.Series([1,2,3,4],['a','b','c','d'])
"""通过自定义索引访问""" 
>>> a['a']
1
"""保留字in操作"""
>>> 'a' in a  # 'a'是a的索引
True
"""保留字in不判定自动索引"""
>>> 0 in a  # 0不在用户自定义索引中
False
"""使用.get()方法"""
>>> a.get('a',404)  # 从'a'中提取值
1
""".get()方法,如该下标不存在，返回参数"""
>>> a.get('e',4)  # 如果'e'不存在，返回4
4
""".get()方法,下标可以是自动下标""" 
>>> a.get(5,"404")  # 后置参数可以是4:int，也可以是str，o,list
'404'

多个Series对象自动对齐

1
2
3
4
5
6
7
8
9
10
>>> a=pd.Series([1,2,3,4],['a','b','c','d'])
>>> b=pd.Series([3,4,5],['a','y','z'])
>>> a+b
a    4.0  # 4.0=a['a']+b['a']=1+3
b    NaN  # NaN=a['b']+b['b']=1+NaN
c    NaN
d    NaN
y    NaN
z    NaN
dtype: float64

name属性

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

Series对象属性可以即刻修改

1
2
3
4
5
6
7
8
9
10
>>> a=pd.Series([1,2,3,4],['a','b','c','d'])
>>> a.name="Series a"
>>> a['a']=11
>>> a['b','c']=22
>>> a
a    11
b    22
c    22
d     4
Name: Series a, dtype: int64

DateFrame类型

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

DataFrame是一个表格型的数据类型，每列值类型可以不同。

DataFrame既有行索引、也有列索引。

DataFrame常用于表达二维数据，也可以表达多维数据。

DateFrame创建

由一维ndarray对象创建，由二维ndarray对象创建，由列表、字典、元组创建，由Series字典创建，由其他的DataFrame类型创建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
>>> import pandas as pd
>>> import numpy as np
"""由一维ndarray创建"""
>>> d=pd.DataFrame(np.arange(10).reshape(2,5))
>>> d
   0  1  2  3  4 	# 0 1 2 3 4表示自动索引
0  0  1  2  3  4
1  5  6  7  8  9
"""由一维ndarray对象字典创建"""
# 创建一维ndarray对象字典
>>> dt={'one' : pd.Series([1,2,3],index=['a','b','c']),
        'two' : pd.Series([9,8,7,6],index=['a','b','c','d'])}                                              
>>> dt                                                                      
{'one': a    1                                                              
        b    2                                                                      
        c    3                                                                      
	dtype: int64, 
 'two': a    9                                                 
        b    8                                                                      
        c    7                                                                      
        d    6                                                                      
	dtype: int64}    
# 创建DataFrame对象
>>> d=pd.DataFrame(dt)  
>>> d                   
   one  two             
a  1.0    9             
b  2.0    8             
c  3.0    7             
d  NaN    6   # 缺少的值为NAN
"""对DataFrame对象表进行拖动,自动补齐"""
>>> pd.DataFrame(dt,index=['b','c','d'],columns=['two','three'])
   two three 
b    8   NaN
c    7   NaN
d    6   NaN
"""由列表类型的字典创建"""
>>> 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

DateFrame索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
"""由列表类型的字典创建DataFrame对象"""
>>> 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
"""列th"""
>>> d.columns 
Index(['one', 'two'], dtype='object')
"""行th"""
>>> d.index 
Index(['a', 'b', 'c', 'd'], dtype='object')
"""去掉表格的列和行,查看数据内容"""
>>> d.values 
array([[1, 9],
       [2, 8],
       [3, 7],
       [4, 6]], dtype=int64)
"""查看单独一列"""
>>> d['one']
a    1
b    2
c    3
d    4
Name: one, dtype: int64
"""查看单独一行"""
>>> d.loc['a']
one    1
two    9
Name: a, dtype: int64
"""查看具体一个数据"""
>>> d['one']['a']
1
>>> d.loc['a']['one']
1
>>> d['one'].a
1
>>> d.loc['a'].one
1

改变Series和DataFrame值

重新索引

.reindex()可改变或者重排Series和DataFrame索引

但是索引的Index对象不可修改类型

详细方法.reindex(index,columns,...)：

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

特别的，当重新索引时，fill_value用于填充缺失位置的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
"""由列表类型的字典创建"""
>>> 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
"""reindex重排行索引index"""
>>> d=d.reindex(index=['d','c','b','a'])
>>> d
   one  two
d    4    6
c    3    7
b    2    8
a    1    9
"""reindex重排列索引columns"""
>>> d=d.reindex(columns=['two','one'])
>>> d
   two  one
a    9    1
b    8    2
c    7    3
d    6    4
"""reindex只能重排，不能重命名"""
>>> d=d.reindex(index=['A','B','C','D'])
>>> d
   one  two
A  NaN  NaN
B  NaN  NaN
C  NaN  NaN
D  NaN  NaN
"""reindex排错了 不可恢复"""
>>> d=d.reindex(index=['a','b','c','d'])
>>> d
   one  two
a  NaN  NaN
b  NaN  NaN
c  NaN  NaN
d  NaN  NaN
"""初始化d"""
>>> d=pd.DataFrame(dl,index=['a','b','c','d'])
"""插入新列，200填充"""
>>> new_d=d.columns.insert(2,'new')
>>> new_d
Index(['two', 'one', 'new'], dtype='object')
>>> newd=d.reindex(columns=new_d,fill_value=200)
>>> newd
   two  one  new
a    9    1  200
b    8    2  200
c    7    3  200
d    6    4  200

按照索引修改数据

方法 说明
.append(index) 连接另一个Inedx对象，产生新的Index对象
.diff(index) 计算差集，产生新的Index对象
.intersection(index) 计算交际
.union(index) 计算并集
.delete(loc) 删除loc位置处的元素，loc只能是int下标
.insert(loc,e) 在loc位置处增加一个元素e
.drop(index) 删除指定行或列 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
"""由列表类型的字典创建"""
>>> 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
"""根据索引修改数据"""
>>> dc=d.columns.delete(0)	# 删除one列
>>> di=d.index.insert(4,'e')	# 在4的位置(d的下边)插入e
>>> d_new=d.reindex(index=di,columns=dc,method='ffill')
>>> d_new
   one
a    1
b    2
c    3
d    4
e    4
"""删除指定行"""
>>> d_new=d_new.drop(['e'])
>>> d_new
   one
a    1
b    2
c    3
d    4
"""删除指定列"""
>>> d.drop('two',axis=1)   # Series只有0轴，DataFrame有1轴
   one                             
a    1                             
b    2                             
c    3                             
d    4

数据四则运算

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

补齐时缺项填充NaN（空值）

二维和一维、一维和零维间(标量)为广播运算(类似矩阵乘标量)

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

方法 说明
.add(d,**argws) 类型间加法运算，可选参数
.sub(d,**argws) 类型间减法运算，可选参数
.mul(d,**argws) 类型间乘法运算，可选参数
.div(d,**argws) 类型间除法运算，可选参数 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
>>> import pandas as pd
>>> import numpy as np
>>> a=pd.DataFrame(np.arange(12).reshape(3,4))
>>> b=pd.DataFrame(np.arange(20).reshape(4,5))
>>> a
   0  1   2   3
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
>>> 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
# 使用add(DataFrame,fill_value)方法,不存在的值按fill_value填充
>>> 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*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
# 使用mul(DataFrame,fill_value)方法,不存在的值按fill_value填充
>>> b.mul(a,fill_value=100)
        0       1       2       3       4
0     0.0     1.0     4.0     9.0   400.0
1    20.0    30.0    42.0    56.0   900.0
2    80.0    99.0   120.0   143.0  1400.0
3  1500.0  1600.0  1700.0  1800.0  1900.0
"""广播减法"""
>>> a-100
     0   1   2   3
0 -100 -99 -98 -97
1  -96 -95 -94 -93
2  -92 -91 -90 -89
"""行列减法"""
>>> c=pd.Series(np.arange(3))
>>> c
0    0
1    1
2    2
dtype: int32
>>> a.sub(c,axis=0)
   0  1  2  3
0  0  1  2  3
1  3  4  5  6
2  6  7  8  9    
"""同维度比较运算"""
>>> c=pd.DataFrame(np.arange(4).reshape(2,2))
>>> d=pd.DataFrame(np.arange(1,5).reshape(2,2))
>>> c>d
       0      1
0  False  False
1  False  False
"""二维与标量广播比较运算"""
>>> c>0
       0     1
0  False  True
1   True  True
"""二维与一维比较运算"""
>>> e=pd.Series(np.arange(4)) # 默认在1轴
>>> a==e
       0      1      2      3
0   True   True   True   True
1  False  False  False  False
2  False  False  False  False
"""不同二维的比较运算"""
>>> a>c
Traceback (most recent call last):
ValueError: Can only compare identically-labeled DataFrame objects

数据排序

横轴axis=0，纵轴axis=1

按照索引的排序

.sort_index()在指定轴上根据索引进行排序，默认升序ascending=True

.sort_index(axis=0,ascending=True)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
>>> 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_index()
>>> c
    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=c.sort_index(axis=1,ascending=False)
>>> b
    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()在指定轴上根据数值进行排序，默认升序ascending=True

Series.sort_values(axis=0,ascending=True)

DataFrame.sort_values(by,axis=0,ascending=True)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
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	# 17
d  10  11  12  13  14	# 12 
a   5   6   7   8   9	# 7 
c   0   1   2   3   4	# 2
"""按照某一行的值进行排序"""
>>> c=c.sort_values('a',axis=1,ascending=False)
>>> c
    4   3   2   1   0	# 参与排序的一行是
b  19  18  17  16  15
d  14  13  12  11  10
a   9   8   7   6   5	# 9 8 7 6 5
c   4   3   2   1   0
"""NaN统一放到排序未尾"""
>>> a=pd.DataFrame(np.zeros((4,4),dtype=int),index=['c','a','d','b'])
>>> a
   0  1  2  3
c  0  0  0  0
a  0  0  0  0
d  0  0  0  0
b  0  0  0  0
>>> c=a+b
>>> c
    0   1   2   3   4
c   0   1   2   3 NaN
a   5   6   7   8 NaN
d  10  11  12  13 NaN
b  15  16  17  18 NaN
>>> c.sort_values('a',axis=1,ascending=False)
    3   2   1   0   4	# 参与排序的一行是
c   3   2   1   0 NaN
a   8   7   6   5 NaN
d  13  12  11  10 NaN	# 13 12 11 10
b  18  17  16  15 NaN

数据统计分析

基本统计分析函数

适用于Series和DataFrame类型

方法 说明
.sum() 计算数据的总和，按0轴计算，下同
.count() 非NaN值的数量
.mean() .median() 计算数据的算水平均值、算术中位数
.var() .std() 计算数据的方差、标准差
.min() .max() 计算数据的最小值、最大值

适用于Series类型

方法 说明
.argmin() .argmax() 计算数据最大值、最小值所在位置的索引位置（自动索引）
.idxmin() .idxmax() 计算数据最大值、最小值所在位置的索引（自定义索引）

适用于Series和DataFrame类型

方法 说明
.describe() 针对0轴（各列）的统计汇总 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
>>> import pandas as pd
"""Series类型"""
>>> 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
"""DataFrame类型"""
>>> b=pd.DataFrame(np.arange(8).reshape(4,2),index=['c','a','d','b'])
>>> b
   0  1
c  0  1
a  2  3
d  4  5
b  6  7
"""查看所有信息"""
>>> b.describe()
              0         1
count  4.000000  4.000000
mean   3.000000  4.000000
std    2.581989  2.581989
min    0.000000  1.000000
25%    1.500000  2.500000
50%    3.000000  4.000000
75%    4.500000  5.500000
max    6.000000  7.000000
"""查看部分信息""" 
>>> type(b)
<class 'pandas.core.frame.DataFrame'>
"""查看一行"""
>>> b.describe().loc['count']
0    4.0
1    4.0
Name: count, dtype: float64
"""查看一列"""
>>> b.describe()[0]
count    4.000000
mean     3.000000
std      2.581989
min      0.000000
25%      1.500000
50%      3.000000
75%      4.500000
max      6.000000
Name: 0, dtype: float64

累计统计分析函数

适用于Series和DataFrame类型，累加计算

方法 说明
.cumsum() 依次给出前1、2、…、n个数的和
.cumprod() 依次给出前1、2、…、n个数的积
.cummax() 依次给出前1、2、…、n个数的最大值
.cummin() 依次给出前1、2、…、n个数的最小值 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
>>> a=pd.DataFrame(np.arange(16).reshape(4,4),index=['c','a','d','b'])
>>> a
    0   1   2   3
c   0   1   2   3
a   4   5   6   7
d   8   9  10  11
b  12  13  14  15
"""依次给出前1、2、…、n个数的和"""
>>> a.cumsum()
    0   1   2   3
c   0   1   2   3
a   4   6   8  10 # 4=0+4 6=1+5 8=6+2 10=3+7
d  12  15  18  21 # 12=4+8 15=6+9 8=8+10 21=10+11
b  24  28  32  36
"""依次给出前1、2、...、n个数的积"""
>>> a.cumprod()
   0    1     2     3
c  0    1     2     3
a  0    5    12    21 # 0=0*0 5=5*1
d  0   45   120   231 # 0=0*0 45=5*9
b  0  585  1680  3465
"""依次给出前1、2、...、n个数的最大值"""
>>> a.cummax()
    0   1   2   3
c   0   1   2   3
a   4   5   6   7
d   8   9  10  11
b  12  13  14  15
"""依次给出前1、2、...、n个数的最小值"""
>>> a.cummin()
   0  1  2  3
c  0  1  2  3
a  0  1  2  3
d  0  1  2  3
b  0  1  2  3

适用于Series和DataFrame类型，相邻计算

方法 说明
.rolling(w).sum() 依次计算相邻w个元素的和
.rolling(w).mean() 依次计算相邻w个元素的算术平均值
.rolling(w).var() 依次计算相邻w个元素的方差
.rolling(w).std() 依次计算相邻w个元素的标准差
.rolling(w).min().max() 依次计算相邻w个元素的最小值和最大值 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
>>> b=pd.DataFrame(np.arange(16).reshape(4,4),index=['c','a','b','d'])
>>> b
    0   1   2   3
c   0   1   2   3
a   4   5   6   7
b   8   9  10  11
d  12  13  14  15
"""依次计算相邻2个行元素的和"""
>>> b.rolling(2).sum()
      0     1     2     3
c   NaN   NaN   NaN   NaN # NaN=0+NaN
a   4.0   6.0   8.0  10.0 # 4.0=0+4
b  12.0  14.0  16.0  18.0 # 12.0=4.0+8.0
d  20.0  22.0  24.0  26.0
"""依次计算相邻3个行元素的和"""
>>> b.rolling(3).sum()
      0     1     2     3
c   NaN   NaN   NaN   NaN
a   NaN   NaN   NaN   NaN
b  12.0  15.0  18.0  21.0
d  24.0  27.0  30.0  33.0
"""依次计算相邻3个列元素的和"""
>>> b.rolling(3,axis=1).sum()
    0   1     2     3
c NaN NaN   3.0   6.0
a NaN NaN  15.0  18.0
b NaN NaN  27.0  30.0
d NaN NaN  39.0  42.0

数据相关分析

X与Y两个值：

  • X增大，Y增大，两个变量正相关。

  • X增大，Y减小，两个变量负相关。

协方差
$$
cov(X,Y)=\frac
{\sum_{i=1}^n(X_i-\overline X)(Y_i-\overline Y)}
{n-1}
$$

  • 协方差>0，X和Y正相关

  • 协方差<0，X和Y负相关

  • 协方差=0，X和Y无关

Pearson相关系数
$$
r=\frac
{\sum_{r=1}^n(x_i-\overline x)(y_i-\overline y)}
{\sqrt{\sum_{i=1}^n(x_i-\overline x)^2}\sqrt{\sum_{i=1}^n(x_i-\overline x)^2}}
$$
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等系数 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>> 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
2008     3.04
2009    22.93
2010    12.75
2011    22.60
2012    12.33
dtype: float64
>>> m2
2008     8.18
2009    18.38
2010     9.13
2011     7.82
2012     6.69
dtype: float64
"""计算相关系数矩阵,r"""
>>> hprice.corr(m2)
0.5239439145220387