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')
- 空
这个空值的数组，其元素的值会是一个随机的值， 这时其值也会有两种情况- 假如创建的空数组的列数， 刚好在此内存环境中被创建过， 那么空数组的元素的值就是之前创建过的值。
- 假如穿件的空数组的列数， 在此内存环境中不存在， 则空数组中的元素的值会是一个随机数
因为在每次创建这种数组时， 会申请一块儿新内存，成功申请后， 此时内存的数据并不会被清除掉。
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])
网友评论