数据分析——Numpy

一、简介

部分内容引用菜鸟教程，毕竟比较全面

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

NumPy 的前身 Numeric 最早是由 Jim Hugunin 与其它协作者共同开发，2005 年，Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色，并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。

NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：

1. 一个强大的N维数组对象 ndarray
2. 广播功能函数
3. 整合 C/C++/Fortran 代码的工具
4. 线性代数、傅里叶变换、随机数生成等功能

二、Numpy ndarray 对象

ndarray对象用于存放同类型元素的多维数组。
ndarray中的每个元素在内存中都有相同的储存大小的区域。

ndarray内部由以下内容组成：

1. 一个指向数据的指针（内存或内存映射文件中的一块数据）的指针。
2. 数据类型或dtype，描述在数组中的固定大小值的格子。
3. 一个表示数组（shape）形状的元组，表示各维度大小的元组。
4. 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要“跨过”的字节数。

创建一个ndarray只需调用Numpy的array函数即可：

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

object 数组或嵌套的数列
dtype 数组元素的数据类型，可选
copy 对象是否需要复制，可选
order 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok 默认返回一个与基类类型一致的数组
ndmin 指定生成数组的最小维度

# 1). 创建数组: a, b, c创建的数组相同， 任选一种;
a = np.array([1, 2, 3, 4, 5])
b = np.array(range(1, 6))
c = np.arange(1, 6)

print(a, b, c)
#
# # 2). 查看numpy创建的数组类型
print(type(a))
print(type(b))
print(type(c))

#
# 3). 查看数组存储的数据类型, 常见的数据类型还有哪些?
print(a.dtype)   # 为什么是int64？ 因为硬件架构是64位;


# 4). 制定创建的数组的数据类型
d = np.array([1.9, 0, 1.3, 0], dtype=float)
print(d, d.dtype)
#
# 5). 修改数组的数据类型
e = d.astype('int64')   # 里面可以是数据类型， 也可以是数据代码;int64---i1
print(e, e.dtype)

# 6). 修改浮点数的小数点位数
# 随机创建一个三行四列的数组;
f = np.random.random((3, 4))
print(f)

# 修改浮点书的小数位数为3位
g = np.round(f, 3)
print(g)

三、Numpy数据类型

numpy支持的数据类型比Python内置的类型要多很多

bool_ 布尔型数据类型（True 或者 False）
int_ 默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
intc 与 C 的 int 类型一样，一般是 int32 或 int 64
intp 用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
int8 字节（-128 to 127）
int16 整数（-32768 to 32767）
int32 整数（-2147483648 to 2147483647）
int64 整数（-9223372036854775808 to 9223372036854775807）
uint8 无符号整数（0 to 255）
uint16 无符号整数（0 to 65535）
uint32 无符号整数（0 to 4294967295）
uint64 无符号整数（0 to 18446744073709551615）
float_ float64 类型的简写
float16 半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32 单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64 双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_ complex128 类型的简写，即 128 位复数
complex64 复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128 复数，表示双 64 位浮点数（实数部分和虚数部分）

四、Numpy数组属性

Numpy数组的维数称为秩（rank），一维数组的秩为 1，二维数组的秩为 2，以此类推

在Numpy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。
很多时候可以声明 axis。
axis=0，（相当于列）表示沿着第 0 轴进行操作，即对每一列进行操作；
axis=1，（相当于行）表示沿着第1轴进行操作，即对每一行进行操作。

ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape’	数组的维度，对于矩阵，n 行 m 列
ndarray.size	数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype	ndarray 对象的元素类型
ndarray.itemsize	ndarray 对象中每个元素的大小，以字节为单位
ndarray.flags	ndarray 对象的内存信息
ndarray.real	ndarray元素的实部
ndarray.imag	ndarray 元素的虚部
ndarray.data	包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

五、Numpy创建数组

【1】np.empty

用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：

numpy.empty(shape, dtype = float, order = 'C')

shape 数组形状
dtype 数据类型，可选
order 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

配置文件案例
>>> np.empty([2, 2])
        array([[ -9.74499359e+001,   6.69583040e-309],
               [  2.13182611e-314,   3.06959433e-309]])         #random
    
        >>> np.empty([2, 2], dtype=int)
        array([[-1073741821, -1067949133],
               [  496041986,    19249760]])                     #random

【2】np.zeros and np.ones

 >>> np.zeros(5)
        array([ 0.,  0.,  0.,  0.,  0.])
    
        >>> np.zeros((5,), dtype=int)
        array([0, 0, 0, 0, 0])
    
        >>> np.zeros((2, 1))
        array([[ 0.],
               [ 0.]])
    
        >>> s = (2,2)
        >>> np.zeros(s)
        array([[ 0.,  0.],
               [ 0.,  0.]])
    
        >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
        array([(0, 0), (0, 0)],
              dtype=[('x', '<i4'), ('y', '<i4')])
    """

>>> np.ones(5)
    array([ 1.,  1.,  1.,  1.,  1.])

    >>> np.ones((5,), dtype=int)
    array([1, 1, 1, 1, 1])

    >>> np.ones((2, 1))
    array([[ 1.],
           [ 1.]])

    >>> s = (2,2)
    >>> np.ones(s)
    array([[ 1.,  1.],
           [ 1.,  1.]])

【3】np.asarray

np.asarray与np.array类似

numpy.asarray(a, dtype = None, order = None)
#a	任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组

【4】np.frombuffer

numpy.frombuffer 用于实现动态数组。
numpy.frombuffer 接受buffer输入的参数，以流的形式读入转化成ndarray对象。

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)

**注意：**buffer是字符串的时候，python3默认str是Unicode类型，所以要转成bytestring在原str前加上b。

buffer	可以是任意对象，会以流的形式读入。
dtype	返回数组的数据类型，可选
count	读取的数据数量，默认为-1，读取所有数据。
offset	读取的起始位置，默认为0。

h = b"hello world"
h1 =np.frombuffer(h,dtype='S1',count=5, offset=6)
print(h1)

【5】np.fromiter

numpy.fromiter方法从可迭代对象中建立ndarray对象，返回一维数组。

numpy.fromiter(iterable, dtype, count=-1)
	iterable	可迭代对象
	dtype	返回数组的数据类型
	count	读取的数据数量，默认为-1，读取所有数据

list=range(7)
it =iter(list)
s =np.fromiter(it,dtype=float,)

s1 =np.array(range(7))

iterable = (x*x for x in range(7))
s2 =np.fromiter(iterable,dtype=float)
print(s,s1,s2)

【6】np.linspace

numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

【7】np.logspace

numpy.logspace 函数用于创建一个于等比数列

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

start 序列的起始值为：base ** start
stop 序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中
num 要生成的等步长的样本数量，默认为50
endpoint 该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。
base 对数 log 的底数。
dtype ndarray 的数据类型

六、numpy切片和索引

【1】索引

import numpy as np
a = np.arange(12).reshape((3, 4))

print(a)

# *****************取单行或者单列*********************
# 取第2行;
print(a[1])
# 取第3列;
print(a[:, 2])
# 获取第2行3列的数据
print(a[1, 2])



# *****************取连续行或者列*********************
# 取第2行和第3行;
print(a[1:3])

# 取第3列和第4列
print(a[:, 2:4])

# 行： 1和2   列: 2
print(a[0:2, 1:2])



# *****************取不连续的行或者列*********************
# 行： 1和3   列: all 获取第一行和第三行的所有元素
print(a[[0, 2], :])
# 行: all   列: 1, 4
print(a[:, [0, 3]])
# 行： 1 , 3   列： 1 4  获取第一行第一列的元素， 和第三行第4列的元素
print("*"*10)
print(a[[0, 2], [0, 3]])

【2】花式索引

花式索引
花式索引指的是利用整数数组进行索引。

花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素；
如果目标是二维数组，那么就是对应下标的行。

花式索引跟切片不一样，它总是将数据复制到新数组中。

"""

"""

import numpy as np
# 传入顺序索引数组
x = np.arange(32).reshape((8, 4))
print(x)
print(x[[4, 2, 1, 7]])

# 传入倒序索引数组
x=np.arange(32).reshape((8,4))
print (x[[-4,-2,-1,-7]])

【3】np.ix_

# 传入多个索引数组（要使用np.ix_）
"""
原理：np.ix_函数就是输入两个数组，产生笛卡尔积的映射关系
将数组[1,5,7,2]和数组[0,3,1,2]产生笛卡尔积，就是得到
(1,0)，(1,3)，(1,1)，(1,2)；(5,0)，(5,3)，(5,1)，(5,2)；(7,0)，(7,3)，(7,1)，(7,2)；(2,0)，(2,3)，(2,1)，(2,2)；
"""
x=np.arange(32).reshape((8,4))
print(x)
print (x[np.ix_([1,5,7,2],[0,3,1,2])])

a=[1,2,3]
b=[4,5,6]
c=(a,b)
print(np.ix_(a,b))
#一次传入多个索引数组会有一点特别。他返回的是一个一维数组，其中元素对应各个索引元组
#---2.2
print ("初始化一个数组")
arr = np.arange(32).reshape(8,4)
print (arr)
print ("多个索引数组")
print (arr[[1,5,7,2],[0,3,1,2]])#返回一个数组最终的元素（1,0）、（5,3）、（7、1）、（2、2）
#如果要得到矩形区域的话，可以这样
print ("得到矩形区域")
print (arr[[1,5,7,2]][:,[0,3,1,2]])
#另一种利用np.ix函数，他可以将两个一维的整数数组转化为方形区域的索引器
print (arr[np.ix_([1,5,7,2],[0,3,1,2])])
#!!! 花式索引跟切片不一样，总是将数据复制到新的数组中

【4】高级索引

（1）整数数组索引
获取数组中的四个角的元素

import numpy as np


def get_edge(data):
    """获取了数组中的四个角的元素"""
    row, column = data.shape
    rows = np.array([[0, 0], [row - 1, row - 1]])
    cols = np.array([[0, column - 1], [0, column - 1]])
    return  data[rows, cols]



if __name__ == '__main__':
    x = np.arange(30).reshape((5, 6))
    print("data：", x)
    print("result: ", get_edge(x))

（2）布尔索引
我们可以通过一个布尔数组来索引目标数组

import numpy as np

# 执行行和指定列的修改
t = np.arange(24).reshape((4, 6))
print(t)
#行： all, 列: 3,4
t[:, 2:4] = 0
print(t)

# 布尔索引
print(t < 10)
#
t[t < 10] = 100
print(t)

t[t > 20] = 200
print(t)


# numpy的三元运算符 t<100?0:10
t1  = np.where(t < 100, 0, 10)
print(t)
print(t1)

七、numpy 广播（Broadcast）

广播（Broadcast）是numpy对不同形状（shape）的数组进行数值计算的方式，对数组的算术运算通常在相应的元素上进行。
如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。

#维度相同
import numpy as np 
a = np.array([1,2,3,4]) 
b = np.array([10,20,30,40]) 
c = a * b 
print (c)

当维度不同时，python将自动触发广播机制。

import numpy as np 
 
a = np.array([[ 0, 0, 0],
           [10,10,10],
           [20,20,20],
           [30,30,30]])
b = np.array([1,2,3])
print(a + b)

广播的规则：

• 让所有输入数组都想其中形状最长的数组看齐，形状不足的部分都通过在前面加1补齐
• 输出数组的形状是输入数组形状的各个维度上的最大值。
• 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
• 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。

八、Numpy数组操作

【1】修改数组的形状

reshape 不改变数据的条件下修改形状
flat 数组元素迭代器
flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
ravel 返回展开数组

【2】翻转数组

transpose 对换数组的维度
ndarray.T 和 self.transpose() 相同
rollaxis 向后滚动指定的轴
swapaxes 对换数组的两个轴

【3】修改数组维度

broadcast 产生模仿广播的对象
broadcast_to 将数组广播到新形状
expand_dims 扩展数组的形状
squeeze 从数组的形状中删除一维条目

【4】连接数组

concatenate 连接沿现有轴的数组序列
stack 沿着新的轴加入一系列数组。
hstack 水平堆叠序列中的数组（列方向）
vstack 竖直堆叠序列中的数组（行方向）

【5】分割数组

split 将一个数组分割为多个子数组
hsplit 将一个数组水平分割为多个子数组（按列）
vsplit 将一个数组垂直分割为多个子数组（按行）

【6】数组元素的添加与删除

resize 返回指定形状的新数组
append 将值添加到数组末尾
insert 沿指定轴将值插入到指定下标之前
delete 删掉某个轴的子数组，并返回删除后的新数组
unique 查找数组内的唯一元素

九、Numpy数学函数

【1】三角函数

NumPy 提供了标准的三角函数：sin()、cos()、tan()。

【2】舍入函数

numpy.around() 函数返回指定的数字的四舍五入值

np.around(a,decimals)

a: 数组
decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置

(1)numpy.floor()
返回数字的下舍整数

（2）numpy.celi()
返回数字的上入整数。

【3】算术函数

numpy包含简单的加减乘除：
(1)add(),subtact(),multiply(),dlvlde()

(2)numpy.reciprocal()
函数返回参数各个元素的倒数。
如 1/4 倒数为 4/1。

(3)numpy.power()
函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相对应元素的幂

(4)numpy.mod()
计算输入数组中相应元素的相除后的余数。
函数numpy.remainder()也产生相同的结果。

【4】统计函数

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。
numpy.amax() 用于计算数组中的元素沿指定轴的最大值。
numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。
numpy.percentile() 百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。
numpy.median() 函数用于计算数组 a 中元素的中位数（中值）
numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。
numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。 average()
np.std() 标准差是一组数据平均值分散程度的一种度量。
标准差公式如下：std = sqrt(mean((x - x.mean())2))
np.var() 统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean()) 2)。
标准差是方差的平方根。

【5】矩阵库（Maxtrix）

NumPy 中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。

一个mxn 的矩阵是一个由行m（row）n列（column）元素排列成的矩形阵列。

矩阵里的元素可以是数字、符号或数学式。

1.matlib.empty()
函数返回一个新的矩阵，语法格式为：

numpy.matlib.empty(shape, dtype, order)

参数说明：
shape: 定义新矩阵形状的整数或整数元组
Dtype: 可选，数据类型
order: C（行序优先） 或者 F（列序优先）

2.numpy.matlib.zeros()

函数创建一个以 0 填充的矩阵。

3.numpy.matlib.ones()
函数创建一个以 1 填充的矩阵。

4.numpy.matlib.eye()
函数返回一个矩阵，对角线元素为 1，其他位置为零。

numpy.matlib.eye(n, M,k, dtype)

 n: 返回矩阵的行数
M: 返回矩阵的列数，默认为 n
k: 对角线的索引
dtype: 数据类型

5.numpy.matlib.identity()
函数返回给定大小的单位矩阵。

6.numpy.matlib.rand()
函数创建一个给定大小的矩阵，数据是随机填充的。

【6】线性代数

NumPy 提供了线性代数函数库 linalg，该库包含了线性代数所需的所有功能

函数	描述
dot	两个数组的点积，即元素对应相乘。
vdot	两个向量的点积
inner	两个数组的内积
matmul	两个数组的矩阵积
determinant	数组的行列式
solve	求解线性矩阵方程
inv	计算矩阵的乘法逆矩阵

十、Numpy IO

Numpy 可以读写磁盘上的文本数据或二进制数据
Numpy为ndarray对象引入了一个简单的文件格式：npy
npy 文件用于存储重建 ndarray 所需的数据、图形、dtype 和其他信息。

常用的 IO 函数有：

load() 和 save() 函数是读写文件数组数据的两个主要函数，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npy 的文件中。
savze() 函数用于将多个数组写入文件，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npz 的文件中。
loadtxt() 和 savetxt() 函数处理正常的文本文件(.txt 等)

【1】numpy.save()

numpy.save() 函数将数组保存到以 .npy 为扩展名的文件中。

numpy.save(file, arr, allow_pickle=True, fix_imports=True)
 file：要保存的文件，扩展名为 .npy，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上。
arr: 要保存的数组
allow_pickle: 可选，布尔值，允许使用 Python pickles 保存对象数组，Python 中的 pickle 用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化。
fix_imports: 可选，为了方便 Pyhton2 中读取 Python3 保存的数据。

【2】np.savez()

numpy.savez() 函数将多个数组保存到以 npz 为扩展名的文件中。

numpy.savez(file, *args, **kwds)

参数说明：

file：要保存的文件，扩展名为 .npz，如果文件路径末尾没有扩展名 .npz，该扩展名会被自动加上。
args: 要保存的数组，可以使用关键字参数为数组起一个名字，非关键字参数传递的数组会自动起名为 arr_0, arr_1, …　。
kwds: 要保存的数组使用关键字名称。

【3】savetxt()

savetxt() 函数是以简单的文本文件格式存储数据，对应的使用 loadtxt() 函数来获取数据。

np.loadtxt(FILENAME, dtype=int, delimiter=' ')
np.savetxt(FILENAME, a, fmt="%d", delimiter=",")

参数 delimiter 可以指定各种分隔符、针对特定列的转换器函数、需要跳过的行数等。

十一、案例

【1】基于Numpy的股价统计分析应用

"""
data.csv文件中存储了股票的信息， 其中第4-8列,即EXCEL表格中的D-H列,
分别为股票的开盘价,最高价,最低价,收盘价,成交量。
分析角度:
    1. 计算成交量加权平均价格
    概念:成交量加权平均价格,英文名VWAP(Volume-Weighted Average Price,成交量加权平均价格)是一个非常重要的经
    济学量,代表着金融资产的“平均”价格。
    某个价格的成交量越大,该价格所占的权重就越大。VWAP就是以成交量为权重计算出来的加权平均值。

    2. 计算最大值和最小值: 计算股价近期最高价的最大值和最低价的最小值
    3. 计算股价近期最高价的最大值和最小值的差值;----(极差)
    计算股价近期最低价的最大值和最小值的差值
    4. 计算收盘价的中位数
    5. 计算收盘价的方差
    6. 计算对数收益率， 股票收益率、年波动率及月波动率
     ***收盘价的分析常常是基于股票收益率的。
     股票收益率又可以分为简单收益率和对数收益率。
            简单收益率：是指相邻两个价格之间的变化率。  diff
            对数收益率：是指所有价格取对数后两两之间的差值。
            # [1, 2,3 4]   ======>[-1, ]
    ***使用的方法: NumPy中的diff函数可以返回一个由相邻数组元素的差值构成的数组。
    不过需要注意的是，diff返回的数组比收盘价数组少一个元素。
    ***在投资学中,波动率是对价格变动的一种度量,历史波动率可以根据历史价格数据计算得出。计算历史波动率时,需要用
    到对数收益率。
        年波动率等于对数收益率的标准差除以其均值,再乘以交易日的平方根,通常交易日取252天。
        月波动率等于对数收益率的标准差除以其均值,再乘以交易月的平方根。通常交易月取12月。
    7. 获取该时间范围内交易日周一、周二、周三、周四、周五分别对应的平均收盘价
    8. 平均收盘价最低,最高分别为星期几

"""


import numpy as np

print("**********************************************")

params1 = dict(
    fname="doc/data.csv",
    delimiter=",",   # 指定文件分隔符;
    usecols=(6, 7),
    unpack=True)  # 是否解包,返回两个一维数组;
# 收盘价,成交量
endPrice, countNum = np.loadtxt(**params1)
# print(endPrice, countNum)
VWAP = np.average(endPrice, weights=countNum)
print("1. 计算成交量加权平均价格：", VWAP)

print("**********************************************")
params2 = dict(
    fname="doc/data.csv",
    delimiter=",",
    usecols=(4, 5),
    unpack=True)
# 最高价和最低价
highPrice, lowPrice = np.loadtxt(**params2)

# 最高价的最大值和最低价的最小值
print("2.最高价的最大值： ", highPrice.max())
print("2.最低价的最小值： ", lowPrice.min())

print("**********************************************")
# 计算股价近期最高价的最大值和最小值的差值;----(极差)
#     计算股价近期最低价的最大值和最小值的差值

print("3. 近期最高价的极差： ", np.ptp(highPrice))
print("3. 近期最低价的极差： ", np.ptp(lowPrice))

print("**********************************************")
# 计算收盘价的中位数
print("4. 计算收盘价的中位数:", np.median(endPrice))

print("**********************************************")
# 计算收盘价的方差
print("5. 计算收盘价的方差:", np.var(endPrice))

print("**********************************************")
def get_week(date):
    """根据传入的日期28-01-2011获取星期数, 0-星期一 1-"""
    from datetime import datetime
    # 默认传入的不是字符串， 是bytes类型;
    date = date.decode('utf-8')
    return datetime.strptime(date, "%d-%m-%Y").weekday()
params3 = dict(
    fname="doc/data.csv",
    delimiter=",",
    usecols=(1, 6),
    converters={1: get_week},
    unpack=True)
# 星期数和收盘价
week, endPrice = np.loadtxt(**params3)
# print(week, endPrice)
allAvg = []
for weekday in range(5):
    # 依次判断获取星期一的平均收盘价, .......星期五
    average = endPrice[week == weekday].mean()
    allAvg.append(average)
    print("7. 星期%s的平均收盘价：%s" % (weekday + 1, average))

# print(allAvg)

print("**********************************************")
# [12, 23, 34, 45, 56]
print("8.平均收盘价最低是星期", np.argmin(allAvg) + 1)
print("8. 平均收盘价最高是星期", np.argmax(allAvg) + 1)
#

print("***********************************************************")
# 简单收益率
simpleReturn = np.diff(endPrice)
print(simpleReturn)
# 对数收益率: 所有价格取对数后两两之间的差值。
logReturn = np.diff(np.log(endPrice))
print("6. 对数收益率:", logReturn)
# 年波动率等于对数收益率的标准差除以其均值,再乘以交易日的平方根,通常交易日取252天。
annual_vol = logReturn.std()/logReturn.mean()*np.sqrt(252)
print("6. 年波动率:",  annual_vol)
#  月波动率等于对数收益率的标准差除以其均值,再乘以交易月的平方根。通常交易月取12月。
month_vol = logReturn.std()/logReturn.mean()*np.sqrt(12)
print("6. 月波动率:", month_vol)