掩码数组操作#

常量#

ma.MaskType

bool 的别名

创建#

从现有数据#

ma.masked_array

MaskedArray 的别名

ma.array(data[, dtype, copy, order, mask, ...])

一个可能包含掩码值的数组类。

ma.copy(self, *args, **params) a.copy(order=)

返回数组的副本。

ma.frombuffer(buffer[, dtype, count, ...])

将缓冲区解释为一维数组。

ma.fromfunction(function, shape, **dtype)

通过对每个坐标执行函数来构造数组。

ma.MaskedArray.copy([order])

返回数组的副本。

ma.diagflat

创建一个二维数组,将扁平化的输入作为对角线。

一和零#

ma.empty(shape[, dtype, order, device, like])

返回一个新的数组,具有给定的形状和类型,但不初始化条目。

ma.empty_like(prototype[, dtype, order, ...])

返回一个新的数组,其形状和类型与给定数组相同。

ma.masked_all(shape[, dtype])

所有元素都被掩码的空掩码数组。

ma.masked_all_like(arr)

具有现有数组属性的空掩码数组。

ma.ones(shape[, dtype, order])

返回一个新的数组,具有给定的形状和类型,并用 1 填充。

ma.ones_like

返回一个全 1 的数组,其形状和类型与给定数组相同。

ma.zeros(shape[, dtype, order, like])

返回一个新的数组,具有给定的形状和类型,并用 0 填充。

ma.zeros_like

返回一个全 0 的数组,其形状和类型与给定数组相同。


检查数组#

ma.all(self[, axis, out, keepdims])

如果所有元素均评估为 True,则返回 True。

ma.any(self[, axis, out, keepdims])

如果 a 的任何元素评估为 True,则返回 True。

ma.count(self[, axis, keepdims])

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

ma.count_masked(arr[, axis])

计算给定轴上掩码元素的数量。

ma.getmask(a)

返回掩码数组的掩码,或 nomask。

ma.getmaskarray(arr)

返回掩码数组的掩码,或全为 False 的布尔数组。

ma.getdata(a[, subok])

将掩码数组的数据作为 ndarray 返回。

ma.nonzero(self)

返回非零且未掩码元素的索引。

ma.shape(obj)

返回数组的形状。

ma.size(obj[, axis])

返回给定轴上元素的数量。

ma.is_masked(x)

判断输入是否包含掩码值。

ma.is_mask(m)

如果 m 是有效的标准掩码,则返回 True。

ma.isMaskedArray(x)

测试输入是否为 MaskedArray 的实例。

ma.isMA(x)

测试输入是否为 MaskedArray 的实例。

ma.isarray(x)

测试输入是否为 MaskedArray 的实例。

ma.isin(element, test_elements[, ...])

计算 element in test_elements,只在 element 上广播。

ma.in1d(ar1, ar2[, assume_unique, invert])

测试数组的每个元素是否也存在于第二个数组中。

ma.unique(ar1[, return_index, return_inverse])

查找数组的唯一元素。

ma.MaskedArray.all([axis, out, keepdims])

如果所有元素均评估为 True,则返回 True。

ma.MaskedArray.any([axis, out, keepdims])

如果 a 的任何元素评估为 True,则返回 True。

ma.MaskedArray.count([axis, keepdims])

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

ma.MaskedArray.nonzero()

返回非零且未掩码元素的索引。

ma.shape(obj)

返回数组的形状。

ma.size(obj[, axis])

返回给定轴上元素的数量。

ma.MaskedArray.data

返回底层数据,作为掩码数组的视图。

ma.MaskedArray.mask

当前掩码。

ma.MaskedArray.recordmask

如果数组没有命名字段,则获取或设置数组的掩码。


操作掩码数组#

更改形状#

ma.ravel(self[, order])

返回 self 的一维版本,作为视图。

ma.reshape(a, new_shape[, order])

返回包含相同数据但具有新形状的数组。

ma.resize(x, new_shape)

返回具有指定大小和形状的新掩码数组。

ma.MaskedArray.flatten([order])

返回数组的副本,折叠成一维。

ma.MaskedArray.ravel([order])

返回 self 的一维版本,作为视图。

ma.MaskedArray.reshape(*s, **kwargs)

为数组赋予新形状,而不更改其数据。

ma.MaskedArray.resize(newshape[, refcheck, ...])

修改轴#

ma.swapaxes(self, *args, ...)

返回交换了 axis1axis2 的数组视图。

ma.transpose(a[, axes])

置换数组的维度。

ma.MaskedArray.swapaxes(axis1, axis2)

返回交换了 axis1axis2 的数组视图。

ma.MaskedArray.transpose(*axes)

返回具有转置轴的数组视图。

更改维数#

ma.atleast_1d

将输入转换为至少有一维的数组。

ma.atleast_2d

将输入视为至少有两维的数组。

ma.atleast_3d

将输入视为至少有三维的数组。

ma.expand_dims(a, axis)

扩展数组的形状。

ma.squeeze

a 中删除长度为一的轴。

ma.MaskedArray.squeeze([axis])

a 中删除长度为一的轴。

ma.stack

沿着新轴连接一系列数组。

ma.column_stack

将一维数组作为列堆叠到二维数组中。

ma.concatenate(arrays[, axis])

沿着给定轴连接一系列数组。

ma.dstack

沿着第三轴(深度方向)依次堆叠数组。

ma.hstack

水平(按列)依次堆叠数组。

ma.hsplit

水平(按列)将数组拆分为多个子数组。

ma.mr_

将切片对象转换为沿着第一个轴的连接。

ma.vstack

垂直(按行)依次堆叠数组。

连接数组#

ma.concatenate(arrays[, axis])

沿着给定轴连接一系列数组。

ma.stack

沿着新轴连接一系列数组。

ma.vstack

垂直(按行)依次堆叠数组。

ma.hstack

水平(按列)依次堆叠数组。

ma.dstack

沿着第三轴(深度方向)依次堆叠数组。

ma.column_stack

将一维数组作为列堆叠到二维数组中。

ma.append(a, b[, axis])

在数组末尾追加值。


掩码操作#

创建掩码#

ma.make_mask(m[, copy, shrink, dtype])

从数组创建布尔掩码。

ma.make_mask_none(newshape[, dtype])

返回给定形状的布尔掩码,填充为 False。

ma.mask_or(m1, m2[, copy, shrink])

使用 logical_or 运算符组合两个掩码。

ma.make_mask_descr(ndtype)

从给定的 dtype 构建 dtype 描述列表。

访问掩码#

ma.getmask(a)

返回掩码数组的掩码,或 nomask。

ma.getmaskarray(arr)

返回掩码数组的掩码,或全为 False 的布尔数组。

ma.masked_array.mask

当前掩码。

查找掩码数据#

ma.ndenumerate(a[, compressed])

多维索引迭代器。

ma.flatnotmasked_contiguous(a)

在掩码数组中查找连续的未掩码数据。

ma.flatnotmasked_edges(a)

查找第一个和最后一个未掩码值的索引。

ma.notmasked_contiguous(a[, axis])

沿着给定轴在掩码数组中查找连续的未掩码数据。

ma.notmasked_edges(a[, axis])

沿着给定轴查找第一个和最后一个未掩码值的索引。

ma.clump_masked(a)

返回对应于一维数组的掩码块的切片列表。

ma.clump_unmasked(a)

返回对应于一维数组的未掩码块的切片列表。

修改掩码#

ma.mask_cols(a[, axis])

掩码包含掩码值的二维数组的列。

ma.mask_or(m1, m2[, copy, shrink])

使用 logical_or 运算符组合两个掩码。

ma.mask_rowcols(a[, axis])

掩码包含掩码值的二维数组的行和/或列。

ma.mask_rows(a[, axis])

掩盖包含掩码值的二维数组的行。

ma.harden_mask(self)

强制掩码变为硬掩码,防止通过赋值取消掩码。

ma.soften_mask(self)

强制掩码变为软掩码(默认),允许通过赋值取消掩码。

ma.MaskedArray.harden_mask()

强制掩码变为硬掩码,防止通过赋值取消掩码。

ma.MaskedArray.soften_mask()

强制掩码变为软掩码(默认),允许通过赋值取消掩码。

ma.MaskedArray.shrink_mask()

尽可能地将掩码缩减为 nomask。

ma.MaskedArray.unshare_mask()

复制掩码并将 sharedmask 标志设置为 False


转换操作#

> 转换为掩码数组#

ma.asarray(a[, dtype, order])

将输入转换为指定数据类型的掩码数组。

ma.asanyarray(a[, dtype])

将输入转换为掩码数组,保留子类。

ma.fix_invalid(a[, mask, copy, fill_value])

返回使用填充值掩盖并替换无效数据的输入。

ma.masked_equal(x, value[, copy])

掩盖等于给定值的数组。

ma.masked_greater(x, value[, copy])

掩盖大于给定值的数组。

ma.masked_greater_equal(x, value[, copy])

掩盖大于或等于给定值的数组。

ma.masked_inside(x, v1, v2[, copy])

掩盖给定区间内的数组。

ma.masked_invalid(a[, copy])

掩盖出现无效值(NaN 或 inf)的数组。

ma.masked_less(x, value[, copy])

掩盖小于给定值的数组。

ma.masked_less_equal(x, value[, copy])

掩盖小于或等于给定值的数组。

ma.masked_not_equal(x, value[, copy])

掩盖等于给定值的数组。

ma.masked_object(x, value[, copy, shrink])

掩盖数组 x,其中数据恰好等于 value。

ma.masked_outside(x, v1, v2[, copy])

掩盖给定区间之外的数组。

ma.masked_values(x, value[, rtol, atol, ...])

使用浮点相等性进行掩盖。

ma.masked_where(condition, a[, copy])

掩盖满足条件的数组。

> 转换为 ndarray#

ma.compress_cols(a)

抑制包含掩码值的二维数组的整列。

ma.compress_rowcols(x[, axis])

抑制包含掩码值的二维数组的行和/或列。

ma.compress_rows(a)

抑制包含掩码值的二维数组的整行。

ma.compressed(x)

将所有非掩码数据作为一维数组返回。

ma.filled(a[, fill_value])

将输入作为 ndarray 返回,掩码值被替换为 fill_value

ma.MaskedArray.compressed()

将所有非掩码数据作为一维数组返回。

ma.MaskedArray.filled([fill_value])

返回 self 的副本,其中掩码值被填充为给定值。

> 转换为其他对象#

ma.MaskedArray.tofile(fid[, sep, format])

将掩码数组以二进制格式保存到文件。

ma.MaskedArray.tolist([fill_value])

将掩码数组的数据部分作为分层 Python 列表返回。

ma.MaskedArray.torecords()

将掩码数组转换为灵活类型数组。

ma.MaskedArray.tobytes([fill_value, order])

将数组数据作为包含数组中原始字节的字符串返回。

填充掩码数组#

ma.common_fill_value(a, b)

如果存在,返回两个掩码数组的公共填充值。

ma.default_fill_value(obj)

返回参数对象的默认填充值。

ma.maximum_fill_value(obj)

返回对象数据类型所能表示的最小值。

ma.minimum_fill_value(obj)

返回对象数据类型所能表示的最大值。

ma.set_fill_value(a, fill_value)

如果 a 是掩码数组,则设置 a 的填充值。

ma.MaskedArray.get_fill_value()

掩码数组的填充值是标量。

ma.MaskedArray.set_fill_value([value])

ma.MaskedArray.fill_value

掩码数组的填充值是标量。


掩码数组算术#

算术运算#

ma.anom(self[, axis, dtype])

计算给定轴上的异常值(与算术平均值的偏差)。

ma.anomalies(self[, axis, dtype])

计算给定轴上的异常值(与算术平均值的偏差)。

ma.average(a[, axis, weights, returned, ...])

返回给定轴上数组的加权平均值。

ma.conjugate(x, /[, out, where, casting, ...])

返回复数共轭,逐元素计算。

ma.corrcoef(x[, y, rowvar, bias, ...])

返回皮尔逊积矩相关系数。

ma.cov(x[, y, rowvar, bias, allow_masked, ddof])

估计协方差矩阵。

ma.cumsum(self[, axis, dtype, out])

返回给定轴上数组元素的累加和。

ma.cumprod(self[, axis, dtype, out])

返回给定轴上数组元素的累乘积。

ma.mean(self[, axis, dtype, out, keepdims])

返回给定轴上数组元素的平均值。

ma.median(a[, axis, out, overwrite_input, ...])

计算指定轴上的中位数。

ma.power(a, b[, third])

返回逐元素地将第一个数组的元素作为底数,第二个数组的元素作为指数进行幂运算的结果。

ma.prod(self[, axis, dtype, out, keepdims])

返回数组元素在给定轴上的乘积。

ma.std(self[, axis, dtype, out, ddof, ...])

返回数组元素在给定轴上的标准差。

ma.sum(self[, axis, dtype, out, keepdims])

返回数组元素在给定轴上的总和。

ma.var(self[, axis, dtype, out, ddof, ...])

计算指定轴上的方差。

ma.MaskedArray.anom([axis, dtype])

计算给定轴上的异常值(与算术平均值的偏差)。

ma.MaskedArray.cumprod([axis, dtype, out])

返回给定轴上数组元素的累乘积。

ma.MaskedArray.cumsum([axis, dtype, out])

返回给定轴上数组元素的累加和。

ma.MaskedArray.mean([axis, dtype, out, keepdims])

返回给定轴上数组元素的平均值。

ma.MaskedArray.prod([axis, dtype, out, keepdims])

返回数组元素在给定轴上的乘积。

ma.MaskedArray.std([axis, dtype, out, ddof, ...])

返回数组元素在给定轴上的标准差。

ma.MaskedArray.sum([axis, dtype, out, keepdims])

返回数组元素在给定轴上的总和。

ma.MaskedArray.var([axis, dtype, out, ddof, ...])

计算指定轴上的方差。

最小值/最大值#

ma.argmax(self[, axis, fill_value, out])

返回沿给定轴的最大值的索引数组。

ma.argmin(self[, axis, fill_value, out])

返回沿给定轴的最小值的索引数组。

ma.max(obj[, axis, out, fill_value, keepdims])

返回给定轴上的最大值。

ma.min(obj[, axis, out, fill_value, keepdims])

返回给定轴上的最小值。

ma.ptp(obj[, axis, out, fill_value, keepdims])

返回给定维度上的(最大值 - 最小值)(即峰峰值)。

ma.diff(a, /[, n, axis, prepend, append])

计算给定轴上的第 n 个离散差分。

ma.MaskedArray.argmax([axis, fill_value, ...])

返回沿给定轴的最大值的索引数组。

ma.MaskedArray.argmin([axis, fill_value, ...])

返回沿给定轴的最小值的索引数组。

ma.MaskedArray.max([axis, out, fill_value, ...])

返回给定轴上的最大值。

ma.MaskedArray.min([axis, out, fill_value, ...])

返回给定轴上的最小值。

ma.MaskedArray.ptp([axis, out, fill_value, ...])

返回给定维度上的(最大值 - 最小值)(即峰峰值)。

排序#

ma.argsort(a[, axis, kind, order, endwith, ...])

返回一个 ndarray,其中包含沿指定轴对数组排序的索引。

ma.sort(a[, axis, kind, order, endwith, ...])

返回掩码数组的已排序副本。

ma.MaskedArray.argsort([axis, kind, order, ...])

返回一个 ndarray,其中包含沿指定轴对数组排序的索引。

ma.MaskedArray.sort([axis, kind, order, ...])

对数组进行排序(就地操作)。

代数#

ma.diag(v[, k])

提取对角线或构造对角线数组。

ma.dot(a, b[, strict, out])

返回两个数组的点积。

ma.identity(n[, dtype])

返回单位矩阵。

ma.inner(a, b, /)

两个数组的内积。

ma.innerproduct(a, b, /)

两个数组的内积。

ma.outer(a, b)

计算两个向量的外积。

ma.outerproduct(a, b)

计算两个向量的外积。

ma.trace(self[, offset, axis1, axis2, ...])

返回数组的对角线上的总和。

ma.transpose(a[, axes])

置换数组的维度。

ma.MaskedArray.trace([offset, axis1, axis2, ...])

返回数组的对角线上的总和。

ma.MaskedArray.transpose(*axes)

返回具有转置轴的数组视图。

多项式拟合#

ma.vander(x[, n])

生成范德蒙德矩阵。

ma.polyfit(x, y, deg[, rcond, full, w, cov])

最小二乘多项式拟合。

裁剪和舍入#

ma.around

将数组舍入到给定的位数。

ma.clip

裁剪(限制)数组中的值。

ma.round(a[, decimals, out])

返回 a 的副本,舍入到 'decimals' 位。

ma.MaskedArray.clip([min, max, out])

返回一个数组,其值被限制在 [min, max]

ma.MaskedArray.round([decimals, out])

返回每个元素,舍入到给定的位数。

集合操作#

ma.intersect1d(ar1, ar2[, assume_unique])

返回两个数组中共同的唯一元素。

ma.setdiff1d(ar1, ar2[, assume_unique])

具有唯一元素的 1D 数组的集合差。

ma.setxor1d(ar1, ar2[, assume_unique])

具有唯一元素的 1D 数组的集合异或。

ma.union1d(ar1, ar2)

两个数组的并集。

杂项#

ma.allequal(a, b[, fill_value])

如果 a 和 b 的所有条目都相等,则返回 True,在其中一个或两个都掩码的情况下使用 fill_value 作为真值。

ma.allclose(a, b[, masked_equal, rtol, atol])

如果两个数组在容差范围内逐元素相等,则返回 True。

ma.amax(a[, axis, out, keepdims, initial, where])

返回数组的最大值或沿轴的最大值。

ma.amin(a[, axis, out, keepdims, initial, where])

返回数组的最小值或沿轴的最小值。

ma.apply_along_axis(func1d, axis, arr, ...)

将函数应用于沿给定轴的 1-D 切片。

ma.apply_over_axes(func, a, axes)

对多个轴重复应用函数。

ma.arange([start,] stop[, step,][, dtype, ...])

在给定间隔内返回均匀间隔的值。

ma.choose(indices, choices[, out, mode])

使用索引数组从选择列表中构造新数组。

ma.compress_nd(x[, axis])

抑制包含掩码值的多个维度的切片。

ma.convolve(a, v[, mode, propagate_mask])

返回两个一维序列的离散线性卷积。

ma.correlate(a, v[, mode, propagate_mask])

两个一维序列的互相关。

ma.ediff1d(arr[, to_end, to_begin])

计算数组中连续元素之间的差异。

ma.flatten_mask(mask)

返回掩码的完全扁平化版本,其中嵌套字段被折叠。

ma.flatten_structured_array(a)

扁平化结构化数组。

ma.fromflex(fxarray)

从合适的灵活类型数组构建掩码数组。

ma.indices(dimensions[, dtype, sparse])

返回表示网格索引的数组。

ma.left_shift(a, n)

将整数的位向左移。

ma.ndim(obj)

返回数组的维数。

ma.put(a, indices, values[, mode])

将存储索引位置设置为相应的 value。

ma.putmask(a, mask, values)

根据条件和输入值更改数组的元素。

ma.right_shift(a, n)

将整数的位向右移。

ma.round_(a[, decimals, out])

返回 a 的副本,舍入到 'decimals' 位。

ma.take(a, indices[, axis, out, mode])

ma.where(condition[, x, y])

返回一个掩码数组,其中元素来自 xy,具体取决于条件。