numpy.ma 模块的常量

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

numpy.ma.masked

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

>>> import numpy as np

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

numpy.ma.nomask

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

numpy.ma.masked_print_option

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

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

MaskedArray 类

class numpy.ma.MaskedArray

ndarray 的一个子类，旨在操作带有缺失数据的数值数组。

MaskedArray 的一个实例可以被认为是几个元素的组合

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

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

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

掩码数组的属性和特性

另请参阅

数组属性

ma.MaskedArray.data

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

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

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

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

ma.MaskedArray.mask

当前掩码。

ma.MaskedArray.recordmask

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

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

ma.MaskedArray.fill_value

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

示例

>>> 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 的扁平版本设置为值。
MaskedArray.__array_priority__

MaskedArray 方法

另请参阅

数组方法

转换

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

形状操作

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

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

项目选择和操作

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

MaskedArray.argmax([axis, fill_value, out, ...])	返回给定轴上最大值的索引数组。
MaskedArray.argmin([axis, fill_value, out, ...])	返回沿给定轴的最小值的索引数组。
MaskedArray.argsort([axis, kind, order, ...])	返回沿指定轴对数组进行排序的索引的 ndarray。
MaskedArray.choose(choices[, out, mode])	使用索引数组从一组选择中构造新数组。
MaskedArray.compress(condition[, axis, out])	返回 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.__div__(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.__idiv__(other)	将 self 就地除以 other。
MaskedArray.__itruediv__(other)	将 self 就地真除以 other。
MaskedArray.__ifloordiv__(other)	原地对 self 进行向下整除 other 的操作。
MaskedArray.__imod__(value, /)	返回 self%=value。
MaskedArray.__ipow__(other)	原地将 self 提升为 other 的幂。
MaskedArray.__ilshift__(value, /)	返回 self<<=value。
MaskedArray.__irshift__(value, /)	返回 self>>=value。
MaskedArray.__iand__(value, /)	返回 self&=value。
MaskedArray.__ior__(value, /)	返回 self|=value。
MaskedArray.__ixor__(value, /)	返回 self^=value。

表示

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

特殊方法

用于标准库函数

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

基本自定义

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

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