Python3 和金融简单介绍

如何使用Python进行量化投资？

• 自己编写：NumPy+pandas+Matplotlib+……

• 在线平台：聚宽、优矿、米筐、Quantopian、……

• 开源框架：RQAlpha、QUANTAXIS、……

涉及到量化投资第三方相关模块

• NumPy：用于数值计算

• pandas：用于数据分析

• Matplotlib：用于图表绘制

Numpy 的使用

1. Numpy 简单介绍

主要用于数值计算
NumPy是高性能科学计算和数据分析的基础包。
它是pandas等其他各种工具的基础。

2. NumPy 的主要功能：

• ndarray，一个多维数组结构，高效且节省空间

• 无需循环对整组数据进行快速运算的数学函数

• *读写磁盘数据的工具以及用于操作内存映射文件的工具

• *线性代数、随机数生成和傅里叶变换功能

• *用于集成C、C++等代码的工具

3. 安装方法：

pip install numpy

4. 官方推荐的引用方式：

import numpy as np

---

5. NumPy 的 ndarray

NumPy 最主要的特点是其 N 维数组对象，即 ndarray。该对象以一个快速而灵活的大数据集容器。
可以利用这组数组对象对整块数据进行一些数学计算，如：+ 、 - 、 * 、 / 、%% 等。

ndarray 是一个通用的同构数据多维容器。也就是说其中所有的元素都必须是同一类型的，字符串和数字不能同时存在，浮点数和整数也不能同时存在。

Numpy 把数组的维数称为它的秩(rank)。

• 一维数组就像是一行数据
• 二维数组就像是一张包含行和列的表格
• 三维数组就像是一个魔方
• 每一维的长度不要求相同

每个数组对象都有几个常用的对象：

• ndim （返回数组的秩）
• shape （返回数组每一秩(维)的元素的数量，也表示了此数组组的形状）
• size （返回数组中所有元素的个数）
• dtype （返回数组的数据类型）

6. ndarray 数组的特性

• 数组中的元素必须是同一类型;

  已知的类型有：字符串(<U1)、正整数int(8/16/32/64)、无符号整数uint(8/16/32/64)、float(16/32/64)

• 数组被创建后，是固定的长度。

  就是说数组一旦被创建成功，它的内存是固定的，不可向其添加和删除元素，但可以改变其中元素的值。

7. 创建 ndarray 对象

使用 array（）就可以创建任意维度的数组对象

• 没有维度

# 创建一个指定类型为 字符串 的数组
In [33]: a1 = np.array([1,2,3],'U1')

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

# 获取数组对象的维度，一维时不显示维度只显示 列
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 最后的数字总是表示有几列数据

8. 创建一些特殊的数组对象

• 全零

In [19]: zero = np.zeros(10)

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 个参数，这个参数可以是一个任意数字(表示要创建元素的个数）或一个表示数组形状的元组。

>>> np.random.random(3)
array([0.05499027, 0.95205191, 0.13715412])

• 创建单位矩阵

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)
<ipython-input-99-166c0c33e02b> in <module>()
----> 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)
<ipython-input-124-f49987d67b64> in <module>()
----> 1 ar1 + ar3

ValueError: operands could not be broadcast together with shapes (3,) (2,)

不论几维的数组之间运算， 都是对数组里每个元素进行逐个运算。

9. 数组的索引和切片

9.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中的列表

15048375609486.jpg

对于上图说明一下：
先说明一点，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])

10. ndarray 高级索引操作

10.1 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 的元素值           

10.2 & 、| 与 ~

& 表示 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])

10.3 花式索引

花式索引是利用了切片、索引、bool索引相结合，可以取出数组中的任意想要的行和列，来创建一个新的多维数组

In [13]: arr = np.arange(35).reshape(5,7)

In [14]: arr
Out[14]:
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]])

对于上面的数组

• 获取 8、11、22、25，组成一个新的二维数组
  先通过索引获取到所要的行，再对获取到的行进行切片和索引

In [15]: new1_arr = arr[[1,4]][:,[1,4]]

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

10.4 行索引和列切片结合

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

10.5 花式索引获取到多行的任意列的值，创建一个一维数组

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

第二行的第二个数，第二行的第五个数
第五行的第二个数，第五行的第五个数

要向获取到多维的数字，进行花式索引切片时，逗号两遍不可均为索引

11. 常用函数

先说一下把一个小数转化为整数有以下几种方法

方法 /值	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])

12. 常用科学和统计方法

下面这些方法是对于一个数组来使用的，通过 . 方式调用

• 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])

13. 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])