Constants of the numpy.ma module

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

numpy.ma.masked

masked常量是MaskedArray的特殊情况，具有float数据类型和null形状。它用于测试被屏蔽数组的特定条目是否被屏蔽，或者屏蔽被屏蔽数组的一个或多个条目：

>>> 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在内部用于在不需要掩码时加快计算速度。

numpy.ma.masked_print_options

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

The MaskedArray class

class numpy.ma.MaskedArray

设计用于操作具有丢失数据的数值数组的ndarray的子类。

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

• data作为任何形状或数据类型（数据）的常规numpy.ndarray。
• 与数据形状相同的布尔mask，其中True值表示数据的相应元素无效。对于没有命名字段的数组，特殊值nomask也可以接受，并且表示没有数据无效。
• fill_value，可用于替换无效条目以返回标准numpy.ndarray的值。

Attributes and properties of masked arrays

也可以看看

Array Attributes

MaskedArray.data

返回底层数据，作为掩码数组的视图。如果底层数据是numpy.ndarray的子类，则返回它。

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

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

MaskedArray.mask

返回底层掩码，作为与数据具有相同形状和结构的数组，但其中所有字段都是原子的布尔值。值True表示无效条目。

MaskedArray.recordmask

如果没有命名字段，则返回数组的掩码。对于结构化数组，如果所有字段被屏蔽，则返回条目为True的布尔值的ndarray，否则返回False

>>> x = 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], dtype=bool)

MaskedArray.fill_value

返回用于填充屏蔽数组的无效条目的值。该值是标量（如果掩蔽的数组没有命名字段），或者如果具有命名字段，则具有与掩蔽的数组相同的dtype的0-D ndarray。

默认填充值取决于数组的数据类型：

数据类型	默认
bool	真正
int	999999
浮动	1.e20
复杂	1.e20 + 0j
目的	'？'
串	'N / A'

MaskedArray.baseclass

返回基础数据的类。

>>> x =  ma.array(np.matrix([[1, 2], [3, 4]]), mask=[[0, 0], [1, 0]])
>>> x.baseclass
<class 'numpy.matrixlib.defmatrix.matrix'>

MaskedArray.sharedmask

返回数组的掩码是否在多个掩码数组之间共享。如果是这种情况，对一个数组的掩码的任何修改将被传播到其他数组。

MaskedArray.hardmask

返回掩码是硬（True）还是软（False）。当掩码是硬的时，掩码的条目不能被取消掩码。

由于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 methods

也可以看看

Array methods

Conversion

MaskedArray.__float__()	转换为浮动。
MaskedArray.__hex__()hex（x）
MaskedArray.__int__()	转换为int。
MaskedArray.__long__()long（x）
MaskedArray.__oct__()oct（x）
MaskedArray.view（[dtype，type]）	数组的新视图与相同的数据。
MaskedArray.astype（newtype）	将MaskedArray转换的副本返回给给定的newtype。
MaskedArray.byteswap（inplace）	交换数组元素的字节
MaskedArray.compressed()	将所有非屏蔽数据作为1-D数组。
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]）	将数组数据作为包含数组中原始字节的字符串返回。

Shape manipulation

对于重塑，调整大小和转置，单个元组参数可以替换为n整数，这将被解释为n元组。

MaskedArray.flatten（[order]）	将折叠的数组的副本返回到一个维度。
MaskedArray.ravel（[order]）	作为视图返回self的1D版本。
MaskedArray.reshape（\ * s，\ * \ * kwargs）	为数组提供新形状，而不更改其数据。
MaskedArray.resize（newshape [，refcheck，order]）
MaskedArray.squeeze（[axis]）	从a形状删除单维条目。
MaskedArray.swapaxes（axis1，axis2）	返回数组的视图，其中axis1和axis2互换。
MaskedArray.transpose（\ * axes）	返回具有轴转置的数组的视图。
MaskedArray.T

Item selection and manipulation

对于采用轴关键字的数组方法，默认为无。如果axis None，则数组被视为1-D数组。axis的任何其他值表示操作应沿其进行的维度。

MaskedArray.argmax（[axis，fill_value，out]）	返回沿给定轴的最大值的索引的数组。
MaskedArray.argmin（[axis，fill_value，out]）	将指数的数组返回给定轴的最小值。
MaskedArray.argsort（[axis，kind，order，...]）	返回沿指定轴对数组进行排序的索引数组。
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（重复[，轴]）	重复数组的元素。
MaskedArray.searchsorted（v [，side，sorter]）	查找索引，其中v的元素应插入到a以维持顺序。
MaskedArray.sort（[axis，kind，order，...]）	就地对数组进行排序
MaskedArray.take（indices [，axis，out，mode]）

Pickling and copy

MaskedArray.copy（[order]）	返回数组的副本。
MaskedArray.dump（file）	将数组的pickle转储到指定的文件。
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（[小数，输出]）	返回四舍五入到给定小数位数的每个元素。
MaskedArray.std（[axis，dtype，out，ddof，...]）	返回给定轴上的数组元素的标准偏差。
MaskedArray.sum（[axis，dtype，out，keepdims]）	返回给定轴上的数组元素的总和。
MaskedArray.trace（[offset，axis1，axis2，...]）	沿数组的对角线返回总和。
MaskedArray.var（[axis，dtype，out，ddof，...]）	计算沿指定轴的方差。

Arithmetic and comparison operations

Comparison operators:

MaskedArray.__lt__	x.__lt__(y) <==> x
MaskedArray.__le__	x。_ le __（y）x
MaskedArray.__gt__	x .__ gt__（y）x> y
MaskedArray.__ge__	x ._ge__（y）x> = y
MaskedArray.__eq__（other）	检查其他是否等于自我元素。
MaskedArray.__ne__（other）	检查其他不等于自我元素

Truth value of an array (bool):

MaskedArray.__nonzero__

x .__ nonzero __()x！= 0

Arithmetic:

MaskedArray.__abs__()abs（x）
MaskedArray.__add__（other）	将self添加到其他，并返回一个新的蒙版数组。
MaskedArray.__radd__（other）	将其他添加到self，并返回一个新的蒙版数组。
MaskedArray.__sub__（other）	从self中减去其他，并返回一个新的蒙版数组。
MaskedArray.__rsub__（other）	从其他中减去self，并返回一个新的蒙版数组。
MaskedArray.__mul__（other）	乘以其他，并返回一个新的蒙版数组。
MaskedArray.__rmul__（other）	通过self乘其他，并返回一个新的蒙版数组。
MaskedArray.__div__（other）	将其他划分为self，并返回一个新的屏蔽数组。
MaskedArray.__rdiv__
MaskedArray.__truediv__（other）	将其他划分为self，并返回一个新的屏蔽数组。
MaskedArray.__rtruediv__（other）	将自我划分为其他，并返回一个新的蒙版数组。
MaskedArray.__floordiv__（other）	将其他划分为self，并返回一个新的屏蔽数组。
MaskedArray.__rfloordiv__（other）	将自我划分为其他，并返回一个新的蒙版数组。
MaskedArray.__mod__	x .__ mod __（y）x％y
MaskedArray.__rmod__	x .__ rmod __（y）y％x
MaskedArray.__divmod__（y）divmod（x，y）
MaskedArray.__rdivmod__（y）divmod（y，x）
MaskedArray.__pow__（other）	提高自我对权力其他，掩蔽潜力NaNs / Infs
MaskedArray.__rpow__（other）	提高其他的力量自我，掩蔽潜力NaNs / Infs
MaskedArray.__lshift__	x .__ lshift __（y）x
MaskedArray.__rlshift__	x .__ rlshift __（y）y
MaskedArray.__rshift__	x .__ rshift__（y）x >> y
MaskedArray.__rrshift__	x .__ rrshift __（y）y >> x
MaskedArray.__and__	x。和__（y）x＆y
MaskedArray.__rand__	x。_ rand __（y）y＆x
MaskedArray.__or__	x .__或__（y）x | y
MaskedArray.__ror__	x .__ ror __（y）y | x
MaskedArray.__xor__	x .__ xor __（y）x ^ y
MaskedArray.__rxor__	x。_ rxor __（y）y ^ x

Arithmetic, in-place:

MaskedArray.__iadd__（other）	添加其他到自己就地。
MaskedArray.__isub__（other）	从其他位置自行扣除。
MaskedArray.__imul__（other）	通过其他就地乘法自我。
MaskedArray.__idiv__（other）	将自己与其他地方分开。
MaskedArray.__itruediv__（other）	真正把自己与其他就地分开。
MaskedArray.__ifloordiv__（other）	地板由其他就地分隔。
MaskedArray.__imod__	x。_ imod __（y）x％= y
MaskedArray.__ipow__（other）	提高自己到力量其他，到位。
MaskedArray.__ilshift__	x .__ ilshift __（y）x
MaskedArray.__irshift__	x .__ irshift __（y）x >> = y
MaskedArray.__iand__	x .__ iand __（y）x＆= y
MaskedArray.__ior__	x .__ ior __（y）x | = y
MaskedArray.__ixor__	x。_ ixor __（y）x ^ = y

Representation

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

Special methods

对于标准库函数：

MaskedArray.__copy__（[order]）	返回数组的副本。
MaskedArray.__deepcopy__（[memo]）
MaskedArray.__getstate__()	返回掩码数组的内部状态，以进行pickling。
MaskedArray.__reduce__()	返回用于酸洗MaskedArray的3元组。
MaskedArray.__setstate__（state）	恢复已屏蔽数组的内部状态，以便进行pickling。

基本定制：

MaskedArray.__new__（[data，mask，dtype，...]）	从头开始创建一个新的蒙版数组。
MaskedArray.__array__（...）	如果未指定dtype，则返回对self的新引用，如果dtype与数组的当前dtype不同，则返回提供的数据类型的新数组。
MaskedArray.__array_wrap__（obj [，context]）	ufuncs的特殊钩子。

容器自定义:(参见Indexing）

MaskedArray.__len__()len（x）
MaskedArray.__getitem__（indx）	x .__ getitem __（y）x [y]
MaskedArray.__setitem__（indx，value）	x .__ setitem __（i，y）x [i] = y
MaskedArray.__delitem__	x .__ delitem __（y）del x [y]
MaskedArray.__contains__	x .__在x中包含__（y）y

Specific methods

Handling the mask

以下方法可用于访问关于掩模的信息或操纵掩模。

MaskedArray.__setmask__（mask [，copy]）	设置掩码。
MaskedArray.harden_mask()	强迫面具硬。
MaskedArray.soften_mask()	强迫面罩柔软。
MaskedArray.unshare_mask()	复制掩码并将sharedmask标志设置为False。
MaskedArray.shrink_mask()	如果可能，减少掩码到nomask。

Handling the fill_value

MaskedArray.get_fill_value()	返回掩码数组的填充值。
MaskedArray.set_fill_value（[value]）	设置掩码数组的填充值。

Counting the missing elements

MaskedArray.count（[axis，keepdims]）

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