概述

• NumPy是一個Python庫，每個數據科學專業人員都應該熟悉它
• 這個全面的NumPy教程從頭開始介紹NumPy，從基本的數學運算到NumPy如何處理圖像數據
• 本文中有大量的Numpy概念和Python代碼

介紹

我非常喜歡Python中的NumPy庫。在我的數據科學之旅中，我無數次依賴它來完成各種任務，從基本的數學運算到使用它進行圖像分類！

簡而言之，NumPy是Python中最基本的庫之一，也許是其中最有用的庫。NumPy高效地處理大型數據集。 作為一名數據科學家或一名有抱負的數據科學專業人士，我們需要對NumPy及其在Python中的工作原理有一個扎實的掌握。

在本文中，我將首先描述一下NumPy庫是什么，以及為什么你應該選擇它而不是繁瑣的Python列表。然后，我們將介紹一些最基本的NumPy操作，這些操作將使你喜歡這個很棒的庫！

目錄

• NumPy庫是什么？
• Python列表與NumPy數組有什么區別？

• 創建NumPy數組

  • 基本的ndarray
  • 全零數組
  • 全一數組
  • ndarray中的隨機數
  • 定制的數組
  • NumPy的Imatrix
  • 等間距的ndarray

• NumPy數組的形狀與重塑

  • NumPy數組的維數
  • NumPy數組的形狀
  • NumPy數組的大小
  • 重塑NumPy數組
  • 展開NumPy數組
  • NumPy數組的轉置

• 擴展和壓縮一個NumPy數組

  • 展開NumPy數組
  • 壓縮NumPy數組

• NumPy數組的索引與切片

  • 一維數組的切片
  • 二維數組切片
  • 三維數組切片
  • NumPy數組的負切片

• 堆疊和級聯Numpy數組

  • 堆疊ndarrays
  • 級聯ndarrays
• Numpy數組廣播
• 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?np

np實際上是數據科學界使用的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 = 2 Columns = 3

NumPy數組的大小

可以使用size屬性確定數組中有多少值。它只是將行數乘以ndarray中的列數：

# size of array a = 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 : 6 Manual 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] = 0 print(a) [[1. 1.][1. 1.]]

所做的更改沒有反映在原始數組中。

c[0] = 0 print(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()將從矩陣中刪除第三個維度：

# squeeze a = 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()會給你一個錯誤:

# squeeze a = 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]) 1 6 4

在這里，我們提供了行值和列值來標識要提取的元素。在一維數組中，我們只提供列值，因為只有一行。

因此，要對二維數組進行切片，需要同時提到行和列的切片：

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 array print(a) [[[ 1 2][ 3 4][ 5 6]][[ 7 8][ 9 10][11 12]][[13 14][15 16][17 18]]]

除了行和列之外，在二維數組中，三維數組還有一個深度軸，在這個深度軸上，它將一個二維數組放在另一個數組后面。所以，當你在切片一個三維數組時，你還需要提到你要切片哪個二維數組。這通常作為索引中的第一個值出現：

# value print('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 : 1 First 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，但希望向其添加新值時，這顯然很有用。

# 將值附加到ndarray a = 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+b array([[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.0 Standard deviation : 2.8284271247461903 Median : 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 np import matplotlib.pyplot as plt from scipy import misc# 讀取圖像 im = misc.imread('./original.jpg') # 圖像 im array([[[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/255 array([[[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和廣播的相同概念！

當你使用神經網絡對圖像進行分類時，你可以做更多的事情來操作你的圖像。

結尾

如需更多資料或網課資源，請添加微信號：shuguangzhanzheng （涵蓋Java、web全棧、Ai深度學習、機器學習開發、前端、安卓等：慕課網,極客時間,開課吧,達內,老男孩,博學谷,咕泡學院,龍果學院,谷粒學院,馬士兵Java,尚硅谷,圣思園,貪心學院,萬門大學,圖靈學院,魯班學院,傳播智客,北風網,小碼哥,小象學院,51CTO,珠峰前端,拉鉤教育CSDN學院,麥子學院,蠻牛學院,陽明k8s,李振良k8s,百度前端學院等180TB網課資源）

?

我們在這篇文章中涉及了很多方面。希望你對NumPy數組的使用非常熟悉，并且非常熱衷于將其融入到日常的分析任務中。

要了解更多關于任何NumPy函數的信息，請查看他們的官方文檔，在那里你可以找到每個函數的詳細描述。

文檔鏈接：https://numpy.org/doc/

原文鏈接：https://www.analyticsvidhya.c...

歡迎關注磐創AI博客站：
http://panchuang.net/

sklearn機器學習中文官方文檔：
http://sklearn123.com/

歡迎關注磐創博客資源匯總站：
http://docs.panchuang.net/

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的全网最全的Numpy开发入门教程（详细案例版）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。