numpy.ma 模块的常量

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

numpy.ma.masked

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

.. try_examples::

>>> import numpy as np

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

numpy.ma.nomask

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

numpy.ma.masked_print_option

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

使用 set_display() 更改默认字符串。例如：numpy.ma.masked_print_option.set_display('X') 会将缺失数据替换为 'X'。

MaskedArray 类

class numpy.ma.MaskedArray

一个旨在处理带有缺失数据的数值数组的 ndarray 子类。

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

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

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

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

掩码数组的属性和特性

另请参阅

数组属性

ma.MaskedArray.data

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

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

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

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

ma.MaskedArray.mask

当前掩码。

ma.MaskedArray.recordmask

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

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

ma.MaskedArray.fill_value

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

示例

在浏览器中尝试！

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

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

恢复默认

>>> x.fill_value = None
>>> x.fill_value
np.float64(1e+20)

返回在新标签页中打开

ma.MaskedArray.baseclass

底层数据的类（只读）。

ma.MaskedArray.sharedmask

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

ma.MaskedArray.hardmask

指定值是否可以通过赋值解除掩盖。

默认情况下，将确切值赋给掩码数组条目将解除其掩盖。当 hardmask 为 True 时，掩码不会通过赋值改变。

另请参阅

ma.MaskedArray.harden_mask

ma.MaskedArray.soften_mask

示例

在浏览器中尝试！

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

由于 m 具有软掩码，赋值元素值会解除该元素的掩盖

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

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

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

返回在新标签页中打开

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

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

MaskedArray 方法

另请参阅

数组方法

转换

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

形状操作

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

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

条目选择和操作

对于接受 axis 关键字的数组方法，它默认为 None。如果 axis 为 None，则数组被视为一维数组。 axis 的任何其他值表示操作应沿其进行的维度。

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

序列化和复制

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

计算

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

算术和比较操作

比较运算符：

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

数组的真值 (bool())：

MaskedArray.__bool__(/)

如果 self 为真，否则为假。

算术运算：

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

就地算术运算：

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

表示

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

特殊方法

用于标准库函数

MaskedArray.__copy__()	如果对数组调用 copy.copy 则使用。
MaskedArray.__deepcopy__(memo, /)	如果对数组调用 copy.deepcopy 则使用。
MaskedArray.__getstate__()	返回掩码数组的内部状态，用于序列化。
MaskedArray.__reduce__()	返回一个三元组，用于序列化 MaskedArray。
MaskedArray.__setstate__(state)	恢复掩码数组的内部状态，用于序列化。

基本自定义

MaskedArray.__new__(cls[, data, mask, ...])	从头开始创建一个新的掩码数组。
MaskedArray.__array__([dtype], *[, copy])	对于 dtype 参数，如果未给出 dtype 或其与数组的数据类型匹配，则返回自身的新引用。
MaskedArray.__array_wrap__(obj[, context, ...])	ufuncs 的特殊钩子。

容器自定义：（参见 索引）

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

特定方法

处理掩码

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

MaskedArray.__setmask__(mask[, copy])	设置掩码。
MaskedArray.harden_mask()	强制掩码为硬掩码，防止通过赋值解除掩盖。
MaskedArray.soften_mask()	强制掩码为软掩码（默认），允许通过赋值解除掩盖。
MaskedArray.unshare_mask()	复制掩码并将 sharedmask 标志设置为 False。
MaskedArray.shrink_mask()	尽可能将掩码缩减为 nomask。

处理 fill_value

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

计算缺失元素

MaskedArray.count([axis, keepdims])

计算沿给定轴的数组中未掩盖的元素数量。