词汇表#

( n ,) #

括号内的数字后跟一个逗号表示一个包含一个元素的元组。尾随的逗号将单元素元组与带括号的区分开来n。

-1 #

在维度条目中，指示 NumPy 选择使数组元素总数保持相同的长度。
```
>>> np.arange(12).reshape(4, -1).shape
(4, 3)
```
在索引中，任何负值都表示从右侧开始索引。

…… #

一个Ellipsis。

当索引数组时，缺失的轴（如果存在）是完整切片的简写。

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

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

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

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

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

最多可使用一次；a[...,0,...]引发IndexError.

在打印输出中，NumPy 替换...大型数组的中间元素。要查看整个数组，请使用numpy.printoptions

：#

Python切片运算符。在 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 不同，在 Python 中，切片创建一个副本，而在 NumPy 中，切片创建一个视图。

有关详细信息，请参阅组合高级索引和基本索引。

< #

在数据类型声明中，表示数据是小端字节序（括号在右边是大括号）。

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

> #

在数据类型声明中，表示数据是大端字节序（括号在左边是大括号）。

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

高级索引#

可以使用数组对轴进行索引，而不是使用标量或切片作为索引，从而提供细粒度的选择。这称为高级索引或“花式索引”。

沿轴#

沿数组轴 n 的操作的a行为就好像其参数是切片数组，其中每个切片都有轴na的连续索引。

例如，如果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]])

回顾沿轴的定义， flip沿轴 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同义使用。

类似数组#

任何可以解释为 ndarray 的标量或序列。除了 ndarray 和标量之外，此类别还包括列表（可能嵌套且具有不同的元素类型）和元组。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 将标量视为零维度数组。相反，0 维数组是仅包含一个值的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]]])

。根据＃

如果数组不拥有其内存，则其基属性返回该数组引用其内存的对象。该对象可能正在引用另一个对象的内存，因此拥有的对象可能是a.base.base.base...。一些作者错误地声称测试base可以确定数组是否是视图。正确方法请参见numpy.shares_memory。

大尾数#

请参阅字节序。

布拉斯#

基本线性代数子程序

播送＃

广播是 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-连续数组，或简称为连续数组，是指按行存储的数据，即存储在内存中的数据的索引从最高维度开始。

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

例如，A如果 2x2 数组的元素按以下顺序存储在内存中，则该数组是 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 连续的，请使用.flags.c_contiguous NumPy 数组的属性。要测试 Fortran 连续性，请使用该 .flags.f_contiguous属性。

复制＃

见视图。

方面＃

参见轴。

数据类型#

描述 ndarray 中（相同类型）元素的数据类型。可以更改它以重新解释数组内容。有关详细信息，请参阅数据类型对象 (dtype)。

花哨的索引#

高级索引的另一个术语。

场地＃

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

Fortran 命令#

与column-major相同。

压扁#

参见拉威尔。

同质＃

同构数组的所有元素都具有相同的类型。与 Python 列表相比，ndarray 是同构的。类型可能很复杂，就像在结构化数组中一样，但所有元素都具有该类型。

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 的二维矩阵类不应再使用；使用常规 ndarray。

ndarray #

NumPy 的基本结构。

对象数组#

数据类型为的数组object；也就是说，它包含对 Python 对象的引用。对数组进行索引会取消对 Python 对象的引用，因此与其他 ndarray 不同，对象数组能够保存异构对象。

拉威尔#

numpy.ravel 和numpy.flatten 都压平 ndarray。ravel如果可能的话将返回一个视图； flatten总是返回一个副本。

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

记录数组#

除了之外，还允许以属性 style () 进行访问的结构化数组。有关详细信息，请参阅 numpy.recararray。a.fielda['field']

行主#

请参阅行主序和列主序。 NumPy 默认按行优先顺序创建数组。

标量#

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

形状＃

显示 ndarray 的每个维度的长度的元组。元组本身的长度是维数（numpy.ndim）。元组元素的乘积是数组中元素的数量。有关详细信息，请参阅 numpy.ndarray.shape。

步幅#

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

步幅是根据数组的数据类型和形状自动计算的，但可以使用 as_strided 直接指定。

有关详细信息，请参阅 numpy.ndarray.strides。

要了解跨步如何发挥 NumPy 视图的强大功能，请参阅 NumPy 数组：高效数值计算的结构。

结构化数组#

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的缩写。 NumPy 例程具有内置的 ufunc，但用户也可以编写自己的。universal function

矢量化#

NumPy 将数组处理交给 C，其中循环和计算比 Python 快得多。为了利用这一点，使用 NumPy 的程序员消除了 Python 循环，转而使用数组到数组的操作。矢量化既可以指 C 卸载，也可以指构建 NumPy 代码以利用它。

看法＃

在不触及基础数据的情况下，NumPy 可以使一个数组看起来改变了其数据类型和形状。

以这种方式创建的数组是一个视图，NumPy 经常利用使用视图相对于创建新数组的性能增益。

一个潜在的缺点是写入视图也会改变原始视图。如果这是一个问题，NumPy 需要创建一个物理上不同的数组 - a 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])