【3】数据分析之概要

单元7：Pandas库入门

Pandas库的介绍

官方网站：http://pandas.pydata.org
Pandas是Python第三方库，提供高性能易用数据类型和分析工具。

import pandas as pd

Pandas基于NumPy实现，常与NumPy和Matplotlib一起使用。
小测：

import pandas as pd

d = pd.Series(range(20))


d

Out[3]: 
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

左侧为索引，右侧为值。
计算前n项和：

d.cumsum()
Out[4]: 
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对比

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

Pandas库的Series类型

由一组数据及其相关的数据索引组成。

import pandas as pd

a = pd.Series([9, 8, 7, 6])

a
Out[3]: 
0    9
1    8
2    7
3    6
dtype: int64

左侧数列为自动索引。数据类型为NumPy中的数据类型。

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

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

此时左侧为自定义索引。

Series类型可由以下数据类型创建：

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

从标量值创建：

s = pd.Series(25, index = ['a', 'b', 'c'])

s
Out[7]: 
a    25
b    25
c    25
dtype: int64

从字典创建：

d = pd.Series({'a':9, 'b':9, 'c':7})

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

如果想要改变形状或索引：

e = pd.Series({'a':9, 'b':9, 'c':7}, index = ['c', 'a', 'b', 'd'])

e
Out[11]: 
c    7.0
a    9.0
b    9.0
d    NaN
dtype: float64

从ndarray类型创建：

import numpy as np

n = pd.Series(np.arange(5))

n
Out[15]: 
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
Out[17]: 
9    0
8    1
7    2
6    3
5    4
dtype: int32

Series类型的基本操作

Series类型包括index和value两部分。

• 类似ndarray类型和Python字典类型

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

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

b.index  ##获取索引
Out[20]: Index(['a', 'b', 'c', 'd'], dtype='object')  ##Index类型

b.values  ##获取数据
Out[21]: array([9, 8, 7, 6], dtype=int64)  ##NumPy的ndarray类型

b['b']  ##自定义索引
Out[22]: 8

b[1]  ##自动索引
Out[23]: 8

b[['c', 'd', 0]]

Out[24]: 
c    7.0
d    6.0
0    NaN  ##两套索引不能混用
dtype: float64

b[['c', 'd', 'a']]
Out[25]: 
c    7
d    6
a    9
dtype: int64

• 索引方法，采用[]
• NumPy中运算和操作可用于Series类型
• 可通过自定义索引的列表进行切片
• 可以通过自动索引进行切片。若存在自定义索引，则一同被切片。

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

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

b[3]  ##索引，得到值
Out[28]: 6

b[:3]  ##切片，得到的是Series类型
Out[29]: 
a    9
b    8
c    7
dtype: int64

b[b > b.median()]  
Out[31]: 
a    9
b    8
dtype: int64

np.exp(b)
Out[32]: 
a    8103.083928
b    2980.957987
c    1096.633158
d     403.428793
dtype: float64

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

b['b']
Out[33]: 8

'c' in b  ##判断b的索引中是否存在'c'
Out[34]: True

0 in b
Out[35]: False

b.get('f', 100)
Out[36]: 100

Series类型对齐操作

Series + Series

a = pd.Series([1, 2, 3], ['c', 'd', 'e'])

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

a + b
Out[40]: 
a    NaN
b    NaN
c    8.0
d    8.0
e    NaN
dtype: float64

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

Series类型的name属性

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

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

b.name

b.name = 'Series对象'

b.index.name = '索引列'

b
Out[45]: 
索引列
a    9
b    8
c    7
d    6
Name: Series对象, dtype: int64

Series类型的修改

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

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

b['a'] = 15

b.name = 'Series'

b
Out[49]: 
a    15
b     8
c     7
d     6
Name: Series, dtype: int64

b.name = 'New Series'

b['b', 'c'] = 20

b
Out[52]: 
a    15
b    20
c    20
d     6
Name: New Series, dtype: int64

Series是一维带“标签”的数组。基本操作类似ndarray和字典，根据索引对齐。

Pandas库的DataFrame类型

由共用相同索引的一组列组成。
是一个表格型数据类型，每列值类型可以不同。
既有行索引（index），也有列索引（column）。
常用于表达二维数据，也可以表达多维数据。

可以由以下类型创建：

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

从二维ndarray对象创建：

import pandas as pd

import numpy as np

d = pd.DataFrame(np.arange(10).reshape(2,5))

d
Out[5]: 
   0  1  2  3  4
0  0  1  2  3  4
1  5  6  7  8  9

生成了自动行索引和自动列索引。

从一维ndarray对象字典创建：

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
Out[8]: 
   one  two
a  1.0    9
b  2.0    8
c  3.0    7
d  NaN    6

d = pd.DataFrame(dt, index = ['b', 'c', 'd'], columns = ['two', 'three'])

d
Out[10]: 
   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
Out[13]: 
   one  two
a    1    9
b    2    8
c    3    7
d    4    6

可以通过[]直接进行索引。

d['one']
Out[14]: 
a    1
b    2
c    3
d    4
Name: one, dtype: int64

d.loc['b']
Out[16]: 
one    2
two    8
Name: b, dtype: int64

d['one']['b']
Out[17]: 2

DataFrame是二维带“标签”数组。
基本操作类似Series，依据行列操作。

Pandas库的数据类型操作

如何改变Series和DataFrame 对象？

重新索引
.reindex()能够改变或重排索引。

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 ]}

d = pd.DataFrame(dl, index = ['c1', 'c2', 'c3', 'c4', 'c5'])

d
Out[22]: 
    城市     环比     同比     定基
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
Out[24]: 
    城市     环比     同比     定基
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
Out[27]: 
    城市     同比     环比     定基
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时，新旧相等不复制

newc = d.columns.insert(4, '新增')

newd = d.reindex(columns = newc, fill_value = 200)

newd
Out[31]: 
    城市     同比     环比     定基   新增
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
Out[32]: Index(['c5', 'c4', 'c3', 'c2', 'c1'], dtype='object')

d.columns
Out[33]: Index(['城市', '同比', '环比', '定基'], dtype='object')

都是Index类型。Index对象是不可修改的类型。
索引的常用方法：

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

删除指定索引对象
.drop()删除指定行或列索引

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

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

a.drop(['b', 'c'])
Out[40]: 
a    9
d    6
dtype: int64

Pandas库的数据类型运算

算数运算法则

根据行列索引，补齐后运算，运算默认产生浮点数。补齐时填充NaN。
二维和一维、一维和零维间为广播运算。
采用+ - * /的二位运算符号会产生新的对象

import pandas as pd

import numpy as np

a = pd.DataFrame(np.arange(12).reshape(3,4))

a
Out[4]: 
   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
Out[6]: 
    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
Out[7]: 
      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
Out[8]: 
      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

方法形式的运算。可以增加一些可选参数

方法	说明
.add(d, **argws)	加法运算
.sum(d, **argws)	减法运算
.mul(d, **argws)	乘法运算
.div(d, **argws)	除法运算

b.add(a, fill_value = 100)  ##a与b之间缺少的部分用100填充，即替代NaN
Out[9]: 
       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)
Out[10]: 
      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

不同维度运算

c = pd.Series(np.arange(4))


c
Out[12]: 
0    0
1    1
2    2
3    3
dtype: int32

c - 10  #广播运算，低维的作用到高维的每一个维度上
Out[14]: 
0   -10
1    -9
2    -8
3    -7
dtype: int32

b - c  #b的每一行与c进行运算。一维默认在1轴（即行）参与运算。
Out[15]: 
      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

b.sub(c, axis = 0)  #规定b的每一列（0轴）与c进行运算
Out[16]: 
    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

比较运算法则

比较运算只能比较相同索引的元素，不进行补齐。
二维和一维、一维和零维间为广播运算
采用> < >= <= == != 等符号进行的二元运算产生布尔对象。

a = pd.DataFrame(np.arange(12).reshape(3,4))

a
Out[18]: 
   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
Out[20]: 
    0   1   2  3
0  12  11  10  9
1   8   7   6  5
2   4   3   2  1

a > d  #同维度运算，尺寸一致
Out[21]: 
       0      1      2      3
0  False  False  False  False
1  False  False  False   True
2   True   True   True   True

a == d
Out[22]: 
       0      1      2      3
0  False  False  False  False
1  False  False   True  False
2  False  False  False  False

不同维度上

a > c  #不同纬度，广播运算，默认为1轴（行）
Out[23]: 
       0      1      2      3
0  False  False  False  False
1   True   True   True   True
2   True   True   True   True

c > 0
Out[24]: 
0    False
1     True
2     True
3     True
dtype: bool

c
Out[25]: 
0    0
1    1
2    2
3    3
dtype: int32

理解数据与索引的关系。数据操作即索引操作。

单元8：Pandas数据特征分析

数据的排序

对一组数据的理解

表达一个或多个含义。
摘要：有损地提取数据特征的过程

• 基本统计（含排序）
• 分布/累计统计
• 数据特征
  相关性、周期性等
• 数据挖掘（形成知识）

Pandas库的数据排序

.sort_index()：在指定轴（默认为0轴，即列）上根据索引进行排序，默认升序
.sort_index(axis = 0, ascending = True)

b = pd.DataFrame(np.arange(20).reshape(4,5), index = ['c', 'a', 'd', 'b'])

b
Out[27]: 
    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()
Out[28]: 
    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)  #改为降序排序
Out[29]: 
    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
Out[31]: 
    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
Out[33]: 
    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轴上某个索引或索引列表

b
Out[34]: 
    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)  #对索引为2的列按数据值进行行降序排序

c
Out[36]: 
    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
Out[38]: 
    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统一放排序末尾

a = pd.DataFrame(np.arange(12).reshape(3,4), index = ['a', 'b', 'c'])

a

Out[40]: 
   0  1   2   3
a  0  1   2   3
b  4  5   6   7
c  8  9  10  11

b
Out[41]: 
    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
Out[43]: 
      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)
Out[44]: 
      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)
Out[45]: 
      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类型
按0轴计算。

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

适用于Series类型

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

基本的统计分析函数

适用于Series和DataFrame类型

方法	说明
.describe()	针对0轴（各列）的统计汇总

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

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

a.describe()  #将一些统计值直接输出
Out[4]: 
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())  #输出结果为Series类型
Out[5]: pandas.core.series.Series

a.describe()['count']  #使用对Series类型索引的方法即可
Out[6]: 4.0

import numpy as np

b = pd.DataFrame(np.arange(20).reshape(4,5), index = ['c', 'a', 'b', 'd'])

b
Out[9]: 
    0   1   2   3   4
c   0   1   2   3   4
a   5   6   7   8   9
b  10  11  12  13  14
d  15  16  17  18  19

b.describe()
Out[10]: 
               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())
Out[11]: pandas.core.frame.DataFrame

b.describe().loc['max']  #获取max行
Out[13]: 
0    15.0
1    16.0
2    17.0
3    18.0
4    19.0
Name: max, dtype: float64

b.describe()[2]  获取第三列
Out[14]: 
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

数据的累计统计分析

对前n个数进行累计运算。减少循环使用

累计统计分析函数

适用于Series和DataFrame类型

说明	方法
.cumsum()	给出前1、2、...、n项的和
.cumprod()	给出前1、2、...、n项的积
.cummax()	给出前1、2、...、n项的最大值
.cummin()	给出前1、2、...、n项的最小值

b
Out[15]: 
    0   1   2   3   4
c   0   1   2   3   4
a   5   6   7   8   9
b  10  11  12  13  14
d  15  16  17  18  19

b.cumsum()  #按照列计算前n项和
Out[16]: 
    0   1   2   3   4
c   0   1   2   3   4
a   5   7   9  11  13
b  15  18  21  24  27
d  30  34  38  42  46

b.cumprod()
Out[17]: 
   0     1     2     3     4
c  0     1     2     3     4
a  0     6    14    24    36
b  0    66   168   312   504
d  0  1056  2856  5616  9576

滚动计算函数（窗口计算函数），适用于Series和DataFrame类型。并不是累计从第一项开始

方法	说明
.rolling(w).sum()	依次计算相邻w个元素的
.rolling(w).mean()	依次计算相邻w个元素的算术平均值
.rolling(w).var()	依次计算相邻w个元素的方差
.rolling(w).std()	依次计算相邻w个元素的标准差
.rolling(w).min() .max()	依次计算相邻w个元素的最小值、最大值

b
Out[18]: 
    0   1   2   3   4
c   0   1   2   3   4
a   5   6   7   8   9
b  10  11  12  13  14
d  15  16  17  18  19

b.rolling(2).sum() #按照列对与前1个元素进行求和
Out[19]: 
      0     1     2     3     4
c   NaN   NaN   NaN   NaN   NaN
a   5.0   7.0   9.0  11.0  13.0
b  15.0  17.0  19.0  21.0  23.0
d  25.0  27.0  29.0  31.0  33.0

b.rolling(3).sum()  #按照列对与前2个元素进行求和
Out[20]: 
      0     1     2     3     4
c   NaN   NaN   NaN   NaN   NaN
a   NaN   NaN   NaN   NaN   NaN
b  15.0  18.0  21.0  24.0  27.0
d  30.0  33.0  36.0  39.0  42.0

数据的相关分析

相关分析

两个事物X和Y，如何判断它们的相关性？

• 正相关
• 负相关
• 不相关

协方差

协方差公式

• 协方差>0，X与Y正相关
• 协方差<0，X与Y负相关
• 协方差=0，X与Y不相关

Pearson相关系数

Pearson相关系数计算公式

取值范围[-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增幅的相关性

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)  #计算相关性
Out[23]: 0.5239439145220387