Numpy的小總結

1.Numpy是什么？

numpy是Python的一個科學計算庫，提供矩陣運算的功能。

1.1Numpy的導入

import numpy as np #一般都是用numpy的別名來進行操作

1.2Numpy的常用函數

np.array((1.2,2,3,4), dtype=np.int32)

這里是強制定義了np里面的矩陣數據類型，是讓其為int32位，如果其中有小數的，都會轉換成整數。

numpy向量轉為矩陣：

arr1 = np.array([1,2,3,4,5,6,6,6])
print(arr1.reshape(2,4))
reshape完之后，就變成矩陣了
arr1.shape()則顯示矩陣的情況，就是是幾維矩陣，矩陣的長度如何。

arr1.dtype顯示arr1矩陣的數據的類型，這里上邊定義的是int類型的

import numpy as np

print(np.array((1.2,2,3,4.1), dtype=np.int32))

arr1 = np.array([1,2,3,4,5,6,6,6])
print(arr1.reshape(2,4))
print(arr1.dtype)

np.linspace(1,10,10)

#起始值為第一個參數，終點值為第二個參數，然后第三個參數是把這個區間的數，分為多少，這里的輸出結果是從1到10
矩陣之間是可以運算的，但是要注意的是什么？就是矩陣的長度得是對應的。比如二維對二維，並且相對應運算行的長度得相同

import numpy as np
a = np.array([[1,2,3],[2,3,4]])
b = np.array([[2,3,4],[2,3,4]])
print(a -b)
"""結果輸出:[[-1 -1 -1]
 [ 0  0  0]]"""

矩陣點乘，行乘列得出結果，看輸出結果中的9可以看出，是a的第一行乘以b的第一列。

import numpy as np
a = np.array([[1,2,3],[2,3,4],[1,1,1]])
b = np.array([[2,3,4],[2,3,4],[1,1,1]])
print(np.dot(a,b))
"""輸出結果[[ 9 12 15]
 [14 19 24]
 [ 5  7  9]]
"""

np.floor(矩陣)向下取整，就是傳進來的矩陣，如果是3.5，就會變成3這樣子

矩陣.ravel()會變成向量

import numpy as np
a = np.array([[1,2,3],[2,3,4],[1,1,1]])
print(a.ravel())
"""輸出結果：[1 2 3 2 3 4 1 1 1]"""

矩陣拼接，vstack和hstack，我發現只能憑借相同大小的，就是如果矩陣不等長的話則按照斷的來拼接。像矩陣a的第二行，有五個數，但是最終只拼接了三個

import numpy as np
a = np.array([[1,2,3],[2,3,4,5,6],[1,1,1]])
a = np.array([[1,2,3],[2,3,4],[1,1,1]])
print(np.hstack((a,b)))
print(np.vstack((a,b)))
"""輸出結果:[[1 2 3 2 3 4]
 [2 3 4 2 3 4]
 [1 1 1 1 1 1]]
[[1 2 3]
 [2 3 4]
 [1 1 1]
 [2 3 4]
 [2 3 4]
 [1 1 1]]"""

矩陣切分

按照行來切,這里在第三行和第四行切了，因此，產生了三個矩陣

a = np.floor(10*np.random.random((2,12))) #按行切
print(a)
print(np.hsplit(a,(3,4)))
"""結果：[[ 0.  2.  0.  3.  3.  1.  5.  9.  1.  5.  5.  9.]
 [ 5.  5.  1.  7.  3.  0.  8.  3.  4.  7.  0.  7.]]
[array([[ 0.,  2.,  0.],
       [ 5.,  5.,  1.]]), array([[ 3.],
       [ 7.]]), array([[ 3.,  1.,  5.,  9.,  1.,  5.,  5.,  9.],
       [ 3.,  0.,  8.,  3.,  4.,  7.,  0.,  7.]])]"""

 按列來分,想切幾刀就切幾刀，切多少下，只要沒超過它的列數，就可以切。

import numpy as np
a = np.floor(10*np.random.random((12,2)))
print(a)
print(np.vsplit(a,3))
"""運行結果[[ 7.  5.]
 [ 4.  9.]
 [ 9.  9.]
 [ 9.  7.]
 [ 8.  6.]
 [ 4.  4.]
 [ 6.  7.]
 [ 3.  2.]
 [ 8.  1.]
 [ 4.  2.]
 [ 2.  5.]
 [ 0.  0.]]
[array([[ 7.,  5.],
       [ 4.,  9.],
       [ 9.,  9.],
       [ 9.,  7.]]), array([[ 8.,  6.],
       [ 4.,  4.],
       [ 6.,  7.],
       [ 3.,  2.]]), array([[ 8.,  1.],
       [ 4.,  2.],
       [ 2.,  5.],
       [ 0.,  0.]])]"""

至於訪問切出來的矩陣，很簡單，就是參考數組，既然切成了多個矩陣，那就是按照不同的下標來訪問咯，比如上邊的結果想拿到第一個數組的第一個數字，則只要賦值了之后，用

賦值的變量[0][0][0]就可以訪問到了，注意數組嵌套的情況。