Python ma（掩码）数组平均值方法的返回类型不一致

我注意到，在可能不应该返回的情况下，返回不同的类型：

import numpy as np

A = np.ma.masked_equal([1,1,0], value=0)
B = np.ma.masked_equal([1,1,1], value=0) # no masked values

type(A.mean())
#numpy.float64
type(B.mean())
#numpy.ma.core.MaskedArray

其他

numpy.ma.core.MaskedArray

方法似乎是一致的

type( A.sum()) == type(B.sum())
# True
type( A.prod()) == type(B.prod())
# True
type( A.std()) == type(B.std())
# True
type( A.mean()) == type(B.mean())
# False

有人能解释一下吗

更新：如评论中所述

C = np.ma.masked_array([1, 1, 1], mask=[False, False, False])
type(C.mean()) == type(A.mean())
# True 

---

B.mask

以以下内容开头：

    if self._mask is nomask:
        result = super(MaskedArray, self).mean(axis=axis, dtype=dtype)

np.ma.nomask

为

False

这是您的

B

的情况：

masked_array(data = [1 1 1],
             mask = False,
       fill_value = 0)

对于

A

而言，掩码是一个与

数据

大小匹配的数组。在

B

中，它是标量，

False

，并且

means

将其作为特殊情况处理

我需要进一步挖掘，看看这意味着什么

In [127]: np.mean(B)
Out[127]: 
masked_array(data = 1.0,
             mask = False,
       fill_value = 0)

In [141]: super(np.ma.MaskedArray,B).mean()
Out[141]: 
masked_array(data = 1.0,
             mask = False,
       fill_value = 0)

我不确定这是否有帮助；在

np.ndarray

方法和

np

函数以及

np.ma

方法之间存在一些循环引用，这使得很难准确识别正在使用的代码。它就像是在使用编译后的

mean

方法，但不清楚它是如何处理掩蔽的

我不知道目的是否在于使用

 np.mean(B.data) # or
 B.data.mean()

而且

super

方法fetch不是正确的方法

在任何情况下，相同的数组（但带有向量掩码）返回标量

In [132]: C
Out[132]: 
masked_array(data = [1 1 1],
             mask = [False False False],
       fill_value = 0)

In [133]: C.mean()
Out[133]: 1.0

====================

在不使用

nomask

快捷方式的情况下尝试此方法会在

        dsum = self.sum(axis=axis, dtype=dtype)
        cnt = self.count(axis=axis)
        if cnt.shape == () and (cnt == 0):
            result = masked
        else:
            result = dsum * 1. / cnt

self.count

在

nomask

情况下返回标量，但在常规掩蔽中返回

np.int32

。因此，

cnt.shape

阻塞

trace

是唯一尝试此

super（MaskedArray…

“快捷方式”的其他屏蔽方法。很明显，中庸的代码有些混乱

====================

相关错误问题：

据报道，去年这里也提出了同样的问题：

---

看起来有很多掩蔽问题，不仅仅是

mean

。现在或不久的将来，开发母版中可能会有修复程序。

如果它仅在您未屏蔽任何值时返回不同的类型，则这不是不一致，这只是一种特殊情况。。。调用masked_equal后，您是否立即检查了B的类型？请注意，如果

C=np.ma.masked_数组（[1,1]，mask=[False，False，False]）

，那么

type（C.mean（））

与

type（A.mean（））

是相同的。确实有趣