NumPy 1.26 中文官方指南（四）（1）

附加文件

术语表

原文：numpy.org/doc/1.26/glossary.html

(n,)

括号中跟着逗号的数字表示一个具有一个元素的元组。尾随逗号将一个元素元组与括号n区分开。

-1

• 在维度入口中，指示 NumPy 选择长度，以保持数组元素总数不变。

>>> np.arange(12).reshape(4, -1).shape
(4, 3) 

• 在索引中，任何负值表示从右边进行索引。
  

…

一个省略号。

• 当索引数组时，缺失的轴简称为全切片。

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

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

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

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

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

• 它最多可以使用一次；a[...,0,...]会引发一个IndexError。
• 在打印输出中，NumPy 用...替代大数组的中间元素。要查看整个数组，使用numpy.printoptions
  

：

Python 的切片操作符。在 ndarrays 中，切片可以应用于每个轴：

>>> a = np.arange(24).reshape(2,3,4)
>>> a
array([[[ 0,  1,  2,  3],
 [ 4,  5,  6,  7],
 [ 8,  9, 10, 11]],
 [[12, 13, 14, 15],
 [16, 17, 18, 19],
 [20, 21, 22, 23]]])
>>> a[1:,-2:,:-1]
array([[[16, 17, 18],
 [20, 21, 22]]]) 

尾部切片可以省略：

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

与 Python 不同，NumPy 中切片创建一个视图而不是副本。

详见组合高级和基本索引。

<

在 dtype 声明中，表示数据为小端（右边是大括号）。

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

在 dtype 声明中，表示数据为大端（左边是大括号）。

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

高级索引

而不是使用标量或切片作为索引，一个轴可以用数组作为索引，提供精细选择。这被称为高级索引或“花式索引”。

沿轴

数组a的操作沿轴 n的行为就好像它的参数是数组a的切片数组，每个切片在轴n上具有连续索引。

例如，如果a是一个 3 x N数组，沿轴 0 的操作表现得好像它的参数是包含每行切片的数组：

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

具体起见，我们可以选择操作为数组反转函数numpy.flip，它接受一个axis参数。我们构造一个 3 x 4 数组a：

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

沿轴 0（行轴）翻转得到

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

回想沿轴的定义，沿轴 0 翻转是将其参数视为

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

而np.flip(a,axis=0)的结果是翻转切片：

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

数组

在 NumPy 文档中与 ndarray 同义使用。

array_like

任何可以解释为 ndarray 的标量或序列。除了 ndarrays 和标量，此类别还包括列表（可能嵌套并具有不同的元素类型）和元组。由 numpy.array 接受的任何参数都是 array_like。

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

数组标量

数组标量是类型/类 float32，float64 等的实例。为了处理操作数的统一性，NumPy 将标量视为零维数组。相比之下，零维数组是包含精确一个值的 ndarray 实例。

轴

数组维度的另一个术语。轴从左到右编号；轴 0 是形状元组中的第一个元素。

在二维矢量中，轴 0 的元素是行，轴 1 的元素是列。

在更高的维度中，情况就不一样了。NumPy 将更高维度的矢量打印为行列建造块的复制，就像这个三维矢量一样：

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

a被描述为一个其元素为 2x3 矢量的两元素数组。从这个角度来看，行和列分别是任何形状中的最终两个轴。

这个规则可以帮助你预测矢量将如何打印，反过来也可以帮助你找到任何打印元素的索引。例如，在这个例子中，8 的最后两个值的索引必须是 0 和 2。由于 8 出现在两个 2x3 中的第二个中，第一个索引必须是 1：

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

在打印矢量时，计算维度的一个方便方法是在开括号后计数[符号。这在区分例如(1,2,3)形状和(2,3)形状时非常有用：

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

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

.base

如果一个数组没有拥有它的内存，那么它的基础属性会返回数组正在引用的对象的内存。该对象可能正在引用另一个对象的内存，因此拥有对象可能是a.base.base.base...。一些作家错误地声称测试base决定数组是否是视图。有关正确的方法，请参阅numpy.shares_memory。

大端

请参见字节序。

BLAS

基本线性代数子程序

广播

广播是 NumPy 处理不同大小的 ndarray 的能力，就好像它们都是相同大小一样。

它允许优雅的做-我-知道什么的行为，在这种情况下，将标量添加到向量会将标量值添加到每个元素。

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

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

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

通常，向量操作数必须全部具有相同的大小，因为 NumPy 逐元素工作——例如，c = a * b是

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

但在某些有用的情况下，NumPy 可以沿着“缺失”的轴或“太短”的维度复制数据，使形状匹配。复制不会占用内存或时间。详情请参见广播。

C 顺序

与行主导相同。

列主导

查看行优先和列优先顺序。

连续的

如果数组是连续的，则：

• 它占据了一块连续的内存块，以及
  
• 具有更高索引的数组元素占据更高地址（即，没有步长为负）。
  

有两种类型的适当连续的 NumPy 数组：

• Fortran 连续数组指的是以列方式存储的数据，即存储在内存中的数据索引从最低维开始；
  
• C 连续，或简单连续的数组，指的是以行方式存储的数据，即存储在内存中的数据索引从最高维开始。
  

对于一维数组，这些概念是相同的。

例如，2x2 数组A如果其元素按以下顺序存储在内存中，则为 Fortran 连续：

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

且如果顺序如下，则为 C 连续：

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

要测试数组是否为 C 连续，请使用 NumPy 数组的.flags.c_contiguous属性。要测试 Fortran 连续性，请使用.flags.f_contiguous属性。

拷贝

查看视图。

维度

查看轴。

数据类型

描述 ndarray 中（类型相同的）元素的数据类型。它可以更改以重新解释数组内容。详情请参见数据类型对象（dtype）。

精细索引

高级索引的另一个术语。

字段

在结构化数据类型中，每个子类型称为字段。字段具有名称（字符串）、类型（任何有效的 dtype）和可选的标题。请参见数据类型对象（dtype）。

Fortran 顺序

与列主导相同。

展平

查看拉伸。

同质的

同质数组的所有元素具有相同类型。与 Python 列表相反，ndarrays 是同质的。类型可能很复杂，如结构化数组，但所有元素都具有该类型。

NumPy 的对象数组，其中包含指向 Python 对象的引用，起到异构数组的作用。

数据项大小

dtype 元素的字节大小。

小端

查看字节顺序。

掩码

用于选��仅对某些元素进行操作的布尔数组：

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

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

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

蒙版数组

坏的或缺失的数据可以通过将其放入蒙版数组中，该数组具有指示无效条目的内部布尔数组来干净地忽略。对于带有蒙版数组的操作会忽略这些条目。

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

详情请参见蒙版数组。

矩阵

NumPy 的二维矩阵类不应再使用；请使用常规 ndarrays。

ndarray

NumPy 的基本结构。

对象数组

一个其数据类型为object的数组；即，它包含对 Python 对象的引用。对数组进行索引解引用 Python 对象，因此与其他 ndarrays 不同，对象数组具有能够保存异构对象的能力。

ravel

numpy.ravel 和 numpy.flatten 都会将 ndarray 展平。如果可能，ravel会返回视图；flatten总是返回副本。

展平将多维数组折叠为单个维度；如何完成此操作的详细信息（例如，a[n+1]应该是下一行还是下一列）是参数。

记录数组

允许以属性样式（a.field）访问的一个结构化数组，除了a['field']。详情请参见 numpy.recarray.

行主序

参见行主序和列主序。NumPy 默认以行主序创建数组。

标量

在 NumPy 中，通常是数组标量的同义词。

形状

显示 ndarray 每个维度的长度的元组。元组本身的长度即为维度的数量（numpy.ndim）。元组元素的乘积即为数组中的元素数量。详情请参见 numpy.ndarray.shape。

步幅

物理内存是一维的；步幅提供了一种将给定索引映射到内存地址的机制。对于 N 维数组，其strides属性是一个 N 元素元组；从索引i向轴n上的索引i+1前进意味着在地址上添加a.strides[n]个字节。

步幅会自动从数组的 dtype 和形状中计算，但也可以直接使用 as_strided 指定。

详情请参见 numpy.ndarray.strides。

要了解步进是如何支撑 NumPy 视图的强大功能，请参见NumPy 数组：高效数值计算的结构。

结构化数组

其 dtype 为结构化数据类型的数组。

结构化数据类型

用户可以创建包含其他数组和数据类型的任意复杂的 dtype，这些复合 dtype 被称为结构化数据类型。

子数组

嵌套在结构化数据类型中的数组，如此处的b：

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

子数组数据类型

表现得像一个 ndarray 的结构化数据类型的元素。

标题

结构化数据类型中字段名称的别名。

类型

在 NumPy 中，通常是 dtype 的同义词。对于更一般的 Python 含义，请参见此处。

ufunc

NumPy 的快速逐元素计算（向量化）可以选择应用哪个函数。该函数的通用术语是ufunc，缩写为universal function。NumPy 例程具有内置的 ufunc，但用户也可以编写自己的。

向量化

NumPy 把数组处理交给了 C 语言，在那里循环和计算比在 Python 中快得多。为了利用这一点，使用 NumPy 的程序员取消了 Python 循环，而是使用数组对数组操作。向量化 既可以指 C 的卸载，也可以指结构化 NumPy 代码以利用它。

视图

不触及底层数据，NumPy 可使一个数组看起来改变其数据类型和形状。

以此方式创建的数组是一个视图，而且 NumPy 经常利用使用视图而不是创建新数组来获得性能优势。

潜在的缺点是对视图的写入也可能改变原始数组。如果这是一个问题，NumPy 需要创建一个物理上不同的数组 - 一个copy.

一些 NumPy 例程总是返回视图，一些总是返回副本，有些可能返回其中之一，对于一些情况可以指定选择。管理视图和副本的责任落在程序员身上。numpy.shares_memory 可以检查b是否为a的视图，但精确答案并非总是可行，就像文档页面所解释的那样。

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

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

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

发布说明

原文：numpy.org/doc/1.26/release.html

• 1.26.0

• 新功能

• numpy.array_api中的数组 API v2022.12 支持
  
• 支持更新的加速 BLAS/LAPACK 库
  
• f2py的meson后端支持
  
• f2py的bind(c)支持
  

• 改进

• f2py的iso_c_binding支持

• 构建系统变更

• NumPy 特定的构建自定义
  
• 构建依赖项
  
• 故障排除
  

• 贡献者
  
• 已合并的拉取请求
  

• 1.25.2

• 贡献者
  
• 已合并的拉取请求
  

• 1.25.1

• 贡献者
  
• 已合并的拉取请求
  

NumPy 1.26 中文官方指南（四）（2）https://developer.aliyun.com/article/1510621