词汇表#

( n ,)#

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

-1#

  • 在维度条目中,指示 NumPy 选择将保持数组元素总数不变的长度.

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

  • 在索引中,任何负值 denotes 从右侧开始索引.

…#

一个 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 slice 运算符.在 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 中,切片创建 view .

有关详细信息,请参见 组合高级索引和基本索引 .

<#

在 dtype 声明中,表示数据是 little-endian (括号右边大).:

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

在 dtype 声明中,表示数据是 big-endian (括号左边大).:

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

轴可以使用数组而不是使用 scalar 或切片作为索引来进行索引,从而提供细粒度的选择.这被称为 advanced indexing 或"花式索引".

沿轴#

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

例如,如果 a 是一个 3 x N 数组,则沿轴 0 的操作的行为就好像它的参数是一个包含每行切片的数组:

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

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

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

沿轴 0(行轴)反转会产生

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

回顾 沿轴 的定义,沿轴 0 的 flip 将其参数视为:

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

np.flip(a,axis=0) 的结果是反转切片:

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

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

array_like#

任何可以解释为 ndarray 的 scalar 或 sequence .除了 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]])
数组标量#

array scalar 是类型/类 float32,float64 等的实例.为了处理操作数的一致性,NumPy 将标量视为零维数组.相反,零维数组是包含恰好一个值的 ndarray 实例.

轴#

数组维度的另一个术语.轴从左到右编号;轴 0 是 shape 元组中的第一个元素.

在二维向量中,轴 0 的元素是行,轴 1 的元素是列.

在更高的维度中,情况会发生变化.NumPy 将更高维度的向量打印为行乘列构建块的复制,如此三维向量:

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

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

此规则可帮助您预测向量的打印方式,反之亦然,如何查找任何打印元素的索引.例如,在该示例中,8 的索引的最后两个值必须为 0 和 2.由于 8 出现在两个 2x3 中的第二个中,因此第一个索引必须为 1:

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

计算打印向量中维度的便捷方法是计算开括号后的 [ 符号.这在区分 (1,2,3) 形状和 (2,3) 形状时很有用:

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

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

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

大端序#

参见 Endianness .

BLAS#

Basic Linear Algebra Subprograms

广播#

广播是 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 可以沿"缺失"轴或"太短"维度复制数据,从而使形状匹配.这种复制不花费任何内存或时间.有关详细信息,请参见 Broadcasting.

C 顺序#

与 row-major 相同.

类型转换#

将数组数据从一种 dtype 转换为另一种 dtype 的过程.存在几种转换模式,由以下转换规则定义:

  • no : 根本不应转换数据类型.数组之间数据类型的任何不匹配都会引发 TypeError .

  • equiv : 只允许字节顺序更改.

  • safe : 只允许保留值的转换.允许向上转换(例如,从 int 到 float),但不允许向下转换.

  • same_kind : "same_kind"转换选项允许安全转换和同类转换,例如 float64 到 float32.

  • unsafe : 可以进行任何数据转换.

列优先#

参见 Row- and column-major order .

连续的#

一个数组是连续的,如果:

  • 它占据一块连续的内存,并且

  • 具有较高索引的数组元素占据较高的地址(即,没有 stride 为负数).

有两种类型的正确连续 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 属性.

复制#

参见 view .

维度#

参见 axis .

dtype#

描述 ndarray 中(相同类型的)元素的 数据类型. 可以更改它以重新解释数组内容. 有关详细信息,请参见 Data type objects (dtype).

花式索引#

advanced indexing 的另一个术语.

字段#

在 structured data type 中,每个子类型都称为"字段". "字段"具有名称(字符串),类型(任何有效的 dtype)和可选的"标题". 参见 数据类型对象 ( dtype ) .

Fortran 顺序#

与 column-major 相同.

扁平化的#

参见 ravel .

同质的#

同质数组的所有元素都具有相同的类型. 与 Python 列表相比,ndarray 是同质的. 该类型可能很复杂,如在 structured array 中,但所有元素都具有该类型.

NumPy object arrays ,其中包含对 Python 对象的引用,填补了异构数组的角色.

itemsize#

dtype 元素的大小(以字节为单位).

小端序#

参见 Endianness .

掩码#

一个布尔数组,用于仅选择某些元素进行操作:

>>> 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)

有关详细信息,请参见 Masked arrays.

矩阵#

NumPy 的二维 matrix class 不应再使用; 请使用常规 ndarray.

ndarray#

NumPy’s basic structure .

对象数组#

dtype 为"object"的数组; 也就是说,它包含对 Python 对象的引用. 索引数组会解引用 Python 对象,因此与其它 ndarray 不同,对象数组具有保存异构对象的能力.

扁平化#

numpy.ravel 和 numpy.flatten 都可以将ndarray展平. ravel 会尽可能返回一个视图; flatten 总是返回一个副本.

扁平化将多维数组折叠成一维;如何进行扁平化的细节(例如, a[n+1] 应该是下一行还是下一列)是参数.

记录数组#

一个 structured array ,允许以属性样式 ( a.field ) 以及 a['field'] 访问. 详情请参见 numpy.recarray.

行优先#

参见 Row- and column-major order . NumPy 默认以行优先顺序创建数组.

标量#

在 NumPy 中,通常是 array scalar 的同义词.

形状#

一个显示ndarray每个维度长度的元组.元组本身的长度是维度的数量( numpy.ndim ).元组元素的乘积是数组中元素的数量.有关详细信息,请参见 numpy.ndarray.shape .

步长#

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

步长会根据数组的 dtype 和 shape 自动计算,但可以使用 as_strided. 直接指定.

有关详细信息,请参见 numpy.ndarray.strides .

要了解步长如何支持 NumPy 视图的强大功能,请参见 The NumPy array: a structure for efficient numerical computation.

结构化数组#

其 dtype 是 structured data type 的数组.

结构化数据类型#

用户可以创建任意复杂的 dtypes ,这些 dtype 可以包含其他数组和 dtype.这些复合 dtype 被称为 structured data types.

子数组#

嵌套在 structured data type 中的数组,例如这里的 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 含义, see here.

ufunc#

NumPy 快速的逐元素计算 ( vectorization ) 允许选择要应用的函数. 函数的通用术语是 ufunc ,是 universal function 的缩写. NumPy 例程具有内置的 ufunc,但用户也可以 write their own.

向量化#

NumPy 将数组处理传递给 C,在 C 中循环和计算比在 Python 中快得多. 为了利用这一点,使用 NumPy 的程序员消除了 Python 循环,转而使用数组到数组的操作. vectorization 既可以指 C 卸载,也可以指构建 NumPy 代码以利用它.

视图#

在不触及底层数据的情况下,NumPy 可以使一个数组看起来改变了它的数据类型和形状.

以这种方式创建的数组是一个 视图 ,NumPy 经常利用使用视图而不是创建新数组的性能优势.

一个潜在的缺点是,写入视图也会改变原始数组.如果这是一个问题,NumPy 需要创建一个物理上不同的数组–一个 副本 .

某些 NumPy 例程总是返回视图,某些总是返回副本,某些可能返回其中之一,并且对于某些,可以选择. 管理视图和副本的责任在于程序员. numpy.shares_memory 将检查 b 是否是 a 的视图,但正如文档页面所解释的那样,一个精确的答案并不总是可行的.

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

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

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