numpy.ma 模块的常量

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

numpy.ma.masked

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

>>> 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 的扁平版本设置为 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])	返回 self 的副本，其中掩码值填充为给定值。
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])	作为视图返回 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])	返回 a，其中 condition 为 True。
MaskedArray.diagonal([offset, axis1, axis2])	返回指定的对角线。
MaskedArray.fill(value)	用标量值填充数组。
MaskedArray.item(*args)	将数组中的元素复制到标准 Python 标量并返回它。
MaskedArray.nonzero()	返回非零且未掩盖元素的索引。
MaskedArray.put(indices, values[, mode])	将存储索引位置设置为相应的 value。
MaskedArray.repeat(repeats[, axis])	重复数组的元素。
MaskedArray.searchsorted(v[, side, sorter])	找到应该将 v 的元素插入 a 中以保持顺序的索引。
MaskedArray.sort([axis, kind, order, ...])	对数组进行就地排序
MaskedArray.take(indices[, axis, out, mode])

Pickling 和 copy

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

Calculations

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, ...])	计算沿指定轴的方差。

Arithmetic 和 comparison operations

Comparison operators:

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

Arithmetic:

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)	将 other 就地从 self 中减去。
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__()	返回掩码数组的内部状态，用于腌制。
MaskedArray.__reduce__()	返回一个 3 元组，用于腌制 MaskedArray。
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])

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