編程學習網 > 編程語言 > Python > python矩陣教程(Python矩陣的創建和運算)
2023
07-10

python矩陣教程(Python矩陣的創建和運算)

Python是可以很方便地計算代數運算的,主要的支持庫就是Numpy,它是Python最優秀的、基礎的、實現數值計算的第三方庫。

Numpy庫就是基于數組來運算的,正是因為這個,使得Python做數值計算的速度非???。所謂數組,在代數運算中就可以理解為矩陣。一般而言,我們的矩陣是一個二維的,由行列指標組成的。Numpy的數組不僅僅支持二維的數組,還可以創建更高維度的數組,比如三維的圖像數據就是使用三維數組來存儲的。下面提到的矩陣,不加一般說明,就是指二維數組。
創建矩陣
學會使用Python做矩陣計算的前提是創建矩陣,下面就給出幾種不同創建矩陣的方式。
創建向量,再重構行列數,得到二維的數組。
使用二維列表創建矩陣。
通過特殊函數創建特殊矩陣。
上面所提到的向量,不會區分行向量還是列向量,可以理解為一行元素或者一列元素。原因有二:其一,向量不參與代數運算時,作出區分是無意義的。其二,代數運算中,向量可以直接與矩陣作運算的,但是在Python程序中是不可以的,必須是矩陣與矩陣之間作運算,也就是說,要將向量“顯示地”轉化為1行n列或者n行一列的矩陣。如何“顯示地”轉換,就是對它進行行列數重構。
我們所說的第一種創建矩陣的方式,是先要創建向量,那么如何創建向量呢?也有兩種方式:
使用列表或者元組創建向量。
使用特殊函數來創建向量。
先看第一種簡單的方式,使用列表或者元素來創建向量,執行下面的代碼:
import numpy as np # 導入必要的包,這是必要的,后面書寫上可能會省略
lst = [1,2,3,4,5,0,9,8,7,6]
vec = np.array(lst) # 使用np.array()函數來創建向量,同時也可以創建矩陣
print(vec)
程序輸出的結果如下:
[1 2 3 4 5 0 9 8 7 6]
下面使用幾個特殊的函數來創建幾個特殊的向量,執行下面的代碼:
vec1 = np.arange(10) # 默認從0開始,步長為1,截止到9
vec2 = np.ones(10) # 創建10個1的向量
vec3 = np.zeros(5) # 創建5個0的向量
start = 1
end = 11
vec4 = np.arange(start, end) # 創建10個元素的向量,1,2,...,10
vec5= np.empty(5) # 創建5個元素的空向量
length = 10
value = 3
vec6 = np.full(shape=length,fill_value=value)
print(vec1, vec2, vec3, vec4, vec5, vec6, sep="\n")
程序輸出的結果如下:
[0 1 2 3 4 5 6 7 8 9]
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
[0. 0. 0. 0. 0.]
[ 1  2  3  4  5  6  7  8  9 10]
[1.32774279e-311 8.01304531e+262 2.60799828e-310 1.32624737e-311 0.00000000e+000]
[3 3 3 3 3 3 3 3 3 3]
需要注意的是,empty函數得到的“空向量”是一個非常小的數組成的向量,而這些非常小的數是隨機生成的。
現在來創建矩陣,先看第一種方法。創建向量再重構行列,重構是使用方法reshape。
row = 4
col = 5 # 行、列只需要指定一個即可,另一個寫成-1
mat1 = np.arange(20).reshape(row, -1)
mat2 = np.reshape(np.arange(1,21), (row, col))
print(mat1, mat2, sep='\n')
程序輸出的結果如下:
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]]
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]
 [16 17 18 19 20]]
第二種方式,使用二維列表創建矩陣,執行下面的代碼:
lst = [[1,2,3], [3,2,1], [4,5,6]]
mat = np.array(lst)
print(mat)
程序輸出的結果如下:
[[1 2 3]
 [3 2 1]
 [4 5 6]]
第三種生成矩陣的方式,是使用特殊函數直接生成矩陣。
row = 3
col = 5
mat1 = np.ones((row, col)) # 1矩陣,直接生成必須填寫一個元組作為參數
mat2 = np.zeros((row, col)) # 0矩陣,元組作參數
mat3 = np.full(shape=(row, col), fill_value=5) # 全值矩陣
print(mat1, mat2, mat3, sep='\n')
程序輸出的結果如下:
[[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]]
[[0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]]
[[5 5 5 5 5]
 [5 5 5 5 5]
 [5 5 5 5 5]]
下面使用一個最實用的函數來創建單位矩陣:
mat = np.identity(4) # 創建一個4×4的單位陣
print(mat)
程序輸出的結果如下:
[[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]
矩陣的簡單計算
這里所謂的矩陣簡單計算,主要是矩陣的加法和乘法。加法直接使用符號"+"即可,矩陣的數乘使用符號"*"即可,但是矩陣的乘法必須使用點乘形式,"A.dot(B)",或者是"np.dot(A,B)",其中的A和B是矩陣。
執行下面的代碼:
mat1 = np.array([[1,2,3], [4,5,6],[7,8,9]])
mat2 = np.arange(15).reshape(3,-1)
mat3 = np.identity(3)
mat4 = mat1+mat3 # 矩陣的加法
mat5 = mat1.dot(mat3) # 矩陣的乘法
mat6 = mat1 * mat3 # 矩陣對應元素相乘
print(mat4, mat5, mat6, sep='\n')
程序輸出的結果如下:
[[ 2.  2.  3.]
 [ 4.  6.  6.]
 [ 7.  8. 10.]]
[[1. 2. 3.]
 [4. 5. 6.]
 [7. 8. 9.]]
[[1. 0. 0.]
 [0. 5. 0.]
 [0. 0. 9.]]
再看兩個矩陣的除法和矩陣的數乘,使用運算符"/","*"。
mat1 = np.arange(1,11).reshape(2,5)
mat2 = np.arange(4,14).reshape(2,5)
mat3 = mat1/mat2 # 矩陣對應元素相除
mat4 = mat1*0.5 # 矩陣的數乘
print(mat3, mat4, sep='\n')
程序輸出的結果如下:
[[0.25       0.4        0.5        0.57142857 0.625     ]
 [0.66666667 0.7        0.72727273 0.75       0.76923077]]
[[0.5 1.  1.5 2.  2.5]
 [3.  3.5 4.  4.5 5. ]]
再看取余除法和取商除法,分別使用運算符"%","http://"。
mat1 = np.arange(1,16).reshape(3,5)
mat2 = np.full((3,5), 3)
mat3 = mat1 % mat2 # 對應元素取余
mat4 = mat1//mat2 # 對應元素向下取整除法
print(mat3, mat4, sep='\n')
程序輸出的結果如下:
[[1 2 0 1 2]
 [0 1 2 0 1]
 [2 0 1 2 0]]
[[0 0 1 1 1]
 [2 2 2 3 3]
 [3 4 4 4 5]]
比較兩個矩陣元素的大小,返回大者或者小者元素,組成一個矩陣,使用函數np.fmax()或者(np.maximum()),和函數np.fmin()或者是(np.minimum()),執行下面的代碼:
mat1 = np.array([1,4,5,6,2,8]).reshape(2,3)
mat2 = np.array([0,3,6,9,1,3]).reshape(2,3)
mat3 = np.fmax(mat1, mat2) # 取最大者元素
mat4 = np.fmin(mat1, mat2) # 取最小者元素
print(mat1, mat2, mat3, mat4, sep='\n')
程序輸出的結果如下:
[[1 4 5]
 [6 2 8]]
[[0 3 6]
 [9 1 3]]
[[1 4 6]
 [9 2 8]]
[[0 3 5]
 [6 1 3]]
兩個矩陣之間元素的大小比較,直接使用比較運算符"<, <=, >, >=, ==, !="即可。返回的是邏輯數組,由True和False組成的數組??梢杂米飨聵藖硭饕龜到M元素,執行下面的元素:
mat1 = np.arange(10).reshape(2,5)
mat2 = np.array([2,1,4,9,8,0,12,8,8,6]).reshape(2,5)
mat3 = mat1 < mat2
mat4 = mat1 <= mat2
mat5 = mat1 == mat2
mat6 = mat1[mat3] # 取出mat1中小于mat2對應元素的元素
mat7 = mat1[np.logical_not(mat3)] # 取出mat1中大于等于mat2對應元素的元素
mat8 = mat1[mat4] # 取出mat1中小于等于mat2對應元素的元素
mat9 = mat1[mat5] # 取出mat1中等于mat2對應元素的元素
print(mat6, mat7, mat8, mat9, sep='\n')
輸出的結果如下:
[0 2 3 4 6 7]
[1 5 8 9]
[0 1 2 3 4 6 7 8]
[1 8]
上面使用到了一個對矩陣元素取非的函數np.logical_not(),下面就展開說說矩陣的邏輯符運算。使用函數np.logical_and()對兩個矩陣的對應元素取“且”,意思是若兩個元素都非零,則返回的元素是True,否則為False。函數np.logical_or()對兩個矩陣的對應元素取“或”,意思是若兩個元素都為零,則返回的元素是False,否則為True。執行下面代碼:
mat1 = np.zeros((2,4))
mat2 = np.array([[0,1,2,3],[3,2,1,0]])
mat3 = np.logical_and(mat1, mat2) # 取且
mat4 = np.logical_or(mat1, mat2) # 取或
mat5 = np.logical_not(mat2) # 取反
print(mat3, mat4, mat5, sep='\n')
程序輸出的結果如下:
[[False False False False]
 [False False False False]]
[[False  True  True  True]
 [ True  True  True False]]
[[ True False False False]
 [False False False  True]]
特別需要注意的是,這里不能使用運算符"&, |"以及關鍵字"not"代替上面的三個函數。
計算兩個矩陣對應元素的最小公倍數和最大公因子,分別使用函數"np.lcm()","np.gcd()",執行下面的代碼:
mat1 = np.array([1,3,5,6,7,8]).reshape(2,3)
mat2 = np.arange(1,7).reshape(2,3)
mat3 = np.gcd(mat1, mat2) # 最大公因子
mat4 = np.lcm(mat1, mat2) # 最小公倍數
print(mat1, mat2, mat3, mat4, sep='\n')
程序輸出的結果如下:
[[1 3 5]
 [6 7 8]]
[[1 2 3]
 [4 5 6]]
[[1 1 1]
 [2 1 2]]
[[ 1  6 15]
 [12 35 24]]
將向量轉化為對角矩陣,使用函數"np.diag()",執行下面的代碼:
vec = np.arange(5)
mat = np.diag(vec)
print(vec, mat, sep='\n')
程序輸出的結果如下:
[0 1 2 3 4]
[[0 0 0 0 0]
 [0 1 0 0 0]
 [0 0 2 0 0]
 [0 0 0 3 0]
 [0 0 0 0 4]]
將對角矩陣的對角元素拉直為向量,仍然是使用函數"np.diag()",執行下面的代碼:
mat = np.identity(4)
vec = np.diag(mat)
print(vec)
程序輸出的結果如下:
[1. 1. 1. 1.]
將矩陣拉直為向量,不能使用函數,只能使用方法"mat.flatten()",其中的"mat"是矩陣名,執行下面的代碼:
mat = np.arange(6).reshape(2,3)
vec = mat.flatten()
print(vec)
程序輸出的結果如下:
[0 1 2 3 4 5]
矩陣的數學函數
矩陣的數學函數,是指將數學函數應用在矩陣的每一個元素上。數學函數有很多,比如三角函數,對數函數,指數函數,反三角函數等。這些函數地對向量或者標量都適用的。
對矩陣元素取相反數,使用函數np.negative()或者符號"-",執行下面的代碼:
mat1 = np.arange(-5,5).reshape(2,5)
mat2 = np.negative(mat1) # 或者是 mat2 = -mat1
print(mat2)
程序輸出的結果如下:
[[ 5  4  3  2  1]
 [ 0 -1 -2 -3 -4]]
對矩陣元素取絕對值,使用函數np.abs(),執行下面的代碼:
mat1 = np.arange(-5,5).reshape(2,5)
mat2 = np.absolute(mat1) # 或者使用內置函數 abs(mat1)
print(mat2)
程序輸出的結果如下:
[[5 4 3 2 1]
 [0 1 2 3 4]]
對矩陣元素應用符號函數,使用函數np.sign(),執行下面的代碼:
mat1 = np.arange(-5,5).reshape(2,5)
mat2 = np.sign(mat1)
print(mat2)
程序輸出的結果如下:
[[-1 -1 -1 -1 -1]
 [ 0  1  1  1  1]]
對矩陣元素向下取整,使用函數np.floor(),執行下面的代碼:
start = 1
end = 10
num_point = 6
mat1 = np.linspace(start=start, stop=end, num=num_point, endpoint=True)
# 通過起始點和線性點列的個數生成一個數列
mat2 = np.floor(mat1)
print(mat1, mat2, sep='\n')
程序輸出的結果如下:
[ 1.   2.8  4.6  6.4  8.2 10. ]
[ 1.  2.  4.  6.  8. 10.]
對矩陣元素向上取整,使用函數np.ceil(),執行下面的代碼:
start = 1
end = 10
num_point = 6
mat1 = np.linspace(start=start, stop=end, num=num_point, endpoint=True)
mat2 = np.ceil(mat1)
print(mat2)
程序輸出的結果如下:
[ 1.  3.  5.  7.  9. 10.]
對矩陣元素就近取整,使用函數np.rint(),執行下面的代碼:
start = -4
end = 4
num_point = 6
mat1 = np.linspace(start=start, stop=end, num=num_point, endpoint=True)
mat2 = np.rint(mat1)
print(mat1, mat2, sep='\n')
它是先不管正負號,取最近的整數,然后加上正負號。程序輸出的結果如下:
[-4.  -2.4 -0.8  0.8  2.4  4. ]
[-4. -2. -1.  1.  2.  4.]
對矩陣元素截尾取整,使用函數np.trunc(),執行下面的代碼:
start = -4
end = 4
num_point = 6
mat1 = np.linspace(start=start, stop=end, num=num_point, endpoint=True)
mat2 = np.trunc(mat1)
print(mat2)
程序輸出的結果如下:
[-4. -2. -0.  0.  2.  4.]
對矩陣元素取三角函數,可以分別使用函數np.sin(),np.cos(),np.tan(),執行下面的代碼:
start = -np.pi
end = np.pi # 圓周率
num_point = 12
mat1 = np.linspace(start=start, stop=end, num=num_point, endpoint=True).reshape(3,4)
mat2 = np.sin(mat1)
mat3 = np.cos(mat1)
mat4 = np.tan(mat1)
print(mat2, mat3, mat4, sep='\n')
程序輸出的結果如下:
[[-1.22464680e-16 -5.40640817e-01 -9.09631995e-01 -9.89821442e-01]
 [-7.55749574e-01 -2.81732557e-01  2.81732557e-01  7.55749574e-01]
 [ 9.89821442e-01  9.09631995e-01  5.40640817e-01  1.22464680e-16]]
[[-1.         -0.84125353 -0.41541501  0.14231484]
 [ 0.65486073  0.95949297  0.95949297  0.65486073]
 [ 0.14231484 -0.41541501 -0.84125353 -1.        ]]
[[ 1.22464680e-16  6.42660977e-01  2.18969456e+00 -6.95515277e+00]
 [-1.15406152e+00 -2.93626493e-01  2.93626493e-01  1.15406152e+00]
 [ 6.95515277e+00 -2.18969456e+00 -6.42660977e-01 -1.22464680e-16]]
對矩陣元素取反三角函數,可以分別使用函數np.arcsin(),np.arccos(),np.arctan(),執行下面的代碼:
start = -1
end = 1
num_point = 12
mat1 = np.linspace(start=start, stop=end, num=num_point, endpoint=True).reshape(3,4)
mat2 = np.arcsin(mat1)
mat3 = np.arccos(mat1)
mat4 = np.arctan(mat1)
print(mat2, mat3, mat4, sep='\n')
程序輸出的結果如下:
[[-1.57079633 -0.95824159 -0.689775   -0.47186184]
 [-0.27622663 -0.09103478  0.09103478  0.27622663]
 [ 0.47186184  0.689775    0.95824159  1.57079633]]
[[3.14159265 2.52903792 2.26057133 2.04265816]
 [1.84702296 1.6618311  1.47976155 1.2945697 ]
 [1.09893449 0.88102133 0.61255474 0.        ]]
[[-0.78539816 -0.68572951 -0.56672922 -0.42662749]
 [-0.26625205 -0.09065989  0.09065989  0.26625205]
 [ 0.42662749  0.56672922  0.68572951  0.78539816]]
對矩陣元素取雙曲函數,可以分別使用函數np.sinh(),np.cosh(),np.tanh(),執行下面的代碼:
mat1 = np.arange(-4,6).reshape(2,5)
mat2 = np.sinh(mat1)
mat3 = np.cosh(mat1)
mat4 = np.tanh(mat1)
print(mat2, mat3, mat4, sep='\n')
程序輸出的結果如下:
[[-27.2899172  -10.01787493  -3.62686041  -1.17520119   0.        ]
 [  1.17520119   3.62686041  10.01787493  27.2899172   74.20321058]]
[[27.30823284 10.067662    3.76219569  1.54308063  1.        ]
 [ 1.54308063  3.76219569 10.067662   27.30823284 74.20994852]]
[[-0.9993293  -0.99505475 -0.96402758 -0.76159416  0.        ]
 [ 0.76159416  0.96402758  0.99505475  0.9993293   0.9999092 ]]
對矩陣元素取反雙曲函數,可以分別使用函數np.arcsinh(),np.arccosh(),np.arctanh(),執行下面的代碼:
mat1 = np.arange(-4,6).reshape(2,5)
mat2 = np.arange(1,7).reshape(2,3)
start = -0.95
end = 1
num_point = 12
mat3 = np.linspace(start=start, stop=end, num=num_point, endpoint=False).reshape(3,4)
mat4 = np.arcsinh(mat1)
mat5 = np.arccosh(mat2)
mat6 = np.arctanh(mat3)
print(mat4, mat5, mat6, sep='\n')
程序輸出的結果如下:
[[-2.09471255 -1.81844646 -1.44363548 -0.88137359  0.        ]
 [ 0.88137359  1.44363548  1.81844646  2.09471255  2.31243834]]
[[0.         1.3169579  1.76274717]
 [2.06343707 2.29243167 2.47788873]]
[[-1.83178082 -1.06481564 -0.73316853 -0.50048691]
 [-0.3095196  -0.1383765   0.02500521  0.18974481]
 [ 0.36544375  0.56611445  0.81987163  1.21274161]]
對矩陣元素取自然對數,使用函數np.log(),取自然指數,使用函數np.exp(),執行下面的代碼:
start = 0.1
end = 4
num_point = 12
mat1 = np.linspace(start=start, stop=end, num=num_point, endpoint=False).reshape(3,4)
mat2 = np.log(mat1)
mat3 = np.exp(mat2)
print(mat2, mat3, sep='\n')
程序輸出的結果如下:
[[-2.30258509 -0.85566611 -0.28768207  0.07232066]
 [ 0.33647224  0.54522705  0.71783979  0.86499744]
 [ 0.99325177  1.10691109  1.20896035  1.30155313]]
[[0.1   0.425 0.75  1.075]
 [1.4   1.725 2.05  2.375]
 [2.7   3.025 3.35  3.675]]
對矩陣元素開根號,取三次方根,可以分別使用函數np.sqrt(),np.cbrt(),執行下面的代碼:
mat1 = np.arange(1,11).reshape(2,5)
mat2 = np.sqrt(mat1)
mat3 = np.cbrt(mat1)
print(mat2, mat3, sep='\n')
程序輸出的結果如下:
[[1.         1.41421356 1.73205081 2.         2.23606798]
 [2.44948974 2.64575131 2.82842712 3.         3.16227766]]
[[1.         1.25992105 1.44224957 1.58740105 1.70997595]
 [1.81712059 1.91293118 2.         2.08008382 2.15443469]]
對矩陣元素取次冪,可以使用運算符"**",執行下面的代碼:
mat1 = np.arange(1,11).reshape(2,5)
mat2 = mat1**2
mat3 = mat1**3
print(mat2, mat3, sep='\n')
程序輸出的結果如下:
[[  1   4   9  16  25]
 [ 36  49  64  81 100]]
[[   1    8   27   64  125]
 [ 216  343  512  729 1000]]
存儲和讀取矩陣
所謂存儲和讀取矩陣,就是將矩陣存儲為一個特定格式的文件。讀取就是將上面存儲的特定格式的文件讀取為矩陣。存儲矩陣為文件和將文件讀取為矩陣,分別使用函數np.save()以及np.load()。
執行下面的代碼:
mat = np.identity(3)
np.save('./data/identity.npy', mat) # 存儲為.npy格式的二進制文件
然后將這個文件讀取出來,還原為矩陣,執行下面的代碼:
mat = np.load('./data/identity.npy')
print(mat)
程序輸出的結果如下:
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
也可以將矩陣存儲為文本文件,分別使用函數np.savetxt(),和np.loadtxt()。執行下面的代碼:
mat1 = np.arange(12).reshape(3,4)
np.savetxt("./data/matrix.txt", mat1)
mat2 = np.loadtxt("./data/matrix.txt")
print(mat2)
程序輸出的結果如下:
[[ 0.  1.  2.  3.]
 [ 4.  5.  6.  7.]

 [ 8.  9. 10. 11.]]

以上就是python矩陣教程(Python矩陣的創建和運算)的詳細內容,想要了解更多Python教程歡迎持續關注編程學習網。

掃碼二維碼 獲取免費視頻學習資料

Python編程學習

查 看2022高級編程視頻教程免費獲取