Python3 和金融簡單介紹

如何使用Python進行量化投資？

• 自己編寫：NumPy+pandas+Matplotlib+……

• 在線平臺：聚寬、優(yōu)礦、米筐、Quantopian谎倔、……

• 開源框架：RQAlpha、QUANTAXIS猿推、……

涉及到量化投資第三方相關模塊

• NumPy：用于數值計算

• pandas：用于數據分析

• Matplotlib：用于圖表繪制

Numpy 的使用

1. Numpy 簡單介紹

主要用于數值計算
NumPy是高性能科學計算和數據分析的基礎包片习。
它是pandas等其他各種工具的基礎。

2. NumPy 的主要功能：

• ndarray彤守，一個多維數組結構毯侦，高效且節(jié)省空間

• 無需循環(huán)對整組數據進行快速運算的數學函數

• *讀寫磁盤數據的工具以及用于操作內存映射文件的工具

• *線性代數、隨機數生成和傅里葉變換功能

• *用于集成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)

• 數組被創(chuàng)建后樱拴，是固定的長度柠衍。

  就是說數組一旦被創(chuàng)建成功，它的內存是固定的晶乔，不可向其添加和刪除元素珍坊，但可以改變其中元素的值。

7. 創(chuàng)建 ndarray 對象

使用 array（）就可以創(chuàng)建任意維度的數組對象

• 沒有維度

# 創(chuàng)建一個指定類型為 字符串 的數組
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'

# 創(chuàng)建默認整數類型的數組對象
In [37]: a2 = np.array([1,2,3])

# 默認整數類型的位數垫蛆，是按照本機的操作系統(tǒng)而定的，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. 創(chuàng)建一些特殊的數組對象

• 全零

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))    # 創(chuàng)建多維的空數組

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. 假如創(chuàng)建的空數組的列數呛占， 剛好在此內存環(huán)境中被創(chuàng)建過， 那么空數組的元素的值就是之前創(chuàng)建過的值懦趋。
  2. 假如穿件的空數組的列數晾虑， 在此內存環(huán)境中不存在， 則空數組中的元素的值會是一個隨機數

因為在每次創(chuàng)建這種數組時仅叫， 會申請一塊兒新內存帜篇，成功申請后， 此時內存的數據并不會被清除掉诫咱。

In [30]: empty = np.empty(5)

In [31]: empty
Out[31]: array([ 1.,  1.,  1.,  1.,  1.])   # 之前創(chuàng)建過列相同的數組

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 會創(chuàng)建 0.0 到 1.0 之間的隨機數組成矩陣笙隙，接受 1 個參數，這個參數可以是一個任意數字(表示要創(chuàng)建元素的個數）或一個表示數組形狀的元組坎缭。

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

• 創(chuàng)建單位矩陣

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
  利用指定數組內元素的個數，來創(chuàng)建數組掏呼。
  這個時候坏快，步長是不固定的

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 一樣， 最后一個參數是要創(chuàng)建元素的個數憎夷。默認不填莽鸿，是 50 個。創(chuàng)建后的元素之間的步長是相等的拾给。

并且有一點和arange不同祥得， 定義元素的結束位置的值會被包含在創(chuàng)建的元素中

• 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 接受一個參數，這個參數表示要創(chuàng)建數組的元素的方位值创千， 就是 arange 的最后一個參數
后面跟 reshape缰雇， reshape 接受兩個參數， 表示要創(chuàng)建數組的形狀追驴，比如創(chuàng)建一個 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 中列表一樣索抓，區(qū)別是切片復制不會自動復制钧忽。

• 索引

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在大部分語言環(huán)境中
ar_name1 是一個元數組男翰，當利用切片取值元素 2 去創(chuàng)建一個新的數組 ar_name2 的時候，系統(tǒng)會建立一個指針纽乱，指針指向了原數組元素 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索引相結合关炼，可以取出數組中的任意想要的行和列昧识，來創(chuàng)建一個新的多維數組

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 花式索引獲取到多行的任意列的值褥影，創(chuàng)建一個一維數組

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. 常用函數

先說一下把一個小數轉化為整數有以下幾種方法

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. 常用科學和統(tǒng)計方法

下面這些方法是對于一個數組來使用的氛雪，通過 . 方式調用

• 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
  返回一個給定的 連續(xù)的 整數范圍內的 一個數組举户，接收一個整數參數或者一個表示形狀的元組

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
  返回一個給定的 非連續(xù)的 隨機的數字列表范圍內的 一個數組烤宙，接收一個整數參數或者一個元組

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