Numpy有很多矩陣運算的方法，小白總結了一些常用和認為在算法中用到的方法~

基礎操作：

首先創建兩個矩陣

            
              A = np.array([[1,2],[1,2]])
B = np.array([[2,4],[5,5]])
            
          

1.矩陣對應位置的元素相加

            
              #矩陣同位置元素相加
np.add(A,B)#方法1
A+B     #方法2
            
          

結果都為：

            
              array([[3, 6],
       [6, 7]])
            
          

2.矩陣對應位置的元素相乘

            
              #矩陣對應位置的每個元素相乘
A*B
            
          

結果為：

            
              array([[ 2,  8],
       [ 5, 10]])
            
          

與之對應的就有矩陣相乘的運算

            
              #矩陣相乘
A.dot(B)   #方法1
np.dot(A,B)#方法2
            
          

結果為：

            
              array([[12, 14],
       [12, 14]])
            
          

進階操作：

用之前博文中介紹過的arange函數創建一個矩陣

這里用arange中的reshape函數創建了一個6*4的矩陣，如果不指定，默認就是一行的矩陣

            
              A = np.arange(24).reshape(6,4)
            
          

結果為：

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

創建好矩陣之后來一寫進階的計算：

1)sum函數

? ? axis就是確定沿矩陣的行或者列進行加和

? ?axis=0：沿著每一列進行操作（所以返回4個值）
? ?axis=1：沿著每一行進行操作（6個行返回六個值）

            
              A.sum(axis=0)
A.sum(axis=1)
            
          

axis=0的結果：

            
              array([60, 66, 72, 78])
            
          

axis=1的結果：

            
              array([ 6, 22, 38, 54, 70, 86])
            
          

2)cumsum函數

? ?axis就是確定沿矩陣的行或者列進行加和

? ?axis=0：沿著每一列對這個位置及之前位置的元素累加
? ?axis=1：沿著每一行對這個位置及之前位置的元素累加

            
              A.cumsum(axis=1)
A.cumsum(axis=0)
            
          

?

axis=1的結果：

            
              array([[ 0,  1,  3,  6],
       [ 4,  9, 15, 22],
       [ 8, 17, 27, 38],
       [12, 25, 39, 54],
       [16, 33, 51, 70],
       [20, 41, 63, 86]], dtype=int32)
            
          

axis=0的結果：

            
              array([[ 0,  1,  2,  3],
       [ 4,  6,  8, 10],
       [12, 15, 18, 21],
       [24, 28, 32, 36],
       [40, 45, 50, 55],
       [60, 66, 72, 78]], dtype=int32)
            
          

3.min函數

? ?axis就是確定沿矩陣的行或者列取最小值

? ?axis=0：沿著每一列取最小值
? ?axis=1：沿著每一行取最大值

            
              A.min(axis=0)
A.min(axis=1)
            
          

? axis=0的結果：

            
              array([0, 1, 2, 3])
            
          

axis=1的結果：

            
              array([ 0,  4,  8, 12, 16, 20])
            
          

像這樣的函數還有很多，不再一一介紹，不過都是按照axis=1按列操作，axis=0按行操作的規律進行的。

矩陣元素的選取：

            
              a = np.arange(10)**2
array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81], dtype=int32)
            
          

選取某個位置的元素：

            
              a[5]
25
            
          

從結果是25可以看出，下標是從0開始計數。

選取某幾個元素:

從結果可以看出，選取的元素是從第一個參數開始，第二個參數為止且不包含第二個參數位置的元素。

            
              a[1:3]
array([1, 4], dtype=int32)
            
          

下面介紹一個大家在復制矩陣時有可能遇到的坑~

            
              a_slice = a[0:5]
array([100, 100, 100,   9,  16], dtype=int32)
            
          

這里選取了0-4位置的元素變成一個新的array，下面對此array進行操作：

可以看到該操作，也同樣對a產生了影響，因為，當選取部分np array的時候，我們創建了一個view，也就是說，我們沒有copy之前的值，而是直接改了原來的array。

            
              a_slice[0]=222
a_slice
array([222, 100, 100,   9,  16], dtype=int32)
a
array([222, 100, 100,   9,  16,  25,  36,  49,  64,  81], dtype=int32)
            
          

那么，如果我們不想改變之前的array怎么辦呢？

這時，就用到了copy函數，是指將數據copy到新的array中并不對原array產生影響。

            
              a_slice_2 = a[0:5].copy()
a_slice_2[1]=222
array([222, 222, 100,   9,  16], dtype=int32)
            
          

下面總結一下用方程建矩陣,及多維矩陣的選取和切片：

            
              def f(x,y):
    return 4 * x +y
b = np.fromfunction(f,(3,2),dtype=int)
b
            
          

這里我們就自定義了一個函數f，下面用fromfunction方法創建一個三行兩列的數組

結果為：

            
              array([[0, 1],
       [4, 5],
       [8, 9]])
            
          

array的選取：

[:]:僅針對行的操作

[:,]：對行和列的選取

            
              #全選
b[:]
array([[0, 1],
       [4, 5],
       [8, 9]])
#從某行開始選到某行結束
b[:1]
array([[0, 1]])
#選取所有行和第一列
b[:,1]
array([1, 5, 9])
#選取行
b[1]
array([4, 5])
#選取某個位置的元素
b[1,0]
4
            
          

這里再說一些shape函數的用法，之前博文中也有提到：

這里0指的是該矩陣有幾行，1代表這個矩陣有幾列

            
              b.shape[0]
3
b.shape[1]
2
            
          

矩陣的轉至,先舉一個一般的矩陣的轉至，以上面的b矩陣為例：

            
              b.T
array([[0, 4, 8],
       [1, 5, 9]])
            
          

那么對于堆矩陣，如何轉至呢？

首先創建一個堆：

            
              c=np.array([[[1,2,3,0],[3,4,5,2]]])
c.shape
            
          

這是一個一堆兩行四列的矩陣

            
              array([[[1, 2, 3, 0],
        [3, 4, 5, 2]]])
(1, 2, 4)
            
          

直接使用T轉至函數：

            
              c.T
            
          

結果為：

            
              array([[[1],
        [3]],

       [[2],
        [4]],

       [[3],
        [5]],

       [[0],
        [2]]])
            
          

看下轉至后的類型：可以看到是原來的每列變成堆，所以變成4堆，整體變為4堆兩行一列

            
              c.T.shape
            
          

            
              (4, 2, 1)
            
          

這時候就有一個進階函數，可以指定轉變的方式

            
              c.transpose(0,2,1)
            
          

三個參數的意思是，第一個維度不變，后面兩個維度交換位置，那形狀就變成了一堆四行兩列

結果為：

            
              array([[[1, 3],
        [2, 4],
        [3, 5],
        [0, 2]]])
            
          

求逆矩陣

            
              a1 = np.mat([[3,4],[2,16]])
np.linalg.inv(np.dot(a1.T,a1))
            
          

結果為：

            
              matrix([[ 0.17    , -0.0275  ],
        [-0.0275  ,  0.008125]])
            
          

比較兩個矩陣是否相同：

            
              a = np.array([[1.,2.],[3.,4.]])
ainv = np.linalg.inv(a)
np.allclose(np.dot(a,ainv),np.eye(2))
            
          

結果為：

            
              True
            
          

以上就是一些介紹啦~