NumPy-1-26-中文文件-四-

NumPy 1.26 中文文件（四）

原文：numpy.org/doc/

numpy.generic.flags

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.flags.html

attribute

generic.flags

flags 的整數值。

numpy.generic.shape

numpy.org/doc/1.26/reference/generated/numpy.generic.shape.html

屬性

generic.shape

陣列維度的元組。

numpy.generic.strides

numpy.org/doc/1.26/reference/generated/numpy.generic.strides.html

屬性

generic.strides

每個維度中的位元組步長元組。

numpy.generic.ndim

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.ndim.html

屬性

generic.ndim

陣列的維度數量。

numpy.generic.data

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.data.html

屬性

generic.data

資料起始指標。

numpy.generic.size

numpy.org/doc/1.26/reference/generated/numpy.generic.size.html

attribute

generic.size

gentype 中的元素數量。

numpy.generic.itemsize

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.itemsize.html

屬性

generic.itemsize

一個元素的長度，以位元組為單位。

numpy.generic.base

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.base.html

屬性

generic.base

與相應陣列屬性相同的標量屬性。

請參閱ndarray.base。

numpy.generic.dtype

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.dtype.html

屬性

generic.dtype

獲取陣列資料描述符。

numpy.generic.real

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.real.html

屬性

generic.real

標量的實部。

numpy.generic.imag

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.imag.html

屬性

generic.imag

標量的虛部。

numpy.generic.flat

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.flat.html

屬性

generic.flat

一個標量的一維檢視。

numpy.generic.T

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.T.html

屬性

generic.T

與相應陣列屬性相同的標量屬性。

請參閱ndarray.T。

numpy.generic.__array_interface__

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.__array_interface__.html

屬性

generic.__array_interface__

陣列協議：Python 端

numpy.generic.__array_struct__

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.__array_struct__.html

屬性

generic.__array_struct__

陣列協議：結構體

numpy.generic.__array_priority__

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.__array_priority__.html

屬性

generic.__array_priority__

陣列優先順序。

numpy.generic.__array_wrap__

numpy.org/doc/1.26/reference/generated/numpy.generic.__array_wrap__.html

方法

generic.__array_wrap__()

sc.array_wrap(obj) 返回陣列中的標量

numpy.generic.__array__

numpy.org/doc/1.26/reference/generated/numpy.generic.__array__.html

方法

generic.__array__()

sc.array(dtype) 返回具有指定 dtype 的標量的零維陣列

numpy.generic.__array_wrap__

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.__array_wrap__.html

方法

generic.__array_wrap__()

sc.array_wrap(obj) 返回陣列中的標量

numpy.generic.squeeze

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.squeeze.html

方法

generic.squeeze()

標量方法與相應的陣列屬性相同。

請參閱ndarray.squeeze。

numpy.generic.byteswap

numpy.org/doc/1.26/reference/generated/numpy.generic.byteswap.html

方法

generic.byteswap()

與相應陣列屬性相同的標量方法。

請檢視ndarray.byteswap。

numpy.generic.__reduce__

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.__reduce__.html

方法

generic.__reduce__()

用於 pickle 的輔助函式。

numpy.generic.__setstate__

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.__setstate__.html

方法

generic.__setstate__()

numpy.generic.setflags

原文：numpy.org/doc/1.26/reference/generated/numpy.generic.setflags.html

方法

generic.setflags()

標量方法與相應的陣列屬性相同。

請參閱ndarray.setflags。

numpy.number.__class_getitem__

原文：numpy.org/doc/1.26/reference/generated/numpy.number.__class_getitem__.html

方法

number.__class_getitem__(item, /)

返回一個圍繞number型別的引數化包裝器。

版本 1.22 中的新功能。

返回：

aliastypes.GenericAlias

一個引數化的number型別。

另請參閱

PEP 585

標準集合中的型別提示泛型。

示例

>>> from typing import Any
>>> import numpy as np 

>>> np.signedinteger[Any]
numpy.signedinteger[typing.Any] 

資料型別物件（dtype）

原文：numpy.org/doc/1.26/reference/arrays.dtypes.html

資料型別物件（numpy.dtype類的一個例項）描述了與陣列項對應的固定大小記憶體塊中的位元組應如何解釋。它描述了資料的以下方面：

1. 資料的型別（整數、浮點數、Python 物件等）

2. 資料的大小（例如 整數佔據多少位元組）

3. 資料的位元組順序（小端或大端）

4. 如果資料型別是結構化資料型別，即其他資料型別的聚合，（例如，描述由整數和浮點陣列成的陣列項），

   1. 結構的“欄位”的名稱是什麼，透過這些名稱可以進行訪問，

   2. 每個欄位的資料型別是什麼，以及

   3. 每個欄位佔據記憶體塊的哪個部分。

5. 如果資料型別是子陣列，則其形狀和資料型別是什麼。

為描述標量資料型別，NumPy 中有幾種內建標量型別，用於不同精度的整數、浮點數等。從陣列中提取的項，例如 透過索引，將是一個 Python 物件，其型別是與陣列的資料型別相關聯的標量型別。

請注意，標量型別不是dtype物件，儘管它們可以在 NumPy 中需要資料型別規範的任何地方替代一個。

結構化資料型別是透過建立一個其欄位包含其他資料型別的資料型別來形成的。每個欄位都有一個名稱，可以透過該名稱進行訪問。父資料型別應具有足夠的大小以包含其所有欄位；父型別幾乎總是基於允許任意項大小的void型別。結構化資料型別還可以在其欄位中包含巢狀的結構化子陣列資料型別。

最後，資料型別可以描述其本身是另一種資料型別的項陣列。但是，這些子陣列必須是固定大小的。

如果使用描述子陣列的資料型別建立陣列，則在建立陣列時，子陣列的維度將附加到陣列的形狀上。結構化型別欄位中的子陣列行為不同，請參閱欄位訪問。

子陣列始終具有 C 連續的記憶體佈局。

示例

包含 32 位大端整數的簡單資料型別：（有關構造詳細資訊，請參見指定和構造資料型別）

>>> dt = np.dtype('>i4')
>>> dt.byteorder
'>'
>>> dt.itemsize
4
>>> dt.name
'int32'
>>> dt.type is np.int32
True 

相應的陣列標量型別是int32。

示例

包含一個 16 字元字串（在欄位‘name’中）和兩個 64 位浮點數子陣列（在欄位‘grades’中）的結構化資料型別：

>>> dt = np.dtype([('name', np.unicode_, 16), ('grades', np.float64, (2,))])
>>> dt['name']
dtype('<U16')
>>> dt['grades']
dtype(('<f8', (2,))) 

此資料型別陣列的項被包裝在一個具有兩個欄位的 array scalar 型別中：

>>> x = np.array([('Sarah', (8.0, 7.0)), ('John', (6.0, 7.0))], dtype=dt)
>>> x[1]
('John', [6., 7.])
>>> x[1]['grades']
array([6.,  7.])
>>> type(x[1])
<class 'numpy.void'>
>>> type(x[1]['grades'])
<class 'numpy.ndarray'> 

指定和構造資料型別

每當在 NumPy 函式或方法中需要資料型別時，可以提供一個dtype物件或可以轉換為其的內容。這些轉換是由dtype建構函式完成的：

dtype(dtype[, align, copy])	建立一個資料型別物件。

下面描述了可以轉換為資料型別物件的內容：

dtype 物件

原樣使用。

無

預設資料型別：float_。

陣列標量型別

所有內建的陣列標量型別物件都轉換為相關聯的資料型別物件。對於它們的子類也是如此。

請注意，並非所有資料型別資訊都可以透過型別物件提供：例如，flexible 資料型別的預設itemsize為 0，需要明確給定大小才能使用。

示例

>>> dt = np.dtype(np.int32)      # 32-bit integer
>>> dt = np.dtype(np.complex128) # 128-bit complex floating-point number 

通用型別

通用層次型別物件根據關聯轉換為相應型別物件：

number, inexact, floating	float
complexfloating	cfloat
integer, signedinteger	int_
unsignedinteger	uint
character	string
generic, flexible	void

自版本 1.19 起已棄用：通用標量型別的此轉換已棄用。這是因為在arr.astype(dtype=np.floating)這樣的上下文中可能會出現意外情況，它將float32陣列轉換為float64陣列，即使float32是np.floating的子型別也是如此。

內建的 Python 型別

當用於生成dtype物件時，幾種 Python 型別等效於相應的陣列標量：

int	int_
bool	bool_
float	float_
complex	cfloat
bytes	bytes_
str	str_
buffer	void
(其他所有)	object_

請注意，str對應於 UCS4 編碼的 Unicode 字串，而string是bytes_的別名。名稱np.unicode_也可用作np.str_的別名，請參閱字串型別說明。

示例

>>> dt = np.dtype(float)   # Python-compatible floating-point number
>>> dt = np.dtype(int)     # Python-compatible integer
>>> dt = np.dtype(object)  # Python object 

注意

所有其他型別為方便起見對映到object_。程式碼應該預期這些型別將來可能對映到特定（新的）dtype。

具有.dtype的型別

具有dtype屬性的任何型別物件：將直接訪問和使用該屬性。該屬性必須返回可轉換為 dtype 物件的內容。

可以轉換多種型別的字串。識別的字串可以用'>'（大端）、'<'（小端）或'='（硬體本機，預設）作為字首，以指定位元組順序。

單字元字串

每種內建資料型別都有一個字元程式碼（更新後的 Numeric 型別程式碼），用於唯一標識它。

示例

>>> dt = np.dtype('b')  # byte, native byte order
>>> dt = np.dtype('>H') # big-endian unsigned short
>>> dt = np.dtype('<f') # little-endian single-precision float
>>> dt = np.dtype('d')  # double-precision floating-point number 

陣列協議型別字串（參見陣列介面協議）

第一個字元指定資料型別，剩餘字元指定每個項的位元組數，除了 Unicode，其中它被解釋為字元數。項大小必須對應於現有型別，否則將引發錯誤。支援的型別有

'?'	布林值
'b'	(有符號) 位元組
'B'	無符號位元組
'i'	(有符號) 整數
'u'	無符號整數
'f'	浮點數
'c'	複數浮點數
'm'	時間差
'M'	日期時間
'O'	(Python) 物件
'S', 'a'	以零結尾的位元組（不建議使用）
'U'	Unicode 字串
'V'	原始資料（void）

例子

>>> dt = np.dtype('i4')   # 32-bit signed integer
>>> dt = np.dtype('f8')   # 64-bit floating-point number
>>> dt = np.dtype('c16')  # 128-bit complex floating-point number
>>> dt = np.dtype('a25')  # 25-length zero-terminated bytes
>>> dt = np.dtype('U25')  # 25-character string 

字串型別說明

為了向後相容原始編寫支援 Python 2 的現有程式碼，S和a型別字串是以零結尾的位元組，numpy.string_繼續別名為numpy.bytes_。對於 Unicode 字串，請使用U，numpy.str_或numpy.unicode_。對於不需要零終止的有符號位元組，可以使用b或i1。

逗號分隔欄位的字串

用於指定結構化資料型別格式的簡寫符號是基本格式的逗號分隔字串。

在此上下文中，基本格式是一個可選的形狀說明符，後跟一個陣列協議型別字串。如果形狀具有多個維度，則需要括號。NumPy 允許在格式上進行修改，任何可以唯一標識型別的字串都可以用於指定欄位的資料型別。生成的資料型別欄位命名為'f0'，'f1'，…，'f<N-1>'，其中 N（>1）是字串中逗號分隔的基本格式的數量。如果提供了可選的形狀說明符，則相應欄位的資料型別描述一個子陣列。

例子

• 名為f0的欄位包含一個 32 位整數

• 名為f1的欄位包含一個 2 x 3 的 64 位浮點數子陣列

• 名為f2的欄位包含一個 32 位浮點數

>>> dt = np.dtype("i4, (2,3)f8, f4") 

• 名為f0的欄位包含一個 3 字元字串

• 名為f1的欄位包含一個形狀為(3,)的子陣列，其中包含 64 位無符號整數

• 名為f2的欄位包含一個 3 x 4 的子陣列，其中包含 10 個字元的字串

>>> dt = np.dtype("a3, 3u8, (3,4)a10") 

型別字串

任何字串在numpy.sctypeDict.keys():

例子

>>> dt = np.dtype('uint32')   # 32-bit unsigned integer
>>> dt = np.dtype('float64')  # 64-bit floating-point number 

（靈活的資料型別，項大小）

第一個引數必須是一個轉換為零大小靈活資料型別物件的物件，第二個引數是提供所需項大小的整數。

例子

>>> dt = np.dtype((np.void, 10))  # 10-byte wide data block
>>> dt = np.dtype(('U', 10))   # 10-character unicode string 

（固定資料型別，形狀）

第一個引數是任何可以轉換為固定大小資料型別物件的物件。第二個引數是此型別的所需形狀。如果形狀引數為 1，則資料型別物件用於等效於固定資料型別。自 NumPy 1.17 以來，此行為已棄用，並將在將來引發錯誤。如果形狀是一個元組，則新資料型別定義給定形狀的子陣列。

例子

>>> dt = np.dtype((np.int32, (2,2)))          # 2 x 2 integer sub-array
>>> dt = np.dtype(('i4, (2,3)f8, f4', (2,3))) # 2 x 3 structured sub-array 

[(field_name, field_dtype, field_shape), ...]

obj 應該是一個欄位列表，其中每個欄位由長度為 2 或 3 的元組描述。（等同於 __array_interface__ 屬性中的 descr 項。）

第一個元素 field_name 是欄位名稱（如果為 ''，則分配標準欄位名稱 'f#'）。欄位名稱也可以是兩個字串的 2 元組，其中第一個字串是“標題”（可以是任何字串或 Unicode 字串）或欄位的後設資料，可以是任何物件，第二個字串是“名稱”，必須是有效的 Python 識別符號。

第二個元素 field_dtype 可以是任何可解釋為資料型別的內容。

可選的第三個元素 field_shape 包含形狀，如果此欄位表示第二個元素中資料型別的陣列。請注意，具有第三個引數等於 1 的 3 元組等效於 2 元組。

此樣式在 dtype 建構函式中不接受 align，因為假定所有記憶體都由陣列介面描述佔用。

示例

具有big（大端 32 位整數）和little（小端 32 位整數）欄位的資料型別：

>>> dt = np.dtype([('big', '>i4'), ('little', '<i4')]) 

具有R、G、B、A欄位的資料型別，每個欄位都是無符號 8 位整數：

>>> dt = np.dtype([('R','u1'), ('G','u1'), ('B','u1'), ('A','u1')]) 

{'names': ..., 'formats': ..., 'offsets': ..., 'titles': ..., 'itemsize': ...}

此樣式有兩個必需鍵和三個可選鍵。names 和 formats 鍵是必需的。它們的值分別是等長的欄位名稱列表和欄位格式列表。欄位名稱必須是字串，欄位格式可以是 dtype 建構函式接受的任何物件。

當提供可選鍵 offsets 和 titles 時，它們的值必須分別是與 names 和 formats 列表長度相同的列表。offsets 值是每個欄位的位元組偏移量列表（限制為 ctypes.c_int），而 titles 值是每個欄位的標題列表（如果不需要該欄位的標題，則可以使用 None）。titles 可以是任何物件，但當一個 str 物件時，將為欄位字典新增另一個由標題為鍵並引用相同欄位元組的條目，該元組將包含標題作為附加元組成員。

itemsize 鍵允許設定 dtype 的總大小，並且必須是足夠大的整數，以便所有欄位都在 dtype 內。如果正在構造的 dtype 是對齊的，則 itemsize 也必須能夠被結構對齊整除。總 dtype itemsize 限制為 ctypes.c_int。

示例

具有r、g、b、a欄位的資料型別，每個欄位都是 8 位無符號整數：

>>> dt = np.dtype({'names': ['r','g','b','a'],
...                'formats': [np.uint8, np.uint8, np.uint8, np.uint8]}) 

具有欄位r和b（具有給定標題）的資料型別，都是 8 位無符號整數，第一個位於欄位開始處的位元組位置 0，第二個位於位置 2：

>>> dt = np.dtype({'names': ['r','b'], 'formats': ['u1', 'u1'],
...                'offsets': [0, 2],
...                'titles': ['Red pixel', 'Blue pixel']}) 

{'field1': ..., 'field2': ..., ...}

不鼓勵使用此用法，因為它與其他基於字典的構造方法存在歧義。如果有一個名為‘names’的欄位和一個名為‘formats’的欄位，將會產生衝突。

此樣式允許傳遞��據型別物件的fields屬性。

obj應包含引用(資料型別，偏移量)或(資料型別，偏移量，標題)元組的字串或 unicode 鍵。

示例

包含欄位col1（位於位元組位置 0 的 10 字元字串），col2（位於位元組位置 10 的 32 位浮點數）和col3（位於位元組位置 14 的整數）的資料型別：

>>> dt = np.dtype({'col1': ('U10', 0), 'col2': (np.float32, 10),
...                'col3': (int, 14)}) 

(base_dtype, new_dtype)

在 NumPy 1.7 及更高版本中，此形式允許base_dtype被解釋為結構化 dtype。使用此 dtype 建立的陣列將具有基礎 dtypebase_dtype，但將具有從new_dtype中獲取的欄位和標誌。這對於建立自定義結構化 dtypes 很有用，就像在記錄陣列中所做的那樣。

這種形式還使得可以指定具有重疊欄位的結構化 dtypes，類似於 C 中的‘union’型別。然而，不鼓勵使用此用法，更傾向於使用 union 機制。

兩個引數必須能夠轉換為具有相同總大小的資料型別物件。

示例

32 位整數，其前兩個位元組透過欄位real解釋為整數，接下來兩個位元組透過欄位imag解釋。

>>> dt = np.dtype((np.int32,{'real':(np.int16, 0),'imag':(np.int16, 2)})) 

32 位整數，被解釋為包含 8 位整數的形狀為(4,)的子陣列：

>>> dt = np.dtype((np.int32, (np.int8, 4))) 

32 位整數，包含欄位r、g、b、a，將整數中的 4 個位元組解釋為四個無符號整數：

>>> dt = np.dtype(('i4', [('r','u1'),('g','u1'),('b','u1'),('a','u1')])) 

dtype

NumPy 資料型別描述是dtype類的例項。

屬性

資料的型別由以下dtype屬性描述：

dtype.type
dtype.kind	用於標識資料的一般型別的字元程式碼（'biufcmMOSUV'之一）。
dtype.char	每種 21 種不同內建型別的唯一字元程式碼。
dtype.num	每種 21 種不同內建型別的唯一數字。
dtype.str	此資料型別物件的陣列協議型別字串。

資料的大小依次由以下描述：

dtype.name	此資料型別的位寬名稱。
dtype.itemsize	此資料型別物件的元素大小。

此資料的位元組順序：

dtype.byteorder	指示此資料型別物件的位元組順序的字元。

在結構化資料型別中關於子資料型別的資訊：

dtype.fields	為此資料型別定義的命名欄位的字典，或為None。
dtype.names	欄位名稱的有序列表，如果沒有欄位則為None。

對描述子陣列的資料型別：

dtype.subdtype	如果此dtype描述一個子陣列，則為元組(item_dtype, shape)，否則為None。
dtype.shape	如果此資料型別描述一個子陣列，則為子陣列的形狀元組，否則為()。

提供額外資訊的屬性：

dtype.hasobject	指示此資料型別是否在任何欄位或子資料型別中包含任何引用計數物件的布林值。
dtype.flags	描述如何解釋此資料型別的位標誌。
dtype.isbuiltin	指示此資料型別與內建資料型別的關係的整數。
dtype.isnative	指示此資料型別的位元組順序是否為平臺本地的布林值。
dtype.descr	資料型別的array_interface描述。
dtype.alignment	根據編譯器，此資料型別所需的對齊方式（位元組）。
dtype.base	返回子陣列的基本元素的資料型別，不考慮其維度或形狀。

使用者附加的後設資料：

dtype.metadata	要麼為None，要麼為只讀的後設資料字典（mappingproxy）。

方法

資料型別具有以下用於更改位元組順序的方法：

dtype.newbyteorder([new_order])	返回一個具有不同位元組順序的新 dtype。

以下方法實現了 pickle 協議：

dtype.__reduce__	pickle 的輔助函式。
dtype.__setstate__

用於輸入的實用方法：

dtype.__class_getitem__(item, /)	返回一個圍繞 dtype 型別的引數化包裝器。

比較操作：

dtype.__ge__(value, /)	返回 self>=value。
dtype.__gt__(value, /)	返回 self>value。
dtype.__le__(value, /)	返回 self<=value。
dtype.__lt__(value, /)	返回 self<value。

指定和構造資料型別

每當在 NumPy 函式或方法中需要資料型別時，可以提供一個 dtype 物件或可以轉換為其中一個的內容。這些轉換是由 dtype 建構函式完成的：

dtype(dtype[, align, copy])	建立一個資料型別物件。

下面描述了可以轉換為資料型別物件的內容：

dtype 物件

如原樣使用。

無

預設資料型別：float_。

陣列標量型別

24 個內建的 陣列標量型別物件 都轉換為一個關聯的資料型別物件。對於它們的子類也是如此。

請注意，並非所有資料型別資訊都可以透過型別物件提供：例如，flexible 資料型別的預設 itemsize 為 0，需要明確給定大小才能使用。

示例

>>> dt = np.dtype(np.int32)      # 32-bit integer
>>> dt = np.dtype(np.complex128) # 128-bit complex floating-point number 

通用型別

通用的分層型別物件根據關聯轉換為相應的型別物件：

number, inexact, floating	float
complexfloating	cfloat
integer, signedinteger	int_
unsignedinteger	uint
character	string
generic, flexible	void

自版本 1.19 起棄用：通用標量型別的此轉換已棄用。這是因為在諸如arr.astype(dtype=np.floating)的上下文中可能會出現意外情況，該操作將float32陣列轉換為float64陣列，即使float32是np.floating的子 dtype。

Python 內建型別

當用於生成dtype物件時，幾種 Python 型別等效於相應的陣列標量：

int	int_
bool	bool_
float	float_
complex	cfloat
bytes	bytes_
str	str_
buffer	void
(其他所有)	object_

請注意，str對應於 UCS4 編碼的 Unicode 字串，而string是bytes_的別名。名稱np.unicode_也可作為np.str_的別名使用，參見字串型別說明。

示例

>>> dt = np.dtype(float)   # Python-compatible floating-point number
>>> dt = np.dtype(int)     # Python-compatible integer
>>> dt = np.dtype(object)  # Python object 

注意

所有其他型別都對映到object_以方便使用。程式碼應該預期這些型別將來可能對映到特定的（新的）dtype。

具有.dtype的型別

具有dtype屬性的任何型別物件：將直接訪問和使用該屬性。該屬性必須返回可轉換為 dtype 物件的內容。

可以轉換多種型別的字串。識別的字串可以以'>'（大端��、'<'（小端）或'='（硬體本機，預設）開頭，以指定位元組順序。

單字元字串

每種內建資料型別都有一個字元程式碼（更新後的 Numeric 型別程式碼），用於唯一標識它。

示例

>>> dt = np.dtype('b')  # byte, native byte order
>>> dt = np.dtype('>H') # big-endian unsigned short
>>> dt = np.dtype('<f') # little-endian single-precision float
>>> dt = np.dtype('d')  # double-precision floating-point number 

陣列協議型別字串（參見陣列介面協議）

第一個字元指定資料型別，剩餘字元指定每個專案的位元組數，除了 Unicode，它被解釋為字元數。專案大小必須對應於現有型別，否則將引發錯誤。支援的型別有

'?'	布林值
'b'	（有符號）位元組
'B'	無符號位元組
'i'	（有符號）整數
'u'	無符號整數
'f'	浮點數
'c'	複數浮點數
'm'	時間間隔
'M'	日期時間
'O'	（Python）物件
'S', 'a'	零結尾位元組（不建議使用）
'U'	Unicode 字串
'V'	原始資料（void）

示例

>>> dt = np.dtype('i4')   # 32-bit signed integer
>>> dt = np.dtype('f8')   # 64-bit floating-point number
>>> dt = np.dtype('c16')  # 128-bit complex floating-point number
>>> dt = np.dtype('a25')  # 25-length zero-terminated bytes
>>> dt = np.dtype('U25')  # 25-character string 

字串型別說明

為了向後相容原始編寫支援 Python 2 的現有程式碼，S和a型別字串是零結尾位元組，numpy.string_繼續別名為numpy.bytes_。對於 Unicode 字串，請使用U，numpy.str_或numpy.unicode_。對於不需要零結尾的有符號位元組，可以使用b或i1。

逗號分隔欄位的字串

用於指定結構化資料型別格式的簡寫符號是基本格式的逗號分隔字串。

在這種情況下，基本格式是可選的形狀說明符，後跟一個陣列協議型別字串。如果形狀具有多個維度，則需要括號。NumPy 允許對格式進行修改，以便使用任何可以唯一標識型別的字串來指定欄位的資料型別。生成的資料型別欄位命名為'f0'，'f1'，…，'f<N-1>'，其中 N（>1）是字串中逗號分隔的基本格式的數量。如果提供了可選的形狀說明符，則相應欄位的資料型別描述一個子陣列。

示例

• 欄位名為f0，包含一個 32 位整數

• 欄位名為f1，包含一個 2 x 3 的 64 位浮點數子陣列

• 欄位名為f2，包含一個 32 位浮點數

>>> dt = np.dtype("i4, (2,3)f8, f4") 

• 欄位名為f0，包含一個 3 字元字串

• 欄位名為f1，包含一個形狀為(3,)的 64 位無符號整數子陣列

• 欄位名為f2，包含一個 3 x 4 的子陣列，其中包含 10 字元字串

>>> dt = np.dtype("a3, 3u8, (3,4)a10") 

型別字串

numpy.sctypeDict中的任何字串.keys():

示例

>>> dt = np.dtype('uint32')   # 32-bit unsigned integer
>>> dt = np.dtype('float64')  # 64-bit floating-point number 

(flexible_dtype, itemsize)

第一個引數必須是轉換為零大小靈活資料型別物件的物件，第二個引數是提供所需 itemsize 的整數。

示例

>>> dt = np.dtype((np.void, 10))  # 10-byte wide data block
>>> dt = np.dtype(('U', 10))   # 10-character unicode string 

(fixed_dtype, shape)

第一個引數是可以轉換為固定大小資料型別物件的任何物件。第二個引數是此型別的期望形狀。如果形狀引數為 1，則資料型別物件用於等效於固定資料型別。自 NumPy 1.17 起，此行為已棄用，並將在將來引發錯誤。如果shape是一個元組，則新資料型別定義給定形狀的子陣列。

示例

>>> dt = np.dtype((np.int32, (2,2)))          # 2 x 2 integer sub-array
>>> dt = np.dtype(('i4, (2,3)f8, f4', (2,3))) # 2 x 3 structured sub-array 

[(field_name, field_dtype, field_shape), ...]

obj應該是一個欄位列表，其中每個欄位由長度為 2 或 3 的元組描述。（等同於__array_interface__屬性中的descr項。）

第一個元素，field_name，是欄位名稱（如果為''，則分配一個標準欄位名稱，'f#'）。欄位名稱也可以是一個包含兩個字串的元組，其中第一個字串是“標題”（可以是任何字串或 Unicode 字串）或欄位的後設資料，可以是任何物件，第二個字串是“名稱”，必須是有效的 Python 識別符號。

第二個元素，field_dtype，可以是任何可解釋為資料型別的內容。

可選的第三個元素field_shape包含形狀，如果此欄位表示第二個元素中資料型別的陣列。請注意，具有第三個引數等於 1 的 3 元組等同於 2 元組。

這種風格在dtype建構函式中不接受align，因為假定所有記憶體都由陣列介面描述佔用。

示例

具有欄位big（大端 32 位整數）和little（小端 32 位整數）的資料型別：

>>> dt = np.dtype([('big', '>i4'), ('little', '<i4')]) 

具有欄位R、G、B、A的資料型別，每個欄位都是無符號 8 位整數：

>>> dt = np.dtype([('R','u1'), ('G','u1'), ('B','u1'), ('A','u1')]) 

{'names': ..., 'formats': ..., 'offsets': ..., 'titles': ..., 'itemsize': ...}

這種風格有兩個必需的和三個可選的鍵。names和formats鍵是必需的。它們各自的值是長度相等的列表，其中包含欄位名稱和欄位格式。欄位名稱必須是字串，欄位格式可以是dtype建構函式接受的任何物件。

當提供可選鍵offsets和titles時，它們的值必須與names和formats列表的長度相同。offsets值是每個欄位的位元組偏移量的列表（限制為ctypes.c_int），而titles值是每個欄位的標題的列表（如果不需要標題，則可以使用None）。titles可以是任何物件，但當一個str物件將為欄位字典新增另一個條目，以標題為鍵，並引用相同的欄位元組，該元組將包含標題作為附加元組成員。

itemsize鍵允許設定 dtype 的總大小，並且必須是一個足夠大的整數，以便所有欄位都在 dtype 內。如果正在構建的 dtype 是對齊的，則itemsize也必須能夠被結構對齊整除。總 dtype itemsize 限制為ctypes.c_int。

示例

具有欄位r、g、b、a，每個欄位都是 8 位無符號整數的資料型別：

>>> dt = np.dtype({'names': ['r','g','b','a'],
...                'formats': [np.uint8, np.uint8, np.uint8, np.uint8]}) 

具有欄位r和b（具有給定標題），都是 8 位無符號整數的資料型別，第一個位於欄位開始處的位元組位置 0，第二個位於位置 2：

>>> dt = np.dtype({'names': ['r','b'], 'formats': ['u1', 'u1'],
...                'offsets': [0, 2],
...                'titles': ['Red pixel', 'Blue pixel']}) 

{'field1': ..., 'field2': ..., ...}

不鼓勵使用此用法，因為它與其他基於字典的構造方法存在歧義。如果有一個名為‘names’的欄位和一個名為‘formats’的欄位，將會產生衝突。

這種樣式允許傳遞資料型別物件的fields屬性。

obj應包含引用(資料型別，偏移量)或(資料型別，偏移量，標題)元組的字串或 unicode 鍵。

示例

包含欄位col1（位於位元組位置 0 處的 10 個字元字串）、col2（位於位元組位置 10 處的 32 位浮點數）和col3（位於位元組位置 14 處的整數）的資料型別：

>>> dt = np.dtype({'col1': ('U10', 0), 'col2': (np.float32, 10),
...                'col3': (int, 14)}) 

(base_dtype, new_dtype)

在 NumPy 1.7 及更高版本中，此形式允許將base_dtype解釋為結構化 dtype。使用此 dtype 建立的陣列將具有基礎 dtype base_dtype，但將從new_dtype中獲取欄位和標誌。這對於建立自定義結構化 dtypes 很有用，就像在記錄陣列中所做的那樣。

這種形式還可以指定具有重疊欄位的結構 dtype，類似於 C 中的‘union’型別。但是，不鼓勵使用此用法，更傾向於使用 union 機制。

兩個引數必須能夠���換為具有相同總大小的資料型別物件。

示例

32 位整數，其前兩個位元組透過欄位real解釋為整數，後兩個位元組透過欄位imag解釋。

>>> dt = np.dtype((np.int32,{'real':(np.int16, 0),'imag':(np.int16, 2)})) 

32 位整數，被解釋為包含 8 位整數的形狀為(4,)的子陣列：

>>> dt = np.dtype((np.int32, (np.int8, 4))) 

32 位整數，包含欄位r、g、b、a，將整數中的 4 個位元組解釋為四個無符號整數：

>>> dt = np.dtype(('i4', [('r','u1'),('g','u1'),('b','u1'),('a','u1')])) 

dtype

NumPy 資料型別描述是dtype類的例項。

屬性

資料型別的型別由以��dtype屬性描述：

dtype.type
dtype.kind	一個字元程式碼（'biufcmMOSUV'之一），用於標識資料的一般型別。
dtype.char	每種 21 種不同內建型別的唯一字元程式碼。
dtype.num	每種 21 種不同內建型別的唯一編號。
dtype.str	此資料型別物件的陣列協議型別字串。

資料的大小由以下描述：

dtype.name	此資料型別的位寬名稱。
dtype.itemsize	此資料型別物件的元素大小。

此資料的位元組順序：

dtype.byteorder	指示此資料型別物件的位元組順序的字元。

有關結構化資料型別中子資料型別的資訊：

dtype.fields	為此資料型別定義的命名欄位的字典，或None。
dtype.names	欄位名稱的有序列表，如果沒有欄位，則為None。

對於描述子陣列的資料型別：

dtype.subdtype	如果此dtype描述一個子陣列，則為元組(item_dtype, shape)，否則為None。
dtype.shape	如果此資料型別描述一個子陣列，則為子陣列的形狀元組，否則為()。

提供額外資訊的屬性：

dtype.hasobject	布林值，指示此 dtype 是否在任何欄位或子資料型別中包含任何引用計數物件。
dtype.flags	描述如何解釋此資料型別的位標誌。
dtype.isbuiltin	指示此資料型別與內建資料型別的關係的整數。
dtype.isnative	布林值，指示此資料型別的位元組順序是否為平臺本機的。
dtype.descr	資料型別的array_interface描述。
dtype.alignment	根據編譯器，此資料型別所需的對齊方式（位元組）。
dtype.base	返回子陣列的基本元素的資料型別，不考慮其維度或形狀。

使用者附加的後設資料：

dtype.metadata	None或只讀後設資料字典（mappingproxy）。

方法

資料型別具有以下用於更改位元組順序的方法：

dtype.newbyteorder([new_order])	返回具有不同位元組順序的新資料型別。

以下方法實現了 pickle 協議：

dtype.__reduce__	pickle 的輔助函式。
dtype.__setstate__

型別的實用方法：

dtype.__class_getitem__(item, /)	返回圍繞dtype型別的引數化包裝器。

比較操作：

dtype.__ge__(value, /)	返回 self>=value。
dtype.__gt__(value, /)	返回 self>value。
dtype.__le__(value, /)	返回 self<=value。
dtype.__lt__(value, /)	返回 self<value。

屬性

資料的型別由以下dtype屬性描述：

dtype.type
dtype.kind	識別資料的一般型別的字元程式碼（'biufcmMOSUV'之一）。
dtype.char	21 種不同內建型別的每種的唯一字元程式碼。
dtype.num	21 種不同內建型別的每種的唯一編號。
dtype.str	此資料型別物件的陣列協議型別字串。

資料的大小由 S

dtype.name	此資料型別的位寬名稱。
dtype.itemsize	此資料型別物件的元素大小。

資料的位元組順序：

dtype.byteorder	指示此資料型別物件的位元組順序的字元。

有關結構化資料型別中子資料型別的資訊：

dtype.fields	為此資料型別定義的命名欄位的字典，或None。
dtype.names	欄位名稱的有序列表，如果沒有欄位，則為None。

對於描述子陣列的資料型別：

dtype.subdtype	如果此dtype描述子陣列，則為元組(item_dtype, shape)，否則為 None。
dtype.shape	如果此資料型別描述子陣列，則為子陣列的形狀元組，否則為()。

提供額外資訊的屬性：

dtype.hasobject	布林值，指示此資料型別是否在任何欄位或子資料型別中包含任何引用計數物件。
dtype.flags	描述如何解釋此資料型別的位標誌。
dtype.isbuiltin	指示此資料型別與內建資料型別的關係的整數。
dtype.isnative	布林值，指示此資料型別的位元組順序是否與平臺本地。
dtype.descr	資料型別的array_interface描述。
dtype.alignment	根據編譯器，此資料型別所需的對齊方式（位元組）。
dtype.base	返回子陣列的基本元素的 dtype，不考慮其維度或形狀。

使用者附加的後設資料：

dtype.metadata	可能是None，也可能是一個只讀的後設資料字典（mappingproxy）。

方法

資料型別具有以下用於更改位元組順序的方法：

dtype.newbyteorder([new_order])	返回具有不同位元組順序的新 dtype。

以下方法實現了 pickle 協議：

dtype.__reduce__	pickle 的輔助函式。
dtype.__setstate__

用於型別的實用方法：

dtype.__class_getitem__(item, /)	返回一個圍繞dtype型別的引數化包裝器。

比較操作：

dtype.__ge__(value, /)	返回 self>=value。
dtype.__gt__(value, /)	返回 self>value。
dtype.__le__(value, /)	返回 self<=value。
dtype.__lt__(value, /)	返回 self<value。

numpy.dtype

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.html

class numpy.dtype(dtype, align=False, copy=False[, metadata])

建立一個資料型別物件。

一個 numpy 陣列是同質的，幷包含由 dtype 物件描述的元素。dtype 物件可以由不同組合的基本數值型別構建。

引數：

dtype

要轉換為資料型別物件的物件。

alignbool，可選

為欄位新增填充，以匹配類似 C 結構的 C 編譯器輸出。只有當obj是字典或逗號分隔的字串時才能為True。如果正在建立結構 dtype，這也會設定一個粘性對齊標誌isalignedstruct。

copybool，可選

製作資料型別物件的新副本。如果False，結果可能只是對內建資料型別物件的引用。

metadatadict，可選

一個可選的帶有 dtype 後設資料的字典。

參見

result_type

示例

使用陣列標量型別：

>>> np.dtype(np.int16)
dtype('int16') 

結構化型別，一個名為‘f1’的欄位，包含 int16：

>>> np.dtype([('f1', np.int16)])
dtype([('f1', '<i2')]) 

結構化型別，一個名為‘f1’的欄位，本身包含一個具有一個欄位的結構化型別：

>>> np.dtype([('f1', [('f1', np.int16)])])
dtype([('f1', [('f1', '<i2')])]) 

結構化型別，兩個欄位：第一個欄位包含一個無符號整數，第二個欄位包含一個 int32：

>>> np.dtype([('f1', np.uint64), ('f2', np.int32)])
dtype([('f1', '<u8'), ('f2', '<i4')]) 

使用陣列協議型別字串：

>>> np.dtype([('a','f8'),('b','S10')])
dtype([('a', '<f8'), ('b', 'S10')]) 

使用逗號分隔的欄位格式。形狀為(2,3)：

>>> np.dtype("i4, (2,3)f8")
dtype([('f0', '<i4'), ('f1', '<f8', (2, 3))]) 

使用元組。int是一個固定型別，3 是欄位的形狀。void是一個靈活的型別，在這裡大小為 10：

>>> np.dtype([('hello',(np.int64,3)),('world',np.void,10)])
dtype([('hello', '<i8', (3,)), ('world', 'V10')]) 

將int16細分為 2 個int8，稱為 x 和 y。0 和 1 是位元組偏移量：

>>> np.dtype((np.int16, {'x':(np.int8,0), 'y':(np.int8,1)}))
dtype((numpy.int16, [('x', 'i1'), ('y', 'i1')])) 

使用字典。兩個名為‘gender’和‘age’的欄位：

>>> np.dtype({'names':['gender','age'], 'formats':['S1',np.uint8]})
dtype([('gender', 'S1'), ('age', 'u1')]) 

位元組偏移，這裡為 0 和 25：

>>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)})
dtype([('surname', 'S25'), ('age', 'u1')]) 

屬性：

alignment

根據編譯器的要求對此資料型別的對齊（位元組）。

base

返回子陣列的基本元素的 dtype，而不考慮它們的維度或形狀。

byteorder

表示此資料型別物件的位元組順序的字元。

char

21 種不同內建型別的每種的唯一字元程式碼。

descr

array_interface 資料型別的描述。

fields

為此資料型別定義的命名欄位的字典，或None。

flags

描述資料型別如何解釋的位標誌。

hasobject

布林值，指示此 dtype 是否在任何欄位或子 dtype 中包含任何引用計數物件。

isalignedstruct

���爾值，指示 dtype 是否為保持欄位對齊的結構體。

isbuiltin

指示此 dtype 與內建 dtype 的關係的整數。

isnative

布林值，指示此 dtype 的位元組順序是否為平臺本機的。

itemsize

此資料型別物件的元素大小。

kind

一個字元程式碼（‘biufcmMOSUV’之一），用於標識資料的一般型別。

metadata

要麼為None，要麼為只讀後設資料字典（mappingproxy）。

name

用於此資料型別的位寬名稱。

names

欄位名稱的有序列表，如果沒有欄位則為None。

ndim

如果此資料型別描述一個子陣列，則為子陣列的維數，否則為0。

num

21 種不同內建型別中的每一種的唯一編號。

shape

如果此資料型別描述一個子陣列，則為子陣列的形狀元組，否則為()。

str

此資料型別物件的陣列協議型別字串。

subdtype

如果此dtype描述一個子陣列，則為元組(item_dtype, shape)，否則為None。

type

方法

newbyteorder([new_order])	返回具有不同位元組順序的新 dtype。

numpy.dtype.type

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.type.html

屬性

dtype.type = None

numpy.dtype.kind

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.kind.html

屬性

dtype.kind

一個字元程式碼（‘biufcmMOSUV’中的一個），用於標識資料的一般型別。

b	布林值
i	有符號整數
u	無符號整數
f	浮點數
c	複數浮點數
m	時間差
M	日期時間
O	物件
S	（位元組）字串
U	Unicode
V	空

示例

>>> dt = np.dtype('i4')
>>> dt.kind
'i'
>>> dt = np.dtype('f8')
>>> dt.kind
'f'
>>> dt = np.dtype([('field1', 'f8')])
>>> dt.kind
'V' 

numpy.dtype.char

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.char.html

屬性

dtype.char

21 種不同內建型別的每種型別都有一個獨特的字元程式碼。

示例

>>> x = np.dtype(float)
>>> x.char
'd' 

numpy.dtype.num

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.num.html

屬性

dtype.num

每種 21 種不同的內建型別都有一個唯一的數字。

這些大致按照從最不精確到最精確的順序排列。

示例

>>> dt = np.dtype(str)
>>> dt.num
19 

>>> dt = np.dtype(float)
>>> dt.num
12 

numpy.dtype.str

numpy.org/doc/1.26/reference/generated/numpy.dtype.str.html

屬性

dtype.str

這個資料型別物件的陣列協議型別字串。

numpy.dtype.name

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.name.html

屬性

dtype.name

該資料型別的位寬名稱。

未指定大小的靈活資料型別物件沒有此屬性。

示例

>>> x = np.dtype(float)
>>> x.name
'float64'
>>> x = np.dtype([('a', np.int32, 8), ('b', np.float64, 6)])
>>> x.name
'void640' 

numpy.dtype.itemsize

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.itemsize.html

屬性

dtype.itemsize

這個資料型別物件的元素大小。

對於 21 種型別中的 18 種，這個數字由資料型別固定。對於靈活的資料型別，這個數字可以是任意值。

示例

>>> arr = np.array([[1, 2], [3, 4]])
>>> arr.dtype
dtype('int64')
>>> arr.itemsize
8 

>>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
>>> dt.itemsize
80 

numpy.dtype.byteorder

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.byteorder.html

屬性

dtype.byteorder

表示此資料型別物件的位元組順序的字元。

一個字元：

‘=’	本地
‘<’	小端
‘>’	大端
‘|’	不適用

所有內建資料型別物件的位元組順序都是‘=’或‘|’。

例子

>>> dt = np.dtype('i2')
>>> dt.byteorder
'='
>>> # endian is not relevant for 8 bit numbers
>>> np.dtype('i1').byteorder
'|'
>>> # or ASCII strings
>>> np.dtype('S2').byteorder
'|'
>>> # Even if specific code is given, and it is native
>>> # '=' is the byteorder
>>> import sys
>>> sys_is_le = sys.byteorder == 'little'
>>> native_code = '<' if sys_is_le else '>'
>>> swapped_code = '>' if sys_is_le else '<'
>>> dt = np.dtype(native_code + 'i2')
>>> dt.byteorder
'='
>>> # Swapped code shows up as itself
>>> dt = np.dtype(swapped_code + 'i2')
>>> dt.byteorder == swapped_code
True 

numpy.dtype.fields

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.fields.html

屬性

dtype.fields

為此資料型別定義的命名欄位的字典，或None。

字典由欄位名稱作為鍵進行索引。字典中的每個條目都是一個完全描述欄位的元組：

(dtype, offset[, title]) 

偏移量限制為 C int，它是有符號的，通常為 32 位。如果存在，可選標題可以是任何物件（如果是字串或 unicode，則還將是欄位字典中的鍵，否則它是後設資料）。還要注意，元組的前兩個元素可以直接作為引數傳遞給ndarray.getfield和ndarray.setfield方法。

另請參見

ndarray.getfield, ndarray.setfield

示例

>>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
>>> print(dt.fields)
{'grades': (dtype(('float64',(2,))), 16), 'name': (dtype('|S16'), 0)} 

numpy.dtype.names

numpy.org/doc/1.26/reference/generated/numpy.dtype.names.html

屬性

dtype.names

欄位名稱的有序列表，如果沒有欄位則為None。

這些名稱按照遞增的位元組偏移排序。例如，可以使用這個來按照偏移順序遍歷所有命名欄位。

示例

>>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
>>> dt.names
('name', 'grades') 

numpy.dtype.subdtype

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.subdtype.html

屬性

dtype.subdtype

如果這個dtype描述一個子陣列，則元組(item_dtype, shape)，否則為 None。

shape是由此資料型別描述的子陣列的固定形狀，item_dtype是陣列的資料型別。

如果檢索具有此屬性的 dtype 物件的欄位，則shape隱含的額外維度將附加到檢索到的陣列的末尾。

另請參閱

dtype.base

示例

>>> x = numpy.dtype('8f')
>>> x.subdtype
(dtype('float32'), (8,)) 

>>> x =  numpy.dtype('i2')
>>> x.subdtype
>>> 

numpy.dtype.shape

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.shape.html

屬性

dtype.shape

如果這個資料型別描述一個子陣列，則是子陣列的形狀元組，否則為()。

示例

>>> dt = np.dtype(('i4', 4))
>>> dt.shape
(4,) 

>>> dt = np.dtype(('i4', (2, 3)))
>>> dt.shape
(2, 3) 

numpy.dtype.hasobject

numpy.org/doc/1.26/reference/generated/numpy.dtype.hasobject.html

屬性

dtype.hasobject

布林值，指示此資料型別是否在任何欄位或子資料型別中包含任何引用計數物件。

請記住，實際上在表示 Python 物件的 ndarray 記憶體中的是該物件的記憶體地址（一個指標）。可能需要特殊處理，此屬性對於區分可能包含任意 Python 物件的資料型別和不會包含的資料型別非常有用。

numpy.dtype.flags

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.flags.html

屬性

dtype.flags

描述如何解釋此資料型別的位標誌。

位掩碼在numpy.core.multiarray中作為常量ITEM_HASOBJECT、LIST_PICKLE、ITEM_IS_POINTER、NEEDS_INIT、NEEDS_PYAPI、USE_GETITEM、USE_SETITEM存在。這些標誌的詳細解釋在 C-API 文件中；它們在使用者定義的資料型別中非常有用。

以下示例演示了對這種特定 dtype 的操作需要使用 Python C-API。

示例

>>> x = np.dtype([('a', np.int32, 8), ('b', np.float64, 6)])
>>> x.flags
16
>>> np.core.multiarray.NEEDS_PYAPI
16 

numpy.dtype.isbuiltin

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.isbuiltin.html

屬性

dtype.isbuiltin

表示此 dtype 與內建 dtype 的關係的整數。

只讀。

0	如果這是一個帶有欄位的結構化陣列型別
1	如果這是編譯到 numpy 中的 dtype（如整數、浮點數等）
2	如果 dtype 是使用者定義的 numpy 型別，則為使用者定義的型別使用 numpy C-API 機制來擴充套件 numpy 以處理新的陣列型別。請參閱 NumPy 手冊中的使用者定義的資料型別。

示例

>>> dt = np.dtype('i2')
>>> dt.isbuiltin
1
>>> dt = np.dtype('f8')
>>> dt.isbuiltin
1
>>> dt = np.dtype([('field1', 'f8')])
>>> dt.isbuiltin
0 

numpy.dtype.isnative

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.isnative.html

屬性

dtype.isnative

布林值，指示此 dtype 的位元組順序是否與平臺本地位元組順序相同。

numpy.dtype.descr

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.descr.html

屬性

dtype.descr

array_interface 資料型別的描述。

格式是 array_interface 屬性中 'descr' 鍵所需的格式。

警告：此屬性專門用於 array_interface，直接傳遞給 np.dtype 將無法準確重建某些資料型別（例如，標量和子陣列資料型別）。

示例

>>> x = np.dtype(float)
>>> x.descr
[('', '<f8')] 

>>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
>>> dt.descr
[('name', '<U16'), ('grades', '<f8', (2,))] 

numpy.dtype.alignment

numpy.org/doc/1.26/reference/generated/numpy.dtype.alignment.html

屬性

dtype.alignment

根據編譯器，此資料型別所需的對齊（位元組）。

更多資訊請參考手冊中的 C-API 部分。

示例

>>> x = np.dtype('i4')
>>> x.alignment
4 

>>> x = np.dtype(float)
>>> x.alignment
8 

numpy.dtype.base

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.base.html

屬性

dtype.base

返回子陣列的基本元素的資料型別，無論其維度或形狀如何。

另請參閱

dtype.subdtype

示例

>>> x = numpy.dtype('8f')
>>> x.base
dtype('float32') 

>>> x =  numpy.dtype('i2')
>>> x.base
dtype('int16') 

numpy.dtype.metadata

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.metadata.html

屬性

dtype.metadata

可以是None，也可以是隻讀的後設資料字典（mappingproxy）。

可以使用任何字典在資料型別建立時設定後設資料欄位。NumPy 目前沒有統一的後設資料傳播方法；雖然一些陣列操作會保留後設資料，但不能保證其他操作也會保留。

警告

雖然在某些專案中使用了這個功能，但長期以來都沒有文件記錄，並且支援不夠完善。未來預計後設資料傳播的某些方面將發生變化。

示例

>>> dt = np.dtype(float, metadata={"key": "value"})
>>> dt.metadata["key"]
'value'
>>> arr = np.array([1, 2, 3], dtype=dt)
>>> arr.dtype.metadata
mappingproxy({'key': 'value'}) 

目前，新增具有相同資料型別的陣列會保留後設資料：

>>> (arr + arr).dtype.metadata
mappingproxy({'key': 'value'}) 

但是，如果陣列具有不同的 dtype 後設資料，則可能會丟失後設資料：

>>> dt2 = np.dtype(float, metadata={"key2": "value2"})
>>> arr2 = np.array([3, 2, 1], dtype=dt2)
>>> (arr + arr2).dtype.metadata is None
True  # The metadata field is cleared so None is returned 

numpy.dtype.newbyteorder

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.newbyteorder.html

方法

dtype.newbyteorder(new_order='S', /)

返回一個具有不同位元組順序的新 dtype。

對資料型別的所有欄位和子陣列也進行更改。

引數：

new_order字串，可選

強制的位元組順序；來自下面位元組順序規範的值。預設值（‘S’）導致交換當前位元組順序。new_order程式碼可以是以下任意之一：

• ‘S’ - 將 dtype 從當前位元組順序交換為相反位元組順序

• {‘<’, ‘little’} - 小端

• {‘>’, ‘big’} - 大端

• {‘=’, ‘native’} - 本機順序

• {‘|’, ‘I’} - 忽略（不改變位元組順序）

返回：

new_dtypedtype

具有給定位元組順序更改的新 dtype 物件。

注意

對資料型別的所有欄位和子陣列也進行更改。

示例

>>> import sys
>>> sys_is_le = sys.byteorder == 'little'
>>> native_code = '<' if sys_is_le else '>'
>>> swapped_code = '>' if sys_is_le else '<'
>>> native_dt = np.dtype(native_code+'i2')
>>> swapped_dt = np.dtype(swapped_code+'i2')
>>> native_dt.newbyteorder('S') == swapped_dt
True
>>> native_dt.newbyteorder() == swapped_dt
True
>>> native_dt == swapped_dt.newbyteorder('S')
True
>>> native_dt == swapped_dt.newbyteorder('=')
True
>>> native_dt == swapped_dt.newbyteorder('N')
True
>>> native_dt == native_dt.newbyteorder('|')
True
>>> np.dtype('<i2') == native_dt.newbyteorder('<')
True
>>> np.dtype('<i2') == native_dt.newbyteorder('L')
True
>>> np.dtype('>i2') == native_dt.newbyteorder('>')
True
>>> np.dtype('>i2') == native_dt.newbyteorder('B')
True 

numpy.dtype.__reduce__

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.__reduce__.html

方法

dtype.__reduce__()

用於 pickle 的輔助函式。

numpy.dtype.__setstate__

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.__setstate__.html

方法

dtype.__setstate__()

numpy.dtype.__class_getitem__

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.__class_getitem__.html

方法

dtype.__class_getitem__(item, /)

返回一個圍繞dtype型別的引數化包裝器。

版本 1.22 中的新功能。

返回：

aliastypes.GenericAlias

一個引數化的dtype型別。

另請參閱

PEP 585

標準集合中的型別提示泛型。

示例

>>> import numpy as np 

>>> np.dtype[np.int64]
numpy.dtype[numpy.int64] 

numpy.dtype.__ge__

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.__ge__.html

方法

dtype.__ge__(value, /)

返回 self>=value。

numpy.dtype.__gt__

numpy.org/doc/1.26/reference/generated/numpy.dtype.__gt__.html

方法

dtype.__gt__(value, /)

返回 self>value。

numpy.dtype.__le__

numpy.org/doc/1.26/reference/generated/numpy.dtype.__le__.html

方法

dtype.__le__(value, /)

返回 self<=value.

numpy.dtype.__lt__

原文：numpy.org/doc/1.26/reference/generated/numpy.dtype.__lt__.html

方法

dtype.__lt__(value, /)

返回 self<value。

索引例程

原文：numpy.org/doc/1.26/reference/arrays.indexing.html

另請參閱

ndarray 上的索引

生成索引陣列

c_	將切片物件轉換為沿第二軸的串聯。
r_	將切片物件轉換為沿第一軸的串聯。
s_	為陣列構建索引元組的更好方式。
nonzero(a)	返回非零元素的索引。
where(condition, [x, y], /)	根據condition選擇x或y中的元素。
indices(dimensions[, dtype, sparse])	返回表示網格索引的陣列。
ix_(*args)	從多個序列構造開放網格。
ogrid	返回開放多維“網格”。
ravel_multi_index(multi_index, dims[, mode, ...])	將索引陣列的元組轉換為平面索引的陣列，並將邊界模式應用於多索引。
unravel_index(indices, shape[, order])	將平面索引或平面索引陣列轉換為座標陣列的元組。
diag_indices(n[, ndim])	返回訪問陣列主對角線的索引。
diag_indices_from(arr)	返回訪問 n 維陣列主對角線的索引。
mask_indices(n, mask_func[, k])	返回訪問(n, n)陣列的索引，給定一個掩碼函式。
tril_indices(n[, k, m])	返回(n, m)陣列的下三角形的索引。
tril_indices_from(arr[, k])	返回 arr 的下三角形的索引。
triu_indices(n[, k, m])	返回(n, m)陣列的上三角形的索引。
triu_indices_from(arr[, k])	返回陣列上三角的索引。

類似索引的操作

take(a, indices[, axis, out, mode])	沿著軸取出陣列中的元素。
take_along_axis(arr, indices, axis)	透過匹配 1d 索引和資料切片，從輸入陣列中取值。
choose(a, choices[, out, mode])	從索引陣列和要選擇的陣列列表構造陣列。
compress(condition, a[, axis, out])	根據給定的軸返回陣列的選擇片段。
diag(v[, k])	提取對角線或構造對角線陣列。
diagonal(a[, offset, axis1, axis2])	返回指定的���角線。
select(condlist, choicelist[, default])	根據條件返回從選擇列表中抽取的陣列。
lib.stride_tricks.sliding_window_view(x, ...)	建立一個視窗形狀的滑動視窗檢視到陣列中。
lib.stride_tricks.as_strided(x[, shape, ...])	用給定的形狀和跨度建立陣列的檢視。

將資料插入陣列

place(arr, mask, vals)	根據條件和輸入值更改陣列的元素。
put(a, ind, v[, mode])	用給定的值替換陣列的指定元素。
put_along_axis(arr, indices, values, axis)	透過匹配 1d 索引和資料切片，將值放入目標陣列。
putmask(a, mask, values)	根據條件和輸入值更改陣列的元素。
fill_diagonal(a, val[, wrap])	填充給定陣列的任意尺寸的主對角線。

透過陣列進行迭代

nditer(op[, flags, op_flags, op_dtypes, ...])	高效的多維迭代器物件，用於對陣列進行迭代。
ndenumerate(arr)	多維索引迭代器。
ndindex(*shape)	用於索引陣列的 N 維迭代器物件。
nested_iters(op, axes[, flags, op_flags, ...])	建立用於巢狀迴圈的 nditers
flatiter()	用於遍歷陣列的平坦迭代器物件。
lib.Arrayterator(var[, buf_size])	大陣列的緩衝迭代器。
iterable(y)	檢查物件是否可迭代。

生成索引陣列

c_	將切片物件轉換為沿第二軸的連線。
r_	將切片物件轉換為沿第一軸的連線。
s_	用於構建陣列的索引元組的更好方式。
nonzero(a)	返回非零元素的索引。
where(condition, [x, y], /)	根據條件從 x 或 y 中選取元素。
indices(dimensions[, dtype, sparse])	返回表示網格索引的陣列。
ix_(*args)	從多個序列構建開放網格。
ogrid	返回一個開放的多維“網格”例項。
ravel_multi_index(multi_index, dims[, mode, ...])	將索引陣列的元組轉換為平坦索引陣列，適用於多索引的邊界模式。
unravel_index(indices, shape[, order])	將平坦索引或平坦索引陣列轉換為座標陣列的元組。
diag_indices(n[, ndim])	返回訪問陣列主對角線的索引。
diag_indices_from(arr)	返回訪問 n 維陣列主對角線的索引。
mask_indices(n, mask_func[, k])	返回使用掩碼函式訪問（n, n）陣列的索引。
tril_indices(n[, k, m])	返回（n, m）陣列的下三角形的索引。
tril_indices_from(arr[, k])	返回陣列的下三角形的索引。
triu_indices(n[, k, m])	返回（n, m）陣列的上三角形的索引。
triu_indices_from(arr[, k])	返回陣列的上三角形的索引。

類似索引的操作

take(a, indices[, axis, out, mode])	沿軸取陣列中的元素。
take_along_axis(arr, indices, axis)	透過匹配一維索引和資料切片從輸入陣列中獲取值。
choose(a, choices[, out, mode])	從索引陣列和要選擇的陣列列表構造陣列。
compress(condition, a[, axis, out])	返回給定軸上陣列的選定切片。
diag(v[, k])	提取對角線或構造對角線陣列。
diagonal(a[, offset, axis1, axis2])	返回指定的對角線。
select(condlist, choicelist[, default])	根據條件從 choicelist 中返回一個陣列。
lib.stride_tricks.sliding_window_view(x, ...)	使用給定的視窗形狀建立陣列的滑動視窗檢視。
lib.stride_tricks.as_strided(x[, shape, ...])	使用給定的形狀和步幅建立陣列的檢視。

向陣列中插入資料

place(arr, mask, vals)	根據條件和輸入值更改陣列的元素。
put(a, ind, v[, mode])	用給定值替換陣列的指定元素。
put_along_axis(arr, indices, values, axis)	透過匹配一維索引和資料切片將值放入目標陣列。
putmask(a, mask, values)	基於條件和輸入值更改陣列元素。
fill_diagonal(a, val[, wrap])	填充給定任意維度陣列的主對角線。

遍歷陣列

nditer(op[, flags, op_flags, op_dtypes, ...])	高效的多維迭代器物件，用於遍歷陣列。
ndenumerate(arr)	多維索引迭代器。
ndindex(*shape)	用於索引陣列的 N 維迭代器物件。
nested_iters(op, axes[, flags, op_flags, ...])	建立用於巢狀迴圈的 nditer。
flatiter()	用於遍歷陣列的扁平迭代器物件。
lib.Arrayterator(var[, buf_size])	大型陣列的緩衝迭代器。
iterable(y)	檢查物件是否可迭代。

numpy.c_

原文：numpy.org/doc/1.26/reference/generated/numpy.c_.html

numpy.c_ = <numpy.lib.index_tricks.CClass object>

將切片物件轉換為沿第二軸的串聯。

這是np.r_['-1,2,0', index expression]的簡寫形式，由於其常見性而很有用。特別是，在將至少升級為 2-D 的陣列沿著最後一個軸堆疊時，將以 1 追加到形狀的末尾（由 1-D 陣列製成的列向量）。

請參閱

column_stack

將 1-D 陣列堆疊為列，形成一個 2-D 陣列。

r_

關於更詳細的文件。

示例

>>> np.c_[np.array([1,2,3]), np.array([4,5,6])]
array([[1, 4],
 [2, 5],
 [3, 6]])
>>> np.c_[np.array([[1,2,3]]), 0, 0, np.array([[4,5,6]])]
array([[1, 2, 3, ..., 4, 5, 6]]) 

numpy.r_

原文：numpy.org/doc/1.26/reference/generated/numpy.r_.html

numpy.r_ = <numpy.lib.index_tricks.RClass object>

將切片物件轉換為沿著第一個軸的連線。

這是快速構建陣列的簡單方法。有兩種用法。

1. 如果索引表示式包含逗號分隔的陣列，則將它們沿著它們的第一個軸堆疊。

2. 如果索引表示式包含切片表示法或標量，則使用切片表示法建立一個 1-D 陣列。

如果使用切片表示法，則語法start:stop:step等同於括號內的np.arange(start, stop, step)。但是，如果step是一個虛數（即 100j），那麼它的整數部分將被解釋為所需的點數，而開始和停止是包含的。換句話說，start:stop:stepj被解釋為括號內的np.linspace(start, stop, step, endpoint=1)。在展開切片表示法後，所有逗號分隔的序列都會連線在一起。

放置在索引表示式的第一個元素位置的可選字元字串可用於更改輸出。字串‘r’或‘c’會產生矩陣輸出。如果結果是 1-D 並且指定了‘r’，則會產生 1 x N（行）矩陣。如果結果是 1-D 並且指定了‘c’，則會產生 N x 1（列）矩陣。如果結果是 2-D，則兩者都提供相同的矩陣結果。

字串整數指定要堆疊多個逗號分隔陣列的軸。兩個逗號分隔的整數字符串允許指示將每個條目強制放入的最小維度數作為第二個整數（仍然是沿著第一個整數指定的軸進行連線）。

一個包含三個逗號分隔整數的字串允許指定要沿著連線的軸，要強制條目的最小維度以及哪個軸應該包含少於指定維度數的陣列的起始位置。換句話說，第三個整數允許您指定 1 應該放置在升級形狀的陣列的形狀元組的前面。第三個引數允許您指定陣列的起始位置。因此，第三個引數為‘0’將 1 放置在陣列形狀的末尾。負整數指定升級陣列的最後一個維度應放置在新形狀元組中的位置，因此預設值為‘-1’。

引數：

不是一個函式，所以不接受引數

返回：

一個連線的 ndarray 或矩陣。

另請參閱

concatenate

沿著現有軸連線一個陣列序列。

c_

將切片物件轉換為沿著第二個軸的連線。

示例

>>> np.r_[np.array([1,2,3]), 0, 0, np.array([4,5,6])]
array([1, 2, 3, ..., 4, 5, 6])
>>> np.r_[-1:1:6j, [0]*3, 5, 6]
array([-1\. , -0.6, -0.2,  0.2,  0.6,  1\. ,  0\. ,  0\. ,  0\. ,  5\. ,  6\. ]) 

字串整數指定要沿著連線的軸或要強制條目進入的最小維度數。

>>> a = np.array([[0, 1, 2], [3, 4, 5]])
>>> np.r_['-1', a, a] # concatenate along last axis
array([[0, 1, 2, 0, 1, 2],
 [3, 4, 5, 3, 4, 5]])
>>> np.r_['0,2', [1,2,3], [4,5,6]] # concatenate along first axis, dim>=2
array([[1, 2, 3],
 [4, 5, 6]]) 

>>> np.r_['0,2,0', [1,2,3], [4,5,6]]
array([[1],
 [2],
 [3],
 [4],
 [5],
 [6]])
>>> np.r_['1,2,0', [1,2,3], [4,5,6]]
array([[1, 4],
 [2, 5],
 [3, 6]]) 

將‘r’或‘c’用作第一個字串引數會建立一個矩陣。

>>> np.r_['r',[1,2,3], [4,5,6]]
matrix([[1, 2, 3, 4, 5, 6]]) 

numpy.s_

原文：numpy.org/doc/1.26/reference/generated/numpy.s_.html

numpy.s_ = <numpy.lib.index_tricks.IndexExpression object>

為陣列構建索引元組的更好方法。

注意

使用兩個預定義例項index_exp或s_而不是直接使用IndexExpression。

對於任何索引組合，包括切片和軸插入，a[indices]與a[np.index_exp[indices]]對於任何陣列a來說是相同的。然而，np.index_exp[indices]可以在 Python 程式碼的任何地方使用，並返回一個可以用於構建複雜索引表示式的切片物件元組。

引數：

maketuplebool

如果為 True，始終返回一個元組。

另請參閱

index_exp

預定義例項，始終返回一個元組：index_exp = IndexExpression(maketuple=True)。

s_

預定義例項，不進行元組轉換：s_ = IndexExpression(maketuple=False)。

注意

您可以使用slice()加上一些特殊物件來完成所有這些操作，但這樣做需要記住很多東西，這個版本更簡單，因為它使用標準的陣列索引語法。

例子

>>> np.s_[2::2]
slice(2, None, 2)
>>> np.index_exp[2::2]
(slice(2, None, 2),) 

>>> np.array([0, 1, 2, 3, 4])[np.s_[2::2]]
array([2, 4]) 

numpy.nonzero

原文：numpy.org/doc/1.26/reference/generated/numpy.nonzero.html

numpy.nonzero(a)

返回非零元素的索引。

返回一個陣列的元組，對應於 a 的每個維度，其中包含該維度中非零元素的索引。a 中的值始終以行主序（C 風格）進行測試和返回。

若要按元素而不是按維度對索引進行分組，請使用 argwhere，它會為每個非零元素返回一行。

注意

當對零維陣列或標量呼叫時，nonzero(a) 被視為 nonzero(atleast_1d(a))。

自 NumPy 版本 1.17.0 起已棄用：如果此行為是故意的，請顯式使用 atleast_1d。

引數：

aarray_like

輸入陣列。

返回：

tuple_of_arraystuple

非零元素的索引。

參見

flatnonzero

返回輸入陣列的扁平化版本中非零的索引。

ndarray.nonzero

對應的 ndarray 方法。

count_nonzero

計算輸入陣列中非零元素的數量。

注意

雖然可以透過 a[nonzero(a)] 獲取非零值，但建議改用 x[x.astype(bool)] 或 x[x != 0]，它們會正確處理 0 維陣列。

示例

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

>>> x[np.nonzero(x)]
array([3, 4, 5, 6])
>>> np.transpose(np.nonzero(x))
array([[0, 0],
 [1, 1],
 [2, 0],
 [2, 1]]) 

nonzero 的一個常見用法是查詢陣列中滿足條件為 True 的索引。給定一個陣列 a，條件 a > 3 是一個布林陣列，由於 False 被解釋為 0，np.nonzero(a > 3) 會返回條件為真的 a 的索引。

>>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> a > 3
array([[False, False, False],
 [ True,  True,  True],
 [ True,  True,  True]])
>>> np.nonzero(a > 3)
(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) 

使用此結果對 a 進行索引等同於直接使用掩碼：

>>> a[np.nonzero(a > 3)]
array([4, 5, 6, 7, 8, 9])
>>> a[a > 3]  # prefer this spelling
array([4, 5, 6, 7, 8, 9]) 

nonzero 也可以作為陣列的方法呼叫。

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

numpy.where

原文：numpy.org/doc/1.26/reference/generated/numpy.where.html

numpy.where(condition, [x, y, ]/)

根據condition從x或y中選擇元素。

注意

當僅提供condition時，此函式是np.asarray(condition).nonzero()的縮寫。應優先使用nonzero，因為它對子類的行為表現正確。本文件的其餘部分僅涵蓋提供所有三個引數的情況。

引數：

conditionarray_like, bool

若為 True，則產生x，否則產生y。

x, yarray_like

需要選擇的值。x、y和condition需要廣播到某種形狀。

返回：

outndarray

返回一個陣列，其中condition為 True 時元素來自x，其他情況下元素來自y。

另請參閱

choose

nonzero

忽略x和y時呼叫的函式

注意事項

如果所有陣列都是 1-D，則where等同於：

[xv if c else yv
 for c, xv, yv in zip(condition, x, y)] 

示例

>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.where(a < 5, a, 10*a)
array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90]) 

這也可以用於多維陣列：

>>> np.where([[True, False], [True, True]],
...          [[1, 2], [3, 4]],
...          [[9, 8], [7, 6]])
array([[1, 8],
 [3, 4]]) 

x、y 和 condition 的形狀一起進行廣播：

>>> x, y = np.ogrid[:3, :4]
>>> np.where(x < y, x, 10 + y)  # both x and 10+y are broadcast
array([[10,  0,  0,  0],
 [10, 11,  1,  1],
 [10, 11, 12,  2]]) 

>>> a = np.array([[0, 1, 2],
...               [0, 2, 4],
...               [0, 3, 6]])
>>> np.where(a < 4, a, -1)  # -1 is broadcast
array([[ 0,  1,  2],
 [ 0,  2, -1],
 [ 0,  3, -1]]) 

numpy.indices

原文：numpy.org/doc/1.26/reference/generated/numpy.indices.html

numpy.indices(dimensions, dtype=<class 'int'>, sparse=False)

返回表示網格索引的陣列。

計算一個陣列，其中子陣列包含索引值 0、1、...僅在相應軸上變化。

引數：

dimensions一系列整數

網格的形狀。

dtype資料型別，可選

結果的資料型別。

sparse布林值，可選

返回網格的稀疏表示而不是密集表示。預設為 False。

版本 1.17 中的新功能。

返回：

grid一個 ndarray 或 ndarray 的元組

如果 sparse 為 False：

返回一個包含網格索引的陣列，grid.shape = (len(dimensions),) + tuple(dimensions)。

如果 sparse 為 True：

返回一個包含陣列的元組，其中grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)，其中 dimensions[i]在第 i 個位置

另請參見

mgrid, ogrid, meshgrid

注意事項

在密集情況下，輸出形狀是透過在維度元組前面加上維數的數量來獲得的，即如果dimensions是長度為N的元組(r0, ..., rN-1)，輸出形狀是(N, r0, ..., rN-1)。

子陣列grid[k]包含沿著第k軸的 N-D 索引陣列。明確地說：

grid[k, i0, i1, ..., iN-1] = ik 

示例

>>> grid = np.indices((2, 3))
>>> grid.shape
(2, 2, 3)
>>> grid[0]        # row indices
array([[0, 0, 0],
 [1, 1, 1]])
>>> grid[1]        # column indices
array([[0, 1, 2],
 [0, 1, 2]]) 

這些索引可用作陣列的索引。

>>> x = np.arange(20).reshape(5, 4)
>>> row, col = np.indices((2, 3))
>>> x[row, col]
array([[0, 1, 2],
 [4, 5, 6]]) 

注意，在上述示例中，直接使用x[:2, :3]提取所需元素會更直接。

如果 sparse 設定為 true，則將以稀疏表示形式返回網格。

>>> i, j = np.indices((2, 3), sparse=True)
>>> i.shape
(2, 1)
>>> j.shape
(1, 3)
>>> i        # row indices
array([[0],
 [1]])
>>> j        # column indices
array([[0, 1, 2]]) 

numpy.ix_

原文：numpy.org/doc/1.26/reference/generated/numpy.ix_.html

numpy.ix_(*args)

從多個序列構建一個開放的網格。

此函式接受 N 1-D 序列，並返回 N 個輸出，每個輸出都有 N 個維度，使得形狀在除了一個維度外都是 1，並且具有非單位形狀值的維度會在所有 N 個維度上迴圈。

使用ix_可以快速構建索引陣列，以便對交叉積進行索引。 a[np.ix_([1,3],[2,5])] 返回陣列[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]。

引數：

args1-D 序列

每個序列都應該是整數或布林型別。布林序列將被解釋為相應維度的布林掩碼（相當於傳入np.nonzero(boolean_sequence)）。

返回：

outndarrays 的元組

N 個陣列，每個陣列都有 N 個維度，N 是輸入序列的數量。這些陣列一起形成一個開放的網格。

另請參閱

ogrid, mgrid, meshgrid

示例

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

>>> ixgrid = np.ix_([True, True], [2, 4])
>>> a[ixgrid]
array([[2, 4],
 [7, 9]])
>>> ixgrid = np.ix_([True, True], [False, False, True, False, True])
>>> a[ixgrid]
array([[2, 4],
 [7, 9]]) 

numpy.ogrid

原文：numpy.org/doc/1.26/reference/generated/numpy.ogrid.html

numpy.ogrid = <numpy.lib.index_tricks.OGridClass object>

一個返回多維“網格”的例項。

一個例項，當索引時返回一個開放的（即未完全展開的）網格，使得返回的陣列中只有一個維度大於 1。輸出陣列的維度和數量等於索引維度的數量。如果步長不是一個複數，那麼結束值就不包括在內。

但是，如果步長是一個複數（例如 5j），那麼其大小的整數部分被解釋為指定開始和結束值之間要建立的點的數量，其中結束值是包括在內的。

返回：

網格

ndarrays，只有一個維度不等於 1

另請參閱

mgrid

就像ogrid但返回密集的（或完全展開的）網格

meshgrid

從座標向量返回座標矩陣

r_

陣列串聯器

如何建立具有等間距數值的陣列

例子

>>> from numpy import ogrid
>>> ogrid[-1:1:5j]
array([-1\. , -0.5,  0\. ,  0.5,  1\. ])
>>> ogrid[0:5,0:5]
[array([[0],
 [1],
 [2],
 [3],
 [4]]), array([[0, 1, 2, 3, 4]])] 

numpy.ravel_multi_index

原文：numpy.org/doc/1.26/reference/generated/numpy.ravel_multi_index.html

numpy.ravel_multi_index(multi_index, dims, mode='raise', order='C')

將索引陣列的元組轉換為扁平索引陣列，並將邊界模式應用到多重索引。

引數：

multi_indexarray_like 的元組

整數陣列的元組，每個維度一個陣列。

dims整數的元組

從multi_index應用到的陣列的形狀。

mode，可選

指定如何處理越界索引。可以指定一個模式或一個模式元組，每個索引一個模式。

• ‘raise’ – 報錯（預設）

• ‘wrap’ – 復原

• ‘clip’ – 剪下到範圍內

在‘clip’模式下，通常會復原的負索引將剪下到 0。

order，可選

確定多重索引是否應視為按行主要（C 風格）或按列主要（Fortran 風格）順序的索引。

返回：

raveled_indicesndarray（扁平化的索引）

一個陣列的索引，該陣列是dims維度的扁平化版本。

另請參閱

unravel_index

註釋

新版本 1.6.0 中新增。

示例

>>> arr = np.array([[3,6,6],[4,5,1]])
>>> np.ravel_multi_index(arr, (7,6))
array([22, 41, 37])
>>> np.ravel_multi_index(arr, (7,6), order='F')
array([31, 41, 13])
>>> np.ravel_multi_index(arr, (4,6), mode='clip')
array([22, 23, 19])
>>> np.ravel_multi_index(arr, (4,4), mode=('clip','wrap'))
array([12, 13, 13]) 

>>> np.ravel_multi_index((3,1,4,1), (6,7,8,9))
1621 

numpy.unravel_index

原文：numpy.org/doc/1.26/reference/generated/numpy.unravel_index.html

numpy.unravel_index(indices, shape, order='C')

將一個平坦索引或平坦索引陣列轉換為座標陣列的元組。

引數：

indices類陣列

一個整數陣列，其元素是指向形狀為shape的陣列的展開版本的索引。在 1.6.0 版本之前，此函式只接受一個索引值。

shape由整陣列成的元組

用於展開indices的陣列的形狀。

在 1.16.0 版本中更改：從dims改名為shape。

order, 可選

確定是否將索引視為按行主要（C 樣式）或按列主要（Fortran 樣式）順序索引。

從 1.6.0 版本開始新加入。

返回值：

unraveled_coords由 ndarray 組成的元組

元組中的每個陣列與indices陣列具有相同的形狀。

另請參見

ravel_multi_index

示例

>>> np.unravel_index([22, 41, 37], (7,6))
(array([3, 6, 6]), array([4, 5, 1]))
>>> np.unravel_index([31, 41, 13], (7,6), order='F')
(array([3, 6, 6]), array([4, 5, 1])) 

>>> np.unravel_index(1621, (6,7,8,9))
(3, 1, 4, 1) 

numpy.diag_indices

numpy.org/doc/1.26/reference/generated/numpy.diag_indices.html

numpy.diag_indices(n, ndim=2)

返回用於訪問陣列的主對角線的索引。

這將返回一個元組索引，可用於訪問具有 a.ndim >= 2 維度和形狀 (n, n, …, n) 的陣列 a 的主對角線。對於 a.ndim = 2，這是通常的對角線，對於 a.ndim > 2，這是一組索引，用於訪問 a[i, i, ..., i]，其中 i = [0..n-1]。

引數：

nint

返回的索引可用於訪問陣列的每個維度的大小。

ndimint, 可選

維度的數量。

另請參閱

diag_indices_from

注意事項

自 1.4.0 版本新增。

示例

建立一組用於訪問 (4, 4) 陣列的對角線的索引：

>>> di = np.diag_indices(4)
>>> di
(array([0, 1, 2, 3]), array([0, 1, 2, 3]))
>>> a = np.arange(16).reshape(4, 4)
>>> a
array([[ 0,  1,  2,  3],
 [ 4,  5,  6,  7],
 [ 8,  9, 10, 11],
 [12, 13, 14, 15]])
>>> a[di] = 100
>>> a
array([[100,   1,   2,   3],
 [  4, 100,   6,   7],
 [  8,   9, 100,  11],
 [ 12,  13,  14, 100]]) 

現在，我們建立用於操作 3-D 陣列的索引：

>>> d3 = np.diag_indices(2, 3)
>>> d3
(array([0, 1]), array([0, 1]), array([0, 1])) 

並將其用於將零陣列的對角線設定為 1：

>>> a = np.zeros((2, 2, 2), dtype=int)
>>> a[d3] = 1
>>> a
array([[[1, 0],
 [0, 0]],
 [[0, 0],
 [0, 1]]]) 

numpy.diag_indices_from

原文：numpy.org/doc/1.26/reference/generated/numpy.diag_indices_from.html

numpy.diag_indices_from(arr)

返回訪問 n 維陣列主對角線的索引。

檢視完整詳情，請參閱diag_indices。

引數：

arr陣列，至少為 2 維

另請參閱

diag_indices

注意事項

新版本 1.4.0 中新增。

示例

建立一個 4x4 的陣列。

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

獲取對角線元素的索引。

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

>>> a[di]
array([ 0,  5, 10, 15]) 

這只是 diag_indices 的一種簡便寫法。

>>> np.diag_indices(a.shape[0])
(array([0, 1, 2, 3]), array([0, 1, 2, 3])) 

numpy.mask_indices

原文：numpy.org/doc/1.26/reference/generated/numpy.mask_indices.html

numpy.mask_indices(n, mask_func, k=0)

給定掩碼函式，返回訪問(n, n)陣列的索引。

假設mask_func是一個函式，對於一個可能有偏移引數k的大小為(n, n)的方形陣列a，當呼叫mask_func(a, k)時，它返回一個在特定位置有零值的新陣列（例如triu或tril函式會精確實現此操作）。然後，此函式返回非零值將位於的索引處。

引數：

n整數

返回的索引將可用於訪問形狀為(n, n)的陣列。

mask_func可呼叫物件

一個呼叫簽名與triu，tril類似的函式。也就是說，mask_func(x, k)返回一個布林陣列，形狀類似於x。k是函式的可選引數。

k標量

一個可選的引數，會傳遞給mask_func。triu，tril等函式接受第二個引數作為偏移量。

返回：

indices陣列的元組。

與mask_func(np.ones((n, n)), k)為 True 的位置對應的n個索引陣列。

另請參閱

triu，tril，triu_indices，tril_indices

注意

版本 1.4.0 中新增。

示例

這些是允許你訪問任何 3x3 陣列的上三角部分的索引：

>>> iu = np.mask_indices(3, np.triu) 

例如，如果a是一個 3x3 陣列：

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

掩碼函式也可以傳遞偏移量。這將使我們從主對角線右側的第一個對角線開始的索引：

>>> iu1 = np.mask_indices(3, np.triu, 1) 

現在我們只提取了三個元素：

>>> a[iu1]
array([1, 2, 5]) 

numpy.tril_indices

原文：numpy.org/doc/1.26/reference/generated/numpy.tril_indices.html

numpy.tril_indices(n, k=0, m=None)

返回（n，m）陣列的下三角形的索引。

引數：

nint

返回的索引將有效的陣列的行維度。

kint，可選

對角線偏移（詳見tril）。

mint，可選

自 1.9.0 版本開始新增。

返回的陣列將有效的陣列的列維度。預設情況下，m取等於n。

返回：

inds陣列的元組

三角形的索引。返回的元組包含兩個陣列，每個陣列都有陣列的一個維度上的索引。

另請參見

triu_indices

類似的函式，用於上三角。

mask_indices

接受任意掩碼函式的通用函式。

tril，triu

注意

自 1.4.0 版本開始新增。

示例

計算兩組不同的索引，用於訪問 4x4 陣列，一組用於從主對角線開始的下三角部分，另一組從右邊開始兩個對角線。

>>> il1 = np.tril_indices(4)
>>> il2 = np.tril_indices(4, 2) 

下面是如何在示例陣列中使用它們：

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

兩者均可用於索引：

>>> a[il1]
array([ 0,  4,  5, ..., 13, 14, 15]) 

以及用於賦值：

>>> a[il1] = -1
>>> a
array([[-1,  1,  2,  3],
 [-1, -1,  6,  7],
 [-1, -1, -1, 11],
 [-1, -1, -1, -1]]) 

這些幾乎覆蓋整個陣列（主對角線右側兩個對角線）：

>>> a[il2] = -10
>>> a
array([[-10, -10, -10,   3],
 [-10, -10, -10, -10],
 [-10, -10, -10, -10],
 [-10, -10, -10, -10]]) 

numpy.tril_indices_from

原文：numpy.org/doc/1.26/reference/generated/numpy.tril_indices_from.html

numpy.tril_indices_from(arr, k=0)

返回 arr 的下三角形的索引。

詳細資訊請參見tril_indices。

引數:

arrarray_like

這些索引將適用於維度與 arr 相同的方陣。

kint，可選

對角線偏移（見tril的詳細資訊）。

另請參見

tril_indices，tril，triu_indices_from

注意事項

新版本 1.4.0 中新增。

示例

建立一個 4x4 的陣列。

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

將陣列傳遞以獲取下三角元素的索引。

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

>>> a[trili]
array([ 0,  4,  5,  8,  9, 10, 12, 13, 14, 15]) 

這只是tril_indices的語法糖。

>>> np.tril_indices(a.shape[0])
(array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3])) 

使用 k 引數來返回低於第 k 個對角線的下三角形陣列的索引。

>>> trili1 = np.tril_indices_from(a, k=1)
>>> a[trili1]
array([ 0,  1,  4,  5,  6,  8,  9, 10, 11, 12, 13, 14, 15]) 

numpy.triu_indices

原文：numpy.org/doc/1.26/reference/generated/numpy.triu_indices.html

numpy.triu_indices(n, k=0, m=None)

返回一個(n, m) 陣列的上三角形的索引。

引數：

nint

返回的索引有效的陣列大小。

kint，可選

對角線偏移（詳情請參閱 triu）。

mint，可選

在 1.9.0 版中新增。

返回的陣列有效的列維度。預設情況下，m 等於 n。

返回：

indstuple，ndarrays 的形狀為(2, n)

三角形的索引。返回的元組包含兩個陣列，每個陣列沿陣列的一個維度的索引。可用於切片形狀為(n, n)的 ndarray。

另請參見

tril_indices

用於下三角形的類似函式。

mask_indices

接受任意掩碼函式的通用函式。

triu，tril

註釋

在 1.4.0 版中新加入。

示例

計算兩組不同的索引，以訪問 4x4 陣列，一組從主對角線開始的上三角部分，另一組從右邊的兩個對角線開始：

>>> iu1 = np.triu_indices(4)
>>> iu2 = np.triu_indices(4, 2) 

以下是它們如何與示例陣列一起使用的示例：

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

均用於索引：

>>> a[iu1]
array([ 0,  1,  2, ..., 10, 11, 15]) 

並用於賦值：

>>> a[iu1] = -1
>>> a
array([[-1, -1, -1, -1],
 [ 4, -1, -1, -1],
 [ 8,  9, -1, -1],
 [12, 13, 14, -1]]) 

這些僅覆蓋整個陣列的一小部分（主對角線的右側兩個對角線）：

>>> a[iu2] = -10
>>> a
array([[ -1,  -1, -10, -10],
 [  4,  -1,  -1, -10],
 [  8,   9,  -1,  -1],
 [ 12,  13,  14,  -1]]) 

numpy.triu_indices_from

原文：numpy.org/doc/1.26/reference/generated/numpy.triu_indices_from.html

numpy.triu_indices_from(arr, k=0)

返回 arr 的上三角的索引。

詳細資訊請參見 triu_indices。

引數：

arr 形狀為 (N, N) 的 ndarray

這些索引對於方陣是有效的。

k 整型，可選

對角線偏移（詳情請參見 triu）。

返回：

triu_indices_from 元組，形狀為 (2) 的 ndarray，形狀為 (N) 的 ndarray

arr 的上三角的索引。

另請參見

triu_indices, triu, tril_indices_from

註解

在 1.4.0 版本中新增。

示例

建立一個 4 行 4 列的陣列。

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

將陣列傳遞以獲取上三角元素的索引。

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

>>> a[triui]
array([ 0,  1,  2,  3,  5,  6,  7, 10, 11, 15]) 

這是 triu_indices() 的語法糖。

>>> np.triu_indices(a.shape[0])
(array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3, 3])) 

使用 k 引數返回從第 k 個對角線開始的上三角陣列的索引。

>>> triuim1 = np.triu_indices_from(a, k=1)
>>> a[triuim1]
array([ 1,  2,  3,  6,  7, 11]) 

numpy.take

原文：numpy.org/doc/1.26/reference/generated/numpy.take.html

numpy.take(a, indices, axis=None, out=None, mode='raise')

沿軸取陣列中的元素。

當 axis 不是 None 時, 此函式與"花式"索引（使用陣列進行陣列索引）執行相同的操作，但如果需要沿指定軸獲取元素，則可能更容易使用。類似於np.take(arr, indices, axis=3)的呼叫等價於arr[:,:,:,indices,...]。

解釋不使用 fancy 索引，這等同於以下對ndindex的使用，它將ii、jj和kk中的每一個設定為索引的元組：

Ni, Nk = a.shape[:axis], a.shape[axis+1:]
Nj = indices.shape
for ii in ndindex(Ni):
    for jj in ndindex(Nj):
        for kk in ndindex(Nk):
            out[ii + jj + kk] = a[ii + (indices[jj],) + kk] 

引數:

aarray_like (Ni…, M, Nk…)

源陣列。

indicesarray_like (Nj…)

要提取的值的索引。

在 1.8.0 版本中新增。

也允許索引為標量。

axisint, optional

選擇值的軸。預設情況下，使用扁平化的輸入陣列。

outndarray, optional (Ni…, Nj…, Nk…)

如果提供，結果將放入此陣列中。它應該具有適當的形狀和 dtype。注意，如果mode=’raise’，out始終被緩衝；使用其他模式以獲得更好的效能。

mode, optional

指定越界索引的行為。

• ‘raise’ – 丟擲錯誤（預設）

• ‘wrap’ – 包裝

• ‘clip’ – 截斷到範圍內

‘clip’ 模式表示所有太大的索引都將被替換為地址該軸上的最後一個元素的索引。注意，這會禁用使用負數進行索引。

返回:

outndarray (Ni…, Nj…, Nk…)

返回的陣列與a具有相同的型別。

參見

compress

使用布林掩碼取元素

ndarray.take

等效方法

take_along_axis

透過匹配陣列和索引陣列取元素

注意

透過消除上面的描述中的內部迴圈，並使用s_構建簡單的切片物件，可以使用take在每個 1-D 切片上應用“fancy”索引來表達：

Ni, Nk = a.shape[:axis], a.shape[axis+1:]
for ii in ndindex(Ni):
    for kk in ndindex(Nj):
        out[ii + s_[...,] + kk] = a[ii + s_[:,] + kk][indices] 

出於這個原因，它等同於（但速度更快）以下對apply_along_axis的使用：

out = np.apply_along_axis(lambda a_1d: a_1d[indices], axis, a) 

例子

>>> a = [4, 3, 5, 7, 6, 8]
>>> indices = [0, 1, 4]
>>> np.take(a, indices)
array([4, 3, 6]) 

在這個例子中, 如果a是一個 ndarray, 可以使用“fancy”索引。

>>> a = np.array(a)
>>> a[indices]
array([4, 3, 6]) 

如果indices不是一維的，則輸出陣列也具有這些維度。

>>> np.take(a, [[0, 1], [2, 3]])
array([[4, 3],
 [5, 7]]) 

numpy.take_along_axis

原文：numpy.org/doc/1.26/reference/generated/numpy.take_along_axis.html

numpy.take_along_axis(arr, indices, axis)

透過匹配 1d 索引和資料切片從輸入陣列中取值。

這在索引和資料陣列上沿指定軸迭代匹配的 1d 切片，然後使用前者在後者中查詢值。這些切片可以具有不同的長度。

返回沿軸線的索引的函式，如 argsort 和 argpartition，可為此函式生成合適的索引。

版本 1.15.0 中的新增功能。

引數：

arrndarray（Ni…，M，Nk…）

源陣列

indicesndarray（Ni…，J，Nk…）

用於每個 1d 切片的索引。這必須與 arr 的維度相匹配，但是維度 Ni 和 Nj 只需要對 arr 進行廣播。

axisint

用於沿著某個軸切片的軸。如果軸為 None，則對輸入陣列進行 1d 扁平化處理，以保持與 sort 和 argsort 一致性。

返回：

out：ndarray（Ni…，J，Nk…）

索引結果。

另請參見

take

沿軸線進行處理，對每個 1d 切片使用相同的索引

put_along_axis

透過匹配 1d 索引和資料切片將值放入目標陣列

註釋

這等效於（但比其更快）以下對 ndindex 和 s_ 的使用，將 ii 和 kk 的每個設定為索引元組：

Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
J = indices.shape[axis]  # Need not equal M
out = np.empty(Ni + (J,) + Nk)

for ii in ndindex(Ni):
    for kk in ndindex(Nk):
        a_1d       = a      [ii + s_[:,] + kk]
        indices_1d = indices[ii + s_[:,] + kk]
        out_1d     = out    [ii + s_[:,] + kk]
        for j in range(J):
            out_1d[j] = a_1d[indices_1d[j]] 

或者，消除內部迴圈，最後兩行將是：

out_1d[:] = a_1d[indices_1d] 

示例

對於此示例陣列

>>> a = np.array([[10, 30, 20], [60, 40, 50]]) 

我們可以直接使用 sort 或 argsort 和此函式進行排序

>>> np.sort(a, axis=1)
array([[10, 20, 30],
 [40, 50, 60]])
>>> ai = np.argsort(a, axis=1)
>>> ai
array([[0, 2, 1],
 [1, 2, 0]])
>>> np.take_along_axis(a, ai, axis=1)
array([[10, 20, 30],
 [40, 50, 60]]) 

如果保持與 "keepdims" 的顯式維度：

>>> np.max(a, axis=1, keepdims=True)
array([[30],
 [60]])
>>> ai = np.argmax(a, axis=1, keepdims=True)
>>> ai
array([[1],
 [0]])
>>> np.take_along_axis(a, ai, axis=1)
array([[30],
 [60]]) 

如果我們同時想要獲得最大值和最小值，我們可以首先堆疊索引

>>> ai_min = np.argmin(a, axis=1, keepdims=True)
>>> ai_max = np.argmax(a, axis=1, keepdims=True)
>>> ai = np.concatenate([ai_min, ai_max], axis=1)
>>> ai
array([[0, 1],
 [1, 0]])
>>> np.take_along_axis(a, ai, axis=1)
array([[10, 30],
 [40, 60]]) 

numpy.choose

原文：numpy.org/doc/1.26/reference/generated/numpy.choose.html

numpy.choose(a, choices, out=None, mode='raise')

從索引陣列和要選擇的陣列列表構造陣列。

首先，如果感到困惑或不確定，請務必檢視示例 - 在其完整範圍內，此函式比下面的程式碼描述（下面是 numpy.lib.index_tricks）看起來要複雜得多。

np.choose(a, c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)]).

但這會忽略一些微妙之處。這裡是一個完全通用的總結：

給定整數“索引”陣列（a）和 n 個陣列（choices）的序列，a 和每個選擇的陣列首先按需廣播為共同形狀的陣列；將這些稱為 Ba 和 Bchoices[i], i = 0,…,n-1，我們有必然地，對於每個 i，Ba.shape == Bchoices[i].shape。然後，建立一個形狀為 Ba.shape 的新陣列，如下所示：

• 如果 mode='raise'（預設），則首先，a（因此 Ba）的每個元素必須在 [0, n-1] 範圍內；現在，假設 i（在該範圍內）是 Ba 中 (j0, j1, ..., jm) 位置的值 - 那麼在新陣列中相同位置的值是 Bchoices[i] 在同一位置處的值；

• 若 mode='wrap'，a（因此 Ba）中的值可以是任意（有符號）整數；使用模運算將範圍在 [0, n-1] 之外的整數對映回該範圍；然後構造新陣列如上；

• 如果 mode='clip'，a（因此 Ba）中的值可以是任意（有符號）整數；負整數對映為 0；大於 n-1 的值對映為 n-1；然後構造新陣列如上。

引數：

a整數陣列

該陣列必須包含 [0, n-1] 範圍內的整數，其中 n 是選擇的數量，除非 mode=wrap 或 mode=clip，在這種情況下，任何整數都是可接受的。

choices陣列序列

選擇陣列。a 和所有 choices 必須可廣播為相同形狀。如果 choices 本身是一個陣列（不建議），則其最外層維度（即對應於 choices.shape[0] 的那一維）被視為定義“序列”。

out陣列，可選

如果提供了，則結果將插入到此陣列中。它應具有適當的形狀和 dtype。請注意，如果 mode='raise'，則始終緩衝 out；用其他模式以獲得更好的效能。

mode，可選

指定 [0, n-1] 之外的索引如何處理：

• ‘raise’：引發異常
• ‘wrap’：值變為值對 n 取模
• ‘clip’：值小於 0 對映為 0，值大於 n-1 對映為 n-1

返回：

merged_array陣列

合併的結果。

引發：

ValueError: 形狀不匹配

如果 a 和每個選擇的陣列不能都廣播為相同形狀。

另請參閱

ndarray.choose

等效方法

numpy.take_along_axis

如果choices是一個陣列，則最好

注意

為了減少誤解的機會，即使下面的“濫用”在名義上是支援的，choices也不應該是單個陣列，即，最外層的類似序列的容器應該是一個列表或元組。

例子

>>> choices = [[0, 1, 2, 3], [10, 11, 12, 13],
...   [20, 21, 22, 23], [30, 31, 32, 33]]
>>> np.choose([2, 3, 1, 0], choices
... # the first element of the result will be the first element of the
... # third (2+1) "array" in choices, namely, 20; the second element
... # will be the second element of the fourth (3+1) choice array, i.e.,
... # 31, etc.
... )
array([20, 31, 12,  3])
>>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1)
array([20, 31, 12,  3])
>>> # because there are 4 choice arrays
>>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4)
array([20,  1, 12,  3])
>>> # i.e., 0 

一些示例說明選擇的廣播方式：

>>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]
>>> choices = [-10, 10]
>>> np.choose(a, choices)
array([[ 10, -10,  10],
 [-10,  10, -10],
 [ 10, -10,  10]]) 

>>> # With thanks to Anne Archibald
>>> a = np.array([0, 1]).reshape((2,1,1))
>>> c1 = np.array([1, 2, 3]).reshape((1,3,1))
>>> c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5))
>>> np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2
array([[[ 1,  1,  1,  1,  1],
 [ 2,  2,  2,  2,  2],
 [ 3,  3,  3,  3,  3]],
 [[-1, -2, -3, -4, -5],
 [-1, -2, -3, -4, -5],
 [-1, -2, -3, -4, -5]]]) 

numpy.compress

原文：numpy.org/doc/1.26/reference/generated/numpy.compress.html

numpy.compress(condition, a, axis=None, out=None)

返回沿給定軸選擇的陣列的選定切片。

在沿著給定軸工作時，每當condition評估為 True 時，就在output中返回該軸上的一個切片。在處理 1-D 陣列時，compress等效於extract。

引數：

conditionbool 值的 1-D 陣列

選擇要返回的條目的陣列。如果 len(condition)小於沿給定軸的a的大小，則輸出被截斷為條件陣列的長度。

aarray_like

從中提取部分的陣列。

軸int，可選

沿其獲取切片的軸。如果為 None（預設），則在扁平化的陣列上工作。

outndarray，可選

輸出陣列。其型別保持不變，必須具有正確的形狀以容納輸出。

返回：

compressed_arrayndarray

一個沒有沿軸切片的副本，其中condition為假。

另請參閱

take，choose，diag，diagonal，select

ndarray.compress

ndarray 中的等效方法

extract

在處理 1-D 陣列時的等效方法

輸出型別確定

例子

>>> a = np.array([[1, 2], [3, 4], [5, 6]])
>>> a
array([[1, 2],
 [3, 4],
 [5, 6]])
>>> np.compress([0, 1], a, axis=0)
array([[3, 4]])
>>> np.compress([False, True, True], a, axis=0)
array([[3, 4],
 [5, 6]])
>>> np.compress([False, True], a, axis=1)
array([[2],
 [4],
 [6]]) 

在扁平化的陣列上工作不會返回沿軸的切片，而是選擇元素。

>>> np.compress([False, True], a)
array([2]) 

numpy.diag

原文：numpy.org/doc/1.26/reference/generated/numpy.diag.html

numpy.diag(v, k=0)

提取對角線或構造對角線陣列。

如果您使用此函式提取對角線並希望對結果陣列進行寫入，請檢視numpy.diagonal的更詳細文件；它返回一個副本還是一個檢視取決於您使用的 numpy 版本。

引數：

varray_like

如果v是一個二維陣列，則返回其第k個對角線的副本。如果v是一個一維陣列，則返回一個二維陣列，其對角線上是v。

kint，可選

相關對角線。預設值為 0。對於主對角線上方的對角線，請使用k>0，對於主對角線下方的對角線，請使用k<0。

返回：

outndarray

提取的對角線或構造的對角線陣列。

另請參見

對角線

返回指定的對角線。

diagflat

使用扁平化輸入建立一個二維陣列作為對角線。

跡

沿對角線求和。

triu

陣列的上三角。

tril

陣列的下三角。

示例

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

>>> np.diag(x)
array([0, 4, 8])
>>> np.diag(x, k=1)
array([1, 5])
>>> np.diag(x, k=-1)
array([3, 7]) 

>>> np.diag(np.diag(x))
array([[0, 0, 0],
 [0, 4, 0],
 [0, 0, 8]]) 

numpy.diagonal

原文：numpy.org/doc/1.26/reference/generated/numpy.diagonal.html

numpy.diagonal(a, offset=0, axis1=0, axis2=1)

返回指定的對角線。

如果a是 2 維的，則返回給定偏移量的a的對角線，即形式為a[i, i+offset]的元素的集合。如果a的維度大於 2，則使用axis1和axis2指定的軸來確定返回的 2-D 子陣列的對角線。可以透過刪除axis1和axis2並在右側附加一個索引，其值等於所得到的對角線的大小，來確定結果陣列的形狀。

在 NumPy 的 1.7 版本之前，該函式總是返回一個包含對角線值的新的獨立陣列的副本。

在 NumPy 1.7 和 1.8 中，它繼續返回對角線的副本，但是依賴於此事實已經不推薦使用。寫入結果陣列的操作將按照以前的方式繼續工作，但會發出 FutureWarning 警告。

從 NumPy 1.9 開始，它返回原始陣列上的只讀檢視。嘗試寫入結果陣列將產生錯誤。

在將來的某個版本中，它將返回一個讀/寫檢視，並且對返回的陣列進行寫入將改變您的原始陣列。返回的陣列將具有與輸入陣列相同的型別。

如果您不對此函式返回的陣列進行寫入操作，則可以忽略上述所有內容。

如果您依賴當前行為，則建議顯式地複製返回的陣列，即使用np.diagonal(a).copy()而不僅僅是np.diagonal(a)。這將適用於過去和未來的 NumPy 版本。

引數：

aarray_like

對角線取自的陣列。

offsetint，可選

對角線偏離主對角線的偏移量。可以是正數或負數。預設為主對角線（0）。

axis1int，可選

用作應從其對角線被取出的 2-D 子陣列的第一個軸的軸。預設為第一個軸（0）。

axis2int，可選

用作應從其對角線被取出的 2-D 子陣列的第二個軸的軸。預設為第二個軸（1）。

返回：

array_of_diagonalsndarray

如果a是 2 維的，則返回一個包含對角線的 1 維陣列，並且型別與a相同，除非a是matrix，此時將返回一個 1 維陣列而不是（2 維）matrix，以保持向後相容性。

如果a.ndim > 2，則刪除由axis1和axis2指定的維度，並在末尾插入一個與對角線對應的新維度。

引發：

ValueError

如果a的維度小於 2。

參見

diag

適用於 1 維和 2 維陣列的類似 MATLAB 的工作。

diagflat

建立對角線陣列。

trace

沿對角線求和。

示例

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

一個 3-D 的例子：

>>> a = np.arange(8).reshape(2,2,2); a
array([[[0, 1],
 [2, 3]],
 [[4, 5],
 [6, 7]]])
>>> a.diagonal(0,  # Main diagonals of two arrays created by skipping
...            0,  # across the outer(left)-most axis last and
...            1)  # the "middle" (row) axis first.
array([[0, 6],
 [1, 7]]) 

我們剛剛獲得的主對角線的子陣列；需要注意的是，每個子陣列對應於固定最右側（列）軸，並且對角線在行中是“緊密排列”的。

>>> a[:,:,0]  # main diagonal is [0 6]
array([[0, 2],
 [4, 6]])
>>> a[:,:,1]  # main diagonal is [1 7]
array([[1, 3],
 [5, 7]]) 

反對角線可以透過使用numpy.flipud 或 numpy.fliplr 中的一個來反轉元素的順序來獲得。

>>> a = np.arange(9).reshape(3, 3)
>>> a
array([[0, 1, 2],
 [3, 4, 5],
 [6, 7, 8]])
>>> np.fliplr(a).diagonal()  # Horizontal flip
array([2, 4, 6])
>>> np.flipud(a).diagonal()  # Vertical flip
array([6, 4, 2]) 

需要注意的是根據反轉函式的不同，獲取對角線的順序也會發生變化。

numpy.select

原文：numpy.org/doc/1.26/reference/generated/numpy.select.html

numpy.select(condlist, choicelist, default=0)

根據條件從choicelist中的元素返回陣列。

引數：

condlistbool ndarrays 列表

決定輸出元素來自choicelist中哪個陣列的條件列表。當滿足多個條件時，使用condlist中首個遇到的條件。

choicelistndarrays 列表

輸出元素所取自的陣列列表。它必須與condlist的長度相同。

default標量，可選

當所有條件求值為 False 時插入output中的元素。

返回值：

outputndarray

位置 m 處的輸出是choicelist中的第 m 個元素，條件列表中對應陣列的第 m 個元素為 True。

另請參閱

where

根據條件從兩個陣列中返回元素。

take, choose, compress, diag, diagonal

示例

>>> x = np.arange(6)
>>> condlist = [x<3, x>3]
>>> choicelist = [x, x**2]
>>> np.select(condlist, choicelist, 42)
array([ 0,  1,  2, 42, 16, 25]) 

>>> condlist = [x<=4, x>3]
>>> choicelist = [x, x**2]
>>> np.select(condlist, choicelist, 55)
array([ 0,  1,  2,  3,  4, 25]) 

numpy.lib.stride_tricks.sliding_window_view

原文：numpy.org/doc/1.26/reference/generated/numpy.lib.stride_tricks.sliding_window_view.html

lib.stride_tricks.sliding_window_view(x, window_shape, axis=None, *, subok=False, writeable=False)

建立一個具有給定視窗形狀的陣列的滑動視窗檢視。

也稱為滾動視窗或移動視窗，視窗沿陣列的所有維度滑動，並在所有視窗位置提取陣列的子集。

版本 1.20.0 中的新功能。

引數：

xarray_like

建立滑動視窗檢視的陣列。

window_shapeint 或 int 元組

在參與滑動視窗的每個軸上的視窗大小。如果沒有axis，則必須具有與輸入陣列維度數量相同的長度。單個整數i會被視為元組(i,)。

axisint 或 int 元組，可選

應用滑動視窗的軸或軸。預設情況下，滑動視窗應用於所有軸，window_shape[i]將指向x的軸i。如果axis給出為int元組，window_shape[i]將指向x的軸axis[i]。單個整數i會被視為元組(i,)*。

subokbool，可選

如果為 True，則子類將被傳遞，否則返回的陣列將被強制為基類陣列（預設值）。

writeablebool，可選

True時，允許對返回的檢視進行寫入。預設值為False，因為這應謹慎使用：返回的檢視多次包含相同的記憶體位置，因此對一個位置的寫入將導致其他位置發生變化。

返回：

viewndarray

陣列的滑動視窗檢視。滑動視窗維度被插入到最後，並且根據滑動視窗的大小要求修剪原始維度。也就是說，view.shape = x_shape_trimmed + window_shape，其中x_shape_trimmed是透過使每個條目減少一個小於對應視窗大小的條目而獲得的x.shape。

另請參見

lib.stride_tricks.as_strided

用於從自定義形狀和步幅建立任意檢視的更低階別和不太安全的例程。

broadcast_to

將陣列廣播到給定的形狀。

注意事項

對於許多應用程式，使用滑動視窗檢視可能很方便，但可能非常慢。通常存在專門的解決方案，例如：

• scipy.signal.fftconvolve

• 在[scipy.ndimage](https://docs.scipy.org/doc/scipy/reference/ndimage.html#module-scipy.ndimage "(在 SciPy v1.11.2)”)中的過濾函式。

• bottleneck提供的移動視窗函式。

作為粗略估計，輸入尺寸為N，視窗尺寸為W的滑動視窗方法的時間複雜度為O(NW)，然而經常一個特殊演算法可以達到O(N)*。這意味著視窗尺寸為 100 的滑動視窗變體可能比更專門的版本慢 100 倍。

然而，對於小視窗尺寸，在沒有自定義演算法存在時，或作為原型化和開發工具時，這個函式可以是一個不錯的解決方案。

例子

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

這在更多維度上也適用，例如：

>>> i, j = np.ogrid[:3, :4]
>>> x = 10*i + j
>>> x.shape
(3, 4)
>>> x
array([[ 0,  1,  2,  3],
 [10, 11, 12, 13],
 [20, 21, 22, 23]])
>>> shape = (2,2)
>>> v = sliding_window_view(x, shape)
>>> v.shape
(2, 3, 2, 2)
>>> v
array([[[[ 0,  1],
 [10, 11]],
 [[ 1,  2],
 [11, 12]],
 [[ 2,  3],
 [12, 13]]],
 [[[10, 11],
 [20, 21]],
 [[11, 12],
 [21, 22]],
 [[12, 13],
 [22, 23]]]]) 

軸可以被明確定義：

>>> v = sliding_window_view(x, 3, 0)
>>> v.shape
(1, 4, 3)
>>> v
array([[[ 0, 10, 20],
 [ 1, 11, 21],
 [ 2, 12, 22],
 [ 3, 13, 23]]]) 

同一軸可以多次使用。在這種情況下，每次使用都會減少相應的原始維度：

>>> v = sliding_window_view(x, (2, 3), (1, 1))
>>> v.shape
(3, 1, 2, 3)
>>> v
array([[[[ 0,  1,  2],
 [ 1,  2,  3]]],
 [[[10, 11, 12],
 [11, 12, 13]]],
 [[[20, 21, 22],
 [21, 22, 23]]]]) 

結合步進切片（::step），這可以用於取跳過元素的滑動檢視：

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

或者移動多個元素的檢視

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

sliding_window_view的常見應用是計算滾動統計資料。最簡單的例子就是移動平均：

>>> x = np.arange(6)
>>> x.shape
(6,)
>>> v = sliding_window_view(x, 3)
>>> v.shape
(4, 3)
>>> v
array([[0, 1, 2],
 [1, 2, 3],
 [2, 3, 4],
 [3, 4, 5]])
>>> moving_average = v.mean(axis=-1)
>>> moving_average
array([1., 2., 3., 4.]) 

注意，滑動視窗方法通常不是最佳選擇（見註釋）。

numpy.lib.stride_tricks.as_strided

原文：numpy.org/doc/1.26/reference/generated/numpy.lib.stride_tricks.as_strided.html

lib.stride_tricks.as_strided(x, shape=None, strides=None, subok=False, writeable=True)

使用給定的形狀和步幅建立陣列的檢視。

警告

必須非常小心地使用此函式，請參閱注意事項。

引數：

xndarray

建立新陣列的陣列。

shape一系列的整數，可選

新陣列的形狀。預設為x.shape。

步幅一系列的整數，可選

新陣列的步幅。預設為x.strides。

subok布林值，可選

版本 1.10 中的新功能。

如果為 True，則子類將被保留。

writeable布林值，可選

版本 1.12 中的新功能。

如果設定為 False，則返回的陣列將始終是隻讀的。否則，如果原始陣列是可寫的，則它將是可寫的。如果可能的話，建議將其設定為 False（請參閱注意事項）。

返回值：

viewndarray

另請參閱

broadcast_to

將陣列廣播到給定的形狀。

reshape

重塑一個陣列。

lib.stride_tricks.sliding_window_view

使用者友好且安全的函式，用於建立滑動視窗檢視。

注意事項

as_strided根據精確的步幅和形狀建立陣列的檢視。這意味著它會操作 ndarray 的內部資料結構，如果操作不正確，陣列元素可能指向無效的記憶體，並可能破壞結果或使您的程式崩潰。建議在計算新的步幅時始終使用原始的x.strides，以避免依賴於連續的記憶體佈局。

此外，使用此函式建立的陣列通常包含自重疊的記憶體，因此兩個元素是相同的。對這些陣列的向量化寫操作通常是不可預測的。它們甚至可能對小型、大型或轉置的陣列產生不同的結果。

由於對這些陣列的寫操作必須進行測試並非常小心，您可能希望使用writeable=False來避免意外的寫操作。

由於這些原因，建議儘量避免使用as_strided。

numpy.place

原文：numpy.org/doc/1.26/reference/generated/numpy.place.html

numpy.place(arr, mask, vals)

基於條件和輸入值更改陣列的元素。

類似於np.copyto(arr, vals, where=mask)，不同之處在於place使用mask中 True 值的前 N 個元素，而N是mask中 True 值的數量，而copyto使用mask為 True 的元素。

請注意，extract正好與place相反。

引數：

arrndarray

要放入資料的陣列。

maskarray_like

布林掩碼陣列。必須與a的大小相同。

vals1-D 序列

要放入a的值。只使用前 N 個元素，其中 N 是mask中 True 值的數量。如果vals小於 N，它將被重複，並且如果a的元素要被遮蔽，這個序列必須是非空的。

另請參見

copyto, put, take, extract

示例

>>> arr = np.arange(6).reshape(2, 3)
>>> np.place(arr, arr>2, [44, 55])
>>> arr
array([[ 0,  1,  2],
 [44, 55, 44]]) 

numpy.put

numpy.org/doc/1.26/reference/generated/numpy.put.html

numpy.put(a, ind, v, mode='raise')

用給定值替換陣列中指定的元素。

索引操作在扁平化的目標陣列上進行。put 大致相當於：

a.flat[ind] = v 

引數：

a 陣列

目標陣列。

ind 類似於陣列

目標索引，解釋為整數。

v類似於陣列

要放置在 a 中目標索引處的值。如果 v 比 ind 短，將根據需要重複。

mode，可選

指定超出邊界的索引的行為。

• ‘raise’ - 丟擲錯誤（預設）

• ‘wrap’ - 圍繞

• ‘clip’ - 裁剪到範圍

‘clip’ 模式意味著所有太大的索引都會被替換為沿該軸定位到最後一個元素的索引。請注意，這會禁用使用負數進行索引。在‘raise’模式下，如果發生異常，則目標陣列可能仍會被修改。

另請參見

putmask、place

put_along_axis

透過匹配陣列和索引陣列放置元素

示例

>>> a = np.arange(5)
>>> np.put(a, [0, 2], [-44, -55])
>>> a
array([-44,   1, -55,   3,   4]) 

>>> a = np.arange(5)
>>> np.put(a, 22, -5, mode='clip')
>>> a
array([ 0,  1,  2,  3, -5]) 

numpy.put_along_axis

原文：numpy.org/doc/1.26/reference/generated/numpy.put_along_axis.html

numpy.put_along_axis(arr, indices, values, axis)

透過匹配一維索引和資料切片放入目標陣列的值。

這在索引和資料陣列中沿指定軸定位的匹配一維切片上進行迭代，並使用前者將值放入後者。這些切片可以具有不同的長度。

返回沿軸線的索引的函式，比如argsort和argpartition，為此函式產生合適的索引。

版本 1.15.0 中的新功能。

引數：

arrndarray（Ni…，M，Nk…）

目標陣列。

indicesndarray（Ni…，J，Nk…）

每個arr一維切片上要改變的索引。這必須匹配arr的維度，但在 Ni 和 Nj 中的維度可以是 1，以便與arr進行廣播。

valuesarray_like（Ni…，J，Nk…）

要插入到這些索引位置的值。其形狀和維度會廣播以匹配indices的形狀。

axisint

在其上進行一維切片的軸。如果 axis 為 None，則目標陣列被視為建立了其展平的一維檢視。

另請參見

take_along_axis

透過匹配一維索引和資料切片從輸入陣列中取值

註釋

這相當於（但比以下用法更快）ndindex和s_的使用，分別將ii和kk設定為索引元組：

Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
J = indices.shape[axis]  # Need not equal M

for ii in ndindex(Ni):
    for kk in ndindex(Nk):
        a_1d       = a      [ii + s_[:,] + kk]
        indices_1d = indices[ii + s_[:,] + kk]
        values_1d  = values [ii + s_[:,] + kk]
        for j in range(J):
            a_1d[indices_1d[j]] = values_1d[j] 

等價地，消除內部迴圈，最後兩行將會是：

a_1d[indices_1d] = values_1d 

例子

對於這個樣本陣列

>>> a = np.array([[10, 30, 20], [60, 40, 50]]) 

我們可以將最大值替換為：

>>> ai = np.argmax(a, axis=1, keepdims=True)
>>> ai
array([[1],
 [0]])
>>> np.put_along_axis(a, ai, 99, axis=1)
>>> a
array([[10, 99, 20],
 [99, 40, 50]]) 

numpy.putmask

原文：numpy.org/doc/1.26/reference/generated/numpy.putmask.html

numpy.putmask(a, mask, values)

根據條件和輸入值更改陣列的元素。

對於每個 n，當 mask.flat[n]==True 時，設定 a.flat[n] = values[n]。

如果 values 的大小與 a 和 mask 的大小不同，則會重複。這與 a[mask] = values 的行為不同。

引數：

a：ndarray

目標陣列。

mask：array_like

布林掩碼陣列。它必須與 a 具有相同的形狀。

values：array_like

當 mask 為 True 時，將值放入 a 中。如果 values 小於 a，它將被重複。

另請參見

place、put、take、copyto

示例

>>> x = np.arange(6).reshape(2, 3)
>>> np.putmask(x, x>2, x**2)
>>> x
array([[ 0,  1,  2],
 [ 9, 16, 25]]) 

如果 values 小於 a，則它將被重複。

>>> x = np.arange(5)
>>> np.putmask(x, x>1, [-33, -44])
>>> x
array([  0,   1, -33, -44, -33]) 

numpy.fill_diagonal

原文：numpy.org/doc/1.26/reference/generated/numpy.fill_diagonal.html

numpy.fill_diagonal(a, val, wrap=False)

填充給定陣列的主對角線，無論維度如何。

對於一個具有 a.ndim >= 2 的陣列 a，對角線是具有相同索引 a[i, ..., i] 的位置列表。此函式會就地修改輸入陣列，不返回任何值。

引數：

a陣列，至少為 2 維。

要填充其對角線的陣列，它會就地修改。

val標量或類似陣列

要寫入對角線的值。如果 val 是標量，則該值沿對角線寫入。如果是類似陣列，則展開的 val 沿對角線寫入，必要時重複以填充所有對角線條目。

wrap布林值

對於 NumPy 版本 1.6.2 之前的高矩陣，對角線在 N 列後“包裹”。您可以使用此選項獲得此行為。這隻影響高矩陣。

另請參閱

diag_indices、diag_indices_from

注意事項

自版本 1.4.0 起新增。

這個功能可以透過 diag_indices 獲得，但在內部，此版本使用了一個更快的實現，它從不構造索引，並使用簡單的切片。

示例

>>> a = np.zeros((3, 3), int)
>>> np.fill_diagonal(a, 5)
>>> a
array([[5, 0, 0],
 [0, 5, 0],
 [0, 0, 5]]) 

相同的函式也可以在 4 維陣列上操作：

>>> a = np.zeros((3, 3, 3, 3), int)
>>> np.fill_diagonal(a, 4) 

為了清晰起見，我們只展示了幾個塊：

>>> a[0, 0]
array([[4, 0, 0],
 [0, 0, 0],
 [0, 0, 0]])
>>> a[1, 1]
array([[0, 0, 0],
 [0, 4, 0],
 [0, 0, 0]])
>>> a[2, 2]
array([[0, 0, 0],
 [0, 0, 0],
 [0, 0, 4]]) 

wrap 選項隻影響高矩陣：

>>> # tall matrices no wrap
>>> a = np.zeros((5, 3), int)
>>> np.fill_diagonal(a, 4)
>>> a
array([[4, 0, 0],
 [0, 4, 0],
 [0, 0, 4],
 [0, 0, 0],
 [0, 0, 0]]) 

>>> # tall matrices wrap
>>> a = np.zeros((5, 3), int)
>>> np.fill_diagonal(a, 4, wrap=True)
>>> a
array([[4, 0, 0],
 [0, 4, 0],
 [0, 0, 4],
 [0, 0, 0],
 [4, 0, 0]]) 

>>> # wide matrices
>>> a = np.zeros((3, 5), int)
>>> np.fill_diagonal(a, 4, wrap=True)
>>> a
array([[4, 0, 0, 0, 0],
 [0, 4, 0, 0, 0],
 [0, 0, 4, 0, 0]]) 

反對角線可以透過使用 numpy.flipud 或 numpy.fliplr 來反轉元素的順序來填充。

>>> a = np.zeros((3, 3), int);
>>> np.fill_diagonal(np.fliplr(a), [1,2,3])  # Horizontal flip
>>> a
array([[0, 0, 1],
 [0, 2, 0],
 [3, 0, 0]])
>>> np.fill_diagonal(np.flipud(a), [1,2,3])  # Vertical flip
>>> a
array([[0, 0, 3],
 [0, 2, 0],
 [1, 0, 0]]) 

注意，填充對角線的順序取決於翻轉函式的順序。

numpy.nditer

原文：numpy.org/doc/1.26/reference/generated/numpy.nditer.html

class numpy.nditer(op, flags=None, op_flags=None, op_dtypes=None, order='K', casting='safe', op_axes=None, itershape=None, buffersize=0)

有效的多維迭代器物件，用於迭代陣列。要開始使用此物件，請參閱 陣列迭代的入門指南。

引數：

op ndarray 或陣列類序列

要迭代的陣列。

flags str 的序列，可選

用於控制迭代器行為的標誌。

• buffered 在需要時啟用緩衝。

• c_index 導致 C 順序索引被跟蹤。

• f_index 導致 Fortran 順序索引被跟蹤。

• multi_index 導致多索引，或每個迭代維度一個的索引元組，被跟蹤。

• common_dtype 導致所有運算元被轉換為共同的資料型別，必要時進行復制或緩衝。

• copy_if_overlap 導致迭代器確定讀運算元是否與寫運算元重疊，並根據需要進行臨時複製以避免重疊。在某些情況下可能會出現誤報（不必要的複製）。

• delay_bufalloc 延遲直到呼叫 reset() 呼叫才分配緩衝區。允許在將其值複製到緩衝區之前初始化 allocate 運算元。

• external_loop 導致給定的values成為多值一維陣列，而不是零維陣列。

• grow_inner 允許在使用 buffered 和 external_loop 時將 value 陣列大小設定為大於緩衝區大小。

• ranged 允許將迭代器限制為 iterindex 值的子範圍。

• refs_ok 啟用引用型別的迭代，例如物件陣列。

• reduce_ok 啟用廣播的 readwrite 運算元的迭代，也稱為約簡運算元。

• zerosize_ok 允許 itersize 為零。

op_flags列表的列表的 str，可選

這是每個運算元的標誌列表。至少必須指定其中之一：readonly、readwrite 或 writeonly。

• readonly 表示運算元只會被讀取。

• readwrite 表示運算元將被讀取和寫入。

• writeonly 表示運算元只會被寫入。

• no_broadcast 防止運算元被廣播。

• contig 強制運算元資料是連續的。

• aligned 強制運算元資料對齊。

• nbo 強制運算元資料採用本機位元組順序。

• copy 如果需要，允許臨時只讀副本。

• updateifcopy 如果需要，允許臨時讀寫副本。

• allocate 導致如果op引數中為 None，則分配陣列。

• no_subtype 防止分配運算元使用子型別。

• arraymask 表示此運算元是在寫入具有設定了 ‘writemasked’ 標誌的運算元時使用的掩碼。迭代器不強制此功能，但在將緩衝區寫回陣列時，只會複製由此掩碼指示的元素。

• writemasked 指示只有在選擇的 arraymask 運算元為 True 時才會被寫入的元素。

• overlap_assume_elementwise 可以用來標記只在迭代器順序中訪問的運算元，以在存在 copy_if_overlap 時允許更少保守的複製。

op_dtypes 標量資料型別或資料型別的元組，可選

運算元的所需資料型別。如果啟用了複製或緩衝，資料將轉換為/從其原始型別。

order {‘C’, ‘F’, ‘A’, ‘K’}，可選

控制迭代順序。‘C’ 表示 C 順序，‘F’ 表示 Fortran 順序，‘A’ 表示如果所有陣列都是 Fortran 連續的，則為 ‘F’ 順序，否則為‘C’ 順序，‘K’ 表示儘可能接近記憶體中陣列元素出現的順序。這也影響到 allocate 運算元的元素記憶體順序，因為它們被分配為與迭代順序相容的。預設為 ‘K’。

casting {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}，可選

控制在進行復制或緩衝時可能發生的資料型別轉換的種類。不建議將其設定為 ‘unsafe’，因為它可能會對累積產生不利影響。

• ‘no’ 表示資料型別根本不應該進行轉換。

• ‘equiv’ 表示只允許位元組順序更改。

• ‘safe’ 表示只允許可以保留值的轉換。

• ‘same_kind’ 表示只允許安全轉換或同種型別的轉換，例如 float64 到 float32。

• ‘unsafe’ 表示任何資料轉換都可能發生。

op_axes 整數的列表的列表，可選

如果提供了，則每個運算元應該是一個整數列表，或者是 None。運算元的軸列表是從迭代器的維度到運算元的維度的對映。可以對條目放置一個值為 -1 的值，導致該維度被視為 newaxis。

itershape 整數的元組，可選

迭代器的期望形狀。這允許維度由 op_axes 對映的 allocate 運算元在不對應於其他運算元的維度的情況下獲得一個非等於 1 的值。

buffersize 整數，可選

當啟用緩衝時，控制臨時緩衝區的大小。設定為 0 以使用預設值。

注意事項

nditer 代替了 flatiter。nditer 的迭代器實現也暴露在 NumPy C API 中。

Python 擴充套件提供了兩種迭代介面，一個遵循 Python 迭代器協議，另一個模仿了 C 風格的 do-while 模式。在大多數情況下，原生的 Python 方法更好，但如果需要迭代器的座標或索引，則可以使用 C 風格的模式。

示例

這是我們可能如何編寫 iter_add 函式，使用 Python 迭代器協議：

>>> def iter_add_py(x, y, out=None):
...     addop = np.add
...     it = np.nditer([x, y, out], [],
...                 [['readonly'], ['readonly'], ['writeonly','allocate']])
...     with it:
...         for (a, b, c) in it:
...             addop(a, b, out=c)
...         return it.operands[2] 

這是相同的函式，但遵循 C 風格的模式：

>>> def iter_add(x, y, out=None):
...    addop = np.add
...    it = np.nditer([x, y, out], [],
...                [['readonly'], ['readonly'], ['writeonly','allocate']])
...    with it:
...        while not it.finished:
...            addop(it[0], it[1], out=it[2])
...            it.iternext()
...        return it.operands[2] 

這是一個外積函式的示例：

>>> def outer_it(x, y, out=None):
...     mulop = np.multiply
...     it = np.nditer([x, y, out], ['external_loop'],
...             [['readonly'], ['readonly'], ['writeonly', 'allocate']],
...             op_axes=[list(range(x.ndim)) + [-1] * y.ndim,
...                      [-1] * x.ndim + list(range(y.ndim)),
...                      None])
...     with it:
...         for (a, b, c) in it:
...             mulop(a, b, out=c)
...         return it.operands[2] 

>>> a = np.arange(2)+1
>>> b = np.arange(3)+1
>>> outer_it(a,b)
array([[1, 2, 3],
 [2, 4, 6]]) 

這是一個操作類似“lambda”的 ufunc 的示例函式：

>>> def luf(lamdaexpr, *args, **kwargs):
...  '''luf(lambdaexpr, op1, ..., opn, out=None, order='K', casting='safe', buffersize=0)'''
...    nargs = len(args)
...    op = (kwargs.get('out',None),) + args
...    it = np.nditer(op, ['buffered','external_loop'],
...            [['writeonly','allocate','no_broadcast']] +
...                            [['readonly','nbo','aligned']]*nargs,
...            order=kwargs.get('order','K'),
...            casting=kwargs.get('casting','safe'),
...            buffersize=kwargs.get('buffersize',0))
...    while not it.finished:
...        it[0] = lamdaexpr(*it[1:])
...        it.iternext()
...    return it.operands[0] 

>>> a = np.arange(5)
>>> b = np.ones(5)
>>> luf(lambda i,j:i*i + j/2, a, b)
array([  0.5,   1.5,   4.5,   9.5,  16.5]) 

如果運算元標誌為"writeonly"或"readwrite"，則運算元可能是對原始資料的檢視，具有 WRITEBACKIFCOPY 標誌。 在這種情況下，必須使用 nditer 作為上下文管理器，或者在使用結果之前必須呼叫 nditer.close 方法。 臨時資料將在呼叫 __exit__ 函式時寫回原始資料，但在此之前不會：

>>> a = np.arange(6, dtype='i4')[::-2]
>>> with np.nditer(a, [],
...        [['writeonly', 'updateifcopy']],
...        casting='unsafe',
...        op_dtypes=[np.dtype('f4')]) as i:
...    x = i.operands[0]
...    x[:] = [-1, -2, -3]
...    # a still unchanged here
>>> a, x
(array([-1, -2, -3], dtype=int32), array([-1., -2., -3.], dtype=float32)) 

重要的是要注意，一旦迭代器退出，懸空引用（例如示例中的 x）可能與原始資料 a 共享資料，也可能不共享。 如果寫回語義處於活動狀態，即如果 x.base.flags.writebackifcopy 為 True，那麼退出迭代器將切斷 x 與 a 之間的連線，向 x 寫入將不再寫入 a。 如果寫回語義未啟用，則 x.data 仍將指向 a.data 的某個部分，對其中一個進行寫入將影響另一個。

上下文管理和 close 方法出現在版本 1.15.0 中。

屬性：

dtypesdtype 元組

在 value 中提供的值的資料型別。 如果啟用了緩衝，則可能與運算元資料型別不同。 僅在迭代器關閉之前有效。

finished布林值

運算元上的迭代是否完成。

has_delayed_bufalloc布林值

如果為 True，則迭代器使用 delay_bufalloc 標誌建立，並且尚未對其呼叫 reset() 函式。

has_index布林值

如果為 True，則迭代器是使用 c_index 或 f_index 標誌建立的，可以使用屬性index來檢索它。

has_multi_index布林值

如果為 True，則迭代器使用 multi_index 標誌建立，並且可以使用屬性 multi_index 來檢索它。

index

當使用 c_index 或 f_index 標誌時，此屬性提供對索引的訪問。 如果訪問並且 has_index 為 False，則引發 ValueError。

iterationneedsapi布林值

迭代是否需要訪問 Python API，例如其中一個運算元是物件陣列。

iterindex整數

一個與迭代順序匹配的索引。

itersize整數

迭代器的大小。

itviews

記憶體中的 operands 的結構化檢視，匹配重新排序和最佳化的迭代器訪問模式。 僅在迭代器關閉之前有效。

multi_index

當使用 multi_index 標誌時，此屬性提供對索引的訪問。如果訪問並且 has_multi_index 為 False，則引發 ValueError。

ndim整數

迭代器的維度。

nop整數

迭代器運算元的數量。

operands運算元的元組

運算元[切片]

shape整數的元組

形狀元組，迭代器的形狀。

value

當前迭代的operands的值。通常，這是一個陣列標量的元組，但如果使用 external_loop 標誌，則是一個一維陣列的元組。

方法

close()	解決可寫運算元中所有回寫語義。
copy()	獲取迭代器在當前狀態的副本。
debug_print()	將當前nditer例項的狀態和除錯資訊列印到標準輸出。
enable_external_loop()	在構造過程中未使用 "external_loop"，但希望使用時，此方法會修改迭代器以表現為已指定了該標誌。
iternext()	檢查是否還有迭代次數，並執行單個內部迭代而不返回結果。
remove_axis(i, /)	從迭代器中刪除軸 i。
remove_multi_index()	當指定了 "multi_index" 標誌時，這會將其刪除，從而允許進一步最佳化內部迭代結構。
reset()	將迭代器重置為其初始狀態。