术语表#

( 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 运算符.在 ndarray 中,切片可以应用于每个轴:

>>> 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 . 除了 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]])
数组标量#

一个 array scalar 是 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]]])
.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 中,每个子类型都称为“字段”. field 具有名称(字符串),类型 (任何有效的 dtype) 和可选的 title . 请参阅 数据类型对象 ( 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 不同,对象数组能够保存异构对象.

ravel#

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 的同义词.

shape#

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

stride#

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

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

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

要了解 striding 如何支持 NumPy views 的强大功能,请参阅 The NumPy array: a structure for efficient numerical computation.

structured array#

dtype 为 structured data type 的数组.

structured data type#

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

subarray#

嵌套在 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,))])
subarray data type#

一种结构化数据类型的元素,其行为类似于 ndarray.

title#

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

type#

在 NumPy 中,通常是 dtype 的同义词.对于更通用的 Python 含义, see here.

ufunc#

NumPy 快速的逐元素计算 ( vectorization ) 提供了一个选择,即应用哪个函数.该函数的通用术语是 ufunc ,是 universal function 的缩写.NumPy 例程有内置 ufunc,但用户也可以 write their own.

vectorization#

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

view#

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

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

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

一些 NumPy 例程总是返回 views,一些总是返回 copies,一些可能返回其中一个,而对于一些例程,可以选择其返回的类型.管理 views 和 copies 的责任落在程序员身上. numpy.shares_memory 将检查 b 是否是 a 的一个 view,但正如文档页面所解释的那样,一个确切的答案并不总是可行的.

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