numpy.ma 模块的常量

除了 MaskedArray 类之外,:mod: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

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

numpy.ma.masked_print_option

当打印掩码数组时,用于代替缺失数据的字符串.默认情况下,这个字符串是 '--'.

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

The 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	返回一个扁平迭代器,或将自身的扁平版本设置为值.
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.tostring([fill_value, order])	tobytes 的兼容别名,具有完全相同的行为.
MaskedArray.tobytes([fill_value, order])	将数组数据作为包含数组中原始字节的字符串返回.

形状操作

对于重塑、调整大小和转置,单个元组参数可以用 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 其中条件为 True.
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)	逐元素检查其他是否等于自身.
MaskedArray.__ne__(other)	逐元素检查其他是否不等于自身.

数组的真值 (bool()):

MaskedArray.__bool__(/)

如果 self 则 True 否则 False

算术:

MaskedArray.__abs__(self)
MaskedArray.__add__(other)	将自身添加到其他,并返回一个新的掩码数组.
MaskedArray.__radd__(other)	将其他内容添加到自身,并返回一个新的掩码数组.
MaskedArray.__sub__(other)	从自身减去其他,并返回一个新的掩码数组.
MaskedArray.__rsub__(other)	从其他项中减去自身,并返回一个新的掩码数组.
MaskedArray.__mul__(other)	将自身乘以其他,并返回一个新的掩码数组.
MaskedArray.__rmul__(other)	将其他乘以自身,并返回一个新的掩码数组.
MaskedArray.__div__(other)	将其他数组除以自身,并返回一个新的掩码数组.
MaskedArray.__truediv__(other)	将其他数组除以自身,并返回一个新的掩码数组.
MaskedArray.__rtruediv__(other)	将自身分割成其他部分,并返回一个新的掩码数组.
MaskedArray.__floordiv__(other)	将其他数组除以自身,并返回一个新的掩码数组.
MaskedArray.__rfloordiv__(other)	将自身分割成其他部分,并返回一个新的掩码数组.
MaskedArray.__mod__(value, /)	返回 self%value.
MaskedArray.__rmod__(value, /)	返回值%self.
MaskedArray.__divmod__(value, /)	返回 divmod(self, value).
MaskedArray.__rdivmod__(value, /)	返回 divmod(value, self).
MaskedArray.__pow__(other)	将自身提升到其他次方,屏蔽潜在的 NaNs/Infs
MaskedArray.__rpow__(other)	将其他提升到自身的幂,屏蔽潜在的 NaNs/Infs
MaskedArray.__lshift__(value, /)	返回 self<<value.
MaskedArray.__rlshift__(value, /)	返回值<<self.
MaskedArray.__rshift__(value, /)	返回 self>>value.
MaskedArray.__rrshift__(value, /)	返回值>>self.
MaskedArray.__and__(value, /)	返回 self&value.
MaskedArray.__rand__(value, /)	返回值&self.
MaskedArray.__or__(value, /)	返回 self|value.
MaskedArray.__ror__(value, /)	返回值|self.
MaskedArray.__xor__(value, /)	返回 self^value.
MaskedArray.__rxor__(value, /)	返回值^self.

算术,就地:

MaskedArray.__iadd__(other)	在原地将其他内容添加到自身.
MaskedArray.__isub__(other)	就地从自身减去其他.
MaskedArray.__imul__(other)	就地将自身乘以其他.
MaskedArray.__idiv__(other)	就地将自己除以其他.
MaskedArray.__itruediv__(other)	True 就地将自己除以其他.
MaskedArray.__ifloordiv__(other)	就地将自身按其他值整除.
MaskedArray.__imod__(value, /)	返回 self%=value.
MaskedArray.__ipow__(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.

Representation

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)	恢复掩码数组的内部状态,用于pickling目的.

基本定制:

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, /)	返回键在 self 中

特定方法

处理掩码

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

MaskedArray.__setmask__(mask[, copy])	设置掩码.
MaskedArray.harden_mask()	强制掩码为硬掩码,防止通过赋值解除掩码.
MaskedArray.soften_mask()	强制掩码为软（默认）,允许通过赋值取消掩码.
MaskedArray.unshare_mask()	复制掩码并将 sharedmask 标志设置为 False.
MaskedArray.shrink_mask()	在可能的情况下将掩码减少到无掩码.

处理 fill_value

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

计算缺失的元素

MaskedArray.count([axis, keepdims])

沿给定轴计算数组中非掩码元素的数量.