介紹
我非常喜歡Python中的NumPy庫。在我的數據科學之旅中，我無數次依賴它來完成各種任務，從基本的數學運算到使用它進行圖像分類！
簡而言之，NumPy是Python中最基本的庫之一，也許是其中最有用的庫。NumPy高效地處理大型數據集。 作為一名數據科學家或一名有抱負的數據科學專業人士，我們需要對NumPy及其在Python中的工作原理有一個紮實的掌握。
在本文中，我將首先描述一下NumPy庫是什麼，以及為什麼你應該選擇它而不是繁瑣的Python列表。然後，我們將介紹一些最基本的NumPy操作，這些操作將使你喜歡這個很棒的庫！
目錄
NumPy庫是什麼？Python列表與NumPy數組有什麼區別？創建NumPy數組基本的ndarray全零數組全一數組ndarray中的隨機數定製的數組NumPy的Imatrix等間距的ndarrayNumPy數組的形狀與重塑NumPy數組的維數NumPy數組的形狀NumPy數組的大小重塑NumPy數組展開NumPy數組NumPy數組的轉置擴展和壓縮一個NumPy數組展開NumPy數組壓縮NumPy數組NumPy數組的索引與切片一維數組的切片二維數組切片三維數組切片NumPy數組的負切片堆疊和級聯Numpy數組堆疊ndarrays級聯ndarraysNumpy數組廣播NumPy Ufuncs用NumPy數組計算平均值、中位數和標準差最小最大值及其索引在NumPy數組中排序NumPy數組和圖像NumPy庫是什麼？
NumPy是Python數值庫，是Python編程中最有用的科學庫之一。它支持大型多維數組對象和各種工具。各種其他的庫，如Pandas、Matplotlib和Scikit-learn，都建立在這個令人驚嘆的庫之上。
數組是元素/值的集合，可以有一個或多個維度。一維數組稱為向量，二維數組稱為矩陣。
NumPy數組稱為ndarray或N維數組，它們存儲相同類型和大小的元素。它以其高性能而聞名，並在數組規模不斷擴大時提供高效的存儲和數據操作。
下載Anaconda時，NumPy會預先安裝。但是如果你想在你的機器上單獨安裝NumPy，只需在你的終端上鍵入以下命令：
pip install numpy現在需要導入庫：
import numpy as npnp實際上是數據科學界使用的NumPy的縮寫。
Python列表與NumPy數組有什麼區別？
如果你熟悉Python，你可能會想，既然我們已經有了Python列表，為什麼還要使用NumPy數組？畢竟，這些Python列表充當一個數組，可以存儲各種類型的元素。這是一個完全正確的問題，答案隱藏在Python在內存中存儲對象的方式中。
Python對象實際上是一個指向內存位置的指針，該內存位置存儲有關該對象的所有詳細信息，如字節和值。儘管這些額外的信息使Python成為一種動態類型語言，但它也付出了代價，這在存儲大量對象（如在數組中）時變得顯而易見。
Python列表本質上是一個指針數組，每個指針指向一個包含與元素相關信息的位置。這在內存和計算方面增加了很多開銷。當列表中存儲的所有對象都是同一類型時，大多數信息都是冗餘的！
為了解決這個問題，我們使用只包含同構元素的NumPy數組，即具有相同數據類型的元素。這使得它在存儲和操作數組方面更加高效。
當數組包含大量元素（比如數千或數百萬個元素）時，這種差異就變得明顯了。另外，使用NumPy數組，你可以執行元素操作，這是使用Python列表不可能做到的！
這就是為什麼在對大量數據執行數學操作時，NumPy數組比Python列表更受歡迎的原因。
創建NumPy數組
基本的ndarray
考慮到NumPy數組解決的複雜問題，它很容易創建。要創建一個非常基本的ndarray，可以使用np.array()方法。你只需將數組的值作為列表傳遞：
np.array([1,2,3,4])輸出：
array([1, 2, 3, 4])此數組包含整數值。可以在dtype參數中指定數據類型：
np.array([1,2,3,4],dtype=np.float32)輸出：
array([1., 2., 3., 4.], dtype=float32)由於NumPy數組只能包含同構數據類型，因此如果類型不匹配，則將向上轉換值：
np.array([1,2.0,3,4])輸出：
array([1., 2., 3., 4.])在這裡，NumPy將整數值上移到浮點值。
NumPy數組也可以是多維的。
np.array([[1,2,3,4],[5,6,7,8]])array([[1, 2, 3, 4], [5, 6, 7, 8]])在這裡，我們創建了一個二維數組。
註：矩陣只是一個NxM形狀的數字矩形數組，其中N是行數，M是矩陣中的列數。你剛才看到的是一個2x4矩陣。
全零數組
NumPy允許你使用 np.zeros()方法。你只需傳遞所需數組的形狀：
np.zeros(5)array([0., 0., 0., 0., 0.])上面一個是一維數組，下面一個是二維數組：
np.zeros((2,3))array([[0., 0., 0.], [0., 0., 0.]])全一數組
你還可以使用 np.ones()方法獲得全一數組：
np.ones(5,dtype=np.int32)array([1, 1, 1, 1, 1])ndarray中的隨機數
創建ndarray的另一個非常常用的方法是隨機隨機數方法。它創建一個給定形狀的數組，其隨機值來自[0,1]：
# 隨機的np.random.rand(2,3)array([[0.95580785, 0.98378873, 0.65133872], [0.38330437, 0.16033608, 0.13826526]])定製的數組
或者，實際上，可以使用 np.full()方法。只需傳入所需數組的形狀和所需的值：
np.full((2,2),7)array([[7, 7], [7, 7]])NumPy的Imatrix
另一個偉大的方法是np.eye()返回一個數組，其對角線上有1，其他地方都有0。
一個單位矩陣是一個正方形矩陣，它的主對角線上有1，其他地方都有0。下面是形狀為3x 3的單位矩陣。
註：正方形矩陣是N x N的形狀。這意味著它具有相同數量的行和列。
# 單位矩陣np.eye(3)array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]])但是，NumPy允許你靈活地更改對角線，值必須為1。你可以將其移到主對角線上方：
# 不是單位矩陣np.eye(3,k=1)array([[0., 1., 0.], [0., 0., 1.], [0., 0., 0.]])或將其移到主對角線下方：
np.eye(3,k=-2)array([[0., 0., 0.], [0., 0., 0.], [1., 0., 0.]])註：只有當1沿主對角線而不是任何其他對角線時，矩陣才稱為單位矩陣！
等間距的ndarray
你可以使用np.arange()方法：
np.arange(5)array([0, 1, 2, 3, 4])通過分別傳遞三個數字作為這些值的參數，可以顯式定義值間隔的開始、結束和步長。這裡要注意的一點是，間隔定義為[開始，結束)，其中最後一個數字將不包含在數組中：
np.arange(2,10,2)array([2, 4, 6, 8])由於步長定義為2，因此下圖展示了輸出的元素。注意，10不會列印出來，因為它是最後一個元素。
另一個類似的功能是 np.linspace()，但它將從間隔中獲取需要檢索的樣本數，而不是步長。這裡要注意的一點是，最後一個數字包含在返回的值中，這與np.arange()不同
np.linspace(0,1,5)array([0. , 0.25, 0.5 , 0.75, 1. ])太好了！現在你知道了如何使用NumPy創建數組。但了解數組的形狀也很重要。
NumPy數組的形狀與重塑
創建了ndarray之後，接下來要做的是檢查ndarray的軸數、形狀和大小。
NumPy數組的維數
可以使用ndims屬性輕鬆確定NumPy數組的維數或軸數：
# 軸數a = np.array([[5,10,15],[20,25,20]])print('Array :','\n',a)print('Dimensions :','\n',a.ndim)Array : [[ 5 10 15] [20 25 20]]Dimensions : 2這個數組有兩個維度：2行3列。
NumPy數組的形狀
形狀是NumPy數組的一個屬性，它顯示每個維度上有多少行元素。你可以進一步索引ndarray返回的形狀，以便沿每個維度獲取值：
a = np.array([[1,2,3],[4,5,6]])print('Array :','\n',a)print('Shape :','\n',a.shape)print('Rows = ',a.shape[0])print('Columns = ',a.shape[1])Array : [[1 2 3] [4 5 6]]Shape : (2, 3)Rows = 2Columns = 3NumPy數組的大小
可以使用size屬性確定數組中有多少值。它只是將行數乘以ndarray中的列數：
# size of arraya = np.array([[5,10,15],[20,25,20]])print('Size of array :',a.size)print('Manual determination of size of array :',a.shape[0]*a.shape[1])Size of array : 6Manual determination of size of array : 6
重塑NumPy數組
可以使用np.reshape()方法。它在不更改ndarray中的數據的情況下更改ndarray的形狀：
# 重塑a = np.array([3,6,9,12])np.reshape(a,(2,2))array([[ 3, 6], [ 9, 12]])在這裡，我將ndarray從一維重塑為二維ndarray。
重塑時，如果你不確定任何軸的形狀，只需輸入-1。當NumPy看到-1時，它會自動計算形狀：
a = np.array([3,6,9,12,18,24])print('Three rows :','\n',np.reshape(a,(3,-1)))print('Three columns :','\n',np.reshape(a,(-1,3)))Three rows : [[ 3 6] [ 9 12] [18 24]]Three columns : [[ 3 6 9] [12 18 24]]展開NumPy數組
有時，當你有多維數組並希望將其摺疊為一維數組時，可以使用 flatten()方法或ravel()方法：
a = np.ones((2,2))b = a.flatten()c = a.ravel()print('Original shape :', a.shape)print('Array :','\n', a)print('Shape after flatten :',b.shape)print('Array :','\n', b)print('Shape after ravel :',c.shape)print('Array :','\n', c)Original shape : (2, 2)Array : [[1. 1.] [1. 1.]]Shape after flatten : (4,)Array : [1. 1. 1. 1.]Shape after ravel : (4,)Array : [1. 1. 1. 1.]但是flatten() 和ravel()之間的一個重要區別是前者返回原始數組的副本，而後者返回對原始數組的引用。這意味著對ravel()返回的數組所做的任何更改也將反映在原始數組中，而flatten()則不會這樣。
b[0] = 0print(a)[[1. 1.] [1. 1.]]所做的更改沒有反映在原始數組中。
c[0] = 0print(a)[[0. 1.] [1. 1.]]但在這裡，更改後的值也反映在原始ndarray中。
這裡發生的事情是flatten()創建了ndarray的深層副本，而ravel()創建了ndarray的淺層副本。
深層副本意味著在內存中創建了一個全新的ndarray，flatten()返回的ndarray對象現在指向這個內存位置。因此，此處所做的任何更改都不會反映在原始ndarray中。
另一方面，淺拷貝返回對原始內存位置的引用。這意味著ravel()返回的對象指向與原始ndarray對象相同的內存位置。因此，毫無疑問，對該ndarray所做的任何更改也將反映在原始ndarray中。
NumPy數組的轉置
NumPy的另一個非常有趣的重塑方法是transpose()方法。它接受輸入數組並用列值交換行，用行值交換列值：
a = np.array([[1,2,3],[4,5,6]])b = np.transpose(a)print('Original','\n','Shape',a.shape,'\n',a)print('Expand along columns:','\n','Shape',b.shape,'\n',b)Original Shape (2, 3) [[1 2 3] [4 5 6]]Expand along columns: Shape (3, 2) [[1 4] [2 5] [3 6]]在轉置一個2x 3數組時，我們得到了一個3x2數組。轉置在線性代數中有著重要的意義。
擴展和壓縮一個NumPy數組
展開NumPy數組
通過提供要展開的數組和軸，可以使用expand_dims()方法將新軸添加到數組中：
# 展開維度a = np.array([1,2,3])b = np.expand_dims(a,axis=0)c = np.expand_dims(a,axis=1)print('Original:','\n','Shape',a.shape,'\n',a)print('Expand along columns:','\n','Shape',b.shape,'\n',b)print('Expand along rows:','\n','Shape',c.shape,'\n',c)Original: Shape (3,) [1 2 3]Expand along columns: Shape (1, 3) [[1 2 3]]Expand along rows: Shape (3, 1) [[1] [2] [3]]壓縮NumPy數組
另一方面，如果希望減小數組的軸，請使用squeeze()方法。它將刪除具有單個條目的軸。這意味著，如果創建了一個2 x 2 x 1矩陣，則squeze()將從矩陣中刪除第三個維度：
# squeezea = np.array([[[1,2,3],[4,5,6]]])b = np.squeeze(a, axis=0)print('Original','\n','Shape',a.shape,'\n',a)print('Squeeze array:','\n','Shape',b.shape,'\n',b)Original Shape (1, 2, 3) [[[1 2 3] [4 5 6]]]Squeeze array: Shape (2, 3) [[1 2 3] [4 5 6]]但是，如果你已經有一個2×2的矩陣，在這種情況下使用squeeze()會給你一個錯誤:
# squeezea = np.array([[1,2,3],[4,5,6]])b = np.squeeze(a, axis=0)print('Original','\n','Shape',a.shape,'\n',a)print('Squeeze array:','\n','Shape',b.shape,'\n',b)
NumPy數組的索引與切片
到目前為止，我們已經看到了如何創建一個NumPy數組以及如何處理它的形狀。在本節中，我們將看到如何使用索引和切片從數組中提取特定值。
一維數組的切片
切片意味著從一個索引檢索元素到另一個索引。我們要做的就是像這樣[start: end]
然而，你也可以定義步長。例如你可以將步長定義為2，這意味著讓元素遠離當前索引2個位置進行取值。
將所有這些內容合併到一個索引中看起來像這樣： [start：end：step-size]。
a = np.array([1,2,3,4,5,6])print(a[1:5:2])[2 4]注意，沒有考慮最後一個元素。這是因為切片包括開始索引，但不包括結束索引。
解決方法是將下一個更高的索引寫入要檢索的最終索引值：
a = np.array([1,2,3,4,5,6])print(a[1:6:2])[2 4 6]如果不指定起始索引或結束索引，則默認值分別為0或數組大小。默認情況下步長為1。
a = np.array([1,2,3,4,5,6])print(a[:6:2])print(a[1::2])print(a[1:6:])[1 3 5][2 4 6][2 3 4 5 6]二維數組切片
現在，二維數組有行和列，所以對二維數組進行切片會有點困難。但是一旦你理解了它，你就可以分割任何維度數組！
在學習如何分割二維數組之前，讓我們先看看如何從二維數組中檢索元素：
a = np.array([[1,2,3],[4,5,6]])print(a[0,0])print(a[1,2])print(a[1,0])164在這裡，我們提供了行值和列值來標識要提取的元素。在一維數組中，我們只提供列值，因為只有一行。
因此，要對二維數組進行切片，需要同時提到行和列的切片：
a = np.array([[1,2,3],[4,5,6]])# 列印第一行值print('First row values :','\n',a[0:1,:])# 具有列的步長print('Alternate values from first row:','\n',a[0:1,::2])# print('Second column values :','\n',a[:,1::2])print('Arbitrary values :','\n',a[0:1,1:3])First row values : [[1 2 3]]Alternate values from first row: [[1 3]]Second column values : [[2] [5]]Arbitrary values : [[2 3]]三維數組切片
到目前為止我們還沒有看到三維數組。首先讓我們想像一下三維數組的樣子：
a = np.array([[[1,2],[3,4],[5,6]],# 第一個軸數組[[7,8],[9,10],[11,12]],# 第二個軸數組[[13,14],[15,16],[17,18]]])# 第三個軸數組# 3-D arrayprint(a)[[[ 1 2] [ 3 4] [ 5 6]] [[ 7 8] [ 9 10] [11 12]] [[13 14] [15 16] [17 18]]]除了行和列之外，在二維數組中，三維數組還有一個深度軸，在這個深度軸上，它將一個二維數組放在另一個數組後面。所以，當你在切片一個三維數組時，你還需要提到你要切片哪個二維數組。這通常作為索引中的第一個值出現：
# valueprint('First array, first row, first column value :','\n',a[0,0,0])print('First array last column :','\n',a[0,:,1])print('First two rows for second and third arrays :','\n',a[1:,0:2,0:2])First array, first row, first column value : 1First array last column : [2 4 6]First two rows for second and third arrays : [[[ 7 8] [ 9 10]] [[13 14] [15 16]]]如果希望將值作為一維數組，則可以始終使用flatten()方法來完成此項工作！
print('Printing as a single array :','\n',a[1:,0:2,0:2].flatten())Printing as a single array : [ 7 8 9 10 13 14 15 16]NumPy數組的負切片
對數組進行切片的一個有趣的方法是使用負切片。負切片從末尾而不是開頭列印元素。請看下面：
a = np.array([[1,2,3,4,5],[6,7,8,9,10]])print(a[:,-1])[ 5 10]這裡，列印了每行的最後一個值。但是，如果我們想從末尾提取，我們必須顯式地提供負步長，否則結果將是空列表。
print(a[:,-1:-3:-1])[[ 5 4] [10 9]]儘管如此，切片的基本邏輯保持不變，即輸出中從不包含結束索引。
負切片的一個有趣的用途是反轉原始數組。
a = np.array([[1,2,3,4,5],[6,7,8,9,10]])print('Original array :','\n',a)print('Reversed array :','\n',a[::-1,::-1])Original array : [[ 1 2 3 4 5] [ 6 7 8 9 10]]Reversed array : [[10 9 8 7 6] [ 5 4 3 2 1]]也可以使用flip()方法來反轉ndarray。
a = np.array([[1,2,3,4,5],[6,7,8,9,10]])print('Original array :','\n',a)print('Reversed array vertically :','\n',np.flip(a,axis=1))print('Reversed array horizontally :','\n',np.flip(a,axis=0))Original array : [[ 1 2 3 4 5] [ 6 7 8 9 10]]Reversed array vertically : [[ 5 4 3 2 1] [10 9 8 7 6]]Reversed array horizontally : [[ 6 7 8 9 10] [ 1 2 3 4 5]]堆疊和級聯Numpy數組
堆疊ndarrays
可以通過組合現有數組來創建新數組。你可以通過兩種方式來完成：
使用vstack()方法垂直組合數組（即沿行），從而增加結果數組中的行數或者使用hstack()以水平方式（即沿列）組合數組，從而增加結果數組中的列數
a = np.arange(0,5)b = np.arange(5,10)print('Array 1 :','\n',a)print('Array 2 :','\n',b)print('Vertical stacking :','\n',np.vstack((a,b)))print('Horizontal stacking :','\n',np.hstack((a,b)))Array 1 : [0 1 2 3 4]Array 2 : [5 6 7 8 9]Vertical stacking : [[0 1 2 3 4] [5 6 7 8 9]]Horizontal stacking : [0 1 2 3 4 5 6 7 8 9]這裡要注意的一點是，組合數組的軸應該具有相同的大小，否則一定會出錯！
a = np.arange(0,5)b = np.arange(5,9)print('Array 1 :','\n',a)print('Array 2 :','\n',b)print('Vertical stacking :','\n',np.vstack((a,b)))print('Horizontal stacking :','\n',np.hstack((a,b)))
組合數組的另一個有趣的方法是使用dstack()方法。它按索引組合數組元素，並沿深度軸堆疊它們：
a = [[1,2],[3,4]]b = [[5,6],[7,8]]c = np.dstack((a,b))print('Array 1 :','\n',a)print('Array 2 :','\n',b)print('Dstack :','\n',c)print(c.shape)Array 1 : [[1, 2], [3, 4]]Array 2 : [[5, 6], [7, 8]]Dstack : [[[1 5] [2 6]] [[3 7] [4 8]]](2, 2, 2)
級聯ndarrays
雖然堆疊數組是組合舊數組以獲得新數組的一種方法，但也可以使用concatenate()方法，其中傳遞的數組沿現有軸連接：
a = np.arange(0,5).reshape(1,5)b = np.arange(5,10).reshape(1,5)print('Array 1 :','\n',a)print('Array 2 :','\n',b)print('Concatenate along rows :','\n',np.concatenate((a,b),axis=0))print('Concatenate along columns :','\n',np.concatenate((a,b),axis=1))Array 1 : [[0 1 2 3 4]]Array 2 : [[5 6 7 8 9]]Concatenate along rows : [[0 1 2 3 4] [5 6 7 8 9]]Concatenate along columns : [[0 1 2 3 4 5 6 7 8 9]]此方法的缺點是原始數組必須具有要合併的軸。否則，準備好迎接錯誤。
另一個非常有用的函數是append方法，它將新元素添加到ndarray的末尾。當你已經有了一個現有的ndarray，但希望向其添加新值時，這顯然很有用。
# 將值附加到ndarraya = np.array([[1,2], [3,4]])np.append(a,[[5,6]], axis=0)array([[1, 2], [3, 4], [5, 6]])Numpy數組廣播
廣播是ndarrays最好的功能之一。它允許你在不同大小的ndarray之間或ndarray與簡單數字之間執行算術運算！
廣播基本上延伸較小的ndarray，使其與較大ndarray的形狀相匹配：
a = np.arange(10,20,2)b = np.array([[2],[2]])print('Adding two different size arrays :','\n',a+b)print('Multiplying an ndarray and a number :',a*2)Adding two different size arrays : [[12 14 16 18 20] [12 14 16 18 20]]Multiplying an ndarray and a number : [20 24 28 32 36]它的工作可以看作是拉伸或複製標量，即數字，[2，2，2]以匹配ndarray的形狀，然後按元素執行操作。但是實際上並沒有生成該數組，這只是一種思考廣播如何運作的方式。
這非常有用，因為用標量值乘一個數組比用另一個數組更有效！需要注意的是，只有當兩個ndarray兼容時，它們才能一起廣播。
Ndarrays在以下情況下兼容：
兩者都有相同的尺寸其中一個ndarrays的維數是1。尺寸為1的廣播會滿足尺寸更大的ndarray的大小要求如果數組不兼容，你將得到一個ValueError。
a = np.ones((3,3))b = np.array([2])a+barray([[3., 3., 3.], [3., 3., 3.], [3., 3., 3.]])在這裡，假設第二個ndarray被拉伸成3x 3形狀，然後計算結果。
NumPy Ufuncs
Python是一種動態類型語言。這意味著在賦值時不需要知道變量的數據類型。Python將在運行時自動確定它。雖然這意味著編寫更乾淨、更容易的代碼，但也會使Python變得遲緩。
當Python必須重複執行許多操作（比如添加兩個數組）時，這個問題就會顯現出來。這是因為每次需要執行操作時，Python都必須檢查元素的數據類型。使用ufuncs函數的NumPy可以解決這個問題。
NumPy使這個工作更快的方法是使用向量化。向量化在編譯的代碼中以逐元素的方式對ndarray執行相同的操作。因此，不需要每次都確定元素的數據類型，從而執行更快的操作。
ufuncs是NumPy中的通用函數，只是數學函數。它們執行快速的元素功能。當對NumPy數組執行簡單的算術操作時，它們會自動調用，因為它們充當NumPy ufuncs的包裝器。
例如，當使用「+」添加兩個NumPy數組時，NumPy ufunc add()會在場景後面自動調用，並悄悄地發揮其魔力：
a = [1,2,3,4,5]b = [6,7,8,9,10]%timeit a+b
a = np.arange(1,6)b = np.arange(6,11)%timeit a+b
你可以看到，在NumPy ufuncs的幫助下，兩個數組的相同添加是如何在更短的時間內完成的！
用NumPy數組計算
下面是一些最重要和最有用的操作，你將需要在你的NumPy數組上執行這些操作。
NumPy數組的基本運算
基本的算術運算可以很容易地在NumPy數組上執行。要記住的重要一點是，這些簡單的算術運算符號只是作為NumPy ufuncs的包裝器。
print('Subtract :',a-5)print('Multiply :',a*5)print('Divide :',a/5)print('Power :',a**2)print('Remainder :',a%5)Subtract : [-4 -3 -2 -1 0]Multiply : [ 5 10 15 20 25]Divide : [0.2 0.4 0.6 0.8 1. ]Power : [ 1 4 9 16 25]Remainder : [1 2 3 4 0]平均值、中位數和標準差
要查找NumPy數組的平均值和標準偏差，請使用mean()、std()和median()方法：
a = np.arange(5,15,2)print('Mean :',np.mean(a))print('Standard deviation :',np.std(a))print('Median :',np.median(a))Mean : 9.0Standard deviation : 2.8284271247461903Median : 9.0最小最大值及其索引
使用Min()和Max()方法可以輕鬆找到ndarray中的Min和Max值：
a = np.array([[1,6],[4,3]])# 最小值print('Min :',np.min(a,axis=0))# 最大值print('Max :',np.max(a,axis=1))Min : [1 3]Max : [6 4]還可以使用argmin()和argmax()方法輕鬆確定ndarray中沿特定軸的最小值或最大值的索引：
a = np.array([[1,6,5],[4,3,7]])# 最小值print('Min :',np.argmin(a,axis=0))# 最大值print('Max :',np.argmax(a,axis=1))Min : [0 1 0]Max : [1 2]讓我給你把輸出分解一下。第一列的最小值是該列的第一個元素。對於第二列，它是第二個元素。對於第三列，它是第一個元素。
類似地，你可以確定最大值的輸出指示什麼。
在NumPy數組中排序
對於任何程式設計師來說，任何算法的時間複雜性都是最重要的。排序是一項重要且非常基本的操作，作為一名數據科學家，你可能每天都會用到它。因此，採用一種時間複雜度最小的排序算法是非常重要的。
當談到排序數組元素時，NumPy庫有一系列排序函數，可用於對數組元素進行排序。當你使用sort()方法時，它已經為你實現了快速排序、堆排序、合併排序和時間排序：
a = np.array([1,4,2,5,3,6,8,7,9])np.sort(a, kind='quicksort')array([1, 2, 3, 4, 5, 6, 7, 8, 9])你甚至可以沿著你想要的任何軸對數組進行排序：
a = np.array([[5,6,7,4], [9,2,3,7]])# 沿列排序print('Sort along column :','\n',np.sort(a, kind='mergresort',axis=1))# 沿行排序print('Sort along row :','\n',np.sort(a, kind='mergresort',axis=0))Sort along column : [[4 5 6 7] [2 3 7 9]]Sort along row : [[5 2 3 4] [9 6 7 7]]NumPy數組和圖像
NumPy數組在存儲和操作圖像數據方面有著廣泛的用途。但圖像數據到底是什麼呢？
圖像由以數組形式存儲的像素組成。每個像素的值介於0到255之間–0表示黑色像素，255表示白色像素。
彩色圖像由三個二維數組組成，每個彩色通道一個：紅色、綠色和藍色，背靠背放置，從而形成三維數組。數組中的每個值構成一個像素值。因此，數組的大小取決於每個維度上的像素數。
請看下圖：
Python可以使用scipy.misc.imread()方法（SciPy庫中的方法）。當我們輸出它時，它只是一個包含像素值的三維數組：
import numpy as npimport matplotlib.pyplot as pltfrom scipy import misc# 讀取圖像im = misc.imread('./original.jpg')# 圖像imarray([[[115, 106, 67], [113, 104, 65], [112, 103, 64], ..., [160, 138, 37], [160, 138, 37], [160, 138, 37]], [[117, 108, 69], [115, 106, 67], [114, 105, 66], ..., [157, 135, 36], [157, 135, 34], [158, 136, 37]], [[120, 110, 74], [118, 108, 72], [117, 107, 71], ...,我們可以檢查這個NumPy數組的形狀和類型：
print(im.shape)print(type(type))(561, 997, 3)numpy.ndarray現在，由於圖像只是一個數組，我們可以使用本文中介紹的數組函數輕鬆地對其進行操作。比如，我們可以使用np.flip()方法：
# 翻轉plt.imshow(np.flip(im, axis=1))
或者你可以規範化或更改像素值的範圍。這有時對更快的計算很有用。
im/255array([[[0.45098039, 0.41568627, 0.2627451 ], [0.44313725, 0.40784314, 0.25490196], [0.43921569, 0.40392157, 0.25098039], ..., [0.62745098, 0.54117647, 0.14509804], [0.62745098, 0.54117647, 0.14509804], [0.62745098, 0.54117647, 0.14509804]], [[0.45882353, 0.42352941, 0.27058824], [0.45098039, 0.41568627, 0.2627451 ], [0.44705882, 0.41176471, 0.25882353], ..., [0.61568627, 0.52941176, 0.14117647], [0.61568627, 0.52941176, 0.13333333], [0.61960784, 0.53333333, 0.14509804]], [[0.47058824, 0.43137255, 0.29019608], [0.4627451 , 0.42352941, 0.28235294], [0.45882353, 0.41960784, 0.27843137], ..., [0.6 , 0.52156863, 0.14117647], [0.6 , 0.52156863, 0.13333333], [0.6 , 0.52156863, 0.14117647]], ...,請記住，這是使用我們在文章中看到的ufuncs和廣播的相同概念！
當你使用神經網絡對圖像進行分類時，你可以做更多的事情來操作你的圖像。
結尾
我們在這篇文章中涉及了很多方面。希望你對NumPy數組的使用非常熟悉，並且非常熱衷於將其融入到日常的分析任務中。
要了解更多關於任何NumPy函數的信息，請查看他們的官方文檔，在那裡你可以找到每個函數的詳細描述。
文檔連結：https://numpy.org/doc/