詞彙表#

(n,)#

一個括號中的數字後接逗號，表示一個單元素元組。尾隨的逗號將單元素元組與括號中的 n 區分開來。

-1#

在維度條目中，指示 NumPy 選擇保持陣列元素總數不變的長度。
```
>>> np.arange(12).reshape(4, -1).shape
(4, 3)
```
在索引中，任何負值表示從右側開始索引。

…#

一個 Ellipsis。

當索引陣列時，簡寫表示缺少的軸（如果存在）是完整切片。

>>> a = np.arange(24).reshape(2,3,4)

>>> a[...].shape
(2, 3, 4)

>>> a[...,0].shape
(2, 3)

>>> a[0,...].shape
(3, 4)

>>> a[0,...,0].shape
(3,)

它最多可以使用一次；a[...,0,...] 會引發 IndexError。

在列印輸出中，NumPy 用 ... 替換大型陣列的中間元素。要查看整個陣列，請使用 numpy.printoptions

:#

Python 切片運算子。在 ndarray 中，切片可以應用於每個軸

>>> a = np.arange(24).reshape(2,3,4)
>>> a
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

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

>>> a[1:,-2:,:-1]
array([[[16, 17, 18],
        [20, 21, 22]]])

尾隨的切片可以省略

>>> a[1] == a[1,:,:]
array([[ True,  True,  True,  True],
       [ True,  True,  True,  True],
       [ True,  True,  True,  True]])

與 Python 中切片建立副本不同，在 NumPy 中，切片建立一個視圖。

詳細資訊請參閱組合進階索引和基本索引。

<#

在 dtype 宣告中，表示資料為小端序（括號在右邊較大）。

>>> dt = np.dtype('<f')  # little-endian single-precision float

>#

在 dtype 宣告中，表示資料為大端序（括號在左邊較大）。

>>> dt = np.dtype('>H')  # big-endian unsigned short

進階索引#

軸可以使用陣列而不是使用純量或切片作為索引進行索引，從而提供細粒度的選擇。這被稱為進階索引或“花式索引”。

沿著軸#

沿著陣列 a 的軸 n 的操作，其行為就像其參數是 a 的切片陣列，其中每個切片都有軸 n 的連續索引。

例如，如果 a 是一個 3 x N 陣列，沿著軸 0 的操作，其行為就像其參數是一個包含每行切片的陣列

>>> np.array((a[0,:], a[1,:], a[2,:])) 

為了使其具體化，我們可以選擇操作為陣列反轉函數 numpy.flip，它接受一個 axis 參數。我們建構一個 3 x 4 陣列 a

>>> a = np.arange(12).reshape(3,4)
>>> a
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

沿著軸 0（行軸）反轉產生

>>> np.flip(a,axis=0)
array([[ 8,  9, 10, 11],
       [ 4,  5,  6,  7],
       [ 0,  1,  2,  3]])

回顧沿著軸的定義，沿著軸 0 的 flip 將其參數視為

>>> np.array((a[0,:], a[1,:], a[2,:]))
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

並且 np.flip(a,axis=0) 的結果是反轉切片

>>> np.array((a[2,:],a[1,:],a[0,:]))
array([[ 8,  9, 10, 11],
       [ 4,  5,  6,  7],
       [ 0,  1,  2,  3]])

陣列#

在 NumPy 文件中與 ndarray 同義使用。

類陣列 (array_like)#

任何可以解釋為 ndarray 的純量或序列。除了 ndarray 和純量之外，此類別還包括列表（可能是巢狀的且具有不同的元素類型）和元組。numpy.array 接受的任何參數都是類陣列。

>>> a = np.array([[1, 2.0], [0, 0], (1+1j, 3.)])

>>> a
array([[1.+0.j, 2.+0.j],
       [0.+0.j, 0.+0.j],
       [1.+1.j, 3.+0.j]])

陣列純量 (array scalar)#

陣列純量是 float32、float64 等類型/類別的實例。為了處理運算元的統一性，NumPy 將純量視為零維陣列。相反，0 維陣列是一個 ndarray 實例，其中僅包含一個值。

軸 (axis)#

陣列維度的另一個術語。軸從左到右編號；軸 0 是形狀元組中的第一個元素。

在二維向量中，軸 0 的元素是行，軸 1 的元素是列。

在更高維度中，情況會發生變化。NumPy 將更高維度的向量列印為逐行逐列的建構區塊的複製品，如下面的三維向量所示

>>> a = np.arange(12).reshape(2,2,3)
>>> a
array([[[ 0,  1,  2],
        [ 3,  4,  5]],
       [[ 6,  7,  8],
        [ 9, 10, 11]]])

a 被描繪為一個雙元素陣列，其元素是 2x3 向量。從這個角度來看，行和列分別是任何形狀中的最後兩個軸。

此規則可幫助您預測向量的列印方式，反之亦然，如何找到任何列印元素的索引。例如，在範例中，8 的索引的最後兩個值必須是 0 和 2。由於 8 出現在兩個 2x3 的第二個中，因此第一個索引必須是 1

>>> a[1,0,2]
8

在列印的向量中計算維度的便捷方法是計算左括號後面的 [ 符號。這在區分例如 (1,2,3) 形狀與 (2,3) 形狀時很有用

>>> a = np.arange(6).reshape(2,3)
>>> a.ndim
2
>>> a
array([[0, 1, 2],
       [3, 4, 5]])

>>> a = np.arange(6).reshape(1,2,3)
>>> a.ndim
3
>>> a
array([[[0, 1, 2],
        [3, 4, 5]]])

.base#

如果陣列不擁有其記憶體，則其 base 屬性會傳回陣列正在參考記憶體的物件。該物件可能正在參考來自另一個物件的記憶體，因此擁有物件可能是 a.base.base.base...。有些作者錯誤地聲稱測試 base 可以確定陣列是否為視圖。正確的方法請參閱 numpy.shares_memory。

大端序 (big-endian)#

請參閱位元組序。

BLAS#

基本線性代數子程式

廣播 (broadcast)#

廣播是 NumPy 處理不同大小的 ndarray，如同它們都是相同大小的能力。

它允許優雅的「做我所想」行為，例如，將純量加到向量會將純量值加到每個元素。

>>> a = np.arange(3)
>>> a
array([0, 1, 2])

>>> a + [3, 3, 3]
array([3, 4, 5])

>>> a + 3
array([3, 4, 5])

通常，向量運算元必須都具有相同的大小，因為 NumPy 逐元素地工作 – 例如，c = a * b 是

 c[0,0,0] = a[0,0,0] * b[0,0,0]
 c[0,0,1] = a[0,0,1] * b[0,0,1]
...

但在某些有用的情況下，NumPy 可以沿著「遺失」的軸或「太短」的維度複製資料，以便形狀匹配。複製不會消耗記憶體或時間。詳細資訊請參閱廣播。

C 順序 (C order)#

與 row-major 相同。

類型轉換 (casting)#

將陣列資料從一種 dtype 轉換為另一種 dtype 的過程。存在多種類型轉換模式，由以下類型轉換規則定義

no：資料類型完全不應轉換。陣列之間資料類型有任何不符都會引發 TypeError。
equiv：僅允許位元組順序變更。
safe：僅允許可以保留值的轉換。允許向上轉換（例如，從 int 到 float），但不允許向下轉換。
same_kind：「same_kind」轉換選項允許安全轉換和種類內的轉換，例如 float64 到 float32。
unsafe：可以進行任何資料轉換。

行優先 (column-major)#

請參閱行優先與列優先順序。

連續 (contiguous)#

如果陣列符合以下條件，則為連續的

它佔用一塊連續的記憶體區塊，並且
索引較高的陣列元素佔用較高的位址（也就是說，沒有步幅為負值）。

有兩種適當的連續 NumPy 陣列

Fortran-連續陣列指的是以列方式儲存的資料，即資料在記憶體中儲存的索引從最低維度開始；
C-連續或簡稱為連續陣列，指的是以行方式儲存的資料，即資料在記憶體中儲存的索引從最高維度開始。

對於一維陣列，這些概念是一致的。

例如，如果 2x2 陣列 A 的元素以以下順序儲存在記憶體中，則它是 Fortran-連續的

A[0,0] A[1,0] A[0,1] A[1,1]

如果順序如下，則是 C-連續的

A[0,0] A[0,1] A[1,0] A[1,1]

要測試陣列是否為 C-連續的，請使用 NumPy 陣列的 .flags.c_contiguous 屬性。要測試 Fortran 連續性，請使用 .flags.f_contiguous 屬性。

副本 (copy)#

請參閱視圖。

維度 (dimension)#

請參閱軸。

dtype#

描述 ndarray 中（相同類型）元素的資料類型。可以變更它以重新解釋陣列內容。詳細資訊請參閱資料類型物件 (dtype)。

花式索引 (fancy indexing)#

另一個進階索引的術語。

欄位 (field)#

在結構化資料類型中，每個子類型都稱為欄位。欄位具有名稱（字串）、類型（任何有效的 dtype）和可選的標題。請參閱資料類型物件 (dtype)。

Fortran 順序 (Fortran order)#

與行優先相同。

扁平化 (flattened)#

請參閱 ravel。

同質 (homogeneous)#

同質陣列的所有元素都具有相同的類型。ndarray 與 Python 列表相反，是同質的。類型可能很複雜，例如在結構化陣列中，但所有元素都具有該類型。

NumPy 物件陣列，其中包含對 Python 物件的參考，填補了異質陣列的角色。

itemsize#

dtype 元素的大小（以位元組為單位）。

小端序 (little-endian)#

請參閱位元組序。

遮罩 (mask)#

用於僅選擇某些元素進行操作的布林陣列

>>> x = np.arange(5)
>>> x
array([0, 1, 2, 3, 4])

>>> mask = (x > 2)
>>> mask
array([False, False, False, True,  True])

>>> x[mask] = -1
>>> x
array([ 0,  1,  2,  -1, -1])

遮罩陣列 (masked array)#

透過將錯誤或遺失的資料放入遮罩陣列中，可以乾淨俐落地忽略它們，遮罩陣列具有指示無效條目的內部布林陣列。使用遮罩陣列的操作會忽略這些條目。

>>> a = np.ma.masked_array([np.nan, 2, np.nan], [True, False, True])
>>> a
masked_array(data=[--, 2.0, --],
             mask=[ True, False,  True],
       fill_value=1e+20)

>>> a + [1, 2, 3]
masked_array(data=[--, 4.0, --],
             mask=[ True, False,  True],
       fill_value=1e+20)

詳細資訊請參閱遮罩陣列。

矩陣 (matrix)#

NumPy 的二維矩陣類別不應再使用；請使用常規 ndarray。

ndarray#

NumPy 的基本結構.

物件陣列 (object array)#

dtype 為 object 的陣列；也就是說，它包含對 Python 物件的參考。索引陣列會取消參考 Python 物件，因此與其他 ndarray 不同，物件陣列具有容納異質物件的能力。

ravel#

numpy.ravel 和 numpy.flatten 都會扁平化 ndarray。ravel 會在可能的情況下傳回視圖；flatten 始終傳回副本。

扁平化將多維陣列摺疊成單個維度；如何完成此操作的詳細資訊（例如，a[n+1] 應該是下一行還是下一列）是參數。

記錄陣列 (record array)#

一種結構化陣列，除了 a['field'] 之外，還允許以屬性樣式 (a.field) 存取。詳細資訊請參閱 numpy.recarray.

行優先 (row-major)#

請參閱行優先與列優先順序。NumPy 預設以行優先順序建立陣列。

純量 (scalar)#

在 NumPy 中，通常是陣列純量的同義詞。

形狀 (shape)#

一個元組，顯示 ndarray 每個維度的長度。元組本身的長度是維度的數量 (numpy.ndim)。元組元素的乘積是陣列中元素的數量。詳細資訊請參閱 numpy.ndarray.shape。

步幅 (stride)#

實體記憶體是一維的；步幅提供了一種機制，將給定的索引對應到記憶體中的位址。對於 N 維陣列，其 strides 屬性是一個 N 元素元組；在軸 n 上從索引 i 前進到索引 i+1 表示將 a.strides[n] 位元組加到位址。

步幅是根據陣列的 dtype 和形狀自動計算的，但可以使用 as_strided. 直接指定。

詳細資訊請參閱 numpy.ndarray.strides。

要了解步幅如何作為 NumPy 視圖的底層基礎，請參閱 The NumPy array: a structure for efficient numerical computation.

結構化陣列 (structured array)#

其 dtype 為結構化資料類型的陣列。

結構化資料類型 (structured data type)#

使用者可以建立任意複雜的 dtype，其中可以包含其他陣列和 dtype。這些複合 dtype 稱為結構化資料類型。

子陣列 (subarray)#

巢狀在結構化資料類型中的陣列，如這裡的 b

>>> dt = np.dtype([('a', np.int32), ('b', np.float32, (3,))])
>>> np.zeros(3, dtype=dt)
array([(0, [0., 0., 0.]), (0, [0., 0., 0.]), (0, [0., 0., 0.])],
      dtype=[('a', '<i4'), ('b', '<f4', (3,))])

子陣列資料類型 (subarray data type)#

結構化資料類型的一個元素，其行為類似於 ndarray。

標題 (title)#

結構化資料類型中欄位名稱的別名。

類型 (type)#

在 NumPy 中，通常是 dtype 的同義詞。對於更通用的 Python 意義，請參閱此處。

ufunc#

NumPy 快速的逐元素計算 (向量化) 提供了一個選擇，可以應用哪個函數。函數的通用術語是 ufunc，是 universal function 的縮寫。NumPy 常式具有內建的 ufunc，但使用者也可以編寫自己的。

向量化 (vectorization)#

NumPy 將陣列處理交給 C 語言，在那裡迴圈和計算比在 Python 中快得多。為了利用這一點，使用 NumPy 的程式設計師消除了 Python 迴圈，轉而使用陣列到陣列的操作。向量化既可以指 C 語言的卸載，也可以指建構 NumPy 程式碼以利用它。

視圖 (view)#

在不接觸底層資料的情況下，NumPy 可以使一個陣列看起來改變其資料類型和形狀。

以這種方式建立的陣列是視圖，NumPy 通常會利用使用視圖而不是建立新陣列的效能提升。

潛在的缺點是寫入視圖也可能會更改原始陣列。如果這是一個問題，NumPy 而是需要建立一個物理上不同的陣列 – 一個 副本。

某些 NumPy 常式始終傳回視圖，某些始終傳回副本，某些可能會傳回其中之一，而對於某些常式，可以指定選擇。管理視圖和副本的責任落在程式設計師身上。numpy.shares_memory 將檢查 b 是否為 a 的視圖，但正如文件頁面所解釋的，並不總是能得到確切的答案。

>>> x = np.arange(5)
>>> x
array([0, 1, 2, 3, 4])

>>> y = x[::2]
>>> y
array([0, 2, 4])

>>> x[0] = 3 # changing x changes y as well, since y is a view on x
>>> y
array([3, 2, 4])