Python3与金融

---

如何使用Python进行量化投资
• 自己编写：NumPy+pandas+Matplotlib+……
• 在线平台：聚宽、优矿、米筐、Quantopian、……
• 开源框架：RQAlpha、QUANTAXIS、……

第一部分 量化投资第三方相关模块

•   NumPy：数值计算
•   pandas：数据分析
•   Matplotlib：图标绘制

Numpy 简单介绍

主要用于数值计算NumPy是高性能科学计算和数据分析的基础包。它是pandas等其他各种工具的基础。
NumPy 的主要功能：
• ndarray，一个多维数组结构，高效且节省空间
• 无需循环对整组数据进行快速运算的数学函数
• *读写磁盘数据的工具以及用于操作内存映射文件的工具
• *线性代数、随机数生成和傅里叶变换功能
• *用于集成C、C++等代码的工具
安装方法：
pip install numpy
官方推荐的引用方式：
import numpy as np

NumPy 的 ndarray
NumPy 最主要的特点是其 N 维数组对象，即 ndarray。该对象以一个快速而灵活的大数据集容器。可以利用这组数组对象对整块数据进行一些数学计算，如： + 、 - 、 * 、 / 、%% 等。
ndarray 是一个通用的同构数据多维容器。也就是说其中所有的元素都必须是同一类型的，字符串和数字不能同时存在，浮点数和整数也不能同时存在。
Numpy 把数组的维数称为它的秩(rank)。
• 一维数组就像是一行数据
• 二维数组就像是一张包含行和列的表格
• 三维数组就像是一个魔方
• 每一维的长度不要求相同
每个数组对象都有几个常用的对象：
• ndim （返回数组的秩）
• shape （返回数组每一秩(维)的元素的数量，也表示了此数组组的形状）
• size （返回数组中所有元素的个数）
• dtype （返回数组的数据类型）
ndarray 数组的特性
• 数组中的元素必须是同一类型; 已知的类型有：字符串( • 数组被创建后，是固定的长度。就是说数组一旦被创建成功，它的内存是固定的，不可向其添加和删除元素，但可以改变其中元素的值。
创建 ndarray 对象
使用 array（）就可以创建任意维度的数组对象 - 没有维度
创建一个指定类型为 字符串 的数组
In [33]: a1 = np.array([1,2,3],'U1')

获取数组对象的元素类型
In [34]: a1.dtype
Out[34]: dtype('

获取数组对象的维度，一维时不显示维度只显示 列
In [35]: a1.shape
Out[35]: (3,)

获取数组对象中的第一个元素的值
In [36]: a1[0]
Out[36]: '1'

创建默认整数类型的数组对象
In [37]: a2 = np.array([1,2,3])

默认整数类型的位数，是按照本机的操作系统而定的，32位/64位
In [38]: a2.dtype
Out[38]: dtype('int64')
• 2 维 可以理解为 2 行， 每行有 n 列数据
In [6]: a23 = np.array([[1,2,3],[4,5,6]])

In [7]: a23
Out[7]:
array([[1, 2, 3],
[4, 5, 6]])

In [8]: a23.shape
Out[8]: (2, 3) # 表示一个 2 维 3 列的数组
• 3 维 可以理解为 3 页 n 行 n 列
In [12]: a323 = np.array([
...: [[1,2,3],[4,5,6]],
...: [[7,8.,9],[10,11,12]],
...: [[13,14,15],[16,17,18]]
...: ])

In [13]: a323
Out[13]:
array([[[ 1., 2., 3.],
[ 4., 5., 6.]],

   [[  7.,   8.,   9.],
    [ 10.,  11.,  12.]],

   [[ 13.,  14.,  15.],
    [ 16.,  17.,  18.]]])

In [14]: a323.shape
Out[14]: (3, 2, 3) # 表示一个 3 页 2 行 3 列的数组
shape 最后的数字总是表示有几列数据
创建一些特殊的数组对象
• 全零
In [20]: zero
Out[20]: array([ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])

In [21]: zero.dtype
Out[21]: dtype('float64') # 默认类型是 float

In [65]: z35 = np.zeros((3,5)) # 创建多维的空数组

In [66]: z35
Out[66]:
array([[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])

In [67]: z35.shape
Out[67]: (3, 5)
• 全一
In [24]: onety = np.ones(5)

In [25]: onety
Out[25]: array([ 1., 1., 1., 1., 1.])

In [26]: onety.dtype
Out[26]: dtype('float64')

In [27]: onetyint = np.ones(5,'int32') # 可以显示的指定类型

In [28]: onetyint.dtype
Out[28]: dtype('int32')
• 空 这个空值的数组，其元素的值会是一个随机的值， 这事其值也会有两种情况
1. 假如创建的空数组的列数， 刚好在此内存环境中被创建过， 那么空数组的元素的值就是之前创建过的值。
2. 假如穿件的空数组的列数， 在此内存环境中不存在， 则空数组中的元素的值会是一个随机数
因为在每次创建这种数组时， 会申请一块儿新内存，成功申请后， 此时内存的数据并不会被清除掉。
In [30]: empty = np.empty(5)

In [31]: empty
Out[31]: array([ 1., 1., 1., 1., 1.]) # 之前创建过列相同的数组

In [32]: empty.shape
Out[32]: (5,)

In [33]: empty.dtype
Out[33]: dtype('float64')

In [35]: empty2 = np.empty(8)

In [36]: empty2
Out[36]:
array([ -3.10503618e+231, -4.33951848e-311, 9.76118064e-313,
2.46151512e-312, 2.37663529e-312, 2.12199584e-314,
2.24759075e-314, 5.56270712e-309])

In [37]: empty2.shape
Out[37]: (8,)

In [38]: empty2.dtype
Out[38]: dtype('float64')
• random random 会创建 0.0 到 1.0 之间的随机数组成矩阵，接受 1 个参数，这个参数可以是一个任意数字(表示要创建元素的个数）或一个表示数组形状的元组

•   创建单位矩阵

In [48]: eye1 = np.eye(1)

In [49]: eye1
Out[49]: array([[ 1.]])
In [53]: eye2
Out[53]:
array([[ 1., 0.],
[ 0., 1.]])

In [57]: eye5
Out[57]:
array([[ 1., 0., 0., 0., 0.],
[ 0., 1., 0., 0., 0.],
[ 0., 0., 1., 0., 0.],
[ 0., 0., 0., 1., 0.],
[ 0., 0., 0., 0., 1.]])
In [58]: eye1.shape
Out[58]: (1, 1)

In [59]: eye2.shape
Out[59]: (5, 5)

In [60]: eye5.shape
Out[60]: (5, 5)
• arange数组版的 range， 支持步长为 浮点数
In [77]: np.arange(1,10)
Out[77]: array([1, 2, 3, 4, 5, 6, 7, 8, 9])

In [78]: np.arange(1,5,0.3)
Out[78]:
array([ 1. , 1.3, 1.6, 1.9, 2.2, 2.5, 2.8, 3.1, 3.4, 3.7, 4. ,
4.3, 4.6, 4.9])

•   linspace 利用指定数组内元素的个数，来创建数组。 这个时候，步长是不固定的

In [83]: lin1 = np.linspace(3,4)

In [84]: lin1.shape
Out[84]: (50,)

In [85]: lin1 = np.linspace(3,6)

In [86]: lin1.shape
Out[86]: (50,)

In [87]: lin6 = np.linspace(3,6,6)

In [88]: lin6.shape
Out[88]: (6,)

In [89]: lin6
Out[89]: array([ 3. , 3.6, 4.2, 4.8, 5.4, 6. ])
前两个参数和 arange 一样， 最后一个参数是要创建元素的个数。默认不填，是 50 个。创建后的元素之间的步长是相等的。
并且有一点和arange不同， 定义元素的结束位置的值会被包含在创建的元素中
• reshape可以改变数组的形状
In [43]: arr = np.arange(10)

In [44]: arr
Out[44]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [45]: arr.ndim
Out[45]: 1

In [46]: arr.shape
Out[46]: (10,)

In [47]: arr = arr.reshape(5,2)

In [48]: arr
Out[48]:
array([[0, 1],
[2, 3],
[4, 5],
[6, 7],
[8, 9]])

In [49]: arr.ndim
Out[49]: 2

In [50]: arr.shape
Out[50]: (5, 2)

In [51]: arr.size
Out[51]: 10

In [52]: arr.shape = (2,5) # 也可以对数组的 shape 属性进行赋值一个表示形状的元组，来达到同样的效果

In [53]: arr
Out[53]:
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])

In [54]: arr.ndim
Out[54]: 2

In [55]: arr.shape
Out[55]: (2, 5)
对表示形状的元组唯一的限制是，秩的乘积必须要等于数组所有元素的个数（上例中是 10 ）
也可以和 arange 配合， arange 接受一个参数，这个参数表示要创建数组的元素的方位值， 就是 arange 的最后一个参数后面跟 reshape， reshape 接受两个参数， 表示要创建数组的形状，比如创建一个 3 行 5 列的 3 维数组，示例如下：
In [98]: np.arange(15).reshape(3,5)
Out[98]:
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])

In [99]: np.arange(15).reshape(3,4)

ValueError Traceback (most recent call last)
in ()
----> 1 np.arange(15).reshape(3,4)

ValueError: cannot reshape array of size 15 into shape (3,4)

In [100]: np.arange(15).reshape(1,15
...: )
Out[100]: array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]])

In [101]: np.arange(1,5),reshape(2,2)
需要注意的是， arange 的参数， 必须是 reshape 两个参数的乘积。
数组之间以及数组和数字之间的运算
不论怎么运算， 最初的数组的值不会别改变；可以把运算的结果重新赋值给原来数组的变量，或者赋值给一个新的变量。- 数组和数字之间的运算
In [111]: ar1 = np.array([1,2,3])

In [112]: ar1 + 1
Out[112]: array([2, 3, 4])

In [113]: ar1 - 1
Out[113]: array([0, 1, 2])

In [114]: ar1 * 2
Out[114]: array([2, 4, 6])

In [115]: ar1 / 2
Out[115]: array([ 0.5, 1. , 1.5])

In [116]: ar1 // 3
Out[116]: array([0, 0, 1])

In [117]: ar1 ** 2
Out[117]: array([1, 4, 9])

In [118]: ar1
Out[118]: array([1, 2, 3])

•   数组之间的运算

In [118]: ar1
Out[118]: array([1, 2, 3])

In [119]: ar2 = np.array([4,5,6])

In [120]: ar1 + ar1
Out[120]: array([2, 4, 6])

In [121]: ar1 * 2
Out[121]: array([2, 4, 6])

In [122]: ar1 + ar2
Out[122]: array([5, 7, 9])

In [123]: ar3 = np.array([3,5])

In [124]: ar1 + ar3 # 两个数组之间运算，两个数组的元素个数和形状必须一样

ValueError Traceback (most recent call last)
in ()
----> 1 ar1 + ar3

ValueError: operands could not be broadcast together with shapes (3,) (2,)
不论几维的数组之间运算， 都是对数组里每个元素进行逐个运算。
数组的索引和切片

1. 没有维度的数组
   没有维度的数组的索引和切片的方法几乎和 Python 中列表一样，区别是切片复制不会自动复制。- 索引
   In [3]: ar1 = np.arange(1,5)

In [4]: ar1
Out[4]: array([1, 2, 3, 4])

In [5]: ar1[0]
Out[5]: 1

In [7]: ar1[2]
Out[7]: 3

In [8]: ar2 = ar1[1] # 利用索引，找到索引位置的值，之后赋值给一个新的变量，
# 此时 ar2 是一个变量，不是一个 ndarray 的数组对象。

In [9]: ar2
Out[9]: 2
• 切片
In [16]: ar1
Out[16]: array([1, 2, 3, 4])

In [17]: ar1[:]
Out[17]: array([1, 2, 3, 4])

In [18]: ar1[1:2]
Out[18]: array([2])

In [19]: ar2 = ar1[1:2]

In [20]: ar2
Out[20]: array([2])

In [21]: ar3 = ar1[1:3]

In [22]: ar3
Out[22]: array([2, 3])

In [23]: ar3[1]=20

In [24]: ar3
Out[24]: array([ 2, 20])

In [25]: ar1
Out[25]: array([ 1, 2, 20, 4])

•   可以看出，数组的切片不会自动复制，改变切片后的数组的元素值，原数组的元素值也会跟着改变；不同于Python中的列表 

对于上图说明一下：先说明一点，muqi在大部分语言环境中ar_name1 是一个元数组，当利用切片取值元素 2 去创建一个新的数组 ar_name2 的时候，系统会建立一个指针，指针指向了原数组元素 2 的原来的内存地址， 并不会重新申请新的内存地址。所以当在 ar_name2 上，更改其元素的值，原数组 ar_name1 上对应的元素的值也会被改变。但是，当原数组 ar_name1 被重新赋值后， 新的 ar_name2 还会保持不变的。
• 切片赋值时，强制复制
In [34]: ar1
Out[34]: array([ 1, 2, 20, 4])

In [35]: ar4 = ar1[1:].copy()

In [36]: ar4
Out[36]: array([ 2, 20, 4])

In [37]: ar4[1] = 3

In [38]: ar4
Out[38]: array([2, 3, 4])

In [39]: ar1
Out[39]: array([ 1, 2, 20, 4])

2. 多维数组
   对于不是一维是数组，进行索引和切片，就要用英文的逗号 "," 分开来指定每一维的索引
   • 索引
   In [41]: ar23 = np.arange(6).reshape(2,3)

In [42]: ar23
Out[42]:
array([[0, 1, 2],
[3, 4, 5]])

In [44]: ar23[1]
Out[44]: array([3, 4, 5])

In [45]: ar23[0]
Out[45]: array([0, 1, 2])

In [46]: ar23[0][1]
Out[46]: 1

In [47]: ar23[0,1]
Out[47]: 1
• 切片
In [49]: ar23
Out[49]:
array([[0, 1, 2],
[3, 4, 5]])

In [50]: ar23[:,2]
Out[50]: array([2, 5])

In [51]: ar23[:,1]
Out[51]: array([1, 4])

In [52]: ar23[1,1] # 这样只是索引获取值，不是切片
Out[52]: 4

In [56]: ar23[1,1:2] # 这样才是切片
Out[56]: array([4])

In [57]: ar23[1:2,1] # 这样也可以
Out[57]: array([4])

In [58]: ar11 = ar23[1:2,1:2] # 这样可以得到 1 行 1 列的 1 维数组，不建议这么干

In [59]: ar11
Out[59]: array([[4]]) # 这使数据结构更复杂了，扁平胜于嵌套

In [60]: ar11.shape
Out[60]: (1, 1)

In [75]: ar11[0] # 嵌套的坏处，使得获取到具体的值更复杂
Out[75]: array([4])

In [76]: ar11[0,0]
Out[76]: 4

In [68]: ar21 = ar23[:,2:3] # 获得 2 行 1列的 2 维数组

In [69]: ar21
Out[69]:
array([[2],
[5]])

In [70]: ar21.shape
Out[70]: (2, 1)

In [54]: ar23[1] # 可以直接切出第几行的全部， 也可以这样 ar23[1,:]， 得到的结果一样
Out[54]: array([3, 4, 5])

ndarray 高级索引操作
• bool 值索引
ndarray 对象的索引还有个 bool 值索引默认会把 bool 值为 true 的元素的值获取到
In [82]: arbool = np.arange(10).reshape(2,5)

In [83]: arbool
Out[83]:
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])

In [84]: arbool[arbool>5]
Out[84]: array([6, 7, 8, 9])

In [85]: art = arbool > 5

In [86]: art
Out[86]:
array([[False, False, False, False, False],
[False, True, True, True, True]], dtype=bool)

In [87]: arbool > 5
Out[87]:
array([[False, False, False, False, False],
[False, True, True, True, True]], dtype=bool)

In [88]: arbool[art]
Out[88]: array([6, 7, 8, 9])

•   可以对元素的索引值进行自定义为 True 或 False

In [104]: arbool2 = np.arange(5)

In [105]: arbool2
Out[105]: array([0, 1, 2, 3, 4])

In [106]: arbool2[0:4]
Out[106]: array([0, 1, 2, 3])

In [107]: arbool2[[True,False,False,True,True]] # 自定义元素的索引值为 True 或 False，
Out[107]: array([0, 3, 4]) # 获取到索引值只为 True 的元素值

•   & | 与 ~ & 表示 and 关系 | 表示 or 关系 ~ 表示 否 关系

In [3]: arbool3 = np.arange(10)

In [4]: arbool3
Out[4]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [5]: arbool3[(arbool3>5) & (arbool3 % 2 == 0)] # 大于 5 的数 并且 是偶数
Out[5]: array([6, 8])

In [6]: arbool3[(arbool3>5) | (arbool3 % 2 == 0)] # 大于 5 的数 和 所有的偶数
Out[6]: array([0, 2, 4, 6, 7, 8, 9])

In [7]: arbool3[~(arbool3>5)] # 不大于 5 的数
Out[7]: array([0, 1, 2, 3, 4, 5])
花式索引
花式索引是利用了切片、索引、bool索引相结合，可以取出数组中的任意想要的行和列，来创建一个新的多维数组
In [13]: arr = np.arange(35).reshape(5,7)

In [14]: arr
Out[14]:
array([[ 0, 1, 2, 3, 4, 5, 6],

[ 7, , 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]])

对于上面的数组
• 获取 8、11、22、25，组成一个新的二维数组 先通过索引获取到所要的行，再对获取到的行进行切片和索引
In [15]: new1_arr = arr[[1,4]][:,[1,4]]

In [16]: new1_arr
Out[16]:
array([[ 8, 11],
[29, 32]])

•   行索引和列切片结合

In [47]: arr[[False,True,False,False,True],1:3] # bool 索引必须按位补全bool值，不可少或者多，不然会有警告信息
Out[47]:
array([[ 8, 9],
[29, 30]])

In [48]: arr[[1,4],1:3]
Out[48]:
array([[ 8, 9],
[29, 30]])
• 花式索引获取到多行的任意列的值，创建一个一维数组
In [49]: arr
Out[49]:
array([[ 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]])

In [50]: arr[[1,1,4,4],[1,4,1,4]]
Out[50]: array([ 8, 11, 29, 32])
第二行的第二个数，第二行的第五个数第五行的第二个数，第五行的第五个数
要向获取到多维的数字，进行花式索引切片时，逗号两遍不可均为索引
常用函数
先说一下把一个小数转化为整数有以下几种方法
方法 /值
3.4
3.5
-3.4
-3.5
Numpy 函数实现
四舍五入法
3
4
-3
-4
rint
向下取整（去尾法）
3
3
-4
-4
floor
向上取整（进一法）
4
4
-3
-3
ceil
向零取整
3
3
-3
-3
trunc
numpy 实现（一元函数）：
• rint
In [68]: arr = np.arange(10,1,-1.4)

In [69]: arr
Out[69]: array([ 10. , 8.6, 7.2, 5.8, 4.4, 3. , 1.6])

In [70]: np.rint(arr)
Out[70]: array([ 10., 9., 7., 6., 4., 3., 2.])
• floor （译为 地板）
In [71]: arr
Out[71]: array([ 10. , 8.6, 7.2, 5.8, 4.4, 3. , 1.6])

In [72]: np.floor(arr)
Out[72]: array([ 10., 8., 7., 5., 4., 2., 1.])
• ceil (译为 天花板)
In [73]: arr
Out[73]: array([ 10. , 8.6, 7.2, 5.8, 4.4, 3. , 1.6])

In [74]: np.ceil(arr)
Out[74]: array([ 10., 9., 8., 6., 5., 3., 2.])
• trunc
In [75]: arr
Out[75]: array([ 10. , 8.6, 7.2, 5.8, 4.4, 3. , 1.6])

In [76]: np.trunc(arr)
Out[76]: array([ 10., 8., 7., 5., 4., 2., 1.])
In [79]: arr2 = np.arange(1,-1,-0.4)

In [80]: arr2
Out[80]: array([ 1. , 0.6, 0.2, -0.2, -0.6])

In [81]: np.trunc(arr2)
Out[81]: array([ 1., 0., 0., -0., -0.])
• sqrt 开根号
In [98]: arr3 = np.arange(1,3)

In [99]: arr3
Out[99]: array([1, 2])

In [100]: np.sqrt(arr3)
Out[100]: array([ 1. , 1.41421356])
• abs 绝对值
In [86]: arr2
Out[86]: array([ 1. , 0.6, 0.2, -0.2, -0.6])

In [87]: np.abs(arr2)
Out[87]: array([ 1. , 0.6, 0.2, 0.2, 0.6])
• modf 对一个含有浮点数的数组进行分割，分割为整数部分和小数部分两个数组
In [223]: modfa = np.arange(1,5,1.2)

In [224]: modfa
Out[224]: array([ 1. , 2.2, 3.4, 4.6])

In [225]: np.modf(modfa)
Out[225]: (array([ 0. , 0.2, 0.4, 0.6]), array([ 1., 2., 3., 4.]))

In [226]: modf = np.modf(modfa)

In [227]: modf[0]
Out[227]: array([ 0. , 0.2, 0.4, 0.6])

In [228]:

In [228]: modf[1]
Out[228]: array([ 1., 2., 3., 4.])

In [234]: modf[0][:2]
Out[234]: array([ 0. , 0.2])

•   isnan 先说 nan 是 not a number ， 意思是不是一个数

In [151]: arr
Out[151]: array([0, 2, 3, 4])

In [152]: arr2
Out[152]: array([0, 1, 2, 3])

In [153]: nan1 = arr/arr2
/Users/yanshunjun/.pyenv/versions/anaconda3-4.4.0/bin/ipython:1: RuntimeWarning: invalid value encountered in true_divide

!/Users/yanshunjun/.pyenv/versions/anaconda3-4.4.0/bin/python

In [154]: nan1
Out[154]: array([ nan, 2. , 1.5 , 1.33333333])

In [155]: nan1[np.isnan(nan1)] # 找到 nan
Out[155]: array([ nan])

In [156]: nan1[~np.isnan(nan1)] # 排除 nan
Out[156]: array([ 2. , 1.5 , 1.33333333])

•   isinf 是一个无穷大的数

In [174]: a
Out[174]: array([1, 2, 3, 4])

In [175]: b
Out[175]: array([0, 1, 2, 3])

In [176]: c = a / b
/Users/yanshunjun/.pyenv/versions/anaconda3-4.4.0/bin/ipython:1: RuntimeWarning: divide by zero encountered in true_divide

!/Users/yanshunjun/.pyenv/versions/anaconda3-4.4.0/bin/python

In [177]: c
Out[177]: array([ inf, 2. , 1.5 , 1.33333333])

In [178]: np.isinf(c)
Out[178]: array([ True, False, False, False], dtype=bool)
还有一些二元函数
• maximum 对两个同样形状的数组中的每个元素进行 max 运算，返回一个最大值
In [114]: arr
Out[114]: array([ 10., 8., 7., 5., 4.])

In [115]: arr2
Out[115]: array([ 20. , 20. , 0.2, -0.2, -0.6])

In [116]: np.maximum(arr,arr2)
Out[116]: array([ 20., 20., 7., 5., 4.
• mininmum 求两个同样形状是数组的最小值
In [118]: arr
Out[118]: array([ 10., 8., 7., 5., 4.])

In [119]: arr2
Out[119]: array([ 20. , 20. , 0.2, -0.2, -0.6])

In [120]: np.minimum(arr,arr2)
Out[120]: array([ 10. , 8. , 0.2, -0.2, -0.6])
常用科学和统计方法
下面这些方法是对于一个数组来使用的，通过 . 方式调用
• sum 求和
In [165]: a
Out[165]: array([7, 8, 2, 6, 1, 5, 4, 3, 9])

In [166]: a.sum()
Out[166]: 45
• cusum 求所有元素的累计和，接收的不论是几维数组，返回的始终是一个一维数组
In [183]: arr
Out[183]:
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])

In [184]: arr.cumsum()
Out[184]: array([ 0, 1, 3, 6, 10, 15, 21, 28, 36, 45])

In [189]: arr5 = np.arange(9).reshape(3,3)

In [190]: arr5
Out[190]:
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])

In [191]: arr5.cumsum()
Out[191]: array([ 0, 1, 3, 6, 10, 15, 21, 28, 36])
• mean 求平均数
In [167]: a.mean()
Out[167]: 5.0
• min 求最小值
In [168]: a.min()
Out[168]: 1
• max 求最大值
In [169]: a.max()
Out[169]: 9
• argmin 求最小值的索引
In [170]: a.argmin()
Out[170]: 4
• argmax 求最大值的索引
In [171]: a.argmax()
Out[171]: 8
• var 求方差
什么是方差
方差就是求一组数的离散程度比如有这样一组数 5、4、3、2、1方法:用这组数中的每一个数去减去这组数的平均值，再用这个得出来的差值求平方，就这样得到每个元素这样算出来的平方数相加之和 再除以这组数的元素数((5-3)2 + (4-3)2 + (3-3)2 + (2-3)2 + (1-3)**2 )/5
In [202]: va = np.arange(5,0,-1)

In [203]: va
Out[203]: array([5, 4, 3, 2, 1])

In [204]: va.var()
Out[204]: 2.0

In [193]: va2 = np.zeros(5)+3

In [194]: va2
Out[194]: array([ 3., 3., 3., 3., 3.])

In [195]: va2.var()
Out[195]: 0.0
• std 求标准差
什么是标准差
标准差就是 方差开根号
In [213]: va
Out[213]: array([5, 4, 3, 2, 1])

In [214]: va.var()
Out[214]: 2.0

In [215]: c = va.var()

In [216]: va.std()
Out[216]: 1.4142135623730951

In [217]: np.sqrt([c])
Out[217]: array([ 1.41421356])
Numpy 随机生成数 random
• rand 返回 0.0 到 1.0 的随机数，组成一个一维数组， 只接收一个参数
In [239]: np.random.rand(5)
Out[239]: array([ 0.93476534, 0.93881936, 0.15654494, 0.64855116, 0.00933524])
• random 返回 0.0 到 1.0 的随机数，组成一个多维数组， 只接收一个元组的参数
In [242]: np.random.random((2,5))
Out[242]:
array([[ 0.97400618, 0.94829591, 0.23247149, 0.60995674, 0.31937055],
[ 0.50170312, 0.71082459, 0.34595982, 0.87529154, 0.21735688]])
• randint 返回一个给定的 连续的 整数范围内的 一个数组，接收一个整数参数或者一个表示形状的元组
In [243]: np.random.randint(1,10, 5)
Out[243]: array([2, 5, 3, 2, 1])

In [244]: np.random.randint(1,10, (2, 5))
Out[244]:
array([[7, 3, 6, 2, 9],
[3, 1, 1, 1, 8]])
• choice 返回一个给定的 非连续的 随机的数字列表范围内的 一个数组，接收一个整数参数或者一个元组
In [247]: np.random.choice([1,5,7,10,1.6,30],3)
Out[247]: array([ 1., 7., 5.])

In [248]: np.random.choice([1,5,7,10,1.6,30],(2,3))
Out[248]:
array([[ 1., 10., 7.],
[ 30., 10., 1.]])

•   shuffle 把一个给定的列表或者一个给定 Numpy 的数组中的元素位置打乱

In [153]: a = np.arange(1,10)

In [154]: a
Out[154]: array([1, 2, 3, 4, 5, 6, 7, 8, 9])

In [155]: b
Out[155]: [1, 2, 3, 4, 5, 6]

In [156]: np.random.shuffle(a)

In [157]: a
Out[157]: array([7, 8, 2, 6, 1, 5, 4, 3, 9])

In [158]: np.random.shuffle(b)

In [159]: b
Out[159]: [4, 6, 2, 3, 5, 1]
• uniform
In [173]: np.random.uniform([1.0,5.0], 2)
Out[173]: array([ 1.10986969, 4.05806047])