Numpy支援大量的維度陣列和矩陣運算，對陣列運算提供了大量的數學函式庫！

Numpy比Python列表更具優勢，其中一個優勢便是速度。在對大型陣列執行操作時，Numpy的速度比Python列表的速度快了好幾百。因為Numpy陣列本身能節省記憶體，並且Numpy在執行算術、統計和線性代數運算時採用了優化演算法。

Numpy的另一個強大功能是具有可以表示向量和矩陣的多維陣列資料結構。Numpy對矩陣運算進行了優化，使我們能夠高效地執行線性代數運算，使其非常適合解決機器學習問題。

與Python列表相比，Numpy具有的另一個強大優勢是具有大量優化的內建數學函式。這些函式使你能夠非常快速地進行各種複雜的數學計算，並且用到很少程式碼（無需使用複雜的迴圈），使程式更容易讀懂和理解。

注：在ndarray結構中，裡面元素必須是同一型別的，如果不是，會自動的向下進行。

Numpy簡單建立陣列

a = [1,2,3]
b = np.array(a)
c = np.array([[0,1,10],[12,13,100,101],[102,110,112,113]],int)
print(c)
print(b)

建立數值為1的陣列

Numpy.ones(引數 1：shape，陣列的形狀；引數 2：dtype， 數值型別)

array_one = np.ones([10,dtype=np.int)
 print(array_one)

建立數值為0的陣列

Numpy.zeros(引數 1：shape，陣列的形狀；引數 2：dtype， 數值型別)

array_zero = np.zeros([10,9],dtype=np.float)
 print(array_zero)

建立指定數值的陣列

Numpy.full(引數 1：shape，陣列的形狀； 引數 2：constant value，陣列填充的常數值；引數 3：dtype， 數值型別)

 array_full = np.full((2,3),5)
 print(array_full)

建立單位矩陣

Numpy.eye(引數 1：N，方陣的維度)

 array_eye = np.eye(5)
 print(array_eye)

建立對角矩陣

Numpy.diag(引數1：v，主對角線數值，引數 2：k，對角線元素)：K = 0表示主對角線，k>0的值選擇在主對角線之上的對角線中的元素，k<0的值選擇在主對角線之下的對角線中的元素

array_diag = np.diag([10,20,30,40])
 print(array_diag)

Numpy檢視陣列屬性

陣列元素個數：b.size 或 np.size()

陣列形狀：b.shape 或 np.shape()

陣列維度：b.ndim

陣列元素型別：b.dtype

# 陣列元素個數：3
print(b.size)
# 陣列形狀:(3,)
print(b.shape)
# 陣列維度:1
print(b.ndim)
# 陣列元素型別:int32
print(b.dtype)

矩陣第一維的長度：shape[0] # 行

矩陣第二維的長度：shape[1] # 列

.......

 array_rand = np.random.rand(10,10,4)
 print(array_rand)
 print(array_rand.ndim)
 print(array_rand.shape[0])
 print(array_rand.shape[1])
 print(array_rand.shape[2])

Numpy建立隨機陣列（np.random）

均勻分佈

建立指定形狀的陣列，數值範圍在0~1之間

array_rand = np.random.rand(10,4)
 print(array_rand)
 print(array_rand.ndim)

建立指定範圍內的一個數：Numpy.random.uniform(low,high,size=None)

 array_uniform = np.random.uniform(0,size=5)
print(array_uniform)

建立指定範圍的一個整數：Numpy.random.randint(low,size=None)

array_int = np.random.randint(0,size=3)
print(array_int)
print(array_int.size)

Numpy.arange()和Numpy.linspace()函式也可以均勻分佈

Numpy.arange(start,stop,step)：建立一個秩為1的array，其中包含位於半開區間[start,stop)內並均勻分佈的值，step表示兩個相鄰值之間的差。

Numpy.linspace(start,N)：建立N個在閉區間[start,stop]內均勻分佈的值。

 X = np.arange(1,5,dtype=np.int)
 print(X)
 y = np.linspace(1,3)
 print(y)

正態分佈

建立給定均值、標準差、維度的正態分佈：Numpy.random.normal(loc,scale,size)

 # 正態生成4行5列的二位陣列
 array_normal = np.random.normal(loc=1.75,scale=0.1,size=[4,5])
 print(array_normal)
 print(array_normal.ndim)

Numpy陣列操作

陣列的索引

array[start : end]

array[start:]

array[:end]

布林型索引：array[array>10 & array<20]

 # 擷取第0至第3行，第2至第4列（從第0行第0列算起）
 after_array = array_normal[:3,2:4]
 print(after_array)

陣列的複製

Numpy.copy(引數 1：陣列)：建立給定array的一個副本，還可當做方法用。

after_array = array_normal[:3,2:4].copy()
copy_array = np.copy(array_normal[:,2:4])

Numpy.sort(引數 1：a，陣列；引數 2：axis=0/1，0表示行1表示列)：np.sort()作為函式使用時，不更改被排序的原始array；array.sort()作為方法使用時，會對原始array修改為排序後陣列array

 # 整體排序
 np.sort(array_normal)
 # 僅行排序
 np.sort(array_normal,axis=0)
 # 僅列排序
 np.sort(array_normal,axis=1)

陣列唯一元素

Numpy.unique(引數 1：a，陣列；引數 2：return_index=True/False，新列表元素在舊列表中的位置；引數 3：return_inverse=True/False，舊列表元素在新列表中的位置；引數 4：return_counts，元素的數量；引數 5：axis=0/1，0表示行1表示列)：查詢array中的唯一元素。

 print("提取唯一元素",np.unique(array_normal))
 print("提取唯一元素",np.unique(array_normal,return_index=True))
 print("提取唯一元素",return_counts=True))
 print("提取唯一元素",return_index=True,return_inverse=True,axis=0))

陣列的改變

陣列轉置

array_normal.T

reshape()：把指定的陣列改變形狀，但是元素個數不變；有返回值，即不對原始多維陣列進行修改

c = np.array([[[0,2],[10,12,13]],[[100,101,102],[110,113]]])
"""
[[[ 0 1]
 [ 2 10]]

 [[ 12 13]
 [100 101]]

 [[102 110]
 [112 113]]]
"""
print(c.reshape(3,2))
"""
[[ 0 1 2 10]
 [ 12 13 100 101]
 [102 110 112 113]]
"""
# 某一維指定為-1時，自動計算維度
print(c.reshape(3,-1))
"""[[[ 0 1]
 [ 2 10]
 [ 12 13]]

 [[100 101]
 [102 110]
 [112 113]]]"""
print(c.reshape(2,-1,2))

resize()：把指定的陣列改變形狀，但是元素個數可變，不足補0；無返回值，即對原始多維陣列進行修改

a = np.array([[[0,113]]])
b = np.array([[[0,113]]])
'''[[0]
 [1]
 [2]]'''
a.resize((3,1))
'''[[ 0 1 2 10 12]
 [ 13 100 101 102 110]
 [112 113 0 0 0]]'''
b.resize((3,5))
print(a)
print(b)

*Numpy計算

條件運算

Numpy.where(condition,x,y)：三目運算滿足condition，為x；不滿足condition，則為y

 score = np.array([[80,88],[82,81],[84,75],[86,83],[75,81]])
 # 如果數值小於80，替換為0，如果大於等於80，替換為90
 re_score = np.where(score < 80,90)
 print(re_score)

]統計運算

指定軸最大值：amax(引數1：陣列；引數2：axis=0/1，0表示行1表示列)

# 求整個矩陣的最大值
result = np.amax(score)
print(result)
# 求每一列的最大值（0表示行）
result = np.amax(score,axis=0)
print(result)
# 求每一行的最大值（1表示列）
result = np.amax(score,axis=1)
print(result)

指定軸最小值：amin(引數1：陣列；引數2：axis=0/1，0表示行1表示列)

# 求整個矩陣的最小值
result = np.amin(score)
print(result)
# 求每一列的最小值（0表示行）
result = np.amin(score,axis=0)
print(result)
# 求每一行的最小值（1表示列）
result = np.amin(score,axis=1)
print(result)

指定軸平均值：mean(引數1：陣列；引數2：axis=0/1，0表示行1表示列；引數3：dtype，輸出資料型別)

# 求整個矩陣的平均值
result = np.mean(score,dtype=np.int)
print(result)
# 求每一列的平均值（0表示行）
result = np.mean(score,axis=0)
print(result)
# 求每一行的平均值（1表示列）
result = np.mean(score,axis=1)
print(result)

指定軸方差：std(引數1：陣列；引數2：axis=0/1，0表示行1表示列；引數3：dtype，輸出資料型別)

# 求整個矩陣的方差
result = np.std(score)
print(result)
# 求每一列的方差（0表示列）
result = np.std(score,axis=0)
print(result)
# 求每一行的方差（1表示行）
result = np.std(score,axis=1)
print(result)

類似的，求和：Numpy.sum()，求中值：Numpy.median

陣列運算

陣列與數的運算（加、減、乘、除、取整、取模）

# 迴圈陣列行和列，每一個數值都加5
score[:,:] = score[:,:]+5
print(score)
# 迴圈陣列行和列，每一個數值都減5
score[:,:]-5
print(score)
# 迴圈陣列行和列，每一個數值都乘以5
score[:,:]*5
print(score)
# 迴圈陣列行和列，每一個數值都除以5
score[:,:]/5
print(score)
# 迴圈陣列行和列，每一個數值除以5取整
score[:,:] // 5
print(score)
# 迴圈陣列行和列，每一個數值除以5取模
score[:,:] % 5
print(score)

陣列間運算（加、減、乘、除），前提是兩個陣列的shape一樣

加：“+”或者np.add(a,b)　　減：“-”或者np.subtract(a,b)　　

乘：“*”或者np.multiply(a,b)　　除：“/”或者np.divide(a,b)

 c = score + score
 d = score - score
 e = score * score
 # 分母陣列保證每個數值不能為0
 b = score / score

Numpy.intersect1d(引數 1：陣列a；引數 2：陣列b)：查詢兩個陣列中的相同元素

Numpy.setdiff1d(引數 1：陣列a；引數 2：陣列b)：查詢在陣列a中不在陣列b中的元素

Numpy.union1d(引數 1：陣列a；引數 2：陣列b)：查詢兩個陣列的並集元素

矩陣運算（一種特殊的二維陣列）

計算規則

（M行，N列）*（N行，Z列）=（M行，Z列）

 st_score = np.array([[80,81]])
 # 平時成績佔40% 期末成績佔60%,計算結果
 q = np.array([[0.4],[0.6]])
 result = np.dot(st_score,q)
 print(result)

矩陣拼接

矩陣垂直拼接（前提兩個兩個矩陣列數相同，行數隨意）：vstack(引數：tuple)

v1 = [[0,3,4,5],[6,7,8,9,11]]
v2 = [[12,14,15,16,17],[18,19,21,22,23],23]]
result = np.vstack((v1,v2))
print(result)

矩陣水平拼接（前提兩個兩個矩陣行數相同，列數隨意）：hstack(引數：tuple)

 v1 = [[0,11]]
 v2 = [[12,23]]
 result = np.hstack((v1,v2))
 print(result)

矩陣刪除：Numpy.delete(引數 1：a，陣列；引數 2：elements，刪除的物件；引數 3：axis=0/1)

OriginalY = np.array([[1,3],[4,6],[7,9]])
 print(np.delete(OriginalY,[0,2]))
 print(np.delete(OriginalY,axis=0))
 print(np.delete(OriginalY,axis=1))

矩陣新增：Numpy.append(引數 1：array，陣列；引數 2： elements，新增元素；引數 3： axis=0/1)

OriginalY = np.array([[1,9]])
# 末尾新增元素
print(np.append(OriginalY,2]))
# 最後一行新增一行
print(np.append(OriginalY,[[0,11]],axis=0))
# 最後一列新增一列（注意新增元素格式）
print(np.append(OriginalY,[[0],[2],[11]],axis=1))

矩陣插入：Numpy.insert(引數 1：array，陣列；引數 2：index，插入位置索引；引數 3： elements，新增元素；引數 4： axis=0/1)

OriginalY = np.array([[1,9]])
print(np.insert(OriginalY,[11,10]))
print(np.insert(OriginalY,[[11,10]],axis=0))
# 在列索引1的位置插入（注意元素格式，跟新增格式不同）
print(np.insert(OriginalY,axis=1))

檔案載入

np.loadtxt(fname,dtype,comments='#',delimiter=None,skiprows=0,usecols=None)

fname:讀取的檔案、檔名

dtype：資料型別

comments：註釋

delimiter：分隔符，預設是空格

skiprows：跳過前幾行讀取，預設是0

usecols：讀取哪些列，usecols=（1， 2， 5）讀取第1,5列，預設所有列

到此這篇關於Python常用庫Numpy進行矩陣運算詳解的文章就介紹到這了,更多相關Python Numpy 矩陣運算內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！