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 实例可以看作是几个元素的组合：

• 作为常规的 numpy.ndarray，具有任意形状和数据类型的 data（数据）。

• 一个布尔型的 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	数组元素的数据类型。
MaskedArray.flags	有关数组内存布局的信息。
MaskedArray.itemsize	数组一个元素占用的字节数。
MaskedArray.nbytes	数组元素消耗的总字节数。
MaskedArray.ndim	数组的维度数。
MaskedArray.shape	数组的维度元组。
MaskedArray.size	数组中的元素数量。
MaskedArray.strides	遍历数组时，每个维度需要跳过的字节数。
MaskedArray.imag	屏蔽数组的虚部。
MaskedArray.real	掩码数组的实部。
MaskedArray.flat	返回一个扁平迭代器，或者将 self 的扁平版本设置为 value。
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])	返回 self 的一维版本，作为视图。
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])	沿轴从掩码数组中提取元素。

Pickling 和复制

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 为真则返回 True，否则返回 False。

算术：

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 的幂，掩盖潜在的 NaN/Inf。
MaskedArray.__rpow__(other)	将 other 提升到 self 的幂，掩盖潜在的 NaN/Inf。
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 的 3-元组。
MaskedArray.__setstate__(state)	为序列化目的恢复掩码数组的内部状态。

基本自定义

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

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

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

沿给定轴计算非掩码元素。