美文网首页
Python3与金融

Python3与金融

作者: 山抹微云君_c | 来源:发表于2019-05-31 18:41 被阅读0次

    如何使用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 数组的特性
    • 数组中的元素必须是同一类型; 已知的类型有:字符串(<U1)、正整数int(8/16/32/64)、无符号整数uint(8/16/32/64)、float(16/32/64)
    • 数组被创建后,是固定的长度。就是说数组一旦被创建成功,它的内存是固定的,不可向其添加和删除元素,但可以改变其中元素的值。
    创建 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 最后的数字总是表示有几列数据
    创建一些特殊的数组对象
    • 全零
    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)
    <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,)
    不论几维的数组之间运算, 都是对数组里每个元素进行逐个运算。
    数组的索引和切片

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

    1. 多维数组
      对于不是一维是数组,进行索引和切片,就要用英文的逗号 "," 分开来指定每一维的索引
      • 索引
      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])

    相关文章

      网友评论

          本文标题:Python3与金融

          本文链接:https://www.haomeiwen.com/subject/utngtctx.html