术语表#

(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 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不同,在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 的 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 的标量或 python:序列.除了 ndarrays 和标量之外,这一类别还包括列表（可能嵌套且元素类型不同）和元组.:doc: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 实例.

axis#

数组维度的另一个术语.轴从左到右编号;轴 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 可以确定数组是否是视图.正确的做法请参见 numpy.shares_memory.

大端序#

请参见字节序.

BLAS#

基本线性代数子程序

广播#

broadcasting 是 NumPy 处理不同大小 ndarrays 的能力,就好像它们都是相同大小一样.

它允许一种优雅的”按我意思做”的行为,例如,将标量添加到向量中会将标量值添加到每个元素中.

>>> 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 顺序#

与行优先相同.

casting#

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

no: 数据类型根本不应该被转换.数组之间的数据类型不匹配将引发 TypeError.
equiv: 只允许字节顺序的变化.
safe: 只允许可以保留值的转换.向上转换（例如,从 int 到 float）是允许的,但向下转换是不允许的.
same_kind: ‘same_kind’ 转换选项允许安全的转换和同一类型内的转换,例如从 float64 到 float32.
unsafe: 可以进行任何数据转换.

column-major#

请参见行优先和列优先顺序.

contiguous#

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

它占据了一个连续的内存块,并且
具有较高索引的数组元素占据较高的地址（即,没有步幅是负的）.

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

Fortran-连续数组指的是按列存储的数据,即数据的索引从最低维度开始存储在内存中;
C-连续,或简单地称为连续数组,指的是按行存储的数据,即数据的索引方式是按照内存中存储的最高维度开始的.

对于一维数组,这些概念是一致的.

例如,一个2x2的数组 A 如果是Fortran连续的,那么它的元素在内存中的存储顺序如下:

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

如果顺序如下,则为 C-contiguous:

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

要测试一个数组是否是 C 连续的,使用 NumPy 数组的 .flags.c_contiguous 属性.要测试是否是 Fortran 连续的,使用 .flags.f_contiguous 属性.

copy#

查看视图.

dimension#

请参见轴.

dtype#

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

花式索引#

另一个术语为高级索引.

field#

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

Fortran 顺序#

与列优先相同.

flattened#

查看 ravel.

homogeneous#

同质数组的全部元素具有相同的类型.与Python列表不同,ndarrays是同质的.类型可以很复杂,例如在结构化数组中,但所有元素都具有该类型.

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

itemsize#

dtype 元素的大小（以字节为单位）.

little-endian#

请参见字节序.

mask#

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

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

详情请参见掩码数组.

matrix#

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

ndarray#

NumPy 的基本结构.

对象数组#

一个 dtype 为 object 的数组;即,它包含对 Python 对象的引用.索引数组会解引用 Python 对象,因此与其他 ndarrays 不同,对象数组具有容纳异构对象的能力.

ravel#

numpy.ravel 和 numpy.flatten 都可以展平一个 ndarray.``ravel`` 如果可能的话会返回一个视图;``flatten`` 总是返回一个副本.

展平将多维数组折叠为一维;如何完成此操作的细节（例如,``a[n+1]`` 应该是下一行还是下一列）是参数.

记录数组#

一个结构化数组允许以属性样式 (a.field) 访问,而不仅仅是 a['field'].详情请参见 numpy.recarray.

row-major#

请参见行优先和列优先顺序 .NumPy 默认以行优先顺序创建数组.

scalar#

在 NumPy 中,通常是数组标量的同义词.

shape#

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

stride#

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

步幅是根据数组的dtype和形状自动计算的,但可以使用 as_strided. 直接指定.

详情请参见 numpy.ndarray.strides.

要了解步幅如何支撑NumPy视图的强大功能,请参阅《NumPy数组:一种高效数值计算的结构》<https://arxiv.org/pdf/1102.1523.pdf>`_

结构化数组#

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

结构化数据类型#

用户可以创建任意复杂的 dtypes ,这些类型可以包括其他数组和数据类型.这些复合数据类型被称为结构化数据类型.

子数组#

嵌套在结构化数据类型中的数组,如 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.

title#

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

类型#

在 NumPy 中,通常是 dtype 的同义词.对于更一般的 Python 含义,:term:请参见此处.

ufunc#

NumPy 的快速逐元素计算（矢量化）提供了一个选择应用哪个函数的机会.该函数的一般术语是 ufunc,是 通用函数 的缩写.NumPy 例程内置了 ufuncs,但用户也可以编写自己的.

矢量化#

NumPy 将数组处理交给 C 语言,因为在 C 语言中循环和计算比在 Python 中快得多.为了利用这一点,使用 NumPy 的程序员会消除 Python 循环,转而使用数组到数组的操作.:term:向量化 既可以指 C 语言的卸载,也可以指构建利用这一点的 NumPy 代码.

视图#

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

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

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

一些 NumPy 例程总是返回视图,一些总是返回副本,一些可能返回其中之一,而对于一些例程,选择可以指定.管理视图和副本的责任落在程序员身上.:func: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])