NumPy-1-26-中文文档-六-

NumPy 1.26 中文文档（六）

原文：numpy.org/doc/

numpy.ma 模块的常量

原文：numpy.org/doc/1.26/reference/maskedarray.baseclass.html

除了MaskedArray类之外，numpy.ma模块还定义了几个常量。

numpy.ma.masked

masked常量是MaskedArray的一个特例，具有浮点数据类型和空形状。它用于测试掩码数组的特定条目是否被掩码，或者掩盖掩码数组的一个或多个条目：

>>> x = ma.array([1, 2, 3], mask=[0, 1, 0])
>>> x[1] is ma.masked
True
>>> x[-1] = ma.masked
>>> x
masked_array(data=[1, --, --],
 mask=[False,  True,  True],
 fill_value=999999) 

numpy.ma.nomask

表示掩码数组没有无效条目的值。nomask在不需要掩码时用于加速计算。在内部表示为np.False_。

numpy.ma.masked_print_option

打印掩码数组时用作缺失数据的字符串。默认情况下，此字符串为'--'��

使用set_display()来更改默认字符串。示例用法：numpy.ma.masked_print_option.set_display('X')用'X'替换缺失数据。

MaskedArray类

class numpy.ma.MaskedArray

一个ndarray的子类，设计用于处理带有缺失数据的数值数组。

一个MaskedArray的实例可以被看作是几个元素的组合：

• data，作为任何形状或数据类型的常规numpy.ndarray（数据）。

• 一个与数据形状相同的布尔mask，其中True值表示数据的相应元素无效。特殊值nomask也适用于没有命名字段的数组，并指示没有数据无效。

• 一个fill_value，一个值，可以用来替换无效条目，以返回一个标准的numpy.ndarray。

掩码数组的属性和特性

参见

数组属性

ma.MaskedArray.data

返回底层数据，作为掩码数组的视图。

如果底层数据是numpy.ndarray的子类，则返回为此。

>>> x = np.ma.array(np.matrix([[1, 2], [3, 4]]), mask=[[0, 1], [1, 0]])
>>> x.data
matrix([[1, 2],
 [3, 4]]) 

数据的类型可以通过baseclass属性访问。

ma.MaskedArray.mask

当前掩码。

ma.MaskedArray.recordmask

获取或设置数组的掩码，如果没有命名字段。对于结构化数组，返回一个布尔值的 ndarray，其中条目如果所有字段都被掩码，则为True，否则为False：

>>> x = np.ma.array([(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)],
...         mask=[(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)],
...        dtype=[('a', int), ('b', int)])
>>> x.recordmask
array([False, False,  True, False, False]) 

ma.MaskedArray.fill_value

掩码数组的填充值是一个标量。在设置时，如果为 None，则会根据数据类型设置为默认值。

示例

>>> for dt in [np.int32, np.int64, np.float64, np.complex128]:
...     np.ma.array([0, 1], dtype=dt).get_fill_value()
...
999999
999999
1e+20
(1e+20+0j) 

>>> x = np.ma.array([0, 1.], fill_value=-np.inf)
>>> x.fill_value
-inf
>>> x.fill_value = np.pi
>>> x.fill_value
3.1415926535897931 # may vary 

重置为默认值：

>>> x.fill_value = None
>>> x.fill_value
1e+20 

ma.MaskedArray.baseclass

底层数据的类（只读）。

ma.MaskedArray.sharedmask

掩码的共享状态（只读）。

ma.MaskedArray.hardmask

指定是否可以通过赋值取消掩码。

默认情况下，为掩码数组条目分配确定值将取消掩码。当hardmask为True时，掩码不会通过赋值而改变。

另请参阅

ma.MaskedArray.harden_mask

ma.MaskedArray.soften_mask

示例

>>> x = np.arange(10)
>>> m = np.ma.masked_array(x, x>5)
>>> assert not m.hardmask 

由于m具有软掩码，分配元素值会取消该元素的掩码：

>>> m[8] = 42
>>> m
masked_array(data=[0, 1, 2, 3, 4, 5, --, --, 42, --],
 mask=[False, False, False, False, False, False,
 True, True, False, True],
 fill_value=999999) 

硬化后，掩码不会受到赋值的影响：

>>> hardened = np.ma.harden_mask(m)
>>> assert m.hardmask and hardened is m
>>> m[:] = 23
>>> m
masked_array(data=[23, 23, 23, 23, 23, 23, --, --, 23, --],
 mask=[False, False, False, False, False, False,
 True, True, False, True],
 fill_value=999999) 

由于MaskedArray是ndarray的子类，因此掩码数组也继承了ndarray实例的所有属性和特性。

MaskedArray.base	如果内存来自其他对象，则为基本对象。
MaskedArray.ctypes	用于简化数组与 ctypes 模块交互的对象。
MaskedArray.dtype	数组元素的数据类型。
MaskedArray.flags	有关数组内存布局的信息。
MaskedArray.itemsize	一个数组元素的长度（以字节为单位）。
MaskedArray.nbytes	数组元素消耗的总字节数。
MaskedArray.ndim	数组维度的数量。
MaskedArray.shape	数组维度的元组。
MaskedArray.size	数组中的元素数量。
MaskedArray.strides	遍历数组时在每个维度中前进的字节数的元组。
MaskedArray.imag	掩码数组的虚部。
MaskedArray.real	掩码数组的实部。
MaskedArray.flat	返回一个扁平迭代器，或将自身的扁平版本设置为值。

| MaskedArray.__array_priority__ | | ## 掩码数组的属性和属性

另请参阅

数组属性

ma.MaskedArray.data

返回作为掩码数组视图的基础数据。

如果基础数据是 numpy.ndarray 的子类，则将其作为这样返回。

>>> x = np.ma.array(np.matrix([[1, 2], [3, 4]]), mask=[[0, 1], [1, 0]])
>>> x.data
matrix([[1, 2],
 [3, 4]]) 

通过 baseclass 属性可以访问数据的类型。

ma.MaskedArray.mask

当前掩码。

ma.MaskedArray.recordmask

获取或设置数组的掩码，如果没有命名字段。对于结构化数组，返回一个布尔值的 ndarray，其中条目为 True 表示所有字段都被掩码���否则为 False：

>>> x = np.ma.array([(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)],
...         mask=[(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)],
...        dtype=[('a', int), ('b', int)])
>>> x.recordmask
array([False, False,  True, False, False]) 

ma.MaskedArray.fill_value

掩码数组的填充值是一个标量。在设置时，如果为 None，则会根据数据类型设置为默认值。

示例

>>> for dt in [np.int32, np.int64, np.float64, np.complex128]:
...     np.ma.array([0, 1], dtype=dt).get_fill_value()
...
999999
999999
1e+20
(1e+20+0j) 

>>> x = np.ma.array([0, 1.], fill_value=-np.inf)
>>> x.fill_value
-inf
>>> x.fill_value = np.pi
>>> x.fill_value
3.1415926535897931 # may vary 

重置为默认值：

>>> x.fill_value = None
>>> x.fill_value
1e+20 

ma.MaskedArray.baseclass

基础数据的类（只读）。

ma.MaskedArray.sharedmask

共享掩码的状态（只读）。

ma.MaskedArray.hardmask

指定是否可以通过赋值取消掩码。

默认情况下，为掩码数组条目分配确定值将取消掩码。当 hardmask 为 True 时，掩码不会通过赋值而改变。

另请参阅

ma.MaskedArray.harden_mask

ma.MaskedArray.soften_mask

示例

>>> x = np.arange(10)
>>> m = np.ma.masked_array(x, x>5)
>>> assert not m.hardmask 

由于 m 具有软掩码，分配元素值会取消该元素的掩码：

>>> m[8] = 42
>>> m
masked_array(data=[0, 1, 2, 3, 4, 5, --, --, 42, --],
 mask=[False, False, False, False, False, False,
 True, True, False, True],
 fill_value=999999) 

硬化后，掩码不受赋值影响：

>>> hardened = np.ma.harden_mask(m)
>>> assert m.hardmask and hardened is m
>>> m[:] = 23
>>> m
masked_array(data=[23, 23, 23, 23, 23, 23, --, --, 23, --],
 mask=[False, False, False, False, False, False,
 True, True, False, True],
 fill_value=999999) 

由于 MaskedArray 是 ndarray 的子类，掩码数组也继承了 ndarray 实例的所有属性和属性。

MaskedArray.base	如果内存来自其他对象，则返回基础对象。
MaskedArray.ctypes	一个简化数组与 ctypes 模块交互的对象。
MaskedArray.dtype	数组元素的数据类型。
MaskedArray.flags	关于数组内存布局的信息。
MaskedArray.itemsize	一个数组元素的字节长度。
MaskedArray.nbytes	数组元素消耗的总字节数。
MaskedArray.ndim	数组的维度数。
MaskedArray.shape	数组维度的元组。
MaskedArray.size	数组中的元素数。
MaskedArray.strides	遍历数组时在每个维度上移动的字节数元组。
MaskedArray.imag	掩码数组的虚部。
MaskedArray.real	掩码数组的实部。
MaskedArray.flat	返回一个扁平迭代器，或将自身的扁平版本设置为值。
MaskedArray.__array_priority__

MaskedArray 方法

另请参阅

数组方法

转换

MaskedArray.__float__()	转换为浮点数。
MaskedArray.__int__()	转换为整数。
MaskedArray.view([dtype, type, fill_value])	返回 MaskedArray 数据的视图。
MaskedArray.astype(dtype[, order, casting, ...])	数组的副本，转换为指定类型。
MaskedArray.byteswap([inplace])	交换数组元素的字节顺序
MaskedArray.compressed()	将所有非掩码数据作为一维数组返回。
MaskedArray.filled([fill_value])	返回一个副本，其中掩码值被给定值填充。
MaskedArray.tofile(fid[, sep, format])	以二进制格式将掩码数组保存到文件中。
MaskedArray.toflex()	将掩码数组转换为灵活类型数组。
MaskedArray.tolist([fill_value])	将掩码数组的数据部分作为分层 Python 列表返回。
MaskedArray.torecords()	将掩码数组转换为灵活类型数组。
MaskedArray.tostring([fill_value, order])	tobytes的兼容别名，具有完全相同的行为。
MaskedArray.tobytes([fill_value, order])	将数组数据作为包含数组中原始字节的字符串返回。

形状操作

对于 reshape、resize 和 transpose，单个元组参数可以替换为n个整数，这将被解释为 n 元组。

MaskedArray.flatten([order])	返回将数组折叠为一维的副本。
MaskedArray.ravel([order])	返回自身的一维版本，作为视图。
MaskedArray.reshape(*s, **kwargs)	为数组赋予新形状，而不更改其数据。
MaskedArray.resize(newshape[, refcheck, order])
MaskedArray.squeeze([axis])	从a中删除长度为一的轴。
MaskedArray.swapaxes(axis1, axis2)	返回axis1和axis2互换的数组视图。
MaskedArray.transpose(*axes)	返回轴转置的数组视图。
MaskedArray.T	转置数组的视图。

项目选择和操作

对于带有axis关键字的数组方法，默认为 None。如果 axis 为 None，则将数组视为 1-D 数组。axis的任何其他值表示应该进行操作的维度。

MaskedArray.argmax([axis, fill_value, out, ...])	返回沿给定轴的最大值的索引数组。
MaskedArray.argmin([axis, fill_value, out, ...])	返回沿给定轴的最小值的索引数组。
MaskedArray.argsort([axis, kind, order, ...])	返回沿指定轴对数组进行排序的索引的 ndarray。
MaskedArray.choose(choices[, out, mode])	使用索引数组从一组选择中构建新数组。
MaskedArray.compress(condition[, axis, out])	当条件为True时返回a。
MaskedArray.diagonal([offset, axis1, axis2])	返回指定的对角线。
MaskedArray.fill(value)	用标量值填充数组。
MaskedArray.item(*args)	将数组的一个元素复制到标准的 Python 标量并返回。
MaskedArray.nonzero()	返回未屏蔽且非零元素的索引。
MaskedArray.put(indices, values[, mode])	将存储索引位置设置为相应的值。
MaskedArray.repeat(repeats[, axis])	重复数组的元素。
MaskedArray.searchsorted(v[, side, sorter])	找到应将 v 的元素插入 a 中以保持顺序的索引。
MaskedArray.sort([axis, kind, order, ...])	对数组进行排序，就地排序。
MaskedArray.take(indices[, axis, out, mode])

Pickling and copy

MaskedArray.copy([order])	返回数组的副本。
MaskedArray.dump(file)	将数组的 pickle 格式数据存储到指定文件中。
MaskedArray.dumps()	返回数组的 pickle 格式字符串。

计算

MaskedArray.all([axis, out, keepdims])	如果所有元素都为 True，则返回 True。
MaskedArray.anom([axis, dtype])	计算沿指定轴的异常值（与算术平均值的偏差）。
MaskedArray.any([axis, out, keepdims])	如果数组 a 中的任何元素为 True，则返回 True。
MaskedArray.clip([min, max, out])	返回数值限制在[min, max]范围内的数组。
MaskedArray.conj()	对所有元素进行复共轭。
MaskedArray.conjugate()	返回复共轭，逐元素操作。
MaskedArray.cumprod([axis, dtype, out])	沿指定轴返回数组元素的累积积。
MaskedArray.cumsum([axis, dtype, out])	沿指定轴返回数组元素的累积和。
MaskedArray.max([axis, out, fill_value, ...])	返回沿给定轴的最大值。
MaskedArray.mean([axis, dtype, out, keepdims])	返回沿指定轴的数组元素的平均值。
MaskedArray.min([axis, out, fill_value, ...])	返回沿给定轴的最小值。
MaskedArray.prod([axis, dtype, out, keepdims])	返回沿指定轴的数组元素的乘积。
MaskedArray.product([axis, dtype, out, keepdims])	返回沿指定轴的数组元素的乘积。
MaskedArray.ptp([axis, out, fill_value, ...])	返回沿给定维度的最大值和最小值之差（即峰值到峰值）。
MaskedArray.round([decimals, out])	返回每个元素四舍五入到指定的小数位数。
MaskedArray.std([axis, dtype, out, ddof, ...])	返回沿指定轴的数组元素的标准差。
MaskedArray.sum([axis, dtype, out, keepdims])	返回沿指定轴的数组元素的和。
MaskedArray.trace([offset, axis1, axis2, ...])	返回数组对角线上的和。
MaskedArray.var([axis, dtype, out, ddof, ...])	计算沿指定轴的方差。

算术和比较运算

比较运算符:

MaskedArray.__lt__(other)	返回 self<value。
MaskedArray.__le__(other)	返回 self<=value。
MaskedArray.__gt__(other)	返回 self>value。
MaskedArray.__ge__(other)	返回 self>=value。
MaskedArray.__eq__(other)	逐元素检查其他是否等于自身。
MaskedArray.__ne__(other)	逐元素检查其他是否不等于自身。

数组的真值（bool()）：

MaskedArray.__bool__(/)	如果自身为真则为 True，否则为 False

算术运算：

MaskedArray.__abs__(self)
MaskedArray.__add__(other)	将自身加到其他，并返回一个新的掩码数组。
MaskedArray.__radd__(other)	将其他加到自身，并返回一个新的掩码数组。
MaskedArray.__sub__(other)	从自身减去其他，并返回一个新的掩码数组。
MaskedArray.__rsub__(other)	从其他中减去自身，并返回一个新的掩码数组。
MaskedArray.__mul__(other)	将自身乘以其他，并返回一个新的掩码数组。
MaskedArray.__rmul__(other)	将其他乘以自身，并返回一个新的掩码数组。
MaskedArray.__div__(other)	将其他除以自身，并返回一个新的掩码数组。
MaskedArray.__truediv__(other)	将其他除以自身，并返回一个新的掩码数组。
MaskedArray.__rtruediv__(other)	将自身除以其他，并返回一个新的掩码数组。
MaskedArray.__floordiv__(other)	将其他除以自身，并返回一个新的掩码数组。
MaskedArray.__rfloordiv__(other)	将 other 除以 self，返回一个新的掩盖数组。
MaskedArray.__mod__(value, /)	返回 self 除以 value 的余数。
MaskedArray.__rmod__(value, /)	返回 value 除以 self 的余数。
MaskedArray.__divmod__(value, /)	返回 self 除以 value 的商和余数。
MaskedArray.__rdivmod__(value, /)	返回 value 除以 self 的商和余数。
MaskedArray.__pow__(other)	将 self 的 other 次方，同时掩盖潜在的 NaNs/Infs。
MaskedArray.__rpow__(other)	将 other 的 self 次方，同时掩盖潜在的 NaNs/Infs。
MaskedArray.__lshift__(value, /)	返回 self 向左移动 value 位的结果。
MaskedArray.__rlshift__(value, /)	返回 value 向左移动 self 位的结果。
MaskedArray.__rshift__(value, /)	返回 self 向右移动 value 位的结果。
MaskedArray.__rrshift__(value, /)	返回 value 向右移动 self 位的结果。
MaskedArray.__and__(value, /)	返回 self 和 value 的按位与运算结果。
MaskedArray.__rand__(value, /)	返回 value 和 self 的按位与运算结果。
MaskedArray.__or__(value, /)	返回 self 和 value 的按位或运算结果。
MaskedArray.__ror__(value, /)	返回 value 和 self 的按位或运算结果。
MaskedArray.__xor__(value, /)	返回 self 和 value 的按位异或运算结果。
MaskedArray.__rxor__(value, /)	返回 value^self��

算术，就地修改：

MaskedArray.__iadd__(other)	将其他数加到自身，就地修改。
MaskedArray.__isub__(other)	将其他数从自身减去，就地修改。
MaskedArray.__imul__(other)	将自身与其他数相乘，就地修改。
MaskedArray.__idiv__(other)	将自身与其他数相除，就地修改。
MaskedArray.__itruediv__(other)	将自身与其他数真除，就地修改。
MaskedArray.__ifloordiv__(other)	将自身与其他数整除，就地修改。
MaskedArray.__imod__(value, /)	返回 self%=value。
MaskedArray.__ipow__(other)	将自身的幂运算为其他数，就地修改。
MaskedArray.__ilshift__(value, /)	返回 self<<=value。
MaskedArray.__irshift__(value, /)	返回 self>>=value。
MaskedArray.__iand__(value, /)	返回 self&=value。
MaskedArray.__ior__(value, /)	返回 self|=value。
MaskedArray.__ixor__(value, /)	返回 self^=value。

表示形式

MaskedArray.__repr__()	字面字符串表示。
MaskedArray.__str__()	返回 str(self)。
MaskedArray.ids()	返回数据和掩码区域的地址。
MaskedArray.iscontiguous()	返回一个布尔值，指示数据是否是连续的。

特殊方法

对于标准库函数：

MaskedArray.__copy__()	如果在数组上调用 copy.copy，则使用此方法。
MaskedArray.__deepcopy__(memo, /)	如果在数组上调用 copy.deepcopy，则使用此方法。
MaskedArray.__getstate__()	返回掩码数组的内部状态，用于 pickle 目的。
MaskedArray.__reduce__()	返回用于 pickle MaskedArray 的 3 元组。
MaskedArray.__setstate__(state)	恢复掩码数组的内部状态，用于 pickle 目的。

基本定制：

MaskedArray.__new__(cls[, data, mask, ...])	从头开始创建一个新的掩码数组。
MaskedArray.__array__([dtype], /)	如果未提供 dtype，则返回对自身的新引用，如果 dtype 与数组的当前 dtype 不同，则返回提供的数据类型的新数组。
MaskedArray.__array_wrap__(obj[, context])	用于 ufuncs 的特殊钩子。

容器定制：（参见 索引）

MaskedArray.__len__(/)	返回 len(self)。
MaskedArray.__getitem__(indx)	x.getitem(y) <==> x[y]
MaskedArray.__setitem__(indx, value)	x.setitem(i, y) <==> x[i]=y
MaskedArray.__delitem__(key, /)	删除 self[key]。
MaskedArray.__contains__(key, /)	返回 self 中的 key。

特定方法

处理掩码

以下方法可用于访问有关掩码的信息或操作掩码。

MaskedArray.__setmask__(mask[, copy])	设置掩码。
MaskedArray.harden_mask()	强制掩码为硬掩码，防止通过赋值取消掩码。
MaskedArray.soften_mask()	强制掩码为软掩码（默认），允许通过赋值取消掩码。
MaskedArray.unshare_mask()	复制掩码并将sharedmask标志设置为False。
MaskedArray.shrink_mask()	在可能的情况下将掩码减少到 nomask。

处理fill_value

MaskedArray.get_fill_value()	掩码数组的填充值是一个标量。
MaskedArray.set_fill_value([value])

统计缺失元素

MaskedArray.count([axis, keepdims])	计算数组沿给定轴的非掩码元素数。

转换

MaskedArray.__float__()	转换为浮点数。
MaskedArray.__int__()	转换为整数。
MaskedArray.view([dtype, type, fill_value])	返回 MaskedArray 数据的视图。
MaskedArray.astype(dtype[, order, casting, ...])	数组的副本，转换为指定类型。
MaskedArray.byteswap([inplace])	交换数组元素的字节
MaskedArray.compressed()	将所有非掩盖数据作为 1-D 数组返回。
MaskedArray.filled([fill_value])	返回一个副本，其中掩盖的值被填充为给定值。
MaskedArray.tofile(fid[, sep, format])	以二进制格式将掩盖数组保存到文件中。
MaskedArray.toflex()	将掩盖数组转换为灵活类型数组。
MaskedArray.tolist([fill_value])	将掩盖数组的数据部分作为分层 Python 列表返回。
MaskedArray.torecords()	将掩盖数组转换为灵活类型数组。
MaskedArray.tostring([fill_value, order])	tobytes的兼容别名，具有完全相同的行为。
MaskedArray.tobytes([fill_value, order])	将数组数据作为包含数组中原始字节的字符串返回。

形状操作

对于 reshape、resize 和 transpose，单个元组参数可以用n个整数替换，这些整数将被解释为一个 n 元组。

MaskedArray.flatten([order])	返回将数组折叠为一维的副本。
MaskedArray.ravel([order])	返回一个作为视图的 self 的 1D 版本。
MaskedArray.reshape(*s, **kwargs)	给数组一个新的形状，但不改变其数据。
MaskedArray.resize(newshape[, refcheck, order])
MaskedArray.squeeze([axis])	从a中删除长度为一的轴。
MaskedArray.swapaxes(axis1, axis2)	返回数组的 axis1 和 axis2 互换的视图。
MaskedArray.transpose(*axes)	返回数组的轴转置视图。
MaskedArray.T	转置数组的视图。

项目选择和操作

对于带有 axis 关键字的数组方法，默认为 None。如果 axis 为 None，则将数组视为 1-D 数组。axis 的任何其他值表示应该进行操作的维度。

MaskedArray.argmax([axis, fill_value, out, ...])	返回沿给定轴的最大值的索引数组。
MaskedArray.argmin([axis, fill_value, out, ...])	返回沿给定轴的最小值的索引数组。
MaskedArray.argsort([axis, kind, order, ...])	返回沿指定轴对数组进行排序的索引数组。
MaskedArray.choose(choices[, out, mode])	使用索引数组从一组选择中构建新数组。
MaskedArray.compress(condition[, axis, out])	返回条件为 True 时的 a。
MaskedArray.diagonal([offset, axis1, axis2])	返回指定的对角线。
MaskedArray.fill(value)	用标量值填充数组。
MaskedArray.item(*args)	将数组的元素复制到标准的 Python 标量并返回。
MaskedArray.nonzero()	返回非零未屏蔽元素的索引。
MaskedArray.put(indices, values[, mode])	将存储索引位置设置为相应的值。
MaskedArray.repeat(repeats[, axis])	重复数组的元素。
MaskedArray.searchsorted(v[, side, sorter])	找到应将 v 的元素插入 a 中以保持顺序的索引。
MaskedArray.sort([axis, kind, order, ...])	对数组进行排序，就地操作。
MaskedArray.take(indices[, axis, out, mode])

Pickling and copy

MaskedArray.copy([order])	返回数组的副本。
MaskedArray.dump(file)	将数组的 pickle 转储到指定文件。
MaskedArray.dumps()	返回数组的 pickle 作为字符串。

计算

MaskedArray.all([axis, out, keepdims])	如果所有元素求值为 True，则返回 True。
MaskedArray.anom([axis, dtype])	计算沿给定轴的异常值（与算术平均值的偏差）。
MaskedArray.any([axis, out, keepdims])	如果a的任何元素求值为 True，则返回 True。
MaskedArray.clip([min, max, out])	返回其值限制在[min, max]的数组。
MaskedArray.conj()	对所有元素进行复共轭。
MaskedArray.conjugate()	返回逐元素的复共轭。
MaskedArray.cumprod([axis, dtype, out])	返回给定轴上数组元素的紪积。
MaskedArray.cumsum([axis, dtype, out])	返回给定轴上数组元素的累积和。
MaskedArray.max([axis, out, fill_value, ...])	返回沿指定轴的最大值。
MaskedArray.mean([axis, dtype, out, keepdims])	返回沿给定轴的数组元素的平均值。
MaskedArray.min([axis, out, fill_value, ...])	返回沿指定轴的最小值。
MaskedArray.prod([axis, dtype, out, keepdims])	返回沿给定轴的数组元素的乘积。
MaskedArray.product([axis, dtype, out, keepdims])	返回沿给定轴的数组元素的乘积。
MaskedArray.ptp([axis, out, fill_value, ...])	返回沿给定维度的（最大值 - 最小值）。
MaskedArray.round([decimals, out])	返回每个元素四舍五入到指定小数位数。
MaskedArray.std([axis, dtype, out, ddof, ...])	返回沿给定轴的数组元素的标准差。
MaskedArray.sum([axis, dtype, out, keepdims])	返回沿给定轴的数组元素的和。
MaskedArray.trace([offset, axis1, axis2, ...])	返回数组对角线上的和。
MaskedArray.var([axis, dtype, out, ddof, ...])	计算沿指定轴的方差。

算术和比较操作

比较运算符：

MaskedArray.__lt__(other)	返回 self<value。
MaskedArray.__le__(other)	返回 self<=value。
MaskedArray.__gt__(other)	返回 self>value。
MaskedArray.__ge__(other)	返回 self>=value。
MaskedArray.__eq__(other)	逐元素检查其他是否等于自身。
MaskedArray.__ne__(other)	逐元素检查其他是否不等于自身。

数组的真值（bool())：

MaskedArray.__bool__(/)	如果自身为真则为 True，否则为 False。

算术运算：

MaskedArray.__abs__(self)
MaskedArray.__add__(other)	将自身加上其他，并返回一个新的掩码数组。
MaskedArray.__radd__(other)	将其他加到自身上，并返回一个新的掩码数组。
MaskedArray.__sub__(other)	将其他从自身减去，并返回一个新的掩码数组。
MaskedArray.__rsub__(other)	将自身从其他减去，并返回一个新的掩码数组。
MaskedArray.__mul__(other)	将自身乘以其他，并返回一个新的掩码数组。
MaskedArray.__rmul__(other)	将其他乘以自身，并返回一个新的掩码数组。
MaskedArray.__div__(other)	将其他除以自身，并返回一个新的掩码数组。
MaskedArray.__truediv__(other)	将其他除以自身，并返回一个新的掩码数组。
MaskedArray.__rtruediv__(other)	将自身除以其他，并返回一个新的掩码数组。
MaskedArray.__floordiv__(other)	将其他除以自身，并返回一个新的掩码数组。
MaskedArray.__rfloordiv__(other)	将 self 除以 other，并返回一个新的掩码数组。
MaskedArray.__mod__(value, /)	返回 self%value。
MaskedArray.__rmod__(value, /)	返回 value%self。
MaskedArray.__divmod__(value, /)	返回 divmod(self, value)。
MaskedArray.__rdivmod__(value, /)	返回 divmod(value, self)。
MaskedArray.__pow__(other)	将 self 提升为 other 的幂，掩盖潜在的 NaNs/Infs。
MaskedArray.__rpow__(other)	将 other 提升为 self 的幂，掩盖潜在的 NaNs/Infs。
MaskedArray.__lshift__(value, /)	返回 self<<value。
MaskedArray.__rlshift__(value, /)	返回 value<<self。
MaskedArray.__rshift__(value, /)	返回 self>>value。
MaskedArray.__rrshift__(value, /)	返回 value>>self。
MaskedArray.__and__(value, /)	返回 self&value。
MaskedArray.__rand__(value, /)	返回 value&self。
MaskedArray.__or__(value, /)	返回 self
MaskedArray.__ror__(value, /)	返回 value
MaskedArray.__xor__(value, /)	返回 self^value。
MaskedArray.__rxor__(value, /)	返回 value^self。

算术，就地操作：

MaskedArray.__iadd__(other)	将 other 添加到 self 中。
MaskedArray.__isub__(other)	将 other 从 self 中减去。
MaskedArray.__imul__(other)	就地将 self 乘以 other。
MaskedArray.__idiv__(other)	就地将 self 除以 other。
MaskedArray.__itruediv__(other)	就地将 self 除以 other。
MaskedArray.__ifloordiv__(other)	就地将 self 地板除以 other。
MaskedArray.__imod__(value, /)	返回 self%=value。
MaskedArray.__ipow__(other)	就地将 self 的幂提升为 other。
MaskedArray.__ilshift__(value, /)	返回 self<<=value。
MaskedArray.__irshift__(value, /)	返回 self>>=value。
MaskedArray.__iand__(value, /)	返回 self&=value。
MaskedArray.__ior__(value, /)	返回 self
MaskedArray.__ixor__(value, /)	返回 self^=value。

比较运算符：

MaskedArray.__lt__(other)	返回 self<value。
MaskedArray.__le__(other)	返回 self<=value。
MaskedArray.__gt__(other)	返回 self>value。
MaskedArray.__ge__(other)	返回 self>=value。
MaskedArray.__eq__(other)	逐元素检查其他是否等于自身。
MaskedArray.__ne__(other)	逐元素检查其他是否不等于自身。

数组的真值（bool())：

MaskedArray.__bool__(/)	如果 self 为真则返回 True，否则返回 False。

算术运算：

MaskedArray.__abs__(self)
MaskedArray.__add__(other)	将自身加到其他，并返回一个新的掩码数组。
MaskedArray.__radd__(other)	将其他加到自身，并返回一个新的掩码数组。
MaskedArray.__sub__(other)	将其他从自身减去，并返回一个新的掩码数组。
MaskedArray.__rsub__(other)	将自身减去其他，并返回一个新的掩码数组。
MaskedArray.__mul__(other)	将自身乘以其他，并返回一个新的掩码数组。
MaskedArray.__rmul__(other)	将其他乘以自身，并返回一个新的掩码数组。
MaskedArray.__div__(other)	将其他除以自身，并返回一个新的掩码数组。
MaskedArray.__truediv__(other)	将其他除以自身，并返回一个新的掩码数组。
MaskedArray.__rtruediv__(other)	将自身除以其他，并返回一个新的掩码数组。
MaskedArray.__floordiv__(other)	将 other 除以 self，并返回一个新的掩码数组。
MaskedArray.__rfloordiv__(other)	将 self 除以 other，并返回一个新的掩码数组。
MaskedArray.__mod__(value, /)	返回 self%value。
MaskedArray.__rmod__(value, /)	返回 value%self。
MaskedArray.__divmod__(value, /)	返回 divmod(self, value)。
MaskedArray.__rdivmod__(value, /)	返回 divmod(value, self)。
MaskedArray.__pow__(other)	将 self 提升到 other 次方，掩盖潜在的 NaNs/Infs。
MaskedArray.__rpow__(other)	将 other 提升到 self 次方，掩盖潜在的 NaNs/Infs。
MaskedArray.__lshift__(value, /)	返回 self<<value。
MaskedArray.__rlshift__(value, /)	返回 value<<self。
MaskedArray.__rshift__(value, /)	返回 self>>value。
MaskedArray.__rrshift__(value, /)	返回 value>>self。
MaskedArray.__and__(value, /)	返回 self&value。
MaskedArray.__rand__(value, /)	返回 value&self。
MaskedArray.__or__(value, /)	返回 self|value。
MaskedArray.__ror__(value, /)	返回 value|self。
MaskedArray.__xor__(value, /)	返回 self^value。
MaskedArray.__rxor__(value, /)	返回 value^self。

算术，就地操作：

MaskedArray.__iadd__(other)	就地将 other 加到 self。
MaskedArray.__isub__(other)	就地从 self 减去 other。
MaskedArray.__imul__(other)	就地将 self 乘以 other。
MaskedArray.__idiv__(other)	就地除 self 与 other。
MaskedArray.__itruediv__(other)	就地真除 self 与 other。
MaskedArray.__ifloordiv__(other)	就地整除 self 与 other。
MaskedArray.__imod__(value, /)	返回 self%=value。
MaskedArray.__ipow__(other)	就地将 self 的幂运算为 other。
MaskedArray.__ilshift__(value, /)	返回 self<<=value。
MaskedArray.__irshift__(value, /)	返回 self>>=value。
MaskedArray.__iand__(value, /)	返回 self&=value。
MaskedArray.__ior__(value, /)	返回 self|=value。
MaskedArray.__ixor__(value, /)	返回 self^=value。

表示

MaskedArray.__repr__()	字符串表示。
MaskedArray.__str__()	返回 str(self)。
MaskedArray.ids()	返回数据和掩码区域的地址。
MaskedArray.iscontiguous()	返回一个布尔值，指示数据是否是连续的。

特殊方法

对于标准库函数：

MaskedArray.__copy__()	如果在数组上调用copy.copy，则使用。
MaskedArray.__deepcopy__(memo, /)	如果在数组上调用copy.deepcopy，则使用。
MaskedArray.__getstate__()	返回掩码数组的内部状态，用于 pickle 目的。
MaskedArray.__reduce__()	返回用于 pickle 掩码数组的 3 元组。
MaskedArray.__setstate__(state)	恢复掩码数组的内部状态，用于 pickle 目的。

基本定制：

MaskedArray.__new__(cls[, data, mask, ...])	从头开始创建一个新的掩码数组。
MaskedArray.__array__([dtype], /)	如果未给出 dtype，则返回对 self 的新引用，如果 dtype 与数组的当前 dtype 不同，则返回所提供数据类型的新数组。
MaskedArray.__array_wrap__(obj[, context])	用于 ufuncs 的特殊钩子。

容器定制：（参见 Indexing）

MaskedArray.__len__(/)	返回 len(self)。
MaskedArray.__getitem__(indx)	x.getitem(y) <==> x[y]
MaskedArray.__setitem__(indx, value)	x.setitem(i, y) <==> x[i]=y
MaskedArray.__delitem__(key, /)	删除 self[key]。
MaskedArray.__contains__(key, /)	返回 self 中的 key。

特定方法

处理掩码

可以使用以下方法访问有关掩码的信息或操作掩码。

MaskedArray.__setmask__(mask[, copy])	设置掩码。
MaskedArray.harden_mask()	强制将掩码硬化，防止通过赋值取消掩码。
MaskedArray.soften_mask()	强制将掩码软化（默认），允许通过赋值取消掩码。
MaskedArray.unshare_mask()	复制掩码并将sharedmask标志设置为False。
MaskedArray.shrink_mask()	在可能的情况下将掩码缩小为 nomask。

处理fill_value

MaskedArray.get_fill_value()	掩码数组��填充值是一个标量。
MaskedArray.set_fill_value([value])

计算缺失元素

MaskedArray.count([axis, keepdims])	计算沿着给定轴的数组中非掩码元素的数量。

处理掩码

可以使用以下方法访问有关掩码的信息或操作掩码。

MaskedArray.__setmask__(mask[, copy])	设置掩码。
MaskedArray.harden_mask()	强制将掩码硬化，防止通过赋值取消掩码。
MaskedArray.soften_mask()	强制将掩码软化（默认），允许通过赋值取消掩码。
MaskedArray.unshare_mask()	复制掩码并将sharedmask标志设置为False。
MaskedArray.shrink_mask()	在可能的情况下将掩码缩小到 nomask。

处理fill_value

MaskedArray.get_fill_value()	掩码数组的填充值是一个标量。
MaskedArray.set_fill_value([value])

计算缺失元素

MaskedArray.count([axis, keepdims])	计算沿给定轴的数组中非掩码元素的数量。

Masked array operations

原文：numpy.org/doc/1.26/reference/routines.ma.html

常量

ma.MaskType	bool_的别名

Creation

From existing data

ma.masked_array	MaskedArray的别名
ma.array(data[, dtype, copy, order, mask, ...])	一个可能包含屏蔽值的数组类。
ma.copy(self, *args, **params) a.copy(order=)	返回数组的副本。
ma.frombuffer(buffer[, dtype, count, ...])	将缓冲区解释为一维数组。
ma.fromfunction(function, shape, **dtype)	通过在每个坐标上执行函数来构造数组。
ma.MaskedArray.copy([order])	返回数组的副本。
ma.diagflat	diagflat

Ones and zeros

ma.empty(shape[, dtype, order, like])	返回给定形状和类型的新数组，但不初始化条目。
ma.empty_like(prototype[, dtype, order, ...])	返回与给定数组相同形状和类型的新数组。
ma.masked_all(shape[, dtype])	所有元素都被屏蔽的空掩码数组。
ma.masked_all_like(arr)	具有现有数组属性的空掩码数组。
ma.ones(shape[, dtype, order])	返回给定形状和类型的新数组，填充为 1。
ma.ones_like	返回与给定数组相同形状和类型的 1 数组。
ma.zeros(shape[, dtype, order, like])	返回给定形状和类型的新数组，填充为 0。
ma.zeros_like	返回与给定数组相同形状和类型的零数组。

---

Inspecting the array

ma.all(self[, axis, out, keepdims])	如果所有元素求值为 True，则返回 True。
ma.any(self[, axis, out, keepdims])	如果a的任何元素求值为 True，则返回 True。
ma.count(self[, axis, keepdims])	计算沿给定轴的数组的非掩码元素数。
ma.count_masked(arr[, axis])	计算沿给定轴的掩码元素数。
ma.getmask(a)	返回掩码数组的掩码，或 nomask。
ma.getmaskarray(arr)	返回掩码数组的掩码，或全为 False 的布尔数组。
ma.getdata(a[, subok])	将掩码数组的数据返回为一个 ndarray。
ma.nonzero(self)	返回未掩码且非零元素的索引。
ma.shape(obj)	返回数组的形状。
ma.size(obj[, axis])	返回沿指定轴的元素数。
ma.is_masked(x)	确定输入是否具有掩码值。
ma.is_mask(m)	如果 m 是有效的标准掩码，则返回 True。
ma.isMaskedArray(x)	测试输入是否是 MaskedArray 的实例。
ma.isMA(x)	测试输入是否是 MaskedArray 的实例。
ma.isarray(x)	测试输入是否是 MaskedArray 的实例。
ma.isin(element, test_elements[, ...])	计算element是否在test_elements中，仅广播element。
ma.in1d(ar1, ar2[, assume_unique, invert])	测试数组中的每个元素是否也存在于第二个数组中。
ma.unique(ar1[, return_index, return_inverse])	查找数组的唯一元素。
ma.MaskedArray.all([axis, out, keepdims])	如果所有元素求值为 True，则返回 True。
ma.MaskedArray.any([axis, out, keepdims])	如果a的任何元素求值为 True，则返回 True。
ma.MaskedArray.count([axis, keepdims])	计算数组沿着给定轴的非屏蔽元素数。
ma.MaskedArray.nonzero()	返回非零未屏蔽元素的索引。
ma.shape(obj)	返回数组的形状。
ma.size(obj[, axis])	返回沿着给定轴的元素数量。
ma.MaskedArray.data	返回作为屏蔽数组视图的基础数据。
ma.MaskedArray.mask	当前掩码。
ma.MaskedArray.recordmask	如果数组没有命名字段，则获取或设置数组的掩码。

---

操作 MaskedArray

改变形状

ma.ravel(self[, order])	返回 self 的一维版本，作为视图。
ma.reshape(a, new_shape[, order])	返回包含相同数据的具有新形状的数组。
ma.resize(x, new_shape)	返回具有指定大小和形状的新屏蔽数组。
ma.MaskedArray.flatten([order])	返回将数组展平为一维的副本。
ma.MaskedArray.ravel([order])	返回 self 的一维版本，作为视图。
ma.MaskedArray.reshape(*s, **kwargs)	给数组赋予新的形状，但不改变其数据。
ma.MaskedArray.resize(newshape[, refcheck, ...])

修改轴

ma.swapaxes(self, *args, ...)	返回一个将axis1和axis2互换的数组视图。
ma.transpose(a[, axes])	对数组的维度进行排列。
ma.MaskedArray.swapaxes(axis1, axis2)	返回axis1和axis2交换的数组视图。
ma.MaskedArray.transpose(*axes)	返回数组的轴转置视图。

改变维度数量

ma.atleast_1d	atleast_1d
ma.atleast_2d	atleast_2d
ma.atleast_3d	atleast_3d
ma.expand_dims(a, axis)	扩展数组的形状。
ma.squeeze	从a中删除长度为一的轴。
ma.MaskedArray.squeeze([axis])	从a中删除长度为一的轴。
ma.stack	stack
ma.column_stack	column_stack
ma.concatenate(arrays[, axis])	沿着给定轴连接一系列数组。
ma.dstack	dstack
ma.hstack	hstack
ma.hsplit	hsplit
ma.mr_	将切片对象转换为沿��一个轴的连接。
ma.row_stack	vstack
ma.vstack	vstack

数组拼接

ma.concatenate(arrays[, axis])	沿着给定轴连接一系列数组。
ma.stack	stack
ma.vstack	vstack
ma.hstack	hstack
ma.dstack	dstack
ma.column_stack	column_stack
ma.append(a, b[, axis])	将值附加到数组的末尾。

---

掩码操作

创建掩码

ma.make_mask(m[, copy, shrink, dtype])	从数组创建布尔掩码。
ma.make_mask_none(newshape[, dtype])	返回给定形状的布尔掩码，填充为 False。
ma.mask_or(m1, m2[, copy, shrink])	使用logical_or运算符组合两个掩码。
ma.make_mask_descr(ndtype)	从给定的 dtype 构造 dtype 描述列表。

访问掩码

ma.getmask(a)	返回掩码数组的掩码，或无掩码。
ma.getmaskarray(arr)	返回掩码数组的掩码，或填充为 False 的完整布尔数组。
ma.masked_array.mask	当前掩码。

查找掩码数据

ma.ndenumerate(a[, compressed])	多维索引迭代器。
ma.flatnotmasked_contiguous(a)	在掩码数组中查找连续的未掩码数据。
ma.flatnotmasked_edges(a)	查找第一个和最后一个未掩码值的索引。
ma.notmasked_contiguous(a[, axis])	在给定轴上查找掩码数组中连续的未掩码数据。
ma.notmasked_edges(a[, axis])	沿轴查找第一个和最后一个未掩码值���索引。
ma.clump_masked(a)	返回与 1-D 数组的掩码块对应的切片列表。
ma.clump_unmasked(a)	返回与 1-D 数组的未掩码块对应的切片列表。

修改掩码

ma.mask_cols(a[, axis])	掩盖包含掩码值的 2D 数组的列。
ma.mask_or(m1, m2[, copy, shrink])	使用logical_or运算符组合两个掩码。
ma.mask_rowcols(a[, axis])	屏蔽包含屏蔽值的 2D 数组的行和/或列。
ma.mask_rows(a[, axis])	屏蔽包含屏蔽值的 2D 数组的行。
ma.harden_mask(self)	强制将掩码硬化，防止通过赋值取消掩码。
ma.soften_mask(self)	强制将掩码软化（默认），允许通过赋值取消掩码。
ma.MaskedArray.harden_mask()	强制将掩码硬化，防止通过赋值取消掩码。
ma.MaskedArray.soften_mask()	强制将掩码软化（默认），允许通过赋值取消掩码。
ma.MaskedArray.shrink_mask()	在可能的情况下将掩码减少到 nomask。
ma.MaskedArray.unshare_mask()	复制掩码并将sharedmask标志设置为False。

---

转换操作

> 到一个屏蔽数组

ma.asarray(a[, dtype, order])	将输入转换为给定数据类型的屏蔽数组。
ma.asanyarray(a[, dtype])	将输入转换为屏蔽数组，保留子类。
ma.fix_invalid(a[, mask, copy, fill_value])	返回将无效数据屏蔽并替换为填充值的输入。
ma.masked_equal(x, value[, copy])	在等于给定值的地方屏蔽数组。
ma.masked_greater(x, value[, copy])	在大于给定值的地方屏蔽数组。
ma.masked_greater_equal(x, value[, copy])	在大于或等于给定值的地方屏蔽数组。
ma.masked_inside(x, v1, v2[, copy])	掩盖给定区间内的数组。
ma.masked_invalid(a[, copy])	掩盖数组中出现无效值（NaN 或 infs）的部分。
ma.masked_less(x, value[, copy])	掩盖数组中小于给定值的部分。
ma.masked_less_equal(x, value[, copy])	掩盖数组中小于或等于给定值的部分。
ma.masked_not_equal(x, value[, copy])	掩盖数组中不等于给定值的部分。
ma.masked_object(x, value[, copy, shrink])	掩盖数组x中数据与 value 完全相等的部分。
ma.masked_outside(x, v1, v2[, copy])	掩盖给定区间外的数组。
ma.masked_values(x, value[, rtol, atol, ...])	使用浮点数相等性进行掩盖。
ma.masked_where(condition, a[, copy])	满足条件时掩盖数组的部分。

> 转移到一个 ndarray

ma.compress_cols(a)	抑制包含掩码值的二维数组的整列。
ma.compress_rowcols(x[, axis])	抑制包含掩码值的二维数组的行和/或列。
ma.compress_rows(a)	抑制包含掩码值的二维数组的整行。
ma.compressed(x)	将所有非掩盖数据作为一维数组返回。
ma.filled(a[, fill_value])	将输入作为一个数组返回��其中掩盖数据被填充为一个填充值。
ma.MaskedArray.compressed()	将所有非掩盖数据作为一维数组返回。
ma.MaskedArray.filled([fill_value])	返回一个副本，其中掩盖值用给定值填充。

> 转移到另一个对象

ma.MaskedArray.tofile(fid[, sep, format])	将掩码数组以二进制格式保存到文件中。
ma.MaskedArray.tolist([fill_value])	将掩码数组的数据部分作为分层 Python 列表返回。
ma.MaskedArray.torecords()	将掩码数组转换为灵活类型数组。
ma.MaskedArray.tobytes([fill_value, order])	将数组数据作为包含数组中原始字节的字符串返回。

填充掩码数组

ma.common_fill_value(a, b)	返回两个掩码数组的公共填充值（如果有的话）。
ma.default_fill_value(obj)	返回参数对象的默认填充值。
ma.maximum_fill_value(obj)	返回对象的数据类型能表示的最小值。
ma.minimum_fill_value(obj)	返回对象的数据类型能表示的最大值。
ma.set_fill_value(a, fill_value)	设置 a 的填充值，如果 a 是一个掩码数组。
ma.MaskedArray.get_fill_value()	掩码数组的填充值是一个标量。
ma.MaskedArray.set_fill_value([value])
ma.MaskedArray.fill_value	掩码数组的填充值是一个标量。

---

掩码数组算术

算术

ma.anom(self[, axis, dtype])	计算沿给定轴的异常值（与算术平均值的偏差）。
ma.anomalies(self[, axis, dtype])	计算沿给定轴的异常值（与算术平均值的偏差）。
ma.average(a[, axis, weights, returned, ...])	返回沿给定轴的数组的加权平均值。
ma.conjugate(x, /[, out, where, casting, ...])	返回逐元素的复共轭。
ma.corrcoef(x[, y, rowvar, bias, ...])	返回皮尔逊积矩相关系数。
ma.cov(x[, y, rowvar, bias, allow_masked, ddof])	估计协方差矩阵。
ma.cumsum(self[, axis, dtype, out])	返回沿给定轴的数组元素的累积和。
ma.cumprod(self[, axis, dtype, out])	返回沿给定轴的数组元素的累积积。
ma.mean(self[, axis, dtype, out, keepdims])	返回沿给定轴的数组元素的平均值。
ma.median(a[, axis, out, overwrite_input, ...])	计算沿指定轴的中位数。
ma.power(a, b[, third])	返回第二个数组的幂次方作为第一个数组的元素。
ma.prod(self[, axis, dtype, out, keepdims])	返回沿给定轴的数组元素的乘积。
ma.std(self[, axis, dtype, out, ddof, keepdims])	返回沿给定轴的数组元素的标准差。
ma.sum(self[, axis, dtype, out, keepdims])	返回沿给定轴的数组元素的和。
ma.var(self[, axis, dtype, out, ddof, keepdims])	计算沿指定轴的方差。
ma.MaskedArray.anom([axis, dtype])	计算沿给定轴的异常值（与算术平均值的偏差）。
ma.MaskedArray.cumprod([axis, dtype, out])	返回沿给定轴的数组元素的累积积。
ma.MaskedArray.cumsum([axis, dtype, out])	返回沿给定轴的数组元素的累积和。
ma.MaskedArray.mean([axis, dtype, out, keepdims])	返回沿指定轴的数组元素的平均值。
ma.MaskedArray.prod([axis, dtype, out, keepdims])	返回沿给定轴的数组元素的乘积。
ma.MaskedArray.std([axis, dtype, out, ddof, ...])	返回沿指定轴的数组元素的标准差。
ma.MaskedArray.sum([axis, dtype, out, keepdims])	返回沿给定轴的数组元素的和。
ma.MaskedArray.var([axis, dtype, out, ddof, ...])	计算沿指定轴的方差。

最小值/最大值

ma.argmax(self[, axis, fill_value, out])	返回沿指定轴的最大值的索引数组。
ma.argmin(self[, axis, fill_value, out])	返回沿指定轴的最小值的索引数组。
ma.max(obj[, axis, out, fill_value, keepdims])	返回沿指定轴的最大值。
ma.min(obj[, axis, out, fill_value, keepdims])	返回沿指定轴的最小值。
ma.ptp(obj[, axis, out, fill_value, keepdims])	返回沿给定维度的（最大值 - 最小值）。
ma.diff(a, /[, n, axis, prepend, append])	计算沿给定轴的第 n 个离散差分。
ma.MaskedArray.argmax([axis, fill_value, ...])	返回沿指定轴的最大值的索引数组。
ma.MaskedArray.argmin([axis, fill_value, ...])	返回沿指定轴的最小值的索引数组。
ma.MaskedArray.max([axis, out, fill_value, ...])	返回沿指定轴的最大值。
ma.MaskedArray.min([axis, out, fill_value, ...])	返回沿指定轴的最小值。
ma.MaskedArray.ptp([axis, out, fill_value, ...])	返回给定维度上的（最大值 - 最小值）。

排序

ma.argsort(a[, axis, kind, order, endwith, ...])	返回沿指定轴排序数组的索引的数组。
ma.sort(a[, axis, kind, order, endwith, ...])	返回排序后的掩码数组的副本。
ma.MaskedArray.argsort([axis, kind, order, ...])	返回沿指定轴排序数组的索引的数组。
ma.MaskedArray.sort([axis, kind, order, ...])	对数组进行原地排序

代数

ma.diag(v[, k])	提取对角线或构造对角线数组。
ma.dot(a, b[, strict, out])	返回两个数组的点积。
ma.identity(n[, dtype])	返回单位矩阵。
ma.inner(a, b, /)	两个数组的内积。
ma.innerproduct(a, b, /)	两个数组的内积。
ma.outer(a, b)	计算两个向量的外积。
ma.outerproduct(a, b)	计算两个向量的外积。
ma.trace(self[, offset, axis1, axis2, ...])	返回数组对角线上的和。
ma.transpose(a[, axes])	排列数组的维度。
ma.MaskedArray.trace([offset, axis1, axis2, ...])	返回数组对角线上的和。
ma.MaskedArray.transpose(*axes)	返回沿轴转置的数组视图。

多项式拟合

ma.vander(x[, n])	生成范德蒙德矩阵。
ma.polyfit(x, y, deg[, rcond, full, w, cov])	最小二乘多项式拟合。

截取和四舍五入

ma.around	将数组四舍五入到给定的小数位数。
ma.clip	限制数组中的值。
ma.round(a[, decimals, out])	返回 a 的副本，四舍五入到'decimals'位。
ma.MaskedArray.clip([min, max, out])	返回其值限制为[min, max]的数组。
ma.MaskedArray.round([decimals, out])	返回每个元素四舍五入到给定的小数位��。

集合操作

ma.intersect1d(ar1, ar2[, assume_unique])	返回两个数组共同的唯一元素。
ma.setdiff1d(ar1, ar2[, assume_unique])	具有唯一元素的 1D 数组的集合差异。
ma.setxor1d(ar1, ar2[, assume_unique])	具有唯一元素的 1-D 数组的异或集。
ma.union1d(ar1, ar2)	两个数组的并集。

杂项

ma.allequal(a, b[, fill_value])	如果 a 和 b 的所有条目都相等，则返回 True，使用 fill_value 作为真值，其中一个或两个被屏蔽。
ma.allclose(a, b[, masked_equal, rtol, atol])	如果两个数组在容差范围内逐元素相等，则返回 True。
ma.apply_along_axis(func1d, axis, arr, ...)	在给定轴上沿着 1-D 切片应用函数。
ma.apply_over_axes(func, a, axes)	在多个轴上重复应用函数。
ma.arange([start,] stop[, step,][, dtype, like])	返回给定区间内均匀间隔的值。
ma.choose(indices, choices[, out, mode])	使用索引数组从选择列表构造新数组。
ma.ediff1d(arr[, to_end, to_begin])	计算数组中相邻元素之间的差异。
ma.indices(dimensions[, dtype, sparse])	返回表示网格索引的数组。
ma.where(condition[, x, y])	根据条件返回一个带有来自x或y的元素的掩码数组。

常量

ma.MaskType	bool_的别名

创建

从现有数据

ma.masked_array	MaskedArray的别名
ma.array(data[, dtype, copy, order, mask, ...])	具有可能掩码值的数组类。
ma.copy(self, *args, **params) a.copy(order=)	返回数组的副本。
ma.frombuffer(buffer[, dtype, count, ...])	将缓冲区解释为 1 维数组。
ma.fromfunction(function, shape, **dtype)	通过在每个坐标上执行函数来构造数组。
ma.MaskedArray.copy([order])	返回数组的副本。
ma.diagflat	diagflat

一和零

ma.empty(shape[, dtype, order, like])	返回给定形状和类型的新数组，但不初始化条目。
ma.empty_like(prototype[, dtype, order, ...])	返回与给定数组相同形状和类型的新数组。
ma.masked_all(shape[, dtype])	具有所有元素掩码的空掩码数组。
ma.masked_all_like(arr)	生成一个具有现有数组属性的空掩码数组。
ma.ones(shape[, dtype, order])	返回给定形状和类型的新数组，填充为 1。
ma.ones_like	返回与给定数组相同形状和类型的全为 1 的数组。
ma.zeros(shape[, dtype, order, like])	返回给定形状和类型的新数组，填充为 0。
ma.zeros_like	返回一个与给定数组具有相同形状和类型的零数组。

从现有数据

ma.masked_array	MaskedArray的别名
ma.array(data[, dtype, copy, order, mask, ...])	具有可能掩码值的数组类。
ma.copy(self, *args, **params) a.copy(order=)	返回数组的副本。
ma.frombuffer(buffer[, dtype, count, ...])	将缓冲区解释为 1 维数组。
ma.fromfunction(function, shape, **dtype)	通过在每个坐标上执行函数来构造数组。
ma.MaskedArray.copy([order])	返回数组的副本。
ma.diagflat	diagflat

1 和 0

ma.empty(shape[, dtype, order, like])	返回一个给定形状和类型的新数组，但不初始化条目。
ma.empty_like(prototype[, dtype, order, ...])	返回一个与给定数组具有相同形状和类型的新数组。
ma.masked_all(shape[, dtype])	具有所有元素掩码的空掩码数组。
ma.masked_all_like(arr)	具有现有数组属性的空掩码数组。
ma.ones(shape[, dtype, order])	返回一个给定形状和类型的新数组，填充为 1。
ma.ones_like	返回一个与给定数组具有相同形状和类型的 1 数组。
ma.zeros(shape[, dtype, order, like])	返回一个给定形状和类型的新数组，填充为 0。
ma.zeros_like	返回一个与给定数组具有相同形状和类型的零数组。

检查数组

ma.all(self[, axis, out, keepdims])	如果所有元素都评估为 True，则返回 True。
ma.any(self[, axis, out, keepdims])	如果a的任何元素评估为 True，则返回 True。
ma.count(self[, axis, keepdims])	计算沿给定轴的数组的非掩码元素数。
ma.count_masked(arr[, axis])	计算沿给定轴的掩码元素的数量。
ma.getmask(a)	返回掩码数组的掩码，或 nomask。
ma.getmaskarray(arr)	返回掩码数组的掩码，或全为 False 的布尔数组。
ma.getdata(a[, subok])	将掩码数组的数据作为 ndarray 返回。
ma.nonzero(self)	返回未掩码且非零元素的索引。
ma.shape(obj)	返回数组的形状。
ma.size(obj[, axis])	返回沿给定轴的元素数量。
ma.is_masked(x)	确定输入是否具有掩码值。
ma.is_mask(m)	如果 m 是有效的标准掩码，则返回 True。
ma.isMaskedArray(x)	测试输入是否为 MaskedArray 的实例。
ma.isMA(x)	测试输入是否为 MaskedArray 的实例。
ma.isarray(x)	测试输入是否为 MaskedArray 的实例。
ma.isin(element, test_elements[, ...])	计算element是否在test_elements中，仅广播element。
ma.in1d(ar1, ar2[, assume_unique, invert])	测试数组的每个元素是否也存在于第二个数组中。
ma.unique(ar1[, return_index, return_inverse])	查找数组的唯一元素。
ma.MaskedArray.all([axis, out, keepdims])	如果所有元素都评估为 True，则返回 True。
ma.MaskedArray.any([axis, out, keepdims])	如果a的任何元素求值为 True，则返回 True。
ma.MaskedArray.count([axis, keepdims])	计算沿给定轴的数组中非屏蔽元素的数量。
ma.MaskedArray.nonzero()	返回非零未屏蔽元素的索引。
ma.shape(obj)	返回数组的形状。
ma.size(obj[, axis])	返回沿着给定轴的元素数量。
ma.MaskedArray.data	返回作为屏蔽数组视图的基础数据。
ma.MaskedArray.mask	当前掩码。
ma.MaskedArray.recordmask	如果数组没有命名字段，则获取或设置数组的掩码。

操作 MaskedArray

改变形状

ma.ravel(self[, order])	返回一个将自身转换为一维版本的视图。
ma.reshape(a, new_shape[, order])	返回包含相同数据的具有新形状的数组。
ma.resize(x, new_shape)	返回具有指定大小和形状的新屏蔽数组。
ma.MaskedArray.flatten([order])	返回将数组展平为一维的副本。
ma.MaskedArray.ravel([order])	返回一个视图，将自身转换为一维版本。
ma.MaskedArray.reshape(*s, **kwargs)	在不改变数据的情况下为数组赋予新的形状。
ma.MaskedArray.resize(newshape[, refcheck, ...])

修改轴

ma.swapaxes(self, *args, ...)	返回一个将axis1和axis2互换的数组视图。
ma.transpose(a[, axes])	对数组的维度进行排列。
ma.MaskedArray.swapaxes(axis1, axis2)	返回axis1和axis2互换的数组视图。
ma.MaskedArray.transpose(*axes)	返回数组的轴转置视图。

改变维度数量

ma.atleast_1d	atleast_1d
ma.atleast_2d	atleast_2d
ma.atleast_3d	atleast_3d
ma.expand_dims(a, axis)	扩展数组的形状。
ma.squeeze	从a中删除长度为一的轴。
ma.MaskedArray.squeeze([axis])	从a中删除长度为一的轴。
ma.stack	stack
ma.column_stack	column_stack
ma.concatenate(arrays[, axis])	沿着给定轴连接序列数组。
ma.dstack	dstack
ma.hstack	hstack
ma.hsplit	hsplit
ma.mr_	将切片对象转换为沿第一个轴的连接。
ma.row_stack	vstack
ma.vstack	vstack

连接数组

ma.concatenate(arrays[, axis])	沿着给定轴连接序列数组。
ma.stack	stack
ma.vstack	vstack
ma.hstack	hstack
ma.dstack	dstack
ma.column_stack	column_stack
ma.append(a, b[, axis])	将值附加到数组的末尾。

改变形状

ma.ravel(self[, order])	返回 self 的一维版本，作为视图。
ma.reshape(a, new_shape[, order])	返回包含相同数据的新形状数组。
ma.resize(x, new_shape)	返回一个指定大小和形状的新掩码数组。
ma.MaskedArray.flatten([order])	返回将数组展平为一维的副本。
ma.MaskedArray.ravel([order])	返回 self 的一维版本，作为视图。
ma.MaskedArray.reshape(*s, **kwargs)	在不改变数据的情况下为数组赋予新形状。
ma.MaskedArray.resize(newshape[, refcheck, ...])

修改轴

ma.swapaxes(self, *args, ...)	返回将axis1和axis2互换的数组视图。
ma.transpose(a[, axes])	对数组的维度进行排列。
ma.MaskedArray.swapaxes(axis1, axis2)	返回将axis1和axis2互换的数组视图。
ma.MaskedArray.transpose(*axes)	返回轴转置的数组视图。

改变维度数量

ma.atleast_1d	atleast_1d
ma.atleast_2d	atleast_2d
ma.atleast_3d	atleast_3d
ma.expand_dims(a, axis)	扩展数组的形状。
ma.squeeze	从a中删除长度为一的轴。
ma.MaskedArray.squeeze([axis])	从a中删除长度为一的轴。
ma.stack	stack
ma.column_stack	column_stack
ma.concatenate(arrays[, axis])	沿着给定轴连接一系列数组。
ma.dstack	dstack
ma.hstack	hstack
ma.hsplit	hsplit
ma.mr_	将切片对象转换为沿第一个轴的连接。
ma.row_stack	vstack
ma.vstack	vstack

连接数组

ma.concatenate(arrays[, axis])	沿着给定轴连接一系列数组。
ma.stack	stack
ma.vstack	vstack
ma.hstack	hstack
ma.dstack	dstack
ma.column_stack	column_stack
ma.append(a, b[, axis])	将值附加到数组的末尾。

掩码操作

创建一个掩码

ma.make_mask(m[, copy, shrink, dtype])	从数组创建一个布尔掩码。
ma.make_mask_none(newshape[, dtype])	返回给定形状的布尔掩码，填充为 False。
ma.mask_or(m1, m2[, copy, shrink])	使用logical_or运算符组合两个掩码。
ma.make_mask_descr(ndtype)	从给定的 dtype 构造一个 dtype 描述列表。

访问掩码

ma.getmask(a)	返回掩码数组的掩码，或无掩码。
ma.getmaskarray(arr)	返回掩码数组的掩码，或填充为 False 的完整布尔数组。
ma.masked_array.mask	当前掩盖。

查找掩盖数据

ma.ndenumerate(a[, compressed])	多维索引迭代器。
ma.flatnotmasked_contiguous(a)	在掩盖数组中查找连续的未掩盖数据。
ma.flatnotmasked_edges(a)	查找第一个和最后一个未掩盖值的索引。
ma.notmasked_contiguous(a[, axis])	在给定轴上查找掩盖数组中的连续未掩盖数据。
ma.notmasked_edges(a[, axis])	查找沿轴的第一个和最后一个未掩盖值的索引。
ma.clump_masked(a)	返回与一维数组中掩盖块对应的切片列表。
ma.clump_unmasked(a)	返回与一维数组中未掩盖块对应的切片列表。

修改掩盖

ma.mask_cols(a[, axis])	掩盖包含掩盖值的二维数组的列。
ma.mask_or(m1, m2[, copy, shrink])	使用logical_or运算符组合两个掩盖。
ma.mask_rowcols(a[, axis])	掩盖包含掩盖值的二维数组的行和/或列。
ma.mask_rows(a[, axis])	掩盖包含掩盖值的二维数组的行。
ma.harden_mask(self)	强制掩盖为硬掩盖，防止通过赋值取消掩盖。
ma.soften_mask(self)	强制掩盖为软掩盖（默认），允许通过赋值取消掩盖。
ma.MaskedArray.harden_mask()	强制掩盖为硬掩盖，防止通过赋值取消掩盖。
ma.MaskedArray.soften_mask()	强制将掩码软化（默认），允许通过赋值取消掩码。
ma.MaskedArray.shrink_mask()	在可能的情况下将掩码减少到无掩码。
ma.MaskedArray.unshare_mask()	复制掩码并将sharedmask标志设置为False。

创建掩码

ma.make_mask(m[, copy, shrink, dtype])	从数组创建一个布尔掩码。
ma.make_mask_none(newshape[, dtype])	返回给定形状的布尔掩码，填充为 False。
ma.mask_or(m1, m2[, copy, shrink])	使用logical_or运算符组合两个掩码。
ma.make_mask_descr(ndtype)	从给定的数据类型构造数据类型描述列表。

访问掩码

ma.getmask(a)	返回掩码数组的掩码，或无掩码。
ma.getmaskarray(arr)	返回掩码数组的掩码，或填充为 False 的完整布尔数组。
ma.masked_array.mask	当前掩码。

查找掩码数据

ma.ndenumerate(a[, compressed])	多维索引迭代器。
ma.flatnotmasked_contiguous(a)	在掩码数组中找到连续的未掩码数据。
ma.flatnotmasked_edges(a)	找到第一个和最后一个未掩码值的索引。
ma.notmasked_contiguous(a[, axis])	在给定轴上找到掩码数组中的连续未掩码数据。
ma.notmasked_edges(a[, axis])	找到沿轴的第一个和最后一个未掩码值的索引。
ma.clump_masked(a)	返回与 1-D 数组中掩码凝块对应的切片列表。
ma.clump_unmasked(a)	返回与 1-D 数组中未掩码凝块对应的切片列表。

修改掩码

ma.mask_cols(a[, axis])	掩盖包含掩码值的 2D 数组的列。
ma.mask_or(m1, m2[, copy, shrink])	使用logical_or运算符组合两个掩码。
ma.mask_rowcols(a[, axis])	掩盖包含掩码值的 2D 数组的行和/或列。
ma.mask_rows(a[, axis])	掩盖包含掩码值的 2D 数组的行。
ma.harden_mask(self)	强制将掩码硬化，防止通过赋值取消掩码。
ma.soften_mask(self)	强制将掩码软化（默认），允许通过赋值取消掩码。
ma.MaskedArray.harden_mask()	强制将掩码硬化，防止通过赋值取消掩码。
ma.MaskedArray.soften_mask()	强制将掩码软化（默认），允许通过赋值取消掩码。
ma.MaskedArray.shrink_mask()	在可能的情况下将掩码减少到无掩码。
ma.MaskedArray.unshare_mask()	复制掩码并将sharedmask标志设置为False。

转换操作

> 转换为掩码数组

ma.asarray(a[, dtype, order])	将输入转换为给定数据类型的掩码数组。
ma.asanyarray(a[, dtype])	将输入转换为掩码数组，保留子类。
ma.fix_invalid(a[, mask, copy, fill_value])	返回将无效数据掩码并替换为填充值的输入。
ma.masked_equal(x, value[, copy])	在等于给定值的地方屏蔽数组。
ma.masked_greater(x, value[, copy])	在大于给定值的地方屏蔽数组。
ma.masked_greater_equal(x, value[, copy])	在大于���等于给定值的地方屏蔽数组。
ma.masked_inside(x, v1, v2[, copy])	在给定区间内屏蔽数组。
ma.masked_invalid(a[, copy])	在出现无效值（NaN 或 infs）的地方屏蔽数组。
ma.masked_less(x, value[, copy])	在小于给定值的地方屏蔽数组。
ma.masked_less_equal(x, value[, copy])	在小于或等于给定值的地方屏蔽数组。
ma.masked_not_equal(x, value[, copy])	在不等于给定值的地方屏蔽数组。
ma.masked_object(x, value[, copy, shrink])	在数据与 value 完全相等的地方屏蔽数组x。
ma.masked_outside(x, v1, v2[, copy])	在给定区间外屏蔽数组。
ma.masked_values(x, value[, rtol, atol, ...])	使用浮点数相等性进行屏蔽。
ma.masked_where(condition, a[, copy])	在满足条件的地方屏蔽数组。

> 转换为 ndarray

ma.compress_cols(a)	抑制包含屏蔽值的 2-D 数组的整列。
ma.compress_rowcols(x[, axis])	抑制包含屏蔽值的 2-D 数组的行和/或列。
ma.compress_rows(a)	抑制包含屏蔽值的 2-D 数组的整行。
ma.compressed(x)	将所有非屏蔽数据作为 1-D 数组返回。
ma.filled(a[, fill_value])	将输入作为一个数组返回，其中掩码数据被填充值替换。
ma.MaskedArray.compressed()	将所有非掩码数据作为 1-D 数组返回。
ma.MaskedArray.filled([fill_value])	返回自身的副本，其中掩码值被给定值填充。

> 转换为另一个对象

ma.MaskedArray.tofile(fid[, sep, format])	以二进制格式将掩码数组保存到文件中。
ma.MaskedArray.tolist([fill_value])	将掩码数组的数据部分作为分层 Python 列表返回。
ma.MaskedArray.torecords()	将掩码数组转换为灵活类型数组。
ma.MaskedArray.tobytes([fill_value, order])	将数组数据作为包含数组中原始字节的字符串返回。

填充掩码数组

ma.common_fill_value(a, b)	返回两个掩码数组的公共填充值，如果有的话。
ma.default_fill_value(obj)	返回参数对象的默认填充值。
ma.maximum_fill_value(obj)	返回对象的数据类型可以表示的最小值。
ma.minimum_fill_value(obj)	返回对象的数据类型可以表示的最大值。
ma.set_fill_value(a, fill_value)	如���a 是掩码数组，则设置 a 的填充值。
ma.MaskedArray.get_fill_value()	掩码数组的填充值是一个标量。
ma.MaskedArray.set_fill_value([value])
ma.MaskedArray.fill_value	掩码数组的填充值是一个标量。

> 转换为掩码数组

ma.asarray(a[, dtype, order])	将输入转换为给定数据类型的掩码数组。
ma.asanyarray(a[, dtype])	将输入转换为掩码数组，保留子类。
ma.fix_invalid(a[, mask, copy, fill_value])	返回掩码并用填充值替换无效数据的输入。
ma.masked_equal(x, value[, copy])	掩码等于给定值的数组。
ma.masked_greater(x, value[, copy])	掩码大于给定值的数组。
ma.masked_greater_equal(x, value[, copy])	掩码大于或等于给定值的数组。
ma.masked_inside(x, v1, v2[, copy])	掩码给定区间内的数组。
ma.masked_invalid(a[, copy])	掩码包含无效值（NaNs 或 infs）的数组。
ma.masked_less(x, value[, copy])	掩码小于给定值的数组。
ma.masked_less_equal(x, value[, copy])	掩码小于或等于给定值的数组。
ma.masked_not_equal(x, value[, copy])	掩码不等于给定值的数组。
ma.masked_object(x, value[, copy, shrink])	掩码数组x，其中数据与值完全相等。
ma.masked_outside(x, v1, v2[, copy])	掩码给定区间外的数组。
ma.masked_values(x, value[, rtol, atol, ...])	使用浮点数相等性进行掩码。
ma.masked_where(condition, a[, copy])	掩码满足条件的数组。

> 转换为 ndarray

ma.compress_cols(a)	抑制包含掩码值的二维数组的整列。
ma.compress_rowcols(x[, axis])	抑制包含掩码值的二维数组的行和/或列。
ma.compress_rows(a)	抑制包含掩码值的二维数组的整行。
ma.compressed(x)	返回所有非掩码数据作为一维数组。
ma.filled(a[, fill_value])	返回将带有掩码数据的输入替换为填充值的数组。
ma.MaskedArray.compressed()	返回所有非掩码数据作为一维数组。
ma.MaskedArray.filled([fill_value])	返回带有给定值填充的自身副本，掩码值被填充。

> 到另一个对象

ma.MaskedArray.tofile(fid[, sep, format])	以二进制格式将掩码数组保存到文件中。
ma.MaskedArray.tolist([fill_value])	将掩码数组的数据部分作为分层 Python 列表返回。
ma.MaskedArray.torecords()	将掩码数组转换为灵活类型数组。
ma.MaskedArray.tobytes([fill_value, order])	将数组数据作为包含数组中原始字节的字符串返回。

填充掩码数组

ma.common_fill_value(a, b)	返回两个掩码数组的公共填充值（如果有）。
ma.default_fill_value(obj)	返回参数对象的默认填充值。
ma.maximum_fill_value(obj)	返回对象的数据类型能表示的最小值。
ma.minimum_fill_value(obj)	返回对象的数据类型可以表示的最大值。
ma.set_fill_value(a, fill_value)	如果 a 是掩码数组，则设置 a 的填充值。
ma.MaskedArray.get_fill_value()	掩码数组的填充值是一个标量。
ma.MaskedArray.set_fill_value([value])
ma.MaskedArray.fill_value	掩码数组的填充值是一个标量。

掩码数组算术

算术

ma.anom(self[, axis, dtype])	计算沿给定轴的异常值（与算术平均值的偏差）。
ma.anomalies(self[, axis, dtype])	计算沿给定轴的异常值（与算术平均值的偏差）。
ma.average(a[, axis, weights, returned, ...])	返回给定轴上数组的加权平均值。
ma.conjugate(x, /[, out, where, casting, ...])	返回复共轭，逐元素。
ma.corrcoef(x[, y, rowvar, bias, ...])	返回皮尔逊积矩相关系数。
ma.cov(x[, y, rowvar, bias, allow_masked, ddof])	估计协方差矩阵。
ma.cumsum(self[, axis, dtype, out])	返回给定轴上数组元素的累积和。
ma.cumprod(self[, axis, dtype, out])	返回给定轴上数组元素的累积乘积。
ma.mean(self[, axis, dtype, out, keepdims])	返回沿给定轴的数组元素的平均值。
ma.median(a[, axis, out, overwrite_input, ...])	计算沿指定轴的中位数。
ma.power(a, b[, third])	返回第二个数组的幂次方作为第一个数组的元素。
ma.prod(self[, axis, dtype, out, keepdims])	返回沿指定轴的数组元素的乘积。
ma.std(self[, axis, dtype, out, ddof, keepdims])	返回沿指定轴的数组元素的标准差。
ma.sum(self[, axis, dtype, out, keepdims])	返回沿指定轴的数组元素之和。
ma.var(self[, axis, dtype, out, ddof, keepdims])	计算沿指定轴的方差。
ma.MaskedArray.anom([axis, dtype])	计算沿指定轴的异常值（与算术平均值的偏差）。
ma.MaskedArray.cumprod([axis, dtype, out])	返回沿指定轴的数组元素的累积乘积。
ma.MaskedArray.cumsum([axis, dtype, out])	返回沿指定轴的数组元素的累积和。
ma.MaskedArray.mean([axis, dtype, out, keepdims])	返回沿指定轴的数组元素的平均值。
ma.MaskedArray.prod([axis, dtype, out, keepdims])	返回沿指定轴的数组元素的乘积。
ma.MaskedArray.std([axis, dtype, out, ddof, ...])	返回沿指定轴的数组元素的标准差。
ma.MaskedArray.sum([axis, dtype, out, keepdims])	返回沿指定轴的数组元素之和。
ma.MaskedArray.var([axis, dtype, out, ddof, ...])	计算沿指定轴的方差。

最小/最大值

ma.argmax(self[, axis, fill_value, out])	返回沿指定轴的最大值的索引数组。
ma.argmin(self[, axis, fill_value, out])	返回沿指定轴的最小值的索引数组。
ma.max(obj[, axis, out, fill_value, keepdims])	返回沿指定轴的最大值。
ma.min(obj[, axis, out, fill_value, keepdims])	返回沿着给定轴的最小值。
ma.ptp(obj[, axis, out, fill_value, keepdims])	返回沿着给定维度的（最大值 - 最小值）（即
ma.diff(a, /[, n, axis, prepend, append])	计算沿着给定轴的第 n 个离散差分。
ma.MaskedArray.argmax([axis, fill_value, ...])	返回沿着给定轴的最大值的索引数组。
ma.MaskedArray.argmin([axis, fill_value, ...])	返回沿着给定轴的最小值的索引数组。
ma.MaskedArray.max([axis, out, fill_value, ...])	返回沿着给定轴的最大值。
ma.MaskedArray.min([axis, out, fill_value, ...])	返回沿着给定轴的最小值。
ma.MaskedArray.ptp([axis, out, fill_value, ...])	返回沿着给定维度的（最大值 - 最小值）（即

排序

ma.argsort(a[, axis, kind, order, endwith, ...])	返回沿着指定轴对数组进行排序的索引的 ndarray。
ma.sort(a[, axis, kind, order, endwith, ...])	返回排序后的掩码数组的副本。
ma.MaskedArray.argsort([axis, kind, order, ...])	返回沿着指定轴对数组进行排序的索引的 ndarray。
ma.MaskedArray.sort([axis, kind, order, ...])	对数组进行排序，就地排序。

代数

ma.diag(v[, k])	提取对角线或构造对角线数组。
ma.dot(a, b[, strict, out])	返回两个数组的点积。
ma.identity(n[, dtype])	返回单位矩阵。
ma.inner(a, b, /)	两个数组的内积。
ma.innerproduct(a, b, /)	两个数组的内积。
ma.outer(a, b)	计算两个向量的外积。
ma.outerproduct(a, b)	计算两个向量的外积。
ma.trace(self[, offset, axis1, axis2, ...])	返回数组对角线上的和。
ma.transpose(a[, axes])	对数组的维度进行排列。
ma.MaskedArray.trace([offset, axis1, axis2, ...])	返回数组对角线上的和。
ma.MaskedArray.transpose(*axes)	返回数组的轴转置视图。

多项式拟合

ma.vander(x[, n])	生成一个范德蒙德矩阵。
ma.polyfit(x, y, deg[, rcond, full, w, cov])	最小二乘多项式拟合。

修剪和四舍五入

ma.around	将数组四舍五入到给定的小数位数。
ma.clip	限制数组中的值。
ma.round(a[, decimals, out])	返回四舍五入到 'decimals' 位的 a 的副本。
ma.MaskedArray.clip([min, max, out])	返回其值限制在 [min, max] 范围内的数组。
ma.MaskedArray.round([decimals, out])	返回每个元素四舍五入到给定的小数位数。

集合操作

ma.intersect1d(ar1, ar2[, assume_unique])	返回两个数组共同的唯一元素。
ma.setdiff1d(ar1, ar2[, assume_unique])	返回具有唯一元素的 1D 数组的差集。
ma.setxor1d(ar1, ar2[, assume_unique])	具有唯一元素的 1-D 数组的异或集。
ma.union1d(ar1, ar2)	两个数组的并集。

杂项

ma.allequal(a, b[, fill_value])	如果 a 和 b 的所有条目相等，则返回 True，使用 fill_value 作为真值，其中任一或两者都被屏蔽。
ma.allclose(a, b[, masked_equal, rtol, atol])	如果两个数组在容差范围内逐元素相等，则返回 True。
ma.apply_along_axis(func1d, axis, arr, ...)	沿着给定轴对 1-D 切片应用函数。
ma.apply_over_axes(func, a, axes)	在多个轴上重复应用函数。
ma.arange([start,] stop[, step,][, dtype, like])	返回给定区间内均匀间隔的值。
ma.choose(indices, choices[, out, mode])	使用索引数组从选择列表中构建新数组。
ma.ediff1d(arr[, to_end, to_begin])	计算数组中连续元素之间的差异。
ma.indices(dimensions[, dtype, sparse])	返回表示网格索引的数组。
ma.where(condition[, x, y])	根据条件从x或y返回一个掩码数组。

Arithmetic

ma.anom(self[, axis, dtype])	计算沿着给定轴的异常值（与算术平均值的偏差）。
ma.anomalies(self[, axis, dtype])	计算沿着给定轴的异常值（与算术平均值的偏差）。
ma.average(a[, axis, weights, returned, ...])	返回给定轴上数组的加权平均值。
ma.conjugate(x, /[, out, where, casting, ...])	返回逐元素的复共轭。
ma.corrcoef(x[, y, rowvar, bias, ...])	返回皮尔逊积矩相关系数。
ma.cov(x[, y, rowvar, bias, allow_masked, ddof])	估计协方差矩阵。
ma.cumsum(self[, axis, dtype, out])	返回给定轴上数组元素的累积和。
ma.cumprod(self[, axis, dtype, out])	返回沿着给定轴的数组元素的累积乘积。
ma.mean(self[, axis, dtype, out, keepdims])	返回沿着给定轴的数组元素的平均值。
ma.median(a[, axis, out, overwrite_input, ...])	计算沿着指定轴的中位数。
ma.power(a, b[, third])	返回第二个数组的幂次方的基本数组的逐元素计算。
ma.prod(self[, axis, dtype, out, keepdims])	返回沿着给定轴的数组元素的乘积。
ma.std(self[, axis, dtype, out, ddof, keepdims])	返回沿着给定轴的数组元素的标准差。
ma.sum(self[, axis, dtype, out, keepdims])	返回沿着给定轴的数组元素的和。
ma.var(self[, axis, dtype, out, ddof, keepdims])	计算沿着指定轴的方差。
ma.MaskedArray.anom([axis, dtype])	计算沿着给定轴的异常值（与算术平均值的偏差）。
ma.MaskedArray.cumprod([axis, dtype, out])	返回沿着给定轴的数组元素的累积乘积。
ma.MaskedArray.cumsum([axis, dtype, out])	返回沿着给定轴的数组元素的累积和。
ma.MaskedArray.mean([axis, dtype, out, keepdims])	返回沿着给定轴的数组元素的平均值。
ma.MaskedArray.prod([axis, dtype, out, keepdims])	返回沿着给定轴的数组元素的乘积。
ma.MaskedArray.std([axis, dtype, out, ddof, ...])	返回沿着给定轴的数组元素的标准差。
ma.MaskedArray.sum([axis, dtype, out, keepdims])	返回沿着给定轴的数组��素的和。
ma.MaskedArray.var([axis, dtype, out, ddof, ...])	计算沿着指定轴的方差。

最小/最大

ma.argmax(self[, axis, fill_value, out])	返回沿着给定轴的最大值的索引数组。
ma.argmin(self[, axis, fill_value, out])	返回沿着给定轴的最小值的索引数组。
ma.max(obj[, axis, out, fill_value, keepdims])	返回沿着给定轴的最大值。
ma.min(obj[, axis, out, fill_value, keepdims])	返回沿着给定轴的最小值。
ma.ptp(obj[, axis, out, fill_value, keepdims])	返回沿着给定维度的（最大值 - 最小值）。
ma.diff(a, /[, n, axis, prepend, append])	计算沿着给定轴的第 n 个离散差分。
ma.MaskedArray.argmax([axis, fill_value, ...])	返回沿着给定轴的最大值的索引数组。
ma.MaskedArray.argmin([axis, fill_value, ...])	返回沿着给定轴的最小值的索引数组。
ma.MaskedArray.max([axis, out, fill_value, ...])	返回沿着给定轴的最大值。
ma.MaskedArray.min([axis, out, fill_value, ...])	返回沿着给定轴的最小值。
ma.MaskedArray.ptp([axis, out, fill_value, ...])	返回沿着给定维度的（最大值 - 最小值）。

排序

ma.argsort(a[, axis, kind, order, endwith, ...])	返回沿着���定轴对数组进行排序的索引的 ndarray。
ma.sort(a[, axis, kind, order, endwith, ...])	返回排序后的掩码数组的副本。
ma.MaskedArray.argsort([axis, kind, order, ...])	返回沿着指定轴对数组进行排序的索引的 ndarray。
ma.MaskedArray.sort([axis, kind, order, ...])	对数组进行排序，就地操作

代数

ma.diag(v[, k])	提取对角线或构造对角线数组。
ma.dot(a, b[, strict, out])	返回两个数组的点积。
ma.identity(n[, dtype])	返回单位矩阵。
ma.inner(a, b, /)	两个数组的内积。
ma.innerproduct(a, b, /)	两个数组的内积。
ma.outer(a, b)	计算两个向量的外积。
ma.outerproduct(a, b)	计算两个向量的外积。
ma.trace(self[, offset, axis1, axis2, ...])	返回数组沿对角线的和。
ma.transpose(a[, axes])	排列数组的维度。
ma.MaskedArray.trace([offset, axis1, axis2, ...])	返回数组沿对角线的和。
ma.MaskedArray.transpose(*axes)	返回数组的轴转置视图。

多项式拟合

ma.vander(x[, n])	生成一个范德蒙矩阵。
ma.polyfit(x, y, deg[, rcond, full, w, cov])	最小二乘多项式拟合。

截取和四舍五入

ma.around	将数组四舍五入到指定的小数位数。
ma.clip	截取（限制）数组中的值。
ma.round(a[, decimals, out])	返回 a 的副本，四舍五入到'decimals'位。
ma.MaskedArray.clip([min, max, out])	返回一个其值限制在[min, max]范围内的数组。
ma.MaskedArray.round([decimals, out])	返回每个元素四舍五入到指定的小数位数。

集合操作

ma.intersect1d(ar1, ar2[, assume_unique])	返回两个数组共同的唯一元素。
ma.setdiff1d(ar1, ar2[, assume_unique])	具有唯一元素的 1D 数组的差集。
ma.setxor1d(ar1, ar2[, assume_unique])	具有唯一元素的 1-D 数组的异或集。
ma.union1d(ar1, ar2)	两个数组的并集。

Miscellanea

ma.allequal(a, b[, fill_value])	如果 a 和 b 的所有条目都相等，则使用 fill_value 作为真值返回 True，其中任一或两者都被屏蔽。
ma.allclose(a, b[, masked_equal, rtol, atol])	如果两个数组在容差范围内逐元素相等，则返回 True。
ma.apply_along_axis(func1d, axis, arr, ...)	沿着给定轴对 1-D 切片应用函数。
ma.apply_over_axes(func, a, axes)	在多个轴上重复应用函数。
ma.arange([start,] stop[, step,][, dtype, like])	返回给定区间内均匀间隔的值。
ma.choose(indices, choices[, out, mode])	使用索引数组从选择列表构造新数组。
ma.ediff1d(arr[, to_end, to_begin])	计算数组连续元素之间的差异。
ma.indices(dimensions[, dtype, sparse])	返回表示网格索引的数组。
ma.where(condition[, x, y])	根据条件从x或y返回一个掩码数组。

数组接口协议

原文：numpy.org/doc/1.26/reference/arrays.interface.html

注意

本页描述了从其他 C 扩展访问 NumPy 数组内容的 NumPy 特定 API。PEP 3118 – 修订的缓冲区协议引入了类似的标准化 API，供 Python 2.6 和 3.0 的任何扩展模块使用。Cython的缓冲区数组支持使用了PEP 3118 API；请参阅Cython NumPy 教程。Cython 提供了一种编写支持缓冲区协议的代码的方式，可以在早于 2.6 的 Python 版本中使用，因为它具有一个向后兼容的实现，利用了此处描述的数组接口。

版本：

3

数组接口（有时称为数组协议）于 2005 年创建，作为 Python 对象类似于数组的智能重用数据缓冲区的手段。同质 N 维数组接口是对象共享 N 维数组内存和信息的默认机制。该接口由 Python 端和 C 端使用两个属性组成。希望在应用代码中被视为 N 维数组的对象应至少支持这两个属性中的一个。希望在应用代码中支持 N 维数组的对象应至少查找其中一个属性并适当使用提供的信息。

此接口描述了同质数组，即数组的每个项目具有相同的“类型”。这种类型可以非常简单，也可以是类似于 C 的任意复杂结构。

有两种使用接口的方式：Python 端和 C 端。两者是独立的属性。

Python 端

此接口的方法包括对象具有一个__array_interface__属性。

object.__array_interface__

一个项目字典（3 个必需和 5 个可选）。如果未提供可选键，则字典中的可选键具有隐含的默认值。

键包括：

shape（必需）

元组，其中的元素是每个维度中的数组大小。每个条目都是一个整数（Python int）。请注意，这些整数可能大于平台int或long可以容纳的（Python int是 C long）。使用此属性的代码应适当处理这一点；要么在可能溢出时引发错误，要么使用long long作为形状的 C 类型。

typestr（必需）

提供同质数组的基本类型的字符串。基本字符串格式由 3 部分组成：描述数据的字节顺序的字符（<：小端，>：大端，|：不相关），给出数组的基本类型的字符代码，以及提供类型使用的字节数的整数。

基本类型字符代码为：

t	位字段（后面的整数给出位字段中的位数）。
b	布尔值（整数类型，所有值仅为True或False）
i	整数
u	无符号整数
f	浮点数
c	复数浮点数
m	时间间隔
M	日期时间
O	对象（即内存包含指向PyObject的指针）
S	字符串（char 的固定长度序列）
U	Unicode（Py_UCS4的固定长度序列）
V	其他（void * - 每个项目是固定大小的内存块）

描述（可选）

提供同质数组中每个项目的内存布局的更详细描述的元组列表。列表中的每个元组有两个或三个元素。通常，当typestr为V[0-9]+时，会使用此属性，但这不是必需的。唯一的要求是typestr键中表示的字节总数与此处表示的字节总数相同。这个想法是支持描述组成数组元素的类似 C 的结构。列表中每个元组的元素为

1. 提供与此数据类型部分关联的名称的字符串。这也可以是一个元组('full name', 'basic_name')，其中 basic name 将是代表字段全名的有效 Python 变量名。

2. 要么是像typestr中的基本类型描述字符串，要么是另一个列表（用于嵌套结构类型）

3. 提供此结构部分应重复多少次的可选形状元组。如果未提供此元组，则不假设重复。可以使用此通用接口描述非常复杂的结构。但请注意，数组的每个元素仍然是相同的数据类型。下面给出了使用此接口的一些示例。

默认值：[('', typestr)]

数据（可选）

第一个参数为指向存储数组内容的数据区域的Python 整数的 2 元组。

注意

从 C/C++通过PyLong_From*或高级绑定（如 Cython 或 pybind11）转换时，请确保使用足够大位数的整数。

此指针必须指向数据的第一个元素（换句话说，在这种情况下，任何偏移量都将被忽略）。元组中的第二个条目是只读标志（true 表示数据区域是只读的）。

此属性还可以是一个暴露缓冲区接口的对象，该对象将用于共享数据。如果此键不存在（或返回 None），则内存共享将通过对象本身的缓冲区接口完成。在这种情况下，可以使用偏移键来指示缓冲区的起始位置。如果要确保内存区域安全，新对象必须存储暴露数组接口的对象的引用。

默认值：None

strides（可选）

要么是None表示 C 风格的连续数组，要么是一个元组，其中提供了跳转到相应维度下一个数组元素所需的字节数。每个条目必须是整数（Python int）。与形状一样，这些值可能比 C int或long能表示的值大；调用代码应适当处理这一点，要么通过引发错误，要么在 C 中使用long long。默认值为None，这意味着 C 风格的连续内存缓冲区。在这种模型中，数组的最后一个维度变化最快。例如，如果一个对象的数组条目长度为 8 字节，形状为(10, 20, 30)，则默认的步幅元组将是(4800, 240, 8)。

默认值：None（C 风格连续）

mask（可选）

None或一个暴露数组接口的对象。掩码数组的所有元素应该只被解释为真或不真，指示该数组的哪些元素有效。此对象的形状应该是“可广播的”到原始数组的形状。

默认值：None（所有数组值都有效）

offset（可选）

一个整数偏移量，指向数组数据区域。只有当数据为None或返回一个buffer对象时才能使用此选项。

默认值：0。

version（必需）

一个整数，显示接口的版本（即此版本为 3）。请注意，不要使用此版本来使暴露未来版本接口的对象无效。

C 结构访问

这种数组接口的方法允许通过仅进行一次属性查找和一个明确定义的 C 结构更快地访问数组。

object.__array_struct__

一个 PyCapsule，其 pointer 成员包含指向填充的 PyArrayInterface 结构的指针。该结构的内存是动态创建的，并且 PyCapsule 也是使用适当的析构函数创建的，因此当完成时，检索此属性的对象只需对此属性返回的对象应用 Py_DECREF。此外，需要将数据复制出来，或者必须持有暴露此属性的对象的引用以确保数据不被释放。暴露 __array_struct__ 接口的对象也不得在其他对象引用它们时重新分配它们的内存。

PyArrayInterface 结构在 numpy/ndarrayobject.h 中定义为：

typedef struct {
  int two;              /* contains the integer 2 -- simple sanity check */
  int nd;               /* number of dimensions */
  char typekind;        /* kind in array --- character code of typestr */
  int itemsize;         /* size of each element */
  int flags;            /* flags indicating how the data should be interpreted */
                        /*   must set ARR_HAS_DESCR bit to validate descr */
  Py_intptr_t *shape;   /* A length-nd array of shape information */
  Py_intptr_t *strides; /* A length-nd array of stride information */
  void *data;           /* A pointer to the first element of the array */
  PyObject *descr;      /* NULL or data-description (same as descr key
                                of __array_interface__) -- must set ARR_HAS_DESCR
                                flag or this will be ignored. */
} PyArrayInterface; 

flags 成员可能由 5 位组成，显示数据应如何解释以及接口应如何解释。数据位是 NPY_ARRAY_C_CONTIGUOUS (0x1)，NPY_ARRAY_F_CONTIGUOUS (0x2)，NPY_ARRAY_ALIGNED (0x100)，NPY_ARRAY_NOTSWAPPED (0x200)，以及 NPY_ARRAY_WRITEABLE (0x400)。最后一个标志 NPY_ARR_HAS_DESCR (0x800) 指示该结构是否具有 arrdescr 字段。除非存在此标志，否则不应访问该字段。

NPY_ARR_HAS_DESCR

自 2006 年 6 月 16 日起新增：

在过去，大多数实现使用 PyCObject 的 desc 成员（现在是 PyCapsule）本身（不要将其与上面的 PyArrayInterface 结构的 “descr” 成员混淆 — 它们是两个不同的东西）来保存指向暴露接口的对象的指针。这现在是接口的一个明确部分。确保引用该对象并在返回 PyCapsule 之前调用 PyCapsule_SetContext，并配置一个析构函数来减少此引用。

注意

__array_struct__被视为遗留代码，不应用于新代码。请使用缓冲区协议或 DLPack 协议numpy.from_dlpack。

类型描述示例

为了清晰起见，提供一些类型描述和相应__array_interface__ 'descr'条目的示例是有用的。感谢 Scott Gilbert 提供这些示例：

在每种情况下，'descr'键都是可选的，但当然提供更多信息可能对各种应用程序很重要：

* Float data
    typestr == '>f4'
    descr == [('','>f4')]

* Complex double
    typestr == '>c8'
    descr == [('real','>f4'), ('imag','>f4')]

* RGB Pixel data
    typestr == '|V3'
    descr == [('r','|u1'), ('g','|u1'), ('b','|u1')]

* Mixed endian (weird but could happen).
    typestr == '|V8' (or '>u8')
    descr == [('big','>i4'), ('little','<i4')]

* Nested structure
    struct {
        int ival;
        struct {
            unsigned short sval;
            unsigned char bval;
            unsigned char cval;
        } sub;
    }
    typestr == '|V8' (or '<u8' if you want)
    descr == [('ival','<i4'), ('sub', [('sval','<u2'), ('bval','|u1'), ('cval','|u1') ]) ]

* Nested array
    struct {
        int ival;
        double data[16*4];
    }
    typestr == '|V516'
    descr == [('ival','>i4'), ('data','>f8',(16,4))]

* Padded structure
    struct {
        int ival;
        double dval;
    }
    typestr == '|V16'
    descr == [('ival','>i4'),('','|V4'),('dval','>f8')] 

应清楚地指出，任何结构化类型都可以使用此接口进行描述。

与数组接口（版本 2）的差异

版本 2 接口非常相似。差异主要是美学上的。特别是：

1. PyArrayInterface 结构在末尾没有 descr 成员（因此没有标志 ARR_HAS_DESCR）

2. 从__array_struct__返回的PyCapsule（正式上是PyCObject的desc成员）的context成员未指定。通常，它是暴露数组的对象（以便在销毁 C 对象时可以保留对其的引用并销毁）。现在明确要求以某种方式使用此字段来保存对拥有对象的引用。

   注意

   直到 2020 年 8 月，这样说：

   现在它必须是一个元组，其第一个元素是带有“PyArrayInterface Version #”的字符串，第二个元素是暴露数组的对象。

   这个设计在提出后几乎立即被撤回，详情请见<mail.python.org/pipermail/numpy-discussion/2006-June/020995.html>。尽管有 14 年的文件说明与之相反，但从未有理由认为__array_interface__胶囊包含此元组内容。

3. 从__array_interface__['data']返回的元组曾经是一个十六进制字符串（现在是一个整数或长整数）。

4. 没有__array_interface__属性，而是__array_interface__字典中的所有键（除了版本）都是它们自己的属性：因此，要获取 Python 端信息，您必须分别访问属性：

   • __array_data__

   • __array_shape__

   • __array_strides__

   • __array_typestr__

   • __array_descr__

   • __array_offset__

   • __array_mask__

Python 端

这种接口的方法包括对象具有一个__array_interface__属性。

object.__array_interface__

一个包含项目的字典（3 个必需和 5 个可选）。如果未提供可选键，则字典中的可选键具有隐含的默认值。

键包括：

shape（必需）

每个维度中数组大小的元组。每个条目都是一个整数（Python int）。请注意，这些整数可能大于平台int或long可以容纳的大小（Python int是 C long）。代码使用此属性时应适当处理这一点；要么在可能发生溢出时引发错误，要么使用long long作为形状的 C 类型。

typestr（必需）

提供同类数组基本类型的字符串。基本字符串格式由 3 部分组成：描述数据的字节顺序的字符（<：小端，>：大端，|：不相关），给出数组基本类型的字符代码，以及提供类型使用的字节数的整数。

基本类型字符代码为：

t	位域（后面的整数给出位域中的位数）。
b	布尔值（整数类型，所有值仅为True或False）
i	整数
u	无符号整数
f	浮点数
c	复数浮点数
m	时间增量
M	日期时间
O	对象（即内存包含指向PyObject的指针）
S	字符串（char 的固定长度序列）
U	Unicode（Py_UCS4的固定长度序列）
V	其他（空指针 - 每个项目都是固定大小的内存块）

descr（可选）

提供同类数组中每个项目的内存布局的更详细描述的元组列表。列表中的每个元组有两个或三个元素。通常，当typestr为V[0-9]+时，会使用此属性，但这不是必需的。唯一的要求是typestr键中表示的字节数与此处表示的总字节数相同。其目的是支持组成数组元素的类似 C 结构的描述。列表中每个元组的元素为

1. 提供与此数据类型部分关联的名称的字符串。这也可以是一个元组('full name', 'basic_name')，其中基本名称将是代表字段全名的有效 Python 变量名。

2. 要么是像typestr中的基本类型描述字符串，要么是另一个列表（用于嵌套结构类型）

3. 提供可选形状元组，指定结构的这一部分应重复多少次。如果未给出，则假定没有重复。可以使用此通用接口描述非常复杂的结构。但请注意，数组的每个元素仍然是相同的数据类型。下面给出了使用此接口的一些示例。

默认：[('', typestr)]

数据（可选）

一个 2 元组，其第一个参数是指向存储数组内容的数据区域的Python 整数。

注意

在通过PyLong_From*或高级绑定（如 Cython 或 pybind11）从 C/C++ 转换时，请确保使用足够大位数的整数。

此指针必须指向数据的第一个元素（换句话说，此时任何偏移量都会被忽略）。元组中的第二个条目是只读标志（true 表示数据区域是只读的）。

此属性也可以是一个暴露缓冲区接口的对象，用于共享数据。如果此键不存在（或返回None），则内存共享将通过对象本身的缓冲区接口进行。在这种情况下，偏移键可用于指示缓冲区的起始位置。如果要确保内存区域安全，新对象必须存储暴露数组接口的对象的引用。

默认值：None

步幅（可选）

可以是None，表示 C 风格的连续数组，或者是一个元组，其中提供了跳转到相应维度下一个数组元素所需的字节数。每个条目必须是整数（Python int）。与形状一样，这些值可能比 C int 或 long 能表示的值更大；调用代码应适当处理这一点，要么通过引发错误，要么在 C 中使用 long long。默认值为None，这意味着 C 风格的连续内存缓冲区。在这种模型中，数组的最后一个维度变化最快。例如，对于一个对象，其数组条目为 8 字节长，形状为(10, 20, 30)的默认步幅元组将是(4800, 240, 8)。

默认值：None（C 风格连续）

掩码（可选）

None或一个暴露数组接口的对象。掩码数组的所有元素应仅解释为真或不真，指示此数组的哪些元素是有效的。此对象的形状应“可广播”到原始数组的形状。

默认值：None（所有数组值都有效）

偏移量（可选）

一个整数偏移量，指向数组数据区域。只能在数据为None或返回buffer对象时使用。

默认值：0。

版本（必需）

一个显示接口版本的整数（即此版本为 3）。请注意，不要使用此版本来使暴露未来版本接口的对象无效。

C 结构访问

此数组接口的方法允许通过仅进行一次属性查找和一个明确定义的 C 结构更快地访问数组。

object.__array_struct__

一个包含指向填充的PyArrayInterface结构的指针的PyCapsule。结构的内存是动态创建的，并且PyCapsule也是用适当的析构函数创建的，因此检索此属性的对象在完成时只需对此属性返回的对象应用Py_DECREF。此外，数据需要被复制出来，或者必须保持对暴露此属性的对象的引用，以确保数据不被释放。暴露__array_struct__接口的对象也不能重新分配它们的内存，如果其他对象正在引用它们。

PyArrayInterface结构在numpy/ndarrayobject.h中定义为：

typedef struct {
  int two;              /* contains the integer 2 -- simple sanity check */
  int nd;               /* number of dimensions */
  char typekind;        /* kind in array --- character code of typestr */
  int itemsize;         /* size of each element */
  int flags;            /* flags indicating how the data should be interpreted */
                        /*   must set ARR_HAS_DESCR bit to validate descr */
  Py_intptr_t *shape;   /* A length-nd array of shape information */
  Py_intptr_t *strides; /* A length-nd array of stride information */
  void *data;           /* A pointer to the first element of the array */
  PyObject *descr;      /* NULL or data-description (same as descr key
                                of __array_interface__) -- must set ARR_HAS_DESCR
                                flag or this will be ignored. */
} PyArrayInterface; 

flags 成员可能由 5 位组成，显示数据应如何解释，以及一位显示接口应如何解释。数据位是NPY_ARRAY_C_CONTIGUOUS（0x1）、NPY_ARRAY_F_CONTIGUOUS（0x2）、NPY_ARRAY_ALIGNED（0x100）、NPY_ARRAY_NOTSWAPPED（0x200）和NPY_ARRAY_WRITEABLE（0x400）。最后一个标志NPY_ARR_HAS_DESCR（0x800）指示此结构是否具有 arrdescr 字段。除非存在此标志，否则不应访问该字段。

NPY_ARR_HAS_DESCR

自 2006 年 6 月 16 日以来新增：

在过去，大多数实现使用PyCObject（现在是PyCapsule）的desc成员本身（不要将其与上面的PyArrayInterface结构中的“descr”成员混淆——它们是两个不同的东西）来保存暴露接口的对象指针。这现在是接口的一个显式部分。在返回PyCapsule之前，请确保引用该对象并调用PyCapsule_SetContext，并配置一个析构函数来减少此引用。

注意

__array_struct__ 被视为遗留代码，不应该用于新代码。而应该使用缓冲区协议或 DLPack 协议 numpy.from_dlpack。

类型描述示例

为了清晰起见，提供一些类型描述和相应的 __array_interface__ ‘descr’ 条目的示例是有用的。感谢 Scott Gilbert 提供这些示例：

在每种情况下，‘descr’ 键都是可选的，但当然提供更多信息可能对各种应用程序很重要：

* Float data
    typestr == '>f4'
    descr == [('','>f4')]

* Complex double
    typestr == '>c8'
    descr == [('real','>f4'), ('imag','>f4')]

* RGB Pixel data
    typestr == '|V3'
    descr == [('r','|u1'), ('g','|u1'), ('b','|u1')]

* Mixed endian (weird but could happen).
    typestr == '|V8' (or '>u8')
    descr == [('big','>i4'), ('little','<i4')]

* Nested structure
    struct {
        int ival;
        struct {
            unsigned short sval;
            unsigned char bval;
            unsigned char cval;
        } sub;
    }
    typestr == '|V8' (or '<u8' if you want)
    descr == [('ival','<i4'), ('sub', [('sval','<u2'), ('bval','|u1'), ('cval','|u1') ]) ]

* Nested array
    struct {
        int ival;
        double data[16*4];
    }
    typestr == '|V516'
    descr == [('ival','>i4'), ('data','>f8',(16,4))]

* Padded structure
    struct {
        int ival;
        double dval;
    }
    typestr == '|V16'
    descr == [('ival','>i4'),('','|V4'),('dval','>f8')] 

应该清楚任何结构化类型都可以使用这个接口来描述。

与数组接口（第 2 版）的差异

第二版接口非常相似。主要区别在于美学方面。特别是：

1. PyArrayInterface 结构在末尾没有 descr 成员（因此没有标志 ARR_HAS_DESCR）

2. 从 __array_struct__ 返回的 PyCapsule（正式上是 PyCObject 的 desc 成员）的 context 成员没有指定。通常，它是暴露数组的对象（以便在销毁 C 对象时保留对它的引用并销毁它）。现在明确要求以某种方式使用此字段来保存对拥有对象的引用。

   注意

   直到 2020 年 8 月，这样说：

   现在它必须是一个元组，其第一个元素是一个带有“PyArrayInterface 版本 #”的字符串，第二个元素是暴露数组的对象。

   这个设计在提出后几乎立即被撤回，在 <mail.python.org/pipermail/numpy-discussion/2006-June/020995.html>。尽管有 14 年的文档说明相反，但从来没有理由认为 __array_interface__ 胶囊包含这个元组内容。

3. 从 __array_interface__['data'] 返回的元组以前是一个十六进制字符串（现在是一个整数或长整数）。

4. 没有 __array_interface__ 属性，而是 __array_interface__ 字典中除了版本之外的所有键都是它们自己的属性：因此，要获取 Python 端的信息，必须分别访问属性：

   • __array_data__

   • __array_shape__

   • __array_strides__

   • __array_typestr__

   • __array_descr__

   • __array_offset__

   • __array_mask__

日期时间和时间增量

原文：numpy.org/doc/1.26/reference/arrays.datetime.html

从 NumPy 1.7 开始。

从 NumPy 1.7 开始，有核心数组数据类型原生支持日期时间功能。该数据类型称为datetime64，因为datetime已经被 Python 标准库使用。

Datetime64 约定和假设

与 Python date类似，日期是在当前的公历日历中表示的，无限地延伸到未来和过去。与 Python date相反，它仅支持 1 AD 年至 9999 AD 年范围内的年份，datetime64还允许 BC 年份；BC 年份遵循天文年编号约定，即公元前 2 年编号为-1，公元前 1 年编号为 0，公元 1 年编号为 1。

时间点，比如 16:23:32.234，是从午夜开始计算小时、分钟、秒和分数表示的：即 00:00:00.000 是午夜，12:00:00.000 是中午，等等。每个日历日恰好有 86400 秒。这是一个“天真”的时间，没有明确的时区或特定的时间标度（UT1、UTC、TAI 等）。

基本日期时间

创建日期时间的最基本方式是从 ISO 8601 日期或日期时间格式的字符串中创建。也可以通过相对于 Unix 纪元（1970 年 1 月 1 日 UTC 00:00:00）的整数偏移来创建日期时间。内部存储的单位会根据字符串的形式自动选择，并且可以是 date unit 或 time unit。日期单位是年（‘Y’）、月（‘M’）、周（‘W’）和日（‘D’），而时间单位是小时（‘h’）、分钟（‘m’）、秒（‘s’）、毫秒（‘ms’）和一些额外的 SI 前缀秒为基础的单位。datetime64数据类型还接受字符串“NAT”，无论是小写还是大写字母的任意组合，表示“非时间”值。

示例

一个简单的 ISO 日期：

>>> np.datetime64('2005-02-25')
numpy.datetime64('2005-02-25') 

从整数和日期单位，自 UNIX 纪元以来的 1 年：

>>> np.datetime64(1, 'Y')
numpy.datetime64('1971') 

使用月份作为单位：

>>> np.datetime64('2005-02')
numpy.datetime64('2005-02') 

仅指定月份，但强制使用‘天’单位：

>>> np.datetime64('2005-02', 'D')
numpy.datetime64('2005-02-01') 

从日期和时间：

>>> np.datetime64('2005-02-25T03:30')
numpy.datetime64('2005-02-25T03:30') 

NAT（非时间）：

>>> np.datetime64('nat')
numpy.datetime64('NaT') 

从字符串创建日期时间数组时，仍然可以通过使用具有通用单位的 datetime 类型从输入中自动选择单位。

示例

>>> np.array(['2007-07-13', '2006-01-13', '2010-08-13'], dtype='datetime64')
array(['2007-07-13', '2006-01-13', '2010-08-13'], dtype='datetime64[D]') 

>>> np.array(['2001-01-01T12:00', '2002-02-03T13:56:03.172'], dtype='datetime64')
array(['2001-01-01T12:00:00.000', '2002-02-03T13:56:03.172'],
 dtype='datetime64[ms]') 

可以从表示 POSIX 时间戳的整数构建日期时间数组。

示例

>>> np.array([0, 1577836800], dtype='datetime64[s]')
array(['1970-01-01T00:00:00', '2020-01-01T00:00:00'],
 dtype='datetime64[s]') 

>>> np.array([0, 1577836800000]).astype('datetime64[ms]')
array(['1970-01-01T00:00:00.000', '2020-01-01T00:00:00.000'],
 dtype='datetime64[ms]') 

Datetime 类型与许多常见的 NumPy 函数一起工作，例如 arange 可用于生成日期范围。

示例

一个月的所有日期：

>>> np.arange('2005-02', '2005-03', dtype='datetime64[D]')
array(['2005-02-01', '2005-02-02', '2005-02-03', '2005-02-04',
 '2005-02-05', '2005-02-06', '2005-02-07', '2005-02-08',
 '2005-02-09', '2005-02-10', '2005-02-11', '2005-02-12',
 '2005-02-13', '2005-02-14', '2005-02-15', '2005-02-16',
 '2005-02-17', '2005-02-18', '2005-02-19', '2005-02-20',
 '2005-02-21', '2005-02-22', '2005-02-23', '2005-02-24',
 '2005-02-25', '2005-02-26', '2005-02-27', '2005-02-28'],
 dtype='datetime64[D]') 

datetime 对象表示一个特定时刻。如果两个日期时间具有不同的单位，它们仍然可能表示相同的时刻，将一个较大单位（如月）转换为较小单位（如天）被认为是一种‘安全’转换，因为时刻仍然被准确表示。

示例

>>> np.datetime64('2005') == np.datetime64('2005-01-01')
True 

>>> np.datetime64('2010-03-14T15') == np.datetime64('2010-03-14T15:00:00.00')
True 

自 NumPy 版本 1.11.0 起已弃用：NumPy 不存储时区信息。为了向后兼容，datetime64 仍然解析时区偏移量，通过转换为 UTC±00:00 (Zulu 时间) 处理。这种行为已被弃用，并将在未来引发错误。

日期时间和时间差运算

NumPy 允许两个日期时间值相减，这个操作会产生一个带有时间单位的数字。因为 NumPy 的核心中没有物理量系统，所以创建了 timedelta64 数据类型来补充 datetime64。timedelta64 的参数是一个数字，表示单位的数量，以及一个日期/时间单位，比如 (D)ay, (M)onth, (Y)ear, (h)ours, (m)inutes, 或 (s)econds。timedelta64 数据类型还接受字符串“NAT”代替数字，表示“非时间”值。

示例

>>> np.timedelta64(1, 'D')
numpy.timedelta64(1,'D') 

>>> np.timedelta64(4, 'h')
numpy.timedelta64(4,'h') 

>>> np.timedelta64('nAt')
numpy.timedelta64('NaT') 

日期时间和时间差一起提供了简单的日期时间计算方式。

示例

>>> np.datetime64('2009-01-01') - np.datetime64('2008-01-01')
numpy.timedelta64(366,'D') 

>>> np.datetime64('2009') + np.timedelta64(20, 'D')
numpy.datetime64('2009-01-21') 

>>> np.datetime64('2011-06-15T00:00') + np.timedelta64(12, 'h')
numpy.datetime64('2011-06-15T12:00') 

>>> np.timedelta64(1,'W') / np.timedelta64(1,'D')
7.0 

>>> np.timedelta64(1,'W') % np.timedelta64(10,'D')
numpy.timedelta64(7,'D') 

>>> np.datetime64('nat') - np.datetime64('2009-01-01')
numpy.timedelta64('NaT','D') 

>>> np.datetime64('2009-01-01') + np.timedelta64('nat')
numpy.datetime64('NaT') 

有两个时间差单位（‘Y’, 年和‘M’, 月）被特殊处理，因为它们代表的时间量取决于它们的使用时间。虽然时间差的天单位等同于 24 小时，但无法将月单位转换为天数，因为不同的月份有不同的天数。

示例

>>> a = np.timedelta64(1, 'Y') 

>>> np.timedelta64(a, 'M')
numpy.timedelta64(12,'M') 

>>> np.timedelta64(a, 'D')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Cannot cast NumPy timedelta64 scalar from metadata [Y] to [D] according to the rule 'same_kind' 

日期时间单位

Datetime 和 Timedelta 数据类型支持大量的时间单位，以及可以根据输入数据强制转换为任何其他单位的通用单位。

Datetimes 总是以 1970-01-01T00:00 为纪元存储。这意味着支持的日期始终是围绕纪元对称的间隔，表格中称为“时间跨度”。

跨度的长度是 64 位整数的范围乘以日期或单位的长度。例如，‘W’（周）的时间跨度恰好是‘D’（天）的时间跨度的 7 倍，而‘D’（天）的时间跨���恰好是‘h’（小时）的时间跨度的 24 倍。

这里是日期单位：

代码	含义	时间跨度（相对）	时间跨度（绝对）
Y	年	+/- 9.2e18 年	[9.2e18 BC, 9.2e18 AD]
M	月	+/- 7.6e17 年	[7.6e17 BC, 7.6e17 AD]
W	周	+/- 1.7e17 年	[1.7e17 BC, 1.7e17 AD]
D	天	+/- 2.5e16 年	[2.5e16 BC, 2.5e16 AD]

这里是时间单位：

代码	意义	时间跨度（相对）	时间跨度（绝对）
h	小时	+/- 1.0e15 年	[1.0e15 BC, 1.0e15 AD]
m	分钟	+/- 1.7e13 年	[1.7e13 BC, 1.7e13 AD]
s	秒	+/- 2.9e11 年	[2.9e11 BC, 2.9e11 AD]
ms	毫秒	+/- 2.9e8 年	[ 2.9e8 BC, 2.9e8 AD]
us / μs	微秒	+/- 2.9e5 年	[290301 BC, 294241 AD]
ns	纳秒	+/- 292 年	[ 1678 AD, 2262 AD]
ps	皮秒	+/- 106 天	[ 1969 AD, 1970 AD]
fs	飞秒	+/- 2.6 小时	[ 1969 AD, 1970 AD]
as	阿秒	+/- 9.2 秒	[ 1969 AD, 1970 AD]

工作日功能

为了使 datetime 可以在只有某些周几有效的情况下使用，NumPy 包含一组“busday”（工作日）函数。

busday 函数的默认值是只有星期一到星期五（通常的工作日）是有效日期。该实现基于包含 7 个布尔标志以指示有效日期的“weekmask”；可以使用自定义星期掩码指定其他一组有效日期。

“busday”函数还可以检查一组“假期”日期，即不是有效日期的特定日期。

函数busday_offset允许您将以‘D’（天）为单位指定的偏移应用于日期时间。

示例

>>> np.busday_offset('2011-06-23', 1)
numpy.datetime64('2011-06-24') 

>>> np.busday_offset('2011-06-23', 2)
numpy.datetime64('2011-06-27') 

当输入日期落在周末或假期时，busday_offset首先应用一个规则将日期滚动到有效的工作日，然后应用偏移。默认规则是‘raise’，简单地引���异常。最常用的规则是‘forward’和‘backward’。

示例

>>> np.busday_offset('2011-06-25', 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Non-business day date in busday_offset 

>>> np.busday_offset('2011-06-25', 0, roll='forward')
numpy.datetime64('2011-06-27') 

>>> np.busday_offset('2011-06-25', 2, roll='forward')
numpy.datetime64('2011-06-29') 

>>> np.busday_offset('2011-06-25', 0, roll='backward')
numpy.datetime64('2011-06-24') 

>>> np.busday_offset('2011-06-25', 2, roll='backward')
numpy.datetime64('2011-06-28') 

在某些情况下，必须适当使用 roll 和 offset 才能获得所需的答案。

示例

在日期之后的第一个工作日：

>>> np.busday_offset('2011-03-20', 0, roll='forward')
numpy.datetime64('2011-03-21')
>>> np.busday_offset('2011-03-22', 0, roll='forward')
numpy.datetime64('2011-03-22') 

严格在日期之后的第一个工作日：

>>> np.busday_offset('2011-03-20', 1, roll='backward')
numpy.datetime64('2011-03-21')
>>> np.busday_offset('2011-03-22', 1, roll='backward')
numpy.datetime64('2011-03-23') 

该函数还可用于计算一些特殊的日期，如假期。在加拿大和美国，母亲节是五月的第二个星期日，可以使用自定义星期掩码计算。

示例

>>> np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun')
numpy.datetime64('2012-05-13') 

当性能对于使用特定的星期掩码和假期操纵许多业务日期很重要时，有一个busdaycalendar对象以优化的形式存储必要的数据。

np.is_busday():

要测试datetime64值是否为有效日期，请使用is_busday。

示例

>>> np.is_busday(np.datetime64('2011-07-15'))  # a Friday
True
>>> np.is_busday(np.datetime64('2011-07-16')) # a Saturday
False
>>> np.is_busday(np.datetime64('2011-07-16'), weekmask="Sat Sun")
True
>>> a = np.arange(np.datetime64('2011-07-11'), np.datetime64('2011-07-18'))
>>> np.is_busday(a)
array([ True,  True,  True,  True,  True, False, False]) 

np.busday_count():

要查找指定的 datetime64 日期范围中有多少有效日期，请使用busday_count:

示例

>>> np.busday_count(np.datetime64('2011-07-11'), np.datetime64('2011-07-18'))
5
>>> np.busday_count(np.datetime64('2011-07-18'), np.datetime64('2011-07-11'))
-5 

如果你有一个 datetime64 日期值的数组，并且想知道其中有多少个是有效日期，你可以这样做：

示例

>>> a = np.arange(np.datetime64('2011-07-11'), np.datetime64('2011-07-18'))
>>> np.count_nonzero(np.is_busday(a))
5 

自定义周掩码

这里有几个自定义 weekmask 值的示例。这些示例指定了“busday”默认为周一至周五为有效日期。

一些例子：

# Positional sequences; positions are Monday through Sunday.
# Length of the sequence must be exactly 7.
weekmask = [1, 1, 1, 1, 1, 0, 0]
# list or other sequence; 0 == invalid day, 1 == valid day
weekmask = "1111100"
# string '0' == invalid day, '1' == valid day

# string abbreviations from this list: Mon Tue Wed Thu Fri Sat Sun
weekmask = "Mon Tue Wed Thu Fri"
# any amount of whitespace is allowed; abbreviations are case-sensitive.
weekmask = "MonTue Wed  Thu\tFri" 

Datetime64 的缺陷

所有天都恰好是 86400 秒长的假设使得datetime64在很大程度上与 Python 的datetime和“POSIX 时间”语义兼容；因此它们都与 UTC 时间刻度和历史时间确定性共享同样众所周知的缺陷。以下是一个简要的非穷尽总结。

• 无法解析在正闰秒期间发生的有效 UTC 时间戳。

  示例

  “2016-12-31 23:59:60 UTC”是一个闰秒，因此“2016-12-31 23:59:60.450 UTC”是一个有效的时间戳，但无法被datetime64解析：

  >>> np.datetime64("2016-12-31 23:59:60.450")
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  ValueError: Seconds out of range in datetime string "2016-12-31 23:59:60.450" 
  

• 两个 UTC 日期之间的 Timedelta64 计算可能会出现整数倍的 SI 秒错误。

  ��例

  计算“2021-01-01 12:56:23.423 UTC”和“2001-01-01 00:00:00.000 UTC”之间的 SI 秒数：

  >>> (
  ...   np.datetime64("2021-01-01 12:56:23.423")
  ...   - np.datetime64("2001-01-01")
  ... ) / np.timedelta64(1, "s")
  631198583.423 
  

  然而正确答案是631198588.423 SI 秒，因为 2001 年至 2021 年之间有 5 个闰秒。

• 过去日期的 Timedelta64 计算不会返回 SI 秒，这与预期不符。

  示例

  计算“000-01-01 UT”和“1600-01-01 UT”之间的秒数，其中 UT 是世界时：

  >>> a = np.datetime64("0000-01-01", "us")
  >>> b = np.datetime64("1600-01-01", "us")
  >>> b - a
  numpy.timedelta64(50491123200000000,'us') 
  

  计算结果为50491123200秒，是经过的天数（584388）乘以86400秒；这是与地球自转同步的时钟秒数。 SI 秒的确切值只能估算，例如使用测量地球自转：公元前 720 年至公元 2015 年，2016 年，皇家学会 A 杂志 472 期，由斯蒂芬森等人发表的数据。一个合理的估计是50491112870 ± 90秒，差异为 10330 秒。

Datetime64 约定和假设

与 Python 的date类似，日期是以当前公历日历表示的，未来和过去都无限延伸。[1] 与 Python 的date不同，它仅支持 1 AD 至 9999 AD 范围内的年份，datetime64还允许 BC 日期；BC 年份遵循天文年编号约定，即公元前 2 年编号为-1，公元前 1 年编号为 0，公元 1 年编号为 1。

时间瞬间，比如 16:23:32.234，是从午夜开始计算小时、分钟、秒和分数：即 00:00:00.000 是午夜，12:00:00.000 是中午，等等。每个日历日恰好有 86400 秒。这是一个“天真”的时间，没有明确的时区或特定的时间刻度（UT1、UTC、TAI 等）。

基本的 Datetime

创建 datetime 的最基本方法是从 ISO 8601 日期或 datetime 格式的字符串创建。还可以通过相对于 Unix 纪元（1970 年 1 月 1 日 UTC 00:00:00）的偏移量从整数创建 datetime。内部存储的单位会根据字符串的形式自动选择，并且可以是 date unit 或 time unit。日期单位是年（‘Y’）、月（‘M’）、周（‘W’）和日（‘D’），而时间单位是小时（‘h’）、分钟（‘m’）、秒（‘s’）、毫秒（‘ms’）和一些额外的 SI 前缀秒为基础的单位。datetime64数据类型还接受字符串“NAT”，大小写字母的任意组合，表示“Not A Time”值。

示例

一个简单的 ISO 日期：

>>> np.datetime64('2005-02-25')
numpy.datetime64('2005-02-25') 

从整数和日期单位开始，自 UNIX 纪元以来 1 年：

>>> np.datetime64(1, 'Y')
numpy.datetime64('1971') 

使用月作为单位：

>>> np.datetime64('2005-02')
numpy.datetime64('2005-02') 

仅指定月份，但强制使用‘天’单位：

>>> np.datetime64('2005-02', 'D')
numpy.datetime64('2005-02-01') 

从日期和时间开始：

>>> np.datetime64('2005-02-25T03:30')
numpy.datetime64('2005-02-25T03:30') 

NAT（不是时间）：

>>> np.datetime64('nat')
numpy.datetime64('NaT') 

当从字符串创建 datetime 数组时，仍然可以通过使用具有通用单位的 datetime 类型从输入中自动选择单位。

示例

>>> np.array(['2007-07-13', '2006-01-13', '2010-08-13'], dtype='datetime64')
array(['2007-07-13', '2006-01-13', '2010-08-13'], dtype='datetime64[D]') 

>>> np.array(['2001-01-01T12:00', '2002-02-03T13:56:03.172'], dtype='datetime64')
array(['2001-01-01T12:00:00.000', '2002-02-03T13:56:03.172'],
 dtype='datetime64[ms]') 

可以从表示 POSIX 时间戳的整数构建 datetime 数组，并指定给定的单位。

示例

>>> np.array([0, 1577836800], dtype='datetime64[s]')
array(['1970-01-01T00:00:00', '2020-01-01T00:00:00'],
 dtype='datetime64[s]') 

>>> np.array([0, 1577836800000]).astype('datetime64[ms]')
array(['1970-01-01T00:00:00.000', '2020-01-01T00:00:00.000'],
 dtype='datetime64[ms]') 

datetime 类型与许多常见的 NumPy 函数一起使用，例如arange可以用于生成日期范围。

示例

所有一个月的日期：

>>> np.arange('2005-02', '2005-03', dtype='datetime64[D]')
array(['2005-02-01', '2005-02-02', '2005-02-03', '2005-02-04',
 '2005-02-05', '2005-02-06', '2005-02-07', '2005-02-08',
 '2005-02-09', '2005-02-10', '2005-02-11', '2005-02-12',
 '2005-02-13', '2005-02-14', '2005-02-15', '2005-02-16',
 '2005-02-17', '2005-02-18', '2005-02-19', '2005-02-20',
 '2005-02-21', '2005-02-22', '2005-02-23', '2005-02-24',
 '2005-02-25', '2005-02-26', '2005-02-27', '2005-02-28'],
 dtype='datetime64[D]') 

datetime 对象表示时间中的一个瞬间。如果两个 datetime 具有不同的单位，它们仍然可能表示相同的时间点，并且从较大的单位（如月）转换为较小的单位（如天）被认为是一种“安全”的转换，因为时间点仍然被准确表示。

示例

>>> np.datetime64('2005') == np.datetime64('2005-01-01')
True 

>>> np.datetime64('2010-03-14T15') == np.datetime64('2010-03-14T15:00:00.00')
True 

自版本 1.11.0 起弃用：NumPy 不存储时区信息。为了向后兼容，datetime64 仍然解析时区偏移量，它通过转换为 UTC±00:00（Zulu 时间）来处理。这种行为已被弃用，并将在未来引发错误。

Datetime 和 Timedelta 算术

NumPy 允许对两个日期时间值进行减法运算，这个操作会产生一个带有时间单位的数字。由于 NumPy 的核心中没有物理量系统，因此创建了timedelta64数据类型来补充datetime64。timedelta64的参数是一个数字，表示单位的数量，以及一个日期/时间单位，比如（D）天，（M）月，（Y）年，（h）小时，（m）分钟或（s）秒。timedelta64数据类型还接受字符串“NAT”来代替数字，表示“非时间”值。

示例

>>> np.timedelta64(1, 'D')
numpy.timedelta64(1,'D') 

>>> np.timedelta64(4, 'h')
numpy.timedelta64(4,'h') 

>>> np.timedelta64('nAt')
numpy.timedelta64('NaT') 

日期时间和时间差一起提供了简单日期时间计算的方法。

示例

>>> np.datetime64('2009-01-01') - np.datetime64('2008-01-01')
numpy.timedelta64(366,'D') 

>>> np.datetime64('2009') + np.timedelta64(20, 'D')
numpy.datetime64('2009-01-21') 

>>> np.datetime64('2011-06-15T00:00') + np.timedelta64(12, 'h')
numpy.datetime64('2011-06-15T12:00') 

>>> np.timedelta64(1,'W') / np.timedelta64(1,'D')
7.0 

>>> np.timedelta64(1,'W') % np.timedelta64(10,'D')
numpy.timedelta64(7,'D') 

>>> np.datetime64('nat') - np.datetime64('2009-01-01')
numpy.timedelta64('NaT','D') 

>>> np.datetime64('2009-01-01') + np.timedelta64('nat')
numpy.datetime64('NaT') 

有两个时间差单位（‘Y’，年和‘M’，月）被特殊处理，因为它们代表的时间量取决于它们何时使用。虽然时间差的天单位等同于 24 小时，但无法将月单位转换为天数，因为不同的月份有不同的天数。

示例

>>> a = np.timedelta64(1, 'Y') 

>>> np.timedelta64(a, 'M')
numpy.timedelta64(12,'M') 

>>> np.timedelta64(a, 'D')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Cannot cast NumPy timedelta64 scalar from metadata [Y] to [D] according to the rule 'same_kind' 

日期时间单位

日期时间和时间差数据类型支持大量的时间单位，以及可以根据输入数据强制转换为任何其他单位的通用单位。

日期时间始终以 1970-01-01T00:00 为基准。这意味着支持的日期始终是围绕基准对称的时间间隔，称为下表中的“时间跨度”。

跨度的长度是 64 位整数的范围乘以日期或单位的长度。例如，‘W’（周）的时间跨度恰好是‘D’（天）的时间跨度的 7 倍，而‘D’（天）的时间跨度恰好是‘h’（小时）的时间跨度的 24 倍。

这里是日期单位：

代码	含义	时间跨度（相对）	时间跨度（绝对）
Y	年	+/- 9.2e18 年	[9.2e18 BC, 9.2e18 AD]
M	月	+/- 7.6e17 年	[7.6e17 BC, 7.6e17 AD]
W	周	+/- 1.7e17 年	[1.7e17 BC, 1.7e17 AD]
D	天	+/- 2.5e16 年	[2.5e16 BC, 2.5e16 AD]

这里是时间单位：

代码	含义	时间跨度（相对）	时间跨度（绝对）
h	小时	+/- 1.0e15 年	[1.0e15 BC, 1.0e15 AD]
m	分钟	+/- 1.7e13 年	[1.7e13 BC, 1.7e13 AD]
s	秒	+/- 2.9e11 年	[2.9e11 BC, 2.9e11 AD]
ms	毫秒	+/- 2.9e8 年	[ 2.9e8 BC, 2.9e8 AD]
us / μs	微秒	+/- 2.9e5 年	[290301 BC, 294241 AD]
ns	纳秒	+/- 292 年	[ 1678 年, 2262 年]
ps	皮秒	+/- 106 天	[ 1969 年, 1970 年]
fs	飞秒	+/- 2.6 小时	[ 1969 年, 1970 年]
as	阿秒	+/- 9.2 秒	[ 1969 年, 1970 年]

工作日功能

为了允许日期时间在只有某些星期几有效的情况下使用，NumPy 包含一组“busday”（工作日）函数。

busday 函数的默认值是只有星期一到星期五（通常的工作日）是有效日期。实现基于包含 7 个布尔标志以指示有效日期的“weekmask”；可以使用自定义星期掩码指定其他一组有效日��。

“busday”函数还可以检查一组“假期”日期，这些日期不是有效日期。

函数busday_offset允许您将以“D”（天）为单位的偏移应用于工作日的日期时间。

示例

>>> np.busday_offset('2011-06-23', 1)
numpy.datetime64('2011-06-24') 

>>> np.busday_offset('2011-06-23', 2)
numpy.datetime64('2011-06-27') 

当输入日期落在周末或假期时，busday_offset首先应用规则将日期滚动到有效的工作日，然后应用偏移。默认规则是“raise”，简单地引发异常。最常用的规则是“forward”和“backward”。

示例

>>> np.busday_offset('2011-06-25', 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Non-business day date in busday_offset 

>>> np.busday_offset('2011-06-25', 0, roll='forward')
numpy.datetime64('2011-06-27') 

>>> np.busday_offset('2011-06-25', 2, roll='forward')
numpy.datetime64('2011-06-29') 

>>> np.busday_offset('2011-06-25', 0, roll='backward')
numpy.datetime64('2011-06-24') 

>>> np.busday_offset('2011-06-25', 2, roll='backward')
numpy.datetime64('2011-06-28') 

在某些情况下，需要适当使用滚动和偏移来获得所需的答案。

示例

日期后的第一个工作日：

>>> np.busday_offset('2011-03-20', 0, roll='forward')
numpy.datetime64('2011-03-21')
>>> np.busday_offset('2011-03-22', 0, roll='forward')
numpy.datetime64('2011-03-22') 

日期后的第一个严格的工作日：

>>> np.busday_offset('2011-03-20', 1, roll='backward')
numpy.datetime64('2011-03-21')
>>> np.busday_offset('2011-03-22', 1, roll='backward')
numpy.datetime64('2011-03-23') 

该函数还可用于计算一些特殊日期，如假期。在加拿大和美国，母亲节是五月的第二个星期日，可以使用自定义的星期掩码来计算。

示例

>>> np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun')
numpy.datetime64('2012-05-13') 

当对于使用一种特定的星期掩码和假期操作许多工作日期时性能很重要时，有一个对象busdaycalendar以优化的形式存储必要的数据。

np.is_busday():

要测试datetime64值是否为有效日期，请使用is_busday。

示例

>>> np.is_busday(np.datetime64('2011-07-15'))  # a Friday
True
>>> np.is_busday(np.datetime64('2011-07-16')) # a Saturday
False
>>> np.is_busday(np.datetime64('2011-07-16'), weekmask="Sat Sun")
True
>>> a = np.arange(np.datetime64('2011-07-11'), np.datetime64('2011-07-18'))
>>> np.is_busday(a)
array([ True,  True,  True,  True,  True, False, False]) 

np.busday_count():

要查找指定范围的 datetime64 日期中有多少个有效日期，请使用busday_count:

示例

>>> np.busday_count(np.datetime64('2011-07-11'), np.datetime64('2011-07-18'))
5
>>> np.busday_count(np.datetime64('2011-07-18'), np.datetime64('2011-07-11'))
-5 

如果您有一个 datetime64 日期值的数组，并且想要计算其中有多少个有效日期，可以这样做：

示例

>>> a = np.arange(np.datetime64('2011-07-11'), np.datetime64('2011-07-18'))
>>> np.count_nonzero(np.is_busday(a))
5 

自定义星期掩码

这里有几个自定义星期掩码值的示例。这些示例指定了星期一到星期五为有效日期的“busday”默认值。

一些示例：

# Positional sequences; positions are Monday through Sunday.
# Length of the sequence must be exactly 7.
weekmask = [1, 1, 1, 1, 1, 0, 0]
# list or other sequence; 0 == invalid day, 1 == valid day
weekmask = "1111100"
# string '0' == invalid day, '1' == valid day

# string abbreviations from this list: Mon Tue Wed Thu Fri Sat Sun
weekmask = "Mon Tue Wed Thu Fri"
# any amount of whitespace is allowed; abbreviations are case-sensitive.
weekmask = "MonTue Wed  Thu\tFri" 

np.is_busday():

要测试datetime64值是否为有效日期，请使用is_busday。

示例

>>> np.is_busday(np.datetime64('2011-07-15'))  # a Friday
True
>>> np.is_busday(np.datetime64('2011-07-16')) # a Saturday
False
>>> np.is_busday(np.datetime64('2011-07-16'), weekmask="Sat Sun")
True
>>> a = np.arange(np.datetime64('2011-07-11'), np.datetime64('2011-07-18'))
>>> np.is_busday(a)
array([ True,  True,  True,  True,  True, False, False]) 

np.busday_count():

要查找指定范围的 datetime64 日期中有多少个有效日期，请使用busday_count:

示例

>>> np.busday_count(np.datetime64('2011-07-11'), np.datetime64('2011-07-18'))
5
>>> np.busday_count(np.datetime64('2011-07-18'), np.datetime64('2011-07-11'))
-5 

如果你有一个 datetime64 日期值的数组，并且想知道其中有多少个是有效日期，你可以这样做：

例子

>>> a = np.arange(np.datetime64('2011-07-11'), np.datetime64('2011-07-18'))
>>> np.count_nonzero(np.is_busday(a))
5 

自定义周掩码

这里有几个自定义周掩码值的例子。这些例子指定了周一到周五作为有效日期的“busday”默认值。

一些例子：

# Positional sequences; positions are Monday through Sunday.
# Length of the sequence must be exactly 7.
weekmask = [1, 1, 1, 1, 1, 0, 0]
# list or other sequence; 0 == invalid day, 1 == valid day
weekmask = "1111100"
# string '0' == invalid day, '1' == valid day

# string abbreviations from this list: Mon Tue Wed Thu Fri Sat Sun
weekmask = "Mon Tue Wed Thu Fri"
# any amount of whitespace is allowed; abbreviations are case-sensitive.
weekmask = "MonTue Wed  Thu\tFri" 

Datetime64 缺陷

所有天数都恰好为 86400 秒长的假设使得datetime64与 Python datetime以及“POSIX 时间”语义基本兼容；因此它们都具有相同的关于 UTC 时间尺度和历史时间确定性的众所周知的缺陷。以下是一个简要的非详尽总结。

• 无法解析发生在正闰秒期间的有效 UTC 时间戳。

  例子

  “2016-12-31 23:59:60 UTC”是一个闰秒，因此“2016-12-31 23:59:60.450 UTC”是一个有效的时间戳，但无法被datetime64解析：

  >>> np.datetime64("2016-12-31 23:59:60.450")
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  ValueError: Seconds out of range in datetime string "2016-12-31 23:59:60.450" 
  

• 两个 UTC 日期之间的 Timedelta64 计算可能会出现整数 SI 秒的错误。

  例子

  计算“2021-01-01 12:56:23.423 UTC”和“2001-01-01 00:00:00.000 UTC”之间的 SI 秒数：

  >>> (
  ...   np.datetime64("2021-01-01 12:56:23.423")
  ...   - np.datetime64("2001-01-01")
  ... ) / np.timedelta64(1, "s")
  631198583.423 
  

  然而正确答案是631198588.423 SI 秒，因为 2001 年至 2021 年之间有 5 个闰秒。

• 过去日期的 Timedelta64 计算不会返回 SI 秒，这与人们的预期不符。

  例子

  计算“000-01-01 UT”和“1600-01-01 UT”之间的秒数，其中 UT 是世界时：

  >>> a = np.datetime64("0000-01-01", "us")
  >>> b = np.datetime64("1600-01-01", "us")
  >>> b - a
  numpy.timedelta64(50491123200000000,'us') 
  

  计算结果为50491123200秒，是通过天数（584388）乘以86400秒得到的；这是一个与地球自转同步的时钟的秒数。准确的 SI 秒值只能估算，例如使用《测量地球自转：公元前 720 年至公元 2015 年，2016 年，皇家学会 A 部门的论文》中发布的数据。一个合理的估计是50491112870 ± 90秒，差异为 10330 秒。

数组 API 标准兼容性

原文：numpy.org/doc/1.26/reference/array_api.html

注意

numpy.array_api 模块仍处于实验阶段。请参阅 NEP 47。

NumPy 在 numpy.array_api 中包含了 array API standard 的参考实现。NEP 47 描述了在 NumPy 中实现数组 API 标准的动机和范围。

numpy.array_api 模块作为数组 API 标准的最小参考实现。作为最小实现，该模块仅实现规范明确要求的内容。规范允许某些内容，但在 numpy.array_api 中明确禁止。这样可以使该模块成为数组 API 标准的用户的参考实现。任何使用数组 API 的消费者都可以针对 numpy.array_api 测试其代码，并确保他们没有使用规范未保证的功能，这些功能可能不会出现在其他符合规范的库中。

此处未记录 numpy.array_api 模块。要查看数组 API 规范中包含的函数列表，请参考 array API standard。numpy.array_api 实现功能完整，因此已实现规范中描述的所有功能。

numpy.array_api 与 numpy 之间的差异表

本表概述了 numpy.array_api 与主 numpy 命名空间之间的主要区别。有三种类型的差异：

1. 严格性。仅为了使 numpy.array_api 成为严格的、最小的实现而执行的事项。实际上，这些事项并不是规范要求的，其他符合规范的库可能不会遵循它们。在大多数情况下，规范不指定或要求给定域之外的任何行为。主 numpy 命名空间不需要做任何更改才能符合规范。

2. 兼容。可以添加到主 numpy 命名空间而不会破坏向后兼容性的事项。

3. Breaking。如果在主 numpy 命名空间中实现，可能会破坏向后兼容性的事项。

名称差异

许多函数在规范中从 NumPy 重命名。除非另有说明，否则这些函数在行为上是相同的，因此都是兼容的更改。

函数名称更改

数组 API 中以下函数的名称与 NumPy 中不同

Array API 名称	NumPy 命名空间名称	注释
acos	arccos
acosh	arccosh
asin	arcsin
asinh	arcsinh
atan	arctan
atan2	arctan2
atanh	arctanh
bitwise_left_shift	left_shift
bitwise_invert	invert
bitwise_right_shift	right_shift
bool	bool_	这是一个破坏性的更改，因为 np.bool 目前是内置 bool 的弃用别名。
concat	concatenate
matrix_norm 和 vector_norm	norm	matrix_norm 和 vector_norm 每个只执行 np.norm 的有限子集。
permute_dims	transpose	与 np.transpose 不同，permute_dims 的 axis 关键字参数是必需的。
pow	power
unique_all、unique_counts、unique_inverse 和 unique_values	unique	每个等效于设置了特定标志的 np.unique。

函数而非方法

• astype 是数组 API 中的一个函数，而在 numpy 中是 ndarray 的方法。

linalg 命名空间差异

这些函数在数组 API 的 linalg 子命名空间中，但在 NumPy 中仅在顶层命名空间中：

• cross

• diagonal

• matmul (*)

• outer

• tensordot (*)

• trace

(*): 这些函数也在数组 API 的顶层命名空间中。

关键字参数重命名

以下函数的关键字参数已被重命名。除非另有说明，否则关键字参数的功能是相同的。具有相同语义定义的重命名关键字参数可能被视为兼容或破坏，具体取决于更改的实现方式。

请注意，此页面不列出主 numpy 命名空间中存在但不在数组 API 中的函数关键字参数。出于严格性的考虑，这些关键字参数被从 numpy.array_api 中省略，因为规范允许函数包含额外的关键字参数。

函数	数组 API 关键字名称	NumPy 关键字名称	备注
argsort 和 sort	stable	kind	stable 和 kind 的定义不同，以及默认值也不同。默认值的更改使得这是一个破坏性的更改。请参阅集合函数差异。
matrix_rank	rtol	tol	rtol 和 tol 的定义不同，以及默认值也不同。默认值的更改使得这是一个破坏性的更改。请参阅线性代数差异。
pinv	rtol	rcond	rtol 和 rcond 的定义相同，但默认值不同，这是一个破坏性的更改。请参阅线性代数差异。
std 和 var	correction	ddof
reshape	shape	newshape	该参数可以作为 NumPy 和数组 API 的位置参数或关键字参数传递。

类型提升差异

类型提升是 NumPy 与规范最大的差异之一。最显著的区别是 NumPy 在许多情况下进行基于值的转换。规范明确禁止基于值的转换。在数组 API 中，任何操作的结果类型始终完全由输入类型确定，与值或形状无关。

特性	类型	备注
有限的数据类型集合。	严格性	numpy.array_api只实现了那些规范要求的数据类型。
操作符（比如+）只接受匹配的标量类型。	严格性	例如，<int32 array> + 1.0是不允许的。查看混合数组和 Python 标量的规范规则。
操作符（比如+）与 Python 标量始终返回与数组相同的数据类型。	破坏性变化	例如，numpy.array_api.asarray(0., dtype=float32) + 1e64是一个float32数组。
当左侧将被提升时，不允许原地操作符。	破坏性变化	例如：a = np.array(1, dtype=np.int8); a += np.array(1, dtype=np.int16)。规范明确禁止这种情况。
当右侧操作数无法广播到左侧操作数的形状时，不允许原地操作符。	严格性	这种所谓的“反向广播”不应该被允许。例如：a = np.empty((2, 3, 4)); a += np.empty((3, 4))应该报错。参见github.com/numpy/numpy/issues/10404。
操作符的int提升仅对在数据类型范围内的整数指定。	严格性	numpy.array_api回退到np.ndarray的行为（要么转换，要么引发OverflowError）。
__pow__和__rpow__不会对 0 维数组进行基于值的转换。	破坏性变化	例如，np.array(0., dtype=float32)**np.array(0., dtype=float64)是float32。请注意，这是针对 0 维数组的基于值的转换，而不是标量。
没有跨类型的转换。	严格性	即，布尔值、整数和浮点数数据类型不会相互转换，除非使用astype显式转换（这与 Python 标量的行为不同）。
不允许将无符号整数数据类型转换为浮点数据类型（例如，int64 + uint64 -> float64）。	严格性
can_cast和result_type受限制。	严格性	numpy.array_api实现不允许跨类型转换。
当dtype=None时，sum和prod总是将float32向上转换为float64。	破坏性变化

索引差异

规范仅要求一部分索引，但规范中的所有索引规则与 NumPy 更广泛的索引规则兼容。

功能	类型	注释
没有隐式的省略号（...）。	严格性	如果索引不包含省略号，则必须索引所有轴。

| 切片的起始和结束位置不能超出范围。 | 严格性 | 对于切片i:j:k，只允许以下情况：

• 省略i或j（None）。

• -n <= i <= max(0, n - 1)。

• 对于k > 0或省略的k（None），-n <= j <= n。

• 对于k < 0，-n - 1 <= j <= max(0, n - 1)。

|

布尔数组索引仅允许作为唯一索引。	严格性
整数数组索引根本不允许。	严格性	除了 0-D 数组，它们被视为整数之外。

类型严格性

numpy.array_api 中的函数限制其输入仅限于规范明确要求的数据类型，即使包装的对应 NumPy 函数允许更广泛的数据类型。在这里，我们列出每个函数及允许在 numpy.array_api 中的数据类型。这些是严格性差异，因为规范不要求其他数据类型会导致错误。这里的类别定义如下：

• 浮点数：float32 或 float64。

• 整数：任何有符号或无符号整数数据类型（int8、int16、int32、int64、uint8、uint16、uint32或uint64）。

• 布尔值：bool。

• 整数或布尔值：任何有符号或无符号整数数据类型，或bool。对于两个参数的函数，两个参数必须都是整数或都是bool。

• 数值：任何整数或浮点数数据类型。对于两个参数的函数，两个参数必须都是整数或都是浮点数。

• 所有：上述数据类型类别中的任何一种。对于两个参数的函数，两个参数必须是相同类型（整数、浮点数或布尔值）。

在所有情况下，返回的数据类型根据规范中概述的规则选择，并且与 NumPy 对于任何允许的输入数据类型的返回数据类型没有区别，除非在下面的子节中明确提到的情况。

逐元素函数

函数名称	数据类型
abs	数值
acos	浮点数
acosh	浮点数
add	数值
asin (*)	浮点数
asinh (*)	浮点数
atan (*)	浮点数
atan2 (*)	浮点数
atanh (*)	浮点数
bitwise_and	整数或布尔值
bitwise_invert	整数或布尔值
bitwise_left_shift (*)	整数
bitwise_or	整数或布尔值
bitwise_right_shift (*)	整数
bitwise_xor	整数或布尔值
ceil	数值
cos	浮点数
cosh	浮点数
divide	浮点数
equal	所有
exp	浮点数
expm1	浮点数
floor	数值
floor_divide	数值
greater	数值
greater_equal	数值
isfinite	数值
isinf	数值
isnan	数值
less	数值
less_equal	数值
log	浮点数
logaddexp	浮点数
log10	浮点数
log1p	浮点数
log2	浮点数
logical_and	布尔值
logical_not	布尔值
logical_or	布尔值
logical_xor	布尔值
multiply	数值
negative	数值
not_equal	所有
positive	数值
pow (*)	数值
remainder	数值
round	数值型
sign	数值型
sin	浮点数
sinh	浮点数
sqrt	浮点数
square	数值型
subtract	数值型
tan	浮点数
tanh	浮点数
trunc	数值型

(*) 这些函数与主numpy命名空间中的名称不同。请参见函数名称更改。

创建函数

函数名称	数据类型
meshgrid	任意类型（所有输入数据类型必须相同）

线性代数函数

函数名称	数据类型
cholesky	浮点数
cross	数值型
det	浮点数
diagonal	任意类型
eigh	浮点数
eighvals	浮点数
inv	浮点数
matmul	数值型
matrix_norm (*)	浮点数
matrix_power	浮点数
matrix_rank	浮点数
matrix_transpose (**)	任意类型
outer	数值型
pinv	浮点数
qr	浮点数
slogdet	浮点数
solve	浮点数
svd	浮点数
svdvals (**)	浮点数
tensordot	数值型
trace	数值型
vecdot (**)	数值型
vector_norm (*)	浮点数

(*) 这些函数从主numpy命名空间中的norm中拆分出来。请参见函数名称更改。

(**) 这些函数是数组 API 中的新功能，不在主numpy命名空间中。

数组对象

数组对象上的所有特殊__operator__方法的行为与它们对应的函数完全相同（请参见规范以获取哪些方法对应哪些函数的列表）。唯一的例外是运算符根据规范中概述的规则明确允许 Python 标量（请参见类型提升差异）。

数组对象差异

特征	类型	注释
无数组标量	严格性	规范中没有数组标量，只有 0-D 数组。但是，除了类型提升差异中概述的提升差异外，标量在规范中作为 0-D 数组进行鸭子类型。它们是不可变的，但规范不要求可变性。
bool()、int()和float()仅适用于 0-D 数组。	严格性	请参见github.com/numpy/numpy/issues/10404。
__imatmul__	兼容	np.ndarray目前未实现__imatmul。请注意，仅在不改变a的形状时才应定义a @= b。
用于矩阵转置的 mT 属性。	兼容	参见mT 的规范定义。
如果输入不是二维的，则 T 属性应报错。	变动	参见规范中的注释。
新方法 to_device 和属性 device	兼容	这些方法实际上不会起作用，因为 NumPy 只支持 CPU。

创建函数差异

特性	类型	注释
asarray 的 copy 关键字参数	兼容
所有数组创建函数（asarray、arange、empty、empty_like、eye、full、full_like、linspace、ones、ones_like、zeros 和 zeros_like）新增了 device 关键字参数。	兼容	device 实际上不会起作用，因为 NumPy 只支持 CPU。

逐元素函数差异

特性	类型	注释
各种函数已更名。	兼容	参见函数名称更改。
仅对给定输入类型组合定义逐元素函数。	严格性	参见类型严格性。
bitwise_left_shift 和 bitwise_right_shift 仅对 x2 非负数定义。	严格性
ceil、floor 和 trunc 在整数输入时返回整数。	变动	np.ceil、np.floor 和 np.trunc 在整数输入时返回浮点数数据类型。

线性代数差异

特性	类型	注释
cholesky 包括一个 upper 关键字参数。	兼容
cross 不允许大小为 2 的向量（仅允许大小为 3）。	变动
diagonal 操作在最后两个轴上。	变动	严格来说这可能是兼容的，因为 diagonal 已经移动到 linalg 命名空间。
eigh、qr、slogdet 和 svd 返回一个命名元组。	兼容	相应的 numpy 函数返回一个 tuple，其中结果数组的顺序相同。
新增了 matrix_norm 和 vector_norm 函数。	兼容	norm 函数已从数组 API 中省略，并分为 matrix_norm 用于矩阵范数和 vector_norm 用于向量范数。请注意，vector_norm 支持任意数量的轴，而 np.linalg.norm 仅支持单个轴用于向量范数。
matrix_rank 具有 rtol 关键字参数而不是 tol。	破坏性变化	在数组 API 中，rtol 会过滤比 rtol * largest_singular_value 小的奇异值。在 np.linalg.matrix_rank 中，tol 会过滤比 tol 小的奇异值。此外，rtol 的默认值为 max(M, N) * eps，而 np.linalg.matrix_rank 中 tol 的默认值为 S.max() * max(M, N) * eps，其中 S 是输入的奇异值。新标志名称是兼容的，但默认更改是破坏性的
matrix_rank 不支持 1 维数组。	破坏性变化
新功能 matrix_transpose。	兼容性	与 np.transpose 不同，matrix_transpose 仅对最后两个轴进行转置。请参阅 规范定义
outer 仅支持 1 维数组。	破坏性变化	规范目前仅指定了对 1 维数组的行为，但未来的行为可能是广播，而不是展平，这是 np.outer 的行为。
pinv 具有 rtol 关键字参数而不是 rcond	破坏性变化	rtol 和 rcond 的含义相同，但 rtol 的默认值为 max(M, N) * eps，而 rcond 的默认值为 1e-15。 新标志名称是兼容的，但默认更改是破坏性的。
solve 仅在 x2 确切为 1 维时才接受作为向量。	破坏性变化	np.linalg.solve 的行为是模糊的。有关更多详细信息，请参阅 此 numpy 问题 和 此数组 API 规范问题。
新功能 svdvals。	兼容性	等效于 np.linalg.svd(compute_uv=False)。
tensordot 的 axis 关键字必须是���组。	兼容性	在 np.tensordot 中，它也可以是数组或类似数组。
trace 在最后两个轴上操作。	破坏性变化	np.trace 默认在前两个轴上操作。请注意，数组 API 的 trace 不允许指定要操作的轴。

操作函数差异

特征	类型	注释
各种函数已被重命名	兼容性	请参阅 函数名称更改。
concat 具有与 np.concatenate 不同的默认转换规则	严格性	无跨类型转换。对标量的值基转换无效（当 axis=None 时）。
stack 具有与 np.stack 不同的默认转换规则	严格性	无跨类型转换。
新功能 permute_dims。	兼容性	与 np.transpose 不同，permute_dims 的 axis 关键字参数是必需的。
reshape 函数具有 copy 关键字参数	兼容性	请参阅 github.com/numpy/numpy/issues/9818。

集合函数差异

特性	类型	注释
新函数 unique_all、unique_counts、unique_inverse 和 unique_values。	兼容	参见 函数名称更改。
四个 unique_* 函数返回一个命名元组。	兼容
unique_all 和 unique_indices 返回的索引与 x 具有相同的形状。	兼容	参见 github.com/numpy/numpy/issues/20638。

集合函数差异

特性	类型	注释
argsort 和 sort 有一个 stable 关键字参数，而不是 kind。	破坏性变化	stable 是一个布尔关键字参数，默认为 True。 kind 接受一个字符串，默认为 "quicksort"。 stable=True 等同于 kind="stable"，kind=False 等同于 kind="quicksort"，尽管当 stable=False 时允许使用任何排序算法。 新的标志名称是兼容的，但默认更改是破坏性的。
argsort 和 sort 有一个 descending 关键字参数。	兼容

统计函数差异

特性	类型	注释
当 dtype=None 时，sum 和 prod 总是将 float32 上转型��� float64。	破坏性变化
std 和 var 函数有一个 correction 关键字参数，而不是 ddof。	兼容

其他差异

特性	类型	注释
数据类型只能以 dtype 对象的形式拼写。	严格性	例如，numpy.array_api.asarray([0], dtype='int32') 是不允许的。
asarray 在任何函数中都不会被隐式调用。	严格性	例外情况是 Python 运算符，在某些情况下接受 Python 标量（参见 类型提升差异）。
tril 和 triu 要求输入至少为 2-D。	严格性
finfo() 返回类型使用 float 来表示各种属性。	严格性	规范允许鸭子类型，因此 finfo 返回 dtype 标量被认为与 float 兼容。

| 每个函数中的位置参数都是仅限位置的。 | 破坏性变化 | 查看每个函数的确切签名规范。请注意，NumPy 的通用函数已经使用了仅限位置的参数，但像 asarray 这样的非通用函数通常不会使用。 | ## numpy.array_api 与 numpy 之间的差异表

这张表概述了 numpy.array_api 与主要 numpy 命名空间之间的主要差异。有三种类型的差异：

1. 严格性。这些只是为了使 numpy.array_api 成为一个严格、最小的实现。它们实际上并不是规范要求的，其他符合规范的库可能不会遵循它们。在大多数情况下，规范并不指定或要求给定领域之外的任何行为。主要的 numpy 命名空间不需要做任何改变才能符合这些规范。

2. 兼容。这些内容可以添加到主numpy命名空间而不会破坏向后兼容性。

3. 破坏性。如果在主numpy命名空间中实现，可能会破坏向后兼容性的内容。

名称差异

许多函数在规范中从 NumPy 中改名。除非另有说明，否则这些函数在行为上是完全相同的，因此都是兼容的更改。

函数名称更改

数组 API 中以下函数的命名方式不同

数组 API 名称	NumPy 命名空间名称	备注
acos	arccos
acosh	arccosh
asin	arcsin
asinh	arcsinh
atan	arctan
atan2	arctan2
atanh	arctanh
bitwise_left_shift	left_shift
bitwise_invert	invert
bitwise_right_shift	right_shift
bool	bool_	这是破坏性的，因为np.bool当前是内置bool的弃用别名。
concat	concatenate
matrix_norm和vector_norm	norm	matrix_norm和vector_norm各自只执行np.norm的有限子集。
permute_dims	transpose	与np.transpose不同，permute_dims需要axis关键字参数。
pow	power
unique_all, unique_counts, unique_inverse和unique_values	unique	每个函数等同于设置了特定标志的np.unique。

函数而非方法

• astype是数组 API 中的一个函数，而在numpy中是ndarray的一个方法。

linalg命名空间差异

这些函数在数组 API 的linalg子命名空间中，但在 NumPy 中仅在顶层命名空间中：

• cross

• diagonal

• matmul (*)

• outer

• tensordot (*)

• trace

(*): 这些函数也在数组 API 的顶层命名空间中。

关键字参数重命名

以下函数具有重命名的关键字参数。除非另有说明，关键字参数的功能是相同的。具有相同语义定义的重命名关键字参数可能被视为兼容或破坏性，具体取决于更改的实现方式。

请注意，此页面不列出在数组 API 中但不在主numpy命名空间中的函数关键字参数。出于严格性的考虑，这些关键字参数在numpy.array_api中被省略，因为规范允许函数包含额外的关键字参数，而不仅限于所需的参数。

函数	数组 API 关键字名称	NumPy 关键字名称	备注
argsort和sort	stable	kind	stable和kind的定义不同，以及默认值也不同。默认值的更改使得这是破坏性的。参见集合函数差异。
matrix_rank	rtol	tol	rtol 和 tol 的定义不同，以及默认值。默认值的更改使这个破坏性的。请参阅线性代数差异。
pinv	rtol	rcond	rtol 和 rcond 的定义相同，但它们的默认值不同，导致这是破坏性的。请参阅线性代数差异。
std 和 var	correction	ddof
reshape	shape	newshape	参数可以作为 NumPy 和数组 API 的位置参数或关键字参数传递。

类型提升差异

类型提升是 NumPy 与规范最大的差异领域。最显著的区别是 NumPy 在许多情况下进行基于值的转换。规范明确禁止基于值的转换。在数组 API 中，任何操作的结果类型始终完全由输入类型确定，与值或形状无关。

特征	类型	注释
---	---	---
有限的 dtype 集合。	严格性	numpy.array_api仅实现了规范所需的那些 dtype。
运算符（如+）与 Python 标量仅接受匹配的标量类型。	严格性	例如，<int32 array> + 1.0 是不允许的。请参阅混合数组和 Python 标量的规范规则。
运算符（如+）与 Python 标量始终返回与数组相同的 dtype。	破坏性的	例如，numpy.array_api.asarray(0., dtype=float32) + 1e64 是一个 float32 数组。
当左侧将被提升时，不允许原地操作符。	破坏性的	例如：a = np.array(1, dtype=np.int8); a += np.array(1, dtype=np.int16)。规范明确禁止这样做。
当右侧操作数无法广播到左侧操作数的形状时，不允许原地操作符。	严格性	这种所谓的“反向广播”不应该被允许。例如：a = np.empty((2, 3, 4)); a += np.empty((3, 4)) 应该报错。请参阅github.com/numpy/numpy/issues/10404。
运算符的int提升仅对在 dtype 范围内的整数指定。	严格性	numpy.array_api回退到np.ndarray行为（要么转换，要么引发OverflowError）。
__pow__ 和 __rpow__ 不对 0-D 数组进行基于值的转换。	破坏性的	例如，np.array(0., dtype=float32)**np.array(0., dtype=float64) 是 float32。请注意，这是对 0-D 数组进行基于值的转换，而不是标量。
不允许不同类型之间的转换。	严格性	即，布尔值、整数和浮点数类型不会相互转换，除非明确使用 astype（这与 Python 标量的行为不同）。
不允许将无符号整数类型转换为浮点类型（例如，int64 + uint64 -> float64）。	严格性
can_cast 和 result_type 受限。	严格性	numpy.array_api 实现不允许不同类型之间的转换。
sum 和 prod 在 dtype=None 时总是将 float32 上转换为 float64。	破坏性

索引差异

规范要求只使用索引的子集，但规范中的所有索引规则与 NumPy 更广泛的索引规则兼容。

特征	类型	备注
不允许隐式省略号（...）。	严格性	如果索引不包括省略号，则必须对所有轴进行索引。

| 切片的起始和结束不能超出边界。 | 严格性 | 对于切片 i:j:k，只允许以下情况：

• 省略 i 或 j（None）。

• -n <= i <= max(0, n - 1)。

• 对于 k > 0 或省略 k（None），-n <= j <= n。

• 对于 k < 0，-n - 1 <= j <= max(0, n - 1)。

|

仅允许布尔数组索引作为唯一索引。	严格性
整数数组索引根本不允许。	严格性	除了被视为整数的 0-D 数组之外。

类型严格性

numpy.array_api 中的函数将它们的输入限制为规范明确要求的那些数据类型，即使包装的对应 NumPy 函数允许更广泛的数据类型。在这里，我们列出每个函数及在 numpy.array_api 中允许的数据类型。这些是严格性差异，因为规范并不要求其他数据类型会导致错误。这里的类别定义如下：

• 浮点数：float32 或 float64。

• 整数：任何有符号或无符号整数类型（int8、int16、int32、int64、uint8、uint16、uint32 或 uint64）。

• 布尔值：bool。

• 整数或布尔值：任何有符号或无符号整数类型，或 bool。对于两个参数的函数，两个参数必须都是整数或都是 bool。

• 数值：任何整数或浮点数类型。对于两个参数的函数，两个参数必须都是整数或都是浮点数。

• 全部：上述数据类型类别中的任何类型。对于两个参数的函数，两个参数必须是相同类型（整数、浮点数或布尔值）。

在所有情况下，返回的数据类型根据规范中概述的规则选择，并且对于允许的任何输入数据类型，与 NumPy 的返回数据类型没有区别，除非在下面的子节中明确提到的情况。

逐元素函数

函数名称	数据类型
abs	数值
acos	浮点数
acosh	浮点数
add	数值
asin (*)	浮点数
asinh (*)	浮点数
atan (*)	浮点数
atan2 (*)	浮点数
atanh (*)	浮点数
bitwise_and	整数或布尔值
bitwise_invert	整数或布尔值
bitwise_left_shift (*)	整数
bitwise_or	整数或布尔值
bitwise_right_shift (*)	整数
bitwise_xor	整数或布尔值
ceil	数值
cos	浮点数
cosh	浮点数
divide	浮点数
equal	所有
exp	浮点数
expm1	浮点数
floor	数值
floor_divide	数值
greater	数值
greater_equal	数值
isfinite	数值
isinf	数值
isnan	数值
less	数值
less_equal	数值
log	浮点数
logaddexp	浮点数
log10	浮点数
log1p	浮点数
log2	浮点数
logical_and	布尔值
logical_not	布尔值
logical_or	布尔值
logical_xor	布尔值
multiply	数值
negative	数值
not_equal	所有
positive	数值
pow (*)	数值
remainder	数值
round	数值
sign	数值
sin	浮点数
sinh	浮点数
sqrt	浮点数
square	数值
subtract	数值
tan	浮点数
tanh	浮点数
trunc	数值

(*) 这些函数与主numpy命名空间中的名称不同。请参阅函数名称更改。

创建函数

函数名称	数据类型
meshgrid	任意（所有输入数据类型必须相同）

线性代数函数

函数名称	数据类型
cholesky	浮点数
cross	数值
det	浮点数
diagonal	任意
eigh	浮点数
eighvals	浮点数
inv	浮点数
matmul	数值
matrix_norm (*)	浮点数
matrix_power	浮点数
matrix_rank	浮点数
matrix_transpose (**)	任意
outer	数值
pinv	浮点数
qr	浮点数
slogdet	浮点数
solve	浮点数
svd	浮点数
svdvals (**)	浮点数
tensordot	数值
trace	数值
vecdot (**)	数值
vector_norm (*)	浮点数

(*) 这些函数是从主numpy命名空间中的norm中拆分出来的。请参阅函数名称更改。

(**) 这些函数是数组 API 中的新功能，不在主numpy命名空间中。

数组对象

数组对象上的所有特殊 __operator__ 方法的行为与其对应的函数完全相同（请参阅 规范 以获取哪些方法对应哪些函数的列表）。唯一的例外是运算符根据 规范中概述的规则 明确允许 Python 标量（请参阅 类型提升差异）。

数组对象差异

特性	类型	注释
无数组标量	严格性	规范中没有数组标量，只有 0-D 数组。然而，除了 类型提升差异 中概述的提升差异外，标量在规范中作为 0-D 数组进行鸭子类型。它们是不可变的，但规范 不要求可变性。
bool(), int(), 和 float() 仅适用于 0-D 数组。	严格性	查看 github.com/numpy/numpy/issues/10404。
__imatmul__	兼容性	np.ndarray 目前未实现 __imatmul__。请注意，只有当 a 的形状不发生变化时，a @= b 才会被定义。
矩阵转置的 mT 属性。	兼容性	查看 规范定义 中的 mT。
T 属性应在输入不是 2 维时报错。	破坏性变化	查看 规范中的注释。
新方法 to_device 和属性 device	兼容性	这些方法实际上不会起作用，因为 NumPy 仅支持 CPU

创建函数差异

特性	类型	注释
asarray 的 copy 关键字参数	兼容性
所有数组创建函数（asarray、arange、empty、empty_like、eye、full、full_like、linspace、ones、ones_like、zeros 和 zeros_like）新增 device 关键字参数。	兼容性	device 实际上不会起作用，因为 NumPy 仅支持 CPU。

逐元素函数差异

特性	类型	注释
各种函数已更名。	兼容性	查看 函数名称更改。
逐元素函数仅对给定的输入类型组合定义。	严格性	查看 类型严格性。
bitwise_left_shift 和 bitwise_right_shift 仅对 x2 非负数定义。	严格性
ceil、floor 和 trunc 对整数输入返回整数。	破坏性更改	np.ceil、np.floor 和 np.trunc 在整数类型输入时返回浮点数类型。

线性代数差异

特性	类型	注释
cholesky 包括一个 upper 关键字参数。	兼容的
cross 不允许大小为 2 的向量（仅大小为 3）。	破坏性更改
diagonal 操作在最后两个轴上。	破坏性更改	严格来说这可能是兼容的，因为 diagonal 被移动到 linalg 命名空间中。
eigh、qr、slogdet 和 svd 返回一个命名元组。	兼容的	相应的 numpy 函数返回一个 tuple，其中结果数组的顺序相同。
新函数 matrix_norm 和 vector_norm。	兼容的	norm 函数已从数组 API 中省略，并分为 matrix_norm 用于矩阵范数和 vector_norm 用于向量范数。请注意，vector_norm 支持任意数量的轴，而 np.linalg.norm 仅支持向量范数的单个轴。
matrix_rank 具有 rtol 关键字参数而不是 tol。	破坏性更改	在数组 API 中，rtol 过滤比 rtol * largest_singular_value 小的奇异值。在 np.linalg.matrix_rank 中，tol 过滤比 tol 小的奇异值。此外，rtol 的默认值是 max(M, N) * eps，而 np.linalg.matrix_rank 中 tol 的默认值是 S.max() * max(M, N) * eps，其中 S 是输入的奇异值。新标志名称是兼容的，但默认更改是破坏性的。
matrix_rank 不支持 1 维数组。	破坏性更改
新函数 matrix_transpose。	兼容的	与 np.transpose 不同，matrix_transpose 只对最后两个轴进行转置。查看规范定义。
outer 仅支持 1 维数组。	破坏性更改	规范目前仅指定了对 1-D 数组的行为，但未来的行为可���是广播，而不是展平，这是 np.outer 的行为。
pinv 具有 rtol 关键字参数而不是 rcond。	破坏性更改	rtol 和 rcond 的含义相同，但 rtol 的默认值是 max(M, N) * eps，而 rcond 的默认值是 1e-15。新标志名称是兼容的，但默认更改是破坏性的。
solve 仅在 x2 精确为 1 维向量时才接受。	破坏性更改	np.linalg.solve 的行为是模棱两可的。更多细节请参阅此 numpy 问题和此数组 API 规范问题。
新函数 svdvals。	兼容的	等同于 np.linalg.svd(compute_uv=False)。
tensordot 的 axis 关键字必须是一个元组。	兼容性更改	在 np.tensordot 中��它也可以是一个数组或类似数组。
trace 在最后两个轴上操作。	破坏性更改	np.trace 默认在前两个轴上操作。请注意，数组 API 的 trace 不允许指定要操作的轴。

操作函数差异

特性	类型	注释
各种函数已被重命名	兼容性更改	请参阅 函数名称更改。
concat 具有与 np.concatenate 不同的默认转换规则	严格性	没有跨类型的转换。对于标量（当 axis=None 时）不进行基于值的转换。
stack 具有与 np.stack 不同的默认转换规则	严格性	没有跨类型的转换。
新函数 permute_dims。	兼容性更改	与 np.transpose 不同，permute_dims 的 axis 关键字参数是必需的。
reshape 函数现在有一个 copy 关键字参数	兼容性更改	请参阅 github.com/numpy/numpy/issues/9818。

集合函数差异

特性	类型	注释
新函数 unique_all, unique_counts, unique_inverse, 和 unique_values。	兼容性更改	请参阅 函数名称更改。
四个 unique_* 函数返回一个命名元组。	兼容性更改
unique_all 和 unique_indices 返回与 x 相同形状的索引。	兼容性更改	请参阅 github.com/numpy/numpy/issues/20638。

集合函数差异

特性	类型	注释
argsort 和 sort 现在有一个 stable 关键字参数，而不是 kind。	破坏性更改	stable 是一个布尔关键字参数，默认为 True。 kind 接受一个字符串，默认为 "quicksort"。 stable=True 等同于 kind="stable"，kind=False 等同于 kind="quicksort"，尽管规范允许任何排序算法当 stable=False 时。新的标志名称是兼容的，但默认更改是破坏性的。
argsort 和 sort 现在有一个 descending 关键字参数。	兼容性更改

统计函数差异

特性	类型	注释
sum 和 prod 在 dtype=None 时总是将 float32 上升为 float64。	破坏性更改
std 和 var 函数现在有一个 correction 关键字参数，而不是 ddof。	兼容性更改

其他差异

特性	类型	注释
数据类型只能以 dtype 对象的形式拼写。	严格性	例如，numpy.array_api.asarray([0], dtype='int32') 是不允许的。
asarray 不会在任何函数中隐式调用。	严格性	例外情况是 Python 运算符，在某些情况下接受 Python 标量（请参阅 类型提升差异）。
tril 和 triu 要求输入至少为 2-D。	严格性
finfo() 返回类型使用float作为各属性。	严格性	规范允许鸭子类型，因此finfo返回 dtype 标量被视为与float兼容。
每个函数的位置参数都是位置参数。	Breaking	查看规范以获取每个函数的确切签名。请注意，NumPy 的 ufuncs 已经使用位置参数，但非 ufuncs 如asarray通常不使用。

名称差异

规范中有许多函数从 NumPy 中重命名。除非另有说明，否则这些函数在行为上是相同的，因此都是兼容更改。

函数名称更改

以下函数在数组 API 中的命名不同

数组 API 名称	NumPy 命名空间名称	备注
acos	arccos
acosh	arccosh
asin	arcsin
asinh	arcsinh
atan	arctan
atan2	arctan2
atanh	arctanh
bitwise_left_shift	left_shift
bitwise_invert	invert
bitwise_right_shift	right_shift
bool	bool_	这是破坏性的，因为np.bool目前是内置bool的弃用别名。
concat	concatenate
matrix_norm 和 vector_norm	norm	matrix_norm 和 vector_norm 分别执行np.norm的有限子集。
permute_dims	transpose	与np.transpose不同，permute_dims需要axis关键字参数。
pow	power
unique_all, unique_counts, unique_inverse, 和 unique_values	unique	每个函数等同于设置了特定标志的np.unique。

函数而非方法

• astype是数组 API 中的函数，而在numpy中是ndarray的方法。

linalg 命名空间差异

这些函数在数组 API 中的linalg子命名空间中，但在 NumPy 中仅在顶层命名空间中：

• cross

• diagonal

• matmul (*)

• outer

• tensordot (*)

• trace

(*): 这些函数也在数组 API 的顶层命名空间中。

关键字参数重命名

以下函数的关键字参数已被重命名。除非另有说明，否则关键字参数的功能是相同的。具有相同语义定义的重命名关键字参数可能被视为兼容或破坏，具体取决于更改的实现方式。

请注意，此页面不列出主numpy命名空间中但不在数组 API 中的函数关键字参数。出于严格性的考虑，这些关键字参数在numpy.array_api中被省略，因为规范允许函数包含额外的关键字参数，而不仅限于所需的参数。

函数	数组 API 关键字名称	NumPy 关键字名称	备注
argsort 和 sort	stable	kind	stable 和 kind 的定义不同， 默认值也不同。 默认值的更改使得这是一个破坏性的更改。 请参阅集合函数差异。
matrix_rank	rtol	tol	rtol 和 tol 的定义不同， 默认值也不同。 默认值的更改使得这是一个破坏性的更改。 请参阅线性代数差异。
pinv	rtol	rcond	rtol 和 rcond 的定义相同，但默认值不同，这是一个破坏性的更改。 请参阅线性代数差异。
std 和 var	correction	ddof
reshape	shape	newshape	参数可以作为 NumPy 和数组 API 的位置参数或关键字参数传递。

函数名称更改

以下函数在数组 API 中的命名不同

数组 API 名称	NumPy 命名空间名称	备注
acos	arccos
acosh	arccosh
asin	arcsin
asinh	arcsinh
atan	arctan
atan2	arctan2
atanh	arctanh
bitwise_left_shift	left_shift
bitwise_invert	invert
bitwise_right_shift	right_shift
bool	bool_	这是一个破坏性的更改，因为 np.bool 目前是内置 bool 的已弃用别名。
concat	concatenate
matrix_norm 和 vector_norm	norm	matrix_norm 和 vector_norm 仅执行 np.norm 的有限子集。
permute_dims	transpose	与 np.transpose 不同，permute_dims 需要 axis 关键字参数。
pow	power
unique_all, unique_counts, unique_inverse, 和 unique_values	unique	每个等价于带有特定标志设置的 np.unique。

函数而不是方法

• astype 是数组 API 中的函数，而在 numpy 中是 ndarray 的方法。

linalg 命名空间差异

这些函数在数组 API 中的 linalg 子命名空间中，但在 NumPy 中仅在顶层命名空间中：

• cross

• diagonal

• matmul (*)

• outer

• tensordot (*)

• trace

(*): 这些函数也在数组 API 的顶层命名空间中。

关键字参数重命名

以下函数的关键字参数已被重命名。 除非另有说明，否则关键字参数的功能是相同的。 除非另有说明，具有相同语义定义的重命名关键字参数可能被视为兼容或破坏，具体取决于更改的实现方式。

请注意，此页面不列出主 numpy 命名空间中存在但不在数组 API 中的函数关键字参数。 为了严格性，numpy.array_api 中省略了这些关键字参数，因为规范允许函数包含额外的关键字参数，而不是所需的参数。

函数	数组 API 关键字名称	NumPy 关键字名称	注释
argsort 和 sort	stable	kind	stable 和 kind 的定义不同，且默认值也不同。默认值的更改导致了这一变动。请参见集合函数差异。
matrix_rank	rtol	tol	rtol 和 tol 的定义不同，且默认值也不同。默认值的更改导致了这一变动。请参见线性代数差异。
pinv	rtol	rcond	rtol 和 rcond 的定义相同，但它们的默认值不同，导致了这一变动。请参见线性代数差异。
std 和 var	correction	ddof
reshape	shape	newshape	对于 NumPy 和数组 API，参数可以作为位置参数或关键字参数传递。

类型提升差异

类型提升是 NumPy 与规范偏离最大的领域。最显著的区别是 NumPy 在许多情况下进行基于值的转换。规范明确禁止基于值的转换。在数组 API 中，任何操作的结果类型完全由输入类型确定，与值或形状无关。

特性	类型	注释
有限的数据类型集合。	严格性	numpy.array_api 仅实现了规范所需的那些数据类型。
仅接受与 Python 标量匹配的标量类型的操作符（如 +）。	严格性	例如，不允许 <int32 array> + 1.0。请参见规范中有关混合数组和 Python 标量的规则。
与 Python 标量进行操作（如 +）始终返回与数组相同的数据类型。	变动	例如，numpy.array_api.asarray(0., dtype=float32) + 1e64 是一个 float32 数组。
当左侧操作数将被提升时，不允许原地操作符。	变动	例如：a = np.array(1, dtype=np.int8); a += np.array(1, dtype=np.int16)。规范明确禁止这种情况。
当右侧操作数无法广播到左侧操作数的形状时，不允许原地操作符。	严格性	这种所谓的“反向广播”不应被允许。例如：a = np.empty((2, 3, 4)); a += np.empty((3, 4)) 应该报错。请参见github.com/numpy/numpy/issues/10404。
仅对数据类型范围内的整数指定运算符的int提升。	严格性	numpy.array_api 回退到 np.ndarray 行为（要么转换，要么引发 OverflowError）。
__pow__和__rpow__不对 0 维数组进行基于值的转换。	破坏性变化	例如，np.array(0., dtype=float32)**np.array(0., dtype=float64)是float32。请注意，这是对 0 维数组的基于值的转换，而不是标量。
不允许不同种类之间的转换。	严格性	即，布尔值、整数和浮点数数据类型不会相互转换，除非使用astype（这与 Python 标量的行为是分开的）。
不允许将无符号整数数据类型转换为浮点数据类型（例如，int64 + uint64 -> float64）。	严格性
can_cast和result_type受限制。	严格性	numpy.array_api实现不允许不同种类之间的转换。
当dtype=None时，sum和prod总是将float32向上转换为float64。	破坏性变化

索引差异

规范仅要求索引的子集，但规范中的所有索引规则与 NumPy 更广泛的索引规则兼容。

特性	类型	注释
不允许隐式省略号（...）。	严格性	如果索引不包括省略号，则必须对所有轴进行索引。

| 切片的起始和结束不能超出边界。 | 严格性 | 对于切片i:j:k，只允许以下情况：

• 省略i或j（None）。

• -n <= i <= max(0, n - 1)。

• 对于k > 0或省略k（None），-n <= j <= n。

• 对于k < 0，-n - 1 <= j <= max(0, n - 1)。

|

布尔数组索引仅允许作为唯一索引。	严格性
不允许整数数组索引。	严格性	除了 0 维数组，它们被视为整数。

类型严格性

numpy.array_api中的函数限制其输入仅限于规范明确要求的那些数据类型，即使包装的对应 NumPy 函数允许更广泛的数据类型。在这里，我们列出每个函数以及在numpy.array_api中允许的数据类型。这些是严格性差异，因为规范不要求其他数据类型会导致错误。这里的类别定义如下：

• 浮点数：float32或float64。

• 整数：任何有符号或无符号整数数据类型（int8、int16、int32、int64、uint8、uint16、uint32或uint64）。

• 布尔值：bool。

• 整数或布尔值：任何有符号或无符号整数数据类型，或bool。对于两个参数的函数，两个参数必须是整数或都是bool。

• 数值：任何整数或浮点数数据类型。对于两个参数的函数，两个参数必须是整数或浮点数。

• 全部：上述数据类型类别中的任何一个。对于两个参数的函数，两个参数必须是相同种类（整数、浮点数或布尔值）。

在所有情况下，返回的数据类型根据规范中概述的规则选择，并且与 NumPy 对于任何允许的输入数据类型的返回数据类型没有区别，除非在下面的子章节中明确提到的情况。

逐元素函数

函数名称	数据类型
abs	数值
acos	浮点数
acosh	浮点数
add	数值
asin (*)	浮点数
asinh (*)	浮点数
atan (*)	浮点数
atan2 (*)	浮点数
atanh (*)	浮点数
bitwise_and	整数或布尔值
bitwise_invert	整数或布尔值
bitwise_left_shift (*)	整数
bitwise_or	整数或布尔值
bitwise_right_shift (*)	整数
bitwise_xor	整数或布尔值
ceil	数值
cos	浮点数
cosh	浮点数
divide	浮点数
equal	所有
exp	浮点数
expm1	浮点数
floor	数值
floor_divide	数值
greater	数值
greater_equal	数值
isfinite	数值
isinf	数值
isnan	数值
less	数值
less_equal	数值
log	浮点数
logaddexp	浮点数
log10	浮点数
log1p	浮点数
log2	浮点数
logical_and	布尔值
logical_not	布尔值
logical_or	布尔值
logical_xor	布尔值
multiply	数值
negative	数值
not_equal	所有
positive	数值
pow (*)	数值
remainder	数值
round	数值
sign	数值
sin	浮点数
sinh	浮点数
sqrt	浮点数
square	数值
subtract	数值
tan	浮点数
tanh	浮点数
trunc	数值

(*) 这些函数与主numpy命名空间中的名称不同。请参阅函数名称更改。

创建函数

函数名称	数据类型
meshgrid	任意（所有输入数据类型必须相同）

线性代数函数

函数名称	数据类型
cholesky	浮点数
cross	数值
det	浮点数
diagonal	任意
eigh	浮点数
eighvals	浮点数
inv	浮点数
matmul	数值
matrix_norm (*)	浮点数
matrix_power	浮点数
matrix_rank	浮点数
matrix_transpose (**)	任意
outer	数值
pinv	浮点数
qr	浮点数
slogdet	浮点数
solve	浮点数
svd	浮点数
svdvals (**)	浮点数
tensordot	数值
trace	数值
vecdot (**)	数值
vector_norm (*)	浮点数

(*) 这些函数从主要的 numpy 命名空间中的 norm 中分离出来。请参阅函数名称更改。

(**) 这些函数是数组 API 中的新功能，不在主要的 numpy 命名空间中。

数组对象

数组对象上的所有特殊 __operator__ 方法的行为与其对应的函数完全相同（请参阅规范以获取哪些方法对应于哪��函数的列表）。唯一的例外是运算符明确允许 Python 标量，根据规范中概述的规则（请参阅类型提升差异）。

逐元素函数

函数名称	数据类型
abs	数值型
acos	浮点型
acosh	浮点型
add	数值型
asin (*)	浮点型
asinh (*)	浮点型
atan (*)	浮点型
atan2 (*)	浮点型
atanh (*)	浮点型
bitwise_and	整数型或布尔型
bitwise_invert	整数型或布尔型
bitwise_left_shift (*)	整数型
bitwise_or	整数型或布尔型
bitwise_right_shift (*)	整数型
bitwise_xor	整数型或布尔型
ceil	数值型
cos	浮点型
cosh	浮点型
divide	浮点型
equal	全部
exp	浮点型
expm1	浮点型
floor	数值型
floor_divide	数值型
greater	数值型
greater_equal	数值型
isfinite	数值型
isinf	数值型
isnan	数值型
less	数值型
less_equal	数值型
log	浮点型
logaddexp	浮点型
log10	浮点型
log1p	浮点型
log2	浮点型
logical_and	布尔型
logical_not	布尔型
logical_or	布尔型
logical_xor	布尔型
multiply	数值型
negative	数值型
not_equal	全部
positive	数值型
pow (*)	数值型
remainder	数值型
round	数值型
sign	数值型
sin	浮点型
sinh	浮点型
sqrt	浮点型
square	数值型
subtract	数值型
tan	浮点型
tanh	浮点型
trunc	数值型

(*) 这些函数与主要的 numpy 命名空间中的名称不同。请参阅函数名称更改。

创建函数

函数名称	数据类型
meshgrid	任意（所有输入数据类型必须相同）

线性代数函数

函数名称	数据类型
cholesky	浮点型
cross	数值型
det	浮点型
diagonal	任意
eigh	浮点型
eighvals	浮点型
inv	浮点型
matmul	数值型
matrix_norm (*)	浮点型
matrix_power	浮点数
matrix_rank	浮点数
matrix_transpose (**)	任意
outer	数值
pinv	浮点数
qr	浮点数
slogdet	浮点数
solve	浮点数
svd	浮点数
svdvals (**)	浮点数
tensordot	数值
trace	数值
vecdot (**)	数值
vector_norm (*)	浮点数

(*) 这些函数是从主numpy命名空间的norm中拆分出来的。请参见函数名称更改。

(**) 这些函数是数组 API 中的新功能，不在主numpy命名空间中。

数组对象

数组对象上的所有特殊__operator__方法的行为与其对应的函数完全相同（请参见规范中哪些方法对应哪些函数的列表）。唯一的例外是，根据规范中概述的规则（请参见类型提升差异），运算符明确允许 Python 标量。

数组对象差异

特征	类型	注释
无数组标量	严格性	规范中没有数组标量，只有 0-D 数组。然而，除了类型提升差异中概述的提升差异之外，标量在规范中作为 0-D 数组进行鸭子类型处理。它们是不可变的，但规范不要求可变性。
bool()、int()和float()仅适用于 0-D 数组。	严格性	请参见github.com/numpy/numpy/issues/10404。
__imatmul__	兼容性	np.ndarray目前没有实现__imatmul。请注意，仅当a的形状不发生变化时，a @= b才应该被定义。
用于矩阵转置的mT属性。	兼容性	请参见mT 的规范定义。
如果输入不是二维的，则T属性应该报错。	破坏性	请参见规范中的注释。
新方法to_device和属性device	兼容性	这些方法实际上不会做任何事情，因为 NumPy 仅支持 CPU。

创建函数差异

特征	类型	注释
copy关键字参数传递给asarray	兼容性
所有数组创建函数（asarray、arange、empty、empty_like、eye、full、full_like、linspace、ones、ones_like、zeros 和 zeros_like）新增 device 关键字参数。	兼容	device 实际上不会起作用，因为 NumPy 仅支持 CPU。

元素函数差异

特性	类型	注释
各种函数已更名。	兼容	请参阅函数名称更改。
仅为给定输入类型组合定义元素函数。	严格性	请参阅类型严格性。
bitwise_left_shift 和 bitwise_right_shift 仅对 x2 非负定义。	严格性
ceil、floor 和 trunc 对整数输入返回整数。	破坏性变更	np.ceil、np.floor 和 np.trunc 对整数类型的输入返回浮点数类型。

线性代数差异

特性	类型	注释
cholesky 包括一个 upper 关键字参数。	兼容
cross 不允许大小为 2 的向量（仅允许大小为 3）。	破坏性变更
diagonal 在最后两个轴上操作。	破坏性变更	严格来说这可以是兼容的，因为 diagonal 移至 linalg 命名空间。
eigh、qr、slogdet 和 svd 返回一个命名元组。	兼容	相应的 numpy 函数返回一个 tuple，其中结果数组的顺序相同。
新功能 matrix_norm 和 vector_norm。	兼容	norm 函数已从数组 API 中省略，并分为 matrix_norm 用于矩阵范数和 vector_norm 用于向量范数。请注意，vector_norm 支持任意数量的轴，而 np.linalg.norm 仅支持向量范数的单个轴。
matrix_rank 使用 rtol 关键字参数代替 tol。	破坏性变更	在数组 API 中，rtol 用于过滤比 rtol * largest_singular_value 小的奇异值。在 np.linalg.matrix_rank 中，tol 用于过滤比 tol 小的奇异值。此外，rtol 的默认值为 max(M, N) * eps，而 np.linalg.matrix_rank 中 tol 的默认值为 S.max() * max(M, N) * eps，其中 S 是输入的奇异值。新标志名称兼容，但默认更改是破坏性的
matrix_rank 不支持 1 维数组。	破坏性变更
新函数 matrix_transpose。	兼容	与 np.transpose 不同，matrix_transpose 仅对最后两个轴进行转置。请参阅规范定义
outer 仅支持 1 维数组。	破坏性变更	规范目前仅指定了 1-D 数组的行为，但未来的行为可能是广播，而不是展平，这是 np.outer 的行为。
pinv 有一个 rtol 关键字参数，而不是 rcond	兼容性破坏	rtol 和 rcond 的含义相同，但 rtol 的默认值是 max(M, N) * eps，而 rcond 的默认值是 1e-15。 新标志名称是兼容的，但默认更改是破坏性的。
solve 仅在 x2 确切为 1 维时才接受其为向量。	兼容性破坏	np.linalg.solve 的行为是模糊的。有关更多详细信息，请参阅 此 numpy 问题 和 此数组 API 规范问题。
新函数 svdvals。	兼容性	等效于 np.linalg.svd(compute_uv=False)。
tensordot 的 axis 关键字必须是一个元组。	兼容性	在 np.tensordot 中，它也可以是数组或类似数组。
trace 在最后两个轴上操作。	兼容性破坏	np.trace 默认在前两个轴上操作。请注意，数组 API 的 trace 不允许指定要操作的轴。

操作函数差异

特性	类型	注释
各种函数已更名	兼容性	查看 函数名称更改。
concat 具有与 np.concatenate 不同的默认转换规则	严格性	没有跨类型转换。标量的值基转换（当 axis=None 时）。
stack 具有与 np.stack 不同的默认转换规则	严格性	没有跨类型转换。
新函数 permute_dims。	兼容性	与 np.transpose 不同，permute_dims 的 axis 关键字参数是必需的。
reshape 函数具有 copy 关键字参数	兼容性	查看 github.com/numpy/numpy/issues/9818。

集合函数差异

特性	类型	注释
新函数 unique_all, unique_counts, unique_inverse 和 unique_values。	兼容性	查看 函数名称更改。
四个 unique_* 函数返回一个命名元组。	兼容性
unique_all 和 unique_indices 返回与 x 相同形状的索引。	兼容性	查看 github.com/numpy/numpy/issues/20638。

集合函数差异

特性	类型	注释
argsort 和 sort 有一个 stable 关键字参数，而不是 kind。	兼容性破坏	stable 是一个布尔关键字参数，默认为 True。 kind 接受一个字符串，默认为 "quicksort"。 stable=True 等效于 kind="stable"，kind=False 等效于 kind="quicksort"，尽管规范允许在 stable=False 时使用任何排序算法。 新标志名称是兼容的，但默认更改是破坏性的。
argsort 和 sort 有一个 descending 关键字参数。	兼容性

统计函数差异

特性	类型	注释
sum 和 prod 在 dtype=None 时总是将 float32 上转型为 float64。	破坏性变化
std 和 var 函数具有 correction 关键字参数而不是 ddof。	兼容性

其他差异

特性	类型	注释
Dtypes 只能以 dtype 对象的形式表示。	严格性	例如，numpy.array_api.asarray([0], dtype='int32') 是不允许的。
asarray 在任何函数中都不会被隐式调用。	严格性	例外情况是 Python 运算符，在某些情况下接受 Python 标量（参见类型提升差异）。
tril 和 triu 要求输入至少是 2-D。	严格性
finfo() 返回类型使用 float 来表示各种属性。	严格性	规范允许鸭子类型，因此 finfo 返回的 dtype 标量被认为与 float 兼容。
每个函数中的位置参数都是仅限位置的。	破坏性变化	请查看每个函数的确切签名规范。请注意，NumPy 的 ufuncs 已经使用了仅限位置的参数，但非 ufunc 的函数如 asarray 通常不会。

数组 API 标准兼容性

原文：numpy.org/doc/1.26/reference/array_api.html

注意

numpy.array_api 模块仍处于实验阶段。请参阅 NEP 47。

NumPy 在 numpy.array_api 中包含了 array API standard 的参考实现。NEP 47 描述了在 NumPy 中��现数组 API 标准的动机和范围。

numpy.array_api 模块作为数组 API 标准的最小参考实现。作为最小实现，该模块仅实现了规范明确要求的内容。规范允许某些内容，但在 numpy.array_api 中明确禁止。这样，该模块可以作为数组 API 标准的用户的参考实现。任何使用数组 API 的用户都可以针对 numpy.array_api 测试其代码，并确保他们没有使用规范中未保证的功能，也可能不存在于其他符合规范的库中。

numpy.array_api 模块在此处未记录。要查看数组 API 规范中存在的函数列表，请参考 array API standard。numpy.array_api 实现是功能完整的，因此实现了规范中描述的所有功能。

numpy.array_api 与 numpy 之间的差异表

该表格概述了 numpy.array_api 与主 numpy 命名空间之间的主要差异。有三种类型的差异：

1. 严格性。仅为了使 numpy.array_api 成为严格的、最小的实现而执行的操作。实际上，这些操作并不是规范要求的，其他符合规范的库可能不会遵循它们。在大多数情况下，规范并未指定或要求给定域之外的任何行为。主 numpy 命名空间不需要做任何更改才能符合这些规范。

2. 兼容。可以添加到主 numpy 命名空间而不会破坏向后兼容性的内容。

3. 破坏性。如果在主 numpy 命名空间中实现，将会破坏向后兼容性的内容。

名称差异

许多函数在规范中从 NumPy 重命名。除非另有说明，否则这些函数在行为上是相同的，因此都是兼容的更改。

函数名称更改

以下函数在数组 API 中具有不同的名称

数组 API 名称	NumPy 命名空间名称	注释
acos	arccos
acosh	arccosh
asin	arcsin
asinh	arcsinh
atan	arctan
atan2	arctan2
atanh	arctanh
bitwise_left_shift	left_shift
bitwise_invert	invert
bitwise_right_shift	right_shift
bool	bool_	这是破坏性的，因为 np.bool 目前是内置 bool 的已弃用别名。
concat	concatenate
matrix_norm 和 vector_norm	norm	matrix_norm 和 vector_norm 每个只执行 np.norm 的有限子集。
permute_dims	transpose	与 np.transpose 不同，permute_dims 的 axis 关键字参数是必需的。
pow	power
unique_all、unique_counts、unique_inverse 和 unique_values	unique	每个等效于设置了特定标志的 np.unique。

函数而非方法

• astype 是数组 API 中的一个函数，而在 numpy 中是 ndarray 的方法。

linalg 命名空间差异

这些函数在数组 API 的 linalg 子命名空间中，但在 NumPy 中仅在顶层命名空间中：

• cross

• diagonal

• matmul (*)

• outer

• tensordot (*)

• trace

(*): 这些函数也在数组 API 的顶层命名空间中。

关键字参数重命名

以下函数具有已重命名的关键字参数。除非另有说明，否则关键字参数的功能是相同的。具有相同语义定义的重命名关键字参数可能被视为兼容或破坏性，具体取决于更改的实现方式。

注意，本页面不列出主 numpy 命名空间中存在但不在数组 API 中的函数关键字参数。为了严格性，numpy.array_api 中省略了这些关键字参数，因为规范允许函数包含额外的关键字参数。

函数	数组 API 关键字名称	NumPy 关键字名称	注释
argsort 和 sort	stable	kind	stable 和 kind 的定义不同，默认值也不同。默认值的更改使得这是破坏性的。请参见集合函数差异。
matrix_rank	rtol	tol	rtol 和 tol 的定义不同，默认值也不同。默认值的更改使得这是破坏性的。请参见线性代数差异。
pinv	rtol	rcond	rtol 和 rcond 的定义相同，但它们的默认值不同，这是破坏性的。请参见线性代数差异。
std 和 var	correction	ddof
reshape	shape	newshape	该参数可以作为 NumPy 和数组 API 的位置参数或关键字参数传递。

类型提升差异

类型提升是 NumPy 与规范最大的不同之处。最显著的区别是 NumPy 在许多情况下进行基于值的转换。规范明确禁止基于值的转换。在数组 API 中，任何操作的结果类型始终完全由输入类型确定，与值或形状无关。

特性	类型	注释
有限的数据类型集合。	严格性	numpy.array_api 仅实现了规范所需的那些 数据类型。
与 Python 标量一起使用的运算符（如 +）仅接受匹配的标量类型。	严格性	例如，<int32 array> + 1.0 是不允许的。请参见 规范中有关混合数组和 Python 标量的规则。
与 Python 标量一起使用的运算符（如 +）始终返回与数组相同的数据类型。	突破	例如，numpy.array_api.asarray(0., dtype=float32) + 1e64 是一个 float32 数组。
当左侧操作数会被提升时，不允许原地操作符。	突破	例如：a = np.array(1, dtype=np.int8); a += np.array(1, dtype=np.int16)。规范明确禁止这种情况。
当右侧操作数无法广播到左侧操作数的形状时，不允许原地操作符。	严格性	这种所谓的“反向广播”不应该被允许。例如：a = np.empty((2, 3, 4)); a += np.empty((3, 4)) 应该报错。参见 github.com/numpy/numpy/issues/10404。
int 运算符的提升仅适用于数据类型范围内的整数。	严格性	numpy.array_api 回退到 np.ndarray 的行为（要么转换，要么引发 OverflowError）。
__pow__ 和 __rpow__ 不会对零维数组进行基于值的转换。	突破	例如，np.array(0., dtype=float32)**np.array(0., dtype=float64) 是 float32。请注意，这是针对零维数组的基于值的转换，而不是标量。
不允许跨类型转换。	严格性	即，布尔值、整数和浮点数数据类型不会相互转换，除非使用 astype 明确转换（这与与 Python 标量的行为是分开的）。
不允许将无符号整数数据类型转换为浮点数据类型（例如，int64 + uint64 -> float64）。	严格性
can_cast 和 result_type 受限。	严格性	numpy.array_api 实现不允许跨类型转换。
当 dtype=None 时，sum 和 prod 总是将 float32 上升为 float64。	突破

索引差异

规范要求仅支持索引的子集，但规范中的所有索引规则都与 NumPy 更广泛的索引规则兼容。

特性	类型	注释
不允许隐式���略号（...）。	严格性	如果索引不包含省略号，则必须对所有轴进行索引。

| 切片的起始和结束位置不能超出边界。 | 严格性 | 对于切片 i:j:k，只允许以下情况：

• i 或 j 被省略（None）。

• -n <= i <= max(0, n - 1)。

• 对于 k > 0 或 k 被省略（None），-n <= j <= n。

• 对于 k < 0，-n - 1 <= j <= max(0, n - 1)。

|

布尔数组索引只允许作为唯一索引。	严格性
整数数组索引根本不允许。	严格性	除了 0 维数组，它们被视为整数。

类型严格性

numpy.array_api中的函数将它们的输入限制为规范明确要求的数据类型，即使包装的对应 NumPy 函数允许更广泛的数据类型。在这里，我们列出每个函数及其在numpy.array_api中允许的数据类型。这些是严格性差异，因为规范并不要求其他数据类型会导致错误。这里的类别定义如下：

• 浮点数：float32或float64。

• 整数：任何有符号或无符号整数数据类型（int8、int16、int32、int64、uint8、uint16、uint32或uint64）。

• 布尔值：bool。

• 整数或布尔值：任何有符号或无符号整数数据类型，或bool。对于两个参数的函数，两个参数必须都是整数或都是bool。

• 数值：任何整数或浮点数数据类型。对于两个参数的函数，两个参数必须都是整数或都是浮点数。

• 所有：上述数据类型类别中的任何一种。对于两个参数的函数，两个参数必须是相同类型（整数、浮点数或布尔值）。

在所有情况下，返回的数据类型根据规范中概述的规则选择，并且对于任何允许的输入数据类型，与 NumPy 的返回数据类型没有区别，除非在下面的具体小节中明确提到的情况。

逐元素函数

函数名称	数据类型
abs	数值
acos	浮点数
acosh	浮点数
add	数值
asin (*)	浮点数
asinh (*)	浮点数
atan (*)	浮点数
atan2 (*)	浮点数
atanh (*)	浮点数
bitwise_and	整数或布尔值
bitwise_invert	整数或布尔值
bitwise_left_shift (*)	整数
bitwise_or	整数或布尔值
bitwise_right_shift (*)	整数
bitwise_xor	整数或布尔值
ceil	数值
cos	浮点数
cosh	浮点数
divide	浮点数
equal	所有
exp	浮点数
expm1	浮点数
floor	数值
floor_divide	数值
greater	数值
greater_equal	数值
isfinite	数值
isinf	数值
isnan	数值
less	数值
less_equal	数值
log	浮点数
logaddexp	浮点数
log10	浮点数
log1p	浮点数
log2	浮点数
logical_and	布尔值
logical_not	布尔值
logical_or	布尔值
logical_xor	布尔值
multiply	���值
negative	数值
not_equal	所有
positive	数值
pow (*)	数值
remainder	数值
round	数值
sign	数值
sin	浮点数
sinh	浮点数
sqrt	浮点数
square	数值
subtract	数值
tan	浮点数
tanh	浮点数
trunc	数值

(*) 这些函数与主numpy命名空间中的名称不同。请参阅函数名称更改。

创建函数

函数名称	数据类型
meshgrid	任意（所有输入数据类型必须相同）

线性代数函数

函数名称	数据类型
cholesky	浮点数
cross	数值
det	浮点数
diagonal	任意
eigh	浮点数
eighvals	浮点数
inv	浮点数
matmul	数值
matrix_norm (*)	浮点数
matrix_power	浮点数
matrix_rank	浮点数
matrix_transpose (**)	任意
outer	数值
pinv	浮点数
qr	浮点数
slogdet	浮点数
solve	浮点数
svd	浮点数
svdvals (**)	浮点数
tensordot	数值
trace	数值
vecdot (**)	数值
vector_norm (*)	浮点数

(*) 这些函数是从主numpy命名空间的norm中拆分出来的。请参阅函数名称更改。

(**) 这些函数是数组 API 中的新功能，不在主numpy命名空间中。

数组对象

数组对象上的所有特殊__operator__方法的行为与其对应的函数完全相同（请参阅规范以获取哪些方法对应哪些函数的列表）。唯一的例外是运算符根据规范中概述的规则明确允许 Python 标量（请参阅类型提升差异）。

数组对象差异

特征	类型	注释
没有数组标量	严格性	规范中没有数组标量，只有 0-D 数组。然而，除了类型提升差异中概述的提升差异外，标量在规范目的上作为 0-D 数组的鸭子类型。它们是不可变的，但规范不要求可变性。
bool()，int()和float()仅适用于 0-D 数组。	严格性	请参阅github.com/numpy/numpy/issues/10404。
__imatmul__	兼容性	np.ndarray目前未实现__imatmul__。请注意，仅当a @= b不改变a的形状时才定义。
mT属性用于矩阵转置。	兼容性更改	请参阅mT 的规范定义。
T属性应在输入不是二维时报错。	破坏性更改	请参阅规范中的注释。
新方法to_device和属性device	兼容性更改	这些方法实际上不会做任何事情，因为 NumPy 仅支持 CPU。

创建函数差异

特性	类型	注释
asarray的copy关键字参数	兼容性更改
所有数组创建函数（asarray、arange、empty、empty_like、eye、full、full_like、linspace、ones、ones_like、zeros和zeros_like）新增device关键字参数。	兼容性更改	device实际上不会做任何事情，因为 NumPy 仅支持 CPU。

逐元素函数差异

特性	类型	注释
各种函数已更名。	兼容性更改	请参阅函数名称更改。
逐元素函数仅针对给定的输入类型组合定义。	严格性	请参阅类型严格性。
bitwise_left_shift和bitwise_right_shift仅对x2非负数定义。	严格性
ceil、floor和trunc在整数输入时返回整数。	破坏性更改	np.ceil、np.floor和np.trunc在整数 dtype 输入时返回浮点 dtype。

线性代数差异

特性	类型	注释
cholesky包括一个upper关键字参数。	兼容性更改
cross不允许大小为 2 的向量（仅允许大小为 3）。	破坏性更改
diagonal作用于最后两个轴。	破坏性更改	严格来说这可以是兼容性更改，因为diagonal已移至linalg命名空间。
eigh、qr、slogdet和svd返回一个命名元组。	兼容性更改	相应的numpy函数返回一个tuple，其中结果数组的顺序相同。
新函数matrix_norm和vector_norm	兼容性更改	norm函数已从数组 API 中省略，并分为matrix_norm用于矩阵范数和vector_norm用于向量范数。请注意，vector_norm支持任意数量的轴，而np.linalg.norm仅支持向量范数的单个轴。
matrix_rank 使用 rtol 关键字参数代替 tol。	破坏性	在数组 API 中，rtol 用于过滤小于 rtol * largest_singular_value 的奇异值。在 np.linalg.matrix_rank 中，tol 用于过滤小于 tol 的奇异值。此外，rtol 的默认值为 max(M, N) * eps，而 np.linalg.matrix_rank 中 tol 的默认值为 S.max() * max(M, N) * eps，其中 S 是输入的奇异值。 新标志名称兼容，但默认更改是破坏性的。
matrix_rank 不支持 1 维数组。	破坏性
新功能 matrix_transpose。	兼容性	与 np.transpose 不同，matrix_transpose 只转置最后两个轴。请参阅 规范定义
outer 仅支持 1 维数组。	破坏性	规范目前仅指定了对 1-D 数组的行为，但未来的��为可能是广播，而不是展平，这是 np.outer 的行为。
pinv 使用 rtol 关键字参数代替 rcond	破坏性	rtol 和 rcond 的含义相同，但 rtol 的默认值为 max(M, N) * eps，而 rcond 的默认值为 1e-15。 新标志名称兼容，但默认更改是破坏性的。
solve 只在 x2 确切为 1 维时接受为向量。	破坏性	np.linalg.solve 的行为模糊。有关更多详细信息，请参阅 此 numpy 问题 和 此数组 API 规范问题。
新功能 svdvals。	兼容性	等同于 np.linalg.svd(compute_uv=False)。
tensordot 的 axis 关键字必须是元组。	兼容性	在 np.tensordot 中，也可以是数组或类似数组。
trace 操作最后两个轴。	破坏性	np.trace 默认操作前两个轴。请注意，数组 API 的 trace 不允许指定要操作的轴。

操作函数差异

特性	类型	备注
多个函数已被重命名	兼容性	请参阅 函数名称更改。
concat 的默认类型转换规则与 np.concatenate 不同	严格性	不允许跨类型转换。标量的值转换不适用（当 axis=None 时）。
stack 的默认类型转换规则与 np.stack 不同	严格性	不允许跨类型转换。
新功能 permute_dims。	兼容性	与 np.transpose 不同，permute_dims 需要 axis 关键字参数。
reshape 函数有一个 copy 关键字参数	兼容性	请参阅 github.com/numpy/numpy/issues/9818。

集合函数差异

功能	类型	注释
新函数unique_all、unique_counts、unique_inverse和unique_values。	兼容性	请参见函数名称更改。
四个unique_*函数返回一个命名元组。	兼容性
unique_all和unique_indices返回的索引与x具有相同的形状。	兼容性	请参见github.com/numpy/numpy/issues/20638。

集合函数差异

功能	类型	注释
argsort和sort具有stable关键字参数而不是kind。	破坏性	stable是一个布尔关键字参数，默认为True。kind接受一个字符串，默认为"quicksort"。stable=True等同于kind="stable"，kind=False等同于kind="quicksort"，尽管规范允许在stable=False时使用任何排序算法。新标志名称是兼容的，但默认更改是破坏性的。
argsort和sort具有descending关键字参数。	兼容性

统计函数差异

功能	类型	注释
sum和prod在dtype=None时总是将float32向上转换为float64。	破坏性
std和var函数具有correction关键字参数而不是ddof。	兼容性

其他差异

功能	类型	注释
Dtypes 只能被拼写为 dtype 对象。	严格性	例如，numpy.array_api.asarray([0], dtype='int32')是不允许的。
asarray不会在任何函数中隐式调用。	严格性	例外情况是 Python 运算符，在某些情况下接受 Python 标量（请参见类型提升差异）。
tril和triu要求输入至少为 2-D。	严格性
finfo()返回类型使用float作为各个属性。	严格性	规范允许鸭子类型，因此finfo返回 dtype 标量被认为与float兼容。

| 每个函数中的位置参数都是仅限位置的。 | 破坏性 | 请查看每个函数的确切签名规范。请注意，NumPy ufuncs 已经使用了仅限位置参数，但非 ufuncs 如asarray通常没有。 | ## numpy.array_api和numpy之间的差异表

这个表格概述了numpy.array_api与主numpy命名空间之间的主要区别。有三种类型的差异：

1. 严格性。这些只是为了使numpy.array_api成为一个严格的、最小的实现而做的事情。它们实际上并不是规范所要求的，其他符合规范的库可能不会遵循它们。在大多数情况下，规范并不指定或要求给定域之外的任何行为。主numpy命名空间不需要做任何改变才能符合这些规范。

2. Compatible。这些可能被添加到主 numpy 命名空间中而不会破坏向后兼容性的事物。

3. Breaking。如果在主 numpy 命名空间中实现，可能会破坏向后兼容性的事物。

名称差异

规范中有许多函数从 NumPy 中被重命名。除非另有说明，否则这些函数在行为上是相同的，因此都是兼容的更改。

函数名称更改

以下函数在数组 API 中的名称与 NumPy 中不同

数组 API 名称	NumPy 命名空间名称	注释
acos	arccos
acosh	arccosh
asin	arcsin
asinh	arcsinh
atan	arctan
atan2	arctan2
atanh	arctanh
bitwise_left_shift	left_shift
bitwise_invert	invert
bitwise_right_shift	right_shift
bool	bool_	这是破坏性的，因为 np.bool 目前是内置 bool 的已弃用别名。
concat	concatenate
matrix_norm 和 vector_norm	norm	matrix_norm 和 vector_norm 分别只执行 np.norm 的有限子集。
permute_dims	transpose	与 np.transpose 不同，permute_dims 的 axis 关键字参数是必需的。
pow	power
unique_all, unique_counts, unique_inverse 和 unique_values	unique	每个都等同于设置了特定标志的 np.unique。

函数而不是方法

• astype 是数组 API 中的一个函数，而在 numpy 中是 ndarray 的一个方法。

linalg 命名空间差异

这些函数在数组 API 的 linalg 子命名空间中，但在 NumPy 中仅在顶层命名空间中：

• cross

• diagonal

• matmul (*)

• outer

• tensordot (*)

• trace

(*): 这些函数也在数组 API ���顶层命名空间中。

关键字参数重命名

以下函数的关键字参数已被重命名。除非另有说明，否则关键字参数的功能是相同的。具有相同语义定义的重命名关键字参数可能被视为兼容或破坏，具体取决于更改的实现方式。

注意，此页面不列出主 numpy 命名空间中存在但不在数组 API 中的函数关键字参数。这些关键字参数在 numpy.array_api 中被省略，以确保严格性，因为规范允许函数包含额外的关键字参数，而不仅限于所需的参数。

函数	数组 API 关键字名称	NumPy 关键字名称	注释
argsort 和 sort	stable	kind	stable 和 kind 的定义不同，以及默认值也不同。默认值的更改使得这是一个破坏性的更改。参见集合函数差异。
matrix_rank	rtol	tol	rtol 和 tol 的定义不同，而默认值也不同。默认值的更改造成了变更。请参阅线性代数差异。
pinv	rtol	rcond	rtol 和 rcond 的定义相同，但默认值不同，造成了变更。请参阅线性代数差异。
std 和 var	correction	ddof
reshape	shape	newshape	该参数可以作为 NumPy 和数组 API 的位置参数或关键字参数传递。

类型提升差异

类型提升是 NumPy 与规范最大的不同之处。最显著的区别是 NumPy 在许多情况下进行基于值的转换。规范明确禁止基于值的转换。在数组 API 中，任何操作的结果类型始终完全由输入类型确定，与值或形状无关。

特征	类型	注释
有限的数据类型集合。	严格性	numpy.array_api 只实现了规范所需的那些数据类型。
操作符（如 +）只接受与 Python 标量匹配的标量类型。	严格性	例如，<int32 array> + 1.0 是不允许的。请参阅规范中有关混合数组和 Python 标量的规则。
与 Python 标量的操作符（如 +）始终返回与数组相同的数据类型。	变更	例如，numpy.array_api.asarray(0., dtype=float32) + 1e64 是一个 float32 数组。
当左操作数将被提升时，不允许原地操作符。	变更	例如：a = np.array(1, dtype=np.int8); a += np.array(1, dtype=np.int16)。规范明确禁止这种情况。
当右操作数无法广播到左操作数的形状时，就不允许原地操作符。	严格性	这种所谓的“反向广播”不应该被允许。例如：a = np.empty((2, 3, 4)); a += np.empty((3, 4)) 应该报错。请参阅github.com/numpy/numpy/issues/10404。
对于操作符的 int 提升仅对数据类型范围内的整数指定。	严格性	numpy.array_api 退回到 np.ndarray 的行为（要么转换，要么引发 OverflowError）。
__pow__ 和 __rpow__ 不会对 0-D 数组进行基于值的转换。	变更	例如，np.array(0., dtype=float32)**np.array(0., dtype=float64) 是 float32。请注意，这是对 0-D 数组进行基于值的转换，而不是标量。
不允许跨类型转换。	严格性	即，布尔值、整数和浮点数数据类型不会相互转换，除非明确使用 astype（这与 Python 标量的行为是分开的）。
不允许将无符号整数类型转换为浮点类型（例如，int64 + uint64 -> float64）。	严格性
can_cast 和 result_type 受限制。	严格性	numpy.array_api 的实现不允许跨类型转换。
sum 和 prod 在 dtype=None 时总是将 float32 向上转换为 float64。	变更

索引差异

规范仅要求一部分索引，但规范中的所有索引规则都与 NumPy 更广泛的索引规则兼容。

特性	类型	注释
不允许隐式省略号 (...)。	严格性	如果索引不包括省略号，则所有轴必须被索引。

| 切片的起始和结束不能超出界限。 | 严格性 | 对于切片 i:j:k，只允许以下情况：

• i 或 j 被省略 (None)。

• -n <= i <= max(0, n - 1)。

• 对于 k > 0 或 k 被省略 (None)，-n <= j <= n。

• 对于 k < 0，-n - 1 <= j <= max(0, n - 1)。

|

布尔数组索引仅允许作为唯一索引。	严格性
整数数组索引根本不被允许。	严格性	除了 0-D 数组，它们被视为整数。

类型严格性

numpy.array_api 中的函数限制其输入仅限于规范明确要求的数据类型，即使包装的对应 NumPy 函数允许更广泛的集合。在这里，我们列出每个函数及其在 numpy.array_api 中允许的数据类型。这些是严格性差异，因为规范不要求其他数据类型会导致错误。这里的类别定义如下：

• 浮点数：float32 或 float64。

• 整数：任何有符号或无符号整数类型 (int8, int16, int32, int64, uint8, uint16, uint32, 或 uint64)。

• 布尔值：bool。

• 整数或布尔值：任何有符号或无符号整数数据类型，或 bool。对于两个参数的函数，两个参数必须是整数或布尔值。

• 数值：任何整数或浮点数数据类型。对于两个参数的函数，两个参数必须是整数或浮点数。

• 所有：以上任何一种数据类型类别。对于两个参数的函数，两个参数必须是相同类型（整数、浮点数或布尔值）。

在所有情况下，返回的数据类型根据规范中概述的规则选择，并且对于任何允许的输入数据类型，与 NumPy 的返回数据类型没有区别，除非在下面的子节中明确提到的情况。

逐元素函数

函数名称	数据类型
abs	数值
acos	浮点数
acosh	浮点数
add	数值
asin (*)	浮点数
asinh (*)	浮点数
atan (*)	浮点数
atan2 (*)	浮点数
atanh (*)	浮点数
bitwise_and	整数或布尔值
bitwise_invert	整数或布尔值
bitwise_left_shift (*)	整数
bitwise_or	整数或布尔值
bitwise_right_shift (*)	整数
bitwise_xor	整数或布尔值
ceil	数值
cos	浮点数
cosh	浮点数
divide	浮点数
equal	所有
exp	浮点数
expm1	浮点数
floor	数值
floor_divide	数值
greater	数值
greater_equal	数值
isfinite	数值
isinf	数值
isnan	数值
less	数值
less_equal	数值
log	浮点数
logaddexp	浮点数
log10	浮点数
log1p	浮点数
log2	浮点数
logical_and	布尔值
logical_not	布尔值
logical_or	布尔值
logical_xor	布尔值
multiply	数值
negative	数值
not_equal	所有
positive	数值
pow (*)	数值
remainder	数值
round	数值
sign	数值
sin	浮点数
sinh	浮点数
sqrt	浮点数
square	数值
subtract	数值
tan	浮点数
tanh	浮点数
trunc	数值

(*) 这些函数与主numpy命名空间中的名称不同。请参阅函数名称更改。

创建函数

函数名称	数据类型
meshgrid	任意（所有输入数据类型必须相同）

线性代数函数

函数名称	数据类型
cholesky	浮点数
cross	数值
det	浮点数
diagonal	任意
eigh	浮点数
eighvals	浮点数
inv	浮点数
matmul	数值
matrix_norm (*)	浮点数
matrix_power	浮点数
matrix_rank	浮点数
matrix_transpose (**)	任意
outer	数值
pinv	浮点数
qr	浮点数
slogdet	浮点数
solve	浮点数
svd	浮点数
svdvals (**)	浮点数
tensordot	数值
trace	数值
vecdot (**)	数值
vector_norm (*)	浮点数

(*) 这些函数从主numpy命名空间中的norm中拆分出来。请参阅函数名称更改。

(**) 这些函数是数组 API 中的新功能，不在主numpy命名空间中。

数组对象

数组对象的所有特殊__operator__方法的行为与其对应的函数完全相同（参见规范以查看哪些方法对应哪些函数）。唯一的例外是，根据规范中概述的规则（参见数组 API 类型提升差异），运算符明确允许 Python 标量。

数组对象的差异

特性	类型	注意事项
没有数组标量	严格性	规范中没有数组标量，只有 0 维数组。然而，除了数组 API 类型提升差异中概述的提升差异外，标量在规范中作为 0 维数组进行鸭子类型。它们是不可变的，但规范不要求可变性。
bool()、int()和float()仅适用于 0 维数组。	严格性	参见github.com/numpy/numpy/issues/10404。
__imatmul__	兼容性	np.ndarray目前不实现__imatmul。请注意，只有当a的形状不发生变化时，a @= b才会被定义。
用于矩阵转置的mT属性。	兼容性	参见规范定义中的mT。
如果输入不是二维的，T属性应该报错。	破坏性	参见规范中的注释。
新方法to_device和属性device	兼容性	这些方法实际上不会做任何事情，因为 NumPy 仅支持 CPU。

创建函数差异

特性	类型	注意事项
asarray的copy关键字参数	兼容性
所有数组创建函数（asarray、arange、empty、empty_like、eye、full、full_like、linspace、ones、ones_like、zeros和zeros_like）都新增了device关键字参数。	兼容性	device实际上不会起作用，因为 NumPy 仅支持 CPU。

元素级函数差异

特性	类型	注意事项
各种函数已被重命名。	兼容性	参见函数名称更改。
元素级函数仅对给定的输入类型组合定义。	严格性	参见类型严格性。
bitwise_left_shift和bitwise_right_shift仅对x2非负定义。	严格性
ceil、floor 和 trunc 对整数输入返回整数。	破坏性更改	np.ceil、np.floor 和 np.trunc 在整数类型输入时返回浮点数类型。

线性代数差异

特征	类型	备注
cholesky 包括一个 upper 关键字参数。	兼容的
cross 不允许大小为 2 的向量（只允许大小为 3）。	破坏性更改
diagonal 操作在最后两个轴上。	破坏性更改	严格来说这可能是兼容的，因为 diagonal 被移动到 linalg 命名空间中。
eigh、qr、slogdet 和 svd 返回一个命名元组。	兼容的	相应的 numpy 函数返回一个 tuple，其中结果数组的顺序相同。
新函数 matrix_norm 和 vector_norm。	兼容的	norm 函数已从数组 API 中省略，并分为 matrix_norm 用于矩阵范数和 vector_norm 用于向量范数。请注意，vector_norm 支持任意数量的轴，而 np.linalg.norm 仅支持向量范数的单个轴。
matrix_rank 有一个 rtol 关键字参数，而不是 tol。	破坏性更改	在数组 API 中，rtol 用于过滤小于 rtol * largest_singular_value 的奇异值。在 np.linalg.matrix_rank 中，tol 用于过滤小于 tol 的奇异值。此外，rtol 的默认值是 max(M, N) * eps，而 np.linalg.matrix_rank 中 tol 的默认值是 S.max() * max(M, N) * eps，其中 S 是输入的奇异值。新标志名称是兼容的，但默认更改是破坏性的。
matrix_rank 不支持一维数组。	破坏性更改
新函数 matrix_transpose。	兼容的	与 np.transpose 不同，matrix_transpose 只转置最后两个轴。请参阅规范定义。
outer 仅支持一维数组。	破坏性更改	规范目前仅指定了对 1-D 数组的行为，��未来的行为可能是广播，而不是展平，这是 np.outer 的行为。
pinv 有一个 rtol 关键字参数，而不是 rcond。	破坏性更改	rtol 和 rcond 的含义相同，但 rtol 的默认值是 max(M, N) * eps，而 rcond 的默认值是 1e-15。新标志名称是兼容的，但默认更改是破坏性的。
solve 仅在 x2 作为一维向量时才接受。	破坏性更改	np.linalg.solve 的行为是模棱两可的。更多细节请参阅此 numpy 问题和此数组 API 规范问题。
新函数 svdvals。	兼容的	等效于 np.linalg.svd(compute_uv=False)。
tensordot 的 axis 关键字必须是一个元组。	Compatible	在 np.tensordot 中，它也可以是一个数组或类似数组。
trace 在最后两个轴上操作。	Breaking	np.trace 默认在前两个轴上操作。请注意，数组 API 的 trace 不允许指定要操作的轴。

操作函数差异

特性	类型	注释
各种函数已被重命名	Compatible	参见 Function Name Changes。
concat 与 np.concatenate 有不同的默认转换规则	Strictness	没有跨类型的转换。在标量上没有基于值的转换（当 axis=None 时）。
stack 与 np.stack 有不同的默认转换规则	Strictness	没有跨类型的转换。
新函数 permute_dims。	Compatible	与 np.transpose 不同，permute_dims 的 axis 关键字参数是必需的。
reshape 函数有一个 copy 关键字参数	Compatible	参见 github.com/numpy/numpy/issues/9818。

集合函数差异

特性	类型	注释
新函数 unique_all、unique_counts、unique_inverse 和 unique_values。	Compatible	参见 Function Name Changes。
四个 unique_* 函数返回一个命名元组。	Compatible
unique_all 和 unique_indices 返回与 x 相同形状的索引。	Compatible	参见 github.com/numpy/numpy/issues/20638。

集合函数差异

特性	类型	注释
argsort 和 sort 有一个 stable 关键字参数，而不是 kind。	Breaking	stable 是一个布尔关键字参数，默认为 True。 kind 接受一个字符串，默认为 "quicksort"。 stable=True 等同于 kind="stable"，kind=False 等同于 kind="quicksort"，尽管规范允许任何排序算法当 stable=False 时。新的标志名称是兼容的，但默认更改是破坏性的。
argsort 和 sort 有一个 descending 关键字参数。	Compatible

统计函数差异

特性	类型	注释
sum 和 prod 在 dtype=None 时总是将 float32 升级为 float64。	Breaking
std 和 var 函数有一个 correction 关键字参数，而不是 ddof。	Compatible

其他差异

特性	类型	注释
Dtypes 只能被拼写为 dtype 对象。	Strictness	例如，numpy.array_api.asarray([0], dtype='int32') 是不允许的。
asarray 在任何函数中都不会被隐式调用。	Strictness	例外是 Python 运算符，在某些情况下接受 Python 标量（请参见 Type Promotion Differences）。
tril 和 triu 要求输入至少为 2-D。	严格性
finfo() 返回类型使用 float 作为各种属性。	严格性	规范允许鸭子类型，因此 finfo 返回 dtype 标量被视为与 float 兼容。
每个函数的位置参数都是仅限位置的。	破坏性的	查看每个函数的确切签名规范。请注意，NumPy 的通用函数已经使用了仅限位置的参数，但非通用函数如 asarray 通常不会使用。

名称差异

许多函数在规范中从 NumPy 中重命名。这些函数在行为上是相同的，因此除非另有说明，它们都是兼容的更改。

函数名称更改

数组 API 中以下函数的命名不同

数组 API 名称	NumPy 命名空间名称	注释
acos	arccos
acosh	arccosh
asin	arcsin
asinh	arcsinh
atan	arctan
atan2	arctan2
atanh	arctanh
bitwise_left_shift	left_shift
bitwise_invert	invert
bitwise_right_shift	right_shift
bool	bool_	这是破坏性的，因为 np.bool 目前是内置 bool 的已弃用别名。
concat	concatenate
matrix_norm 和 vector_norm	norm	matrix_norm 和 vector_norm 分别执行 np.norm 的有限子集。
permute_dims	transpose	与 np.transpose 不同，permute_dims 需要 axis 关键字参数。
pow	power
unique_all, unique_counts, unique_inverse 和 unique_values	unique	每个函数等同于设置了特定标志的 np.unique。

函数而非方法

• astype 是数组 API 中的函数，而在 numpy 中是 ndarray 的方法。

linalg 命名空间差异

这些函数在数组 API 的 linalg 子命名空间中，但在 NumPy 中仅在顶层命名空间中：

• cross

• diagonal

• matmul (*)

• outer

• tensordot (*)

• trace

(*): 这些函数也在数组 API 的顶层命名空间中。

关键字参数重命名

以下函数的关键字参数已重命名。除非另有说明，关键字参数的功能是相同的。具有相同语义定义的重命名关键字参数可能被视为兼容或破坏性，具体取决于更改的实现方式。

请注意，此页面不列出主 numpy 命名空间中存在但不在数组 API 中的函数关键字参数。为了严格性，这些关键字参数在 numpy.array_api 中被省略，因为规范允许函数包含额外的关键字参数。

函数	数组 API 关键字名称	NumPy 关键字名称	注释
argsort 和 sort	稳定	种类	稳 和 种类 的定义不同，以及默认值。默认值的更改使得这是破坏性的。请参阅集函数差异。
矩阵秩	rtol	tol	linalg 命名空间中 rtol 和 tol 的定义不同，以及 默认度 。默认值的更改使得这是破坏的。请参, 见数组, API 线性代数差, 异。
伪逆	rtol	rcond	rtol 和 rcond 的定义相同，但它们的默认值不同，这是破坏性的。请参阅线性代数差异。
标准差 和 方差	校正	自由度
重塑	形状	新形状	参数可以作为 NumPy 和数组 API 的位置或关键字参数传递。

函数名称更改

数组 API 中以下函数的名称不同

数组 API 名称	NumPy 命名空间名称	注释
acos	arccos
双曲余弦	反双曲余弦
asin	arcsin
反双曲正弦	反双曲正弦
atan	arctan
atan2	arctan2
反双曲正切	反双曲正切
按位左移	左移
按位取反	取反
按位右移	右移
`布尔``	bool_	这是破坏性的，因为 np.bool 目前是内置, bool 的, 弃, 用别名。
连接	连接
矩阵范数 和 向量范数	范数	矩阵范数 和 向量范数 仅执行 np.norm 的有限子集。
置换维度	转置	与 np.transpose 不同，permute_dims 需要 axis 关键字参数。
幂	幂
唯一全部, 唯一计数, 唯一逆, 和 唯一值	唯一	每个与设置特定标志的 np.unique 等效。

函数而非方法

• astype 是数组 API 中的��个函数，而在 numpy 中是 ndarray 的一个方法。

linalg 命名空间差异

这些函数在数组 API 的 linalg 子命名空间中，但只在 NumPy 的顶层命名空间中：

• 叉积

• 对角线

• 矩阵乘法 (*)

• 外积

• 张量点积 (*)

• 跟踪

(*): 这些函数也在数组 API 的顶层命名空间中。

关键字参数重命名

数组 API 中以下函数具有已重命名的关键字参数。除非另有说明，否则关键字参数, 的功能是相同的。具有相同语义定义的重命名关键字参数可能被视为兼容或破坏性，具体取决于更改的实现方式。

请注意，此页面不列出主 numpy 命名空间中存在但不在数组 API 中的函数关键字参数。为了严格性，numpy.array_api 中省略了这些关键字参数，因为规范允许函数包括额外的关键字参数，而不是所, 需要的。

功能	数组 API 关键字名称	NumPy 关键字名称	备注
argsort 和 sort	stable	kind	stable 和 kind 的定义不同，默认值也不同。默认值的更改会导致破坏。参见 集合函数差异。
matrix_rank	rtol	tol	rtol 和 tol 的定义不同，默认值也不同。默认值的更改会导致破坏。参见 线性代数差异。
pinv	rtol	rcond	rtol 和 rcond 的定义相同，但默认值不同，这会导致破坏。参见 线性代数差异。
std 和 var	correction	ddof
reshape	shape	newshape	对于 NumPy 和数组 API，参数可以作为位置参数或关键字参数传递。

类型提升差异

类型提升是 NumPy 与规范最大的差异领域。最显著的区别是 NumPy 在许多情况下进行基于值的转换。规范明确禁止基于值的转换。在数组 API 中，任何操作的结果类型始终完全由输入类型确定，与值或形状无关。

特性	类型	备注
有限的数据类型集合。	严格性	numpy.array_api 仅实现了规范所需的那些数据类型。
仅接受与 Python 标量匹配的标量类型的操作符（如 +）。	严格性	例如，<int32 array> + 1.0 是不允许的。参见 混合数组和 Python 标量的规则。
与 Python 标量一起使用的操作符（如 +）始终返回与数组相同的 dtype。	破坏	例如，numpy.array_api.asarray(0., dtype=float32) + 1e64 是一个 float32 数组。
当左侧将被提升时，不允许原地操作符。	破坏	例如：a = np.array(1, dtype=np.int8); a += np.array(1, dtype=np.int16)。规范明确禁止这种情况。
当右侧操作数无法广播到左侧操作数的形状时，不允许原地操作符。	严格性	这种所谓的“逆向广播”不应该被允许。例如：a = np.empty((2, 3, 4)); a += np.empty((3, 4)) 应该报错。参见 github.com/numpy/numpy/issues/10404。
仅为在 dtype 范围内的整数指定运算符的int提升。	严格性	numpy.array_api 回退到 np.ndarray 行为（要么转换，要么引发 OverflowError）。
__pow__ 和 __rpow__ 不会对 0-D 数组进行基于值的转换。	破坏性	例如，np.array(0., dtype=float32)**np.array(0., dtype=float64) 是 float32。请注意，这是对 0-D 数组的基于值的转换，而不是标量。
不允许跨类型转换。	严格性	即，布尔值、整数和浮点数据类型不会相互转换，除非使用 astype 明确转换（这与 Python 标量的行为是分开的）。
不允许将无符号整数数据类型转换为浮点数据类型（例如，int64 + uint64 -> float64。	严格性
can_cast 和 result_type 受限制。	严格性	numpy.array_api 的实现不允许跨类型转换。
当 dtype=None 时，sum 和 prod 总是将 float32 向上转换为 float64。	破坏性

索引差异

规范仅要求一部分索引，但规范中的所有索引规则都与 NumPy 更广泛的索引规则兼容。

特性	类型	注释
不允许隐式省略 (...)。	严格性	如果索引不包括省略号，则所有轴必须被索引。

| 切片的起始和结束不能超出边界。 | 严格性 | 对于切片 i:j:k，只允许以下情况：

• i 或 j 被省略 (None)。

• -n <= i <= max(0, n - 1)。

• 对于 k > 0 或 k 被省略 (None)，-n <= j <= n。

• 对于 k < 0，-n - 1 <= j <= max(0, n - 1)。

|

仅允许布尔数组索引作为唯一索引。	严格性
完全不允许整数数组索引。	严格性	除了 0-D 数组，它们被视为整数。

类型严格性

numpy.array_api 中的函数将它们的输入限制为规范明确要求的数据类型，即使包装的对应 NumPy 函数允许更广泛的数据类型。在这里，我们列出每个函数以及在 numpy.array_api 中允许的数据类型。这些是严格性差异，因为规范不要求其他数据类型会导致错误。这里的类别定义如下：

• 浮点数: float32 或 float64。

• 整数: 任何有符号或无符号整数数据类型（int8、int16、int32、int64、uint8、uint16、uint32 或 uint64）。

• Boolean: bool。

• 整数或布尔值: 任何有符号或无符号整数数据类型，或 bool。对于两个参数的函数，两个参数必须是整数或都是 bool。

• Numeric: 任何整数或浮点数数据类型。对于两个参数的函数，两个参数必须都是整数或都是浮点数。

• 全部: 以上述数据类型类别中的任何一种。对于两个参数的函数，两个参数必须是相同类型（整数、浮点数或布尔值）。

在所有情况下，返回的数据类型根据规范中概述的规则选择，并且对于任何允许的输入数据类型，不会与 NumPy 的返回数据类型有所不同，除非在下面的子节中明确提到的情况。

逐元素函数

函数名称	数据类型
abs	数值型
acos	浮点数
acosh	浮点数
add	数值型
asin (*)	浮点数
asinh (*)	浮点数
atan (*)	浮点数
atan2 (*)	浮点数
atanh (*)	浮点数
bitwise_and	整数或布尔型
bitwise_invert	整数或布尔型
bitwise_left_shift (*)	整数
bitwise_or	整数或布尔型
bitwise_right_shift (*)	整数
bitwise_xor	整数或布尔型
ceil	数值型
cos	浮点数
cosh	浮点数
divide	浮点数
equal	所有
exp	浮点数
expm1	浮点数
floor	数值型
floor_divide	数值型
greater	数值型
greater_equal	数值型
isfinite	数值型
isinf	数值型
isnan	数值型
less	数值型
less_equal	数值型
log	浮点数
logaddexp	浮点数
log10	浮点数
log1p	浮点数
log2	浮点数
logical_and	布尔型
logical_not	布尔型
logical_or	布尔型
logical_xor	布尔型
multiply	数值型
negative	数值型
not_equal	所有
positive	数值型
pow (*)	数值型
remainder	数值型
round	数值型
sign	数值型
sin	浮点数
sinh	浮点数
sqrt	浮点数
square	数值型
subtract	数值型
tan	浮点数
tanh	浮点数
trunc	数值型

(*) 这些函数与主numpy命名空间中的名称不同。请参阅函数名称更改。

创建函数

函数名称	��据类型
meshgrid	任意类型（所有输入数据类型必须相同）

线性代数函数

函数名称	数据类型
cholesky	浮点数
cross	数值型
det	浮点数
diagonal	任意类型
eigh	浮点数
eighvals	浮点数
inv	浮点数
matmul	数值型
matrix_norm (*)	浮点数
matrix_power	浮点数
matrix_rank	浮点数
matrix_transpose (**)	任意类型
outer	数值型
pinv	浮点数
qr	浮点数
slogdet	浮点数
solve	浮点数
svd	浮点数
svdvals (**)	浮点数
tensordot	数值型
trace	数值型
vecdot (**)	数值型
vector_norm (*)	浮点数

(*) 这些函数是从主numpy命名空间中的norm中拆分出来的。请参阅函数名称更改。

(**) 这些函数是数组 API 中的新功能，不在主numpy命名空间中。

数组对象

所有数组对象上的特殊__operator__方法的行为与其对应的函数完全相同（请参阅规范以获取哪些方法对应于哪些函数的列表）。唯一的例外是运算符明确允许根据规范中概述的规则使用 Python 标量（请参阅类型提升差异）。

逐元素函数

函数名称	数据类型
abs	数值
acos	浮点数
acosh	浮点数
add	数值
asin (*)	浮点数
asinh (*)	浮点数
atan (*)	浮点数
atan2 (*)	浮点数
atanh (*)	浮点数
bitwise_and	整数或布尔值
bitwise_invert	整数或布尔值
bitwise_left_shift (*)	整数
bitwise_or	整数或布尔值
bitwise_right_shift (*)	整数
bitwise_xor	整数或布尔值
ceil	数值
cos	浮点数
cosh	浮点数
divide	浮点数
equal	所有
exp	浮点数
expm1	浮点数
floor	数值
floor_divide	数值
greater	数值
greater_equal	数值
isfinite	数值
isinf	数值
isnan	数值
less	数值
less_equal	数值
log	浮点数
logaddexp	浮点数
log10	浮点数
log1p	浮点数
log2	浮点数
logical_and	布尔值
logical_not	布尔值
logical_or	布尔值
logical_xor	布尔���
multiply	数值
negative	数值
not_equal	所有
positive	数值
pow (*)	数值
remainder	数值
round	数值
sign	数值
sin	浮点数
sinh	浮点数
sqrt	浮点数
square	数值
subtract	数值
tan	浮点数
tanh	浮点数
trunc	数值

(*) 这些函数与主numpy命名空间中的名称不同。请参阅函数名称更改。

创建函数

函数名称	数据类型
meshgrid	任意（所有输入数据类型必须相同）

线性代数函数

函数名称	数据类型
cholesky	浮点数
cross	数值
det	浮点数
diagonal	任意
eigh	浮点数
eighvals	浮点数
inv	浮点数
matmul	数值
matrix_norm (*)	浮点数
matrix_power	浮点数
matrix_rank	浮点数
matrix_transpose (**)	任意
outer	数值型
pinv	浮点数
qr	浮点数
slogdet	浮点数
solve	浮点数
svd	浮点数
svdvals (**)	浮点数
tensordot	数值型
trace	数值型
vecdot (**)	数值型
vector_norm (*)	浮点数

(*) 这些函数从主 numpy 命名空间的 norm 中拆分出来。参见 函数名称更改。

(**) 这些函数是数组 API 中的新功能，不在主 numpy 命名空间中。

数组对象

数组对象上的所有特殊 __operator__ 方法的行为与其对应的函数完全相同（请参阅 规范 以查看哪些方法对应哪些函数）。唯一的例外是，根据规范中概述的规则（请参见 类型提升差异），运算符明确允许 Python 标量。

数组对象差异

特性	类型	注释
没有数组标量	严格性	规范中没有数组标量，只有 0-D 数组。然而，除了在 类型提升差异 中概述的提升差异之外，标量在规范中作为 0-D 数组进行鸭子类型处理。它们是不可变的，但规范不要求可变性。
bool()、int() 和 float() 仅适用于 0-D 数组。	严格性	参见 github.com/numpy/numpy/issues/10404。
__imatmul__	兼容性	np.ndarray 目前未实现 __imatmul__。请注意，仅当它不改变 a 的形状时，a @= b 才应该被定义。
矩阵转置的 mT 属性。	兼容性	参见 规范定义 中的 mT。
��果输入不是二维的，则 T 属性应该报错。	破坏性变更	参见 规范中的注释。
新方法 to_device 和属性 device	兼容性	这些方法实际上不会做任何事情，因为 NumPy 只支持 CPU。

创建函数差异

特性	类型	注释
asarray 的 copy 关键字参数	兼容性
所有数组创建函数（asarray、arange、empty、empty_like、eye、full、full_like、linspace、ones、ones_like、zeros和zeros_like）新增device关键字参数。	兼容性	device实际上不会起作用，因为 NumPy 仅支持 CPU。

逐元素函数差异

特性	类型	注释
各种函数已更名。	兼容性	参见函数名称更改。
逐元素函数仅对给定的输入类型组合定义。	严格性	参见类型严格性。
bitwise_left_shift和bitwise_right_shift仅对x2非负数定义。	严格性
ceil、floor和trunc在整数输入时返回整数。	破坏性变化	np.ceil、np.floor和np.trunc在整数 dtype 输入时返回浮点 dtype。

线性代数差异

特性	类型	注释
cholesky包括一个upper关键字参数。	兼容性
cross不允许大小为 2 的向量（仅允许大小为 3）。	破坏性变化
diagonal在最后两个轴上操作。	破坏性变化	严格来说，这可能是兼容的，因为diagonal已移至linalg命名空间。
eigh、qr、slogdet和svd返回一个命名元组。	兼容性	相应的numpy函数返回一个tuple，其中结果数组的顺序相同。
新函数matrix_norm和vector_norm。	兼容性	norm函数已从数组 API 中省略，并分为矩阵范数matrix_norm和向量范数vector_norm。请注意，vector_norm支持任意���量的轴，而np.linalg.norm仅支持向量范数的单个轴。
matrix_rank有一个rtol关键字参数，而不是tol。	破坏性变化	在数组 API 中，rtol过滤小于rtol * largest_singular_value的奇异值。在np.linalg.matrix_rank中，tol过滤小于tol的奇异值。此外，rtol的默认值是max(M, N) * eps，而np.linalg.matrix_rank中tol的默认值是S.max() * max(M, N) * eps，其中S是输入的奇异值。新标志名称是兼容的，但默认更改是破坏性的
matrix_rank不支持 1 维数组。	破坏性变化
新函数matrix_transpose。	兼容性	与np.transpose不同，matrix_transpose仅转置最后两个轴。参见规范定义
outer仅支持 1 维数组。	破坏性变化	规范目前仅指定了对 1-D 数组的行为，但未来的行为可能是广播，而不是展平，这是np.outer的行为。
pinv具有rtol关键字参数而不是rcond	破坏性	rtol和rcond的含义相同，但rtol的默认值为max(M, N) * eps，而rcond的默认值为1e-15。 新标志名称兼容，但默认更改是破坏性的。
solve仅在x2恰好为 1 维时接受作为向量。	破坏性	np.linalg.solve的行为是模棱两可的。有关更多详细信息，请参阅此 numpy 问题和此数组 API 规范问题。
新函数svdvals。	兼容	等同于np.linalg.svd(compute_uv=False)。
tensordot的axis关键字必须是一个元组。	兼容	在np.tensordot中，也可以是数组或类似数组。
trace在最后两个轴上操作。	破坏性	np.trace默认在前两个轴上操作。请注意，数组 API 的trace不允许指定要操作的轴。

操作函数差异

特性	类型	注释
各种函数已更名	兼容	参见函数名称更改。
concat具有与np.concatenate不同的默认转换规则	严格性	不允许跨类型转换。���标量上没有基于值的转换（当 axis=None 时）。
stack具有与np.stack不同的默认转换规则	严格性	不允许跨类型转换。
新函数permute_dims。	兼容	与np.transpose不同，permute_dims需要axis关键字参数。
reshape函数具有copy关键字参数	兼容	参见github.com/numpy/numpy/issues/9818。

集合函数差异

特性	类型	注释
新函数unique_all、unique_counts、unique_inverse和unique_values。	兼容	参见函数名称更改。
四个unique_*函数返回一个命名元组。	兼容
unique_all和unique_indices返回与x相同形状的索引。	兼容	参见github.com/numpy/numpy/issues/20638。

集合函数差异

特性	类型	注释
argsort和sort具有stable关键字参数而不是kind。	破坏性	stable是一个布尔关键字参数，默认为True。 kind接受一个字符串，默认为"quicksort"。 stable=True等同于kind="stable"，kind=False等同于kind="quicksort"，尽管在stable=False时允许任何排序算法。 新标志名称兼容，但默认更改是破坏性的。
argsort和sort具有descending关键字参数。	兼容

统计函数差异

特性	类型	注释
sum 和 prod 在 dtype=None 时总是将 float32 上转型为 float64。	破坏性
std 和 var 函数有一个 correction 关键字参数，而不是 ddof。	兼容性

其他差异

特性	类型	注释
Dtypes 只能以 dtype 对象的形式拼写。	严格性	例如，numpy.array_api.asarray([0], dtype='int32') 是不允许的。
asarray 在任何函数中都不会被隐式调用。	严格性	例外情况是 Python 运算符，在某些情况下接受 Python 标量（参见类型提升差异）。
tril 和 triu 要求输入至少为 2-D。	严格性
finfo() 返回类型使用 float 作为各个属性。	严格性	规范允许鸭子类型，因此 finfo 返回 dtype 标量被认为与 float 兼容。
每个函数中的位置参数都是仅限位置的。	破坏性	查看每个函数的确切签名的规范。请注意，NumPy 的 ufuncs 已经使用了仅限位置的参数，但非 ufunc，如 asarray 通常不会。