Python Numpy 100題實驗（八）：線性代數函式以及fromfunction函式等
阿新 • • 發佈：2018-12-14
本次的主要內容有：
- 對線性代數函式例如逆矩陣函式，特徵值以及特徵值向量函式等的應用
- fromfunction（）函式的使用
求解給定矩陣的逆矩陣並驗證
a = np.random.randint(1, 5, (3,3)) # 注意這樣的話要多試幾次，因為隨機數生成的矩陣可能會是奇異矩陣。。 print('Arrray a:') print(a) b = np.linalg.inv(a) print('Inverse Matrix:') print(b) print(np.dot(a, b)) # 驗證一下矩陣相乘的結果是不是單位陣 assert np.allclose(np.dot(a, b), np.eye(3)) # 或者用這種方式
輸出：
Arrray a:
[[1 4 4]
[1 2 4]
[2 4 4]]
Inverse Matrix:
[[-1. 0. 1. ]
[ 0.5 -0.5 0. ]
[ 0. 0.5 -0.25]]
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
使用Numpy計算矩陣的特徵值以及特徵向量
線性代數的方法直接呼叫即可
a = np.array([[1,2,3], [4,5,6], [7,8,9]]) print('Array a:') print(a) w, v = np.linalg.eig(a) print('Eigen value:') print(w) print('Eigen vector:') print(v)
輸出：
Array a:
[[1 2 3]
[4 5 6]
[7 8 9]]
Eigen value:
[ 1.61168440e+01 -1.11684397e+00 -1.30367773e-15]
Eigen vector:
[[-0.23197069 -0.78583024 0.40824829]
[-0.52532209 -0.08675134 -0.81649658]
[-0.8186735 0.61232756 0.40824829]]
使用Numpy計算Ndarray兩相鄰元素的差值
diff函式的應用，也就是計算相鄰的元素之間的差，所以每一次計算都會比之前的陣列減少一個元素
a = np.random.randint(1, 10, 10) print('Array a:') print(a) # 計算一次差值 print(np.diff(a, n=1)) # 計算兩次差值 print(np.diff(a, n=2)) # 計算三次差值 print(np.diff(a, n=3))
輸出：
Array a:
[1 5 1 2 6 1 2 3 2 8]
[ 4 -4 1 4 -5 1 1 -1 6]
[-8 5 3 -9 6 0 -2 7]
[ 13 -2 -12 15 -6 -2 9]
使用Numpy將Ndarray相鄰元素依次累加
對於一個數組，輸出一個數組，輸出陣列的每一個元素對應從第一個元素累加到這個位置元素的和
a = np.random.randint(1, 10, 10)
print('Array a:')
print(a)
print(np.cumsum(a))
輸出：
Array a:
[8 9 1 2 9 6 2 1 6 9]
[ 8 17 18 20 29 35 37 38 44 53]
Numpy好變態啊。。這種函式都有。。。
使用Numpy按列連線兩個陣列
這裡注意兩種方法區別：
a = np.array([1,2,3])
b = np.array([4,5,6])
print([a,b])
c = [a, b]
print(type(c)) # 注意看這裡 簡單寫在一塊之後輸出的是列表
print(np.array(c))
print(type(np.array(c)))
d = np.c_[a, b] # 使用 numpy.c_函式直接生成的就是陣列
print(d)
print(d.T)
print(type(d))
輸出：
[array([1, 2, 3]), array([4, 5, 6])]
<class 'list'>
[[1 2 3]
[4 5 6]]
<class 'numpy.ndarray'>
[[1 4]
[2 5]
[3 6]]
[[1 2 3]
[4 5 6]]
<class 'numpy.ndarray'>
使用Numpy按行連線兩個陣列
與按列的方式是對應的，一個是column的簡寫，一個是row的間歇嘛，不過要注意函式後邊是中括號。
a = np.array([1,2,3])
b = np.array([4,5,6])
print(np.r_[a, b])
輸出：
[1 2 3 4 5 6]
使用Numpy列印九九乘法表
果然，不管是學習哪種語言，九九乘法表都是與hello world一樣的存在啊
不過使用Numpy有超級簡單的實現方式：
np.fromfunction(lambda i, j: (i + 1) * (j + 1), (9, 9))
輸出：
array([[ 1., 2., 3., 4., 5., 6., 7., 8., 9.],
[ 2., 4., 6., 8., 10., 12., 14., 16., 18.],
[ 3., 6., 9., 12., 15., 18., 21., 24., 27.],
[ 4., 8., 12., 16., 20., 24., 28., 32., 36.],
[ 5., 10., 15., 20., 25., 30., 35., 40., 45.],
[ 6., 12., 18., 24., 30., 36., 42., 48., 54.],
[ 7., 14., 21., 28., 35., 42., 49., 56., 63.],
[ 8., 16., 24., 32., 40., 48., 56., 64., 72.],
[ 9., 18., 27., 36., 45., 54., 63., 72., 81.]])
好吧，其實跟我們傳統的乘法表不太一樣。。
這裡主要是要注意fromfunciton函式的使用，這個函式我們可以非常方便地使用函式規則建立陣列，先看幾個例子：
例子一：
def f(x, y):
return 10*x + y
b =np.fromfunction(f, (5,4), dtype=np.int)
print(b)
輸出：
[[ 0 1 2 3]
[10 11 12 13]
[20 21 22 23]
[30 31 32 33]
[40 41 42 43]]
例子二：
a = np.fromfunction(lambda i,j: i==j ,(3,3), dtype=np.int)
print(a)
[[ True False False]
[False True False]
[False False True]]
我覺得看完這兩個例子，基本就搞清楚基本用法了，第一個引數指定了規則，也就是函數了，第二個引數制定了輸出的形狀，第三個引數則是指定了傳入函式資料的型別。一般這個函式與lambda函式放在一起使用，會使程式簡潔一些。
以上~