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

将数组广播到给定的形状。

注意事项

对于许多应用程序，使用滑动窗口视图可能很方便，但可能非常慢。通常存在专门的解决方案，例如：

作为粗略估计，输入尺寸为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() 将迭代器重置为其初始状态。
posted @ 2024-06-24 14:57  绝不原创的飞龙  阅读(8)  评论(0)  编辑  收藏  举报