NumPy-1-26-中文文档-十四-

NumPy 1.26 中文文档（十四）

原文：numpy.org/doc/

`numpy.ma.corrcoef`

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

ma.corrcoef(x, y=None, rowvar=True, bias=<no value>, allow_masked=True, ddof=<no value>)

返回皮尔逊积矩相关系数。

除了处理缺失数据外，此函数与numpy.corrcoef执行相同。更多细节和示例，请参见numpy.corrcoef。

参数:

xarray_like

包含多个变量和观察值的一维或二维数组。 x的每一行代表一个变量，每一列代表所有这些变量的单个观察值。另请参见下面的rowvar。

yarray_like，可选

一组额外的变量和观察值。y的形状与x相同。

rowvarbool，可选

如果rowvar为 True（默认值），则每行代表一个变量，观察值在列中。否则，关系被转置：每列代表一个变量，而行包含观察值。

bias_NoValue，可选

没有效果，不要使用。

自 1.10.0 版起已弃用。

allow_maskedbool，可选

如果为 True，则掩码值会成对传播：如果x中的值被掩码，那么y中的对应值也会被掩码。如果为 False，则会引发异常。因为bias已被弃用，必须将此参数视为仅限关键字，以避免警告。

ddof_NoValue，可选

没有效果，不要使用。

自 1.10.0 版起已弃用。

另请参见

numpy.corrcoef

顶层 NumPy 模块中的等效函数。

cov

估计协方差矩阵。

注释

这个函数接受但丢弃了偏差和自由度的参数。这是为了与该函数先前版本的向后兼容性。这些参数对函数的返回值没有影响，在这个版本和以前的版本中都可以安全地忽略。

`numpy.ma.cov`

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

ma.cov(x, y=None, rowvar=True, bias=False, allow_masked=True, ddof=None)

估计协方差矩阵。

除了处理缺失数据外，此函数的操作与 numpy.cov 相同。有关详细信息和示例，请参阅 numpy.cov。

默认情况下，掩码值会被识别。如果 x 和 y 具有相同的形状，会分配一个通用掩码：如果 x[i,j] 被掩盖，则 y[i,j] 也会被掩盖。将 allow_masked 设置为 False 将在输入数组中的值缺失时引发异常。

参数：

x array_like

包含多个变量和观察的 1-D 或 2-D 数组。x 的每一行表示一个变量，每一列表示所有这些变量的单个观察。也请参阅下面的 rowvar。

y array_like，可选

附加的一组变量和观察。y 与 x 具有相同的形状。

rowvar bool，可选

如果 rowvar 为 True（默认值），那么每一行表示一个变量，列中包含观察。否则，关系被转置：每列表示一个变量，而行包含观察。

bias bool，可选

默认的归一化（False）为 (N-1)，其中 N 是给定的观察数量（无偏估计）。如果 bias 为 True，则归一化为 N。此关键字可以被 numpy 版本 >= 1.5 中的关键字 ddof 覆盖。

allow_masked bool，可选

如果为 True，则掩码值成对传播：如果 x 中的值被掩盖，则 y 中的相应值也会被掩盖。如果为 False，在一些值缺失时引发 ValueError 异常。

ddof {None, int}，可选

如果不是 None，则归一化为 (N - ddof)，其中 N 为观察数量；这将覆盖 bias 暗示的值。默认值为 None。

1.5 版本中的新功能。

引发异常：

值错误

如果存在缺失值且 allow_masked 为 False，则引发。

另请参见

numpy.cov

`numpy.ma.cumsum`

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

ma.cumsum(self, axis=None, dtype=None, out=None) = <numpy.ma.core._frommethod object>

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

在计算过程中，掩码值被设置为 0。然而，它们的位置被保存，结果将在相同位置被掩码。

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

另请参阅

numpy.ndarray.cumsum

对于 ndarrays 的对应函数

numpy.cumsum

等效函数

注意事项

如果out不是有效的ma.MaskedArray，掩码将丢失！

当使用整数类型时，算术运算是模运算的，溢出时不会引发错误。

示例

>>> marr = np.ma.array(np.arange(10), mask=[0,0,0,1,1,1,0,0,0,0])
>>> marr.cumsum()
masked_array(data=[0, 1, 3, --, --, --, 9, 16, 24, 33],
 mask=[False, False, False,  True,  True,  True, False, False,
 False, False],
 fill_value=999999)

`numpy.ma.cumprod`

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

ma.cumprod(self, axis=None, dtype=None, out=None) = <numpy.ma.core._frommethod object>

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

在计算过程中，遮罩值被设置为 1。但是它们的位置被保存，结果将在相同位置被遮罩。

有关完整文档，请参考numpy.cumprod。

另请参阅

numpy.ndarray.cumprod

ndarrays 的对应函数

numpy.cumprod

等效函数

注意

如果out不是有效的 MaskedArray，则遮罩将丢失！

在使用整数类型时，算术运算是模数的，并且在溢出时不会引发错误。

`numpy.ma.mean`

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

ma.mean(self, axis=None, dtype=None, out=None, keepdims=<no value>) = <numpy.ma.core._frommethod object>

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

掩码条目将被忽略，并且不是有限的结果元素将被掩码。

请参考完整文档。

另请参阅

numpy.ndarray.mean

对应于 ndarrays 的函数

numpy.mean

等效函数

numpy.ma.average

加权平均。

示例

>>> a = np.ma.array([1,2,3], mask=[False, False, True])
>>> a
masked_array(data=[1, 2, --],
 mask=[False, False,  True],
 fill_value=999999)
>>> a.mean()
1.5

`numpy.ma.median`

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

ma.median(a, axis=None, out=None, overwrite_input=False, keepdims=False)

沿指定轴计算中位数。

返回数组元素的中位数。

参数：

aarray_like

输入数组或可转换为数组的对象。

axisint，可选

计算中位数的轴。默认值（None）是沿数组的扁平化版本计算中位数。

outndarray，可选

替代输出数组，用于存放结果。它必须具有与预期输出相同的形状和缓冲区长度，但如果需要，类型将被转换。

overwrite_inputbool，可选

如果为 True，则允许使用输入数组（a）的内存进行计算。调用中位数时，输入数组将被修改。当您不需要保留输入数组的内容时，这将节省内存。将输入视为未定义，但可能已完全或部分排序。默认值为 False。请注意，如果overwrite_input为 True，并且输入尚未是ndarray，则会引发错误。

keepdimsbool，可选

如果设置为 True，则被减少的轴将作为大小为一的维度保留在结果中。使用此选项，结果将正确广播到输入数组。

1.10.0 版本中的新功能。

medianndarray

除非指定了 out，否则将返回一个保存结果的新数组。对于小于float64的整数和浮点数，返回数据类型为float64，否则为输入数据类型。

另请参阅

mean

注意

给定一个具有N个非掩码值的向量V，V的中位数是V的排序副本的中间值（即Vs[(N-1)/2]，当N为奇数时，或{Vs[N/2 - 1] + Vs[N/2]}/2，当N为偶数时。

示例

>>> x = np.ma.array(np.arange(8), mask=[0]*4 + [1]*4)
>>> np.ma.median(x)
1.5

>>> x = np.ma.array(np.arange(10).reshape(2, 5), mask=[0]*6 + [1]*4)
>>> np.ma.median(x)
2.5
>>> np.ma.median(x, axis=-1, overwrite_input=True)
masked_array(data=[2.0, 5.0],
 mask=[False, False],
 fill_value=1e+20)

`numpy.ma.power`

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

ma.power(a, b, third=None)

返回元素级别的基本数组提升到第二个数组的幂。

这是numpy.power的掩码数组版本。有关详细信息，请参阅numpy.power。

另请参阅

numpy.power

注意事项

numpy.power中的out参数不受支持，third必须为 None。

示例

>>> import numpy.ma as ma
>>> x = [11.2, -3.973, 0.801, -1.41]
>>> mask = [0, 0, 0, 1]
>>> masked_x = ma.masked_array(x, mask)
>>> masked_x
masked_array(data=[11.2, -3.973, 0.801, --],
 mask=[False, False, False,  True],
 fill_value=1e+20)
>>> ma.power(masked_x, 2)
masked_array(data=[125.43999999999998, 15.784728999999999,
 0.6416010000000001, --],
 mask=[False, False, False,  True],
 fill_value=1e+20)
>>> y = [-0.5, 2, 0, 17]
>>> masked_y = ma.masked_array(y, mask)
>>> masked_y
masked_array(data=[-0.5, 2.0, 0.0, --],
 mask=[False, False, False,  True],
 fill_value=1e+20)
>>> ma.power(masked_x, masked_y)
masked_array(data=[0.29880715233359845, 15.784728999999999, 1.0, --],
 mask=[False, False, False,  True],
 fill_value=1e+20)

`numpy.ma.prod`

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

ma.prod(self, axis=None, dtype=None, out=None, keepdims=<no value>) = <numpy.ma.core._frommethod object>

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

屏蔽元素在计算时内部被设置为 1。

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

另请参阅

numpy.ndarray.prod

ndarrays 的对应函数

numpy.prod

等效函数

注意事项

当使用整数类型时，算术运算是模块化的，溢出时不会引发错误。

`numpy.ma.std`

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

ma.std(self, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>) = <numpy.ma.core._frommethod object>

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

忽略掩码条目。

请参考numpy.std获取完整文档。

另请参阅

numpy.ndarray.std

ndarrays 的对应函数

numpy.std

等效函数

`numpy.ma.sum`

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

ma.sum(self, axis=None, dtype=None, out=None, keepdims=<no value>) = <numpy.ma.core._frommethod object>

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

屏蔽元素在内部被设为 0。

请参考numpy.sum获取完整文档。

另请参阅

numpy.ndarray.sum

ndarrays 的对应函数

numpy.sum

等效函数

示例

>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> x
masked_array(
 data=[[1, --, 3],
 [--, 5, --],
 [7, --, 9]],
 mask=[[False,  True, False],
 [ True, False,  True],
 [False,  True, False]],
 fill_value=999999)
>>> x.sum()
25
>>> x.sum(axis=1)
masked_array(data=[4, 5, 16],
 mask=[False, False, False],
 fill_value=999999)
>>> x.sum(axis=0)
masked_array(data=[8, 5, 12],
 mask=[False, False, False],
 fill_value=999999)
>>> print(type(x.sum(axis=0, dtype=np.int64)[0]))
<class 'numpy.int64'>

`numpy.ma.var`

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

ma.var(self, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>) = <numpy.ma.core._frommethod object>

沿指定轴计算方差。

返回数组元素的方差，这是分布扩展的度量。默认情况下，计算平坦数组的方差，否则在指定轴上计算。

参数：

aarray_like

包含所需方差的数字的数组。如果a不是数组，则会尝试转换。

axisNone 或整数或整数元组，可选

计算方差的轴或轴。默认值是计算平坦数组的方差。

新版本为 1.7.0。

如果这是一个整数元组，则在多个轴上执行方差计算，而不是像以前那样在单个轴或所有轴上执行。

dtype数据类型，可选

用于计算方差的类型。对于整数类型的数组，默认值为float64；对于浮点类型的数组，与数组类型相同。

outndarray，可选

替代输出数组，其中放置结果。它必须具有与预期输出相同的形状，但必要时会进行类型转换。

ddof整数，可选

“自由度差异”：计算中使用的除数为N - ddof，其中N表示元素数量。默认情况下ddof为零。

keepdims布尔类型，可选

如果设置为 True，则被减少的轴将作为大小为一的维度保留在结果中。使用此选项，结果将正确广播到输入数组。

如果传递了默认值，则keepdims将不会传递给var的子类方法，但任何非默认值将会传递。如果子类方法不实现keepdims，则会引发任何异常。

where布尔类型的 array_like，可选

要包含在方差中的元素。有关详细信息，请参见reduce。

新版本为 1.20.0。

方差ndarray，请参见上面的 dtype 参数

如果out=None，则返回一个包含方差的新数组；否则，返回对输出数组的引用。

参见

std，mean，nanmean，nanstd，nanvar

输出类型确定

注意

方差是平均值与平均值的平方偏差之间的平均值，即var = mean(x)，其中x = abs(a - a.mean())**2。

均值通常计算为x.sum() / N，其中N = len(x)。然而，如果指定了ddof，则除数改为N - ddof。在标准统计实践中，ddof=1提供了一个对假设的无限总体方差的无偏估计。ddof=0为正态分布变量的方差提供了最大似然估计。

请注意，对于复数，先取绝对值再平方，以确保结果始终为实数且非负。

对于浮点输入，方差是使用输入具有的相同精度计算的。根据输入数据的不同，这可能导致结果不准确，特别是对于float32（见下面的示例）。使用dtype关键字指定更高精度的累加器可以缓解这个问题。

示例

>>> a = np.array([[1, 2], [3, 4]])
>>> np.var(a)
1.25
>>> np.var(a, axis=0)
array([1.,  1.])
>>> np.var(a, axis=1)
array([0.25,  0.25])

在单精度中，var()可能不准确：

>>> a = np.zeros((2, 512*512), dtype=np.float32)
>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.var(a)
0.20250003

在 float64 中计算方差更准确：

>>> np.var(a, dtype=np.float64)
0.20249999932944759 # may vary
>>> ((1-0.55)**2 + (0.1-0.55)**2)/2
0.2025

指定 where 参数：

>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
>>> np.var(a)
6.833333333333333 # may vary
>>> np.var(a, where=[[True], [True], [False]])
4.0

`numpy.ma.MaskedArray.anom`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.anom.html

方法

ma.MaskedArray.anom(axis=None, dtype=None)

计算沿给定轴的异常值（与算术平均值的偏差）。

返回一个异常值数组，形状与输入相同，其中算术平均值沿给定轴计算。

参数：

axisint，可选

采取异常值的轴。默认值是使用扁平化数组的平均值作为参考。

dtypedtype，可选

用于计算方差的类型。对于整数类型的数组

默认为 float32；对于浮点类型的数组，与数组类型相同。

另请参阅

mean

计算数组的均值。

示例

>>> a = np.ma.array([1,2,3])
>>> a.anom()
masked_array(data=[-1.,  0.,  1.],
 mask=False,
 fill_value=1e+20)

`numpy.ma.MaskedArray.cumprod`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.cumprod.html

方法

ma.MaskedArray.cumprod(axis=None, dtype=None, out=None)

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

在计算过程中，掩码值在内部被设置为 1。然而，它们的位置被保存，结果将在相同位置被掩码。

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

另请参阅

numpy.ndarray.cumprod

对于 ndarrays 的对应函数

numpy.cumprod

等效函数

注意

如果out不是有效的 MaskedArray，则掩码将丢失！

当使用整数类型时，算术运算是模运算，溢出时不会引发错误。

`numpy.ma.MaskedArray.cumsum`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.cumsum.html

方法

ma.MaskedArray.cumsum(axis=None, dtype=None, out=None)

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

在计算过程中，被屏蔽的数值在内部被设为 0。然而，它们的位置被保存，结果将在相同位置被屏蔽。

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

另请参阅

numpy.ndarray.cumsum

适用于 ndarrays 的对应函数

numpy.cumsum

等效函数

注意

如果out不是有效的ma.MaskedArray，则掩码将丢失！

在使用整数类型时，算术运算是模运算，溢出时不会引发错误。

示例

>>> marr = np.ma.array(np.arange(10), mask=[0,0,0,1,1,1,0,0,0,0])
>>> marr.cumsum()
masked_array(data=[0, 1, 3, --, --, --, 9, 16, 24, 33],
 mask=[False, False, False,  True,  True,  True, False, False,
 False, False],
 fill_value=999999)

`numpy.ma.MaskedArray.mean`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.mean.html

方法

ma.MaskedArray.mean(axis=None, dtype=None, out=None, keepdims=<no value>)

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

忽略掩码条目，并且不是有限的结果元素将被掩码。

参考numpy.mean获取完整文档。

另请参阅

numpy.ndarray.mean

适用于 ndarrays 的对应函数

numpy.mean

等效函数

numpy.ma.average

加权平均值。

示例

>>> a = np.ma.array([1,2,3], mask=[False, False, True])
>>> a
masked_array(data=[1, 2, --],
 mask=[False, False,  True],
 fill_value=999999)
>>> a.mean()
1.5

`numpy.ma.MaskedArray.prod`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.prod.html

方法

ma.MaskedArray.prod(axis=None, dtype=None, out=None, keepdims=<no value>)

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

掩码元素在计算时内部设置为 1。

参考numpy.prod获取完整文档。

另请参阅

numpy.ndarray.prod

用于 ndarrays 的对应函数

numpy.prod

等效函数

注意事项

当使用整数类型时，算术运算是模运算，溢出时不会引发错误。

`numpy.ma.MaskedArray.std`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.std.html

方法

ma.MaskedArray.std(axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>)

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

忽略掩码条目。

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

另请参阅

numpy.ndarray.std

对应于 ndarrays 的函数

numpy.std

等效函数

`numpy.ma.MaskedArray.sum`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.sum.html

方法

ma.MaskedArray.sum(axis=None, dtype=None, out=None, keepdims=<no value>)

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

掩盖元素在内部被设置为 0。

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

另请参阅

numpy.ndarray.sum

ndarrays 的对应函数

numpy.sum

等效函数

示例

>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> x
masked_array(
 data=[[1, --, 3],
 [--, 5, --],
 [7, --, 9]],
 mask=[[False,  True, False],
 [ True, False,  True],
 [False,  True, False]],
 fill_value=999999)
>>> x.sum()
25
>>> x.sum(axis=1)
masked_array(data=[4, 5, 16],
 mask=[False, False, False],
 fill_value=999999)
>>> x.sum(axis=0)
masked_array(data=[8, 5, 12],
 mask=[False, False, False],
 fill_value=999999)
>>> print(type(x.sum(axis=0, dtype=np.int64)[0]))
<class 'numpy.int64'>

`numpy.ma.MaskedArray.var`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.var.html

方法

ma.MaskedArray.var(axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>)

计算沿指定轴的方差。

返回数组元素的方差，是分布扩散的度量。默认情况下，对扁平化数组计算方差，否则沿指定轴计算。

参数:

a类似数组

包含所需方差的数字的数组。如果 a 不是数组，则尝试转换。

axisNone 或整数或整数元组，可选

计算方差的轴或轴。默认是计算扁平化数组的方差。

新版本 1.7.0 中新增。

如果这是整数元组，则在多个轴上执行方差计算，而不是像以前那样在单个轴或所有轴上执行。

dtype数据类型，可选

用于计算方差的类型。对于整数类型的数组，默认值为 float64；对于浮点类型的数组，与数组类型相同。

outndarray，可选

替代输出数组，用于放置结果。它必须具有与预期输出相同的形状，但必要时进行类型转换。

ddof整数，可选

“自由度差”: 计算中使用的除数为 N - ddof，其中 N 表示元素数量。默认情况下 ddof 为零。

keepdims布尔值，可选

如果设置为 True，则被减少的轴将作为大小为一的维度保留在结果中。使用此选项，结果将正确广播到输入数组。

如果传递了默认值，则 keepdims 将不会传递给 var 的子类方法，但任何非默认值将会传递。如果子类方法没有实现 keepdims，则会引发任何异常。

where布尔值数组，可选

包含在方差中的元素。有关详细信息，请参阅 reduce。

新版本 1.20.0 中新增。

variancendarray，参见上述 dtype 参数

如果 out=None，则返回一个包含方差的新数组；否则，返回对输出数组的引用。

另请参见

std, mean, nanmean, nanstd, nanvar

输出类型确定

注意

方差是平均值与平均值的平方偏差的平均值，即 var = mean(x)，其中 x = abs(a - a.mean())**2。

均值通常计算为 x.sum() / N，其中 N = len(x)。然而，如果指定了 ddof，则使用除数 N - ddof。在标准统计实践中，ddof=1 提供了一个无偏的估计值，用于估计假设的无限总体的方差。ddof=0 为正态分布变量的方差提供了最大似然估计。

请注意，对于复数，先取绝对值再平方，以确保结果始终为实数且非负。

对于浮点输入，方差是使用与输入相同精度计算的。根据输入数据的不同，这可能导致结果不准确，特别是对于float32（见下面的示例）。使用 dtype 关键字指定更高精度的累加器可以缓解这个问题。

示例

>>> a = np.array([[1, 2], [3, 4]])
>>> np.var(a)
1.25
>>> np.var(a, axis=0)
array([1.,  1.])
>>> np.var(a, axis=1)
array([0.25,  0.25])

在单精度下，var() 可能不准确：

>>> a = np.zeros((2, 512*512), dtype=np.float32)
>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.var(a)
0.20250003

在 float64 中计算方差更准确：

>>> np.var(a, dtype=np.float64)
0.20249999932944759 # may vary
>>> ((1-0.55)**2 + (0.1-0.55)**2)/2
0.2025

指定 where 参数：

>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
>>> np.var(a)
6.833333333333333 # may vary
>>> np.var(a, where=[[True], [True], [False]])
4.0

`numpy.ma.argmax`

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

ma.argmax(self, axis=None, fill_value=None, out=None) = <numpy.ma.core._frommethod object>

返回沿给定轴的最大值的索引数组。掩码值被视为具有填充值的值。

参数：

轴

如果为 None，则索引是在展平的数组中，否则沿着指定的轴

填充值标量或 None，可选

用于填充掩码值的数值。如果为 None，则使用 maximum_fill_value(self._data)的输出。

输出，可选

结果可以放置到的数组。其类型保持不变，必须具有正确的形状以容纳输出。

索引数组

示例

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

`numpy.ma.argmin`

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

ma.argmin(self, axis=None, fill_value=None, out=None) = <numpy.ma.core._frommethod object>

返回沿给定轴的最小值的索引数组。

参数：

axis

如果为 None，则索引是在展平的数组中，否则沿指定轴

fill_value标量或 None，可选

用于填充掩码值的值。如果为 None，则使用 minimum_fill_value(self._data) 的输出。

out，可选

结果可以放置的数组。其类型被保留，必须具有正确的形状以容纳输出。

ndarray 或标量

如果输入是多维的，则返回沿给定轴的最小值的索引数组。否则，返回沿给定轴的最小值的索引标量。

示例

>>> x = np.ma.array(np.arange(4), mask=[1,1,0,0])
>>> x.shape = (2,2)
>>> x
masked_array(
 data=[[--, --],
 [2, 3]],
 mask=[[ True,  True],
 [False, False]],
 fill_value=999999)
>>> x.argmin(axis=0, fill_value=-1)
array([0, 0])
>>> x.argmin(axis=0, fill_value=9)
array([1, 1])

`numpy.ma.max`

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

ma.max(obj, axis=None, out=None, fill_value=None, keepdims=<no value>)

返回沿指定轴的最大值。

参数：

axisNone 或 int 或 int 元组，可选

操作的轴。默认情况下，axis为 None，使用扁平化的输入。.. versionadded:: 1.7.0 如果这是一个 int 元组，则选择多个轴上的最大值，而不是像以前那样在单个轴或所有轴上选择。

out类似数组，可选

替代输出数组，用于放置结果。必须与预期输出的形状和缓冲区长度相同。

fill_value标量或 None，可选

用于填充掩码值的值。如果为 None，则使用 maximum_fill_value()的输出。

keepdims布尔值，可选

如果设置为 True，则减少的轴将作为大小为一的维度保留在结果中。使用此选项，结果将正确广播到数组。

amax类似数组

持有结果的新数组。如果指定了out，则返回out。

参见

ma.maximum_fill_value

返回给定数据类型的最大填充值。

示例

>>> import numpy.ma as ma
>>> x = [[-1., 2.5], [4., -2.], [3., 0.]]
>>> mask = [[0, 0], [1, 0], [1, 0]]
>>> masked_x = ma.masked_array(x, mask)
>>> masked_x
masked_array(
 data=[[-1.0, 2.5],
 [--, -2.0],
 [--, 0.0]],
 mask=[[False, False],
 [ True, False],
 [ True, False]],
 fill_value=1e+20)
>>> ma.max(masked_x)
2.5
>>> ma.max(masked_x, axis=0)
masked_array(data=[-1.0, 2.5],
 mask=[False, False],
 fill_value=1e+20)
>>> ma.max(masked_x, axis=1, keepdims=True)
masked_array(
 data=[[2.5],
 [-2.0],
 [0.0]],
 mask=[[False],
 [False],
 [False]],
 fill_value=1e+20)
>>> mask = [[1, 1], [1, 1], [1, 1]]
>>> masked_x = ma.masked_array(x, mask)
>>> ma.max(masked_x, axis=1)
masked_array(data=[--, --, --],
 mask=[ True,  True,  True],
 fill_value=1e+20,
 dtype=float64)

`numpy.ma.min`

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

ma.min(obj, axis=None, out=None, fill_value=None, keepdims=<no value>)

沿着给定轴返回最小值。

参数：

axisNone 或 int 或整数元组，可选

沿着其操作的轴。默认情况下，axis为 None，使用扁平化的输入。.. versionadded:: 1.7.0 如果这是一个整数元组，则选择多个轴上的最小值，而不是像以前那样在单个轴或所有轴上选择。

out类似数组，可选

替代输出数组，用于放置结果。必须与预期输出的形状和缓冲区长度相同。

fill_value标量或 None，可选

用于填充掩码值的值。如果为 None，则使用minimum_fill_value的输出。

keepdimsbool，可选

如果设置为 True，则被减少的轴将作为大小为一的维度保留在结果中。使用此选项，结果将正确广播到数组。

amin类似数组

包含结果的新数组。如果指定了out，则返回out。

另请参见

ma.minimum_fill_value

返回给定数据类型的最小填充值。

示例

>>> import numpy.ma as ma
>>> x = [[1., -2., 3.], [0.2, -0.7, 0.1]]
>>> mask = [[1, 1, 0], [0, 0, 1]]
>>> masked_x = ma.masked_array(x, mask)
>>> masked_x
masked_array(
 data=[[--, --, 3.0],
 [0.2, -0.7, --]],
 mask=[[ True,  True, False],
 [False, False,  True]],
 fill_value=1e+20)
>>> ma.min(masked_x)
-0.7
>>> ma.min(masked_x, axis=-1)
masked_array(data=[3.0, -0.7],
 mask=[False, False],
 fill_value=1e+20)
>>> ma.min(masked_x, axis=0, keepdims=True)
masked_array(data=[[0.2, -0.7, 3.0]],
 mask=[[False, False, False]],
 fill_value=1e+20)
>>> mask = [[1, 1, 1,], [1, 1, 1]]
>>> masked_x = ma.masked_array(x, mask)
>>> ma.min(masked_x, axis=0)
masked_array(data=[--, --, --],
 mask=[ True,  True,  True],
 fill_value=1e+20,
 dtype=float64)

`numpy.ma.ptp`

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

ma.ptp(obj, axis=None, out=None, fill_value=None, keepdims=<no value>)

沿给定维度返回（最大值 - 最小值）（即峰峰值）。

警告

ptp保留数组的数据类型。这意味着对于带有 n 位的有符号整数输入（例如np.int8，np.int16等），返回值也是带有 n 位的有符号整数。在这种情况下，大于2**(n-1)-1的峰峰值将作为负值返回。下面显示了一个带有解决方法的示例。

参数：

轴，可选

用于查找峰值的轴。如果为 None（默认），则使用扁平化的数组。

out，可选

替代输出数组，用于放置结果。它必须具有与预期输出相同的形状和缓冲区长度，但必要时将进行类型转换。

fill_value标量或无，可选

用于填充掩码值的值。

keepdims布尔值，可选

如果设置为 True，则被减少的轴将作为大小为一的维度保留在结果中。使用此选项，结果将正确地广播到数组。

ptp数组。

一个新的数组保存结果，除非指定了out，否则将返回对out的引用。

示例

>>> x = np.ma.MaskedArray([[4, 9, 2, 10],
...                        [6, 9, 7, 12]])

>>> x.ptp(axis=1)
masked_array(data=[8, 6],
 mask=False,
 fill_value=999999)

>>> x.ptp(axis=0)
masked_array(data=[2, 0, 5, 2],
 mask=False,
 fill_value=999999)

>>> x.ptp()
10

此示例显示，当输入为带符号整数数组时，可能会返回负值。

>>> y = np.ma.MaskedArray([[1, 127],
...                        [0, 127],
...                        [-1, 127],
...                        [-2, 127]], dtype=np.int8)
>>> y.ptp(axis=1)
masked_array(data=[ 126,  127, -128, -127],
 mask=False,
 fill_value=999999,
 dtype=int8)

一个解决方法是使用view()方法将结果视为具有相同位宽的无符号整数：

>>> y.ptp(axis=1).view(np.uint8)
masked_array(data=[126, 127, 128, 129],
 mask=False,
 fill_value=999999,
 dtype=uint8)

`numpy.ma.diff`

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

ma.diff(a, /, n=1, axis=-1, prepend=<no value>, append=<no value>)

沿着给定轴计算第 n 个离散差分。第一个差分由out[i] = a[i+1] - a[i]给出，沿着给定轴，更高阶的差分通过递归使用diff来计算。保留输入的掩码。

参数：

aarray_like

输入数组

nint，可选

差分的次数。如果为零，则返回输入数组本身。

axisint，可选

进行差分的轴，默认为最后一个轴。

prepend, appendarray_like，可选

要在执行差分之前沿着轴添加或附加到a的值。标量值在轴的方向上扩展为具有长度 1 的数组，并且在所有其他轴上的形状与输入数组的形状相同。否则，维度和形状必须与a相匹配，除了在轴上。

diffMaskedArray

第 n 个差分。输出的形状与a相同，除了在axis上的维度减小了n。输出的类型与a的任意两个元素之间的差异的类型相同。在大多数情况下，这与a的类型相同。一个值得注意的例外是datetime64，它会导致一个timedelta64输出数组。

参见

numpy.diff

在顶级 NumPy 模块中的等效函数。

注意

对于布尔数组，类型将被保留，因此当连续元素相同时结果将包含False，当它们不同时将包含True。

对于无符号整数数组，结果也将是无符号的。这并不奇怪，因为结果与直接计算差异是一致的：

>>> u8_arr = np.array([1, 0], dtype=np.uint8)
>>> np.ma.diff(u8_arr)
masked_array(data=[255],
 mask=False,
 fill_value=999999,
 dtype=uint8)
>>> u8_arr[1,...] - u8_arr[0,...]
255

如果不希望这样，那么数组应首先转换为较大的整数类型：

>>> i16_arr = u8_arr.astype(np.int16)
>>> np.ma.diff(i16_arr)
masked_array(data=[-1],
 mask=False,
 fill_value=999999,
 dtype=int16)

示例

>>> a = np.array([1, 2, 3, 4, 7, 0, 2, 3])
>>> x = np.ma.masked_where(a < 2, a)
>>> np.ma.diff(x)
masked_array(data=[--, 1, 1, 3, --, --, 1],
 mask=[ True, False, False, False,  True,  True, False],
 fill_value=999999)

>>> np.ma.diff(x, n=2)
masked_array(data=[--, 0, 2, --, --, --],
 mask=[ True, False, False,  True,  True,  True],
 fill_value=999999)

>>> a = np.array([[1, 3, 1, 5, 10], [0, 1, 5, 6, 8]])
>>> x = np.ma.masked_equal(a, value=1)
>>> np.ma.diff(x)
masked_array(
 data=[[--, --, --, 5],
 [--, --, 1, 2]],
 mask=[[ True,  True,  True, False],
 [ True,  True, False, False]],
 fill_value=1)

>>> np.ma.diff(x, axis=0)
masked_array(data=[[--, --, --, 1, -2]],
 mask=[[ True,  True,  True, False, False]],
 fill_value=1)

`numpy.ma.MaskedArray.argmax`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.argmax.html

方法

ma.MaskedArray.argmax(axis=None, fill_value=None, out=None, *, keepdims=<no value>)

返回沿给定轴的最大值的索引数组。掩盖的值被视为具有填充值。

参数：

axis

如果为 None，则索引是在扁平化的数组中，否则沿着指定的轴

fill_value标量或 None，可选

用于填充掩码值的值。如果为 None，则使用 maximum_fill_value(self._data)的输出。

out，可选

结果可以放置的数组。其类型保持不变，必须具有正确的形状以容纳输出。

index_array

示例

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

`numpy.ma.MaskedArray.argmin`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.argmin.html

方法

ma.MaskedArray.argmin(axis=None, fill_value=None, out=None, *, keepdims=<no value>)

返回沿着给定轴的最小值的索引数组。

参数：

axis

如果为 None，则索引是到扁平化数组，否则沿指定轴

fill_value标量或 None，可选

用于填充掩码值的值。如果为 None，则使用 minimum_fill_value(self._data)的输出。

out，可选

结果可以放置的数组。其类型被保留，必须具有正确的形状以容纳输出。

ndarray 或标量

如果是多维输入，则返回沿给定轴的最小值的索引的新 ndarray。否则，返回沿给定轴的最小值的索引的标量。

示例

>>> x = np.ma.array(np.arange(4), mask=[1,1,0,0])
>>> x.shape = (2,2)
>>> x
masked_array(
 data=[[--, --],
 [2, 3]],
 mask=[[ True,  True],
 [False, False]],
 fill_value=999999)
>>> x.argmin(axis=0, fill_value=-1)
array([0, 0])
>>> x.argmin(axis=0, fill_value=9)
array([1, 1])

`numpy.ma.MaskedArray.max`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.max.html

方法

ma.MaskedArray.max(axis=None, out=None, fill_value=None, keepdims=<no value>)

返回沿给定轴的最大值。

参数：

axisNone 或整数或整数元组，可选

操作的轴。默认情况下，axis为 None，使用扁平化的输入。 .. versionadded:: 1.7.0 如果这是一个整数元组，则选择多个轴上的最大值，而不是以前的单个轴或所有轴。

out类似数组，可选

替代输出数组，用于存放结果。必须与预期输出的形状和缓冲长度相同。

fill_value标量或 None，可选

用于填充掩码值的值。如果为 None，则使用 maximum_fill_value()的输出。

keepdims布尔值，可选

如果设置为 True，则被减少的轴将保留在结果中作为大小为一的维度。使用此选项，结果将正确广播到数组。

amax类似数组

存储结果的新数组。如果指定了out，则返回out。

另请参见

ma.maximum_fill_value

返回给定数据类型的最大填充值。

示例

>>> import numpy.ma as ma
>>> x = [[-1., 2.5], [4., -2.], [3., 0.]]
>>> mask = [[0, 0], [1, 0], [1, 0]]
>>> masked_x = ma.masked_array(x, mask)
>>> masked_x
masked_array(
 data=[[-1.0, 2.5],
 [--, -2.0],
 [--, 0.0]],
 mask=[[False, False],
 [ True, False],
 [ True, False]],
 fill_value=1e+20)
>>> ma.max(masked_x)
2.5
>>> ma.max(masked_x, axis=0)
masked_array(data=[-1.0, 2.5],
 mask=[False, False],
 fill_value=1e+20)
>>> ma.max(masked_x, axis=1, keepdims=True)
masked_array(
 data=[[2.5],
 [-2.0],
 [0.0]],
 mask=[[False],
 [False],
 [False]],
 fill_value=1e+20)
>>> mask = [[1, 1], [1, 1], [1, 1]]
>>> masked_x = ma.masked_array(x, mask)
>>> ma.max(masked_x, axis=1)
masked_array(data=[--, --, --],
 mask=[ True,  True,  True],
 fill_value=1e+20,
 dtype=float64)

`numpy.ma.MaskedArray.min`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.min.html

方法

ma.MaskedArray.min(axis=None, out=None, fill_value=None, keepdims=<no value>)

沿着给定轴的最小值。

参数：

axis None 或整数或整数元组，可选

操作的轴。默认情况下，axis为 None，使用扁平化的输入。.. versionadded:: 1.7.0 如果这是一个整数元组，则选择多个轴上的最小值，而不是像以前那样在单个轴或所有轴上选择。

out 类似数组，可选

替代输出数组，其中放置结果。必须与预期输出具有相同的形状和缓冲区长度。

fill_value 标量或 None，可选

用于填充掩码值的值。如果为 None，则使用minimum_fill_value的输出。

keepdims 布尔值，可选

如果设置为 True，则被减少的轴将作为大小为一的维度保留在结果中。使用此选项，结果将正确广播到数组。

amin 类似数组

包含结果的新数组。如果指定了out，则返回out。

另请参阅

ma.minimum_fill_value

返回给定数据类型的最小填充值。

示例

>>> import numpy.ma as ma
>>> x = [[1., -2., 3.], [0.2, -0.7, 0.1]]
>>> mask = [[1, 1, 0], [0, 0, 1]]
>>> masked_x = ma.masked_array(x, mask)
>>> masked_x
masked_array(
 data=[[--, --, 3.0],
 [0.2, -0.7, --]],
 mask=[[ True,  True, False],
 [False, False,  True]],
 fill_value=1e+20)
>>> ma.min(masked_x)
-0.7
>>> ma.min(masked_x, axis=-1)
masked_array(data=[3.0, -0.7],
 mask=[False, False],
 fill_value=1e+20)
>>> ma.min(masked_x, axis=0, keepdims=True)
masked_array(data=[[0.2, -0.7, 3.0]],
 mask=[[False, False, False]],
 fill_value=1e+20)
>>> mask = [[1, 1, 1,], [1, 1, 1]]
>>> masked_x = ma.masked_array(x, mask)
>>> ma.min(masked_x, axis=0)
masked_array(data=[--, --, --],
 mask=[ True,  True,  True],
 fill_value=1e+20,
 dtype=float64)

`numpy.ma.MaskedArray.ptp`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.ptp.html

方法

ma.MaskedArray.ptp(axis=None, out=None, fill_value=None, keepdims=False)

返回沿给定维度的（最大值 - 最小值）（即峰值到峰值值）。

警告

ptp 保留数组的数据类型。这意味着对于带有 n 位的有符号整数输入（例如 np.int8, np.int16 等），返回值也是带有 n 位的有符号整数。在这种情况下，大于 2**(n-1)-1 的峰值将作为负值返回。下面展示了一个示例及解决方法。

参数：

axis {None, int}，可选

要查找峰值的轴。如果为 None（默认），则使用扁平化的数组。

out {None, array_like}，可选

替代输出数组，用于放置结果。它必须具有与预期输出相同的形状和缓冲区长度，但如果需要，类型将被转换。

fill_value 标量或 None，可选

用于填充掩码值的值。

keepdims 布尔值，可选

如果设置为 True，则被减少的轴将作为大小为一的维度保留在结果中。使用此选项，结果将正确广播到数组。

ptp ndarray。

一个新数组保存结果，除非指定了 out，否则将返回对 out 的引用。

示例

>>> x = np.ma.MaskedArray([[4, 9, 2, 10],
...                        [6, 9, 7, 12]])

>>> x.ptp(axis=1)
masked_array(data=[8, 6],
 mask=False,
 fill_value=999999)

>>> x.ptp(axis=0)
masked_array(data=[2, 0, 5, 2],
 mask=False,
 fill_value=999999)

>>> x.ptp()
10

这个示例显示，当输入为带符号整数数组时，可能会返回负值。

>>> y = np.ma.MaskedArray([[1, 127],
...                        [0, 127],
...                        [-1, 127],
...                        [-2, 127]], dtype=np.int8)
>>> y.ptp(axis=1)
masked_array(data=[ 126,  127, -128, -127],
 mask=False,
 fill_value=999999,
 dtype=int8)

一个解决方法是使用 view() 方法将结果视为具有相同位宽的无符号整数：

>>> y.ptp(axis=1).view(np.uint8)
masked_array(data=[126, 127, 128, 129],
 mask=False,
 fill_value=999999,
 dtype=uint8)

`numpy.ma.argsort`

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

ma.argsort(a, axis=<no value>, kind=None, order=None, endwith=True, fill_value=None)

返回一个沿指定轴对数组进行排序的索引的 ndarray。在fill_value之前填充掩码值。

参数：

axis整数，可选

要排序的轴。如果为 None，则使用平坦的数组。

在 1.13.0 版本中更改：以前，默认值被记录为-1，但那是错误的。在将来的某个日期，默认值将更改为-1，如最初意图的那样。在那之前，当arr.ndim > 1时，应明确给出轴，以避免出现 FutureWarning。

kind，可选

所使用的排序算法。

order列表，可选

当a是一个已定义字段的数组时，此参数指定首先比较哪些字段，第二个字段等等。不需要指定所有字段。

endwith，可选

是否应将缺失值（如果有）视为最大值（True）或最小值（False）。当数组包含在数据类型的相同极端处的未掩码值时，这些值和掩码值的排序是未定义的。

fill_value标量或 None，可选

用于掩码值的内部值。如果fill_value不是 None，则它将取代endwith。

index_array ndarray，int

沿指定轴对a进行排序的索引数组。换句话说，a[index_array]产生一个排序后的a。

另请参见

ma.MaskedArray.sort

描述所使用的排序算法。

lexsort

使用多个键进行间接稳定排序。

numpy.ndarray.sort

原地排序。

注意

有关不同排序算法的说明，请参见sort。

示例

>>> a = np.ma.array([3,2,1], mask=[False, False, True])
>>> a
masked_array(data=[3, 2, --],
 mask=[False, False,  True],
 fill_value=999999)
>>> a.argsort()
array([1, 0, 2])

`numpy.ma.sort`

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

ma.sort(a, axis=-1, kind=None, order=None, endwith=True, fill_value=None)

返回排序后的遮蔽数组副本。

等同于创建数组的副本并应用 MaskedArray 的sort()方法。

请参考MaskedArray.sort获取完整文档

另请参阅

MaskedArray.sort

等效方法

示例

>>> import numpy.ma as ma
>>> x = [11.2, -3.973, 0.801, -1.41]
>>> mask = [0, 0, 0, 1]
>>> masked_x = ma.masked_array(x, mask)
>>> masked_x
masked_array(data=[11.2, -3.973, 0.801, --],
 mask=[False, False, False,  True],
 fill_value=1e+20)
>>> ma.sort(masked_x)
masked_array(data=[-3.973, 0.801, 11.2, --],
 mask=[False, False, False,  True],
 fill_value=1e+20)

`numpy.ma.MaskedArray.argsort`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.argsort.html

方法

ma.MaskedArray.argsort(axis=<no value>, kind=None, order=None, endwith=True, fill_value=None)

返回一个沿指定轴对数组进行排序的索引数组。在填充屏蔽值之前，屏蔽值被填充到fill_value。

参数：

axis整数，可选

用于排序的轴。如果为 None，则使用默认值，即使用扁平化的数组。

在 1.13.0 版本中更改：先前，默认值被记录为-1，但那是错误的。在将来的某个日期，默认值将更改为-1，如最初意图。在那之前，当arr.ndim > 1时，应明确给出轴，以避免出现 FutureWarning。

kind, 可选

所使用的排序算法。

order列表，可选

当a是具有定义字段的数组时，此参数指定首先比较哪些字段，第二个字段等。不需要指定所有字段。

endwith, 可选

是否应将缺失值（如果有）视为最大值（True）或最小值（False）。当数组包含未屏蔽值处于数据类型的极端位置时，这些值和屏蔽值的排序是未定义的。

fill_value标量或 None，可选

用于屏蔽值的内部使用值。如果fill_value不是 None，则它将取代endwith。

index_arrayndarray，整数

沿指定轴对a进行排序的索引数组。换句话说，a[index_array]产生一个排序后的a。

另请参见

ma.MaskedArray.sort

描述所使用的排序算法。

lexsort

使用多个键进行间接稳定排序。

numpy.ndarray.sort

原地排序。

注意事项

有关不同排序算法的说明，请参见sort。

示例

>>> a = np.ma.array([3,2,1], mask=[False, False, True])
>>> a
masked_array(data=[3, 2, --],
 mask=[False, False,  True],
 fill_value=999999)
>>> a.argsort()
array([1, 0, 2])

`numpy.ma.MaskedArray.sort`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.sort.html

方法

ma.MaskedArray.sort(axis=-1, kind=None, order=None, endwith=True, fill_value=None)

原地对数组进行排序

参数：

a类似数组

要排序的数组。

axisint，可选

用于排序的轴。如果为 None，则在排序之前将数组展平。默认值为-1，沿着最后一个轴排序。

kind，可选

使用的排序算法。

order列表，可选

当a是一个结构化数组时，此参数指定首先比较哪些字段，其次是哪些字段，依此类推。此列表不需要包含所有字段。

endwith，可选

是否将缺失值（如果有）视为最大值（True）或最小值（False）当数组包含未屏蔽值时，在数据类型的极端处进行排序时，这些值和屏蔽值的排序是未定义的。

fill_value标量或 None，可选

用于屏蔽值的内部值。如果fill_value不为 None，则它将取代endwith。

sorted_arrayndarray

与a相同类型和形状的数组。

另请参见

numpy.ndarray.sort

在原地对数组进行排序的方法。

argsort

间接排序。

lexsort

多个键的间接稳定排序。

searchsorted

在排序数组中查找元素。

注意

有关不同排序算法的说明，请参见sort。

示例

>>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
>>> # Default
>>> a.sort()
>>> a
masked_array(data=[1, 3, 5, --, --],
 mask=[False, False, False,  True,  True],
 fill_value=999999)

>>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
>>> # Put missing values in the front
>>> a.sort(endwith=False)
>>> a
masked_array(data=[--, --, 1, 3, 5],
 mask=[ True,  True, False, False, False],
 fill_value=999999)

>>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
>>> # fill_value takes over endwith
>>> a.sort(endwith=False, fill_value=3)
>>> a
masked_array(data=[1, --, --, 3, 5],
 mask=[False,  True,  True, False, False],
 fill_value=999999)

`numpy.ma.diag`

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

ma.diag(v, k=0)

提取对角线或构造对角线数组。

此函数相当于考虑掩码值的numpy.diag函数，详情请参见numpy.diag。

参见

numpy.diag

用于 ndarrays 的等效函数。

示例

创建一个带有负值掩码的数组：

>>> import numpy as np
>>> x = np.array([[11.2, -3.973, 18], [0.801, -1.41, 12], [7, 33, -12]])
>>> masked_x = np.ma.masked_array(x, mask=x < 0)
>>> masked_x
masked_array(
 data=[[11.2, --, 18.0],
 [0.801, --, 12.0],
 [7.0, 33.0, --]],
 mask=[[False,  True, False],
 [False,  True, False],
 [False, False,  True]],
 fill_value=1e+20)

从掩码数组中隔离主对角线：

>>> np.ma.diag(masked_x)
masked_array(data=[11.2, --, --],
 mask=[False,  True,  True],
 fill_value=1e+20)

隔离主对角线下方的第一个对角线：

>>> np.ma.diag(masked_x, -1)
masked_array(data=[0.801, 33.0],
 mask=[False, False],
 fill_value=1e+20)

`numpy.ma.dot`

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

ma.dot(a, b, strict=False, out=None)

返回两个数组的点积。

这个函数相当于numpy.dot，考虑了掩码值。请注意，strict和out的位置与方法版本不同。为了保持与相应方法的兼容性，建议将可选参数视为仅关键字。在某些情况下，这可能是强制性的。

参数：

a, b掩码数组样式

输入数组。

strict布尔值，可选

是否传播掩码数据（True）或将其设置为 0（False）进行计算。默认为 False。传播掩码意味着如果一行或列中出现掩码值，则整行或整列被视为掩码。

out掩码数组，可选

输出参数。这必须具有与未使用时返回的完全相同的类型。特别是，它必须具有正确的类型，必须是 C 连续的，并且其 dtype 必须是dot(a,b)返回的 dtype。这是一个性能特性。因此，如果不满足这些条件，将引发异常，而不是尝试灵活处理。

新版本 1.10.2 中新增。

另请参阅

numpy.dot

用于 ndarrays 的等效函数。

示例

>>> a = np.ma.array([[1, 2, 3], [4, 5, 6]], mask=[[1, 0, 0], [0, 0, 0]])
>>> b = np.ma.array([[1, 2], [3, 4], [5, 6]], mask=[[1, 0], [0, 0], [0, 0]])
>>> np.ma.dot(a, b)
masked_array(
 data=[[21, 26],
 [45, 64]],
 mask=[[False, False],
 [False, False]],
 fill_value=999999)
>>> np.ma.dot(a, b, strict=True)
masked_array(
 data=[[--, --],
 [--, 64]],
 mask=[[ True,  True],
 [ True, False]],
 fill_value=999999)

`numpy.ma.identity`

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

ma.identity(n, dtype=None) = <numpy.ma.core._convert2ma object>

返回单位矩阵。

单位矩阵是一个主对角线上为 1 的方阵。

参数：

nint

输出中n x n的行数（和列数）。

dtype数据类型，可选

输出的数据类型。默认为float。

likearray_like，可选

参考对象，允许创建不是 NumPy 数组的数组。如果传入like的类似数组支持__array_function__协议，则结果将由它定义。在这种情况下，它确保创建一个与通过此参数传入的对象兼容的数组对象。

在 1.20.0 版本中新增。

out掩码数组

n x n数组，其主对角线设置为 1，所有其他元素为 0。

示例

>>> np.identity(3)
array([[1.,  0.,  0.],
 [0.,  1.,  0.],
 [0.,  0.,  1.]])

`numpy.ma.inner`

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

ma.inner(a, b, /)

两个数组的内积。

对于 1-D 数组的普通向量内积（不包括复共轭），在更高维度上是最后一个轴上的和积。

参数：

a, barray_like

如果 a 和 b 都不是标量，则它们的最后一个维度必须匹配。

outndarray

如果 a 和 b 都是标量或都是 1-D 数组，则返回一个标量；否则返回一个数组。out.shape = (*a.shape[:-1], *b.shape[:-1])

引发：

ValueError

如果 a 和 b 都不是标量且它们的最后一个维度大小不同。

另请参阅

tensordot

在任意轴上求和积。

dot

广义矩阵乘积，使用 b 的倒数第二个维度。

einsum

爱因斯坦求和约定。

注意

掩码值将被替换为 0。

对于向量（1-D 数组），它计算普通的内积：

np.inner(a, b) = sum(a[:]*b[:])

更一般地，如果 ndim(a) = r > 0 且 ndim(b) = s > 0：

np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))

或者明确地：

np.inner(a, b)[i0,...,ir-2,j0,...,js-2]
     = sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:])

此外 a 或 b 可能是标量，此时：

np.inner(a,b) = a*b

示例

向量的普通内积：

>>> a = np.array([1,2,3])
>>> b = np.array([0,1,0])
>>> np.inner(a, b)
2

一些多维示例：

>>> a = np.arange(24).reshape((2,3,4))
>>> b = np.arange(4)
>>> c = np.inner(a, b)
>>> c.shape
(2, 3)
>>> c
array([[ 14,  38,  62],
 [ 86, 110, 134]])

>>> a = np.arange(2).reshape((1,1,2))
>>> b = np.arange(6).reshape((3,2))
>>> c = np.inner(a, b)
>>> c.shape
(1, 1, 3)
>>> c
array([[[1, 3, 5]]])

一个 b 是标量的例子：

>>> np.inner(np.eye(2), 7)
array([[7., 0.],
 [0., 7.]])

`numpy.ma.innerproduct`

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

ma.innerproduct(a, b, /)

两个数组的内积。

对于 1-D 数组的向量的普通内积（不包括复共轭），在更高维度中是对最后一个轴的求和乘积。

参数：

a, barray_like

如果a和b都不是标量，则它们的最后一个维度必须匹配。

outndarray

如果a和b都是标量或都是 1-D 数组，则返回标量；否则返回数组。out.shape = (*a.shape[:-1], *b.shape[:-1])

引发：

ValueError

如果a和b都不是标量且它们的最后一个维度大小不同。

另请参阅

tensordot

在任意轴上求和乘积。

dot

广义矩阵乘积，使用b的倒数第二个维度。

einsum

爱因斯坦求和约定。

注意

掩码值被替换为 0。

对于向量（1-D 数组），它计算普通内积：

np.inner(a, b) = sum(a[:]*b[:])

更一般地，如果ndim(a) = r > 0且ndim(b) = s > 0：

np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))

或明确地：

np.inner(a, b)[i0,...,ir-2,j0,...,js-2]
     = sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:])

此外，a或b可能是标量，此时：

np.inner(a,b) = a*b

示例

向量的普通内积：

>>> a = np.array([1,2,3])
>>> b = np.array([0,1,0])
>>> np.inner(a, b)
2

一些多维示例：

>>> a = np.arange(24).reshape((2,3,4))
>>> b = np.arange(4)
>>> c = np.inner(a, b)
>>> c.shape
(2, 3)
>>> c
array([[ 14,  38,  62],
 [ 86, 110, 134]])

>>> a = np.arange(2).reshape((1,1,2))
>>> b = np.arange(6).reshape((3,2))
>>> c = np.inner(a, b)
>>> c.shape
(1, 1, 3)
>>> c
array([[[1, 3, 5]]])

一个b是标量的例子：

>>> np.inner(np.eye(2), 7)
array([[7., 0.],
 [0., 7.]])

`numpy.ma.outer`

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

ma.outer(a, b)

计算两个向量的外积。

给定长度为M和N的两个向量a和b，外积[1]为：

[[a_0*b_0  a_0*b_1 ... a_0*b_{N-1} ]
 [a_1*b_0    .
 [ ...          .
 [a_{M-1}*b_0            a_{M-1}*b_{N-1} ]]

参数：

a(M,) 类似数组

第一个输入向量。如果不是 1 维的，则输入会被展平。

b(N,) 类似数组

第二个输入向量。如果不是 1 维的，则输入会被展平。

out(M, N) 数组，可选

存储结果的位置

版本 1.9.0 中的新功能。

out(M, N) 数组

out[i, j] = a[i] * b[j]

另请参阅

inner

einsum

einsum('i,j->ij', a.ravel(), b.ravel())是等效的。

ufunc.outer

除了 1D 以外的维度和其他操作的泛化。np.multiply.outer(a.ravel(), b.ravel())是等效的。

tensordot

np.tensordot(a.ravel(), b.ravel(), axes=((), ()))是等效的。

注意

掩码值被替换为 0。

参考文献

[1]

G. H. Golub 和 C. F. Van Loan，Matrix Computations，第 3 版，马里兰州巴尔的摩，约翰霍普金斯大学出版社，1996 年，第 8 页。

示例

为计算 Mandelbrot 集合制作（非常）粗糙的网格：

>>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))
>>> rl
array([[-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.]])
>>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))
>>> im
array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
 [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
 [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
 [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
 [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])
>>> grid = rl + im
>>> grid
array([[-2.+2.j, -1.+2.j,  0.+2.j,  1.+2.j,  2.+2.j],
 [-2.+1.j, -1.+1.j,  0.+1.j,  1.+1.j,  2.+1.j],
 [-2.+0.j, -1.+0.j,  0.+0.j,  1.+0.j,  2.+0.j],
 [-2.-1.j, -1.-1.j,  0.-1.j,  1.-1.j,  2.-1.j],
 [-2.-2.j, -1.-2.j,  0.-2.j,  1.-2.j,  2.-2.j]])

使用“字母”向量的示例：

>>> x = np.array(['a', 'b', 'c'], dtype=object)
>>> np.outer(x, [1, 2, 3])
array([['a', 'aa', 'aaa'],
 ['b', 'bb', 'bbb'],
 ['c', 'cc', 'ccc']], dtype=object)

`numpy.ma.outerproduct`

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

ma.outerproduct(a, b)

计算两个向量的外积。

给定长度分别为M和N的两个向量a和b，外积[1]为：

[[a_0*b_0  a_0*b_1 ... a_0*b_{N-1} ]
 [a_1*b_0    .
 [ ...          .
 [a_{M-1}*b_0            a_{M-1}*b_{N-1} ]]

参数：

a(M,) 数组样式

第一个输入向量。如果尚未是 1 维，则输入将被展平。

b(N,) 数组样式

第二个输入向量。如果尚未是 1 维，则输入将被展平。

out(M, N) 数组样式，可选

存储结果的位置

自版本 1.9.0 起新增。

out(M, N) 数组样式

out[i, j] = a[i] * b[j]

参见

numpy.inner

numpy.einsum

einsum('i,j->ij', a.ravel(), b.ravel()) 是等效的。

numpy.ufunc.outer

适用于除 1D 以外的维度和其他操作的泛化。np.multiply.outer(a.ravel(), b.ravel()) 是等效的。

numpy.tensordot

np.tensordot(a.ravel(), b.ravel(), axes=((), ())) 是等效的。

注意

掩码值将被替换为 0。

参考资料

[1]

G. H. Golub 和 C. F. Van Loan，Matrix Computations，第 3 版，马里兰州巴尔的摩，约翰霍普金斯大学出版社，1996 年，第 8 页。

示例

创建一个（非常粗糙）用于计算曼德勃罗集的网格：

>>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))
>>> rl
array([[-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.],
 [-2., -1.,  0.,  1.,  2.]])
>>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))
>>> im
array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
 [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
 [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
 [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
 [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])
>>> grid = rl + im
>>> grid
array([[-2.+2.j, -1.+2.j,  0.+2.j,  1.+2.j,  2.+2.j],
 [-2.+1.j, -1.+1.j,  0.+1.j,  1.+1.j,  2.+1.j],
 [-2.+0.j, -1.+0.j,  0.+0.j,  1.+0.j,  2.+0.j],
 [-2.-1.j, -1.-1.j,  0.-1.j,  1.-1.j,  2.-1.j],
 [-2.-2.j, -1.-2.j,  0.-2.j,  1.-2.j,  2.-2.j]])

使用“字母”向量的示例：

>>> x = np.array(['a', 'b', 'c'], dtype=object)
>>> np.outer(x, [1, 2, 3])
array([['a', 'aa', 'aaa'],
 ['b', 'bb', 'bbb'],
 ['c', 'cc', 'ccc']], dtype=object)

`numpy.ma.trace`

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

ma.trace(self, offset=0, axis1=0, axis2=1, dtype=None, out=None) a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None) = <numpy.ma.core._frommethod object>

返回数组沿对角线的和。

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

另请参阅

numpy.trace

等效函数

`numpy.ma.transpose`

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

ma.transpose(a, axes=None)

对数组维度进行置换。

这个函数与numpy.transpose完全等效。

参见

numpy.transpose

在顶层的 NumPy 模块中，有等效的函数。

示例

>>> import numpy.ma as ma
>>> x = ma.arange(4).reshape((2,2))
>>> x[1, 1] = ma.masked
>>> x
masked_array(
 data=[[0, 1],
 [2, --]],
 mask=[[False, False],
 [False,  True]],
 fill_value=999999)

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

`numpy.ma.MaskedArray.trace`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.trace.html

方法

ma.MaskedArray.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)

返回数组沿对角线的和。

参考numpy.trace获取完整文档。

另请参阅

numpy.trace

等效函数

`numpy.ma.MaskedArray.transpose`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.transpose.html

方法

ma.MaskedArray.transpose(*axes)

返回一个具有轴线转置的数组视图。

请查阅完整文档numpy.transpose。

参数：

axes None，整数元组，或 n 个整数

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

p ndarray

具有合适调换轴线排列的数组视图。

参见

transpose

等效函数。

ndarray.T

返回转置后的数组视图。

ndarray.reshape

为数组赋予新的形状，而不改变其数据。

示例

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

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

`numpy.ma.vander`

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

ma.vander(x, n=None)

生成一个范德蒙矩阵。

输出矩阵的列是输入向量的幂。幂的顺序由increasing布尔参数确定。具体来说，当increasing为 False 时，第i列的输出是输入向量逐元素的N - i - 1次幂。这样的矩阵，每行都有一个几何级数，因此被称为亚历山大- 蒂奥菲尔·范德蒙矩阵。

参数：

x：array_like

1-D 输入数组。

N：整数，可选

输出中的列数。如果未指定N，则返回一个方阵（N = len(x)）。

increasing：布尔值，可选

列的幂次顺序。如果为 True，则幂从左到右增加，如果为 False（默认值），则为相反顺序。

1.9.0 版本中的新功能。

out：ndarray

范德蒙矩阵。如果increasing为 False，则第一列是x^(N-1)，第二列是x^(N-2)，依此类推。如果increasing为 True，则列为x⁰, x¹, ..., x^(N-1)。

另见

polynomial.polynomial.polyvander

注解

输入数组中的掩码值会导致零行。

示例

>>> x = np.array([1, 2, 3, 5])
>>> N = 3
>>> np.vander(x, N)
array([[ 1,  1,  1],
 [ 4,  2,  1],
 [ 9,  3,  1],
 [25,  5,  1]])

>>> np.column_stack([x**(N-1-i) for i in range(N)])
array([[ 1,  1,  1],
 [ 4,  2,  1],
 [ 9,  3,  1],
 [25,  5,  1]])

>>> x = np.array([1, 2, 3, 5])
>>> np.vander(x)
array([[  1,   1,   1,   1],
 [  8,   4,   2,   1],
 [ 27,   9,   3,   1],
 [125,  25,   5,   1]])
>>> np.vander(x, increasing=True)
array([[  1,   1,   1,   1],
 [  1,   2,   4,   8],
 [  1,   3,   9,  27],
 [  1,   5,  25, 125]])

方阵范德蒙德矩阵的行列式是输入向量值之间的差值的乘积：

>>> np.linalg.det(np.vander(x))
48.000000000000043 # may vary
>>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1)
48

`numpy.ma.polyfit`

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

ma.polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False)

最小二乘多项式拟合。

注意

这构成了旧多项式 API 的一部分。自版本 1.4 以后，优先使用在numpy.polynomial中定义的新多项式 API。可以在过渡指南中找到差异的摘要。

拟合多项式p(x) = p[0] * x**deg + ... + p[deg]到点(x, y)。返回最小化次数为deg的误差的系数p的向量，deg，deg-1，... 0。

推荐使用Polynomial.fit类方法进行新代码编写，因为在数值上更加稳定。有关该方法的更多信息，请参阅该方法的文档。

参数：

xarray_like，形状（M，）

M 个样本点的 x 坐标(x[i], y[i])。

yarray_like，形状（M，）或（M，K）

数据点的 y 坐标。可以通过传入包含每列一个数据集的 2D 数组，一次拟合具有相同 x 坐标的多个数据集的样本点。

degint

拟合多项式的次数

rcondfloat，可选

拟合的相对条件数。相对于最大奇异值，小于此值的奇异值将被忽略。默认值为 len(x)*eps，其中 eps 是 float 类型的相对精度，大约为 2e-16，在大多数情况下。

fullbool，可选

决定返回值性质的开关。当为 False（默认值）时，仅返回系数，当为 True 时，还返回奇异值分解的诊断信息。

warray_like，形状（M，），可选

weights 如果不是 None，则权重w[i]应用于y[i] - y_hat[i]在x[i]处的非平方残差。理想情况下，权重应该被选择，以使得产品w[i]*y[i]的误差具有相同的方差。使用逆方差加权时，使用w[i] = 1/sigma(y[i])。默认值为 None。

covbool 或 str，可选

如果给定并且不是False，不仅返回估计值，还返回其协方差矩阵。默认情况下，协方差由 chi2/dof（其中 dof = M - (deg + 1)，即假定权重在相对意义上除了一切都按照缩放，以使得缩减的 chi2 为统一）缩放。如果cov='unscaled'省略了这种规模变换，这对于权重是 w = 1/sigma 的情况是相关的，其中 sigma 已知是可靠的不确定度估计。

pndarray，形状（deg+1，）或（deg+1，K）

多项式系数，最高幂优先。如果y是 2-D，则第k个数据集的系数在p[:,k]中。

残差，秩，奇异值，rcond

仅当full == True时才返回这些值

residuals – 最小二乘拟合的残差平方和
rank – 缩放范德蒙德矩阵的有效秩

系数矩阵
singular_values – 缩放范德蒙德矩阵的奇异值

系数矩阵
rcond – rcond 的值。

更多详细信息，请参阅 numpy.linalg.lstsq。

V 数组，形状为 (M,M) 或 (M,M,K)

仅当 full == False 且 cov == True 时才会出现。多项式系数估计的协方差矩阵。该矩阵的对角线是每个系数的方差估计。如果 y 是一个 2-D 数组，则第 k 个数据集的协方差矩阵在 V[:,:,k] 中。

警告：

RankWarning

在最小二乘拟合的系数矩阵的秩不足时引发警告。仅当 full == False 时才会引发警告。

可以通过以下方式关闭警告

>>> import warnings
>>> warnings.simplefilter('ignore', np.RankWarning)

另请参阅

polyval

计算多项式值。

linalg.lstsq

计算最小二乘拟合。

scipy.interpolate.UnivariateSpline

计算样条拟合。

注意事项

x 中的任何掩码值都会传播到 y 中，反之亦然。

该解决方案使得平方误差最小化

[E = \sum_{j=0}^k |p(x_j) - y_j|²]

在方程中：

x[0]**n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0]
x[1]**n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1]
...
x[k]**n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k]

系数矩阵 p 的伴随矩阵是一个范德蒙德矩阵。

当最小二乘拟合的条件很差时，polyfit 会发出 RankWarning。这意味着由于数值误差，最佳拟合不确定。通过降低多项式的次数或将 x 替换为 x - *x.mean()，可以改善结果。也可以将 rcond 参数设置为比默认值小的值，但所得的拟合可能是虚假的：包含小奇异值的贡献可能会给结果添加数值噪声。

需要注意的是，当多项式的次数较大或样本点的间隔较差时，拟合多项式系数的条件会出现问题。在这些情况下，应始终检查拟合的质量。当多项式拟合不理想时，样条插值可能是一个很好的选择。

参考文献

[1]

维基百科，“曲线拟合”，zh.wikipedia.org/wiki/曲线拟合

[2]

维基百科，“多项式插值”，zh.wikipedia.org/wiki/多项式插值

示例

>>> import warnings
>>> x = np.array([0.0, 1.0, 2.0, 3.0,  4.0,  5.0])
>>> y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0])
>>> z = np.polyfit(x, y, 3)
>>> z
array([ 0.08703704, -0.81349206,  1.69312169, -0.03968254]) # may vary

对于处理多项式，使用 poly1d 对象很方便：

>>> p = np.poly1d(z)
>>> p(0.5)
0.6143849206349179 # may vary
>>> p(3.5)
-0.34732142857143039 # may vary
>>> p(10)
22.579365079365115 # may vary

高阶多项式可能会出现大幅振荡：

>>> with warnings.catch_warnings():
...     warnings.simplefilter('ignore', np.RankWarning)
...     p30 = np.poly1d(np.polyfit(x, y, 30))
...
>>> p30(4)
-0.80000000000000204 # may vary
>>> p30(5)
-0.99999999999999445 # may vary
>>> p30(4.5)
-0.10547061179440398 # may vary

图示：

>>> import matplotlib.pyplot as plt
>>> xp = np.linspace(-2, 6, 100)
>>> _ = plt.plot(x, y, '.', xp, p(xp), '-', xp, p30(xp), '--')
>>> plt.ylim(-2,2)
(-2, 2)
>>> plt.show()

../../_images/numpy-ma-polyfit-1.png

`numpy.ma.around`

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

ma.around = <numpy.ma.core._MaskedUnaryOperation object>

将数组舍入到给定的小数位数。

round_ 是 around 和 round 的不推荐使用的向后兼容别名。

自版本 1.25.0 弃用：round_ 在 NumPy 1.25.0 中已弃用，并将在 NumPy 2.0 中移除。请使用 round 代替。

另请参见

around

等效函数；详情请参阅。

`numpy.ma.clip`

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

ma.clip = <numpy.ma.core._convert2ma object>

限制数组中的值。

给定一个区间，超出该区间的值将被裁剪到区间的边缘。例如，如果指定了间隔[0, 1]，小于 0 的值将成为 0，大于 1 的值将成为 1。

等同于但比np.minimum(a_max, np.maximum(a, a_min))更快。

不会执行检查以确保a_min < a_max。

参数：

aarray_like

包含要裁剪元素的数组。

a_min, a_maxarray_like 或 None

最小值和最大值。如果为None，则不在相应边界上执行裁剪。a_min和a_max只能有一个为None。两者都会与a进行广播。

outndarray，可选参数

结果将放入此数组中。它可以是用于就地裁剪的输入数组。out必须具有正确的形状来容纳输出。它的类型将被保留。

**kwargs

关于其他仅限关键字参数，请参阅 ufunc 文档。

在 1.17.0 版本中新增。

clipped_arrayMaskedArray

一个包含了a元素的数组，但其中小于a_min的值被替换为a_min，大于a_max的值被替换为a_max。

参见

输出类型确定

注意

当a_min大于a_max时，clip返回一个数组，其中所有值都等于a_max，如第二个例子所示。

示例

>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.clip(a, 1, 8)
array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
>>> np.clip(a, 8, 1)
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
>>> np.clip(a, 3, 6, out=a)
array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
>>> a
array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8)
array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])

`numpy.ma.round`

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

ma.round(a, decimals=0, out=None)

返回四舍五入到‘decimals’位的 a 的副本。

当‘decimals’为负数时，它指定小数点左边的位置数。复数的实部和虚部分别四舍五入。如果数组不是浮点类型且‘decimals’大于或等于 0，则不执行任何操作。

参数：

decimalsint

要四舍五入的小数位数。可以为负数。

outarray_like

用于输出的现有数组。如果不提供，则返回 a 的默认副本。

注：

如果给定 out，并且 out 没有 mask 属性，则 a 的 mask 会丢失！

示例

>>> import numpy.ma as ma
>>> x = [11.2, -3.973, 0.801, -1.41]
>>> mask = [0, 0, 0, 1]
>>> masked_x = ma.masked_array(x, mask)
>>> masked_x
masked_array(data=[11.2, -3.973, 0.801, --],
 mask=[False, False, False, True],
 fill_value=1e+20)
>>> ma.round_(masked_x)
masked_array(data=[11.0, -4.0, 1.0, --],
 mask=[False, False, False, True],
 fill_value=1e+20)
>>> ma.round(masked_x, decimals=1)
masked_array(data=[11.2, -4.0, 0.8, --],
 mask=[False, False, False, True],
 fill_value=1e+20)
>>> ma.round_(masked_x, decimals=-1)
masked_array(data=[10.0, -0.0, 0.0, --],
 mask=[False, False, False, True],
 fill_value=1e+20)

`numpy.ma.MaskedArray.clip`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.clip.html

方法

ma.MaskedArray.clip(min=None, max=None, out=None, **kwargs)

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

有关详细文档，请参阅 numpy.clip。

另请参阅

numpy.clip

等效函数

`numpy.ma.MaskedArray.round`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.round.html

方法

ma.MaskedArray.round(decimals=0, out=None)

返回每个元素舍入到指定小数位数。

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

另请参见

numpy.ndarray.round

ndarrays 的相应函数

numpy.around

等效函数

`numpy.ma.intersect1d`

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

ma.intersect1d(ar1, ar2, assume_unique=False)

返回两个数组中共同的唯一元素。

掩盖值被视为相等。输出始终是一个掩盖数组。

参见numpy.intersect1d 了解更多细节。

另请参阅

numpy.intersect1d

ndarrays 的等效函数。

例子

>>> x = np.ma.array([1, 3, 3, 3], mask=[0, 0, 0, 1])
>>> y = np.ma.array([3, 1, 1, 1], mask=[0, 0, 0, 1])
>>> np.ma.intersect1d(x, y)
masked_array(data=[1, 3, --],
 mask=[False, False,  True],
 fill_value=999999)

`numpy.ma.setdiff1d`

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

ma.setdiff1d(ar1, ar2, assume_unique=False)

具有唯一元素的 1D 数组的差集。

输出始终是掩码数组。有关更多详细信息，请参见numpy.setdiff1d。

参见

numpy.setdiff1d

ndarrays 的等效函数。

例子

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

`numpy.ma.setxor1d`

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

ma.setxor1d(ar1, ar2, assume_unique=False)

对具有唯一元素的 1-D 数组进行排他性或集。

输出始终是一个掩码数组。有关更多详细信息，请参阅 numpy.setxor1d。

另请参阅

numpy.setxor1d

对 ndarrays 的等效函数。

`numpy.ma.union1d`

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

ma.union1d(ar1, ar2)

两个数组的并集。

输出始终为掩码数组。有关更多详细信息，请参阅numpy.union1d。

另请参阅

numpy.union1d

ndarrays 的等效函数。

`numpy.ma.allequal`

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

ma.allequal(a, b, fill_value=True)

如果 a 和 b 的所有元素都相等，则返回 True ，并使用 fill_value 作为真值判断，其中 a 或 b 或两者都是屏蔽的。

参数：

a, barray_like

要比较的输入数组。

fill_valuebool, 可选项

是否将 a 或 b 中的屏蔽值视作相等（True）或不相等（False）。

ybool

如果两个数组在给定的公差内相等，则返回 True ，否则返回 False 。如果任一数组包含 NaN，则返回 False 。

请参考

all, any

numpy.ma.allclose

示例

>>> a = np.ma.array([1e10, 1e-7, 42.0], mask=[0, 0, 1])
>>> a
masked_array(data=[10000000000.0, 1e-07, --],
 mask=[False, False,  True],
 fill_value=1e+20)

>>> b = np.array([1e10, 1e-7, -42.0])
>>> b
array([  1.00000000e+10,   1.00000000e-07,  -4.20000000e+01])
>>> np.ma.allequal(a, b, fill_value=False)
False
>>> np.ma.allequal(a, b)
True

`numpy.ma.allclose`

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

ma.allclose(a, b, masked_equal=True, rtol=1e-05, atol=1e-08)

如果两个数组在容忍度内元素对元素相等，则返回 True。

此函数等同于allclose，除了掩码值被视为相等（默认）或不等，取决于masked_equal参数。

参数：

a, b数组或类数组

要比较的输入数组。

masked_equal布尔值，可选

a和b中的掩码值是否被认为是相等（True）或不相等（False）。默认情况下，它们被认为是相等的。

rtol浮点数，可选

相对容差。相对差等于rtol * b。默认为 1e-5。

atol浮点数，可选

绝对容差。绝对差等于atol。默认为 1e-8。

y布尔值

如果两个数组在给定的容差内相等，则返回 True，否则返回 False。如果任一数组包含 NaN，则返回 False。

参见

all, any

numpy.allclose

非掩码的allclose。

注意事项

如果以下方程元素对元素为 True，则allclose返回 True：

absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))

如果a和b的所有元素在给定的容差内都相等，则返回 True。

示例

>>> a = np.ma.array([1e10, 1e-7, 42.0], mask=[0, 0, 1])
>>> a
masked_array(data=[10000000000.0, 1e-07, --],
 mask=[False, False,  True],
 fill_value=1e+20)
>>> b = np.ma.array([1e10, 1e-8, -42.0], mask=[0, 0, 1])
>>> np.ma.allclose(a, b)
False

>>> a = np.ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])
>>> b = np.ma.array([1.00001e10, 1e-9, -42.0], mask=[0, 0, 1])
>>> np.ma.allclose(a, b)
True
>>> np.ma.allclose(a, b, masked_equal=False)
False

掩码值不会直接比较。

>>> a = np.ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])
>>> b = np.ma.array([1.00001e10, 1e-9, 42.0], mask=[0, 0, 1])
>>> np.ma.allclose(a, b)
True
>>> np.ma.allclose(a, b, masked_equal=False)
False

`numpy.ma.apply_along_axis`

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

ma.apply_along_axis(func1d, axis, arr, *args, **kwargs)

沿着指定轴对一维切片应用函数。

执行func1d(a, args, **kwargs)，其中func1d在一维数组上操作，a是沿着axis的arr*的一维切片。

这相当于（但比以下的方法更快）使用ndindex和s_的以下用法，将ii，jj和kk设置为索引元组：

Ni, Nk = a.shape[:axis], a.shape[axis+1:]
for ii in ndindex(Ni):
    for kk in ndindex(Nk):
        f = func1d(arr[ii + s_[:,] + kk])
        Nj = f.shape
        for jj in ndindex(Nj):
            out[ii + jj + kk] = f[jj]

等效地，消除内循环，这可以表达为：

Ni, Nk = a.shape[:axis], a.shape[axis+1:]
for ii in ndindex(Ni):
    for kk in ndindex(Nk):
        out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk])

参数：

func1d函数 (M,) -> (Nj…)

这个函数应该接受一维数组。它应用于指定轴上arr的一维切片。

axis整数

对arr进行切片的轴。

arr数组 (Ni…, M, Nk…)

输入数组。

args任何

func1d的附加参数。

kwargs任何

func1d的附加命名参数。

自 1.9.0 版本开始新增。

out数组 (Ni…, Nj…, Nk…)

输出数组。out的形状与arr的形状相同，除了axis维度。这个轴被移除，并用与func1d返回值形状相同的新维度替换。因此，如果func1d返回标量，out比arr少一个维度。

另请参阅

apply_over_axes

在多个轴上重复应用函数。

示例

>>> def my_func(a):
...  """Average first and last element of a 1-D array"""
...     return (a[0] + a[-1]) * 0.5
>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>> np.apply_along_axis(my_func, 0, b)
array([4., 5., 6.])
>>> np.apply_along_axis(my_func, 1, b)
array([2.,  5.,  8.])

对于返回一维数组的函数，outarr中的维度数与arr相同。

>>> b = np.array([[8,1,7], [4,3,9], [5,2,6]])
>>> np.apply_along_axis(sorted, 1, b)
array([[1, 7, 8],
 [3, 4, 9],
 [2, 5, 6]])

对于返回更高维数组的函数，这些维度替换axis维度。

>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>> np.apply_along_axis(np.diag, -1, b)
array([[[1, 0, 0],
 [0, 2, 0],
 [0, 0, 3]],
 [[4, 0, 0],
 [0, 5, 0],
 [0, 0, 6]],
 [[7, 0, 0],
 [0, 8, 0],
 [0, 0, 9]]])

`numpy.ma.apply_over_axes`

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

ma.apply_over_axes(func, a, axes)

在多个轴上重复应用函数。

func 被调用为res = func(a, axis)，其中axis是axes的第一个元素。函数调用的结果res必须具有与a相同的维度或比a少一个维度。如果res的维度比a少一个，则在axis之前插入一个维度。然后对axes中的每个轴重复对func的调用，res作为第一个参数。

参数：

func function

此函数必须接受两个参数，func(a, axis)。

a array_like

输入数组。

axes array_like

func 被应用的轴；这些元素必须是整数。

apply_over_axis ndarray

输出数组。维数与a相同，但形状可能不同。这取决于func是否改变其输出相对于其输入的形状。

另请参阅

apply_along_axis

对数组沿着给定轴应用函数。

示例

>>> a = np.ma.arange(24).reshape(2,3,4)
>>> a[:,0,1] = np.ma.masked
>>> a[:,1,:] = np.ma.masked
>>> a
masked_array(
 data=[[[0, --, 2, 3],
 [--, --, --, --],
 [8, 9, 10, 11]],
 [[12, --, 14, 15],
 [--, --, --, --],
 [20, 21, 22, 23]]],
 mask=[[[False,  True, False, False],
 [ True,  True,  True,  True],
 [False, False, False, False]],
 [[False,  True, False, False],
 [ True,  True,  True,  True],
 [False, False, False, False]]],
 fill_value=999999)
>>> np.ma.apply_over_axes(np.ma.sum, a, [0,2])
masked_array(
 data=[[[46],
 [--],
 [124]]],
 mask=[[[False],
 [ True],
 [False]]],
 fill_value=999999)

元组轴参数对于 ufunc 是等效的：

>>> np.ma.sum(a, axis=(0,2)).reshape((1,-1,1))
masked_array(
 data=[[[46],
 [--],
 [124]]],
 mask=[[[False],
 [ True],
 [False]]],
 fill_value=999999)

`numpy.ma.arange`

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

ma.arange([start, ]stop, [step, ]dtype=None, *, like=None) = <numpy.ma.core._convert2ma object>

在给定间隔内返回均匀间隔的值。

arange可以用不同数量的位置参数调用：

arange(stop)：在半开放区间 [0, stop) 内生成值（换句话说，包括* start 但不包括 stop *的区间）。
arange(start, stop)：在半开放区间 [start, stop) 内生成值。
arange(start, stop, step)：在半开放区间 [start, stop) 之间生成值，值之间的间隔由step给出。

对于整数参数，该函数与 Python 内置的range大致等价，但返回的是一个 ndarray 而不是range实例。

当使用非整数步长，例如 0.1 时，通常最好使用numpy.linspace。

有关更多信息，请参阅下面的警告部分。

参数：

start：整数或实数，可选

区间开始。区间包括此值。默认起始值为 0。

stop：整数或实数

区间结束。不包括此值，但在某些情况下除外，步长不是整数，并且浮点舍入会影响out的长度。

step：整数或实数，可选

值之间的间隔。对于任何输出out，这是两个相邻值之间的距离，out[i+1] - out[i]。默认步长为 1。如果步长被指定为位置参数，则必须同时给出start。

dtype：dtype，可选

输出数组的类型。如果没有给出dtype，则从其他输入参数中推断数据类型。

like：array_like, optional

参考对象，以允许创建不是 NumPy 数组的数组。如果传递给like的类似数组支持__array_function__协议，则结果将由它定义。在这种情况下，它确保创建与通过此参数传入的数组对象兼容的数组对象。

版本 1.20.0 中的新功能。

arange：MaskedArray

均匀间隔的数组。

对于浮点参数，结果的长度为ceil((stop - start)/step)。由于浮点溢出，这一规则可能导致out的最后一个元素大于* stop *。

警告

输出的长度可能不是数值稳定的。

另一个稳定性问题是由于内部实现numpy.arange。用于填充数组的实际步长值是dtype(start + step) - dtype(start)而不是* step 。在这里可能会发生精度损失，由于强制转换或使用浮点数时 start 远大于 step *。这可能导致意外行为。例如：

>>> np.arange(0, 5, 0.5, dtype=int)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
>>> np.arange(-3, 3, 0.5, dtype=int)
array([-3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8])

在这种情况下，应该优先使用numpy.linspace。

内置函数range生成具有任意大小的Python 内置整数，而numpy.arange生成numpy.int32或numpy.int64类型的数字。对于大整数值，可能导致错误的结果：

>>> power = 40
>>> modulo = 10000
>>> x1 = [(n ** power) % modulo for n in range(8)]
>>> x2 = [(n ** power) % modulo for n in np.arange(8)]
>>> print(x1)
[0, 1, 7776, 8801, 6176, 625, 6576, 4001]  # correct
>>> print(x2)
[0, 1, 7776, 7185, 0, 5969, 4816, 3361]  # incorrect

另请参阅

numpy.linspace

在处理端点时，保证数字间隔均匀。

numpy.ogrid

在 N 维空间中产生均匀间隔的数字数组。

numpy.mgrid

在 N 维空间中产生形状为网格的均匀间隔数字数组。

如何创建带有等间距值的数组

示例

>>> np.arange(3)
array([0, 1, 2])
>>> np.arange(3.0)
array([ 0.,  1.,  2.])
>>> np.arange(3,7)
array([3, 4, 5, 6])
>>> np.arange(3,7,2)
array([3, 5])

`numpy.ma.choose`

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

ma.choose(indices, choices, out=None, mode='raise')

使用索引数组从选择列表构造新数组。

给定一个整数数组和一个包含 n 个选择数组的列表，此方法将创建一个新数组，合并每个选择数组。其中索引值为 i 的地方，新数组将具有与 choices[i] 相同位置的值。

参数：

indices整数的 ndarray

此数组必须包含在[0, n-1]范围内的整数，其中 n 是选择的数量。

choices数组序列

选择数组。索引数组和所有选择都应可广播到相同的形状。

out数组，可选

如果提供，结果将插入到此数组中。它应具有适当的形状和dtype。

mode，可选

指定越界索引的行为方式。

‘raise’ : 抛出错误
‘wrap’ : 环绕
‘clip’ : 裁剪到范围内

merged_array数组

另请参阅

choose

等效函数

示例

>>> choice = np.array([[1,1,1], [2,2,2], [3,3,3]])
>>> a = np.array([2, 1, 0])
>>> np.ma.choose(a, choice)
masked_array(data=[3, 2, 1],
 mask=False,
 fill_value=999999)

`numpy.ma.ediff1d`

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

ma.ediff1d(arr, to_end=None, to_begin=None)

计算数组中相邻元素之间的差值。

该函数相当于numpy.ediff1d，考虑了掩码数值，详情请见numpy.ediff1d。

另见

numpy.ediff1d

适用于 ndarrays 的等效函数。

`numpy.ma.indices`

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

ma.indices(dimensions, dtype=<class 'int'>, sparse=False) = <numpy.ma.core._convert2ma object>

返回一个表示网格索引的数组。

计算一个数组，其中子数组包含索引值 0, 1,…只沿着相应轴变化。

参数：

dimensions整数序列

网格的形状。

dtype数据类型，可选

结果的数据类型。

sparse布尔值，可选

返回网格的稀疏表示而不是密集表示。默认为 False。

版本 1.17 中的新增功能。

grid一个 MaskedArray 或者 MaskedArrays 元组。

如果 sparse 为 False：

返回一个 grid 索引数组，grid.shape = (len(dimensions),) + tuple(dimensions)。

如果 sparse 为 True：

返回一个数组元组，其中grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)，其中 dimensions[i]在第 i 个位置

另请参阅

mgrid, ogrid, meshgrid

注意

在稠密模式下的输出形状是通过在维度元组之前添加维度的数量来获得的，比如，如果dimensions是一个长度为N的元组(r0, ..., rN-1)，输出形状是(N, r0, ..., rN-1)。

子数组grid[k]包含沿k-th轴的 N-D 数组的索引。具体地：

grid[k, i0, i1, ..., iN-1] = ik

示例

>>> grid = np.indices((2, 3))
>>> grid.shape
(2, 2, 3)
>>> grid[0]        # row indices
array([[0, 0, 0],
 [1, 1, 1]])
>>> grid[1]        # column indices
array([[0, 1, 2],
 [0, 1, 2]])

索引可以被用作数组的索引。

>>> x = np.arange(20).reshape(5, 4)
>>> row, col = np.indices((2, 3))
>>> x[row, col]
array([[0, 1, 2],
 [4, 5, 6]])

请注意，在上面的例子中，如果直接使用x[:2, :3]提取所需的元素会更直接。

如果 sparse 设置为 true，则网格将以稀疏表示返回。

>>> i, j = np.indices((2, 3), sparse=True)
>>> i.shape
(2, 1)
>>> j.shape
(1, 3)
>>> i        # row indices
array([[0],
 [1]])
>>> j        # column indices
array([[0, 1, 2]])

`numpy.ma.where`

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

ma.where(condition, x=<no value>, y=<no value>)

返回一个带有来自 x 或 y 的元素的掩码数组，取决于条件。

注意

当只提供 condition 时，此函数与 nonzero 相同。本文档的其余部分仅涵盖提供了所有三个参数的情况。

参数：

conditionarray_like, bool

如果为 True，则产出 x，否则产出 y。

x, yarray_like, optional

选择数值的来源。x、y 和 condition 需要广播到某种形状。

outMaskedArray

一个掩码数组，其中条件被掩盖，条件为 True 时从 x 中取出元素，其他情况从 y 中取出元素。

参见

numpy.where

顶级 NumPy 模块中的等效功能。

nonzero

在忽略 x 和 y 时调用的函数

例子

>>> x = np.ma.array(np.arange(9.).reshape(3, 3), mask=[[0, 1, 0],
...                                                    [1, 0, 1],
...                                                    [0, 1, 0]])
>>> x
masked_array(
 data=[[0.0, --, 2.0],
 [--, 4.0, --],
 [6.0, --, 8.0]],
 mask=[[False,  True, False],
 [ True, False,  True],
 [False,  True, False]],
 fill_value=1e+20)
>>> np.ma.where(x > 5, x, -3.1416)
masked_array(
 data=[[-3.1416, --, -3.1416],
 [--, -3.1416, --],
 [6.0, --, 8.0]],
 mask=[[False,  True, False],
 [ True, False,  True],
 [False,  True, False]],
 fill_value=1e+20)

数学函数

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

三角函数

`sin`(x, /[, out, where, casting, order, ...])	正弦函数，逐元素计算。
`cos`(x, /[, out, where, casting, order, ...])	余弦函数，逐元素计算。
`tan`(x, /[, out, where, casting, order, ...])	计算正切，逐元素计算。
`arcsin`(x, /[, out,��where, casting, order, ...])	反正弦函数，逐元素计算。
`arccos`(x, /[, out, where, casting, order, ...])	反余弦函数，逐元素计算。
`arctan`(x, /[, out, where, casting, order, ...])	反正切函数，逐元素计算。
`hypot`(x1, x2, /[, out, where, casting, ...])	给定直角三角形的两条边，返回其斜边。
`arctan2`(x1, x2, /[, out, where, casting, ...])	对 `x1/x2` 逐元素计算反正切，正确选择象限。
`degrees`(x, /[, out, where, casting, order, ...])	将角度从弧度转换为度。
`radians`(x, /[, out, where, casting, order, ...])	将角度从度转换为弧度。
`unwrap`(p[, discont, axis, period])	通过求相对于周期的补数来展开。
`deg2rad`(x, /[, out, where, casting, order, ...])	将角度从度转换为弧度。
`rad2deg`(x, /[, out, where, casting, order, ...])	将角度从弧度转换为度。

双曲函数

`sinh`(x, /[, out, where, casting, order, ...])	双曲正弦函数，逐元素计算。
`cosh`(x, /[, out, where, casting, order, ...])	双曲余弦函数，逐元素计算。
`tanh`(x, /[, out, where, casting, order, ...])	计算双曲正切，逐元素计算。
`arcsinh`(x, /[, out, where, casting, order, ...])	反双曲正弦函数，逐元素计算。
`arccosh`(x, /[, out, where, casting, order, ...])	反双曲余弦函数，逐元素计算。
`arctanh`(x, /[, out, where, casting, order, ...])	逐个元素的反双曲正切。

舍入

`round`(a[, decimals, out])	按指定的小数位数进行四舍五入。
`around`(a[, decimals, out])	将数组四舍五入到指定的小数位数。
`rint`(x, /[, out, where, casting, order, ...])	数组元素四舍五入到最近的整数。
`fix`(x[, out])	朝零方向四舍五入到最近的整数。
`floor`(x, /[, out, where, casting, order, ...])	返回输入的下限值，逐个元素。
`ceil`(x, /[, out, where, casting, order, ...])	返回输入的上限值，逐个元素。
`trunc`(x, /[, out, where, casting, order, ...])	返回输入的截断值，逐个元素。

求和，乘积，差异

`prod`(a[, axis, dtype, out, keepdims, ...])	返回给定轴上数组元素的乘积。
`sum`(a[, axis, dtype, out, keepdims, ...])	返回给定轴上数组元素的和。
`nanprod`(a[, axis, dtype, out, keepdims, ...])	返回给定轴上数组元素的乘积，将 Not a Number（NaN）视为 1。
`nansum`(a[, axis, dtype, out, keepdims, ...])	返回给定轴上数组元素的和，将 Not a Number（NaN）视为零。
`cumprod`(a[, axis, dtype, out])	返回沿给定轴对元素的累积乘积。
`cumsum`(a[, axis, dtype, out])	返回沿给定轴对数组元素的累积和。
`nancumprod`(a[, axis, dtype, out])	返回给定轴上数组元素的累积乘积，将 Not a Number（NaN）视为 1。
`nancumsum`(a[, axis, dtype, out])	返回给定轴上数组元素的累积和，将 Not a Number（NaN）视为零。
`diff`(a[, n, axis, prepend, append])	沿着给定的轴计算第 n 个离散差分。
`ediff1d`(ary[, to_end, to_begin])	数组中相邻元素之间的差异。
`gradient`(f, *varargs[, axis, edge_order])	返回 N 维数组的梯度。
`cross`(a, b[, axisa, axisb, axisc, axis])	返回两个（向量数组的）叉积。
`trapz`(y[, x, dx, axis])	使用复合梯形规则沿给定轴积分。

指数和对数

`exp`(x, /[, out, where, casting, order, ...])	计算输入数组中所有元素的指数。
`expm1`(x, /[, out, where, casting, order, ...])	计算数组中所有元素的`exp(x) - 1`。
`exp2`(x, /[, out, where, casting, order, ...])	计算输入数组中所有p的2p。
`log`(x, /[, out, where, casting, order, ...])	自然对数，逐元素方式。
`log10`(x, /[, out, where, casting, order, ...])	返回输入数组的以 10 为底的对数，逐元素方式。
`log2`(x, /[, out, where, casting, order, ...])	x的以 2 为底的对数。
`log1p`(x, /[, out, where, casting, order, ...])	返回输入数组元素加 1 的自然对数，逐元素方式。
`logaddexp`(x1, x2, /[, out, where, casting, ...])	输入指数之和的对数。
`logaddexp2`(x1, x2, /[, out, where, casting, ...])	以 2 为底的输入指数之和的对数。

其他特殊函数

`i0`(x)	第一类修改贝塞尔函数，阶数为 0。
`sinc`(x)	返回归一化的 sinc 函数。

浮点数例程

`signbit`(x, /[, out, where, casting, order, ...])	在 signbit 设置的元素位置返回 True（小于零）。
`copysign`(x1, x2, /[, out, where, casting, ...])	将 x1 的符号更改为 x2 的符号，逐元素方式。
`frexp`(x[, out1, out2], / [[, out, where, ...])	将 x 的元素分解为尾数和二次指数。
`ldexp`(x1, x2, /[, out, where, casting, ...])	逐元素返回 x1 * 2**x2。
`nextafter`(x1, x2, /[, out, where, casting, ...])	返回在`x1`之后的下一个浮点数值，接近于`x2`，元素级别地
`spacing`(x, /[, out, where, casting, order, ...])	返回`x`和最近相邻数之间的距离

分式计算

`lcm`(x1, x2, /[, out, where, casting, order, ...])	返回`\|x1\|`和`\|x2\|`的最小公倍数
`gcd`(x1, x2, /[, out, where, casting, order, ...])	返回`\|x1\|`和`\|x2\|`的最大公约数

算术运算

`add`(x1, x2, /[, out, where, casting, order, ...])	元素级别地相加
`reciprocal`(x, /[, out, where, casting, ...])	返回参数的倒数，元素级别地
`positive`(x, /[, out, where, casting, order, ...])	数值正数元素级别地
`negative`(x, /[, out, where, casting, order, ...])	数值负数元素级别地
`multiply`(x1, x2, /[, out, where, casting, ...])	元素级别地相乘
`divide`(x1, x2, /[, out, where, casting, ...])	元素级别地相除
`power`(x1, x2, /[, out, where, casting, ...])	将第一个数组的元素按照第二个数组的元素作为指数逐个计算次方
`subtract`(x1, x2, /[, out, where, casting, ...])	元素级别的减法
`true_divide`(x1, x2, /[, out, where, ...])	元素级别地相除
`floor_divide`(x1, x2, /[, out, where, ...])	返回输入的除法的最大整数小于或等于结果
`float_power`(x1, x2, /[, out, where, ...])	将第一个数组的元素按照第二个数组的元素作为指数逐个计算次方
`fmod`(x1, x2, /[, out, where, casting, ...])	返回元素级别的除法余数
`mod`(x1, x2, /[, out, where, casting, order, ...])	返回元素级别的除法余数
`modf`(x[, out1, out2], / [[, out, where, ...])	返回数组的分数部分和整数部分，按元素操作。
`remainder`(x1, x2, /[, out, where, casting, ...])	返回除法的元素余数。
`divmod`(x1, x2[, out1, out2], / [[, out, ...])	同时返回逐个元素除法的商和余数。

虚数处理

`angle`(z[, deg])	返回复数参数的角度。
`real`(val)	返回复数参数的实部。
`imag`(val)	返回复数参数的虚部。
`conj`(x, /[, out, where, casting, order, ...])	返回每个元素的复数共轭。
`conjugate`(x, /[, out, where, casting, ...])	返回每个元素的复数共轭。

极值查找

`maximum`(x1, x2, /[, out, where, casting, ...])	数组元素的逐个最大值。
`max`(a[, axis, out, keepdims, initial, where])	返回数组或沿轴的最大值。
`amax`(a[, axis, out, keepdims, initial, where])	返回数组或沿轴的最大值。
`fmax`(x1, x2, /[, out, where, casting, ...])	数组元素的逐个最大值。
`nanmax`(a[, axis, out, keepdims, initial, where])	返回数组或沿轴的最大值，忽略任何 NaN。
`minimum`(x1, x2, /[, out, where, casting, ...])	数组元素的逐个最小值。
`min`(a[, axis, out, keepdims, initial, where])	返回数组或沿轴的最小值。
`amin`(a[, axis, out, keepdims, initial, where])	返回数组或沿轴的最小值。
`fmin`(x1, x2, /[, out, where, casting, ...])	数组元素的逐个最小值。
`nanmin`(a[, axis, out, keepdims, initial, where])	返回数组或沿轴的最小值，忽略任何 NaN。

杂项

`convolve`(a, v[, mode])	返回两个一维序列的离散线性卷积。
`clip`(a, a_min, a_max[, out])	裁剪（限制）数组中的值。
`sqrt`(x, /[, out, where, casting, order, ...])	返回数组的非负平方根，逐元素操作。
`cbrt`(x, /[, out, where, casting, order, ...])	返回数组的立方根，逐元素操作。
`square`(x, /[, out, where, casting, order, ...])	返回输入的逐元素平方。
`absolute`(x, /[, out, where, casting, order, ...])	逐元素计算绝对值。
`fabs`(x, /[, out, where, casting, order, ...])	逐元素计算绝对值。
`sign`(x, /[, out, where, casting, order, ...])	返回数字的逐元素符号指示。
`heaviside`(x1, x2, /[, out, where, casting, ...])	计算海维赛德阶跃函数。
`nan_to_num`(x[, copy, nan, posinf, neginf])	用零替换 NaN，用大有限数替换无穷（默认行为）或用用户使用`nan`、posinf或neginf关键字定义的数替换。
`real_if_close`(a[, tol])	如果输入是所有虚部接近零的复数，则返回实部。
`interp`(x, xp, fp[, left, right, period])	单调递增样本点的一维线性插值。

三角函数

`sin`(x, /[, out, where, casting, order, ...])	正弦，逐元素操作。
`cos`(x, /[, out, where, casting, order, ...])	余弦，逐元素操作。
`tan`(x, /[, out, where, casting, order, ...])	计算正切，逐元素操作。
`arcsin`(x, /[, out, where, casting, order, ...])	反正弦，逐元素操作。
`arccos`(x, /[, out, where, casting, order, ...])	逆余弦，逐元素操作。
`arctan`(x, /[, out, where, casting, order, ...])	逆三角反正切，逐元素进行。
`hypot`(x1, x2, /[, out, where, casting, ...])	针对直角三角形的“腿”，返回其斜边。
`arctan2`(x1, x2, /[, out, where, casting, ...])	选择正确象限的`x1/x2`的元素方位角正切。
`degrees`(x, /[, out, where, casting, order, ...])	将角度从弧度转换为度数。
`radians`(x, /[, out, where, casting, order, ...])	将角度从度数转换为弧度。
`unwrap`(p[, discont, axis, period])	通过相对于周期的补集来取消大的增量。
`deg2rad`(x, /[, out, where, casting, order, ...])	将角度从度数转换为弧度。
`rad2deg`(x, /[, out, where, casting, order, ...])	将角度从弧度转换为度数。

双曲函数

`sinh`(x, /[, out, where, casting, order, ...])	双曲正弦，逐元素进行。
`cosh`(x, /[, out, where, casting, order, ...])	双曲余弦，逐元素进行。
`tanh`(x, /[, out, where, casting, order, ...])	计算双曲正切的元素。
`arcsinh`(x, /[, out, where, casting, order, ...])	逆双曲正弦逐元素进行。
`arccosh`(x, /[, out, where, casting, order, ...])	反双曲余弦，逐元素进行。
`arctanh`(x, /[, out, where, casting, order, ...])	逆双曲正切，逐元素进行。

四舍五入

`round`(a[, decimals, out])	均匀地四舍五入到给定的小数位数。
`around`(a[, decimals, out])	将数组四舍五入到给定的小数位数。
`rint`(x, /[, out, where, casting, order, ...])	将数组元素四舍五入到最接近的整数。
`fix`(x[, out])	向零舍入到最近的整数。
`floor`(x, /[, out, where, casting, order, ...])	返回输入的下限，逐元素进行。
`ceil`(x, /[, out, where, casting, order, ...])	返回输入的上限, 按元素计算。
`trunc`(x, /[, out, where, casting, order, ...])	返回输入的截断值，按元素计算。

求和、乘积、差异

`prod`(a[, axis, dtype, out, keepdims, ...])	返回沿给定轴的数组元素的乘积。
`sum`(a[, axis, dtype, out, keepdims, ...])	沿着给定轴的数组元素的和。
`nanprod`(a[, axis, dtype, out, keepdims, ...])	返回数组元素沿着给定轴的乘积，将 NaN 处理为 1。
`nansum`(a[, axis, dtype, out, keepdims, ...])	返回数组元素沿着给定轴的和，并将 Not a Number（NaN）视为零。
`cumprod`(a[, axis, dtype, out])	返回沿给定轴的元素的累积乘积。
`cumsum`(a[, axis, dtype, out])	返回沿给定轴的元素的累积和。
`nancumprod`(a[, axis, dtype, out])	返回数组元素沿着给定轴的累积乘积, 将 Not a Number（NaN）视为 1。
`nancumsum`(a[, axis, dtype, out])	返回数组元素沿着给定轴的累积和, 将 Not a Number（NaN）视为零。
`diff`(a[, n, axis, prepend, append])	计算沿着给定轴的第 n 个离散差异。
`ediff1d`(ary[, to_end, to_begin])	数组中相邻元素的差。
`gradient`(f, *varargs[, axis, edge_order])	返回 N 维数组的梯度。
`cross`(a, b[, axisa, axisb, axisc, axis])	返回两个（向量的）数组的叉乘积。
`trapz`(y[, x, dx, axis])	使用复合梯形法则沿着给定轴进行积分。

指数和对数

`exp`(x, /[, out, where, casting, order, ...])	计算输入数组中所有元素的指数。
`expm1`(x, /[, out, where, casting, order, ...])	计算数组中所有元素�� `exp(x) - 1`。
`exp2`(x, /[, out, where, casting, order, ...])	计算输入数组中所有p的2p。
`log`(x, /[, out, where, casting, order, ...])	自然对数，对每个元素进行操作。
`log10`(x, /[, out, where, casting, order, ...])	返回输入数组每个元素的以 10 为底的对数。
`log2`(x, /[, out, where, casting, order, ...])	x 的底为 2 的对数。
`log1p`(x, /[, out, where, casting, order, ...])	返回输入数组每个元素加一后的自然对数。
`logaddexp`(x1, x2, /[, out, where, casting, ...])	输入的指数之和的对数。
`logaddexp2`(x1, x2, /[, out, where, casting, ...])	基于底为 2 计算输入的指数之和的对数。

其他特殊函数

`i0`(x)	第一类修改 Bessel 函数，阶数为 0。
`sinc`(x)	返回归一化的 sinc 函数。

浮点数例程

`signbit`(x, /[, out, where, casting, order, ...])	在符号位设置时返回 True，即小于零。
`copysign`(x1, x2, /[, out, where, casting, ...])	将 x1 的符号更改为 x2 的符号，对每个元素进行操作。
`frexp`(x[, out1, out2], / [[, out, where, ...])	将 x 的元素分解为尾数和两个的指数。
`ldexp`(x1, x2, /[, out, where, casting, ...])	返回 x1 * 2**x2，对每个元素进行操作。
`nextafter`(x1, x2, /[, out, where, casting, ...])	返回 x1 朝向 x2 的下一个浮点值，对每个元素进行操作。
`spacing`(x, /[, out, where, casting, order, ...])	返回 x 与最近相邻数之间的距离。

有理数例程

`lcm`(x1, x2, /[, out, where, casting, order, ...])	返回`\|x1\|`和`\|x2\|`的最小公倍数。
`gcd`(x1, x2, /[, out, where, casting, order, ...])	返回`\|x1\|`和`\|x2\|`的最大公约数。

算术运算

`add`(x1, x2, /[, out, where, casting, order, ...])	逐元素地相加。
`reciprocal`(x, /[, out, where, casting, ...])	返回参数的倒数，逐元素进行操作。
`positive`(x, /[, out, where, casting, order, ...])	数值取正，逐元素进行操作。
`negative`(x, /[, out, where, casting, order, ...])	数值求负，逐元素进行操作。
`multiply`(x1, x2, /[, out, where, casting, ...])	逐元素地相乘。
`divide`(x1, x2, /[, out, where, casting, ...])	逐元素地相除。
`power`(x1, x2, /[, out, where, casting, ...])	将第一个数组的元素逐元素地提升到第二个数组的幂。
`subtract`(x1, x2, /[, out, where, casting, ...])	逐元素地相减。
`true_divide`(x1, x2, /[, out, where, ...])	逐元素地相除。
`floor_divide`(x1, x2, /[, out, where, ...])	返回输入的商中最大的小于或等于整数。
`float_power`(x1, x2, /[, out, where, ...])	将第一个数组的元素逐元素地提升到第二个数组的幂。
`fmod`(x1, x2, /[, out, where, casting, ...])	返回逐元素地取模后的余数。
`mod`(x1, x2, /[, out, where, casting, order, ...])	返回逐元素地取模后的余数。
`modf`(x[, out1, out2], / [[, out, where, ...])	返回数组的分数部分和整数部分，逐元素进行操作。
`remainder`(x1, x2, /[, out, where, casting, ...])	返回逐元素地取模后的余数。
`divmod`(x1, x2[, out1, out2], / [[, out, ...])	同时返回逐元素地商和余数。

处理复数

`angle`(z[, deg])	返回复数参数的角度。
`real`(val)	返回复数参数的实部。
`imag`(val)	返回复数参数的虚部。
`conj`(x, /[, out, where, casting, order, ...])	返回复共轭，逐元素计算。
`conjugate`(x, /[, out, where, casting, ...])	返回复共轭，逐元素计算。

极值查找

`maximum`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最大值。
`max`(a[, axis, out, keepdims, initial, where])	返回数组的最大值或沿轴的最大值。
`amax`(a[, axis, out, keepdims, initial, where])	返回数组的最大值或沿轴的最大值。
`fmax`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最大值。
`nanmax`(a[, axis, out, keepdims, initial, where])	返回数组的最大值或沿轴的最大值，忽略任何 NaN 值。
`minimum`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最小值。
`min`(a[, axis, out, keepdims, initial, where])	返回数组的最小值或沿轴的最小值。
`amin`(a[, axis, out, keepdims, initial, where])	返回数组的最小值或沿轴的最小值。
`fmin`(x1, x2, /[, out, where, casting, ...])	数组元素的逐元素最小值。
`nanmin`(a[, axis, out, keepdims, initial, where])	返回数组的最小值或沿轴的最小值，忽略任何 NaN 值。

其他

`convolve`(a, v[, mode])	返回两个一维序列的离散线性卷积。
`clip`(a, a_min, a_max[, out])	将数组中的值裁剪（限制）到指定范围内。
`sqrt`(x, /[, out, where, casting, order, ...])	返回数组的非负平方根，逐元素计算。
`cbrt`(x, /[, out, where, casting, order, ...])	返回数组的立方根，逐元素计算。
`square`(x, /[, out, where, casting, order, ...])	返回输入的逐元素平方。
`absolute`(x, /[, out, where, casting, order, ...])	计算元素级别的绝对值。
`fabs`(x, /[, out, where, casting, order, ...])	计算元素级别的绝对值。
`sign`(x, /[, out, where, casting, order, ...])	返回一个元素级别的数字符号指示。
`heaviside`(x1, x2, /[, out, where, casting, ...])	计算海维赛德阶跃函数。
`nan_to_num`(x[, copy, nan, posinf, neginf])	用零替换 NaN，用大有限数替换无穷大（默认行为）或者用用户使用`nan`、posinf或neginf关键字定义的数字替换。
`real_if_close`(a[, tol])	如果输入是复数，所有虚部接近零，则返回实部。
`interp`(x, xp, fp[, left, right, period])	单调递增样本点的一维线性插值。

`numpy.sin`

原文：numpy.org/doc/1.26/reference/generated/numpy.sin.html

numpy.sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'sin'>

三角正弦，逐个元素。

参数：

xarray_like

弧度，以弧度为单位（(2 \pi) rad 等于 360 度）。

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供了，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。长度等于输出数量的元组（可能仅作为关键字参数）。

wherearray_like, 可选

此条件在输入上广播。在条件为 True 的位置，out 数组将设置为 ufunc 结果。在其他位置，out 数组将保留其原始值。请注意，如果通过默认值 out=None 创建了未初始化的 out 数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他仅关键字参数，请参阅 ufunc 文档。

yarray_like

x中每个元素的正弦。如果 x 是标量，则这是一个标量。

另请参阅

arcsin, sinh, cos

笔记

正弦是三角学（三角形的数学研究）的基本函数之一。考虑一个以原点为中心、半径为 1 的圆。一条射线从 (+x) 轴进入，以原点处的角度出发（逆时针从该轴测量），并离开原点。射线与单位圆相交的 (y) 坐标是该角度的正弦。它在 (x=3\pi / 2) 处为 -1，而在 (\pi / 2) 处为 +1。该函数在角度是 (\pi) 的倍数的位置为零。介于 (\pi) 和 (2\pi) 之间的角的正弦为负。正弦和相关函数的众多特性包括在任何标准三角学文本中。

例子

打印一个角度的正弦：

>>> np.sin(np.pi/2.)
1.0

打印以度为单位给出的角度数组的正弦：

>>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. )
array([ 0\.        ,  0.5       ,  0.70710678,  0.8660254 ,  1\.        ])

绘制正弦函数：

>>> import matplotlib.pylab as plt
>>> x = np.linspace(-np.pi, np.pi, 201)
>>> plt.plot(x, np.sin(x))
>>> plt.xlabel('Angle [rad]')
>>> plt.ylabel('sin(x)')
>>> plt.axis('tight')
>>> plt.show()

../../_images/numpy-sin-1.png

`numpy.cos`

原文：numpy.org/doc/1.26/reference/generated/numpy.cos.html

numpy.cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'cos'>

逐元素计算余弦。

参数：

xarray_like

弧度制输入数组。

outndarray、None 或 ndarray 和 None 的元组，可选

用来存储结果的位置。如果提供了，它必须具有与输入广播到的形状相同的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）必须具有与输出数量相等的长度。

wherearray_like, 可选

此条件广播至输入。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认的out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其它仅限关键字参数，请参阅 ufunc docs。

yndarray

对应的余弦值。如果x是一个标量，则为标量。

注意

如果提供了out，函数会将结果写入其中，并返回out的引用。（见示例）

参考

M. Abramowitz 和 I. A. Stegun，《数学函数手册》纽约，NY：多佛，1972 年。

例子

>>> np.cos(np.array([0, np.pi/2, np.pi]))
array([  1.00000000e+00,   6.12303177e-17,  -1.00000000e+00])
>>>
>>> # Example of providing the optional output parameter
>>> out1 = np.array([0], dtype='d')
>>> out2 = np.cos([0.1], out1)
>>> out2 is out1
True
>>>
>>> # Example of ValueError due to provision of shape mis-matched `out`
>>> np.cos(np.zeros((3,3)),np.zeros((2,2)))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (3,3) (2,2)

`numpy.tan`

原文：numpy.org/doc/1.26/reference/generated/numpy.tan.html

numpy.tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'tan'>

逐元素计算切线。

等价于np.sin(x)/np.cos(x)逐元素运算。

参数：

x，array_like

输入数组。

out，ndarray，None，或元组（ndarray 和 None），可选

存储结果的位置。如果提供了，则必须具有输入扩展到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出数。

where，array_like，可选

此条件在输入上广播。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认值out=None创建了一个未初始化的out数组，那么其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc docs。

y，ndarray

相应的切线值。如果x是标量，则这是一个标量。

注意

如果提供了out，函数会将结果写入其中，并返回out的引用。（参见示例）

引用

M. Abramowitz 和 I. A. Stegun，《Handbook of Mathematical Functions》，1972 年，纽约多佛出版社。

示例

>>> from math import pi
>>> np.tan(np.array([-pi,pi/2,pi]))
array([  1.22460635e-16,   1.63317787e+16,  -1.22460635e-16])
>>>
>>> # Example of providing the optional output parameter illustrating
>>> # that what is returned is a reference to said parameter
>>> out1 = np.array([0], dtype='d')
>>> out2 = np.cos([0.1], out1)
>>> out2 is out1
True
>>>
>>> # Example of ValueError due to provision of shape mis-matched `out`
>>> np.cos(np.zeros((3,3)),np.zeros((2,2)))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (3,3) (2,2)

`numpy.arcsin`

原文：numpy.org/doc/1.26/reference/generated/numpy.arcsin.html

numpy.arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'arcsin'>

逐元素的反正弦。

参数：

xarray_like

单位圆上的y坐标。

outndarray、None 或者 ndarray 和 None 的元组，可选

一个用于存储结果的位置。如果提供，它必须具有与输入传播的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）的长度必须等于输出的数量。

wherearray_like，可选

此条件会对输入进行广播。在条件为 True 的位置，out 数组将被设置为 ufunc 的结果。在其他位置，out 数组将保留其原始值。注意，如果通过默认 out=None 创建了未初始化的 out 数组，则其中条件为 False 的位置将保持未初始化。

**kwargs

对于其他关键字参数，请参见 ufunc 文档。

anglendarray

x 中每个元素的反正弦，以弧度为单位，在闭区间 [-pi/2, pi/2] 内。如果 x 是一个标量，则为标量。

另请参见

sin，cos，arccos，tan，arctan，arctan2，emath.arcsin

注意事项

arcsin 是一个多值函数：对于每个 x，存在无穷多个数字 z，使得 (sin(z) = x)。惯例是返回实部位于 [-pi/2, pi/2] 的角度 z。

对于实值输入数据类型，arcsin 总是返回实数输出。对于每个无法表示为实数或无穷大的值，它产生 nan 并设置 invalid 浮点错误标志。

对于复值输入，arcsin 是一个复解析函数，按照惯例，其分支切割为 [-inf, -1] 和 [1, inf]，在前者上方连续，在后者下方连续。

反正弦也被称为 asin 或 sin^{-1}。

引用

Abramowitz, M. 和 Stegun, I. A.，《Handbook of Mathematical Functions》，第 10 版，纽约：多佛出版社，1964 年，第 79 页。personal.math.ubc.ca/~cbm/aands/page_79.htm

示例

>>> np.arcsin(1)     # pi/2
1.5707963267948966
>>> np.arcsin(-1)    # -pi/2
-1.5707963267948966
>>> np.arcsin(0)
0.0

`numpy.arccos`

原文：numpy.org/doc/1.26/reference/generated/numpy.arccos.html

numpy.arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'arccos'>

逐元素的反余弦三角函数。

cos的反函数，如果 y = cos(x)，则 x = arccos(y)。

参数:

xarray_like

x轴上的单位圆上的坐标。对于实数参数，定义域是[-1, 1]。

outndarray, None, 或元组 ndarray 和 None, 可选

结果存储的位置。如果提供，必须具有与输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）的长度必须等于输出的数量。

其中array_like, 可选

此条件广播到输入。在条件为真的位置，out 数组将设置为 ufunc 结果。在其他地方，out 数组将保留其原始值。请注意，如果通过默认的 out=None 创建了未初始化的 out 数组，则其中条件为假的位置将保持未初始化。

**kwargs

对于其他仅关键字参数，请参阅 ufunc 文档。

角度ndarray

与给定 x 坐标在弧度 [0, pi] 处相交单位圆的射线的角度。如果 x 是标量，则这是一个标量。

另请参阅

cos, arctan, arcsin, emath.arccos

备注

arccos 是一个多值函数：对于每个 x，有无数多个数 z 使得 cos(z) = x。约定是返回实部位于 [0, pi] 的角度 z。

对于实值输入数据类型，arccos 总是返回实数输出。对于每个不能表示为实数或无穷大的值，它产生 nan 并设置 invalid 浮点错误标志。

对于复值输入，arccos 是一个具有分支割线 [-inf, -1] 和 [1, inf] 的复解析函数，对于前者从上方连续，对于后者从下方连续。

反余弦cos 也被称为 acos 或 cos^-1。

参考

M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”, 1964 年第 10 次印刷, 页码 79. personal.math.ubc.ca/~cbm/aands/page_79.htm

示例

我们期望 arccos(1) 为 0，并且 arccos(-1) 为 pi：

>>> np.arccos([1, -1])
array([ 0\.        ,  3.14159265])

绘制 arccos:

>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-1, 1, num=100)
>>> plt.plot(x, np.arccos(x))
>>> plt.axis('tight')
>>> plt.show()

../../_images/numpy-arccos-1.png

`numpy.arctan`

原文：numpy.org/doc/1.26/reference/generated/numpy.arctan.html

numpy.arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'arctan'>

反三角正切，逐个元素计算。

反正切函数的逆运算，如果y = tan(x)，那么x = arctan(y)。

参数：

xarray_like

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，必须具有输入广播到的形状。如果未提供或 None，则返回一个新分配的数组。元组（仅限关键字参数）的长度必须等于输出的数量。

wherearray_like，可选

此条件在输入上广播。在条件为真的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他关键字-only 参数，请参阅 ufunc docs。

outndarray 或标量

输出与x相同的形状。其实部在[-pi/2, pi/2]（arctan(+/-inf)返回+/-pi/2）。如果x是标量，这是一个标量。

另请参见

arctan2

由（x，y）和正x轴形成的角度的“四象限”反正切。

angle

复数值的参数。

注意

arctan是一个多值函数：对于每个x，都存在无数多个z，使得 tan(z) = x。约定是返回其实部位于[-pi/2, pi/2]的角度z。

对于实值输入数据类型，arctan总是返回实值输出。对于每个值，如果不能表达为实数或无穷大，它产生nan并设置invalid浮点错误标志。

对于复值输入，arctan是一个通解复解析函数，它有[1j, infj]和[-1j, -infj]作为分支切线，对前者是左连续的，对后者是右连续的。

反正切也被称为atan或tan^{-1}。

参考

Abramowitz, M. and Stegun, I. A.，Handbook of Mathematical Functions，第 10 版，纽约：多弗尔出版社，1964 年，第 79 页。personal.math.ubc.ca/~cbm/aands/page_79.htm

示例

我们期望 0 的反正切是 0，1 的反正切是 pi/4：

>>> np.arctan([0, 1])
array([ 0\.        ,  0.78539816])

>>> np.pi/4
0.78539816339744828

绘制反正切：

>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-10, 10)
>>> plt.plot(x, np.arctan(x))
>>> plt.axis('tight')
>>> plt.show()

../../_images/numpy-arctan-1.png

`numpy.hypot`

原文：numpy.org/doc/1.26/reference/generated/numpy.hypot.html

numpy.hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'hypot'>

给定“腿”的直角三角形，返回其斜边。

相当于sqrt(x1**2 + x2**2)，逐元素计算。如果x1或x2是标量（即可以明确转换为标量类型），它将被广播以用于另一个参数的每个元素。（参见示例）

参数：

x1, x2array_like

三角形的腿。如果x1.shape != x2.shape，它们必须能够广播到一个共同的形状（这将成为输出的形状）。

outndarray，None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供了，它必须具有输入广播到的形状。如果不提供或为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数可能）必须具有与输出数量相等的长度。

wherearray_like，可选

此条件会广播到输入。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他位置，out数组将保留其原始值。请注意，如果通过默认的out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字参数，请参阅 ufunc docs。

zndarray

三角形的斜边。如果x1和x2都是标量，则这是一个标量。

示例

>>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3)))
array([[ 5.,  5.,  5.],
 [ 5.,  5.,  5.],
 [ 5.,  5.,  5.]])

显示标量样式参数的广播示例：

>>> np.hypot(3*np.ones((3, 3)), [4])
array([[ 5.,  5.,  5.],
 [ 5.,  5.,  5.],
 [ 5.,  5.,  5.]])

`numpy.arctan2`

原文：numpy.org/doc/1.26/reference/generated/numpy.arctan2.html

numpy.arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'arctan2'>

选择正确象限的x1/x2的元素级反正切。

选择象限（即分支），以便arctan2(x1, x2)是通过点(1,0)结束并通过点(x2, x1)结束的射线与起点之间的有符号弧度角（注意角色颠倒：第一个函数参数是“y-坐标”，第二个是“x-坐标”）。根据 IEEE 约定，此函数对于x2 = +/-0 以及x1和/或x2 = +/-inf 都定义了（有关特定值，请参阅注意事项）。

此函数对于复数值参数未定义；对于所谓的复数值的参数，请使用angle。

参数：

x1数组样式，实数型

y坐标。

x2数组样式，实数型

x坐标。如果x1.shape != x2.shape，它们必须可广播到一个公共形状（这将成为输出的形状）。

out数组样式，None 或者包含数组和 None 的元组，可选

结果存储的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。元组（仅作为关键字参数）必须具有与输出数量相等的长度。

where数组样式，可选

此条件广播至输入。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他位置，out数组将保留其原始值。请注意，如果通过默认out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字的参数，请参阅 ufunc 文档。

角度数组

角度数组，单位为弧度，范围为[-pi, pi]。如果x1和x2都是标量，则这是一个标量。

另请参见

arctan，tan，angle

注意事项

arctan2与底层 C 库的atan2函数相同。C 标准中定义了以下特殊值：[1]

x1	x2	arctan2(x1,x2)
+/- 0	+0	+/- 0
+/- 0	-0	+/- pi
> 0	+/-inf	+0 / +pi
< 0	+/-inf	-0 / -pi
+/-inf	+inf	+/- (pi/4)
+/-inf	-inf	+/- (3*pi/4)

请注意，+0 和-0 是不同的浮点数，+inf 和-inf 也是如此。

参考文献

[1]

ISO/IEC 标准 9899:1999，“C 编程语言。”

示例

考虑不同象限中的四个点：

>>> x = np.array([-1, +1, +1, -1])
>>> y = np.array([-1, -1, +1, +1])
>>> np.arctan2(y, x) * 180 / np.pi
array([-135.,  -45.,   45.,  135.])

注意参数的顺序。arctan2 在x2等于 0 以及其他几个特殊点也有定义，并在范围[-pi, pi]内取值：

>>> np.arctan2([1., -1.], [0., 0.])
array([ 1.57079633, -1.57079633])
>>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf])
array([0\.        , 3.14159265, 0.78539816])

`numpy.degrees`

原文：numpy.org/doc/1.26/reference/generated/numpy.degrees.html

numpy.degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'degrees'>

将角度从弧度转换为度。

参数：

x：array_like

弧度的输入数组。

out：ndarray、None 或者 ndarray 和 None 的元组，可选

存储结果的位置。如果提供了，则必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。作为关键字参数的元组必须具有与输出数量相等的长度。

where：array_like，可选

此条件将传播到输入。在条件为 True 的位置，out数组将被设置为 ufunc 的结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认的out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他关键字参数，请参阅 ufunc 文档。

y：浮点数的 ndarray

对应的度数值；如果提供了out，则这是对其的引用。如果x是标量，这是一个标量。

另请参阅

rad2deg

等效函数

示例

将弧度数组转换为度数

>>> rad = np.arange(12.)*np.pi/6
>>> np.degrees(rad)
array([   0.,   30.,   60.,   90.,  120.,  150.,  180.,  210.,  240.,
 270.,  300.,  330.])

>>> out = np.zeros((rad.shape))
>>> r = np.degrees(rad, out)
>>> np.all(r == out)
True

`numpy.radians`

原文：numpy.org/doc/1.26/reference/generated/numpy.radians.html

numpy.radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <ufunc 'radians'>

将角度从度数转换为弧度。

参数：

xarray_like

输入数组以度为单位。

outndarray，None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。只有作为关键字参数的元组必须具有长度等于输出数量。

wherearray_like，可选

此条件将广播到输入。在条件为 True 的位置，out数组将被设置为 ufunc 的结果。在其他位置，out数组将保持其原始值。请注意，如果通过默认值out=None创建了未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

对于其他仅限关键字的参数，请参阅 ufunc docs。

返回值：

yndarray

相应的弧度值。如果x是标量，则为标量。

另请参阅

deg2rad

等效的函数

示例

将角度数组转换为弧度

>>> deg = np.arange(12.) * 30.
>>> np.radians(deg)
array([ 0\.        ,  0.52359878,  1.04719755,  1.57079633,  2.0943951 ,
 2.61799388,  3.14159265,  3.66519143,  4.1887902 ,  4.71238898,
 5.23598776,  5.75958653])

>>> out = np.zeros((deg.shape))
>>> ret = np.radians(deg, out)
>>> ret is out
True

posted @ 2024-06-24 14:55 绝不原创的飞龙阅读(2) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

NumPy-1-26-中文文档-十四-

NumPy 1.26 中文文档（十四）

numpy.ma.corrcoef

numpy.ma.cov

numpy.ma.cumsum

numpy.ma.cumprod

numpy.ma.mean

numpy.ma.median

numpy.ma.power

numpy.ma.prod

numpy.ma.std

numpy.ma.sum

numpy.ma.var

numpy.ma.MaskedArray.anom

numpy.ma.MaskedArray.cumprod

numpy.ma.MaskedArray.cumsum

numpy.ma.MaskedArray.mean

numpy.ma.MaskedArray.prod

numpy.ma.MaskedArray.std

numpy.ma.MaskedArray.sum

numpy.ma.MaskedArray.var

numpy.ma.argmax

numpy.ma.argmin

numpy.ma.max

numpy.ma.min

numpy.ma.ptp

numpy.ma.diff

numpy.ma.MaskedArray.argmax

numpy.ma.MaskedArray.argmin

numpy.ma.MaskedArray.max

numpy.ma.MaskedArray.min

numpy.ma.MaskedArray.ptp

numpy.ma.argsort

numpy.ma.sort

numpy.ma.MaskedArray.argsort

numpy.ma.MaskedArray.sort

numpy.ma.diag

numpy.ma.dot

numpy.ma.identity

numpy.ma.inner

numpy.ma.innerproduct

numpy.ma.outer

numpy.ma.outerproduct

numpy.ma.trace

numpy.ma.transpose

numpy.ma.MaskedArray.trace

numpy.ma.MaskedArray.transpose

numpy.ma.vander

numpy.ma.polyfit

numpy.ma.around

numpy.ma.clip

numpy.ma.round

numpy.ma.MaskedArray.clip

numpy.ma.MaskedArray.round

numpy.ma.intersect1d

numpy.ma.setdiff1d

numpy.ma.setxor1d

numpy.ma.union1d

numpy.ma.allequal

numpy.ma.allclose

numpy.ma.apply_along_axis

numpy.ma.apply_over_axes

numpy.ma.arange

numpy.ma.choose

numpy.ma.ediff1d

numpy.ma.indices

numpy.ma.where

数学函数

三角函数

双曲函数

舍入

求和，乘积，差异

指数和对数

其他特殊函数

浮点数例程

分式计算

算术运算

虚数处理

`numpy.ma.corrcoef`

`numpy.ma.cov`

`numpy.ma.cumsum`

`numpy.ma.cumprod`

`numpy.ma.mean`

`numpy.ma.median`

`numpy.ma.power`

`numpy.ma.prod`

`numpy.ma.std`

`numpy.ma.sum`

`numpy.ma.var`

`numpy.ma.MaskedArray.anom`

`numpy.ma.MaskedArray.cumprod`

`numpy.ma.MaskedArray.cumsum`

`numpy.ma.MaskedArray.mean`

`numpy.ma.MaskedArray.prod`

`numpy.ma.MaskedArray.std`

`numpy.ma.MaskedArray.sum`

`numpy.ma.MaskedArray.var`

`numpy.ma.argmax`

`numpy.ma.argmin`

`numpy.ma.max`

`numpy.ma.min`

`numpy.ma.ptp`

`numpy.ma.diff`

`numpy.ma.MaskedArray.argmax`

`numpy.ma.MaskedArray.argmin`

`numpy.ma.MaskedArray.max`

`numpy.ma.MaskedArray.min`

`numpy.ma.MaskedArray.ptp`

`numpy.ma.argsort`

`numpy.ma.sort`

`numpy.ma.MaskedArray.argsort`

`numpy.ma.MaskedArray.sort`

`numpy.ma.diag`

`numpy.ma.dot`

`numpy.ma.identity`

`numpy.ma.inner`

`numpy.ma.innerproduct`

`numpy.ma.outer`

`numpy.ma.outerproduct`

`numpy.ma.trace`

`numpy.ma.transpose`

`numpy.ma.MaskedArray.trace`

`numpy.ma.MaskedArray.transpose`

`numpy.ma.vander`

`numpy.ma.polyfit`

`numpy.ma.around`

`numpy.ma.clip`

`numpy.ma.round`

`numpy.ma.MaskedArray.clip`

`numpy.ma.MaskedArray.round`

`numpy.ma.intersect1d`

`numpy.ma.setdiff1d`

`numpy.ma.setxor1d`

`numpy.ma.union1d`

`numpy.ma.allequal`

`numpy.ma.allclose`

`numpy.ma.apply_along_axis`

`numpy.ma.apply_over_axes`

`numpy.ma.arange`

`numpy.ma.choose`

`numpy.ma.ediff1d`

`numpy.ma.indices`

`numpy.ma.where`

`numpy.sin`

`numpy.cos`

`numpy.tan`

`numpy.arcsin`

`numpy.arccos`

`numpy.arctan`

`numpy.hypot`

`numpy.arctan2`

`numpy.degrees`

`numpy.radians`