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

NumPy 1.26 中文文档（十二）

原文：numpy.org/doc/

numpy.any

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

numpy.any(a, axis=None, out=None, keepdims=<no value>, *, where=<no value>)

检验沿着给定轴是否存在任何数组元素评估为 True。

如果 axis 是 None，则返回单个布尔值。

参数：

a array_like

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

axis None 或 int 或 int 元组，可选的

进行逻辑或归约操作的轴或轴。默认(axis=None)是对输入数组的所有维度执行逻辑或运算。axis 可能为负值，这种情况下将从最后一个轴开始计算。

1.7.0 版本中新增。

如果这是一个整数元组，则在多个轴上执行归约操作，而不是像以前那样在单个轴或所有轴上执行操作。

out ndarray，可选的

替代的输出数组，用于存放结果。它必须与预期输出具有相同的形状，并且其类型会保留（例如，如果它的类型为 float，则它将保留为 float，True 返回 1.0，False 返回 0.0，不管 a 的类型如何）。有关更多详细信息，请参阅输出类型确定。

keepdims bool，可选的

如果设置为 True，则被归约的轴将保留在结果中作为具有大小为一的维度。使用此选项，结果将正确广播到输入阵列。

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

where array_like 的 bool，可选的

在检查任何 True 值时要包括的元素。有关详情，请参见reduce。

1.20.0 版本中新增。

返回：

any bool 或 ndarray

除非指定 out，否则将返回一个新的布尔值或 ndarray的引用。

另请参见

ndarray.any

等效方法

all

检验沿着给定轴的所有元素是否评估为 True。

注释

Not a Number (NaN), 正无穷和负无穷会被计算为True，因为它们不等于零。

示例

>>> np.any([[True, False], [True, True]])
True 

>>> np.any([[True, False], [False, False]], axis=0)
array([ True, False]) 

>>> np.any([-1, 0, 5])
True 

>>> np.any(np.nan)
True 

>>> np.any([[True, False], [False, False]], where=[[False], [True]])
False 

>>> o=np.array(False)
>>> z=np.any([-1, 4, 5], out=o)
>>> z, o
(array(True), array(True))
>>> # Check now that z is a reference to o
>>> z is o
True
>>> id(z), id(o) # identity of z and o 
(191614240, 191614240) 

numpy.isfinite

原文:numpy.org/doc/1.26/reference/generated/numpy.isfinite.html

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

元素级检查有限性(非无穷且非 Not a Number)。

结果以布尔数组的形式返回。

参数:

xarray_like

输入值。

outndarray, None, or tuple of ndarray and None, optional

存储结果的位置。如果提供, 它必须具有与输入广播后的形状相同的形状。如果未提供或为 None, 则返回一个新分配的数组。元组(仅作为关键字参数可能出现)的长度必须等于输出的数量。

wherearray_like, optional

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

**kwargs

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

返回值:

yndarray, bool

当 x 不是正无穷、负无穷或 NaN 时返回 True; 否则返回 False。如果 x 是标量，则结果也是标量。

另见

isinf、isneginf、isposinf、isnan

注意

Not a Number、正无穷和负无穷被视为非有限。

NumPy 使用 IEEE 754 标准进行浮点运算。这意味着 Not a Number 不等同于无穷大。同时, 正无穷也不等同于负无穷。但是, 正无穷等同于无穷大。如果第二个参数在 x 为标量输入时提供, 或者第一个和第二个参数形状不同时会出错。

示例

>>> np.isfinite(1)
True
>>> np.isfinite(0)
True
>>> np.isfinite(np.nan)
False
>>> np.isfinite(np.inf)
False
>>> np.isfinite(np.NINF)
False
>>> np.isfinite([np.log(-1.),1.,np.log(0)])
array([False,  True, False]) 

>>> x = np.array([-np.inf, 0., np.inf])
>>> y = np.array([2, 2, 2])
>>> np.isfinite(x, y)
array([0, 1, 0])
>>> y
array([0, 1, 0]) 

numpy.isinf

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

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

逐元素测试是否为正无穷大或负无穷大。

返回一个布尔数组，形状与 x 相同，x == +/-inf 时为 True，否则为 False。

参数：

xarray_like

输入值

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

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

wherearray_like，可选

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

**kwargs

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

返回：

ybool（标量）或布尔 ndarray

x 为正无穷大或负无穷大时为 True，否则为 False。如果 x 是标量，则结果也是标量。

另请参阅：

isneginf, isposinf, isnan, isfinite

注意事项：

NumPy 使用 IEEE 标准的二进制浮点数算术（IEEE 754）。

如果第一个参数是标量，则在提供第二个参数时会产生错误，或者如果第一个参数和第二个参数的形状不同也会产生错误。

示例：

>>> np.isinf(np.inf)
True
>>> np.isinf(np.nan)
False
>>> np.isinf(np.NINF)
True
>>> np.isinf([np.inf, -np.inf, 1.0, np.nan])
array([ True,  True, False, False]) 

>>> x = np.array([-np.inf, 0., np.inf])
>>> y = np.array([2, 2, 2])
>>> np.isinf(x, y)
array([1, 0, 1])
>>> y
array([1, 0, 1]) 

numpy.isnan

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

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

对 NaN 进行逐元素测试，并将结果作为布尔数组返回。

参数：

xarray_like

输入数组。

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

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

wherearray_like，可选

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

**kwargs

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

返回：

y ndarray 或布尔

当 x 为 NaN 时为 True，否则为 False。如果 x 是标量，则这是一个标量。

另请参见

isinf、isneginf、isposinf、isfinite、isnat

注意

NumPy 使用 IEEE 标准的二进制浮点运算（IEEE 754）。这意味着 Not a Number 不等同于无穷大。

示例

>>> np.isnan(np.nan)
True
>>> np.isnan(np.inf)
False
>>> np.isnan([np.log(-1.),1.,np.log(0)])
array([ True, False, False]) 

numpy.isnat

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

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

逐元素测试是否为 NaT（非时间）并将结果返回为布尔值数组。

从版本 1.13.0 开始新增。

参数：

x类似数组

输入包含日期时间或时间差数据类型的数组。

outn 维数组、None 或 n 维数组和 None 的元组，可选

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

where类似数组，可选

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

**kwargs

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

返回：

yn 维数组或布尔值

如果x是 NaT，则为 True，否则为 False。如果x是标量，则为标量。

另请参见

isnan, isinf, isneginf, isposinf, isfinite

示例

>>> np.isnat(np.datetime64("NaT"))
True
>>> np.isnat(np.datetime64("2016-01-01"))
False
>>> np.isnat(np.array(["NaT", "2016-01-01"], dtype="datetime64[ns]"))
array([ True, False]) 

numpy.isneginf

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

numpy.isneginf(x, out=None)

逐元素测试是否为负无穷大，并返回布尔数组作为结果。

参数：

x数组型

输入数组。

out数组型，可选

存储结果的位置。如果提供，必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的布尔数组。

返回：

out ndarray

一个与输入相同维度的布尔数组。如果没有提供第二个参数，则返回一个 numpy 布尔数组，其中对应输入元素为负无穷大的值为 True，对应输入元素不为负无穷大的值为 False。

如果提供第二个参数，则结果将存储在那里。如果该数组的类型是数值类型，则结果将表示为零和一，如果类型是布尔类型，则表示为 False 和 True。返回值out然后是对该数组的引用。

另请参见

isinf，isposinf，isnan，isfinite

备注

NumPy 使用 IEEE 标准进行二进制浮点运算（IEEE 754）。

如果 x 是标量输入，则第二个参数也被提供会导致错误结果，如果第一个和第二个参数具有不同的形状，或者第一个参数具有复数值也会导致错误。

例子

>>> np.isneginf(np.NINF)
True
>>> np.isneginf(np.inf)
False
>>> np.isneginf(np.PINF)
False
>>> np.isneginf([-np.inf, 0., np.inf])
array([ True, False, False]) 

>>> x = np.array([-np.inf, 0., np.inf])
>>> y = np.array([2, 2, 2])
>>> np.isneginf(x, y)
array([1, 0, 0])
>>> y
array([1, 0, 0]) 

numpy.isposinf

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

numpy.isposinf(x, out=None)

对每个元素逐个测试是否为正无穷大，返回布尔数组作为结果。

参数：

xarray_like

输入数组。

outarray_like，可选

存储结果的位置。如果提供了该参数，则它必须具有输入可以广播到的形状。如果没有提供或为 None，则返回一个新分配的布尔数组。

返回值：

outndarray

一个布尔数组，与输入具有相同的维度。如果没有提供第二个参数，则返回一个布尔数组，其中元素的值为 True，对应的输入元素为正无穷大，否则为 False。

如果有提供第二个参数，则结果将储存在那个位置。如果该数组的类型是数值类型，则结果表示为零和一；如果类型是布尔类型，则表示为 False 和 True。返回值 out 是对该数组的引用。

参见

isinf、isneginf、isfinite、isnan

注意事项

NumPy 在算术运算中使用 IEEE 二进制浮点数标准（IEEE 754）。

如果 x 是标量输入时也提供了第二个参数、第一个参数和第二个参数的形状不同或者第一个参数含有复数值，则会出现错误结果。

示例

>>> np.isposinf(np.PINF)
True
>>> np.isposinf(np.inf)
True
>>> np.isposinf(np.NINF)
False
>>> np.isposinf([-np.inf, 0., np.inf])
array([False, False,  True]) 

>>> x = np.array([-np.inf, 0., np.inf])
>>> y = np.array([2, 2, 2])
>>> np.isposinf(x, y)
array([0, 0, 1])
>>> y
array([0, 0, 1]) 

numpy.iscomplex

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

numpy.iscomplex(x)

返回一个布尔数组，其中输入元素为复数时为 True。

测试的是输入是否具有非零虚部，而不是输入类型是否为复数。

参数：

xarray_like

输入数组。

返回：

outbool 型的 ndarray

输出数组。

另请参阅

isreal

iscomplexobj

如果 x 是复数类型或复数数组，则返回 True。

示例

>>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j])
array([ True, False, False, False, False,  True]) 

numpy.iscomplexobj

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

numpy.iscomplexobj(x)

检查复数类型或复数数组。

检查输入的类型，而不是值。即使输入的虚部等于零，iscomplexobj 也会计算为真。

参数：

x 任意类型

输入可以是任何类型和形状。

返回：

iscomplexobj 布尔值

返回值，如果 x 是复数类型或至少有一个复数元素，则为真。

另请参阅

isrealobj，iscomplex

示例

>>> np.iscomplexobj(1)
False
>>> np.iscomplexobj(1+0j)
True
>>> np.iscomplexobj([3, 1+0j, True])
True 

numpy.isfortran

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

numpy.isfortran(a)

检查数组是否按 Fortran 连续但 不 是 C 连续。

此函数已过时，并且由于松弛的步幅检查导致的更改，对于 NumPy >= 1.10.0 及之前版本的相同数组，其返回值可能会有所不同。如果您只想检查数组是否按 Fortran 连续，请改用 a.flags.f_contiguous。

参数：

andarray

输入数组。

返回值：

isfortran布尔值

如果数组是 Fortran 连续但 不 是 C 连续，则返回 True。

示例

np.array 允许指定数组是按 C 连续顺序（最后一个索引变化最快）还是按内存中的 FORTRAN 连续顺序（第一个索引变化最快）编写的。

>>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
>>> a
array([[1, 2, 3],
 [4, 5, 6]])
>>> np.isfortran(a)
False 

>>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F')
>>> b
array([[1, 2, 3],
 [4, 5, 6]])
>>> np.isfortran(b)
True 

C-ordered 数组的转置是一个 FORTRAN-ordered 数组。

>>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
>>> a
array([[1, 2, 3],
 [4, 5, 6]])
>>> np.isfortran(a)
False
>>> b = a.T
>>> b
array([[1, 4],
 [2, 5],
 [3, 6]])
>>> np.isfortran(b)
True 

即使 C-ordered 数组也是 FORTRAN-ordered，它们的求值结果为 False。

>>> np.isfortran(np.array([1, 2], order='F'))
False 

numpy.isreal

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

numpy.isreal(x)

返回一个布尔数组，其中输入元素为实数时为 True。

如果元素具有零虚部的复数类型，则该元素的返回值为 True。

参数：

x：类似数组

输入数组。

返回：

out：ndarray，布尔型

布尔数组，与 x 具有相同的形状。

另请参见

iscomplex

isrealobj

如果 x 不是复数类型，则返回 True。

注意

对于字符串或对象数组，isreal 可能会表现出意外行为（请参阅示例）。

示例

>>> a = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j], dtype=complex)
>>> np.isreal(a)
array([False,  True,  True,  True,  True, False]) 

该函数不适用于字符串数组。

>>> a = np.array([2j, "a"], dtype="U")
>>> np.isreal(a)  # Warns about non-elementwise comparison
False 

对于 dtype=object 的输入数组中的所有元素，即使其中任何元素为复数，也返回 True。

>>> a = np.array([1, "2", 3+4j], dtype=object)
>>> np.isreal(a)
array([ True,  True,  True]) 

不应将isreal与对象数组一起使用。

>>> a = np.array([1+2j, 2+1j], dtype=object)
>>> np.isreal(a)
array([ True,  True]) 

numpy.isrealobj

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

numpy.isrealobj(x)

如果x是非复杂类型或复数数组，则返回 True。

检查输入的类型，而不是值。因此，即使输入的虚部等于零， isrealobj 的数据类型是复数时，返回值为 False。

参数：

x 任何类型

输入可以是任何类型和形状。

返回值：

y 布尔类型

如果x是复杂类型，则返回值为 False。

参见

iscomplexobj，isreal

注意事项

该函数仅适用于具有数值的数组，但接受所有其他对象。由于它假定数组输入，其他对象的返回值可能为 True。

>>> np.isrealobj('A string')
True
>>> np.isrealobj(False)
True
>>> np.isrealobj(None)
True 

例子

>>> np.isrealobj(1)
True
>>> np.isrealobj(1+0j)
False
>>> np.isrealobj([3, 1+0j, True])
False 

numpy.isscalar

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

numpy.isscalar(element)

如果element的类型是标量类型，则返回 True。

参数：

element任意

输入参数，可以是任何类型和形状。

返回：

val布尔值

如果element是标量类型，则为 True，否则为 False。

参见

ndim

获取数组的维数

注意

如果需要更严格地识别数值标量，请使用isinstance(x, numbers.Number)，因为对于大多数非数值元素（如字符串），它会返回False。

在大多数情况下，应该使用np.ndim(x) == 0代替此函数，因为这样也适用于 0 维数组。这就是 numpy 如何重载函数的风格，例如gradient的dx参数和histogram的bins参数。一些关键区别：

x	isscalar(x)	np.ndim(x) == 0
PEP 3141 数字对象（包括内置对象）	True	True
内置字符串和缓冲对象	True	True
其他内置对象，例如pathlib.Path，异常，re.compile的结果	False	True
第三方对象如matplotlib.figure.Figure	False	True
零维 numpy 数组	False	True
其他 numpy 数组	False	False
列表，元组 和其他序列对象	False	False

示例

>>> np.isscalar(3.1)
True
>>> np.isscalar(np.array(3.1))
False
>>> np.isscalar([3.1])
False
>>> np.isscalar(False)
True
>>> np.isscalar('numpy')
True 

NumPy 支持 PEP 3141 数字：

>>> from fractions import Fraction
>>> np.isscalar(Fraction(5, 17))
True
>>> from numbers import Number
>>> np.isscalar(Number())
True 

numpy.logical_and

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

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

逐元素计算 x1 AND x2 的真值。

参数：

x1, x2类似数组

输入数组。如果x1.shape != x2.shape，它们必须可广播到一个通用形状（成为输出形状）。

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

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

where类似数组，可选

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

**kwargs

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

返回：

yndarray 或 bool

对x1和x2元素应用逻辑 AND 操作的布尔结果；形状由广播确定。如果x1和x2都是标量，则结果是标量。

另请参阅

logical_or，logical_not，logical_xor

bitwise_and

例子

>>> np.logical_and(True, False)
False
>>> np.logical_and([True, False], [False, False])
array([False, False]) 

>>> x = np.arange(5)
>>> np.logical_and(x>1, x<4)
array([False, False,  True,  True, False]) 

&运算符可用作布尔 ndarrays 上np.logical_and的简写。

>>> a = np.array([True, False])
>>> b = np.array([False, False])
>>> a & b
array([False, False]) 

numpy.logical_or

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

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

逐元素计算 x1 OR x2 的真值。

参数：

x1, x2array_like

将逻辑 OR 应用于 x1 和 x2 的元素。如果 x1.shape != x2.shape，它们必须可广播到一个公共形状（将成为输出的形状）。

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

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

wherearray_like，可选

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

**kwargs

有关其他仅限关键字的参数，请参见 ufunc 文档。

返回值：

yndarray 或 bool

对 x1 和 x2 的逻辑 OR 操作的布尔结果；形状由广播决定。如果 x1 和 x2 都是标量，则结果是标量。

另请参阅

logical_and、logical_not、logical_xor

bitwise_or

示例

>>> np.logical_or(True, False)
True
>>> np.logical_or([True, False], [False, False])
array([ True, False]) 

>>> x = np.arange(5)
>>> np.logical_or(x < 1, x > 3)
array([ True, False, False, False,  True]) 

对 boolean ndarrays，可以使用 | 运算符作为 np.logical_or 的简写。

>>> a = np.array([True, False])
>>> b = np.array([False, False])
>>> a | b
array([ True, False]) 

numpy.logical_not

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

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

逐元素计算 NOT x 的真值。

参数:

x数组样式

将逻辑 NOT 应用于x的元素。

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

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

where数组样式，可选

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

**kwargs

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

返回:

y布尔值或布尔 ndarray

返回与x相同形状的布尔结果，对x的元素进行 NOT 操作。如果x是标量，则结果是标量。

另请参见

logical_and，logical_or，logical_xor

示例

>>> np.logical_not(3)
False
>>> np.logical_not([True, False, 0, 1])
array([False,  True,  True, False]) 

>>> x = np.arange(5)
>>> np.logical_not(x<3)
array([False, False, False,  True,  True]) 

numpy.logical_xor

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

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

逐元素计算 x1 XOR x2 的真值。

参数：

x1, x2array_like

对 x1 和 x2 的逻辑异或操作。如果 x1.shape != x2.shape，它们必须可广播到一个公共形状（该形状成为输出的形状）。

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

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

wherearray_like，可选

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

**kwargs

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

返回：

ybool 或 bool 数组

逻辑异或运算应用于 x1 和 x2 元素的布尔结果；形状由广播确定。如果 x1 和 x2 都是标量，则这是一个标量。

另请参见

logical_and、logical_or、logical_not、bitwise_xor

示例

>>> np.logical_xor(True, False)
True
>>> np.logical_xor([True, True, False, False], [True, False, True, False])
array([False,  True,  True, False]) 

>>> x = np.arange(5)
>>> np.logical_xor(x < 1, x > 3)
array([ True, False, False, False,  True]) 

支持广播的简单示例

>>> np.logical_xor(0, np.eye(2))
array([[ True, False],
 [False,  True]]) 

numpy.allclose

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

numpy.allclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)

如果两个数组在容差范围内逐元素相等，则返回 True。

容差值为正，通常是非常小的数字。相对差异（rtol * abs(b)）和绝对差异atol相加要与a和b之间的绝对差异进行比较。

如果 NaN 位于相同位置且equal_nan=True，则将其视为相等。如果 Infs 位于相同位置且两个数组中的符号相同，则将其视为相等。

参数：

a, b类似数组

要比较的输入数组。

rtol浮点数

相对容差参数（见注释）。

atol浮点数

绝对容差参数（见注释）。

equal_nan布尔值

是否将 NaN 视为相等。如果为 True，则输出数组中的 NaN 将被视为与b中的 NaN 相等。

新版本 1.10.0 中新增。

返回：

allclose布尔值

如果两个数组在给定的容差范围内相等，则返回 True；否则返回 False。

另请参阅

isclose，all，any，equal

注释

如果以下方程逐元素为 True，则 allclose 返回 True。

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

上述公式在a和b中不对称，因此allclose(a, b)在一些罕见情况下可能与allclose(b, a)不同。

对a和b的比较使用标准广播，这意味着allclose(a, b)为 True 时，a和b不需要具有相同的形状。对于equal也是如此，但对于array_equal则不是。

allclose对非数值数据类型未定义。对于此目的，bool被视为数值数据类型。

示例

>>> np.allclose([1e10,1e-7], [1.00001e10,1e-8])
False
>>> np.allclose([1e10,1e-8], [1.00001e10,1e-9])
True
>>> np.allclose([1e10,1e-8], [1.0001e10,1e-9])
False
>>> np.allclose([1.0, np.nan], [1.0, np.nan])
False
>>> np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
True 

numpy.isclose

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

numpy.isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)

返回一个布尔数组，其中两个数组在容差范围内的逐元素相等。

容差值为正值，通常非常小。 相对差异（rtol * abs(b））和绝对差异atol相加以与a和b之间的绝对差异进行比较。

警告

默认的atol不适用于比一小得多的数字进行比较（请参阅备注）。

参数：

a，b类数组

要比较的输入数组。

rtol浮点

相对容差参数（请参阅备注）。

atol浮点

绝对容差参数（请参阅备注）。

equal_nan布尔值

是否将 NaN 视为相等。 如果为 True，则a中的 NaN 将被视为输出数组中b中的 NaN。

返回：

y 类数组

返回一个布尔值数组，其中a和b在给定的容差范围内相等。 如果a和b都是标量，则返回单个布尔值。

另请参阅

allclose

math.isclose

备注

1.7.0 版中的新功能。

对于有限值，isclose使用以下方程来测试两个浮点值是否等价。

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

与内置math.isclose不同，上述方程在a和b上并不对称 - 它假设b是参考值 - 因此isclose(a, b)可能与isclose(b, a)不同。

isclose非数字数据类型不适用。 对于此目的，bool被视为数值数据类型。

示例

>>> np.isclose([1e10,1e-7], [1.00001e10,1e-8])
array([ True, False])
>>> np.isclose([1e10,1e-8], [1.00001e10,1e-9])
array([ True, True])
>>> np.isclose([1e10,1e-8], [1.0001e10,1e-9])
array([False,  True])
>>> np.isclose([1.0, np.nan], [1.0, np.nan])
array([ True, False])
>>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
array([ True, True])
>>> np.isclose([1e-8, 1e-7], [0.0, 0.0])
array([ True, False])
>>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0)
array([False, False])
>>> np.isclose([1e-10, 1e-10], [1e-20, 0.0])
array([ True,  True])
>>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0)
array([False,  True]) 

numpy.array_equal

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

numpy.array_equal(a1, a2, equal_nan=False)

如果两个数组形状和元素相同，则返回 True，否则返回 False。

参数：

a1, a2类数组

输入数组。

equal_nan布尔类型

是否将 NaN 视为相等。如果 a1 和 a2 的 dtype 是复数，则会将值视为相等，只要给定值的实部或虚部是nan。

在版本 1.19.0 中新增。

返回：

b布尔类型

如果数组相等，则返回 True。

另请参阅

allclose

如果两个数组在公差范围内逐元素相等，则返回 True。

array_equiv

如果输入数组形状一致且所有元素相等，则返回 True。

示例

>>> np.array_equal([1, 2], [1, 2])
True
>>> np.array_equal(np.array([1, 2]), np.array([1, 2]))
True
>>> np.array_equal([1, 2], [1, 2, 3])
False
>>> np.array_equal([1, 2], [1, 4])
False
>>> a = np.array([1, np.nan])
>>> np.array_equal(a, a)
False
>>> np.array_equal(a, a, equal_nan=True)
True 

当equal_nan为 True 时，带有 nan 分量的复数值，若实部或虚部是 nan，则被视为相等。

>>> a = np.array([1 + 1j])
>>> b = a.copy()
>>> a.real = np.nan
>>> b.imag = np.nan
>>> np.array_equal(a, b, equal_nan=True)
True 

numpy.array_equiv

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

numpy.array_equiv(a1, a2)

如果输入数组的形状一致并且所有元素相等，则返回 True。

形状一致意味着它们要么是相同的形状，要么一个输入数组可以通过广播创建与另一个输入数组相同的形状。

参数：

a1, a2 类似数组

输入数组。

返回值：

out 布尔值

如果等效，则为 True，否则为 False。

示例

>>> np.array_equiv([1, 2], [1, 2])
True
>>> np.array_equiv([1, 2], [1, 3])
False 

显示形状等效性：

>>> np.array_equiv([1, 2], [[1, 2], [1, 2]])
True
>>> np.array_equiv([1, 2], [[1, 2, 1, 2], [1, 2, 1, 2]])
False 

>>> np.array_equiv([1, 2], [[1, 2], [1, 3]])
False 

numpy.greater

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

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

返回 (x1 > x2) 的逐元素真值。

参数：

x1, x2数组或者类似数组

输入数组。如果 x1.shape != x2.shape，它们必须能够广播到一个公共形状（成为输出的形状）。

out 数组，None 或者数组元组和 None，可选

一个数组，结果将被存储在其中。如果提供，则其形状必须与输入进行广播。如果未提供或者为 None，则返回一个新分配的数组。一个元组（仅作为关键字参数）的长度必须等于输出的数量。

where 数组或者类似数组，可选

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

**kwargs

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

返回：

out 数组或者标量

输出数组，x1 和 x2 的逐元素比较。通常为 bool 类型，除非传递 dtype=object。如果 x1 和 x2 都是标量，则为标量。

参见

greater_equal, less, less_equal, equal, not_equal

示例

>>> np.greater([4,2],[2,2])
array([ True, False]) 

对于 ndarrays，可以用 > 运算符作为 np.greater 的缩写。

>>> a = np.array([4, 2])
>>> b = np.array([2, 2])
>>> a > b
array([ True, False]) 

numpy.greater_equal

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

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

返回(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 文档。

返回：

outbool 或布尔类型的 ndarray

输出数组，x1和x2的逐元素比较。通常为布尔类型，除非传递了dtype=object。如果x1和x2都是标量，则这是一个标量。

另请参见

greater, less, less_equal, equal, not_equal

示例

>>> np.greater_equal([4, 2, 1], [2, 2, 2])
array([ True, True, False]) 

>=运算符可用作对 ndarrays 上的np.greater_equal的简写。

>>> a = np.array([4, 2, 1])
>>> b = np.array([2, 2, 2])
>>> a >= b
array([ True,  True, False]) 

numpy.less

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

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

返回(x1 < x2)逐元素的真值。

参数：

x1, x2 array_like

输入数组。如果x1.shape != x2.shape，它们必须能够进行广播以获得一个共同的形状（这将成为输出的形状）。

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

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

where array_like，可选

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

**kwargs

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

返回：

out ndarray 或标量

输出数组，对x1和x2的逐元素比较。通常为 bool 类型，除非传递了dtype=object。如果x1和x2都是标量，则这是一个标量。

另请参阅

greater, less_equal, greater_equal, equal, not_equal

示例

>>> np.less([1, 2], [2, 2])
array([ True, False]) 

<操作符可用作 ndarrays 上np.less的简写。

>>> a = np.array([1, 2])
>>> b = np.array([2, 2])
>>> a < b
array([ True, False]) 

numpy.less_equal

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

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

逐元素返回(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 文档。

返回:

outndarray 或者标量

输出数组，x1和x2的逐元素比较。通常为布尔类型，除非传递了dtype=object。如果x1和x2都是标量，则这是一个标量。

参见

greater、less、greater_equal、equal、not_equal

示例

>>> np.less_equal([4, 2, 1], [2, 2, 2])
array([False,  True,  True]) 

<=运算符可以作为 ndarrays 上np.less_equal的简写使用。

>>> a = np.array([4, 2, 1])
>>> b = np.array([2, 2, 2])
>>> a <= b
array([False,  True,  True]) 

numpy.equal

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

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

返回（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 文档。

返回:

outndarray 或标量

输出数组，x1和x2的逐元素比较。通常是 bool 类型，除非传递了dtype=object。如果x1和x2都是标量，则这是一个标量。

另请参阅

not_equal，greater_equal，less_equal，greater，less

示例

>>> np.equal([0, 1, 3], np.arange(3))
array([ True,  True, False]) 

所比较的是值，而不是类型。因此，int（1）和长度为一的数组可以评估为 True：

>>> np.equal(1, np.ones(1))
array([ True]) 

==操作符可用作 ndarray 上的np.equal的简写。

>>> a = np.array([2, 4, 6])
>>> b = np.array([2, 4, 2])
>>> a == b
array([ True,  True, False]) 

numpy.not_equal

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

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

逐元素返回(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 文档。

返回：

outndarray 或标量

输出数组，x1和x2的逐元素比较。通常为 bool 类型，除非传递了dtype=object。如果x1和x2都是标量，则这是一个标量。

参见

equal, greater, greater_equal, less, less_equal

示例

>>> np.not_equal([1.,2.], [1., 3.])
array([False,  True])
>>> np.not_equal([1, 2], [[1, 3],[1, 4]])
array([[False,  True],
 [False,  True]]) 

在 ndarray 上，!=运算符可用作np.not_equal的简写。

>>> a = np.array([1., 2.])
>>> b = np.array([1., 3.])
>>> a != b
array([False,  True]) 

屏蔽数组操作

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

常数

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, ...])	将缓冲区解释为一维数组。
ma.fromfunction(function, shape, **dtype)	通过在每个坐标上执行函数来构造数组。
ma.MaskedArray.copy([order])	返回数组的副本。
ma.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])	返回给定形状和类型的新数组，其中所有元素都填充为零。
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)	返回掩码数组的掩码，或者没有掩码。
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.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 或无穷大）的数组。
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)	压缩包含掩盖值的 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])	返回 self 的副本，将掩盖值填充为给定值。

> 到另一个对象

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 的所有元素都相等，使用 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 返回掩码数组。

常量

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

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

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)	返回掩码数组的掩码，或者没有掩码。
ma.getmaskarray(arr)	返回掩码数组的掩码，或者全部为假的布尔数组。
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。
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 的 1D 版本，作为视图。
ma.reshape(a, new_shape[, order])	返回一个包含相同数据但具有新形状的数组。
ma.resize(x, new_shape)	返回具有指定大小和形状的新掩码数组。
ma.MaskedArray.flatten([order])	返回将数组展平为一维的副本。
ma.MaskedArray.ravel([order])	返回 self 的 1D 版本，作为视图。
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])	返回一个自身的一维版本，作为视图。
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.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()	在可能的情况下将掩码减少到 nomask。
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)	从给定的 dtype 构造 dtype 描述列表。

访问掩码

ma.getmask(a)	返回掩码数组的掩码，或 nomask。
ma.getmaskarray(arr)	返回掩码数组的掩码，或全为假的完整布尔数组。
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])	对数组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()	返回所有非掩码数据作为 1-D 数组。
ma.MaskedArray.filled([fill_value])	返回一个将掩码值替换为给定值的 self 的副本。

> 到另一个对象

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)	返回对象的 dtype 可表示的最小值。
ma.minimum_fill_value(obj)	返回对象的 dtype 可表示的最大值。
ma.set_fill_value(a, fill_value)	如果 a 是一个掩码数组，则设置 a 的填充值。
ma.MaskedArray.get_fill_value()	掩码数组的填充值是一个标量。
ma.MaskedArray.set_fill_value([value])
ma.MaskedArray.fill_value	掩码数组的填充值是一个标量。

> 转换为 masked array。

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 或无穷大)的部分进行掩码。
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)	抑制包含掩码值的 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])	返回 self 的副本，其中掩码值填充为给定值。

> 转换到另一个对象

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, ...])	返回 Pearson 积矩相关系数。
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)	返回具有转置轴的数组视图。

Polynomial fit

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

Clipping and rounding

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

Set operations

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 的所有条目相等，则返回 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.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])	返回舍入到'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)	两个数组的并集。

Miscellanea

ma.allequal(a, b[, fill_value])	如果 a 和 b 的所有条目相等，则返回 True，使用 fill_value 作为真值，其中 a 或 b 或两者都被屏蔽。
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])	根据 condition 返回一个带有来自x或y的元素的掩码数组。

numpy.ma.MaskType

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

numpy.ma.MaskType

别名为bool_

numpy.ma.masked_array

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

numpy.ma.masked_array

别名：MaskedArray

numpy.ma.array

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

ma.array(data, dtype=None, copy=False, order=None, mask=False, fill_value=None, keep_mask=True, hard_mask=False, shrink=True, subok=True, ndmin=0)

带有可能被屏蔽的值的数组类。

True 的屏蔽值排除了任何计算中对应的元素。

构造方式：

x = MaskedArray(data, mask=nomask, dtype=None, copy=False, subok=True,
                ndmin=0, fill_value=None, keep_mask=True, hard_mask=None,
                shrink=True, order=None) 

参数：

data类数组

输入数据。

mask序列，可选

掩码。必须可以转换为与data形状相同的布尔值数组。True 表示屏蔽（即无效）数据。

dtypedtype，可选

输出的数据类型。如果dtype为 None，则使用数据参数（data.dtype）的类型。如果dtype不为 None 并且与data.dtype不同，则执行复制操作。

copybool，可选

是否复制输入数据（True），还是使用引用。默认为 False。

subokbool，可选

是否在可能的情况下返回MaskedArray的子类（True），或者返回普通的MaskedArray。默认为 True。

ndminint，可选

最小维数。默认为 0。

fill_value标量，可选

在必要时用于填充屏蔽值的值。如果为 None，则使用基于数据类型的默认值。

keep_maskbool，可选

是否将mask与输入数据的掩码合并（True），或仅对输出使用mask（False）。默认为 True。

hard_maskbool，可选

是否使用硬掩码。使用硬掩码时，屏蔽的值无法取消屏蔽。默认为 False。

shrinkbool，可选

是否强制压缩空屏蔽。默认为 True。

order，可选

指定数组的顺序。如果顺序为'c'，则数组将按行优先顺序存储（即最后一个维度变化最快）。如果顺序为'F'，则返回的数组将按列优先顺序存储（即第一个维度变化最快）。如果顺序为'A'（默认值），则返回的数组可以按任何顺序存储（C-、Fortran-连续，甚至是不连续的），除非需要复制，在这种情况下它将是 C-连续的。

示例

mask可以使用与data形状相同的布尔值数组进行初始化。

>>> data = np.arange(6).reshape((2, 3))
>>> np.ma.MaskedArray(data, mask=[[False, True, False],
...                               [False, False, True]])
masked_array(
 data=[[0, --, 2],
 [3, 4, --]],
 mask=[[False,  True, False],
 [False, False,  True]],
 fill_value=999999) 

或者，可以通过传入标量布尔值将mask初始化为与data形状相同的同质布尔数组：

>>> np.ma.MaskedArray(data, mask=False)
masked_array(
 data=[[0, 1, 2],
 [3, 4, 5]],
 mask=[[False, False, False],
 [False, False, False]],
 fill_value=999999) 

>>> np.ma.MaskedArray(data, mask=True)
masked_array(
 data=[[--, --, --],
 [--, --, --]],
 mask=[[ True,  True,  True],
 [ True,  True,  True]],
 fill_value=999999,
 dtype=int64) 

注意

使用标量布尔值初始化mask的推荐做法是使用True/False而不是np.True_/np.False_。原因是nomask在内部表示为np.False_。

>>> np.False_ is np.ma.nomask
True 

numpy.ma.copy

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

ma.copy(self, *args, **params) a.copy(order='C') = <numpy.ma.core._frommethod object>

返回数组的副本。

参数：

order, 可选

控制副本的内存布局。‘C’代表 C 顺序，‘F’代表 F 顺序，‘A’代表如果a是 Fortran 连贯的则使用‘F’，否则使用‘C’。‘K’代表尽可能匹配a的布局。（注意，此函数和numpy.copy非常相似，但它们对于 order=参数的默认值有所不同，而且此函数总是通过子类。）

另请参阅

numpy.copy

具有不同默认行为的类似函数

numpy.copyto

注意事项

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

示例

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

>>> y = x.copy() 

>>> x.fill(0) 

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

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

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

numpy.ma.frombuffer

numpy.org/doc/1.26/reference/generated/numpy.ma.frombuffer.html

ma.frombuffer(buffer, dtype=float, count=-1, offset=0, *, like=None) = <numpy.ma.core._convert2ma object>

将缓冲区解释为 1 维数组。

参数：

buffer类似缓冲区

一个暴露缓冲区接口的对象。

dtype数据类型，可选

返回数组的数据类型；默认值：浮点数。

count整数，可选

要读取的项目数。-1表示缓冲区中的所有数据。

offset整数，可选

从此偏移量（以字节为单位）开始读取缓冲区；默认值：0。

like类似数组，可选

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

版本1.20.0中新增。

返回：

输出：MaskedArray

另请参见

ndarray.tobytes

该操作的逆操作，从数组中的原始数据字节构造 Python 字节。

注意

如果缓冲区中的数据不是机器字节顺序的，应将其作为数据类型的一部分指定，例如：

>>> dt = np.dtype(int)
>>> dt = dt.newbyteorder('>')
>>> np.frombuffer(buf, dtype=dt) 

结果数组的数据不会发生字节交换，但将被正确解释。

此函数创建原始对象的视图。通常情况下应该是安全的，但如果原始对象是可变的或不受信任的，则复制结果可能是有意义的。

示例

>>> s = b'hello world'
>>> np.frombuffer(s, dtype='S1', count=5, offset=6)
array([b'w', b'o', b'r', b'l', b'd'], dtype='|S1') 

>>> np.frombuffer(b'\x01\x02', dtype=np.uint8)
array([1, 2], dtype=uint8)
>>> np.frombuffer(b'\x01\x02\x03\x04\x05', dtype=np.uint8, count=3)
array([1, 2, 3], dtype=uint8) 

numpy.ma.fromfunction

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

ma.fromfunction(function, shape, **dtype) = <numpy.ma.core._convert2ma object>

通过对每个坐标执行函数来构建数组。

结果数组因此在坐标(x, y, z)处有值fn(x, y, z)。

参数：

function可调用对象

函数使用 N 个参数进行调用，其中 N 是shape的秩。每个参数都代表数组沿特定轴变化的坐标。例如，如果shape为(2, 2)，那么参数将是array([[0, 0], [1, 1]])和array([[0, 1], [0, 1]])

shape(N,) 整数元组

输出数组的形状，也确定传递给function的坐标数组的形状。

dtype数据类型，可选

传递给function的坐标数组的数据类型。默认情况下，dtype为 float。

likearray_like，可选

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

版本 1.20.0 中的新功能。

返回：

fromfunction：MaskedArray

调用function的结果直接返回。因此，fromfunction的形状完全由function确定。如果function返回标量值，则fromfunction的形状与shape参数不匹配。

参见

indices，meshgrid

注意事项

除dtype和like之外的关键字被传递给function。

示例

>>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float)
array([[0., 0.],
 [1., 1.]]) 

>>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float)
array([[0., 1.],
 [0., 1.]]) 

>>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
array([[ True, False, False],
 [False,  True, False],
 [False, False,  True]]) 

>>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)
array([[0, 1, 2],
 [1, 2, 3],
 [2, 3, 4]]) 

numpy.ma.MaskedArray.copy

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

方法

ma.MaskedArray.copy(order='C')

返回数组的副本。

参数：

order, 可选

控制副本的内存布局。'C'表示 C 排序，'F'表示 F 排序，'A'表示如果 a 是 Fortran 连续的，则为 'F'，否则为 'C'。 'K'表示尽可能按照 a 的布局进行匹配。（请注意，此函数和numpy.copy非常相似，但其 order=参数具有不同的默认值，此函数始终传递子类。）

也可以参考

numpy.copy

具有不同默认行为的类似函数

numpy.copyto

注意事项

该函数是创建数组副本的首选方法。函数numpy.copy类似，但默认使用顺序 'K'，默认情况下不会传递子类。

示例

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

>>> y = x.copy() 

>>> x.fill(0) 

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

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

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

numpy.ma.diagflat

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

ma.diagflat = <numpy.ma.extras._fromnxfunction_single object>

diagflat

使用展平的输入创建一个二维数组作为对角线。

参数：

varray_like

输入数据，它被展平并设置为输出的第k个对角线。

kint，可选

对角线设置；0，即默认值，对应于“主”对角线，正（负）k表示在主对角线上方（下方）的对角线数量。

返回：

outndarray

2-D 输出数组。

另请参阅

diag

1-D 和 2-D 数组的类似 MATLAB 工作。

diagonal

返回指定的对角线。

trace

沿对角线求和。

注：

如果有的话，该函数将应用于 _data 和 _mask。

示例

>>> np.diagflat([[1,2], [3,4]])
array([[1, 0, 0, 0],
 [0, 2, 0, 0],
 [0, 0, 3, 0],
 [0, 0, 0, 4]]) 

>>> np.diagflat([1,2], 1)
array([[0, 1, 0],
 [0, 0, 2],
 [0, 0, 0]]) 

numpy.ma.empty

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

ma.empty(shape, dtype=float, order='C', *, like=None) = <numpy.ma.core._convert2ma object>

返回一个给定形状和类型的新数组，而不初始化条目。

参数：

shape整数或整数元组

空数组的形状，例如(2, 3)或2。

dtype数据类型，可选

期望的输出数据类型，例如numpy.int8。默认为numpy.float64。

order，可选，默认为‘C’

在内存中存储多维数据的顺序，行优先（C 风格）或列优先（Fortran 风格）。

like类似数组，可选

引用对象，允许创建非 NumPy 数组的数组。如果作为 like 传入的类似数组支持 __array_function__ 协议，则结果将由它定义。在这种情况下，它确保创建与通过该参数传入的兼容的数组对象。

版本 1.20.0 中的新功能。

返回：

out掩码数组

未初始化（任意）数据的具有给定形状、dtype 和 order 的数组。对象数组将初始化为 None。

参见

empty_like

返回与输入形状和类型相同的空数组。

ones

返回一个将值设为一的新数组。

zeros

返回一个将值设为零的新数组。

full

返回一个给定形状且填充有数值的新数组。

注意事项

empty，与zeros 不同，不会将数组值设为零，因此可能稍微更快。另一方面，需要用户手动设置数组中的所有值，并且应谨慎使用。

示例

>>> np.empty([2, 2])
array([[ -9.74499359e+001,   6.69583040e-309],
 [  2.13182611e-314,   3.06959433e-309]])         #uninitialized 

>>> np.empty([2, 2], dtype=int)
array([[-1073741821, -1067949133],
 [  496041986,    19249760]])                     #uninitialized 

numpy.ma.empty_like

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

ma.empty_like(prototype, dtype=None, order='K', subok=True, shape=None) = <numpy.ma.core._convert2ma object>

返回一个具有与给定数组相同形状和类型的新数组。

参数：

prototype类数组

prototype 的形状和数据类型定义了返回数组的相同属性。

dtype数据类型，可选

覆盖结果的数据类型。

新版本 1.6.0。

order，可选

覆盖结果的内存布局。‘C’ 表示‘C’顺序，‘F’ 表示‘F’顺序，‘A’ 表示如果 prototype 是 Fortran 连续的，则意味着是‘F’，否则是‘C’。‘K’ 表示尽量按照 prototype 的布局匹配。

新版本 1.6.0 中新增内容。

subok布尔值，可选。

如果为 True，则新创建的数组将使用 prototype 的子类型，否则它将是基类数组。默认为 True。

shapeint 或者 int 序列，可选。

覆盖结果的形状。如果 order=’K’ 并且维度数量没有改变，则尝试保持顺序；否则，隐含 order=’C’。

新版本 1.17.0。

返回：

outMaskedArray

具有相同形状和类型的 prototype 的未初始化（任意）数据数组。

参见

ones_like

返回一个具有输入形状和类型的全为 1 的数组。

zeros_like

返回一个具有输入形状和类型的全为 0 的数组。

full_like

返回一个具有输入形状的新数组，并填充值。

empty

返回一个新的未初始化数组。

注意事项

此函数 不 初始化返回的数组；要做到这一点，请使用zeros_like 或者 ones_like。它可能比设置数组值的函数稍微快一点。

示例

>>> a = ([1,2,3], [4,5,6])                         # a is array-like
>>> np.empty_like(a)
array([[-1073741821, -1073741821,           3],    # uninitialized
 [          0,           0, -1073741821]])
>>> a = np.array([[1., 2., 3.],[4.,5.,6.]])
>>> np.empty_like(a)
array([[ -2.00000715e+000,   1.48219694e-323,  -2.00000572e+000], # uninitialized
 [  4.38791518e-305,  -2.00000715e+000,   4.17269252e-309]]) 

numpy.ma.masked_all

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

ma.masked_all(shape, dtype=<class 'float'>)

所有元素都被屏蔽的空的屏蔽数组。

返回一个给定形状和 dtype 的空屏蔽数组，其中所有数据都被屏蔽。

参数：

shapeint 或 int 元组

所需的 MaskedArray 的形状，例如(2, 3)或2。

dtypedtype，可选

输出的数据类型。

返回值：

aMaskedArray

所有数据都被屏蔽的屏蔽数组。

另请参见：

masked_all_like

基于现有数组模拟的空的屏蔽数组。

示例：

>>> import numpy.ma as ma
>>> ma.masked_all((3, 3))
masked_array(
 data=[[--, --, --],
 [--, --, --],
 [--, --, --]],
 mask=[[ True,  True,  True],
 [ True,  True,  True],
 [ True,  True,  True]],
 fill_value=1e+20,
 dtype=float64) 

dtype参数定义底层数据类型。

>>> a = ma.masked_all((3, 3))
>>> a.dtype
dtype('float64')
>>> a = ma.masked_all((3, 3), dtype=np.int32)
>>> a.dtype
dtype('int32') 

numpy.ma.masked_all_like

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

ma.masked_all_like(arr)

具有现有数组属性的空掩码数组。

返回一个与数组arr形状和 dtype 相同的空掩码数组，其中所有数据都被掩码。

参数：

arrndarray

描述所需 MaskedArray 的形状和 dtype 的数组。

返回：

a掩码数组

所有数据都被掩码的掩码数组。

引发：

属性错误

如果arr没有形状属性（即不是 ndarray）

请参阅

masked_all

所有元素都被掩码的空掩码数组。

示例

>>> import numpy.ma as ma
>>> arr = np.zeros((2, 3), dtype=np.float32)
>>> arr
array([[0., 0., 0.],
 [0., 0., 0.]], dtype=float32)
>>> ma.masked_all_like(arr)
masked_array(
 data=[[--, --, --],
 [--, --, --]],
 mask=[[ True,  True,  True],
 [ True,  True,  True]],
 fill_value=1e+20,
 dtype=float32) 

掩码数组的 dtype 与arr的 dtype 匹配。

>>> arr.dtype
dtype('float32')
>>> ma.masked_all_like(arr).dtype
dtype('float32') 

numpy.ma.ones

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

ma.ones(shape, dtype=None, order='C') = <numpy.ma.core._convert2ma object>

返回一个给定形状和类型的全为 1 的新数组。

参数：

shape 整数或整数序列

新数组的形状，例如，(2, 3) 或 2。

dtype 数据类型，可选的

数组的所需数据类型，例如，numpy.int8。默认为 numpy.float64。

order {'C'，'F'}，可选的，默认值：C

是否以行主要顺序（C 风格）或列主要顺序（Fortran 风格）在内存中存储多维数据。

like 类似数组，可选的

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

新版本 1.20.0 中新增。

返回：

out 遮盖数组

形状、dtype 和顺序给定的全为 1 的数组。

参见

ones_like

返回一个与输入形状和类型相同的全为 1 的数组。

empty

返回一个新的未初始化数组。

zeros

返回将值设置为零的新数组。

full

返回一个给定形状并填充值的新数组。

示例

>>> np.ones(5)
array([1., 1., 1., 1., 1.]) 

>>> np.ones((5,), dtype=int)
array([1, 1, 1, 1, 1]) 

>>> np.ones((2, 1))
array([[1.],
 [1.]]) 

>>> s = (2,2)
>>> np.ones(s)
array([[1.,  1.],
 [1.,  1.]]) 

numpy.ma.ones_like

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

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

返回一个具有与给定数组相同形状和类型的数组。

参数：

a类似数组

a的形状和数据类型定义了返回的数组的相同属性。

dtype数据类型，可选

覆盖结果的数据类型。

新版本 1.6.0 中。

order，可选

覆盖结果的内存布局。‘C’表示 C 顺序，‘F’表示 F 顺序，‘A’表示如果a是 Fortran 连续的，则为‘F’，否则为‘C’。‘K’表示尽可能与a的布局相匹配。

新版本 1.6.0 中。

subokbool，可选。

如果为 True，则新创建的数组将使用a的子类类型，否则将是基类数组。默认为 True。

shapeint 或 int 序列，可选。

覆盖结果的形状。如果 order=‘K’且维度数不变，则尝试保持顺序，否则，暗示 order=‘C’。

新版本 1.17.0 中。

返回：

outMaskedArray

一个与a具有相同形状和类型的数组。

另见

empty_like

返回一个形状和类型与输入相同的空数组。

zeros_like

返回一个形状和类型与输入相同的零数组。

full_like

返回一个形状与输入相同的新数组，并用值填充。

ones

返回将值设置为一的新数组。

示例

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

>>> y = np.arange(3, dtype=float)
>>> y
array([0., 1., 2.])
>>> np.ones_like(y)
array([1.,  1.,  1.]) 

numpy.ma.zeros

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

ma.zeros(shape, dtype=float, order='C', *, like=None) = <numpy.ma.core._convert2ma object>

返回一个给定形状和类型的新数组，用零填充。

参数：

shape整数或整数元组

新数组的形状，例如，(2, 3)或2。

dtype数据类型，可选

数组的期望数据类型，例如，numpy.int8。默认值为numpy.float64。

order，可选，默认：‘C’

决定是否将多维数据存储在内存中的行主序（C 风格）或列主序（Fortran 风格）。

like类似数组，可选

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

自版本 1.20.0 起新增。

返回：

out掩码数组

具有给定形状、数据类型和顺序的零数组。

参见

zeros_like

返回一个具有输入形状和类型的零数组。

empty

返回一个新的未初始化数组。

ones

返回一个将值设置为 1 的新数组。

full

返回一个给定形状的新数组，填充有值。

示例

>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.]) 

>>> np.zeros((5,), dtype=int)
array([0, 0, 0, 0, 0]) 

>>> np.zeros((2, 1))
array([[ 0.],
 [ 0.]]) 

>>> s = (2,2)
>>> np.zeros(s)
array([[ 0.,  0.],
 [ 0.,  0.]]) 

>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
array([(0, 0), (0, 0)],
 dtype=[('x', '<i4'), ('y', '<i4')]) 

numpy.ma.zeros_like

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

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

返回一个与给定数组相同形状和类型的零数组。

参数：

a类似数组

a的形状和数据类型决定了返回数组的这些属性。

dtype数据类型，可选

覆盖结果的数据类型。

1.6.0 版本中新增。

order，可选

覆盖结果的存储布局。‘C’表示 C 顺序，‘F’表示 F 顺序，‘A’表示如果a是 Fortran 连续的则为‘F’，否则为‘C’。‘K’表示尽可能与a的布局匹配。

1.6.0 版本中新增。

subok布尔值，可选。

如果为 True，则新创建的数组将使用a的子类类型，否则将是基类数组。默认为 True。

shape整数或整数序列，可选。

覆盖结果的形状。如果 order=‘K’且维数不变，则尝试保持布局，否则，暗示 order=‘C’。

1.17.0 版本中新增。

返回：

out蒙版数组

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

另请参见

empty_like

返回一个形状和类型与输入相同的空数组。

ones_like

返回一个形状和类型与输入相同的全为 1 的数组。

full_like

返回一个形状与输入相同且填充了值的新数组。

zeros

返回一个将值设置为零的新数组。

示例

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

>>> y = np.arange(3, dtype=float)
>>> y
array([0., 1., 2.])
>>> np.zeros_like(y)
array([0.,  0.,  0.]) 

numpy.ma.all

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

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

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

当给定轴上的所有值都被屏蔽时，输出数组会被屏蔽：如果输出本来应该是标量并且所有值都被屏蔽，则输出为masked。

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

另请参见

numpy.ndarray.all

ndarrays 的相应函数

numpy.all

对应的函数

示例

>>> np.ma.array([1,2,3]).all()
True
>>> a = np.ma.array([1,2,3], mask=True)
>>> (a.all() is np.ma.masked)
True 

numpy.ma.any

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

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

如果* a * 的任何元素求值为 True，则返回 True。

在计算过程中，掩码值被视为 False。

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

参见

numpy.ndarray.any

适用于 ndarrays 的对应函数

numpy.any

等效函数

numpy.ma.count

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

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

对给定轴沿数组计数非屏蔽元素。

参数：

axisNone or int or tuple of ints, optional

进行计数的轴或轴。 默认值 None，在输入数组的所有维度上执行计数。轴可以为负，这样它将从最后一个轴数到第一个轴数计数。

在 1.10.0 版中新增。

如果这是一个整数的元组，计数将在多个轴上执行，而不是在单个轴或所有轴上执行。

keepdimsbool, optional

如果这个参数设置为 True，则被减少的轴将作为尺寸为 1 的维度保留在结果中。 使用这个选项，结果将正确地广播到数组。

返回值：

resultndarray or scalar

返回一个与输入数组形状相同的数组，指定的轴被移除。 如果数组是 0 维数组，或者axis为 None，则返回一个标量。

另请参见

ma.count_masked

计算数组或沿给定轴掩蔽的元素数。

示例

>>> import numpy.ma as ma
>>> a = ma.arange(6).reshape((2, 3))
>>> a[1, :] = ma.masked
>>> a
masked_array(
 data=[[0, 1, 2],
 [--, --, --]],
 mask=[[False, False, False],
 [ True,  True,  True]],
 fill_value=999999)
>>> a.count()
3 

当指定轴关键字时，将返回一个大小合适的数组。

>>> a.count(axis=0)
array([1, 1, 1])
>>> a.count(axis=1)
array([3, 0]) 

numpy.ma.count_masked

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

ma.count_masked(arr, axis=None)

沿着给定的轴计算被屏蔽元素的数量。

参数：

arr array_like

一个包含（可能）屏蔽元素的数组。

axis int, optional

用于计算的轴。如果为 None（默认值），则使用数组的展平版本。

返回值：

count int, ndarray

屏蔽元素的总数（axis=None）或沿着给定轴的每个切片的屏蔽元素的数量。

参见

MaskedArray.count

计算非屏蔽元素的数量。

示例

>>> import numpy.ma as ma
>>> a = np.arange(9).reshape((3,3))
>>> a = ma.array(a)
>>> a[1, 0] = ma.masked
>>> a[1, 2] = ma.masked
>>> a[2, 1] = ma.masked
>>> a
masked_array(
 data=[[0, 1, 2],
 [--, 4, --],
 [6, --, 8]],
 mask=[[False, False, False],
 [ True, False,  True],
 [False,  True, False]],
 fill_value=999999)
>>> ma.count_masked(a)
3 

当使用 axis 关键字时，将返回一个数组。

>>> ma.count_masked(a, axis=0)
array([1, 1, 1])
>>> ma.count_masked(a, axis=1)
array([0, 2, 1]) 

numpy.ma.getmask

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

ma.getmask(a)

返回一个掩码数组的掩码，或者 nomask。

如果 a 是一个 MaskedArray 并且掩码不是 nomask，则返回 a 的掩码作为一个数组，否则返回 nomask。为了保证一个与 a 形状相同的布尔型数组，使用 getmaskarray。

参数：

a 类似于数组

输入所需掩码的 MaskedArray。

另请参阅

getdata

返回掩码数组的数据，类型为数组。

getmaskarray

返回一个掩码数组的掩码，或者全为 False 的数组。

示例

>>> import numpy.ma as ma
>>> a = ma.masked_equal([[1,2],[3,4]], 2)
>>> a
masked_array(
 data=[[1, --],
 [3, 4]],
 mask=[[False,  True],
 [False, False]],
 fill_value=2)
>>> ma.getmask(a)
array([[False,  True],
 [False, False]]) 

等效地使用 MaskedArray 的 mask 属性。

>>> a.mask
array([[False,  True],
 [False, False]]) 

当 mask == nomask 时的结果

>>> b = ma.masked_array([[1,2],[3,4]])
>>> b
masked_array(
 data=[[1, 2],
 [3, 4]],
 mask=False,
 fill_value=999999)
>>> ma.nomask
False
>>> ma.getmask(b) == ma.nomask
True
>>> b.mask == ma.nomask
True 

numpy.ma.getmaskarray

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

ma.getmaskarray(arr)

返回掩码数组的掩码，或全布尔数组。

如果 arr 是 MaskedArray 并且掩码不是 nomask，则返回掩码数组的掩码作为 ndarray，否则返回形状与 arr 相同的全布尔数组。

参数：

arrarray_like

输入 MaskedArray 需要掩码的数组。

另请参阅

getmask

返回掩码数组的掩码，或者无掩码。

getdata

返回掩码数组的数据作为 ndarray。

示例

>>> import numpy.ma as ma
>>> a = ma.masked_equal([[1,2],[3,4]], 2)
>>> a
masked_array(
 data=[[1, --],
 [3, 4]],
 mask=[[False,  True],
 [False, False]],
 fill_value=2)
>>> ma.getmaskarray(a)
array([[False,  True],
 [False, False]]) 

当掩码 == nomask 时的结果

>>> b = ma.masked_array([[1,2],[3,4]])
>>> b
masked_array(
 data=[[1, 2],
 [3, 4]],
 mask=False,
 fill_value=999999)
>>> ma.getmaskarray(b)
array([[False, False],
 [False, False]]) 

numpy.ma.getdata

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

ma.getdata(a, subok=True)

以 ndarray 形式返回掩码数组的数据。

如果a是MaskedArray，则以 ndarray 形式返回a的数据，否则如果a不是，则作为 ndarray 或其子类（取决于subok）返回a。

参数：

aarray_like

输入MaskedArray，或者 ndarray 或其子类。

subokbool

是否强制输出为纯 ndarray（False），或者如果适用的话返回 ndarray 的子类（True，默认值）。

另请参见

getmask

返回掩码数组的掩码，或者没有掩码。

getmaskarray

返回掩码数组的掩码，或者完全由 False 组成的数组。

示例

>>> import numpy.ma as ma
>>> a = ma.masked_equal([[1,2],[3,4]], 2)
>>> a
masked_array(
 data=[[1, --],
 [3, 4]],
 mask=[[False,  True],
 [False, False]],
 fill_value=2)
>>> ma.getdata(a)
array([[1, 2],
 [3, 4]]) 

可以等效地使用MaskedArray data属性。

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

numpy.ma.nonzero

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

ma.nonzero(self) = <numpy.ma.core._frommethod object>

返回未掩盖且不为零的元素的索引。

返回一个包含每个维度中非零元素索引的数组元组，对应的非零值可使用以下方式获取：

a[a.nonzero()] 

若要按元素分组索引，而不是按维度分组，使用：

np.transpose(a.nonzero()) 

其结果始终是一个 2 维数组，每个非零元素对应一行。

参数：

无

返回：

数组元组array tuple

非零元素的索引。

另见

numpy.nonzero

操作在 ndarrays 上的函数。

flatnonzero

返回扁平化版本的输入数组中非零元素的索引。

numpy.ndarray.nonzero

等效的 ndarray 方法。

count_nonzero

计算输入数组中非零元素的数量。

例子

>>> import numpy.ma as ma
>>> x = ma.array(np.eye(3))
>>> x
masked_array(
 data=[[1., 0., 0.],
 [0., 1., 0.],
 [0., 0., 1.]],
 mask=False,
 fill_value=1e+20)
>>> x.nonzero()
(array([0, 1, 2]), array([0, 1, 2])) 

掩盖的元素将被忽略。

>>> x[1, 1] = ma.masked
>>> x
masked_array(
 data=[[1.0, 0.0, 0.0],
 [0.0, --, 0.0],
 [0.0, 0.0, 1.0]],
 mask=[[False, False, False],
 [False,  True, False],
 [False, False, False]],
 fill_value=1e+20)
>>> x.nonzero()
(array([0, 2]), array([0, 2])) 

也可以按元素分组索引。

>>> np.transpose(x.nonzero())
array([[0, 0],
 [2, 2]]) 

nonzero的一个常见用途是查找一个数组的索引，满足某种条件为真。给定一个数组a，条件a > 3 是一个布尔数组，由于 False 被解释为 0，ma.nonzero(a > 3)会产生满足条件为真的a的索引。

>>> a = ma.array([[1,2,3],[4,5,6],[7,8,9]])
>>> a > 3
masked_array(
 data=[[False, False, False],
 [ True,  True,  True],
 [ True,  True,  True]],
 mask=False,
 fill_value=True)
>>> ma.nonzero(a > 3)
(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) 

也可以调用条件数组的nonzero方法。

>>> (a > 3).nonzero()
(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) 

numpy.ma.shape

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

ma.shape(obj)

返回数组的形状。

参数：

a数组样式

输入数组。

返回值：

shape整数元组

形状元组的元素给出了相应数组维度的长度。

另请参见

len

len(a) 等效于对于 N>=1 的 N-D 数组 np.shape(a)[0]。

ndarray.shape

等效数组方法。

示例

>>> np.shape(np.eye(3))
(3, 3)
>>> np.shape([[1, 3]])
(1, 2)
>>> np.shape([0])
(1,)
>>> np.shape(0)
() 

>>> a = np.array([(1, 2), (3, 4), (5, 6)],
...              dtype=[('x', 'i4'), ('y', 'i4')])
>>> np.shape(a)
(3,)
>>> a.shape
(3,) 

numpy.ma.size

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

ma.size(obj, axis=None)

返回给定轴上的元素数量。

参数：

aarray_like

输入数据。

axis整数，可选

沿着这些元素被计数的轴。默认情况下，给出总元素数量。

返回：

element_count整数

沿指定轴的元素数量。

另请参见

shape

数组的维度

ndarray.shape

数组的维度

ndarray.size

数组中的元素数量

示例

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

numpy.ma.is_masked

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

ma.is_masked(x)

确定输入是否具有屏蔽值。

接受任何对象作为输入，但除非输入是包含屏蔽值的 MaskedArray，否则始终返回 False。

参数：

x：array_like

要检查是否有屏蔽值的数组。

返回：

result：bool

如果x是一个带有屏蔽值的 MaskedArray，则返回 True，否则返回 False。

示例

>>> import numpy.ma as ma
>>> x = ma.masked_equal([0, 1, 0, 2, 3], 0)
>>> x
masked_array(data=[--, 1, --, 2, 3],
 mask=[ True, False,  True, False, False],
 fill_value=0)
>>> ma.is_masked(x)
True
>>> x = ma.masked_equal([0, 1, 0, 2, 3], 42)
>>> x
masked_array(data=[0, 1, 0, 2, 3],
 mask=False,
 fill_value=42)
>>> ma.is_masked(x)
False 

如果x不是 MaskedArray，则始终返回 False。

>>> x = [False, True, False]
>>> ma.is_masked(x)
False
>>> x = 'a string'
>>> ma.is_masked(x)
False 

numpy.ma.is_mask

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

ma.is_mask(m)

如果 m 是有效的标准掩码，则返回 True。

此函数不检查输入的内容，只检查类型是否为 MaskType。特别地，如果掩码具有灵活的 dtype，则此函数返回 False。

参数：

marray_like

要测试的数组。

返回：

resultbool

如果m.dtype.type为 MaskType，则返回 True，否则返回 False。

参见

ma.isMaskedArray

测试输入是否为 MaskedArray 的实例。

示例

>>> import numpy.ma as ma
>>> m = ma.masked_equal([0, 1, 0, 2, 3], 0)
>>> m
masked_array(data=[--, 1, --, 2, 3],
 mask=[ True, False,  True, False, False],
 fill_value=0)
>>> ma.is_mask(m)
False
>>> ma.is_mask(m.mask)
True 

输入必须是 ndarray（或具有类似属性）才能视为有效掩码。

>>> m = [False, True, False]
>>> ma.is_mask(m)
False
>>> m = np.array([False, True, False])
>>> m
array([False,  True, False])
>>> ma.is_mask(m)
True 

具有复杂 dtype 的数组不会返回 True。

>>> dtype = np.dtype({'names':['monty', 'pithon'],
...                   'formats':[bool, bool]})
>>> dtype
dtype([('monty', '|b1'), ('pithon', '|b1')])
>>> m = np.array([(True, False), (False, True), (True, False)],
...              dtype=dtype)
>>> m
array([( True, False), (False,  True), ( True, False)],
 dtype=[('monty', '?'), ('pithon', '?')])
>>> ma.is_mask(m)
False 

numpy.ma.isMaskedArray

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

ma.isMaskedArray(x)

测试输入是否是 MaskedArray 的一个实例。

此函数返回 True 如果 x 是 MaskedArray 的一个实例，否则返回 False。任何对象都被接受作为输入。

参数：

x对象

要测试的对象。

返回：

结果bool

如果 x 是 MaskedArray，则返回 True。

另请参阅

isMA

isMaskedArray 的别名。

isarray

isMaskedArray 的别名。

示例

>>> import numpy.ma as ma
>>> a = np.eye(3, 3)
>>> a
array([[ 1.,  0.,  0.],
 [ 0.,  1.,  0.],
 [ 0.,  0.,  1.]])
>>> m = ma.masked_values(a, 0)
>>> m
masked_array(
 data=[[1.0, --, --],
 [--, 1.0, --],
 [--, --, 1.0]],
 mask=[[False,  True,  True],
 [ True, False,  True],
 [ True,  True, False]],
 fill_value=0.0)
>>> ma.isMaskedArray(a)
False
>>> ma.isMaskedArray(m)
True
>>> ma.isMaskedArray([0, 1, 2])
False 

numpy.ma.isMA

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

ma.isMA(x)

测试输入是否为 MaskedArray 的实例。

如果 x 是 MaskedArray 的实例，则返回 True，否则返回 False。任何对象都可接受为输入。

参数：

xobject

要测试的对象。

返回：

resultbool

如果 x 是 MaskedArray，则返回 True。

另请参阅

isMA

别名为 isMaskedArray。

isarray

别名为 isMaskedArray。

示例

>>> import numpy.ma as ma
>>> a = np.eye(3, 3)
>>> a
array([[ 1.,  0.,  0.],
 [ 0.,  1.,  0.],
 [ 0.,  0.,  1.]])
>>> m = ma.masked_values(a, 0)
>>> m
masked_array(
 data=[[1.0, --, --],
 [--, 1.0, --],
 [--, --, 1.0]],
 mask=[[False,  True,  True],
 [ True, False,  True],
 [ True,  True, False]],
 fill_value=0.0)
>>> ma.isMaskedArray(a)
False
>>> ma.isMaskedArray(m)
True
>>> ma.isMaskedArray([0, 1, 2])
False 

numpy.ma.isarray

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

ma.isarray(x)

测试输入是否为 MaskedArray 的实例。

此函数如果x是 MaskedArray 的实例则返回 True，否则返回 False。任何对象都可以作为输入。

参数：

x对象

要测试的对象。

返回：

result bool

如果x是 MaskedArray，则返回 True。

参见

isMA

isMaskedArray 的别名。

isarray

isMaskedArray 的别名。

示例

>>> import numpy.ma as ma
>>> a = np.eye(3, 3)
>>> a
array([[ 1.,  0.,  0.],
 [ 0.,  1.,  0.],
 [ 0.,  0.,  1.]])
>>> m = ma.masked_values(a, 0)
>>> m
masked_array(
 data=[[1.0, --, --],
 [--, 1.0, --],
 [--, --, 1.0]],
 mask=[[False,  True,  True],
 [ True, False,  True],
 [ True,  True, False]],
 fill_value=0.0)
>>> ma.isMaskedArray(a)
False
>>> ma.isMaskedArray(m)
True
>>> ma.isMaskedArray([0, 1, 2])
False 

numpy.ma.isin

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

ma.isin(element, test_elements, assume_unique=False, invert=False)

只对element进行广播，计算element中是否在test_elements中。

输出始终是与element相同形状的掩码数组。更多详情请参阅numpy.isin。

另请参阅

in1d

该函数的平坦版本。

numpy.isin

ndarrays 的等效函数。

注意事项

于 1.13.0 版本中新增。

numpy.ma.in1d

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

ma.in1d(ar1, ar2, assume_unique=False, invert=False)

测试数组中的每个元素是否也存在于第二个数组中。

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

我们建议在新代码中使用 isin，而不是 in1d。

另请参见

isin

此函数的版本可保留 ar1 的形状。

numpy.in1d

等效的针对多维数组的函数。

注意事项

版本 1.4.0 中的新功能。

numpy.ma.unique

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

ma.unique(ar1, return_index=False, return_inverse=False)

找到数组的唯一元素。

屏蔽值被视为相同元素（屏蔽）。输出数组始终为屏蔽数组。更多细节请参见numpy.unique。

另请参阅

numpy.unique

对于 ndarrays 的等效函数。

示例

>>> import numpy.ma as ma
>>> a = [1, 2, 1000, 2, 3]
>>> mask = [0, 0, 1, 0, 0]
>>> masked_a = ma.masked_array(a, mask)
>>> masked_a
masked_array(data=[1, 2, --, 2, 3],
 mask=[False, False,  True, False, False],
 fill_value=999999)
>>> ma.unique(masked_a)
masked_array(data=[1, 2, 3, --],
 mask=[False, False, False,  True],
 fill_value=999999)
>>> ma.unique(masked_a, return_index=True)
(masked_array(data=[1, 2, 3, --],
 mask=[False, False, False,  True],
 fill_value=999999), array([0, 1, 4, 2]))
>>> ma.unique(masked_a, return_inverse=True)
(masked_array(data=[1, 2, 3, --],
 mask=[False, False, False,  True],
 fill_value=999999), array([0, 1, 3, 1, 2]))
>>> ma.unique(masked_a, return_index=True, return_inverse=True)
(masked_array(data=[1, 2, 3, --],
 mask=[False, False, False,  True],
 fill_value=999999), array([0, 1, 4, 2]), array([0, 1, 3, 1, 2])) 

numpy.ma.MaskedArray.all

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

方法

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

如果所有元素求值为真，则返回 True。

输出数组在给定轴上的所有值都被掩盖的地方被掩盖：如果输出本应为标量且所有值都被掩盖，则输出为掩盖。

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

另请参阅

numpy.ndarray.all

对于 ndarrays 的对应函数

numpy.all

等效函数

示例

>>> np.ma.array([1,2,3]).all()
True
>>> a = np.ma.array([1,2,3], mask=True)
>>> (a.all() is np.ma.masked)
True 

numpy.ma.MaskedArray.any

参考：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.any.html

方法

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

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

在计算过程中，掩码值被视为 False。

请查看完整文档参考numpy.any。

另请参阅

numpy.ndarray.any

ndarrays 的对应函数

numpy.any

等效函数

numpy.ma.MaskedArray.count

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

方法

ma.MaskedArray.count(axis=None, keepdims=<no value>)

沿给定轴计算数组中非屏蔽元素的数量。

参数：

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

在其上执行计数的轴或轴。默认值 None 在输入数组的所有维度上执行计数。axis 可能是负值，此时从最后一个轴开始计数到第一个轴。

1.10.0 版本中的新功能。

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

keepdims 布尔值，可选

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

返回：

result ndarray 或标量

一个与输入数组形状相同的数组，删除了指定的轴。如果数组是 0 维数组，或者 axis 是 None，则返回标量。

另请参阅

ma.count_masked

计算数组中的屏蔽元素或沿着给定轴进行计数。

示例

>>> import numpy.ma as ma
>>> a = ma.arange(6).reshape((2, 3))
>>> a[1, :] = ma.masked
>>> a
masked_array(
 data=[[0, 1, 2],
 [--, --, --]],
 mask=[[False, False, False],
 [ True,  True,  True]],
 fill_value=999999)
>>> a.count()
3 

当指定 axis 关键字时，返回一个大小合适的数组。

>>> a.count(axis=0)
array([1, 1, 1])
>>> a.count(axis=1)
array([3, 0]) 

numpy.ma.MaskedArray.nonzero

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

方法

ma.MaskedArray.nonzero()

返回未遮罩的非零元素的索引。

返回一个数组的数组的元组，每个数组都包含该维度非零元素的索引。相应的非零值可以用以下方法获取：

a[a.nonzero()] 

要按元素而不是维度分组索引，请使用：

np.transpose(a.nonzero()) 

这个结果始终是一个 2D 数组，每个非零元素都有一行。

参数：

None

返回：

tuple_of_arraystuple

非零元素的索引。

另请参阅

numpy.nonzero

操作 ndarrays 的函数。

flatnonzero

返回输入数组的展平版本中非零的索引。

numpy.ndarray.nonzero

等效的 ndarray 方法。

count_nonzero

统计输入数组中非零元素的数量。

示例

>>> import numpy.ma as ma
>>> x = ma.array(np.eye(3))
>>> x
masked_array(
 data=[[1., 0., 0.],
 [0., 1., 0.],
 [0., 0., 1.]],
 mask=False,
 fill_value=1e+20)
>>> x.nonzero()
(array([0, 1, 2]), array([0, 1, 2])) 

掩盖元素将被忽略。

>>> x[1, 1] = ma.masked
>>> x
masked_array(
 data=[[1.0, 0.0, 0.0],
 [0.0, --, 0.0],
 [0.0, 0.0, 1.0]],
 mask=[[False, False, False],
 [False,  True, False],
 [False, False, False]],
 fill_value=1e+20)
>>> x.nonzero()
(array([0, 2]), array([0, 2])) 

索引也可以按元素分组。

>>> np.transpose(x.nonzero())
array([[0, 0],
 [2, 2]]) 

nonzero的一个常见用法是找到数组的索引，其中条件为 True。给定一个数组a，条件 a > 3 是一个布尔数组，因为 False 被解释为 0，所以 ma.nonzero(a > 3)产生满足条件为真的a的索引。

>>> a = ma.array([[1,2,3],[4,5,6],[7,8,9]])
>>> a > 3
masked_array(
 data=[[False, False, False],
 [ True,  True,  True],
 [ True,  True,  True]],
 mask=False,
 fill_value=True)
>>> ma.nonzero(a > 3)
(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) 

条件数组的nonzero方法也可以被调用。

>>> (a > 3).nonzero()
(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) 

numpy.ma.shape

numpy.org/doc/1.26/reference/generated/numpy.ma.shape.html

ma.shape(obj)

返回数组的形状。

参数：

a类似于数组的对象

输入数组。

返回：

shape整数的元组

shape 元组的元素给出了对应数组维度的长度。

另请参阅

len

对于N>=1维数组，len(a)等效于np.shape(a)[0]。

ndarray.shape

等效的数组方法。

示例

>>> np.shape(np.eye(3))
(3, 3)
>>> np.shape([[1, 3]])
(1, 2)
>>> np.shape([0])
(1,)
>>> np.shape(0)
() 

>>> a = np.array([(1, 2), (3, 4), (5, 6)],
...              dtype=[('x', 'i4'), ('y', 'i4')])
>>> np.shape(a)
(3,)
>>> a.shape
(3,) 

numpy.ma.size

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

ma.size(obj, axis=None)

返回沿给定轴的元素数量。

参数：

aarray_like

输入数据。

轴int，可选

要计数元素的轴。默认情况下，给出元素的总数。

返回：

element_countint

沿指定轴的元素数量。

另请参见

shape

数组的维数

ndarray.shape

数组的维数

ndarray.size

数组中的元素数量

示例

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