无标题 — darts 文档

class darts.dataprocessing.dtw.cost_matrix.CostMatrix[source]¶

基类: ABC

(n+1) x (m+1) 矩阵单元格 (i,j) 对应于 series1 和 series2 中匹配元素 (i-1, j-1) 的最小总成本/距离。

行 0 和列 0 通常设置为无穷大，以防止在第一个元素之前进行匹配

方法

to_dense()

返回类型: 密集 n x m numpy 数组，其中空单元格设置为 np.inf

fill

abstract fill(value)[source]¶

m: int¶

n: int¶

abstract to_dense()[source]¶

返回类型: 密集 n x m numpy 数组，其中空单元格设置为 np.inf

class darts.dataprocessing.dtw.cost_matrix.DenseCostMatrix(n, m)[source]¶

基类: ndarray, CostMatrix

属性

`T`	转置数组的视图。
`base`	如果内存来自其他对象，则为基对象。
`ctypes`	一个用于简化数组与 ctypes 模块交互的对象。
`data`	指向数组数据开头的 Python 缓冲区对象。
`dtype`	数组元素的数据类型。
`flags`	关于数组内存布局的信息。
`flat`	数组上的一维迭代器。
`imag`	数组的虚部。
`itemsize`	一个数组元素以字节为单位的长度。
`mT`	矩阵转置数组的视图。
`nbytes`	数组元素消耗的总字节数。
`ndim`	数组维度数。
`real`	数组的实部。
`shape`	数组维度的元组。
`size`	数组中的元素数。
`strides`	遍历数组时在每个维度上步进的字节元组。

device
itemset
newbyteorder
ptp

方法

`all`([axis, out, keepdims, where])	如果所有元素都评估为 True，则返回 True。
`any`([axis, out, keepdims, where])	如果 a 的任何元素评估为 True，则返回 True。
`argmax`([axis, out, keepdims])	返回给定轴上最大值的索引。
`argmin`([axis, out, keepdims])	返回给定轴上最小值的索引。
`argpartition`(kth[, axis, kind, order])	返回将分区此数组的索引。
`argsort`([axis, kind, order])	返回将排序此数组的索引。
`astype`(dtype[, order, casting, subok, copy])	数组的副本，强制转换为指定的类型。
`byteswap`([inplace])	交换数组元素的字节
`choose`(choices[, out, mode])	使用索引数组从一组选择中构建新数组。
`clip`([min, max, out])	返回其值被限制在 `[min, max]` 范围内的数组。
`compress`(condition[, axis, out])	返回沿给定轴从此数组中选择的切片。
`conj`()	对所有元素进行复共轭。
`conjugate`()	返回元素的复共轭。
`copy`([order])	返回数组的副本。
`cumprod`([axis, dtype, out])	返回沿给定轴的元素的累积乘积。
`cumsum`([axis, dtype, out])	返回沿给定轴的元素的累积和。
`diagonal`([offset, axis1, axis2])	返回指定的对角线。
`dump`(file)	将数组的 pickle 转储到指定文件中。
`dumps`()	将数组的 pickle 作为字符串返回。
`fill`(value)	用标量值填充数组。
`flatten`([order])	返回折叠成一维的数组副本。
`getfield`(dtype[, offset])	将给定数组的字段作为某种类型返回。
`item`(*args)	将数组的一个元素复制到标准的 Python 标量并返回。
`max`([axis, out, keepdims, initial, where])	返回沿给定轴的最大值。
`mean`([axis, dtype, out, keepdims, where])	返回沿给定轴的数组元素的平均值。
`min`([axis, out, keepdims, initial, where])	返回沿给定轴的最小值。
`nonzero`()	返回非零元素的索引。
`partition`(kth[, axis, kind, order])	部分排序数组中的元素，使得位于 k-th 位置的元素处于在排序数组中应有的位置。在输出数组中，所有小于 k-th 元素的元素位于该元素的左侧，所有等于或大于的元素位于其右侧。输出数组中 k-th 元素两侧的两个分区中元素的顺序是未定义的。
`prod`([axis, dtype, out, keepdims, initial, ...])	返回给定轴上的数组元素的乘积
`put`(indices, values[, mode])	对于 indices 中的所有 n，设置 `a.flat[n] = values[n]`。
`ravel`([order])	返回展平的数组。
`repeat`(repeats[, axis])	重复数组的元素。
`reshape`(shape, /, *[, order, copy])	返回包含相同数据但具有新形状的数组。
`resize`(new_shape[, refcheck])	就地更改数组的形状和大小。
`round`([decimals, out])	返回 a，其中每个元素都四舍五入到给定的小数位数。
`searchsorted`(v[, side, sorter])	找到应将 v 的元素插入 a 以保持顺序的索引。
`setfield`(val, dtype[, offset])	将值放入由数据类型定义的字段中的指定位置。
`setflags`([write, align, uic])	分别设置数组标志 WRITEABLE, ALIGNED, WRITEBACKIFCOPY。
`sort`([axis, kind, order])	就地排序数组。
`squeeze`([axis])	从 a 中移除长度为一的轴。
`std`([axis, dtype, out, ddof, keepdims, where])	返回沿给定轴的数组元素的标准差。
`sum`([axis, dtype, out, keepdims, initial, where])	返回给定轴上数组元素的总和。
`swapaxes`(axis1, axis2)	返回将 axis1 和 axis2 互换的数组视图。
`take`(indices[, axis, out, mode])	返回由 a 在给定索引处的元素形成的数组。
`to_dense`()	返回类型密集 n x m numpy 数组，其中空单元格设置为 np.inf
`tobytes`([order])	构建包含数组中原始数据字节的 Python 字节。
`tofile`(fid[, sep, format])	将数组作为文本或二进制（默认）写入文件。
`tolist`()	将数组作为 `a.ndim` 深度嵌套的 Python 标量列表返回。
`tostring`([order])	~ndarray.tobytes 的兼容性别名，行为完全相同。
`trace`([offset, axis1, axis2, dtype, out])	返回沿数组对角线的总和。
`transpose`(*axes)	返回轴已转置的数组视图。
`var`([axis, dtype, out, ddof, keepdims, where])	返回沿给定轴的数组元素的方差。
`view`([dtype][, type])	具有相同数据的新数组视图。

dot
to_device

T¶

转置数组的视图。

与 self.transpose() 相同。

示例

>>> import numpy as np
>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
       [3, 4]])
>>> a.T
array([[1, 3],
       [2, 4]])

>>> a = np.array([1, 2, 3, 4])
>>> a
array([1, 2, 3, 4])
>>> a.T
array([1, 2, 3, 4])

另请参阅

transpose

all(axis=None, out=None, keepdims=False, *, where=True)¶

如果所有元素都评估为 True，则返回 True。

请参阅 numpy.all 获取完整文档。

另请参阅

numpy.all: 等效函数

any(axis=None, out=None, keepdims=False, *, where=True)¶

如果 a 的任何元素评估为 True，则返回 True。

请参阅 numpy.any 获取完整文档。

另请参阅

numpy.any: 等效函数

argmax(axis=None, out=None, *, keepdims=False)¶

返回给定轴上最大值的索引。

请参阅 numpy.argmax 获取完整文档。

另请参阅

numpy.argmax: 等效函数

argmin(axis=None, out=None, *, keepdims=False)¶

返回给定轴上最小值的索引。

请参阅 numpy.argmin 获取详细文档。

另请参阅

numpy.argmin: 等效函数

argpartition(kth, axis=- 1, kind='introselect', order=None)¶

返回将分区此数组的索引。

请参阅 numpy.argpartition 获取完整文档。

另请参阅

numpy.argpartition: 等效函数

argsort(axis=- 1, kind=None, order=None)¶

返回将排序此数组的索引。

请参阅 numpy.argsort 获取完整文档。

另请参阅

numpy.argsort: 等效函数

astype(dtype, order='K', casting='unsafe', subok=True, copy=True)¶

数组的副本，强制转换为指定的类型。

参数

dtype (str 或 dtype) – 数组要强制转换成的类型代码或数据类型。
order ({'C', 'F', 'A', 'K'}, 可选) – 控制结果的内存布局顺序。'C' 表示 C 顺序，'F' 表示 Fortran 顺序，'A' 表示如果所有数组都是 Fortran 连续的则为 'F' 顺序，否则为 'C' 顺序，'K' 表示尽可能接近数组元素在内存中出现的顺序。默认值为 'K'。
casting ({'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, 可选) –
控制可能发生的数据强制转换类型。为了向后兼容，默认为 ‘unsafe’。
- ‘no’ 表示数据类型根本不应被强制转换。
- ‘equiv’ 表示只允许字节序更改。
- ‘safe’ 表示只允许可以保留值的强制转换。
- ‘same_kind’ 表示只允许安全转换或同类转换，例如 float64 到 float32。
- ‘unsafe’ 表示可以进行任何数据转换。
subok (bool, 可选) – 如果为 True，则子类将透传（默认），否则返回的数组将被强制为基类数组。
copy (bool, 可选) – 默认情况下，astype 总是返回新分配的数组。如果此参数设置为 false，并且满足 dtype、order 和 subok 要求，则返回输入数组而不是副本。

返回

arr_t – 除非 copy 为 False 并且满足返回输入数组的其他条件（参见 copy 输入参数的描述），否则 arr_t 是一个与输入数组具有相同形状的新数组，其 dtype 和 order 由 dtype 和 order 给出。

返回类型

ndarray

引发

ComplexWarning – 当从复数转换为浮点数或整数时。为了避免这种情况，应该使用 a.real.astype(t)。

示例

>>> import numpy as np
>>> x = np.array([1, 2, 2.5])
>>> x
array([1. ,  2. ,  2.5])

>>> x.astype(int)
array([1, 2, 2])

base¶

如果内存来自其他对象，则为基对象。

示例

拥有其内存的数组的基是 None

>>> import numpy as np
>>> x = np.array([1,2,3,4])
>>> x.base is None
True

切片创建一个视图，其内存与 x 共享

>>> y = x[2:]
>>> y.base is x
True

byteswap(inplace=False)¶

交换数组元素的字节

通过返回字节交换数组来在低位优先和高位优先数据表示之间切换，可以选择就地交换。字节字符串数组不会被交换。复数的实部和虚部分别被交换。

参数: inplace (bool, 可选) – 如果为 True，则就地交换字节，默认为 False。
返回: out – 字节交换后的数组。如果 inplace 为 True，则这是 self 的视图。
返回类型: ndarray

示例

>>> import numpy as np
>>> A = np.array([1, 256, 8755], dtype=np.int16)
>>> list(map(hex, A))
['0x1', '0x100', '0x2233']
>>> A.byteswap(inplace=True)
array([  256,     1, 13090], dtype=int16)
>>> list(map(hex, A))
['0x100', '0x1', '0x3322']

字节字符串数组不会被交换

>>> A = np.array([b'ceg', b'fac'])
>>> A.byteswap()
array([b'ceg', b'fac'], dtype='|S3')

A.view(A.dtype.newbyteorder()).byteswap() 生成一个值相同但在内存中有不同表示的数组

>>> A = np.array([1, 2, 3],dtype=np.int64)
>>> A.view(np.uint8)
array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
       0, 0], dtype=uint8)
>>> A.view(A.dtype.newbyteorder()).byteswap(inplace=True)
array([1, 2, 3], dtype='>i8')
>>> A.view(np.uint8)
array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
       0, 3], dtype=uint8)

choose(choices, out=None, mode='raise')¶

使用索引数组从一组选择中构建新数组。

请参阅 numpy.choose 获取完整文档。

另请参阅

numpy.choose: 等效函数

clip(min=None, max=None, out=None, **kwargs)¶

返回其值被限制在 [min, max] 范围内的数组。必须给出 max 或 min 中的一个。

请参阅 numpy.clip 获取完整文档。

另请参阅

numpy.clip: 等效函数

compress(condition, axis=None, out=None)¶

返回沿给定轴从此数组中选择的切片。

请参阅 numpy.compress 获取完整文档。

另请参阅

numpy.compress: 等效函数

conj()¶

对所有元素进行复共轭。

请参阅 numpy.conjugate 获取完整文档。

另请参阅

numpy.conjugate: 等效函数

conjugate()¶

返回元素的复共轭。

请参阅 numpy.conjugate 获取完整文档。

另请参阅

numpy.conjugate: 等效函数

copy(order='C')¶

返回数组的副本。

参数: order ({'C', 'F', 'A', 'K'}, 可选) – 控制副本的内存布局。'C' 表示 C 顺序，'F' 表示 F 顺序，如果 a 是 Fortran 连续的则 'A' 表示 'F'，否则为 'C'。'K' 表示尽可能匹配 a 的布局。（请注意，此函数与 numpy.copy() 非常相似，但其 order= 参数的默认值不同，并且此函数总是透传子类。）

另请参阅

numpy.copy: 默认行为不同的类似函数

numpy.copyto

说明

此函数是创建数组副本的首选方法。numpy.copy() 函数类似，但它默认为使用 order ‘K’，并且默认不会透传子类。

示例

>>> import numpy as np
>>> x = np.array([[1,2,3],[4,5,6]], order='F')

>>> y = x.copy()

>>> x.fill(0)

>>> x
array([[0, 0, 0],
       [0, 0, 0]])

>>> y
array([[1, 2, 3],
       [4, 5, 6]])

>>> y.flags['C_CONTIGUOUS']
True

对于包含 Python 对象（例如 dtype=object）的数组，复制是浅拷贝。新数组将包含相同的对象，如果该对象可以修改（是可变的），可能会导致意外。

>>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
>>> b = a.copy()
>>> b[2][0] = 10
>>> a
array([1, 'm', list([10, 3, 4])], dtype=object)

为确保 object 数组中的所有元素都被复制，请使用 copy.deepcopy

>>> import copy
>>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
>>> c = copy.deepcopy(a)
>>> c[2][0] = 10
>>> c
array([1, 'm', list([10, 3, 4])], dtype=object)
>>> a
array([1, 'm', list([2, 3, 4])], dtype=object)

ctypes¶

一个用于简化数组与 ctypes 模块交互的对象。

此属性创建一个对象，使得在使用 ctypes 模块调用共享库时更容易使用数组。返回的对象具有 data、shape 和 strides 等属性（参见下面的说明），这些属性本身返回 ctypes 对象，可以用作共享库的参数。

参数: None –
返回: c – 具有 data, shape, strides 等属性。
返回类型: Python 对象

另请参阅

numpy.ctypeslib

说明

以下是此对象的公共属性，已在“Guide to NumPy”中记录（我们已省略未记录的公共属性以及已记录的私有属性）

_ctypes.data

一个指向数组内存区域的 Python 整数指针。此内存区域可能包含未对齐或字节序不正确的数据。该内存区域甚至可能不可写。将此属性传递给任意 C 代码时，应遵守此数组的数组标志和数据类型，以避免可能导致 Python 崩溃的问题。用户注意！此属性的值与 self._array_interface_['data'][0] 完全相同。

注意，与 data_as 不同，不会保留对数组的引用：像 ctypes.c_void_p((a + b).ctypes.data) 这样的代码将导致指向已释放数组的指针，应写成 (a + b).ctypes.data_as(ctypes.c_void_p)

_ctypes.shape

一个长度为 self.ndim 的 ctypes 数组，其 basetype 是此平台上对应于 dtype('p') 的 C 整数（参见 ~numpy.ctypeslib.c_intp）。这个基类型可能是 ctypes.c_int、ctypes.c_long 或 ctypes.c_longlong，具体取决于平台。ctypes 数组包含底层数组的形状。

类型: (c_intp*self.ndim)

_ctypes.strides

一个长度为 self.ndim 的 ctypes 数组，其 basetype 与 shape 属性的相同。此 ctypes 数组包含底层数组的 strides 信息。此 strides 信息对于显示在数组中跳跃多少字节才能到达下一个元素非常重要。

类型: (c_intp*self.ndim)

_ctypes.data_as(obj)

返回强制转换为特定 c-types 对象的 data 指针。例如，调用 self._as_parameter_ 等同于 self.data_as(ctypes.c_void_p)。也许你想将 data 用作指向浮点数据 ctypes 数组的指针：self.data_as(ctypes.POINTER(ctypes.c_double))。

返回的指针将保留对数组的引用。

_ctypes.shape_as(obj): 将 shape 元组作为某些其他 c-types 类型的数组返回。例如：self.shape_as(ctypes.c_short)。

_ctypes.strides_as(obj): 将 strides 元组作为某些其他 c-types 类型的数组返回。例如：self.strides_as(ctypes.c_longlong)。

如果 ctypes 模块不可用，则数组对象的 ctypes 属性仍然返回有用的东西，但不会返回 ctypes 对象，而是可能引发错误。特别是，该对象仍将具有 as_parameter 属性，该属性将返回一个等于 data 属性的整数。

示例

>>> import numpy as np
>>> import ctypes
>>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)
>>> x
array([[0, 1],
       [2, 3]], dtype=int32)
>>> x.ctypes.data
31962608 # may vary
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32))
<__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents
c_uint(0)
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents
c_ulong(4294967296)
>>> x.ctypes.shape
<numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary
>>> x.ctypes.strides
<numpy._core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary

cumprod(axis=None, dtype=None, out=None)¶

返回沿给定轴的元素的累积乘积。

请参阅 numpy.cumprod 获取完整文档。

另请参阅

numpy.cumprod: 等效函数

cumsum(axis=None, dtype=None, out=None)¶

返回沿给定轴的元素的累积和。

请参阅 numpy.cumsum 获取完整文档。

另请参阅

numpy.cumsum: 等效函数

data¶: 指向数组数据开头的 Python 缓冲区对象。

device¶

diagonal(offset=0, axis1=0, axis2=1)¶

返回指定的对角线。在 NumPy 1.9 中，返回的数组是只读视图而不是像以前 NumPy 版本那样的副本。在未来的版本中将移除只读限制。

请参阅 numpy.diagonal() 获取完整文档。

另请参阅

numpy.diagonal: 等效函数

dot()¶

dtype¶

数组元素的数据类型。

警告

不鼓励设置 arr.dtype，将来可能会弃用。设置将替换 dtype 但不修改内存（另请参阅 ndarray.view 和 ndarray.astype）。

参数: None –
返回: d
返回类型: numpy dtype 对象

另请参阅

ndarray.astype: 将数组中包含的值强制转换为新的数据类型。
ndarray.view: 创建相同数据但不同数据类型的视图。

numpy.dtype

示例

>>> x
array([[0, 1],
       [2, 3]])
>>> x.dtype
dtype('int32')
>>> type(x.dtype)
<type 'numpy.dtype'>

dump(file)¶

将数组的 pickle 转储到指定文件中。可以使用 pickle.load 或 numpy.load 读回该数组。

参数: file (str 或 Path) – 转储文件的字符串名称。

dumps()¶

将数组的 pickle 作为字符串返回。pickle.loads 将把字符串转换回数组。

参数: None –

fill(value)¶

用标量值填充数组。

参数: value (scalar) – a 的所有元素都将分配此值。

示例

>>> import numpy as np
>>> a = np.array([1, 2])
>>> a.fill(0)
>>> a
array([0, 0])
>>> a = np.empty(2)
>>> a.fill(1)
>>> a
array([1.,  1.])

Fill 期望一个标量值，其行为总是与赋值给单个数组元素相同。以下是一个这种区别很重要的罕见示例

>>> a = np.array([None, None], dtype=object)
>>> a[0] = np.array(3)
>>> a
array([array(3), None], dtype=object)
>>> a.fill(np.array(3))
>>> a
array([array(3), array(3)], dtype=object)

而其他形式的赋值会解包被赋值的数组

>>> a[...] = np.array(3)
>>> a
array([3, 3], dtype=object)

flags¶

关于数组内存布局的信息。

C_CONTIGUOUS(C)¶: 数据位于一个单一的 C-style 连续段中。

F_CONTIGUOUS(F)¶: 数据位于一个单一的 Fortran-style 连续段中。

OWNDATA(O)¶: 数组拥有其使用的内存或从另一个对象借用内存。

WRITEABLE(W)¶: 数据区域可以写入。将其设置为 False 会锁定数据，使其只读。视图（切片等）在创建时从其基数组继承 WRITEABLE，但可写数组的视图可能会随后被锁定，而基数组保持可写。（反之则不成立，即锁定数组的视图不能变为可写。然而，目前，锁定基对象不会锁定任何已引用它的视图，因此在这种情况下，可以通过先前创建的可写视图修改锁定数组的内容。）尝试更改不可写数组会引发 RuntimeError 异常。

ALIGNED(A)¶: 数据和所有元素都已针对硬件进行适当对齐。

WRITEBACKIFCOPY(X)¶: 此数组是其他数组的副本。在释放之前，必须调用 C-API 函数 PyArray_ResolveWritebackIfCopy，基数组将更新为此数组的内容。

FNC¶: F_CONTIGUOUS 且不是 C_CONTIGUOUS。

FORC¶: F_CONTIGUOUS 或 C_CONTIGUOUS（一段测试）。

BEHAVED(B)¶: ALIGNED 和 WRITEABLE。

CARRAY(CA)¶: BEHAVED 和 C_CONTIGUOUS。

FARRAY(FA)¶: BEHAVED 和 F_CONTIGUOUS 且不是 C_CONTIGUOUS。

说明

flags 对象可以像字典一样访问（如 a.flags['WRITEABLE']），或使用小写属性名（如 a.flags.writeable）。短标志名仅支持字典访问。

只有 WRITEBACKIFCOPY、WRITEABLE 和 ALIGNED 标志可以由用户更改，通过直接赋值给属性或字典条目，或通过调用 ndarray.setflags。

数组标志不能任意设置

WRITEBACKIFCOPY 只能设置为 False。
只有数据真正对齐时，ALIGNED 才能设置为 True。
只有数组拥有自己的内存，或者内存的最终所有者暴露了可写缓冲区接口或是字符串时，WRITEABLE 才能设置为 True。

数组可以同时是 C-style 和 Fortran-style 连续的。对于一维数组来说这很清楚，但对于更高维的数组也可能成立。

即使对于连续数组，给定维度的步幅 arr.strides[dim] 可能是任意的，如果 arr.shape[dim] == 1 或者数组没有元素。对于 C-style 连续数组，self.strides[-1] == self.itemsize 通常不成立，对于 Fortran-style 连续数组，self.strides[0] == self.itemsize 也不成立。

flat¶

数组上的一维迭代器。

这是一个 numpy.flatiter 实例，其行为类似于 Python 的内置迭代器对象，但不是其子类。

另请参阅

flatten: 返回折叠成一维的数组副本。

flatiter

示例

>>> import numpy as np
>>> x = np.arange(1, 7).reshape(2, 3)
>>> x
array([[1, 2, 3],
       [4, 5, 6]])
>>> x.flat[3]
4
>>> x.T
array([[1, 4],
       [2, 5],
       [3, 6]])
>>> x.T.flat[3]
5
>>> type(x.flat)
<class 'numpy.flatiter'>

一个赋值示例

>>> x.flat = 3; x
array([[3, 3, 3],
       [3, 3, 3]])
>>> x.flat[[1,4]] = 1; x
array([[3, 1, 3],
       [3, 1, 3]])

flatten(order='C')¶

返回折叠成一维的数组副本。

参数: order ({'C', 'F', 'A', 'K'}, 可选) – ‘C’ 表示按行主序（C-style）展平。‘F’ 表示按列主序（Fortran-style）展平。如果 a 在内存中是 Fortran 连续的，则 ‘A’ 表示按列主序展平，否则按行主序展平。‘K’ 表示按元素在内存中出现的顺序展平 a。默认值为 ‘C’。
返回: y – 输入数组的副本，展平为一维。
返回类型: ndarray

另请参阅

ravel: 返回展平的数组。
flat: 数组上的一维平面迭代器。

示例

>>> import numpy as np
>>> a = np.array([[1,2], [3,4]])
>>> a.flatten()
array([1, 2, 3, 4])
>>> a.flatten('F')
array([1, 3, 2, 4])

getfield(dtype, offset=0)¶

将给定数组的字段作为某种类型返回。

字段是具有给定数据类型的数组数据的视图。视图中的值由给定类型和当前数组中的字节偏移量决定。偏移量需要使得视图 dtype 适合于数组 dtype；例如，dtype complex128 的数组具有 16 字节的元素。如果使用 32 位整数（4 字节）创建视图，则偏移量需要在 0 到 12 字节之间。

参数

dtype (str 或 dtype) – 视图的数据类型。视图的 dtype 大小不能大于数组本身。
offset (int) – 在开始元素视图之前要跳过的字节数。

示例

>>> import numpy as np
>>> x = np.diag([1.+1.j]*2)
>>> x[1, 1] = 2 + 4.j
>>> x
array([[1.+1.j,  0.+0.j],
       [0.+0.j,  2.+4.j]])
>>> x.getfield(np.float64)
array([[1.,  0.],
       [0.,  2.]])

通过选择 8 字节的偏移量，我们可以为视图选择数组的复数部分

>>> x.getfield(np.float64, offset=8)
array([[1.,  0.],
       [0.,  4.]])

imag¶

数组的虚部。

示例

>>> import numpy as np
>>> x = np.sqrt([1+0j, 0+1j])
>>> x.imag
array([ 0.        ,  0.70710678])
>>> x.imag.dtype
dtype('float64')

item(*args)¶

将数组的一个元素复制到标准的 Python 标量并返回。

参数

*args (参数 (数量和类型可变)) –

none: 在这种情况下，该方法仅适用于含有一个元素 (a.size == 1) 的数组，该元素被复制到标准的 Python 标量对象并返回。
int_type: 此参数被解释为数组的平面索引，指定要复制并返回哪个元素。
int_types 的元组: 功能与单个 int_type 参数相同，只是该参数被解释为数组的 nd-索引。

返回

z – 指定的数组元素作为合适的 Python 标量的副本

返回类型

标准的 Python 标量对象

说明

当 a 的数据类型为 longdouble 或 clongdouble 时，item() 返回一个标量数组对象，因为没有可用的 Python 标量不会丢失信息。Void 数组为 item() 返回一个缓冲区对象，除非定义了字段，在这种情况下返回一个元组。

item 与 a[args] 非常相似，不同之处在于返回的是标准的 Python 标量，而不是数组标量。这对于加速访问数组元素以及使用 Python 优化的数学对数组元素进行算术运算很有用。

示例

>>> import numpy as np
>>> np.random.seed(123)
>>> x = np.random.randint(9, size=(3, 3))
>>> x
array([[2, 2, 6],
       [1, 3, 6],
       [1, 0, 1]])
>>> x.item(3)
1
>>> x.item(7)
0
>>> x.item((0, 1))
2
>>> x.item((2, 2))
1

对于 object dtype 的数组，元素按原样返回。

>>> a = np.array([np.int64(1)], dtype=object)
>>> a.item() #return np.int64
np.int64(1)

itemset¶

itemsize¶

一个数组元素以字节为单位的长度。

示例

>>> import numpy as np
>>> x = np.array([1,2,3], dtype=np.float64)
>>> x.itemsize
8
>>> x = np.array([1,2,3], dtype=np.complex128)
>>> x.itemsize
16

m: int¶

mT¶

矩阵转置数组的视图。

矩阵转置是最后两个维度的转置，即使数组具有更高的维度。

2.0 版本新增。

引发: ValueError – 如果数组的维度小于 2。

示例

>>> import numpy as np
>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
       [3, 4]])
>>> a.mT
array([[1, 3],
       [2, 4]])

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

       [[4, 5],
        [6, 7]]])
>>> a.mT
array([[[0, 2],
        [1, 3]],

       [[4, 6],
        [5, 7]]])

max(axis=None, out=None, keepdims=False, initial=<no value>, where=True)¶

返回沿给定轴的最大值。

请参阅 numpy.amax 获取完整文档。

另请参阅

numpy.amax: 等效函数

mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True)¶

返回沿给定轴的数组元素的平均值。

请参阅 numpy.mean 获取完整文档。

另请参阅

numpy.mean: 等效函数

min(axis=None, out=None, keepdims=False, initial=<no value>, where=True)¶

返回沿给定轴的最小值。

请参阅 numpy.amin 获取完整文档。

另请参阅

numpy.amin: 等效函数

n: int¶

nbytes¶

数组元素消耗的总字节数。

说明

不包括数组对象的非元素属性消耗的内存。

另请参阅

sys.getsizeof: 对象本身消耗的内存，不包括父级（在视图情况下）。这确实包括非元素属性消耗的内存。

示例

>>> import numpy as np
>>> x = np.zeros((3,5,2), dtype=np.complex128)
>>> x.nbytes
480
>>> np.prod(x.shape) * x.itemsize
480

ndim¶

数组维度数。

示例

>>> import numpy as np
>>> x = np.array([1, 2, 3])
>>> x.ndim
1
>>> y = np.zeros((2, 3, 4))
>>> y.ndim
3

newbyteorder¶

nonzero()¶

返回非零元素的索引。

请参阅 numpy.nonzero 获取完整文档。

另请参阅

numpy.nonzero: 等效函数

partition(kth, axis=- 1, kind='introselect', order=None)¶

部分排序数组中的元素，使得位于 k-th 位置的元素处于在排序数组中应有的位置。在输出数组中，所有小于 k-th 元素的元素位于该元素的左侧，所有等于或大于的元素位于其右侧。输出数组中 k-th 元素两侧的两个分区中元素的顺序是未定义的。

参数

kth (int 或 ints 序列) –
用于分区的元素索引。第 kth 个元素的值将位于其最终排序位置，所有较小的元素将移至其前面，所有等于或更大的元素将移至其后面。分区中所有元素的顺序是未定义的。

自版本 1.22.0 起已弃用: 将布尔值作为索引传递已弃用。
axis (int, 可选) – 排序所沿的轴。默认为 -1，表示沿最后一个轴排序。
kind ({'introselect'}, 可选) – 选择算法。默认为 ‘introselect’。
order (str 或 str 列表, 可选) – 当 a 是一个定义了字段的数组时，此参数指定先比较哪个字段、其次是哪个字段等。单个字段可以指定为字符串，并且无需指定所有字段，但未指定的字段仍将按其在 dtype 中出现的顺序使用，以打破平局。

另请参阅

numpy.partition: 返回数组的分区副本。
argpartition: 间接分区。
sort: 完全排序。

说明

有关不同算法的说明，请参阅 np.partition。

示例

>>> import numpy as np
>>> a = np.array([3, 4, 2, 1])
>>> a.partition(3)
>>> a
array([2, 1, 3, 4]) # may vary

>>> a.partition((1, 3))
>>> a
array([1, 2, 3, 4])

prod(axis=None, dtype=None, out=None, keepdims=False, initial=1, where=True)¶

返回给定轴上的数组元素的乘积

请参阅 numpy.prod 获取完整文档。

另请参阅

numpy.prod: 等效函数

ptp¶

put(indices, values, mode='raise')¶

对于 indices 中的所有 n，设置 a.flat[n] = values[n]。

请参阅 numpy.put 获取完整文档。

另请参阅

numpy.put: 等效函数

ravel([order])¶

返回展平的数组。

请参阅 numpy.ravel 获取完整文档。

另请参阅

numpy.ravel: 等效函数
ndarray.flat: 数组上的平面迭代器。

real¶

数组的实部。

示例

>>> import numpy as np
>>> x = np.sqrt([1+0j, 0+1j])
>>> x.real
array([ 1.        ,  0.70710678])
>>> x.real.dtype
dtype('float64')

另请参阅

numpy.real: 等效函数

repeat(repeats, axis=None)¶

重复数组的元素。

请参阅 numpy.repeat 获取完整文档。

另请参阅

numpy.repeat: 等效函数

reshape(shape, /, *, order='C', copy=None)¶

返回包含相同数据但具有新形状的数组。

请参阅 numpy.reshape 获取完整文档。

另请参阅

numpy.reshape: 等效函数

说明

与自由函数 numpy.reshape 不同，ndarray 上的此方法允许将 shape 参数的元素作为单独的参数传递。例如，a.reshape(10, 11) 等同于 a.reshape((10, 11))。

resize(new_shape, refcheck=True)¶

就地更改数组的形状和大小。

参数

new_shape (ints 元组, 或 n 个 int) – 重设大小后的数组形状。
refcheck (bool, 可选) – 如果为 False，则不检查引用计数。默认为 True。

返回类型

None

引发

ValueError – 如果 a 不拥有其自己的数据或存在对其的引用或视图，并且必须更改数据内存。仅限于 PyPy：如果必须更改数据内存，将始终引发错误，因为没有可靠的方法确定是否存在对其的引用或视图。
SystemError – 如果指定了 order 关键字参数。此行为是 NumPy 中的一个 bug。

另请参阅

resize: 返回具有指定形状的新数组。

说明

如果需要，这将重新分配数据区域的空间。

只有连续数组（内存中连续的数据元素）可以重设大小。

引用计数检查的目的是确保您不将此数组用作另一个 Python 对象的缓冲区，然后重新分配内存。但是，引用计数可以通过其他方式增加，因此如果您确定尚未与另一个 Python 对象共享此数组的内存，则可以安全地将 refcheck 设置为 False。

示例

缩小数组：数组被展平（按数据在内存中的存储顺序），重设大小，并重新整形

>>> import numpy as np

>>> a = np.array([[0, 1], [2, 3]], order='C')
>>> a.resize((2, 1))
>>> a
array([[0],
       [1]])

>>> a = np.array([[0, 1], [2, 3]], order='F')
>>> a.resize((2, 1))
>>> a
array([[0],
       [2]])

增大数组：如上所述，但缺失的条目用零填充

>>> b = np.array([[0, 1], [2, 3]])
>>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
>>> b
array([[0, 1, 2],
       [3, 0, 0]])

引用数组会阻止重设大小…

>>> c = a
>>> a.resize((1, 1))
Traceback (most recent call last):
...
ValueError: cannot resize an array that references or is referenced ...

除非 refcheck 为 False

>>> a.resize((1, 1), refcheck=False)
>>> a
array([[0]])
>>> c
array([[0]])

round(decimals=0, out=None)¶

返回 a，其中每个元素都四舍五入到给定的小数位数。

请参阅 numpy.around 获取完整文档。

另请参阅

numpy.around: 等效函数

searchsorted(v, side='left', sorter=None)¶

找到应将 v 的元素插入 a 以保持顺序的索引。

有关完整文档，请参阅 numpy.searchsorted

另请参阅

numpy.searchsorted: 等效函数

setfield(val, dtype, offset=0)¶

将值放入由数据类型定义的字段中的指定位置。

将 val 放入 a 中由 dtype 定义、从字段开始处偏移 offset 字节的位置。

参数

val (object) – 要放入字段的值。
dtype (dtype object) – 放置 val 的字段的数据类型。
offset (int, optional) – 放置 val 的字段内字节偏移量。

返回类型

None

另请参阅

getfield

示例

>>> import numpy as np
>>> x = np.eye(3)
>>> x.getfield(np.float64)
array([[1.,  0.,  0.],
       [0.,  1.,  0.],
       [0.,  0.,  1.]])
>>> x.setfield(3, np.int32)
>>> x.getfield(np.int32)
array([[3, 3, 3],
       [3, 3, 3],
       [3, 3, 3]], dtype=int32)
>>> x
array([[1.0e+000, 1.5e-323, 1.5e-323],
       [1.5e-323, 1.0e+000, 1.5e-323],
       [1.5e-323, 1.5e-323, 1.0e+000]])
>>> x.setfield(np.eye(3), np.int32)
>>> x
array([[1.,  0.,  0.],
       [0.,  1.,  0.],
       [0.,  0.,  1.]])

setflags(write=None, align=None, uic=None)¶

分别设置数组标志 WRITEABLE, ALIGNED, WRITEBACKIFCOPY。

这些布尔值标志影响 numpy 如何解释 a 使用的内存区域（参见下面的 Notes）。ALIGNED 标志只有在数据实际按类型对齐时才能设置为 True。WRITEBACKIFCOPY 标志永远不能设置为 True。WRITEABLE 标志只有在数组拥有自己的内存，或者内存的最终所有者暴露了一个可写缓冲区接口，或者是字符串时才能设置为 True。（字符串的例外是为了可以在不复制内存的情况下进行反序列化。）

参数

write (bool, optional) – 描述 a 是否可以写入。
align (bool, optional) – 描述 a 是否根据其类型正确对齐。
uic (bool, optional) – 描述 a 是否是另一个“基础”数组的副本。

说明

数组标志提供有关如何解释数组使用的内存区域的信息。共有 7 个布尔标志在使用中，其中只有三个可以由用户更改：WRITEBACKIFCOPY、WRITEABLE 和 ALIGNED。

WRITEABLE (W) 数据区域可写入；

ALIGNED (A) 数据和跨度根据硬件（由编译器确定）适当对齐；

WRITEBACKIFCOPY (X) 此数组是某个其他数组（由 .base 引用）的副本。当调用 C-API 函数 PyArray_ResolveWritebackIfCopy 时，基础数组将使用此数组的内容进行更新。

所有标志都可以使用单个（大写）字母和全名访问。

示例

>>> import numpy as np
>>> y = np.array([[3, 1, 7],
...               [2, 0, 0],
...               [8, 5, 9]])
>>> y
array([[3, 1, 7],
       [2, 0, 0],
       [8, 5, 9]])
>>> y.flags
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
>>> y.setflags(write=0, align=0)
>>> y.flags
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : False
  ALIGNED : False
  WRITEBACKIFCOPY : False
>>> y.setflags(uic=1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: cannot set WRITEBACKIFCOPY flag to True

shape¶

数组维度的元组。

shape 属性通常用于获取数组的当前形状，但也可以通过为其分配一个数组维度元组来就地重塑数组。与 numpy.reshape 一样，新的形状维度之一可以是 -1，在这种情况下，其值将根据数组的大小和剩余维度推断出来。如果需要复制，则就地重塑数组将失败。

警告

不鼓励设置 arr.shape，将来可能会弃用。推荐使用 ndarray.reshape 方法。

示例

>>> import numpy as np
>>> x = np.array([1, 2, 3, 4])
>>> x.shape
(4,)
>>> y = np.zeros((2, 3, 4))
>>> y.shape
(2, 3, 4)
>>> y.shape = (3, 8)
>>> y
array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
>>> y.shape = (3, 6)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: total size of new array must be unchanged
>>> np.zeros((4,2))[::2].shape = (-1,)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: Incompatible shape for in-place modification. Use
`.reshape()` to make a copy with the desired shape.

另请参阅

numpy.shape: 等效的 getter 函数。
numpy.reshape: 类似于设置 shape 的函数。
ndarray.reshape: 类似于设置 shape 的方法。

size¶

数组中的元素数。

等于 np.prod(a.shape)，即数组维度的乘积。

说明

a.size 返回标准的任意精度 Python 整数。通过其他方法获取相同值可能不是这样（例如建议的 np.prod(a.shape) 返回 np.int_ 的实例），并且如果该值用于进一步的计算可能导致固定大小整数类型溢出，则可能相关。

示例

>>> import numpy as np
>>> x = np.zeros((3, 5, 2), dtype=np.complex128)
>>> x.size
30
>>> np.prod(x.shape)
30

sort(axis=- 1, kind=None, order=None)¶

就地排序数组。有关完整文档，请参阅 numpy.sort。

参数

axis (int, 可选) – 排序所沿的轴。默认为 -1，表示沿最后一个轴排序。
kind ({'quicksort', 'mergesort', 'heapsort', 'stable'}, optional) – 排序算法。默认为 'quicksort'。请注意，'stable' 和 'mergesort' 在底层都使用 timsort，并且通常实际实现会因数据类型而异。保留 'mergesort' 选项是为了向后兼容。
order (str or list of str, optional) – 当 a 是一个定义了字段的数组时，此参数指定首先比较哪个字段，然后是第二个，依此类推。单个字段可以指定为字符串，并且不需要指定所有字段，但未指定的字段仍将按照它们在 dtype 中出现的顺序用于打破平局。

另请参阅

numpy.sort: 返回数组的排序副本。
numpy.argsort: 间接排序。
numpy.lexsort: 基于多个键的间接稳定排序。
numpy.searchsorted: 在已排序数组中查找元素。
numpy.partition: 部分排序。

说明

有关不同排序算法的注意事项，请参阅 numpy.sort。

示例

>>> import numpy as np
>>> a = np.array([[1,4], [3,1]])
>>> a.sort(axis=1)
>>> a
array([[1, 4],
       [1, 3]])
>>> a.sort(axis=0)
>>> a
array([[1, 3],
       [1, 4]])

使用 order 关键字指定对结构化数组进行排序时使用的字段

>>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
>>> a.sort(order='y')
>>> a
array([(b'c', 1), (b'a', 2)],
      dtype=[('x', 'S1'), ('y', '<i8')])

squeeze(axis=None)¶

从 a 中移除长度为一的轴。

有关完整文档，请参阅 numpy.squeeze。

另请参阅

numpy.squeeze: 等效函数

std(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)¶

返回沿给定轴的数组元素的标准差。

有关完整文档，请参阅 numpy.std。

另请参阅

numpy.std: 等效函数

strides¶

遍历数组时在每个维度上步进的字节元组。

数组 a 中元素 (i[0], i[1], ..., i[n]) 的字节偏移量为

offset = sum(np.array(i) * a.strides)

关于跨度的更详细解释可以在 arrays.ndarray 中找到。

警告

不鼓励设置 arr.strides，将来可能会弃用。应优先使用 numpy.lib.stride_tricks.as_strided 以更安全的方式创建相同数据的新视图。

说明

想象一个由 32 位整数（每个 4 字节）组成的数组

x = np.array([[0, 1, 2, 3, 4],
              [5, 6, 7, 8, 9]], dtype=np.int32)

此数组在内存中存储为 40 个连续的字节块。数组的跨度告诉我们必须在内存中跳过多少字节才能沿着某个轴移动到下一个位置。例如，我们必须跳过 4 个字节（1 个值）才能移动到下一列，但要跳过 20 个字节（5 个值）才能到达下一行的相同位置。因此，数组 x 的跨度将是 (20, 4)。

另请参阅

numpy.lib.stride_tricks.as_strided

示例

>>> import numpy as np
>>> y = np.reshape(np.arange(2*3*4), (2,3,4))
>>> y
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]]])
>>> y.strides
(48, 16, 4)
>>> y[1,1,1]
17
>>> offset=sum(y.strides * np.array((1,1,1)))
>>> offset/y.itemsize
17

>>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
>>> x.strides
(32, 4, 224, 1344)
>>> i = np.array([3,5,2,2])
>>> offset = sum(i * x.strides)
>>> x[3,5,2,2]
813
>>> offset / x.itemsize
813

sum(axis=None, dtype=None, out=None, keepdims=False, initial=0, where=True)¶

返回给定轴上数组元素的总和。

有关完整文档，请参阅 numpy.sum。

另请参阅

numpy.sum: 等效函数

swapaxes(axis1, axis2)¶

返回将 axis1 和 axis2 互换的数组视图。

有关完整文档，请参阅 numpy.swapaxes。

另请参阅

numpy.swapaxes: 等效函数

take(indices, axis=None, out=None, mode='raise')¶

返回由 a 在给定索引处的元素形成的数组。

有关完整文档，请参阅 numpy.take。

另请参阅

numpy.take: 等效函数

to_dense()[source]¶

返回类型: 密集 n x m numpy 数组，其中空单元格设置为 np.inf

to_device()¶

tobytes(order='C')¶

构建包含数组中原始数据字节的 Python 字节。

构造 Python 字节串，显示数据内存原始内容的副本。默认情况下，字节串以 C 顺序生成。此行为由 order 参数控制。

参数: order ({'C', 'F', 'A'}, optional) – 控制字节串的内存布局。'C' 表示 C 顺序，'F' 表示 F 顺序，'A'（Any 的缩写）表示如果 a 是 Fortran 连续，则为 'F'，否则为 'C'。默认为 'C'。
返回: s – 显示 a 原始数据副本的 Python 字节串。
返回类型: bytes

另请参阅

frombuffer: 此操作的逆操作，从 Python 字节串构造一个一维数组。

示例

>>> import numpy as np
>>> x = np.array([[0, 1], [2, 3]], dtype='<u2')
>>> x.tobytes()
b'\x00\x00\x01\x00\x02\x00\x03\x00'
>>> x.tobytes('C') == x.tobytes()
True
>>> x.tobytes('F')
b'\x00\x00\x02\x00\x01\x00\x03\x00'

tofile(fid, sep='', format='%s')¶

将数组作为文本或二进制（默认）写入文件。

数据始终以 'C' 顺序写入，与 a 的顺序无关。此方法生成的数据可以使用 fromfile() 函数恢复。

参数

fid (file or str or Path) – 一个打开的文件对象，或包含文件名的字符串。
sep (str) – 文本输出中数组项之间的分隔符。如果为 ""（空），则写入二进制文件，等效于 file.write(a.tobytes())。
format (str) – 文本文件输出的格式字符串。数组中的每个条目首先转换为最接近的 Python 类型，然后使用 "format" % item 格式化为文本。

说明

这是一个方便的功能，用于快速存储数组数据。字节序和精度信息会丢失，因此此方法不是用于归档数据或在具有不同字节序的机器之间传输数据的文件的好选择。其中一些问题可以通过将数据输出为文本文件来解决，但这会牺牲速度和文件大小。

当 fid 是一个文件对象时，数组内容直接写入文件，绕过了文件对象的 write 方法。因此，tofile 不能用于支持压缩的文件对象（例如 GzipFile）或不支持 fileno() 的类文件对象（例如 BytesIO）。

tolist()¶

将数组作为 a.ndim 深度嵌套的 Python 标量列表返回。

将数组数据的副本返回为（嵌套的）Python 列表。数据项通过 ~numpy.ndarray.item 函数转换为最接近的兼容内置 Python 类型。

如果 a.ndim 为 0，则由于嵌套列表的深度为 0，它根本不会是一个列表，而是一个简单的 Python 标量。

参数: none –
返回: y – 数组元素的可能嵌套列表。
返回类型: object，或 list of object，或 list of list of object，或 …

说明

数组可以通过 a = np.array(a.tolist()) 重新创建，尽管这有时可能会丢失精度。

示例

对于一维数组，a.tolist() 几乎与 list(a) 相同，除了 tolist 会将 numpy 标量更改为 Python 标量

>>> import numpy as np
>>> a = np.uint32([1, 2])
>>> a_list = list(a)
>>> a_list
[np.uint32(1), np.uint32(2)]
>>> type(a_list[0])
<class 'numpy.uint32'>
>>> a_tolist = a.tolist()
>>> a_tolist
[1, 2]
>>> type(a_tolist[0])
<class 'int'>

此外，对于二维数组，tolist 递归应用

>>> a = np.array([[1, 2], [3, 4]])
>>> list(a)
[array([1, 2]), array([3, 4])]
>>> a.tolist()
[[1, 2], [3, 4]]

此递归的基本情况是 0D 数组

>>> a = np.array(1)
>>> list(a)
Traceback (most recent call last):
  ...
TypeError: iteration over a 0-d array
>>> a.tolist()
1

tostring(order='C')¶

~ndarray.tobytes 的兼容性别名，行为完全相同。

尽管名为 tostring，它返回的是 bytes，而不是 str。

自版本 1.19.0 起弃用。

trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)¶

返回沿数组对角线的总和。

有关完整文档，请参阅 numpy.trace。

另请参阅

numpy.trace: 等效函数

transpose(*axes)¶

返回轴已转置的数组视图。

有关完整文档，请参阅 numpy.transpose。

参数

axes (None, tuple of ints, or n ints) –

None 或无参数：反转轴的顺序。
整数元组：元组中第 j 个位置的 i 表示数组的第 i 个轴成为转置数组的第 j 个轴。
n 个整数：与由相同整数组成的 n 元组相同（此形式仅用作元组形式的“便利”替代）。

返回

p – 数组经过适当置换轴后的视图。

返回类型

ndarray

另请参阅

transpose: 等效函数。
ndarray.T: 返回数组转置的数组属性。
ndarray.reshape: 在不改变数据的情况下为数组提供新的形状。

示例

>>> import numpy as np
>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
       [3, 4]])
>>> a.transpose()
array([[1, 3],
       [2, 4]])
>>> a.transpose((1, 0))
array([[1, 3],
       [2, 4]])
>>> a.transpose(1, 0)
array([[1, 3],
       [2, 4]])

>>> a = np.array([1, 2, 3, 4])
>>> a
array([1, 2, 3, 4])
>>> a.transpose()
array([1, 2, 3, 4])

var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)¶

返回沿给定轴的数组元素的方差。

有关完整文档，请参阅 numpy.var。

另请参阅

numpy.var: 等效函数

view([dtype][, type])¶

具有相同数据的新数组视图。

注意

为 dtype 传递 None 与省略参数不同，因为前者会调用 dtype(None)，它是 dtype('float64') 的别名。

参数

dtype (data-type or ndarray sub-class, optional) – 返回视图的数据类型描述符，例如 float32 或 int16。省略它会导致视图与 a 具有相同的数据类型。此参数也可以指定为 ndarray 子类，然后指定返回对象的类型（这等效于设置 type 参数）。
type (Python type, optional) – 返回视图的类型，例如 ndarray 或 matrix。同样，省略此参数会保留原类型。

说明

a.view() 有两种不同的用法

a.view(some_dtype) 或 a.view(dtype=some_dtype) 构造一个具有不同数据类型的数组内存视图。这可能导致内存字节被重新解释。

a.view(ndarray_subclass) 或 a.view(type=ndarray_subclass) 只是返回一个 ndarray_subclass 的实例，该实例查看相同的数组（相同的形状、dtype 等）。这不会导致内存的重新解释。

对于 a.view(some_dtype)，如果 some_dtype 的每个条目的字节数与之前的 dtype 不同（例如，将常规数组转换为结构化数组），则 a 的最后一个轴必须是连续的。此轴将在结果中重新调整大小。

版本 1.23.0 中更改：只有最后一个轴需要连续。以前，整个数组必须是 C 连续的。

示例

>>> import numpy as np
>>> x = np.array([(-1, 2)], dtype=[('a', np.int8), ('b', np.int8)])

使用不同的类型和 dtype 查看数组数据

>>> nonneg = np.dtype([("a", np.uint8), ("b", np.uint8)])
>>> y = x.view(dtype=nonneg, type=np.recarray)
>>> x["a"]
array([-1], dtype=int8)
>>> y.a
array([255], dtype=uint8)

在结构化数组上创建视图以便在计算中使用

>>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
>>> xv = x.view(dtype=np.int8).reshape(-1,2)
>>> xv
array([[1, 2],
       [3, 4]], dtype=int8)
>>> xv.mean(0)
array([2.,  3.])

更改视图会更改底层数组

>>> xv[0,1] = 20
>>> x
array([(1, 20), (3,  4)], dtype=[('a', 'i1'), ('b', 'i1')])

使用视图将数组转换为 recarray

>>> z = x.view(np.recarray)
>>> z.a
array([1, 3], dtype=int8)

视图共享数据

>>> x[0] = (9, 10)
>>> z[0]
np.record((9, 10), dtype=[('a', 'i1'), ('b', 'i1')])

通常应避免对由切片、转置、Fortran 顺序等定义的数组使用更改 dtype 大小（每个条目的字节数）的视图。

>>> x = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int16)
>>> y = x[:, ::2]
>>> y
array([[1, 3],
       [4, 6]], dtype=int16)
>>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
Traceback (most recent call last):
    ...
ValueError: To change to a dtype of a different size, the last axis must be contiguous
>>> z = y.copy()
>>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
array([[(1, 3)],
       [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])

然而，对于最后一个轴是连续的数组，即使其余轴不是 C 连续的，更改 dtype 的视图也完全可以接受。

>>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
>>> x.transpose(1, 0, 2).view(np.int16)
array([[[ 256,  770],
        [3340, 3854]],

       [[1284, 1798],
        [4368, 4882]],

       [[2312, 2826],
        [5396, 5910]]], dtype=int16)