NumPy-1-26-中文文档-十三-

NumPy 1.26 中文文档（十三）

原文：numpy.org/doc/

`numpy.ma.ravel`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.ravel.html

ma.ravel(self, order='C') = <numpy.ma.core._frommethod object>

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

参数：

order，可选

元素a是按照这种索引顺序读取的。'C'表示按照类似于 C 的顺序索引元素，最后一个轴的索引变化最快，回到第一个轴的索引变化最慢。'F'表示按照类似于 Fortran 的索引顺序索引元素，第一个索引变化最快，最后一个索引变化最慢。注意，'C'和'F'选项不考虑底层数组的内存布局，只涉及轴索引的顺序。'A'表示如果m在内存中是 Fortran contiguous，则按照类似于 Fortran 的索引顺序读取元素，否则按照类似于 C 的顺序。'K'表示按照内存中的发生顺序读取元素，但是在步幅为负时颠倒数据。默认情况下，使用'C'索引顺序。(当传递'K' 时，屏蔽数组当前使用'A'处理数据。)

MaskedArray

输出视图的形状为(self.size,)（或者(np.ma.product(self.shape),)）。

示例

>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> x
masked_array(
 data=[[1, --, 3],
 [--, 5, --],
 [7, --, 9]],
 mask=[[False,  True, False],
 [ True, False,  True],
 [False,  True, False]],
 fill_value=999999)
>>> x.ravel()
masked_array(data=[1, --, 3, --, 5, --, 7, --, 9],
 mask=[False,  True, False,  True, False,  True, False,  True,
 False],
 fill_value=999999)

`numpy.ma.reshape`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.reshape.html

ma.reshape(a, new_shape, order='C')

返回一个包含相同数据的新形状数组。

详细使用说明，请参阅MaskedArray.reshape。

参见

MaskedArray.reshape

等效函数

`numpy.ma.resize`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.resize.html

ma.resize(x, new_shape)

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

这是 numpy.resize 函数的掩码版本。新数组将以 x 的重复副本填充（按照内存中的数据存储顺序）。如果 x 被掩码，则新数组将被掩码，并且新掩码将是旧掩码的重复。

另请参阅

numpy.resize

在顶级 NumPy 模块中的等效函数。

示例

>>> import numpy.ma as ma
>>> a = ma.array([[1, 2] ,[3, 4]])
>>> a[0, 1] = ma.masked
>>> a
masked_array(
 data=[[1, --],
 [3, 4]],
 mask=[[False,  True],
 [False, False]],
 fill_value=999999)
>>> np.resize(a, (3, 3))
masked_array(
 data=[[1, 2, 3],
 [4, 1, 2],
 [3, 4, 1]],
 mask=False,
 fill_value=999999)
>>> ma.resize(a, (3, 3))
masked_array(
 data=[[1, --, 3],
 [4, 1, --],
 [3, 4, 1]],
 mask=[[False,  True, False],
 [False, False,  True],
 [False, False, False]],
 fill_value=999999)

不管输入类型如何，都将返回一个 MaskedArray。

>>> a = np.array([[1, 2] ,[3, 4]])
>>> ma.resize(a, (3, 3))
masked_array(
 data=[[1, 2, 3],
 [4, 1, 2],
 [3, 4, 1]],
 mask=False,
 fill_value=999999)

`numpy.ma.MaskedArray.flatten`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.flatten.html

方法

ma.MaskedArray.flatten(order='C')

返回数组被降维为一维的副本。

参数：

order，可选

‘C’表示按行主序（C 语言风格）展开。‘F’表示按列主序（Fortran 风格）展开。‘A’表示如果a在内存中是 Fortran 连续的，则按列主序展开，在其他情况下按行主序展开。‘K’表示按照元素在内存中出现的顺序展开a。默认为‘C’。

返回值：

yndarray

输入数组的一个被展开为一维的副本。

另请参阅

ravel

返回一个扁平化的数组。

flat

一个沿数组的一维扁平迭代器。

示例

>>> a = np.array([[1,2], [3,4]])
>>> a.flatten()
array([1, 2, 3, 4])
>>> a.flatten('F')
array([1, 3, 2, 4])

`numpy.ma.MaskedArray.ravel`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.ravel.html

方法

ma.MaskedArray.ravel(order='C')

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

参数：

order，可选

使用此索引顺序读取 a 的元素。‘C’ 表示按 C 类似的顺序索引元素，最后的轴索引最快变化，最前的轴索引最慢变化。‘F’ 表示按 Fortran 类似的索引顺序索引元素，第一个索引最快变化，最后一个索引最慢变化。请注意，‘C’ 和 ‘F’ 选项不考虑底层数组的内存布局，只涉及轴索引的顺序。‘A’ 表示如果 m 在内存中是 Fortran 连续的，则按 Fortran 类似的索引顺序读取元素，否则按 C 类似的顺序读取。‘K’ 表示按照内存中出现的顺序读取元素，除非步长为负时，会翻转数据。默认情况下，使用 ‘C’ 索引顺序。（当传递 ‘K’ 时，掩码数组当前使用数据时使用 ‘A’。）

返回值：

MaskedArray

输出视图的形状为 (self.size,)（或 (np.ma.product(self.shape),)）。

示例

>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> x
masked_array(
 data=[[1, --, 3],
 [--, 5, --],
 [7, --, 9]],
 mask=[[False,  True, False],
 [ True, False,  True],
 [False,  True, False]],
 fill_value=999999)
>>> x.ravel()
masked_array(data=[1, --, 3, --, 5, --, 7, --, 9],
 mask=[False,  True, False,  True, False,  True, False,  True,
 False],
 fill_value=999999)

`numpy.ma.MaskedArray.reshape`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.reshape.html

方法

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

给数组一个新的形状，但不改变其数据。

返回一个包含相同数据的掩码数组，但具有新形状。结果是原始数组的视图；如果这不可能，则引发 ValueError。

参数：

shapeint 或 int 元组

新形状应与原始形状兼容。如果提供一个整数，则结果将是该长度的 1-D 数组。

order，可选

确定数组数据是否应视为 C（行优先）或 FORTRAN（列优先）顺序。

返回值：

reshaped_array数组

数组的新视图。

另请参阅

reshape

掩码数组模块中的等效函数。

numpy.ndarray.reshape

ndarray 对象上的等效方法。

numpy.reshape

在 NumPy 模块中的等效函数。

注意

重新塑形操作不能保证不会进行复制，要在原地修改形状，请使用 a.shape = s

示例

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

`numpy.ma.MaskedArray.resize`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.resize.html

方法

ma.MaskedArray.resize(newshape, refcheck=True, order=False)

警告

除了引发 ValueError 异常之外，这个方法什么也不做。一个掩码数组不拥有其数据，因此不能安全地原地调整大小。请使用 numpy.ma.resize 函数代替。

这个方法很难安全地实现，并且可能在未来的 NumPy 发布版本中被弃用。

`numpy.ma.swapaxes`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.swapaxes.html

ma.swapaxes(self, *args, **params) a.swapaxes(axis1, axis2) = <numpy.ma.core._frommethod object>

返回数组的一个视图，axis1 和 axis2 互换。

参考numpy.swapaxes获取完整文档。

另请参阅

numpy.swapaxes

等效函数

`numpy.ma.transpose`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.transpose.html

ma.transpose(a, axes=None)

对数组的维度进行重排。

此函数与numpy.transpose完全等效。

另请参阅

numpy.transpose

顶层 NumPy 模块中的等效函数。

示例

>>> import numpy.ma as ma
>>> x = ma.arange(4).reshape((2,2))
>>> x[1, 1] = ma.masked
>>> x
masked_array(
 data=[[0, 1],
 [2, --]],
 mask=[[False, False],
 [False,  True]],
 fill_value=999999)

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

`numpy.ma.MaskedArray.swapaxes`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.swapaxes.html

方法

ma.MaskedArray.swapaxes(axis1, axis2)

返回一个交换了axis1和axis2的数组视图。

参考numpy.swapaxes以获取完整文档。

另请参阅

numpy.swapaxes

等效函数

`numpy.ma.MaskedArray.transpose`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.transpose.html

方法

ma.MaskedArray.transpose(*axes)

返回一个转置了轴的数组视图。

参考numpy.transpose获取完整文档。

参数：

轴None，整数的元组或n个整数

None 或无参数：颠倒轴的顺序。
整数的元组：i在元组的第j个位置表示数组的第i个轴变为转置数组的第j个轴。
n ints：与相同 ints 的 n-tuple 相同（此形式只是作为元组形式的“便利”替代方式）。

pndarray

具有其轴适当排列的数组的视图。

另请参阅

transpose

等效函数。

ndarray.T

返回数组的转置数组的数组属性。

ndarray.reshape

为数组提供新的形状，而不改变数据。

举例

>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
 [3, 4]])
>>> a.transpose()
array([[1, 3],
 [2, 4]])
>>> a.transpose((1, 0))
array([[1, 3],
 [2, 4]])
>>> a.transpose(1, 0)
array([[1, 3],
 [2, 4]])

>>> a = np.array([1, 2, 3, 4])
>>> a
array([1, 2, 3, 4])
>>> a.transpose()
array([1, 2, 3, 4])

`numpy.ma.atleast_1d`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.atleast_1d.html

ma.atleast_1d = <numpy.ma.extras._fromnxfunction_allargs object>

atleast_1d

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

标量输入被转换为 1 维数组，而高维输入被保留。

参数：

arys1, arys2, …array_like

一个或多个输入数组。

retndarray

一个数组，或数组列表，每个数组都具有a.ndim >= 1。只有在必要时才会复制。

另请参见

atleast_2d, atleast_3d

注释

如果有的话，该函数被应用于 _data 和 _mask。

例子

>>> np.atleast_1d(1.0)
array([1.])

>>> x = np.arange(9.0).reshape(3,3)
>>> np.atleast_1d(x)
array([[0., 1., 2.],
 [3., 4., 5.],
 [6., 7., 8.]])
>>> np.atleast_1d(x) is x
True

>>> np.atleast_1d(1, [3, 4])
[array([1]), array([3, 4])]

`numpy.ma.atleast_2d`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.atleast_2d.html

ma.atleast_2d = <numpy.ma.extras._fromnxfunction_allargs object>

atleast_2d

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

参数：

arys1, arys2, …array_like

一个或多个类似数组的序列。非数组输入将被转换为数组。已经具有两个或更多维度的数组将被保留。

res, res2, …ndarray

一个数组，或者数组列表，每个数组都满足a.ndim >= 2。尽可能避免复制，并返回两个或更多维度的视图。

另请参见

atleast_1d, atleast_3d

注意

如果存在，该函数将应用于 _data 和 _mask。

示例

>>> np.atleast_2d(3.0)
array([[3.]])

>>> x = np.arange(3.0)
>>> np.atleast_2d(x)
array([[0., 1., 2.]])
>>> np.atleast_2d(x).base is x
True

>>> np.atleast_2d(1, [1, 2], [[1, 2]])
[array([[1]]), array([[1, 2]]), array([[1, 2]])]

`numpy.ma.atleast_3d`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.atleast_3d.html

ma.atleast_3d = <numpy.ma.extras._fromnxfunction_allargs object>

atleast_3d

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

参数：

arys1, arys2, …array_like

一个或多个类似数组的序列。非数组输入被转换为数组。已经具有三个或更多维度的数组将被保留。

res1, res2, …ndarray

一个数组，或数组的列表，每个数组的a.ndim >= 3。在可能的情况下避免复制，并返回三个或更多维度的视图。例如，形状为(N,)的一维数组变为形状为(1, N, 1)的视图，形状为(M, N)的二维数组变为形状为(M, N, 1)的视图。

另请参阅

atleast_1d, atleast_2d

注意

如果有的话，该函数应用于 _data 和 _mask。

例子

>>> np.atleast_3d(3.0)
array([[[3.]]])

>>> x = np.arange(3.0)
>>> np.atleast_3d(x).shape
(1, 3, 1)

>>> x = np.arange(12.0).reshape(4,3)
>>> np.atleast_3d(x).shape
(4, 3, 1)
>>> np.atleast_3d(x).base is x.base  # x is a reshape, so not base itself
True

>>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]):
...     print(arr, arr.shape) 
...
[[[1]
 [2]]] (1, 2, 1)
[[[1]
 [2]]] (1, 2, 1)
[[[1 2]]] (1, 1, 2)

`numpy.ma.expand_dims`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.expand_dims.html

ma.expand_dims(a, axis)

扩展数组的形状。

在扩展数组形状中的轴位置插入一个新的轴。

参数：

aarray_like

输入数组。

axisint 或 int 元组

扩展轴中新轴（或轴）的位置。

自版本 1.13.0 起已弃用：传递axis > a.ndim的轴将被视为axis == a.ndim，并且传递axis < -a.ndim - 1的轴将被视为axis == 0。此行为已被弃用。

在版本 1.18.0 中更改：现在支持轴的元组。如上所述的超出范围的轴现在被禁止并引发AxisError。

resultndarray

将维度数量增加的a的视图。

另请参见

squeeze

逆操作，移除单维度

reshape

插入、移除和组合维度，并调整现有维度的大小

doc.indexing，atleast_1d，atleast_2d，atleast_3d

示例

>>> x = np.array([1, 2])
>>> x.shape
(2,)

以下等效于x[np.newaxis, :]或x[np.newaxis]：

>>> y = np.expand_dims(x, axis=0)
>>> y
array([[1, 2]])
>>> y.shape
(1, 2)

以下等效于x[:, np.newaxis]：

>>> y = np.expand_dims(x, axis=1)
>>> y
array([[1],
 [2]])
>>> y.shape
(2, 1)

axis也可以是元组：

>>> y = np.expand_dims(x, axis=(0, 1))
>>> y
array([[[1, 2]]])

>>> y = np.expand_dims(x, axis=(2, 0))
>>> y
array([[[1],
 [2]]])

请注意，一些示例可能使用None而不是np.newaxis。这些是相同的对象：

>>> np.newaxis is None
True

`numpy.ma.squeeze`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.squeeze.html

ma.squeeze = <numpy.ma.core._convert2ma object>

从a中删除长度为一的轴。

参数：

a类似数组

输入数据。

axisNone 或 int 或 int 元组，可选

新版本中新增的 1.7.0。

在形状中选择长度为一的条目的子集。如果选择了长度大于一的形状条目的轴，则会引发错误。

压缩后的MaskedArray

输入数组，但删除了所有或部分长度为 1 的维度。这始终是a本身或a的视图。请注意，如果所有轴都被压缩，则结果是一个 0 维数组而不是标量。

引发：

ValueError

如果axis不为 None，并且被压缩的轴的长度不为 1

另请参见

expand_dims

逆操作，添加长度为一的条目

reshape

插入、删除和组合维度，并调整现有维度的大小

示例

>>> x = np.array([[[0], [1], [2]]])
>>> x.shape
(1, 3, 1)
>>> np.squeeze(x).shape
(3,)
>>> np.squeeze(x, axis=0).shape
(3, 1)
>>> np.squeeze(x, axis=1).shape
Traceback (most recent call last):
...
ValueError: cannot select an axis to squeeze out which has size not equal to one
>>> np.squeeze(x, axis=2).shape
(1, 3)
>>> x = np.array([[1234]])
>>> x.shape
(1, 1)
>>> np.squeeze(x)
array(1234)  # 0d array
>>> np.squeeze(x).shape
()
>>> np.squeeze(x)[()]
1234

`numpy.ma.MaskedArray.squeeze`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.squeeze.html

方法

ma.MaskedArray.squeeze(axis=None)

从a中删除长度为一的轴。

请参考numpy.squeeze获取完整文档。

另请参阅

numpy.squeeze

等效函数

`numpy.ma.stack`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.stack.html

ma.stack = <numpy.ma.extras._fromnxfunction_seq object>

stack

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

axis参数指定结果的维度中的新轴的索引。例如，如果axis=0，它将是第一个维度，如果axis=-1，它将是最后一个维度。

版本 1.10.0 中的新功能。

参数：

arraysarray_like 序列

每个数组必须具有相同的形状。

axisint，可选

结果数组中的轴，沿着这个轴堆叠输入数组。

outndarray，可选

如果提供了，则为放置结果的目标。形状必须正确，与如果没有指定 out 参数，则 stack 将返回的形状相匹配。

dtypestr 或 dtype

如果提供了，则目标数组将具有此 dtype。不能与out一起提供。

版本 1.24 中的新功能。

casting，可选

控制可能发生的数据转换的类型。默认为‘same_kind’。

版本 1.24 中的新功能。

stackedndarray

堆叠的数组比输入数组多一个维度。

另请参见

concatenate

沿着现有轴连接一系列数组。

block

从嵌套块列表中组装一个 nd 数组。

split

将数组分割成多个相等大小的子数组列表。

注意

如果有的话，该函数将应用于 _data 和 _mask。

示例

>>> arrays = [np.random.randn(3, 4) for _ in range(10)]
>>> np.stack(arrays, axis=0).shape
(10, 3, 4)

>>> np.stack(arrays, axis=1).shape
(3, 10, 4)

>>> np.stack(arrays, axis=2).shape
(3, 4, 10)

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.stack((a, b))
array([[1, 2, 3],
 [4, 5, 6]])

>>> np.stack((a, b), axis=-1)
array([[1, 4],
 [2, 5],
 [3, 6]])

`numpy.ma.column_stack`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.column_stack.html

ma.column_stack = <numpy.ma.extras._fromnxfunction_seq object>

column_stack

将 1-D 数组堆叠为 2-D 数组的列。

取一个 1-D 数组序列，并将它们堆叠为列以生成一个单独的 2-D 数组。2-D 数组按原样堆叠，就像使用hstack一样。1-D 数组首先转换为 2-D 列。

参数：

tup1-D 或 2-D 数组的序列。

要堆叠的数组。它们都必须具有相同的第一个维度。

stacked2-D 数组

由给定数组堆叠形成的数组。

另请参阅

stack, hstack, vstack, concatenate

笔记

如果有的话，该函数将应用于 _data 和 _mask。

示例

>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.column_stack((a,b))
array([[1, 2],
 [2, 3],
 [3, 4]])

`numpy.ma.concatenate`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.concatenate.html

ma.concatenate(arrays, axis=0)

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

参数：

arraysarray_like 序列

数组必须具有相同的形状，除了与axis（默认情况下为第一个）对应的维度。

axisint，可选

数组将被连接的轴。默认为 0。

resultMaskedArray

保留任何掩码条目的连接数组。

另请参见

numpy.concatenate

NumPy 模块中的等效函数。

示例

>>> import numpy.ma as ma
>>> a = ma.arange(3)
>>> a[1] = ma.masked
>>> b = ma.arange(2, 5)
>>> a
masked_array(data=[0, --, 2],
 mask=[False,  True, False],
 fill_value=999999)
>>> b
masked_array(data=[2, 3, 4],
 mask=False,
 fill_value=999999)
>>> ma.concatenate([a, b])
masked_array(data=[0, --, 2, 2, 3, 4],
 mask=[False,  True, False, False, False, False],
 fill_value=999999)

`numpy.ma.dstack`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.dstack.html

ma.dstack = <numpy.ma.extras._fromnxfunction_seq object>

dstack

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

这相当于在将形状为(M,N)的 2-D 数组重塑为(M,N,1)，将形状为(N,)的 1-D 数组重塑为(1,N,1)后，沿着第三轴进行连接。重新构建由dsplit分割的数组。

此函数对最多具有 3 个维度的数组最有意义。例如，对于具有高度（第一轴）、宽度（第二轴）和 r/g/b 通道（第三轴）的像素数据。函数concatenate、stack和block提供了更一般的堆叠和连接操作。

参数：

tup数组序列

所有轴上的形状必须相同。1-D 或 2-D 数组必须具有相同的形状。

stackedndarray

由堆叠给定数组形成的数组，至少为 3-D。

另请参见

concatenate

沿着现有轴连接数组序列。

stack

沿着新轴连接数组序列。

block

从嵌套块列表中组装 nd-array。

vstack

沿着垂直方向（行方向）依次堆叠数组。

hstack

沿着水平方向（列方向）依次堆叠数组。

column_stack

将 1-D 数组堆叠为列，形成 2-D 数组。

dsplit

沿着第三轴分割数组。

注意

如果有的话，该函数将应用于 _data 和 _mask。

示例

>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.dstack((a,b))
array([[[1, 2],
 [2, 3],
 [3, 4]]])

>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[2],[3],[4]])
>>> np.dstack((a,b))
array([[[1, 2]],
 [[2, 3]],
 [[3, 4]]])

`numpy.ma.hstack`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.hstack.html

ma.hstack = <numpy.ma.extras._fromnxfunction_seq object>

hstack

沿水平方向（列方向）顺序堆叠数组。

这相当于沿第二轴进行连接，除了 1-D 数组，它沿第一轴进行连接。重新构建由hsplit分割的数组。

该函数对于最多 3 维的数组最有意义。例如，对于具有高度（第一轴）、宽度（第二轴）和 r/g/b 通道（第三轴）的像素数据。函数concatenate、stack和block提供了更一般的堆叠和连接操作。

参数：

tupndarrays 序列

所有数组除了第二轴外必须具有相同的形状，除了可以是任意长度的 1-D 数组。

dtypestr 或 dtype

如果提供，则目标数组将具有此 dtype。不能与out一起提供。

.. versionadded:: 1.24

casting，可选

控制可能发生的数据转换类型。默认为‘same_kind’。

.. versionadded:: 1.24

stackedndarray

由给定数组堆叠形成的数组。

另请参阅

concatenate

沿现有轴连接一系列数组。

stack

沿新轴连接一系列数组。

block

从块的嵌套列表中组装一个 nd-array。

vstack

沿垂直方向（行方向）顺序堆叠数组。

dstack

沿深度方向（沿第三轴）顺序堆叠数组。

column_stack

将 1-D 数组堆叠为 2-D 数组的列。

hsplit

水平（列方向）将数组分割为多个子数组。

注意

如果有的话，该函数将应用于 _data 和 _mask。

示例

>>> a = np.array((1,2,3))
>>> b = np.array((4,5,6))
>>> np.hstack((a,b))
array([1, 2, 3, 4, 5, 6])
>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[4],[5],[6]])
>>> np.hstack((a,b))
array([[1, 4],
 [2, 5],
 [3, 6]])

`numpy.ma.hsplit`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.hsplit.html

ma.hsplit = <numpy.ma.extras._fromnxfunction_single object>

hsplit

将数组水平（列方向）分割成多个子数组。

请参考split文档。hsplit 等同于带有 axis=1 的 split，数组总是沿第二轴分割，除了 1-D 数组，它在 axis=0 处分割。

另请参阅

split

将数组分割成多个大小相等的子数组。

笔记

如果有的话，该函数将应用于 _data 和 _mask。

示例

>>> x = np.arange(16.0).reshape(4, 4)
>>> x
array([[ 0.,   1.,   2.,   3.],
 [ 4.,   5.,   6.,   7.],
 [ 8.,   9.,  10.,  11.],
 [12.,  13.,  14.,  15.]])
>>> np.hsplit(x, 2)
[array([[  0.,   1.],
 [  4.,   5.],
 [  8.,   9.],
 [12.,  13.]]),
 array([[  2.,   3.],
 [  6.,   7.],
 [10.,  11.],
 [14.,  15.]])]
>>> np.hsplit(x, np.array([3, 6]))
[array([[ 0.,   1.,   2.],
 [ 4.,   5.,   6.],
 [ 8.,   9.,  10.],
 [12.,  13.,  14.]]),
 array([[ 3.],
 [ 7.],
 [11.],
 [15.]]),
 array([], shape=(4, 0), dtype=float64)]

对于更高维度的数组，分割仍然沿第二轴进行。

>>> x = np.arange(8.0).reshape(2, 2, 2)
>>> x
array([[[0.,  1.],
 [2.,  3.]],
 [[4.,  5.],
 [6.,  7.]]])
>>> np.hsplit(x, 2)
[array([[[0.,  1.]],
 [[4.,  5.]]]),
 array([[[2.,  3.]],
 [[6.,  7.]]])]

对于 1-D 数组，分割沿轴 0 进行。

>>> x = np.array([0, 1, 2, 3, 4, 5])
>>> np.hsplit(x, 2)
[array([0, 1, 2]), array([3, 4, 5])]

`numpy.ma.mr_`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.mr_.html

ma.mr_ = <numpy.ma.extras.mr_class object>

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

这是lib.index_tricks.RClass的掩码数组版本。

另请参阅

lib.index_tricks.RClass

示例

>>> np.ma.mr_[np.ma.array([1,2,3]), 0, 0, np.ma.array([4,5,6])]
masked_array(data=[1, 2, 3, ..., 4, 5, 6],
 mask=False,
 fill_value=999999)

`numpy.ma.row_stack`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.row_stack.html

ma.row_stack = <numpy.ma.extras._fromnxfunction_seq object>

vstack

沿着垂直方向（行）顺序堆叠数组。

这相当于在将形状为(N,)的 1-D 数组重新形状为(1,N)后沿第一个轴进行连接。通过vsplit分割的数组进行重建。

该函数对于最多具有 3 维的数组最有意义。例如，对于具有高度（第一个轴）、宽度（第二个轴）和 r/g/b 通道（第三个轴）的像素数据。函数concatenate、stack和block提供了更一般的堆叠和连接操作。

np.row_stack是vstack的别名。它们是相同的函数。

参数：

tupndarrays 序列

所有数组在除第一个轴以外的所有轴上必须具有相同的形状。 1-D 数组必须具有相同的长度。

dtypestr 或 dtype

如果提供了，目标数组将具有此 dtype。不能与out一起提供。

.. versionadded:: 1.24

casting，可选

控制可能发生的数据转换类型。默认为'same_kind'。

.. versionadded:: 1.24

stackedndarray

由给定数组堆叠而成的数组，至少为 2-D。

另请参阅

concatenate

沿着现有轴连接数组序列。

stack

沿着新轴连接数组序列。

block

从块的嵌套列表中组装一个 nd 数组。

hstack

沿着水平方向（列）顺序堆叠数组。

dstack

沿着第三轴（深度方向）顺序堆叠数组。

column_stack

将 1-D 数组堆叠为列，形成 2-D 数组。

vsplit

将数组沿垂直方向（行）拆分为多个子数组。

注意事项

该函数应用于 _data 和 _mask，如果有的话。

示例

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.vstack((a,b))
array([[1, 2, 3],
 [4, 5, 6]])

>>> a = np.array([[1], [2], [3]])
>>> b = np.array([[4], [5], [6]])
>>> np.vstack((a,b))
array([[1],
 [2],
 [3],
 [4],
 [5],
 [6]])

`numpy.ma.vstack`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.vstack.html

ma.vstack = <numpy.ma.extras._fromnxfunction_seq object>

vstack

沿着垂直方向（按行）堆叠数组。

这相当于在 1-D 形状为(N,)的数组重塑为(1,N)后沿第一个轴进行连接。重建由vsplit分割的数组。

此函数对最多具有 3 维的数组最有意义。例如，对于具有高度（第一个轴）、宽度（第二个轴）和 r/g/b 通道（第三个轴）的像素数据。函数concatenate、stack和block提供了更一般的堆叠和连接操作。

np.row_stack是vstack的别名。它们是相同的函数。

参数：

tupndarrays 序列

所有轴上的形状必须相同。1-D 数组必须具有相同的长度。

dtypestr 或 dtype

如果提供，则目标数组将具有此 dtype。不能与out一起提供。

.. versionadded:: 1.24

casting，可选

控制可能发生的数据转换类型。默认为‘same_kind’。

.. versionadded:: 1.24

stackedndarray

由给定数组堆叠形成的数组，至少为 2-D。

另请参见

concatenate

沿着现有轴连接一系列数组。

stack

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

block

从块的嵌套列表中组装一个 nd-array。

hstack

沿着水平方向（列方向）堆叠数组。

dstack

沿着第三轴深度堆叠数组。

column_stack

将 1-D 数组堆叠为列到 2-D 数组。

vsplit

将数组垂直（按行）拆分为多个子数组。

注意事项

如果有的话，该函数将应用于 _data 和 _mask。

示例

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.vstack((a,b))
array([[1, 2, 3],
 [4, 5, 6]])

>>> a = np.array([[1], [2], [3]])
>>> b = np.array([[4], [5], [6]])
>>> np.vstack((a,b))
array([[1],
 [2],
 [3],
 [4],
 [5],
 [6]])

`numpy.ma.concatenate`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.concatenate.html

ma.concatenate(arrays, axis=0)

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

参数：

arraysarray_like 序列

数组必须具有相同的形状，除了与axis（默认情况下为第一个）对应的维度。

axisint，可选

将要连接的数组的轴。默认为 0。

返回值：

resultMaskedArray

连接后的数组，保留任何掩码条目。

参见

numpy.concatenate

在顶层 NumPy 模块中的等效函数。

示例

>>> import numpy.ma as ma
>>> a = ma.arange(3)
>>> a[1] = ma.masked
>>> b = ma.arange(2, 5)
>>> a
masked_array(data=[0, --, 2],
 mask=[False,  True, False],
 fill_value=999999)
>>> b
masked_array(data=[2, 3, 4],
 mask=False,
 fill_value=999999)
>>> ma.concatenate([a, b])
masked_array(data=[0, --, 2, 2, 3, 4],
 mask=[False,  True, False, False, False, False],
 fill_value=999999)

`numpy.ma.stack`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.stack.html

ma.stack = <numpy.ma.extras._fromnxfunction_seq object>

stack

沿新轴连接一系列数组。

axis参数指定结果维度中新轴的索引。例如，如果axis=0，它将是第一个维度，如果axis=-1，它将是最后一个维度。

新版本 1.10.0 中新增。

参数：

arrays数组序列

每个数组必须具有相同的形状。

axisint，可选

结果数组中沿着输入数组堆叠的轴。

outndarray，可选

如果提供，指定放置结果的目标位置。形状必须正确，与如果未指定 out 参数，则 stack 将返回的形状相匹配。

dtypestr 或 dtype

如果提供，目标数组将具有此 dtype。不能与out一起提供。

新版本 1.24 中新增。

casting，可选

控制可能发生的数据转换类型。默认为‘same_kind’。

新版本 1.24 中新增。

stackedndarray

堆叠的数组比输入数组多一个维度。

另请参阅

concatenate

沿现有轴连接一系列数组。

block

从嵌套块的列表中组装一个 nd-array。

split

将数组拆分为多个相等大小的子数组列表。

注意

如果有，该函数将应用于 _data 和 _mask。

示例

>>> arrays = [np.random.randn(3, 4) for _ in range(10)]
>>> np.stack(arrays, axis=0).shape
(10, 3, 4)

>>> np.stack(arrays, axis=1).shape
(3, 10, 4)

>>> np.stack(arrays, axis=2).shape
(3, 4, 10)

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.stack((a, b))
array([[1, 2, 3],
 [4, 5, 6]])

>>> np.stack((a, b), axis=-1)
array([[1, 4],
 [2, 5],
 [3, 6]])

`numpy.ma.vstack`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.vstack.html

ma.vstack = <numpy.ma.extras._fromnxfunction_seq object>

vstack

沿着序列垂直（按行）堆叠数组。

这相当于在将形状为(N,)的 1-D 数组重塑为(1,N)后沿第一个轴进行串联。通过vsplit重新构建数组。

此函数对最多具有 3 个维度的数组最有意义。例如，对于具有高度（第一个轴）、宽度（第二个轴）和 r/g/b 通道（第三个轴）的像素数据。函数concatenate、stack和block提供了更通用的堆叠和串联操作。

np.row_stack是vstack的别名。它们是相同的函数。

参数：

元组ndarrays 序列

所有轴上的形状必须相同，除了第一个轴。1-D 数组必须具有相同的长度。

数据类型str 或 dtype

如果提供了，目标数组将具有此数据类型。不能与out一起提供。

.. 版本新增:: 1.24

转换，可选

控制可能发生的数据转换类型。默认为‘same_kind’。

.. 版本新增:: 1.24

堆叠ndarray

由给定数组堆叠而成的数组至少为 2-D。

另请参阅

concatenate

沿着现有轴连接一系列数组。

stack

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

block

从嵌套块的列表中组装一个 nd-array。

hstack

沿着序列水平（列）堆叠数组。

dstack

沿着第三个轴深度堆叠数组。

column_stack

将 1-D 数组堆叠为列，形成 2-D 数组。

vsplit

将数组垂直（按行）分割为多个子数组。

注意

如果有的话，该函数将应用于 _data 和 _mask。

示例

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.vstack((a,b))
array([[1, 2, 3],
 [4, 5, 6]])

>>> a = np.array([[1], [2], [3]])
>>> b = np.array([[4], [5], [6]])
>>> np.vstack((a,b))
array([[1],
 [2],
 [3],
 [4],
 [5],
 [6]])

`numpy.ma.hstack`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.hstack.html

ma.hstack = <numpy.ma.extras._fromnxfunction_seq object>

hstack

沿着水平方向（列方向）按顺序堆叠数组。

这相当于沿第二轴的串联，除了 1-D 数组，它沿第一轴串联。重建由hsplit分割的数组。

该函数对最多具有 3 个维度的数组最有意义。例如，对于具有高度（第一轴）、宽度（第二轴）和 r/g/b 通道（第三轴）的像素数据。函数concatenate、stack和block提供更一般的堆叠和串联操作。

参数：

tupndarrays 序列

所有数组在除第二轴外的所有轴上必须具有相同的形状，除了 1-D 数组可以是任意长度。

dtypestr 或 dtype

如果提供，目标数组将具有此 dtype。不能与out一起提供。

.. 版本新增:: 1.24

casting，可选

控制可能发生的数据转换的类型。默认为‘same_kind’。

.. 版本新增:: 1.24

stackedndarray

通过堆叠给定的数组形成的数组。

另请参阅

concatenate

沿着现有轴连接一个数组序列。

stack

沿着新轴连接一个数组序列。

block

从嵌套块的列表中组装一个 nd 数组。

vstack

沿着垂直方向（行方向）按顺序堆叠数组。

dstack

沿着第三轴按顺序堆叠数组。

column_stack

将 1-D 数组堆叠为列到 2-D 数组。

hsplit

将数组水平（列方向）分割为多个子数组。

注意

如果有的话，该函数将应用于 _data 和 _mask。

示例

>>> a = np.array((1,2,3))
>>> b = np.array((4,5,6))
>>> np.hstack((a,b))
array([1, 2, 3, 4, 5, 6])
>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[4],[5],[6]])
>>> np.hstack((a,b))
array([[1, 4],
 [2, 5],
 [3, 6]])

`numpy.ma.dstack`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.dstack.html

ma.dstack = <numpy.ma.extras._fromnxfunction_seq object>

dstack

沿着第三轴对数组进行深度顺序堆叠。

这相当于对形状为(M,N)的 2-D 数组重新整形为(M,N,1)，对形状为(N,)的 1-D 数组重新整形为(1,N,1)，然后在第三轴上进行连接。重建被dsplit分割的数组。

这个函数对于最多包含 3 维的数组是最有意义的。例如，对于具有高度（第一个轴）、宽度（第二个轴）和 r/g/b 通道（第三个轴）的像素数据。函数concatenate、stack和block提供了更普遍的堆叠和连接操作。

参数：

tup数组序列

所有数组除了第三轴外，形状必须相同。1-D 或 2-D 数组必须具有相同的形状。

stackedndarray

堆叠给定数组而形成的数组，至少为 3-D。

参见

concatenate

沿着现有轴连接一系列数组。

stack

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

block

从嵌套的块列表中组装 nd 数组。

vstack

按垂直方向（按行）顺序堆叠数组。

hstack

按水平方向（按列）顺序堆叠数组。

column_stack

将 1-D 数组按列堆叠成 2-D 数组。

dsplit

沿第三轴拆分数组。

注意

如果有的话，该函数将同时应用于数据和掩码。

示例

>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.dstack((a,b))
array([[[1, 2],
 [2, 3],
 [3, 4]]])

>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[2],[3],[4]])
>>> np.dstack((a,b))
array([[[1, 2]],
 [[2, 3]],
 [[3, 4]]])

`numpy.ma.column_stack`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.column_stack.html

ma.column_stack = <numpy.ma.extras._fromnxfunction_seq object>

column_stack

将 1-D 数组堆叠为 2-D 数组的列。

采用 1-D 数组的序列，并将它们堆叠为列，以形成单个 2-D 数组。2-D 数组按原样堆叠，就像使用hstack一样。首先将 1-D 数组转换为 2-D 列。

参数：

tup是 1-D 或 2-D 数组的序列。

数组堆叠。它们都必须具有相同的第一维。

stacked2-D 数组

由给定数组堆叠形成的数组。

另请参见

stack, hstack, vstack, concatenate

注释

如果有的话，该函数适用于 _data 和 _mask。

例子

>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.column_stack((a,b))
array([[1, 2],
 [2, 3],
 [3, 4]])

`numpy.ma.append`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.append.html

ma.append(a, b, axis=None)

在一个数组的末尾附加值。

1.9.0 版新增。

参数：

aarray_like

将值附加到此数组的副本中。

barray_like

这些值被附加到 a 的副本中。它必须具有正确的形状（与 a 的形状相同，不包括 axis）。如果未指定 axis，b 可以是任意形状，在使用之前将被展平。

axisint，可选

v 被附加的轴。如果未给出 axis，a 和 b 将在使用之前被展平。

返回值：

appendMaskedArray

b 附加到 axis 的 a 的副本。注意，append 不是原地操作：它分配和填充一个新数组。如果 axis 为 None，则结果是一个展平的数组。

详见

numpy.append

NumPy 顶层模块中的等效函数。

示例

>>> import numpy.ma as ma
>>> a = ma.masked_values([1, 2, 3], 2)
>>> b = ma.masked_values([[4, 5, 6], [7, 8, 9]], 7)
>>> ma.append(a, b)
masked_array(data=[1, --, 3, 4, 5, 6, --, 8, 9],
 mask=[False,  True, False, False, False, False,  True, False,
 False],
 fill_value=999999)

`numpy.ma.make_mask`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.make_mask.html

ma.make_mask(m, copy=False, shrink=True, dtype=<class 'numpy.bool_'>)

从数组创建一个布尔掩码。

将m转换为布尔掩码，如果需要或请求，则创建副本。该函数可以接受任何可转换为整数或nomask的序列。不要求内容必须为 0 和 1，值为 0 被解释为 False，其他值被解释为 True。

参数:

marray_like

潜在的掩码。

copybool，可选

是否返回m的副本（True）或m本身（False）。

shrinkbool，可选

如果m的所有值都为 False，是否将m收缩为nomask。

dtypedtype，可选

输出掩码的数据类型。默认情况下，输出掩码具有 MaskType（bool）的数据类型。如果数据类型是灵活的，则每个字段都具有布尔数据类型。当m为nomask时，此选项将被忽略，此时将始终返回nomask。

返回值:

resultndarray

从m派生的布尔掩码。

示例

>>> import numpy.ma as ma
>>> m = [True, False, True, True]
>>> ma.make_mask(m)
array([ True, False,  True,  True])
>>> m = [1, 0, 1, 1]
>>> ma.make_mask(m)
array([ True, False,  True,  True])
>>> m = [1, 0, 2, -3]
>>> ma.make_mask(m)
array([ True, False,  True,  True])

shrink参数的效果。

>>> m = np.zeros(4)
>>> m
array([0., 0., 0., 0.])
>>> ma.make_mask(m)
False
>>> ma.make_mask(m, shrink=False)
array([False, False, False, False])

使用灵活的dtype。

>>> m = [1, 0, 1, 1]
>>> n = [0, 1, 0, 0]
>>> arr = []
>>> for man, mouse in zip(m, n):
...     arr.append((man, mouse))
>>> arr
[(1, 0), (0, 1), (1, 0), (1, 0)]
>>> dtype = np.dtype({'names':['man', 'mouse'],
...                   'formats':[np.int64, np.int64]})
>>> arr = np.array(arr, dtype=dtype)
>>> arr
array([(1, 0), (0, 1), (1, 0), (1, 0)],
 dtype=[('man', '<i8'), ('mouse', '<i8')])
>>> ma.make_mask(arr, dtype=dtype)
array([(True, False), (False, True), (True, False), (True, False)],
 dtype=[('man', '|b1'), ('mouse', '|b1')])

`numpy.ma.make_mask_none`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.make_mask_none.html

ma.make_mask_none(newshape, dtype=None)

返回一个给定形状、填充有 False 的布尔掩码。

此函数返回一个所有条目均为 False 的布尔 ndarray，可用于常见的掩码操作。如果指定了复杂 dtype，则每个字段的类型都会转换为布尔类型。

参数：

newshape元组

一个指示掩码形状的元组。

dtype {None, dtype}，可选

如果没有，使用一个 MaskType 实例。否则，使用与dtype相同字段的新数据类型，转换为布尔类型。

result ndarray

一个适当形状和 dtype 的 ndarray，填充有 False。

另请参见

make_mask

从数组创建一个布尔遮罩。

制作遮罩描述

从给定的 dtype 构造一个 dtype 描述列表。

示例

>>> import numpy.ma as ma
>>> ma.make_mask_none((3,))
array([False, False, False])

定义一个更复杂的 dtype。

>>> dtype = np.dtype({'names':['foo', 'bar'],
...                   'formats':[np.float32, np.int64]})
>>> dtype
dtype([('foo', '<f4'), ('bar', '<i8')])
>>> ma.make_mask_none((3,), dtype=dtype)
array([(False, False), (False, False), (False, False)],
 dtype=[('foo', '|b1'), ('bar', '|b1')])

`numpy.ma.mask_or`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.mask_or.html

ma.mask_or(m1, m2, copy=False, shrink=True)

用logical_or运算符合并两个掩码。

如果另一个是nomask（即 False），则结果可以是m1或m2的视图。

参数：

m1, m2类似数组

输入掩码。

复制bool，可选

如果 copy 为 False 并且输入的一个是nomask，则返回另一个输入掩码的视图。默认为 False。

缩小bool，可选

所有值都是 False 时，是否将输出缩小到nomask。默认为 True。

掩码输出掩码

结果掩码值是m1或m2中任一掩码的值。

异常：

ValueError

如果m1和m2具有不同的灵活数据类型。

示例

>>> m1 = np.ma.make_mask([0, 1, 1, 0])
>>> m2 = np.ma.make_mask([1, 0, 0, 0])
>>> np.ma.mask_or(m1, m2)
array([ True,  True,  True, False])

`numpy.ma.make_mask_descr`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.make_mask_descr.html

ma.make_mask_descr(ndtype)

从给定的数据类型构建数据类型描述列表。

返回一个新的数据类型对象，将ndtype中所有字段的类型更改为布尔类型。字段名称不会改变。

参数：

ndtypedtype

要转换的数据类型。

resultdtype

类似于ndtype的数据类型，所有字段的类型都是布尔类型。

示例

>>> import numpy.ma as ma
>>> dtype = np.dtype({'names':['foo', 'bar'],
...                   'formats':[np.float32, np.int64]})
>>> dtype
dtype([('foo', '<f4'), ('bar', '<i8')])
>>> ma.make_mask_descr(dtype)
dtype([('foo', '|b1'), ('bar', '|b1')])
>>> ma.make_mask_descr(np.float32)
dtype('bool')

`numpy.ma.getmask`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.getmask.html

ma.getmask(a)

返回掩模数组的掩模，或者nomask。

如果a是MaskedArray且掩模不是nomask，则返回a的掩模作为 ndarray，否则返回nomask。要保证与a形状相同的完整布尔数组，请使用getmaskarray。

参数：

a类似数组

需要掩模的MaskedArray输入。

另请参阅

getdata

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

getmaskarray

返回掩模数组的掩模，或者完整的 False 数组。

示例

>>> import numpy.ma as ma
>>> a = ma.masked_equal([[1,2],[3,4]], 2)
>>> a
masked_array(
 data=[[1, --],
 [3, 4]],
 mask=[[False,  True],
 [False, False]],
 fill_value=2)
>>> ma.getmask(a)
array([[False,  True],
 [False, False]])

或者使用MaskedArray的mask属性。

>>> a.mask
array([[False,  True],
 [False, False]])

当掩模为nomask时的结果

>>> b = ma.masked_array([[1,2],[3,4]])
>>> b
masked_array(
 data=[[1, 2],
 [3, 4]],
 mask=False,
 fill_value=999999)
>>> ma.nomask
False
>>> ma.getmask(b) == ma.nomask
True
>>> b.mask == ma.nomask
True

`numpy.ma.getmaskarray`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.getmaskarray.html

ma.getmaskarray(arr)

返回掩码数组的掩码，或者完整的布尔数组，全为 False。

如果 arr 是一个 MaskedArray，并且掩码不是 nomask，则将 arr 的掩码返回为一个 ndarray；否则返回与 arr 相同形状的全为 False 的完整布尔数组。

参数：

arrarray_like

需要掩码的 MaskedArray 输入。

另请参见

getmask

返回掩码数组的掩码，或者 nomask。

getdata

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

示例

>>> import numpy.ma as ma
>>> a = ma.masked_equal([[1,2],[3,4]], 2)
>>> a
masked_array(
 data=[[1, --],
 [3, 4]],
 mask=[[False,  True],
 [False, False]],
 fill_value=2)
>>> ma.getmaskarray(a)
array([[False,  True],
 [False, False]])

掩码等于 nomask 时的结果

>>> b = ma.masked_array([[1,2],[3,4]])
>>> b
masked_array(
 data=[[1, 2],
 [3, 4]],
 mask=False,
 fill_value=999999)
>>> ma.getmaskarray(b)
array([[False, False],
 [False, False]])

`numpy.ma.masked_array.mask`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.masked_array.mask.html

属性

property ma.masked_array.mask

当前的掩码。

`numpy.ma.ndenumerate`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.ndenumerate.html

ma.ndenumerate(a, compressed=True)

多维索引迭代器。

返回一个迭代器，产生数组坐标和值的对，跳过被掩码的元素。使用 compressed=False，ma.masked 被产生为被掩码的元素的值。此行为与numpy.ndenumerate不同，后者产生基础数据数组的值。

参数：

aarray_like

一个包含（可能）掩码元素的数组。

compressedbool, 可选的

如果为 True（默认），则跳过掩码元素。

参见

numpy.ndenumerate

忽略任何掩码的等效函数。

注意

从版本 1.23.0 开始的新内容。

示例

>>> a = np.ma.arange(9).reshape((3, 3))
>>> a[1, 0] = np.ma.masked
>>> a[1, 2] = np.ma.masked
>>> a[2, 1] = np.ma.masked
>>> a
masked_array(
 data=[[0, 1, 2],
 [--, 4, --],
 [6, --, 8]],
 mask=[[False, False, False],
 [ True, False,  True],
 [False,  True, False]],
 fill_value=999999)
>>> for index, x in np.ma.ndenumerate(a):
...     print(index, x)
(0, 0) 0
(0, 1) 1
(0, 2) 2
(1, 1) 4
(2, 0) 6
(2, 2) 8

>>> for index, x in np.ma.ndenumerate(a, compressed=False):
...     print(index, x)
(0, 0) 0
(0, 1) 1
(0, 2) 2
(1, 0) --
(1, 1) 4
(1, 2) --
(2, 0) 6
(2, 1) --
(2, 2) 8

`numpy.ma.flatnotmasked_contiguous`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.flatnotmasked_contiguous.html

ma.flatnotmasked_contiguous(a)

在屏蔽数组中找到连续未屏蔽的数据。

参数:

aarray_like

输入数组。

slice_listlist

一系列已排序的slice对象（起始索引，结束索引）。

在 1.15.0 版本中更改: 现在对于完全屏蔽的数组，返回空列表而不是 None

另请参阅

flatnotmasked_edges, notmasked_contiguous, notmasked_edges

clump_masked, clump_unmasked

注释

最多只接受 2-D 数组。

例子

>>> a = np.ma.arange(10)
>>> np.ma.flatnotmasked_contiguous(a)
[slice(0, 10, None)]

>>> mask = (a < 3) | (a > 8) | (a == 5)
>>> a[mask] = np.ma.masked
>>> np.array(a[~a.mask])
array([3, 4, 6, 7, 8])

>>> np.ma.flatnotmasked_contiguous(a)
[slice(3, 5, None), slice(6, 9, None)]
>>> a[:] = np.ma.masked
>>> np.ma.flatnotmasked_contiguous(a)
[]

`numpy.ma.flatnotmasked_edges`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.flatnotmasked_edges.html

ma.flatnotmasked_edges(a)

找到数组中第一个和最后一个非屏蔽值的索引。

预期是 1-D MaskedArray，如果所有值都被屏蔽，则返回 None。

参数：

aarray_like

输入 1-D MaskedArray

edgesndarray 或 None

数组中第一个和最后一个非屏蔽值的索引。如果所有值都被屏蔽，则返回 None。

参见

flatnotmasked_contiguous, notmasked_contiguous, notmasked_edges

clump_masked, clump_unmasked

注释

仅接受 1-D 数组。

示例

>>> a = np.ma.arange(10)
>>> np.ma.flatnotmasked_edges(a)
array([0, 9])

>>> mask = (a < 3) | (a > 8) | (a == 5)
>>> a[mask] = np.ma.masked
>>> np.array(a[~a.mask])
array([3, 4, 6, 7, 8])

>>> np.ma.flatnotmasked_edges(a)
array([3, 8])

>>> a[:] = np.ma.masked
>>> print(np.ma.flatnotmasked_edges(a))
None

`numpy.ma.notmasked_contiguous`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.notmasked_contiguous.html

ma.notmasked_contiguous(a, axis=None)

在给定轴上查找掩蔽数组中的连续未屏蔽数据。

参数：

a类似数组

输入数组。

axis整数，可选

执行操作的轴。如果为 None（默认值），则应用于数组的平坦版本，这与flatnotmasked_contiguous相同。

endpoints列表

数组中未屏蔽索引的切片（起始索引和结束索引）列表。

如果输入为 2 维且指定了 axis，则结果为列表的列表。

另请参阅

flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges

clump_masked, clump_unmasked

注释

最多接受 2-D 数组。

示例

>>> a = np.arange(12).reshape((3, 4))
>>> mask = np.zeros_like(a)
>>> mask[1:, :-1] = 1; mask[0, 1] = 1; mask[-1, 0] = 0
>>> ma = np.ma.array(a, mask=mask)
>>> ma
masked_array(
 data=[[0, --, 2, 3],
 [--, --, --, 7],
 [8, --, --, 11]],
 mask=[[False,  True, False, False],
 [ True,  True,  True, False],
 [False,  True,  True, False]],
 fill_value=999999)
>>> np.array(ma[~ma.mask])
array([ 0,  2,  3,  7, 8, 11])

>>> np.ma.notmasked_contiguous(ma)
[slice(0, 1, None), slice(2, 4, None), slice(7, 9, None), slice(11, 12, None)]

>>> np.ma.notmasked_contiguous(ma, axis=0)
[[slice(0, 1, None), slice(2, 3, None)], [], [slice(0, 1, None)], [slice(0, 3, None)]]

>>> np.ma.notmasked_contiguous(ma, axis=1)
[[slice(0, 1, None), slice(2, 4, None)], [slice(3, 4, None)], [slice(0, 1, None), slice(3, 4, None)]]

`numpy.ma.notmasked_edges`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.notmasked_edges.html

ma.notmasked_edges(a, axis=None)

查找沿轴的第一个和最后一个未屏蔽值的索引。

如果所有值都被屏蔽，则返回 None。否则，返回包含两个元组的列表，分别对应第一个和最后一个未屏蔽值的索引。

参数：

aarray_like

输入数组。

axisint，可选

进行操作的轴。如果为 None（默认），则应用于数组的展平版本。

edgesndarray 或列表

如果数组中有任何掩码数据，则返回开始和结束索引的数组。如果数组中没有掩码数据，则edges是第一个和最后一个索引的列表。

另请参阅

flatnotmasked_contiguous, flatnotmasked_edges, notmasked_contiguous

clump_masked, clump_unmasked

示例

>>> a = np.arange(9).reshape((3, 3))
>>> m = np.zeros_like(a)
>>> m[1:, 1:] = 1

>>> am = np.ma.array(a, mask=m)
>>> np.array(am[~am.mask])
array([0, 1, 2, 3, 6])

>>> np.ma.notmasked_edges(am)
array([0, 6])

`numpy.ma.clump_masked`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.clump_masked.html

ma.clump_masked(a)

返回一个与 1-D 数组中掩码簇对应的切片列表。（“簇”被定义为数组的连续区域）。

参数：

a ndarray

一个一维掩码数组。

slices 切片列表

为 a 中每个连续的掩码元素区域提供切片列表。

请参阅

flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges

notmasked_contiguous, clump_unmasked

注意

在版本 1.4.0 中新增。

示例

>>> a = np.ma.masked_array(np.arange(10))
>>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked
>>> np.ma.clump_masked(a)
[slice(0, 3, None), slice(6, 7, None), slice(8, 10, None)]

`numpy.ma.clump_unmasked`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.clump_unmasked.html

ma.clump_unmasked(a)

返回与一维数组中未遮罩的聚类对应的切片列表（“聚类”被定义为数组的连续区域）。

参数：

andarray

一个一维掩码数组。

slices切片列表

切片列表，每个未遮罩元素的连续区域对应一个切片。

参见

flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges

notmasked_contiguous, clump_masked

注意

新版本 1.4.0 中新增。

示例

>>> a = np.ma.masked_array(np.arange(10))
>>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked
>>> np.ma.clump_unmasked(a)
[slice(3, 6, None), slice(7, 8, None)]

`numpy.ma.mask_cols`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.mask_cols.html

ma.mask_cols(a, axis=<no value>)

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

此函数是mask_rowcols的快捷方式，axis等于 1。

另请参阅

mask_rowcols

掩盖二维数组的行和/或列。

masked_where

满足条件的掩码。

例子

>>> import numpy.ma as ma
>>> a = np.zeros((3, 3), dtype=int)
>>> a[1, 1] = 1
>>> a
array([[0, 0, 0],
 [0, 1, 0],
 [0, 0, 0]])
>>> a = ma.masked_equal(a, 1)
>>> a
masked_array(
 data=[[0, 0, 0],
 [0, --, 0],
 [0, 0, 0]],
 mask=[[False, False, False],
 [False,  True, False],
 [False, False, False]],
 fill_value=1)
>>> ma.mask_cols(a)
masked_array(
 data=[[0, --, 0],
 [0, --, 0],
 [0, --, 0]],
 mask=[[False,  True, False],
 [False,  True, False],
 [False,  True, False]],
 fill_value=1)

`numpy.ma.mask_or`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.mask_or.html

ma.mask_or(m1, m2, copy=False, shrink=True)

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

如果另一个是nomask（即 False），则结果可能是m1或m2的视图。

参数：

m1, m2array_like

输入掩码。

copybool, optional

如果 copy 为 False，并且输入中的一个是nomask，则返回另一个输入掩码的视图。默认为 False。

shrinkbool, optional

是否将输出缩小到nomask，如果其所有值都为 False。默认为 True。

mask输出掩码

结果掩码值被屏蔽在m1或m2中的任一者中。

引发：

ValueError

如果m1和m2具有不同的灵活数据类型。

示例

>>> m1 = np.ma.make_mask([0, 1, 1, 0])
>>> m2 = np.ma.make_mask([1, 0, 0, 0])
>>> np.ma.mask_or(m1, m2)
array([ True,  True,  True, False])

`numpy.ma.mask_rowcols`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.mask_rowcols.html

ma.mask_rowcols(a, axis=None)

掩码包含被掩码值的 2D 数组的行和/或列。

掩码包含被掩码值的 2D 数组的整行和/或整列。使用axis参数选择掩码行为。

如果axis为 None，则行和列都被掩码。

如果axis为 0，则只有行被掩码。

如果axis为 1 或-1，则只有列被掩码。

参数：

aarray_like，MaskedArray

要进行掩码的数组。如果不是 MaskedArray 实例（或如果没有数组元素被掩码），则结果是一个mask设置为nomask（False）的 MaskedArray。必须是一个 2D 数组。

axisint，可选

执行操作的轴。如果为 None，则应用于数组的扁平版本。

aMaskedArray

输入数组的修改版本，取决于axis参数的值。

引发：

未实现错误

如果输入数组a不是 2D。

另请参阅

mask_rows

掩码包含被掩码值的 2D 数组的行。

mask_cols

掩码包含被掩码值的 2D 数组的列。

masked_where

满足条件时进行掩码。

注意事项

该函数修改了输入数组的掩码。

示例

>>> import numpy.ma as ma
>>> a = np.zeros((3, 3), dtype=int)
>>> a[1, 1] = 1
>>> a
array([[0, 0, 0],
 [0, 1, 0],
 [0, 0, 0]])
>>> a = ma.masked_equal(a, 1)
>>> a
masked_array(
 data=[[0, 0, 0],
 [0, --, 0],
 [0, 0, 0]],
 mask=[[False, False, False],
 [False,  True, False],
 [False, False, False]],
 fill_value=1)
>>> ma.mask_rowcols(a)
masked_array(
 data=[[0, --, 0],
 [--, --, --],
 [0, --, 0]],
 mask=[[False,  True, False],
 [ True,  True,  True],
 [False,  True, False]],
 fill_value=1)

`numpy.ma.mask_rows`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.mask_rows.html

ma.mask_rows(a, axis=<no value>)

遮蔽包含遮蔽值的 2D 数组的行。

此函数是将mask_rowcols的* axis *快捷方式设置为 0。

请参见

mask_rowcols

遮蔽 2D 数组的行和/或列。

masked_where

遮蔽条件满足的地方。

例子

>>> import numpy.ma as ma
>>> a = np.zeros((3, 3), dtype=int)
>>> a[1, 1] = 1
>>> a
array([[0, 0, 0],
 [0, 1, 0],
 [0, 0, 0]])
>>> a = ma.masked_equal(a, 1)
>>> a
masked_array(
 data=[[0, 0, 0],
 [0, --, 0],
 [0, 0, 0]],
 mask=[[False, False, False],
 [False,  True, False],
 [False, False, False]],
 fill_value=1)

>>> ma.mask_rows(a)
masked_array(
 data=[[0, 0, 0],
 [--, --, --],
 [0, 0, 0]],
 mask=[[False, False, False],
 [ True,  True,  True],
 [False, False, False]],
 fill_value=1)

`numpy.ma.harden_mask`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.harden_mask.html

ma.harden_mask(self) = <numpy.ma.core._frommethod object>

将掩码硬化，防止被赋值时解除掩码。

掩码数组的掩码是硬还是软取决于其hardmask属性。 harden_mask将hardmask设置为True（并返回修改后的自身）。

另请参阅

ma.MaskedArray.hardmask

ma.MaskedArray.soften_mask

`numpy.ma.soften_mask`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.soften_mask.html

ma.soften_mask(self) = <numpy.ma.core._frommethod object>

强制使掩码变软（默认），允许通过赋值取消遮罩。

掩码数组的遮罩是硬性还是软性，取决于其 hardmask 属性。soften_mask 将 hardmask 设置为 False（并返回修改后的自身）。

参见

ma.MaskedArray.hardmask

ma.MaskedArray.harden_mask

`numpy.ma.MaskedArray.harden_mask`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.harden_mask.html

方法

ma.MaskedArray.harden_mask()

将掩码强制转换为硬掩码，防止赋值解码。

掩码数组的掩码是硬掩码还是软掩码由其hardmask属性确定。harden_mask设置hardmask为True（并返回修改后的自身）。

请参阅

ma.MaskedArray.hardmask

ma.MaskedArray.soften_mask

`numpy.ma.MaskedArray.soften_mask`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.soften_mask.html

方法

ma.MaskedArray.soften_mask()

强制将掩码设为软性（默认），允许通过赋值来取消掩码。

掩码数组的掩码是硬性还是软性取决于其hardmask属性。soften_mask将hardmask设为False（并返回修改后的自身）。

请参阅

ma.MaskedArray.hardmask

ma.MaskedArray.harden_mask

`numpy.ma.MaskedArray.shrink_mask`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.shrink_mask.html

方法

ma.MaskedArray.shrink_mask()

当可能时将掩码减少为无掩码。

参数：

无

示例

>>> x = np.ma.array([[1,2 ], [3, 4]], mask=[0]*4)
>>> x.mask
array([[False, False],
 [False, False]])
>>> x.shrink_mask()
masked_array(
 data=[[1, 2],
 [3, 4]],
 mask=False,
 fill_value=999999)
>>> x.mask
False

`numpy.ma.MaskedArray.unshare_mask`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.unshare_mask.html

方法

ma.MaskedArray.unshare_mask()

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

掩码是否在遮蔽数组之间共享可以从sharedmask属性中看出。unshare_mask确保掩码不共享。只有在掩码共享时才会复制掩码。

参见

sharedmask

`numpy.ma.asarray`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.asarray.html

ma.asarray(a, dtype=None, order=None)

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

如果输入已经是一个ndarray，则不执行复制操作。如果a是MaskedArray的子类，则返回基类MaskedArray。

参数：

aarray_like

以任何可以转换为掩码数组的形式的输入数据。这包括列表、元组列表、元组、元组的元组、元组的列表、ndarrays 和掩码数组。

dtypedtype，可选

默认情况下，数据类型是从输入数据推断出来的。

order，可选

是否使用行优先（‘C’）或列优先（‘FORTRAN’）的内存表示。默认为‘C’。

outMaskedArray

对a的掩码数组解释。

另请参见

asanyarray

类似于asarray，但保留子类。

示例

>>> x = np.arange(10.).reshape(2, 5)
>>> x
array([[0., 1., 2., 3., 4.],
 [5., 6., 7., 8., 9.]])
>>> np.ma.asarray(x)
masked_array(
 data=[[0., 1., 2., 3., 4.],
 [5., 6., 7., 8., 9.]],
 mask=False,
 fill_value=1e+20)
>>> type(np.ma.asarray(x))
<class 'numpy.ma.core.MaskedArray'>

`numpy.ma.asanyarray`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.asanyarray.html

ma.asanyarray(a, dtype=None)

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

如果a是MaskedArray的子类，则保留其类。如果输入已经是ndarray，则不执行复制。

参数：

a类数组

任何可以转换为数组的形式的输入数据。

dtypedtype，可选

默认情决与输入数据推断数据类型。

order，可选

是否使用行主要（‘C’）或列主要（‘FORTRAN’）内存表示。默认为‘C’。

outMaskedArray

a的掩码数组解释。

另请参阅

asarray

类似于asanyarray，但不保留子类。

示例

>>> x = np.arange(10.).reshape(2, 5)
>>> x
array([[0., 1., 2., 3., 4.],
 [5., 6., 7., 8., 9.]])
>>> np.ma.asanyarray(x)
masked_array(
 data=[[0., 1., 2., 3., 4.],
 [5., 6., 7., 8., 9.]],
 mask=False,
 fill_value=1e+20)
>>> type(np.ma.asanyarray(x))
<class 'numpy.ma.core.MaskedArray'>

`numpy.ma.fix_invalid`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.fix_invalid.html

ma.fix_invalid(a, mask=False, copy=True, fill_value=None)

以填充值掩盖和替换无效数据的输入。

无效数据表示nan，inf等的值。

参数：

a类似数组

输入数组，a（ndarray 的子类）。

掩码序列，可选

Mask。必须转换为与数据相同形状的布尔数组。True 表示掩码（即无效）数据。

复制bool，可选

是否使用a的副本（True）或在原地修复a（False）。默认为 True。

填充值标量，可选

用于修正无效数据的值。默认为 None，此时使用a.fill_value。

b掩码数组

输入数组中无效条目已被修复。

注

默认情况下执行复制。

示例

>>> x = np.ma.array([1., -1, np.nan, np.inf], mask=[1] + [0]*3)
>>> x
masked_array(data=[--, -1.0, nan, inf],
 mask=[ True, False, False, False],
 fill_value=1e+20)
>>> np.ma.fix_invalid(x)
masked_array(data=[--, -1.0, --, --],
 mask=[ True, False,  True,  True],
 fill_value=1e+20)

>>> fixed = np.ma.fix_invalid(x)
>>> fixed.data
array([ 1.e+00, -1.e+00,  1.e+20,  1.e+20])
>>> x.data
array([ 1., -1., nan, inf])

`numpy.ma.masked_equal`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.masked_equal.html

ma.masked_equal(x, value, copy=True)

屏蔽数组中等于给定值的部分。

返回一个 MaskedArray，其中 array x中的数据等于value时被屏蔽。返回的 MaskedArray 的 fill_value 设置为value。

对于浮点数数组，考虑使用masked_values(x, value)。

另请参阅

masked_where

满足条件时进行屏蔽。

masked_values

使用浮点数相等进行屏蔽。

示例

>>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_equal(a, 2)
masked_array(data=[0, 1, --, 3],
 mask=[False, False,  True, False],
 fill_value=2)

`numpy.ma.masked_greater`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.masked_greater.html

ma.masked_greater(x, value, copy=True)

当大于给定值时，屏蔽数组。

这个函数是masked_where的快捷方式，其中condition = (x > value)。

参见

masked_where

当满足条件时进行屏蔽。

例子

>>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_greater(a, 2)
masked_array(data=[0, 1, 2, --],
 mask=[False, False, False,  True],
 fill_value=999999)

`numpy.ma.masked_greater_equal`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.masked_greater_equal.html

ma.masked_greater_equal(x, value, copy=True)

屏蔽数组中大于等于给定值的部分。

这个函数是masked_where的快捷方式，condition = (x >= value)。

另请参阅

masked_where

在满足条件时进行屏蔽。

举例

>>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_greater_equal(a, 2)
masked_array(data=[0, 1, --, --],
 mask=[False, False,  True,  True],
 fill_value=999999)

`numpy.ma.masked_inside`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.masked_inside.html

ma.masked_inside(x, v1, v2, copy=True)

在给定区间内遮盖数组。

masked_where的快捷方式，其中condition对于在区间[v1,v2]内的x为 True（v1 <= x <= v2）。边界v1和v2可以以任何顺序给出。

请参阅

masked_where

在满足条件的地方进行遮盖。

注释

数组x已使用其填充值预先填充。

示例

>>> import numpy.ma as ma
>>> x = [0.31, 1.2, 0.01, 0.2, -0.4, -1.1]
>>> ma.masked_inside(x, -0.3, 0.3)
masked_array(data=[0.31, 1.2, --, --, -0.4, -1.1],
 mask=[False, False,  True,  True, False, False],
 fill_value=1e+20)

v1和v2的顺序不重要。

>>> ma.masked_inside(x, 0.3, -0.3)
masked_array(data=[0.31, 1.2, --, --, -0.4, -1.1],
 mask=[False, False,  True,  True, False, False],
 fill_value=1e+20)

`numpy.ma.masked_invalid`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.masked_invalid.html

ma.masked_invalid(a, copy=True)

在出现无效值（NaNs 或 infs）的情况下对数组进行掩码。

这个函数是masked_where的快捷方式，其中condition = ~(np.isfinite(a))。任何预先存在的掩码都会被保留。仅适用于具有 NaNs 或 infs 意义的 dtype 的数组（即浮点类型），但接受任何 array_like 对象。

另请参阅

masked_where

当条件满足时进行掩码。

示例

>>> import numpy.ma as ma
>>> a = np.arange(5, dtype=float)
>>> a[2] = np.NaN
>>> a[3] = np.PINF
>>> a
array([ 0.,  1., nan, inf,  4.])
>>> ma.masked_invalid(a)
masked_array(data=[0.0, 1.0, --, --, 4.0],
 mask=[False, False,  True,  True, False],
 fill_value=1e+20)

`numpy.ma.masked_less`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.masked_less.html

ma.masked_less(x, value, copy=True)

在小于给定值的情况下对数组进行屏蔽。

此函数是masked_where的快捷方式，条件为 (x < value)。

另请参见

masked_where

满足条件时进行屏蔽。

示例

>>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_less(a, 2)
masked_array(data=[--, --, 2, 3],
 mask=[ True,  True, False, False],
 fill_value=999999)

`numpy.ma.masked_less_equal`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.masked_less_equal.html

ma.masked_less_equal(x, value, copy=True)

当数组中的元素小于或等于给定值时，掩盖数组。

该函数是masked_where的快捷方式，condition = (x <= value)。

另请参阅

masked_where

满足条件时掩盖。

示例

>>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_less_equal(a, 2)
masked_array(data=[--, --, --, 3],
 mask=[ True,  True,  True, False],
 fill_value=999999)

`numpy.ma.masked_not_equal`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.masked_not_equal.html

ma.masked_not_equal(x, value, copy=True)

对于不等于给定值的数组进行掩码。

这个函数是masked_where的快捷方式，条件=(x != value)。

参见

masked_where

使用条件满足的掩码。

示例

>>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_not_equal(a, 2)
masked_array(data=[--, --, 2, --],
 mask=[ True,  True, False,  True],
 fill_value=999999)

`numpy.ma.masked_object`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.masked_object.html

ma.masked_object(x, value, copy=True, shrink=True)

在数据完全等于值的情况下对数组 x 进行掩码。

该函数类似于masked_values，但仅适用于对象数组: 对于浮点数，应改用masked_values。

参数：

x类似数组

要掩码的数组

value对象

比较值

copy, 可选

是否返回 x 的副本。

shrink, 可选

是否将充满 False 的掩码折叠为 nomask

resultMaskedArray

在等于 value 的情况下对 x 进行掩码的结果。

另请参阅

masked_where (链接 "numpy.ma.masked_where")

符合条件的掩码。

masked_equal (链接 "numpy.ma.masked_equal")

符合给定值（整数）的掩码。

masked_values (链接 "numpy.ma.masked_values")

通过浮点数相等性进行掩码。

示例

>>> import numpy.ma as ma
>>> food = np.array(['green_eggs', 'ham'], dtype=object)
>>> # don't eat spoiled food
>>> eat = ma.masked_object(food, 'green_eggs')
>>> eat
masked_array(data=[--, 'ham'],
 mask=[ True, False],
 fill_value='green_eggs',
 dtype=object)
>>> # plain ol` ham is boring
>>> fresh_food = np.array(['cheese', 'ham', 'pineapple'], dtype=object)
>>> eat = ma.masked_object(fresh_food, 'green_eggs')
>>> eat
masked_array(data=['cheese', 'ham', 'pineapple'],
 mask=False,
 fill_value='green_eggs',
 dtype=object)

请注意，如果可能，mask 设置为 nomask。

>>> eat
masked_array(data=['cheese', 'ham', 'pineapple'],
 mask=False,
 fill_value='green_eggs',
 dtype=object)

`numpy.ma.masked_outside`

numpy.org/doc/1.26/reference/generated/numpy.ma.masked_outside.html

ma.masked_outside(x, v1, v2, copy=True)

在给定区间之外对数组进行蒙版。

masked_where的快捷方式，其中condition对于区间[v1,v2]之外的x为真（x < v1)|(x > v2）。边界值v1和v2可以以任何顺序给出。

参见

masked_where

满足条件的地方进行蒙版。

笔记

数组x已填满其填充值。

示例

>>> import numpy.ma as ma
>>> x = [0.31, 1.2, 0.01, 0.2, -0.4, -1.1]
>>> ma.masked_outside(x, -0.3, 0.3)
masked_array(data=[--, --, 0.01, 0.2, --, --],
 mask=[ True,  True, False, False,  True,  True],
 fill_value=1e+20)

v1和v2的顺序无关紧要。

>>> ma.masked_outside(x, 0.3, -0.3)
masked_array(data=[--, --, 0.01, 0.2, --, --],
 mask=[ True,  True, False, False,  True,  True],
 fill_value=1e+20)

`numpy.ma.masked_values`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.masked_values.html

ma.masked_values(x, value, rtol=1e-05, atol=1e-08, copy=True, shrink=True)

使用浮点数相等性进行掩码。

返回一个 MaskedArray，在其中使用isclose确定数组x中的数据value与value近似相等的位置被标记为掩码。masked_values的默认容差与isclose相同。

对于整数类型，使用精确相等性，就像masked_equal一样。

如果有可能，将填充值设置为value，掩码设置为nomask。

参数：

xarray_like

要掩码的数组。

valuefloat

掩码值。

rtol, atolfloat, optional

传递给isclose的容差参数。

copybool, optional

是否返回x的副本。

shrinkbool, optional

是否将一个全为 False 的掩码折叠为nomask。

resultMaskedArray

掩码 x，与value近似相等的位置将被标记。

另请参见

masked_where

满足条件时的掩码。

masked_equal

与给定值相等时的掩码（整数）。

示例

>>> import numpy.ma as ma
>>> x = np.array([1, 1.1, 2, 1.1, 3])
>>> ma.masked_values(x, 1.1)
masked_array(data=[1.0, --, 2.0, --, 3.0],
 mask=[False,  True, False,  True, False],
 fill_value=1.1)

如果有可能，注意将mask设置为nomask。

>>> ma.masked_values(x, 2.1)
masked_array(data=[1\. , 1.1, 2\. , 1.1, 3\. ],
 mask=False,
 fill_value=2.1)

与masked_equal不同，masked_values可以进行近似相等性比较。

>>> ma.masked_values(x, 2.1, atol=1e-1)
masked_array(data=[1.0, 1.1, --, 1.1, 3.0],
 mask=[False, False,  True, False, False],
 fill_value=2.1)

`numpy.ma.masked_where`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.masked_where.html

ma.masked_where(condition, a, copy=True)

满足条件时进行掩盖的数组。

返回在condition为 True 处对a进行掩盖的数组。a或condition的任何掩码值也会在输出中被掩盖。

参数：

conditionarray_like

掩盖条件。当condition测试浮点值是否相等时，考虑使用masked_values。

aarray_like

要进行掩盖的数组。

copybool

如果为 True（默认值），则在结果中复制a。如果为 False，则在原位修改a并返回一个视图。

resultMaskedArray

在condition为 True 时对a进行掩盖的结果。

另请参见

masked_values

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

masked_equal

在等于给定值的地方进行掩盖。

masked_not_equal

掩盖不等于给定值的地方。

masked_less_equal

在小于或等于给定值的地方进行掩盖。

masked_greater_equal

在大于或等于给定值的地方进行掩盖。

masked_less

在小于给定值的地方进行掩盖。

masked_greater

在大于给定值的地方进行掩盖。

masked_inside

在给定区间内进行掩盖。

masked_outside

在给定区间之外进行掩盖。

masked_invalid

掩盖无效值（NaN 或 infs）。

示例

>>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_where(a <= 2, a)
masked_array(data=[--, --, --, 3],
 mask=[ True,  True,  True, False],
 fill_value=999999)

在满足a条件的情况下对数组b进行掩盖。

>>> b = ['a', 'b', 'c', 'd']
>>> ma.masked_where(a == 2, b)
masked_array(data=['a', 'b', --, 'd'],
 mask=[False, False,  True, False],
 fill_value='N/A',
 dtype='<U1')

copy参数的影响。

>>> c = ma.masked_where(a <= 2, a)
>>> c
masked_array(data=[--, --, --, 3],
 mask=[ True,  True,  True, False],
 fill_value=999999)
>>> c[0] = 99
>>> c
masked_array(data=[99, --, --, 3],
 mask=[False,  True,  True, False],
 fill_value=999999)
>>> a
array([0, 1, 2, 3])
>>> c = ma.masked_where(a <= 2, a, copy=False)
>>> c[0] = 99
>>> c
masked_array(data=[99, --, --, 3],
 mask=[False,  True,  True, False],
 fill_value=999999)
>>> a
array([99,  1,  2,  3])

当condition或a包含掩码值时。

>>> a = np.arange(4)
>>> a = ma.masked_where(a == 2, a)
>>> a
masked_array(data=[0, 1, --, 3],
 mask=[False, False,  True, False],
 fill_value=999999)
>>> b = np.arange(4)
>>> b = ma.masked_where(b == 0, b)
>>> b
masked_array(data=[--, 1, 2, 3],
 mask=[ True, False, False, False],
 fill_value=999999)
>>> ma.masked_where(a == 3, b)
masked_array(data=[--, 1, --, --],
 mask=[ True, False,  True,  True],
 fill_value=999999)

`numpy.ma.compress_cols`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.compress_cols.html

ma.compress_cols(a)

抑制包含掩码值的 2-D 数组的整列。

这相当于np.ma.compress_rowcols(a, 1)，详情请参见compress_rowcols。

另请参阅

compress_rowcols

`numpy.ma.compress_rowcols`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.compress_rowcols.html

ma.compress_rowcols(x, axis=None)

抑制包含掩盖值的 2-D 数组的行和/或列。

抑制行为由axis参数选择。

如果轴为 None，则行和列都被抑制。
如果轴为 0，则只有行被抑制。
如果轴为 1 或-1，则只有列被抑制。

参数：

xarray_like，MaskedArray

需要操作的数组。如果不是 MaskedArray 实例（或者没有数组元素被遮罩），x被解释为一个 MaskedArray，其中mask设置为nomask。必须是一个 2D 数组。

axisint，可选

执行操作的轴。默认为 None。

compressed_arrayndarray

压缩后的数组。

示例

>>> x = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0],
...                                                   [1, 0, 0],
...                                                   [0, 0, 0]])
>>> x
masked_array(
 data=[[--, 1, 2],
 [--, 4, 5],
 [6, 7, 8]],
 mask=[[ True, False, False],
 [ True, False, False],
 [False, False, False]],
 fill_value=999999)

>>> np.ma.compress_rowcols(x)
array([[7, 8]])
>>> np.ma.compress_rowcols(x, 0)
array([[6, 7, 8]])
>>> np.ma.compress_rowcols(x, 1)
array([[1, 2],
 [4, 5],
 [7, 8]])

`numpy.ma.compress_rows`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.compress_rows.html

ma.compress_rows(a)

抑制包含掩码值的 2-D 数组的整行。

这相当于np.ma.compress_rowcols(a, 0), 详细信息请参阅compress_rowcols。

另请参阅

compress_rowcols

`numpy.ma.compressed`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.compressed.html

ma.compressed(x)

将所有非掩码数据作为 1-D 数组返回。

这个函数等效于调用ma.MaskedArray的"compressed"方法，请参见 ma.MaskedArray.compressed 了解详情。

另请参阅

ma.MaskedArray.compressed

等效方法。

示例

创建一个带有负值掩码的数组：

>>> import numpy as np
>>> x = np.array([[1, -1, 0], [2, -1, 3], [7, 4, -1]])
>>> masked_x = np.ma.masked_array(x, mask=x < 0)
>>> masked_x
masked_array(
 data=[[1, --, 0],
 [2, --, 3],
 [7, 4, --]],
 mask=[[False,  True, False],
 [False,  True, False],
 [False, False,  True]],
 fill_value=999999)

将掩码数组压缩为非掩码值的 1-D 数组：

>>> np.ma.compressed(masked_x)
array([1, 0, 2, 3, 7, 4])

`numpy.ma.filled`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.filled.html

ma.filled(a, fill_value=None)

将输入作为一个带有掩码数据替换的填充值的数组返回。

如果a不是MaskedArray，则返回a本身。如果a是MaskedArray并且fill_value为 None，则fill_value被设置为a.fill_value。

参数：

aMaskedArray 或 array_like

输入对象。

fill_valuearray_like，可选。

可以是标量或非标量。如果是非标量，则生成的填充数组应该可以在输入数组上进行广播。默认为 None。

andarray

填充的数组。

另请参见

compressed

示例

>>> x = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0],
...                                                   [1, 0, 0],
...                                                   [0, 0, 0]])
>>> x.filled()
array([[999999,      1,      2],
 [999999,      4,      5],
 [     6,      7,      8]])
>>> x.filled(fill_value=333)
array([[333,   1,   2],
 [333,   4,   5],
 [  6,   7,   8]])
>>> x.filled(fill_value=np.arange(3))
array([[0, 1, 2],
 [0, 4, 5],
 [6, 7, 8]])

`numpy.ma.MaskedArray.compressed`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.compressed.html

方法

ma.MaskedArray.compressed()

返回所有非掩盖的数据作为一个一维数组。

datandarray

返回一个新的ndarray来保存非掩盖的数据。

注释

结果不是一个 MaskedArray！

示例

>>> x = np.ma.array(np.arange(5), mask=[0]*2 + [1]*3)
>>> x.compressed()
array([0, 1])
>>> type(x.compressed())
<class 'numpy.ndarray'>

`numpy.ma.MaskedArray.filled`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.filled.html

方法

ma.MaskedArray.filled(fill_value=None)

返回 self 的副本，掩码值用给定值填充。然而，如果没有需要填充的掩码值，则会返回 self 作为一个 ndarray。

参数：

fill_valuearray_like，可选

用于无效条目的值。可以是标量或非标量。如果是非标量，则生成的 ndarray 必须在输入数组上进行广播。默认值为 None，此时，数组的fill_value属性将被使用。

filled_arrayndarray

用fill_value（无论是函数参数还是self的属性）替换无效条目后的self的副本，或者如果没有需要替换的无效条目，则返回self本身作为 ndarray。

注释

结果不是一个 MaskedArray！

例子

>>> x = np.ma.array([1,2,3,4,5], mask=[0,0,1,0,1], fill_value=-999)
>>> x.filled()
array([   1,    2, -999,    4, -999])
>>> x.filled(fill_value=1000)
array([   1,    2, 1000,    4, 1000])
>>> type(x.filled())
<class 'numpy.ndarray'>

子类继承保持不变。这意味着，如果，例如，掩码数组的数据部分是一个 recarray，filled将返回一个 recarray：

>>> x = np.array([(-1, 2), (-3, 4)], dtype='i8,i8').view(np.recarray)
>>> m = np.ma.array(x, mask=[(True, False), (False, True)])
>>> m.filled()
rec.array([(999999,      2), (    -3, 999999)],
 dtype=[('f0', '<i8'), ('f1', '<i8')])

`numpy.ma.MaskedArray.tofile`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.tofile.html

方法

ma.MaskedArray.tofile(fid, sep='', format='%s')

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

警告

此功能尚未实现。

抛出异常:

NotImplementedError

当调用tofile方法时。

`numpy.ma.MaskedArray.tolist`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.tolist.html

方法

ma.MaskedArray.tolist(fill_value=None)

以分层的 Python 列表形式返回掩码数组的数据部分。

数据项被转换为最接近的兼容的 Python 类型。掩码值被转换为fill_value。如果 fill_value为 None，则输出列表中对应的条目将为 None。

参数：

fill_value标量，可选

用于无效条目的值。默认值为 None。

返回值：

result列表

掩码数组的 Python 列表表示。

示例

>>> x = np.ma.array([[1,2,3], [4,5,6], [7,8,9]], mask=[0] + [1,0]*4)
>>> x.tolist()
[[1, None, 3], [None, 5, None], [7, None, 9]]
>>> x.tolist(-999)
[[1, -999, 3], [-999, 5, -999], [7, -999, 9]]

`numpy.ma.MaskedArray.torecords`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.torecords.html

方法

ma.MaskedArray.torecords()

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

返回的灵活类型数组将有两个字段：

_data字段存储数组的_data部分。
_mask字段存储数组的_mask部分。

参数：

None

recordndarray

包含两个字段的新的灵活类型ndarray：第一个元素包含一个值，第二个元素包含相应的掩码布尔值。返回的记录形状与 self.shape 匹配。

注意

将掩码数组转换为灵活的ndarray的一个副作用是，元信息 (fill_value, …) 将会丢失。

示例

>>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4)
>>> x
masked_array(
 data=[[1, --, 3],
 [--, 5, --],
 [7, --, 9]],
 mask=[[False,  True, False],
 [ True, False,  True],
 [False,  True, False]],
 fill_value=999999)
>>> x.toflex()
array([[(1, False), (2,  True), (3, False)],
 [(4,  True), (5, False), (6,  True)],
 [(7, False), (8,  True), (9, False)]],
 dtype=[('_data', '<i8'), ('_mask', '?')])

`numpy.ma.MaskedArray.tobytes`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.tobytes.html

方法

ma.MaskedArray.tobytes(fill_value=None, order='C')

返回表示数组中原始字节的字符串。

在字符串转换之前，数组将填充为填充值。

版本 1.9.0 中的新内容。

参数：

fill_value标量，可选

用于填充掩码值的值。默认为 None，此时使用 MaskedArray.fill_value。

order，可选

复制中数据项的顺序。默认为‘C’。

‘C’ – C 顺序（行优先）。
‘F’ – Fortran 顺序（列优先）。
‘A’ – 任何，当前数组的顺序。
无 - 与‘A’相同。

另见

numpy.ndarray.tobytes

tolist，tofile

注意事项

对于ndarray.tobytes，关于形状、dtype 等的信息，还有关于fill_value的信息会丢失。

示例

>>> x = np.ma.array(np.array([[1, 2], [3, 4]]), mask=[[0, 1], [1, 0]])
>>> x.tobytes()
b'\x01\x00\x00\x00\x00\x00\x00\x00?B\x0f\x00\x00\x00\x00\x00?B\x0f\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00'

`numpy.ma.common_fill_value`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.common_fill_value.html

ma.common_fill_value(a, b)

返回两个掩模数组的常见填充值，如果有的话。

如果a.fill_value == b.fill_value，则返回填充值，否则返回 None。

参数：

a, b掩模数组

要比较填充值的掩模数组。

fill_value标量或 None

常见的填充值，或者为 None。

示例

>>> x = np.ma.array([0, 1.], fill_value=3)
>>> y = np.ma.array([0, 1.], fill_value=3)
>>> np.ma.common_fill_value(x, y)
3.0

`numpy.ma.default_fill_value`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.default_fill_value.html

ma.default_fill_value(obj)

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

默认填充值取决于输入数组的数据类型或输入标量的类型：

数据类型默认

bool True

整数 999999

float 1.e20

复数 1.e20+0j

对象 ‘?’

字符串 ‘N/A’

数据类型	默认
bool	True
整数	999999
float	1.e20
复数	1.e20+0j
对象	‘?’
字符串	‘N/A’

对于结构化类型，将返回一个结构化标量，其中每个字段都是其类型的默认填充值。

对于子数组类型，填充值是一个尺寸相同的数组，其中包含默认的标量填充值。

参数：

objndarray、dtype 或标量

返回默认填充值的数组数据类型或标量。

返回值：

fill_value标量

默认填充值。

示例

>>> np.ma.default_fill_value(1)
999999
>>> np.ma.default_fill_value(np.array([1.1, 2., np.pi]))
1e+20
>>> np.ma.default_fill_value(np.dtype(complex))
(1e+20+0j)

`numpy.ma.maximum_fill_value`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.maximum_fill_value.html

ma.maximum_fill_value(obj)

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

这个函数非常有用，可以用于计算适合于具有给定数据类型的数组取最大值的填充值。

参数：

obj是一个 ndarray、dtype 或者标量

可查询其数值类型的对象。

val是一个标量

能表示的最小值。

抛出异常：

类型错误

如果obj不是一个合适的数值类型。

另请参见

minimum_fill_value

逆函数。

set_fill_value

设置掩码数组的填充值。

MaskedArray.fill_value

返回当前的填充值。

示例

>>> import numpy.ma as ma
>>> a = np.int8()
>>> ma.maximum_fill_value(a)
-128
>>> a = np.int32()
>>> ma.maximum_fill_value(a)
-2147483648

也可以传递一个数值数据的数组。

>>> a = np.array([1, 2, 3], dtype=np.int8)
>>> ma.maximum_fill_value(a)
-128
>>> a = np.array([1, 2, 3], dtype=np.float32)
>>> ma.maximum_fill_value(a)
-inf

`numpy.ma.minimum_fill_value`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.minimum_fill_value.html

ma.minimum_fill_value(obj)

返回对象的 dtype 可以表示的最大值。

该函数用于计算适合使用给定 dtype 的数组进行最小值计算的填充值。

参数：

obj数组、dtype 或标量

可以查询其数字类型的对象。

val标量

可表示的最大值。

引发：

类型错误

如果obj不是一个合适的数字类型。

参见

maximum_fill_value

反函数。

set_fill_value

设置掩码数组的填充值。

MaskedArray.fill_value

返回当前填充值。

示例

>>> import numpy.ma as ma
>>> a = np.int8()
>>> ma.minimum_fill_value(a)
127
>>> a = np.int32()
>>> ma.minimum_fill_value(a)
2147483647

也可以传递一个数字数据数组。

>>> a = np.array([1, 2, 3], dtype=np.int8)
>>> ma.minimum_fill_value(a)
127
>>> a = np.array([1, 2, 3], dtype=np.float32)
>>> ma.minimum_fill_value(a)
inf

`numpy.ma.set_fill_value`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.set_fill_value.html

ma.set_fill_value(a, fill_value)

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

此函数就地更改掩码数组a的填充值。如果a不是掩码数组，则函数会静默返回，什么也不做。

参数：

aarray_like

输入数组。

fill_valuedtype

填充值。执行一致性测试，确保值与a的 dtype 兼容。

None

此函数未返回任何内容。

另请参阅

maximum_fill_value

返回 dtype 的默认填充值。

MaskedArray.fill_value

返回当前填充值。

MaskedArray.set_fill_value

等效方法。

示例

>>> import numpy.ma as ma
>>> a = np.arange(5)
>>> a
array([0, 1, 2, 3, 4])
>>> a = ma.masked_where(a < 3, a)
>>> a
masked_array(data=[--, --, --, 3, 4],
 mask=[ True,  True,  True, False, False],
 fill_value=999999)
>>> ma.set_fill_value(a, -999)
>>> a
masked_array(data=[--, --, --, 3, 4],
 mask=[ True,  True,  True, False, False],
 fill_value=-999)

如果a不是掩码数组，则不会发生任何事情。

>>> a = list(range(5))
>>> a
[0, 1, 2, 3, 4]
>>> ma.set_fill_value(a, 100)
>>> a
[0, 1, 2, 3, 4]
>>> a = np.arange(5)
>>> a
array([0, 1, 2, 3, 4])
>>> ma.set_fill_value(a, 100)
>>> a
array([0, 1, 2, 3, 4])

`numpy.ma.MaskedArray.get_fill_value`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.get_fill_value.html

方法

ma.MaskedArray.get_fill_value()

遮盖数组的填充值是一个标量。当设置时，None 将设置为基于数据类型的默认值。

示例

>>> for dt in [np.int32, np.int64, np.float64, np.complex128]:
...     np.ma.array([0, 1], dtype=dt).get_fill_value()
...
999999
999999
1e+20
(1e+20+0j)

>>> x = np.ma.array([0, 1.], fill_value=-np.inf)
>>> x.fill_value
-inf
>>> x.fill_value = np.pi
>>> x.fill_value
3.1415926535897931 # may vary

重置为默认值：

>>> x.fill_value = None
>>> x.fill_value
1e+20

`numpy.ma.MaskedArray.set_fill_value`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.MaskedArray.set_fill_value.html

方法

ma.MaskedArray.set_fill_value(value=None)

`numpy.ma.anom`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.anom.html

ma.anom(self, axis=None, dtype=None) = <numpy.ma.core._frommethod object>

计算沿指定轴的异常值（与算术平均值的偏差）。

返回具有与输入相同形状的异常值数组，其中算术平均值沿指定轴计算。

参数：

axisint, optional

被取异常值的轴。默认值是使用数组的平均值作为参考。

dtypedtype, optional

计算方差时使用的类型。对于整数类型的数组

默认值是 float32；对于浮点类型的数组，其类型与数组类型相同。

参见

mean

计算数组的平均值。

示例

>>> a = np.ma.array([1,2,3])
>>> a.anom()
masked_array(data=[-1.,  0.,  1.],
 mask=False,
 fill_value=1e+20)

`numpy.ma.anomalies`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.anomalies.html

ma.anomalies(self, axis=None, dtype=None) = <numpy.ma.core._frommethod object>

计算沿着给定轴的异常值（与算术平均值的偏差）。

返回一个与输入形状相同的异常数组，其中算术平均值沿着给定的轴计算。

参数:

axisint, 可选

异常取值的轴。默认情况下，使用平坦数组的平均值作为参考。

dtypedtype, 可选

用于计算方差的类型。对于整数类型的数组

默认值为 float32；对于浮点类型的数组，它与数组类型相同。

参见

mean

计算数组的平均值。

示例

>>> a = np.ma.array([1,2,3])
>>> a.anom()
masked_array(data=[-1.,  0.,  1.],
 mask=False,
 fill_value=1e+20)

`numpy.ma.average`

译文：numpy.org/doc/1.26/reference/generated/numpy.ma.average.html

ma.average(a, axis=None, weights=None, returned=False, *, keepdims=<no value>)

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

参数：

a类似数组

要进行平均值计算的数据。在计算中不考虑掩码条目。

axisint，可选

在其上对 a 进行平均的轴。如果为 None，则对平坦数组进行平均值。

weights类似数组，可选

每个元素在计算平均值中的重要性。权重数组可以是 1-D（在这种情况下，其长度必须与给定轴上的a的大小相同），或者与a具有相同的形状。如果 weights=None，则假定a中的所有数据的权重都等于 1。1-D 计算为：

avg = sum(a * weights) / sum(weights)

对 weights 的唯一约束是 sum(weights) 不能为 0。

returnedbool，可选

表示是否应该将元组 (result, sum of weights) 作为输出返回（True），还是只返回结果（False）的标志。默认为 False。

keepdimsbool，可选

如果设置为 True，则减小的轴将作为大小为一的维度保留在结果中。此选项可以使结果与原始a正确地进行广播。注意： keepdims 在 numpy 矩阵类型或其他不支持 keepdims 方法的类的实例上不起作用。

在 1.23.0 版本中新增。

average，[sum_of_weights](标量或 MaskedArray 的元组)

指定轴的平均值。当 returned 为 True 时，返回一个元组，其第一个元素为平均值，第二个元素为权重的总和。如果 a 的整数类型为 np.float64 且小于 float64 类型的浮点数，或者输入数据类型为浮点数，则返回类型为 np.float64。如果 returned，sum_of_weights 总是 float64。

示例

>>> a = np.ma.array([1., 2., 3., 4.], mask=[False, False, True, True])
>>> np.ma.average(a, weights=[3, 1, 0, 0])
1.25

>>> x = np.ma.arange(6.).reshape(3, 2)
>>> x
masked_array(
 data=[[0., 1.],
 [2., 3.],
 [4., 5.]],
 mask=False,
 fill_value=1e+20)
>>> avg, sumweights = np.ma.average(x, axis=0, weights=[1, 2, 3],
...                                 returned=True)
>>> avg
masked_array(data=[2.6666666666666665, 3.6666666666666665],
 mask=[False, False],
 fill_value=1e+20)

使用 keepdims=True，以下结果的形状为 (3, 1)。

>>> np.ma.average(x, axis=1, keepdims=True)
masked_array(
 data=[[0.5],
 [2.5],
 [4.5]],
 mask=False,
 fill_value=1e+20)

`numpy.ma.conjugate`

原文：numpy.org/doc/1.26/reference/generated/numpy.ma.conjugate.html

ma.conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) = <numpy.ma.core._MaskedUnaryOperation object>

逐元素返回复共轭。

复数的复共轭是通过改变其虚部的符号获得的。

参数：

xarray_like

输入值。

outndarray、None 或 ndarray 和 None 的元组，可选

存储结果的位置。如果提供，它必须具有输入广播到的形状。如果未提供或为 None，则返回一个新分配的数组。长度等于输出数量的元组（仅作为关键字参数）必须具有相同的长度。

wherearray_like，可选

此条件将广播到输入。在条件为 True 的位置，out数组将设置为 ufunc 结果。在其他地方，out数组将保留其原始值。请注意，如果通过默认情况下的out=None创建了一个未初始化的out数组，则其中条件为 False 的位置将保持未初始化状态。

**kwargs

关于其他仅限关键字参数，请参阅 ufunc docs。

yndarray

x的复共轭，与y具有相同的 dtype。如果x是标量，则这是一个标量。

注意事项

conj 是 conjugate 的别名：

>>> np.conj is np.conjugate
True

示例

>>> np.conjugate(1+2j)
(1-2j)

>>> x = np.eye(2) + 1j * np.eye(2)
>>> np.conjugate(x)
array([[ 1.-1.j,  0.-0.j],
 [ 0.-0.j,  1.-1.j]])

posted @ 2024-06-24 14:55 绝不原创的飞龙阅读(7) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· NumPy-1-26-中文文档-八-

· NumPy-1-26-中文文档-六-

· Python-numpy

· 基于Python Numpy的数组array和矩阵matrix详解

· Python 之 Numpy 框架入门

历史上的今天：
2021-06-24 如何评价「施一公请辞清华大学副校长，全职执掌西湖大学」？你如何看待西湖大学的发展前景？

公告

Github：@wizardforcel

简书：@布客飞龙

微博：@布客飞龙

赞助我：

昵称：绝不原创的飞龙
园龄： 5年2个月
粉丝： 67
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

掠夺·扩张·投机·博弈

NumPy 1.26 中文文档（十三）

numpy.ma.ravel

numpy.ma.reshape

numpy.ma.resize

numpy.ma.MaskedArray.flatten

numpy.ma.MaskedArray.ravel

numpy.ma.MaskedArray.reshape

numpy.ma.MaskedArray.resize

numpy.ma.swapaxes

numpy.ma.transpose

numpy.ma.MaskedArray.swapaxes

numpy.ma.MaskedArray.transpose

numpy.ma.atleast_1d

numpy.ma.atleast_2d

numpy.ma.atleast_3d

numpy.ma.expand_dims

numpy.ma.squeeze

numpy.ma.MaskedArray.squeeze

numpy.ma.stack

numpy.ma.column_stack

numpy.ma.concatenate

numpy.ma.dstack

numpy.ma.hstack

numpy.ma.hsplit

numpy.ma.mr_

numpy.ma.row_stack

numpy.ma.vstack

numpy.ma.concatenate

numpy.ma.stack

numpy.ma.vstack

numpy.ma.hstack

numpy.ma.dstack

numpy.ma.column_stack

numpy.ma.append

numpy.ma.make_mask

numpy.ma.make_mask_none

numpy.ma.mask_or

numpy.ma.make_mask_descr

numpy.ma.getmask

numpy.ma.getmaskarray

numpy.ma.masked_array.mask

numpy.ma.ndenumerate

numpy.ma.flatnotmasked_contiguous

numpy.ma.flatnotmasked_edges

numpy.ma.notmasked_contiguous

numpy.ma.notmasked_edges

numpy.ma.clump_masked

numpy.ma.clump_unmasked

numpy.ma.mask_cols

numpy.ma.mask_or

numpy.ma.mask_rowcols

numpy.ma.mask_rows

numpy.ma.harden_mask

numpy.ma.soften_mask

numpy.ma.MaskedArray.harden_mask

numpy.ma.MaskedArray.soften_mask

numpy.ma.MaskedArray.shrink_mask

numpy.ma.MaskedArray.unshare_mask

numpy.ma.asarray

numpy.ma.asanyarray

numpy.ma.fix_invalid

numpy.ma.masked_equal

numpy.ma.masked_greater

numpy.ma.masked_greater_equal

numpy.ma.masked_inside

numpy.ma.masked_invalid

numpy.ma.masked_less

numpy.ma.masked_less_equal

numpy.ma.masked_not_equal

numpy.ma.masked_object

numpy.ma.masked_outside

numpy.ma.masked_values

numpy.ma.masked_where

numpy.ma.compress_cols

numpy.ma.compress_rowcols

numpy.ma.compress_rows

numpy.ma.compressed

numpy.ma.filled

numpy.ma.MaskedArray.compressed

`numpy.ma.ravel`

`numpy.ma.reshape`

`numpy.ma.resize`

`numpy.ma.MaskedArray.flatten`

`numpy.ma.MaskedArray.ravel`

`numpy.ma.MaskedArray.reshape`

`numpy.ma.MaskedArray.resize`

`numpy.ma.swapaxes`

`numpy.ma.transpose`

`numpy.ma.MaskedArray.swapaxes`

`numpy.ma.MaskedArray.transpose`

`numpy.ma.atleast_1d`

`numpy.ma.atleast_2d`

`numpy.ma.atleast_3d`

`numpy.ma.expand_dims`

`numpy.ma.squeeze`

`numpy.ma.MaskedArray.squeeze`

`numpy.ma.stack`

`numpy.ma.column_stack`

`numpy.ma.concatenate`

`numpy.ma.dstack`

`numpy.ma.hstack`

`numpy.ma.hsplit`

`numpy.ma.mr_`

`numpy.ma.row_stack`

`numpy.ma.vstack`

`numpy.ma.concatenate`

`numpy.ma.stack`

`numpy.ma.vstack`

`numpy.ma.hstack`

`numpy.ma.dstack`

`numpy.ma.column_stack`

`numpy.ma.append`

`numpy.ma.make_mask`

`numpy.ma.make_mask_none`

`numpy.ma.mask_or`

`numpy.ma.make_mask_descr`

`numpy.ma.getmask`

`numpy.ma.getmaskarray`

`numpy.ma.masked_array.mask`

`numpy.ma.ndenumerate`

`numpy.ma.flatnotmasked_contiguous`

`numpy.ma.flatnotmasked_edges`

`numpy.ma.notmasked_contiguous`

`numpy.ma.notmasked_edges`

`numpy.ma.clump_masked`

`numpy.ma.clump_unmasked`

`numpy.ma.mask_cols`

`numpy.ma.mask_or`

`numpy.ma.mask_rowcols`

`numpy.ma.mask_rows`

`numpy.ma.harden_mask`

`numpy.ma.soften_mask`

`numpy.ma.MaskedArray.harden_mask`

`numpy.ma.MaskedArray.soften_mask`

`numpy.ma.MaskedArray.shrink_mask`

`numpy.ma.MaskedArray.unshare_mask`

`numpy.ma.asarray`

`numpy.ma.asanyarray`

`numpy.ma.fix_invalid`

`numpy.ma.masked_equal`

`numpy.ma.masked_greater`

`numpy.ma.masked_greater_equal`

`numpy.ma.masked_inside`

`numpy.ma.masked_invalid`

`numpy.ma.masked_less`

`numpy.ma.masked_less_equal`

`numpy.ma.masked_not_equal`

`numpy.ma.masked_object`

`numpy.ma.masked_outside`

`numpy.ma.masked_values`

`numpy.ma.masked_where`

`numpy.ma.compress_cols`

`numpy.ma.compress_rowcols`

`numpy.ma.compress_rows`

`numpy.ma.compressed`

`numpy.ma.filled`

`numpy.ma.MaskedArray.compressed`

`numpy.ma.MaskedArray.filled`

`numpy.ma.MaskedArray.tofile`