<no title> — darts 文档

class darts.dataprocessing.dtw.cost_matrix.CostMatrix[源代码]¶

基类：ABC

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

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

方法

to_dense()

rtype: 密集的 n x m numpy 数组，其中空单元格设置为 np.inf

填充

abstract fill(value)[源代码]¶

m: int¶

n: int¶

abstract to_dense()[源代码]¶

返回类型: Dense n x m numpy array, where empty cells are set to np.inf

class darts.dataprocessing.dtw.cost_matrix.DenseCostMatrix(n, m)[源代码]¶

基类：ndarray, CostMatrix

属性

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

方法

`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 标量并返回它。
`itemset`(*args)	将标量插入数组（如果可能，标量将被转换为数组的dtype）
`max`([axis, out, keepdims, initial, where])	返回沿给定轴的最大值。
`mean`([axis, dtype, out, keepdims, where])	返回沿给定轴的数组元素的平均值。
`min`([axis, out, keepdims, initial, where])	沿指定轴返回最小值。
`newbyteorder`([new_order])	返回以不同字节顺序查看的相同数据的数组。
`nonzero`()	返回非零元素的索引。
`partition`(kth[, axis, kind, order])	重新排列数组中的元素，使得第 k 个位置的元素处于它在排序数组中应有的位置。
`prod`([axis, dtype, out, keepdims, initial, ...])	返回给定轴上数组元素的乘积
`ptp`([axis, out, keepdims])	沿给定轴的峰峰值（最大值 - 最小值）。
`put`(indices, values[, mode])	对于索引中的所有 n，设置 `a.flat[n] = values[n]`。
`ravel`([order])	返回一个扁平化的数组。
`repeat`(repeats[, axis])	重复数组中的元素。
`reshape`(shape[, order])	返回一个包含相同数据但形状不同的新数组。
`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`()	rtype 密集的 n x m numpy 数组，其中空单元格设置为 np.inf
`tobytes`([order])	构建包含数组中原始数据字节的 Python 字节。
`tofile`(fid[, sep, format])	将数组写入文件为文本或二进制（默认）。
`tolist`()	将数组作为 `a.ndim` 层深的嵌套 Python 标量列表返回。
`tostring`([order])	tobytes 的兼容别名，具有完全相同的行为。
`trace`([offset, axis1, axis2, dtype, out])	返回数组对角线上的元素之和。
`transpose`(*axes)	返回数组的转置视图。
`var`([axis, dtype, out, ddof, keepdims, where])	返回沿给定轴的数组元素的方差。
`view`([dtype][, type])	具有相同数据的新数组视图。

点

T¶

转置数组的视图。

与 self.transpose() 相同。

实际案例

>>> 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 以获取完整文档。

1.8.0 新版功能.

参见

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

返回

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

返回类型

ndarray

提示

在 1.17.0 版更改: 简单数据类型和结构化数据类型之间的转换仅在“不安全”转换时才可能。允许多个字段的转换，但不允许多个字段的反向转换。

在 1.9.0 版更改: 在’安全’转换模式下，从数值类型转换为字符串类型时，要求字符串数据类型的长度足够长，以存储转换后的最大整数/浮点值。

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

实际案例

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

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

base¶

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

实际案例

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

>>> 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, optional) – 如果 True ，就地交换字节，默认是 False 。
返回: out – 字节交换后的数组。如果 inplace 为 True，这是对自身的视图。
返回类型: ndarray

实际案例

>>> 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.newbyteorder().byteswap() 生成一个具有相同值的数组: 但在内存中以不同的表示形式

>>> A = np.array([1, 2, 3])
>>> 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.newbyteorder().byteswap(inplace=True)
array([1, 2, 3])
>>> 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'}, optional) – 控制副本的内存布局。’C’ 表示 C 顺序，’F’ 表示 F 顺序，’A’ 表示如果 a 是 Fortran 连续的则为 ‘F’，否则为 ‘C’。’K’ 表示尽可能匹配 a 的布局。（注意，此函数与 numpy.copy() 非常相似，但它们的 order= 参数的默认值不同，并且此函数始终通过子类。）

参见

numpy.copy: 具有相同功能但默认行为不同

numpy.copyto

提示

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

实际案例

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

ctypes¶

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

此属性创建一个对象，使得在使用 ctypes 模块调用共享库时更容易使用数组。返回的对象具有数据、形状和步幅属性（参见下面的注释），这些属性本身返回可以作为共享库参数使用的 ctypes 对象。

参数: None –
返回: c – 具有属性数据、形状、步幅等。
返回类型: Python object

参见

numpy.ctypeslib

提示

以下是此对象的公共属性，这些属性在《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 数组，其中基类型是与此平台上的 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 数组，其中基类型与 shape 属性的基类型相同。这个 ctypes 数组包含了底层数组的步幅信息。这个步幅信息对于显示获取数组中下一个元素必须跳过的字节数非常重要。

类型: (c_intp*self.ndim)

_ctypes.data_as(obj)

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

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

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

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

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

实际案例

>>> 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 缓冲区对象。

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 object

参见

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 or Path) – 指定转储文件的名称。 .. versionchanged:: 1.17.0 pathlib.Path 对象现在也被接受。

dumps()¶

返回数组的 pickle 字符串。pickle.loads 会将字符串转换回数组。

参数: None –

fill(value)¶

用标量值填充数组。

参数: value (scalar) – a 的所有元素都将被赋予这个值。

实际案例

>>> 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语言风格的连续段中。

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

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)¶: 对齐且可写。

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风格和Fortran风格同时连续的。对于一维数组这一点很清楚，但对于更高维的数组也可以是正确的。

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

flat¶

数组的 1-D 迭代器。

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

参见

flatten: 返回数组的一个副本，将其折叠为一维。

flatiter

实际案例

>>> 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'}, optional) – ‘C’ 表示按行优先（C 风格）顺序展平。’F’ 表示按列优先（Fortran 风格）顺序展平。’A’ 表示如果 a 在内存中是 Fortran 连续的，则按列优先顺序展平，否则按行优先顺序展平。’K’ 表示按 a 在内存中出现的顺序展平。默认是 ‘C’。
返回: y – 输入数组的副本，展平为一维。
返回类型: ndarray

参见

ravel: 返回一个扁平化的数组。
flat: 数组的1维平面迭代器。

实际案例

>>> 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 or dtype) – 视图的数据类型。视图的 dtype 大小不能大于数组本身的大小。
offset (int) – 在开始元素视图之前要跳过的字节数。

实际案例

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

数组的虚部。

实际案例

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

item(*args)¶

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

参数

*args (Arguments (variable number and type)) –

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

返回

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

返回类型

Standard Python scalar object

提示

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

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

实际案例

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

itemset(*args)¶

将标量插入数组（如果可能，标量将被转换为数组的dtype）

必须至少有1个参数，并将最后一个参数定义为 item 。然后， a.itemset(*args) 等同于但比 a[args] = item 更快。item 应为标量值，且 args 必须选择数组 a 中的单个项。

参数: *args (Arguments) – 如果一个参数：一个标量，仅在 a 的大小为 1 时使用。如果两个参数：最后一个参数是要设置的值，并且必须是一个标量，第一个参数指定单个数组元素的位置。它要么是一个整数，要么是一个元组。

提示

与索引语法相比，itemset 在将标量放置到 ndarray 的特定位置时提供了一些速度提升，如果你必须这样做的话。然而，通常不鼓励这样做：在其他问题中，它使代码的外观变得复杂。此外，在使用 itemset`（和 `item）在循环内部时，请确保将方法分配给局部变量，以避免在每次循环迭代时进行属性查找。

实际案例

>>> np.random.seed(123)
>>> x = np.random.randint(9, size=(3, 3))
>>> x
array([[2, 2, 6],
       [1, 3, 6],
       [1, 0, 1]])
>>> x.itemset(4, 0)
>>> x.itemset((2, 2), 9)
>>> x
array([[2, 2, 6],
       [1, 0, 6],
       [1, 0, 9]])

itemsize¶

一个数组元素的字节长度。

实际案例

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

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: 在案例视图中，对象自身消耗的内存，不包括父对象。这确实包括非元素属性消耗的内存。

实际案例

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

ndim¶

数组的维度数量。

实际案例

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

newbyteorder(new_order='S', /)¶

返回以不同字节顺序查看的相同数据的数组。

相当于:

arr.view(arr.dtype.newbytorder(new_order))

数组数据类型的所有字段和子数组中也进行了更改。

参数: new_order (string, optional) – 要强制的字节顺序；从下面的字节顺序规范中选择一个值。new_order 代码可以是以下任意一种：* ‘S’ - 将 dtype 从当前字节顺序交换为相反的字节顺序 * {‘<’, ‘little’} - 小端序 * {‘>’, ‘big’} - 大端序 * {‘=’, ‘native’} - 本地顺序，等同于 sys.byteorder * {‘|’, ‘I’} - 忽略（字节顺序不变）默认值 (‘S’) 会导致交换当前的字节顺序。
返回: new_arr – 具有反映给定字节顺序更改的 dtype 的新数组对象。
返回类型: array

nonzero()¶

返回非零元素的索引。

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

参见

numpy.nonzero: 等效函数

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

重新排列数组中的元素，使得第 k 个位置的元素处于其在排序数组中应有的位置。所有小于第 k 个元素的元素都被移动到该元素之前，所有等于或大于的元素都被移动到该元素之后。两个分区中元素的顺序是未定义的。

1.8.0 新版功能.

参数

kth (int or sequence of ints) – 按其划分的元素索引。第k个元素的值将处于其最终排序位置，所有较小的元素将移到它之前，所有相等或更大的元素将移到它之后。分区中所有元素的顺序是未定义的。如果提供了一个kth序列，它将一次性将由kth索引的所有元素分区到其排序位置。.. deprecated:: 1.22.0 传递布尔值作为索引已被弃用。
axis (int, optional) – 要排序的轴。默认值为 -1，这意味着沿着最后一个轴排序。
kind ({'introselect'}, optional) – 选择算法。默认是 ‘introselect’。
order (str or list of str, optional) – 当 a 是一个定义了字段的数组时，此参数指定首先比较哪些字段，其次比较哪些字段等。单个字段可以指定为字符串，并且不需要指定所有字段，但未指定的字段仍将使用，按照它们在 dtype 中出现的顺序来打破平局。

参见

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

提示

参见 np.partition 了解不同算法的说明。

实际案例

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

>>> 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(axis=None, out=None, keepdims=False)¶

沿给定轴的峰峰值（最大值 - 最小值）。

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

参见

numpy.ptp: 等效函数

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

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

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

参见

numpy.put: 等效函数

ravel([order])¶

返回一个扁平化的数组。

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

参见

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

real¶

数组的实部。

实际案例

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

返回一个包含相同数据但形状不同的新数组。

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

参见

numpy.reshape: 等效函数

提示

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

resize(new_shape, refcheck=True)¶

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

参数

new_shape (tuple of ints, or n ints) – 调整大小后的数组形状。
refcheck (bool, optional) – 如果为 False，则不会检查引用计数。默认值为 True。

返回类型

None

引发

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

参见

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

提示

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

只有连续数组（内存中连续的数据元素）才能被调整大小。

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

实际案例

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

>>> 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 放入由 dtype 定义的 a 的字段中，并从字段的 offset 字节开始。

参数

val (object) – 要放置在字段中的值。
dtype (dtype object) – 要放置 val 的字段的数据类型。
offset (int, optional) – 在字段中放置 val 的字节数。

返回类型

None

参见

getfield

实际案例

>>> 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 使用的内存区域（见下文注释）。ALIGNED 标志只有在数据实际上根据类型对齐时才能设置为 True。WRITEBACKIFCOPY 和 flag 永远不能设置为 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 时，基数组将被更新为此数组的内容。

所有标志都可以通过单个（大写）字母以及全名来访问。

实际案例

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

实际案例

>>> 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: 等效的获取函数。
numpy.reshape: 功能类似于设置 shape。
ndarray.reshape: 类似于设置 shape 的方法。

size¶

数组中的元素数量。

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

提示

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

实际案例

>>> 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, optional) – 要排序的轴。默认值为 -1，这意味着沿着最后一个轴排序。
kind ({'quicksort', 'mergesort', 'heapsort', 'stable'}, optional) – 排序算法。默认是 ‘quicksort’。注意，’stable’ 和 ‘mergesort’ 在底层使用 timsort，并且实际的实现会根据数据类型而变化。’mergesort’ 选项保留用于向后兼容。 .. versionchanged:: 1.15.0 添加了 ‘stable’ 选项。
order (str or list of str, optional) – 当 a 是一个定义了字段的数组时，此参数指定首先比较哪些字段，其次比较哪些字段等。单个字段可以指定为字符串，并且不需要指定所有字段，但未指定的字段仍将使用，按照它们在 dtype 中出现的顺序来打破平局。

参见

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

提示

关于不同的排序算法，请参见 numpy.sort。

实际案例

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

在NumPy参考指南的“ndarray.rst”文件中可以找到关于步幅的更详细解释。

警告

不建议设置 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

实际案例

>>> 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()[源代码]¶

返回类型: Dense n x m numpy array, where empty cells are set to np.inf

tobytes(order='C')¶

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

构建显示数据内存原始内容副本的 Python 字节。字节对象默认按 C 顺序生成。此行为由 order 参数控制。

1.9.0 新版功能.

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

参见

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

实际案例

>>> 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) – 一个打开的文件对象，或包含文件名的字符串。 .. versionchanged:: 1.17.0 pathlib.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, or list of object, or list of list of object, or …

提示

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

实际案例

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

>>> a = np.uint32([1, 2])
>>> a_list = list(a)
>>> a_list
[1, 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')¶

tobytes 的兼容别名，具有完全相同的行为。

尽管它的名字如此，它返回的是 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) –

无参数或无参数：反转轴的顺序。
ints 的元组：元组中第 j 位的 i 表示数组的第 i 轴变为转置数组的第 j 轴。
n 个整数：与包含相同整数的 n-元组相同（此形式旨在作为元组形式的“便利”替代方案）。

返回

p – 数组的视图，其轴已适当置换。

返回类型

ndarray

参见

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

实际案例

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

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

备注

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

参数

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连续的。

实际案例

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

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

>>> y = x.view(dtype=np.int16, type=np.matrix)
>>> y
matrix([[513]], dtype=int16)
>>> print(type(y))
<class 'numpy.matrix'>

创建一个结构化数组的视图，以便在计算中使用

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

使用视图将数组转换为记录数组：

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

视图共享数据：

>>> x[0] = (9, 10)
>>> z[0]
(9, 10)

应尽量避免在由切片、转置、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)