NumPy用法總結

NumPy用法總結

快速瞭解NumPy

NumPy是一個開源的Python科學計算庫，用於快速處理任意維度的數組。
NumPy支持常見的數組和矩陣操作。對於同樣的數值計算任務，使用NumPy比直接使用Python要簡潔的多。
NumPy使用ndarray對象來處理多維數組，該對象是一個快速而靈活的大數據容器

優勢

1. 對於同樣的數值計算任務，使用Numpy要比直接編寫Python代碼便捷地多
2. NumPy中的數組的存儲效率和輸入輸出性能均遠遠優於Python中等價的基本數據結構，且能夠提升的性能是與數組中的元素成比例的
3. Numpy的大部分代碼都是用C語言寫的，其底層算法在設計時就有着優異的性能，這使得NumPy比純Python代碼高效地多

NumPy的Ndarray對象

創建一維數組

# 一維數組
import numpy as np

# 創建數組的多種形式

# 1. 直接傳入列表的形式進行創建
list1 = [1,2,3,4,5]
oneArray = np.array(list1)
print(type(oneArray))
print(oneArray)

# 2.傳入range()生成序列
t2 = np.array(range(10))
print(t2)
print(type(t2))

# 3. 使用numpy自帶的np.arange()生成數組
t3 = np.arange(0,10,2)
print(t3)
print(type(t3))

---

運行結果：
<class 'numpy.ndarray'>
[1 2 3 4 5]

[0 1 2 3 4 5 6 7 8 9]
<class 'numpy.ndarray'>

[0 2 4 6 8]
<class 'numpy.ndarray'>

---

創建二維數組

# 創建二維數組
import numpy as np
list2 = [[1,2],[3,4],[5,6]]

twoArray = np.array(list2)
print(twoArray)

---

運行結果：
[[1 2]
[3 4]
[5 6]]

---

常用屬性

# 常用屬性
import numpy as np

list2 = [[1,2],[3,4],[5,6]]

twoArray = np.array(list2)
print(twoArray)

# 獲取數組的維度（注意：與函數的參數很像）
print(twoArray.ndim)

# 形狀（行，列）
print(twoArray.shape)

# 有多少個元素
print(twoArray.size)

---

運行結果：
[[1 2]
[3 4]
[5 6]]

2

(3, 2)

6

---

調整數組的形狀

import numpy as np

four = np.array([[1,2,3],[4,5,6]])

print(four,four.shape,id(four))
# 修改的是原有的
# four.shape = (3,2)
# print(four)
# 修改返回一個新的數組
# five = four.reshape(3,2)
# print(four,id(five))
# print(four)

# 將多維數組變成一維數組
# 默認情況下 'C'以行爲主的順序展開，'F'（Fortran風格）意味着以列的順序展開
five = four.reshape((6,),order="F")
six = four.flatten(order='C')
print(five)
print(six)

---

運行結果：
[[1 2 3]
[4 5 6]] (2, 3) 2183058601424

[1 4 2 5 3 6]
[1 2 3 4 5 6]

---

# 維度的轉換
t = np.arange(24)
print(t)
print(t.shape)
# 轉化爲二維
t1 =t.reshape((4,6))
print(t1)
print(t1.shape)
# 轉化爲三維
t2 = t.reshape((2,3,4))
print(t2)
print(t2.shape)

---

運行結果：
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
(24,)

[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
(4, 6)

[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]

[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
(2, 3, 4)

---

將數組轉爲list

# 將數組轉化爲列表
a = np.array([9,12,88,14,25])
list_a = a.tolist()
print(list_a)
print(type(list_a))

---

運行結果：
[9, 12, 88, 14, 25]
<class 'list'>

---

數組的計算

數組和數的計算

# 數組的操作
t1 = np.arange(24).reshape((6,4))
t2 = np.arange(100,124).reshape((6,4))
print(t1)
print(t2)
print(t1+t2)
print(t1*t2)

---

運行結果：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]

[[100 101 102 103]
[104 105 106 107]
[108 109 110 111]
[112 113 114 115]
[116 117 118 119]
[120 121 122 123]]

[[100 102 104 106]
[108 110 112 114]
[116 118 120 122]
[124 126 128 130]
[132 134 136 138]
[140 142 144 146]]

[[ 0 101 204 309]
[ 416 525 636 749]
[ 864 981 1100 1221]
[1344 1469 1596 1725]
[1856 1989 2124 2261]
[2400 2541 2684 2829]]

---

數組與數組之間的操作

# 不同形狀的多維數組不可以進行計算
t1 = np.arange(24).reshape((4,6))
t2 = np.arange(18).reshape((3,6))
print(t1)
print(t2)
# print(t1-t2)

# 行數或列數相同的一維數組和多維數組也可以進行計算，直適合一維數組和多維數組的情況
# 行形狀相同
t1 = np.arange(24).reshape((4,6))
t2 = np.arange(0,6)
print(t1)
print(t2)
print(t1-t2)

---

運行結果：
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]

[0 1 2 3 4 5]

[[ 0 0 0 0 0 0]
[ 6 6 6 6 6 6]
[12 12 12 12 12 12]
[18 18 18 18 18 18]]

---

# 列形狀相同
t1 = np.arange(24).reshape((4,6))
t2 = np.arange(4).reshape((4,1))
print(t1)
print(t2)
print(t1+t2)

---

運行結果：
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]

[[0]
[1]
[2]
[3]]

[[ 0 1 2 3 4 5]
[ 7 8 9 10 11 12]
[14 15 16 17 18 19]
[21 22 23 24 25 26]]

---

數組中的軸

# 軸的理解
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a)

print(np.sum(a,axis=0))
print(np.sum(a,axis=1))

print(np.sum(a))

---

[[1 2 3]
[4 5 6]]

[5 7 9]

[ 6 15]

21

---

# 軸的理解之三維數組
a =  np.arange(27).reshape((3,3,3))
print('原三維數組')
print(a)
print('-----------')

b = np.sum(a,axis=0)
print('0軸')
print(b)
print('-----------')

c = np.sum(a,axis=1)
print('1軸')
print(c)
print('-----------')

d= np.sum(a,axis=2)
print('2軸')
print(d)
print('-----------')

---

運行結果：
原三維數組
[[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]]

[[ 9 10 11]
[12 13 14]
[15 16 17]]

[[18 19 20]
[21 22 23]
[24 25 26]]]

0軸
[[27 30 33]
[36 39 42]
[45 48 51]]

1軸
[[ 9 12 15]
[36 39 42]
[63 66 69]]

2軸
[[ 3 12 21]
[30 39 48]
[57 66 75]]

---

數組中的索引和切片

# 數組的索引和切片
# 一維數組
a = np.arange(10)
print(a)
# 冒號分隔切片參數 start:stop:step 來進行切片操作
print(a[2:7:2]) # 從索引 2 開始索引 到 7 停止（不包括7） 間隔爲 2

# 如果只放置一個參數 如[2]  將返回與該索引相對應的單個元素
print(a[2],a)

# 如果爲 [2:],表示從該索引（包括該索引）開始以後的所有項將都被提取
print(a[2:])

---

運行結果：
[0 1 2 3 4 5 6 7 8 9]

[2 4 6]

2 [0 1 2 3 4 5 6 7 8 9]

[2 3 4 5 6 7 8 9]

---

# 數組的索引之多維數組
t1 = np.arange(24).reshape(4,6)
print('原數組')
print(t1)
print('*'*20)
print('取一行')
print(t1[1]) # 取一行（一行代表一條數據，索引也是從0開始的）
print('取一行')
print(t1[1,:]) # 取一行 （根據行和列進行索取）
print("*"*20)
print('取連續的多行')
print(t1[1:])     #取連續的多行 和所有的列   取第二行以及以後的行數
print('取連續的多行')
print(t1[1:3,:])  #取連續的多行   取第二行，第三行，不取第四行
print('取不連續的多行')
print(t1[[1,3],:]) # 取不連續的多行
print("*"*20)
print('原數組')
print(t1)
print('取出一列')
print(t1[:,1]) # 取出一列  索引爲1 即第二列
print('取出連續的多列')
print(t1[:,1:])# 取出連續的多列 
print('取出不連續的多列')
print(t1[:,[0,2,3]]) # 取不連續的多列
print('取出某一個特定的值')
print(t1[3,4]) #取某一個特定的值，第四行第五列
print('取多個不連續的值')
print(t1[[0,1,1],[0,1,3]])

數組中的數值修改

t = np.arange(24).reshape(4,6)
print(t)
print()

# 修改某一行的值
t[1,:]=0
print(t)
print()

# 修改連續多行
t[1:3,:]=0
print(t)
print()

# 修改連續多列
t[:,1:4]=0
print(t)
print()

# 修改多個不相鄰的點
t[[0,3],[5,5]]=0
print(t)
print()

---

運行結果：
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]

[[ 0 1 2 3 4 5]
[ 0 0 0 0 0 0]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]

[[ 0 1 2 3 4 5]
[ 0 0 0 0 0 0]
[ 0 0 0 0 0 0]
[18 19 20 21 22 23]]

[[ 0 0 0 0 4 5]
[ 0 0 0 0 0 0]
[ 0 0 0 0 0 0]
[18 0 0 0 22 23]]

[[ 0 0 0 0 4 0]
[ 0 0 0 0 0 0]
[ 0 0 0 0 0 0]
[18 0 0 0 22 0]]

---

數組的添加、刪除、去重

# 數組的添加
'''
arr: 輸入的數組
values: 要向 arr 中添加的值 ，需要和 arr 形狀相同（除了要添加的軸）
axis : 默認爲None 不輸入時默認以一維數組的形式添加 
'''
a = np.array([[1,2,3],[4,5,6]])
print('第一個數組：')
print(a)
print('\n')

# 該添加方法會先把二維數組轉化爲一維數組，然後進行添加，結果是一維數組
print('向數組中添加元素：')
print(np.append(a,[7,8,9]))
print('\n')

print('沿0軸添加元素：')
print(np.append(a,[[7,8,9]],axis=0))
print('\n')

print('沿1軸添加元素')
print(np.append(a,[[5,5,5],[7,8,9]],axis=1))
print('\n')

---

運行結果：
第一個數組：
[[1 2 3]
[4 5 6]]

向數組中添加元素：
[1 2 3 4 5 6 7 8 9]

沿0軸添加元素：
[[1 2 3]
[4 5 6]
[7 8 9]]

沿1軸添加元素
[[1 2 3 5 5 5]
[4 5 6 7 8 9]]

---

# 數組的添加 insert 方法
import numpy as np

a = np.array([[1,2],[3,4],[5,6]])
print('第一個數組：')
print(a)
print('\n')

print('未傳遞 axis 參數。在插入參數 之前輸入數組會被展開')
# 插到索引位置之前
print(np.insert(a,3,[11,12]))
print('\n')

print('傳遞了 axis 參數。會廣播數組來匹配輸入數組')
print('沿 0 軸廣播：')
print(np.insert(a,1,[11],axis=0))
print('\n')

print('沿1軸廣播：')
print(np.insert(a,1,[11,12,13],axis=1))

---

運行結果：
第一個數組：
[[1 2]
[3 4]
[5 6]]

未傳遞 axis 參數。在插入參數 之前輸入數組會被展開
[ 1 2 3 11 12 4 5 6]

傳遞了 axis 參數。會廣播數組來匹配輸入數組
沿 0 軸廣播：
[[ 1 2]
[11 11]
[ 3 4]
[ 5 6]]

沿1軸廣播：
[[ 1 11 2]
[ 3 12 4]
[ 5 13 6]]

---

# 數組刪除 delete
'''
參數說明：
arr: 輸入的數組
obj: 可以被切片，整數或者整數數組 ，表明要從輸入數組刪除的子數組
axis : 沿着它刪除給定子數組的軸 ，如果未提供 ，則輸入數組會被展開
'''
a = np.arange(12).reshape(3,4)

print('第一個數組：')
print(a)
print('\n')

print('未傳遞 Axis 參數。 在刪除之前輸入數組會被展開')
# 根據索引進行刪除
print(np.delete(a,5))
print('\n')

print('刪除每一行中的第二列：')
print(np.delete(a,1,axis=1))
print('\n')

print('刪除每一列中的第一行：')
print(np.delete(a,0,axis=0))
print('\n')

---

運行結果：
第一個數組：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]

未傳遞 Axis 參數。 在刪除之前輸入數組會被展開
[ 0 1 2 3 4 6 7 8 9 10 11]

刪除每一行中的第二列：
[[ 0 2 3]
[ 4 6 7]
[ 8 10 11]]

刪除每一列中的第一行：
[[ 4 5 6 7]
[ 8 9 10 11]]

---

# 數組去重
'''
參數設置
arr: 輸入數組 ，如果不是一維數組 則會展開
return_index: 如果爲true ，返回新列表元素在舊的列表中的位置(下標)，並以列表形式儲存
return_inverse: 如果爲 true ,返回舊列表元素在新列表中的位置，並以列表形式儲存
return_counts : 如果爲 true ，返回去重數組中的元素在原數組出現次數 
'''
a = np.array([5,2,6,2,7,5,6,8,2,9])

print('第一個數組:')
print(a)
print('\n')

print('第一個數組的去重值：')
u = np.unique(a)
print(u)
print('\n')

print('新列表元素在舊的列表中的位置(下標)：')
u,indices = np.unique(a,return_index=True)
print(indices)
print('\n')

print('舊列表元素對應新列表的位置（下標）')
u,indices = np.unique(a,return_inverse=True)
print(u)
print(indices)
print(a)
print('\n')

print('返回去重元素的重複數量：')
u,indices = np.unique(a,return_counts=True)
print(u)
print(indices)

---

運行結果：
第一個數組:
[5 2 6 2 7 5 6 8 2 9]

第一個數組的去重值：
[2 5 6 7 8 9]

新列表元素在舊的列表中的位置(下標)：
[1 0 2 4 7 9]

舊列表元素對應新列表的位置（下標）
[2 5 6 7 8 9]
[1 0 2 0 3 1 2 4 0 5]
[5 2 6 2 7 5 6 8 2 9]

返回去重元素的重複數量：
[2 5 6 7 8 9]
[3 2 2 1 1 1]

---

numpy的計算

# numpy 的 計算
import numpy as np
score = np.array([[80,88],[82,83],[75,81]])

print('原數組：\n',score,'\n')

# 1. 獲取所有數據最大值
result = np.max(score)
print('整個數組的最大值',result,'\n')

# 獲取某一個軸上的數據最大值
result = np.max(score,axis=0)
print('獲取0軸上的數據最大值',result,'\n')

# 獲取最小值
result = np.min(score)
print("獲取整個數組的最小值：",result,'\n')

# 獲取某一個軸上的數據最小值
result = np.min(score,axis=1)
print('1軸上的最小值:',result,'\n')

# 數據的比較 
result = np.maximum([-2,-1,0,1,2],0) # 第一個參數中的每一個數與第二個參數比較返回大的
print('數據比較 返回大的',result,'\n')

result = np.minimum([-2,-1,0,1,2],0) # 第一個參數中的每一個數與第二個參數比較返回小的
print('數據比較 返回小的',result,'\n')

result = np.maximum([-2,-1,0,1,2],[1,-2,3,4,5]) # 接受兩個參數，可以大小一致 第二個參數只是
# 一個值時 利用維度的廣播機制
print('數據比較 返回大的',result,'\n')

# 求取平均值
result = np.mean(score) #獲取所有數據的平均值
print('獲取所有數據的平均值',result,'\n')
result = np.mean(score,axis=0)
print('獲取某一行或某一列的平均值',np.mean(score,axis=0),np.mean(score,axis=1),'\n')

# 返回給定axis上的累計和
#axis=0，代表以行方式掃描，第一次掃描第一行，第二次掃描第二行，以此類推。
#第一行掃描時，沒有前幾行可累加，所以數值不變。掃描到第二行，累加前幾行，以此類推。
arr = np.array([[1,2,3],[4,5,6]])
print('數組：\n',arr,'\n')
print(arr.cumsum(0),'\n')
print(arr.cumsum(1),'\n')

#  argmin 求最小值索引
result = np.argmin(score,axis=0)
print(result,'\n')
#  求每列的標準差
result = np.std(score,axis=0)
print('每列的標準差',result,'\n')

# 極值
print('最大值和最小值的差',np.ptp(score,axis=None))

# 擴展: 方差 var , 協方差 cov ,計算平均值 average, 計算中位數 median

數組的拼接

# 數組的拼接
#  1. 根據軸連接的數組序列
a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])

# 要求 a,b 兩個數組的維度相同
print('沿0軸連接兩個數組：')
print(np.concatenate((a,b),axis=0))
print('\n')
print('沿 1 軸 連接兩個數組：')
print(np.concatenate((a,b),axis=1),'\n')

# 根據軸進行堆疊
print(a)
print(b)
print('沿 0 軸 連接兩個數組:')
print(np.stack((a,b),axis=0))
print('\n')
print('沿 1 軸 連接兩個數組:')
print(np.stack((a,b),axis=1))

# 矩陣 垂直拼接
v1 = [[0,1,2,3,4,5],[6,7,8,9,10,11]]
v2 = [[12,13,14,15,16,17],[18,19,20,21,22,23]]

result = np.vstack((v1,v2))
print(result)

# 矩陣水平拼接
print(np.hstack((v1,v2)))

數組的分割

# 將一個數組分割成多個子數組
'''
參數說明:
arr: 被分割的數組
indices_or_sections：如果是一個整數，就用該數平均切分，如果是一個數組，爲沿軸切分位置（左開右閉）
axis: 沿着哪個維度進行切分，默認是0 ，橫向切分。爲1時，縱向切分
'''
arr = np.arange(9).reshape(3,3)
print('將數組分成三個大小相等的子數組：')
b = np.split(arr,3)
print(b)

# 2. numpy.hsplit 函數用於水平分割數組，通過指定要返回的相同形狀的數組數量來拆分原數組
# floor() 返回數字的下舍整數
harr = np.floor(10 * np.random.random((2,6)))
print('原 array ')
print(harr)
print('拆分後：')
print(np.hsplit(harr,3))

#  numpy.vsplit:沿着垂直軸分割
a = np.arange(16).reshape(4,4)
print('第一個數組：')
print(a)
print('\n')

print('沿着垂直軸分割：')
b = np.vsplit(a,2)
print(b)

---

運行結果：
將數組分成三個大小相等的子數組：
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]
原 array
[[4. 2. 2. 2. 8. 6.]
[7. 3. 8. 7. 6. 0.]]
拆分後：
[array([[4., 2.],
[7., 3.]]), array([[2., 2.],
[8., 7.]]), array([[8., 6.],
[6., 0.]])]
第一個數組：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]

豎直分割：
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]

---

數組中的nan 和 inf

#  nan（缺失的數據） inf(無窮大)
#  創建一個nan 和 inf

a = np.nan # 空值（缺失數據）
b = np.inf # 無窮大
print(a,type(a))
print(b,type(b))

# 判斷數組中爲nan的個數 （注意：float類型的數據才能賦值 nan）
t = np.arange(24,dtype=float).reshape(4,6)
print(t)
# 可以使用 np.count_nonzero()來判斷非零的個數
print(np.count_nonzero(t))
# 將三行四列的數改成 nan
t[3,4] = np.nan
print(t)
# 並且 np.nan != np.nan 結果是True  np.nan == np.nan False 結合這個性質進行判斷
print(np.count_nonzero(t != t))
print('isnan:',np.isnan(t))

# 注意：nan 和任何數計算都爲 nan
print(np.sum(t,axis=0))

# 將 nan 替換成 0 
t[np.isnan(t)] = 0
print(t)
print('*' * 30)

# 練習 ：處理數組中的nan
t = np.arange(24).reshape(4,6).astype('float')
# 將數組中的一部分替換成 nan
t[1,3:] = np.nan
print(t)
# 遍歷每一列 ,然後判斷每一列 是否有nan
# t.shape[1] s數組中的總列數
print(t.shape[1])
for i in range(t.shape[1]):
    temp_col = t[:,i]
    nan_num = np.count_nonzero(temp_col != temp_col)
    if nan_num != 0:
        # 取出這一列中不爲nan的元素
        temp_col_not_nan = temp_col[temp_col==temp_col]
        # 將nan替換成這一列的平均值   
        # np.isnan(temp_col) : 參數：數組 返回nan的索引
        temp_col[np.isnan(temp_col)] = np.mean(temp_col_not_nan)
print(t)

---

運行結果：
nan <class 'float'>
inf <class 'float'>
[[ 0. 1. 2. 3. 4. 5.]
[ 6. 7. 8. 9. 10. 11.]
[12. 13. 14. 15. 16. 17.]
[18. 19. 20. 21. 22. 23.]]
23
[[ 0. 1. 2. 3. 4. 5.]
[ 6. 7. 8. 9. 10. 11.]
[12. 13. 14. 15. 16. 17.]
[18. 19. 20. 21. nan 23.]]
1
isnan: [[False False False False False False]
[False False False False False False]
[False False False False False False]
[False False False False True False]]
[36. 40. 44. 48. nan 56.]
[[ 0. 1. 2. 3. 4. 5.]
[ 6. 7. 8. 9. 10. 11.]
[12. 13. 14. 15. 16. 17.]
[18. 19. 20. 21. 0. 23.]]

---

[[ 0. 1. 2. 3. 4. 5.]
[ 6. 7. 8. nan nan nan]
[12. 13. 14. 15. 16. 17.]
[18. 19. 20. 21. 22. 23.]]
6
[[ 0. 1. 2. 3. 4. 5.]
[ 6. 7. 8. 13. 14. 15.]
[12. 13. 14. 15. 16. 17.]
[18. 19. 20. 21. 22. 23.]]

---

二維數組的轉置

# 二維數組的轉置
a = np.arange(12).reshape(3,4)

print('原數組:')
print(a)
print('\n')

print('對換數組:')
print(np.transpose(a))

# 與 transpose 一致
print('轉置數組：')
print(a.T)
print('\n')

# 函數用於交換數組的兩個軸
t1 = np.arange(24).reshape(4,6)
re = t1.swapaxes(1,0)
print('原數組：')
print(t1)
print('\n')

print('調用 swapaxes 函數後的數組：')
print(re)