Numpy数组简介

发表于 2017-05-27 分类于 python

　　Numpy是Python的一个工具包，提供了丰富的科学计算接口。现将网络上多个学习Numpy数组的总结搬运至此，留作备忘。　　NumPy数组是一个多维数组对象，称为ndarray。其由两部分组成：实际的数据以及描述这些数据的元数据。大部分操作仅针对于元数据，而不改变底层实际的数据。　　关于NumPy数组有几点必需了解的： - NumPy数组的下标从0开始 - 同一个NumPy数组中所有元素的类型必须是相同的

NumPy数组的基本属性

　　NumPy数组的维数称为秩（rank），一维数组的秩为1，二维数组的秩为2，以此类推。在NumPy中，每一个线性的数组称为是一个轴（axes），秩其实是描述轴的数量(数组的维数)。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中的每个元素又是一个一维数组。所以一维数组就是NumPy中的轴（axes），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。　　对于二维数组，传统上我们用矩形的行和列表示一个二维数组或矩阵，其中沿着0轴的方向被穿过的称作行，沿着1轴的方向被穿过的是列。NumPy的数组中比较重要的ndarray对象属性有： - ndarray.ndim：数组的维数（即数组轴的个数），等于秩。最常见的为二维数组（矩阵）。 - ndarray.shape：数组的维度，表示数组在每个轴上的长度的整数元组。例如二维数组中，表示数组的“行数”和“列数”。返回值为一个元组，这个元组的长度就是维数，即ndim属性。 - ndarray.size：数组元素的总个数，等于shape属性中元组元素的乘积。(len(a)能查看二维数组a的行数) - ndarray.dtype：数组中元素的类型。 - ndarray.itemsize：数组中每个元素的字节大小。例如，元素类型为float64的数组，其itemsiz值为8(float64占用64个bits，每个字节长度为8，所以64/8，占用8个字节）。 - ndarray.data：包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

创建数组

　　Python中使用的基本数据类型中是list。比如，

>>> a=['a','b','c',1,'1']
>>> type(a)   # output: list
>>> a[0]      # output: 'a'
>>> a[0:2]    # output: ['a', 'b']

　　再来介绍创建数组。创建数组的方法有很多。

>>> from numpy import *
　　　
>>> a = array( [2,3,4] )　　　            # 使用array函数从常规的Python列表和元组创造数组
>>> a        # output: array([2, 3, 4])
>>> a.dtype  # output: dtype('int64')     # 所创建的数组类型由原序列中的元素类型推导而来
    
>>> b = array([1.2, 3.5, 5.1])　　　
>>> b.dtype    # output: dtype('float64')
    
# 可以在创建时显式指定数组中元素的类型
>>> c = array( [ [1,2], [3,4] ], dtype=complex)  
>>> c  
    array([[ 1.+0.j,  2.+0.j],  
　　　    [ 3.+0.j,  4.+0.j]])  

# 可使用双重序列来表示二维的数组，三重序列表示三维数组，以此类推
>>> b = array( [ (1.5,2,3), (4,5,6) ] )　　  
>>> b  
    array([[ 1.5,  2. ,  3. ],  
　　　     [ 4. ,  5. ,  6. ]]) 

# ndarray 与 python的list之间相互转换
b=np.asarray(a)                   # list a 转为 numpy数组 b
aa=b.tolist()                     # 将numpy的数组b转为python的list aa

　　创建指定维度的数组

>>> d = zeros((3,4))    # zeros可创建一个元素全是0的数组
>>> d.dtype             # output: dtype('float64')  
>>> d  
    array([[ 0.,  0.,  0.,  0.],  
　　   [ 0.,  0.,  0.,  0.],  
　　   [ 0.,  0.,  0.,  0.]])  

>>> d = ones((2,3,4))            # ones可创建一个元素全为1的数组
>>> empty((2,3))                 # empty创建一个内容随机并且依赖于内存状态的数组
>>> d = eye(3)                   # eye创建一个单位矩阵
>>> d = repeat(3, 4)             # repeat创建一个一维数组，元素值是把3重复4次，array([3, 3, 3, 3])
>>> b= np.random.random((2,3))

>>> ones( (2,3,4), dtype=int16 )  # 手动指定数组中元素的类型，默认为 float64
      array([[[1, 1, 1, 1],  
　　　        [1, 1, 1, 1],  
　　　        [1, 1, 1, 1]],  
　　　  
　　　       [[1, 1, 1, 1],  
　　　        [1, 1, 1, 1],  
　　　        [1, 1, 1, 1]]], dtype=int16)

　　NumPy提供一个类似arange的函数返回一个等间隔的数组:

>>> np.arange(10, 30, 5)                   # 以10开始，差值为5的等差数列
    array([10, 15, 20, 25]) 
    
>>> np.arange(0,2,0.5)                     # 浮点数
    array([ 0. ,  0.5,  1. ,  1.5])  
    
# 当arange使用浮点数参数时，由于浮点数精度有限，通常无法预测获得的元素个数
# 因此，最好使用函数linspace去接收我们想要的元素个数来代替用range来指定步长    
>>> numpy.linspace(-1, 0, 5)  
        array([-1.  , -0.75, -0.5 , -0.25,  0.  ])

　　数组中的元素是通过下标来访问的，可以通过方括号括起一个下标来访问数组中的某一个元素，也可以以切片的形式访问数组中多个元素。关于切片访问，将在切片一节介绍。

NumPy中的数据类型

　　对于科学计算来说，Python中自带的整型、浮点型和复数类型远远不够，因此NumPy中添加了许多数据类型。比如 bool, inti, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64或float, complex64, complex128或complex. NumPy类型转换方式如下：

>>> float64(42)  # output: 42.0  
>>> int8(42.0)   # output:  42
>>> bool(42)     # output: True 
>>> bool(42.0)   # output: True
>>> float(True)  # output: 1.0

自定义结构数组

　　通过NumPy也可以定义像C语言那样的结构类型。在NumPy中定义结构的方法如下，定义结构类型名称；定义字段名称，标明字段数据类型。

student= dtype({'names':['name', 'age', 'weight'], 'formats':['S32', 'i','f']}, align = True)

这里student是自定义结构类型的名称，使用dtype函数创建，在第一个参数中，`names`和`formats`不能改变，names中列出的是结构中字段名称，formats中列出的是对应字段的数据类型
S32表示32字节长度的字符串，i表示32位的整数，f表示32位长度的浮点数
最后一个参数为True时，表示要求进行内存对齐。
在定义好结构类型之后，就可以定义以该类型为元素的数组了：

a= array([(“Zhang”, 32, 65.5), (“Wang”, 24, 55.2)], dtype =student)  

除了在每个元素中依次列出对应字段的数据外，还需要在array函数中最后一个参数指定其所对应的数据类型。(注：例子来源于张若愚的Python科学计算艺术的29页。更多关于dtype的内容请参考《NumPy for Beginner》一书的第二章。)

输出数组

　　当输出一个数组时，NumPy以特定的布局用类似嵌套列表的形式显示： - 第一行从左到右输出 - 每行依次自上而下输出 - 每个切片通过一个空行与下一个隔开 - 一维数组被打印成行，二维数组成矩阵，三维数组成矩阵列表。

>>> a = np.arange(6)                         # 1d array  
>>> print(a)  
    [0 1 2 3 4 5]  
>>> b = np.arange(12).reshape(4,3)           # 2d array  
>>> print(b)  
    [[ 0  1  2]  
    [ 3  4  5]  
    [ 6  7  8]  
    [ 9 10 11]]　　　  
>>> c = np.arange(24).reshape(2,3,4)         # 3d array  
>>> print(c)  
    [[[ 0  1  2  3]  
    [ 4  5  6  7]  
    [ 8  9 10 11]]  
　　　  
    [[12 13 14 15]  
    [16 17 18 19]  
    [20 21 22 23]]]

numpy保存和读取数组

保存和读取一维和二维数组[文本文件]

# 保存 
np.savetxt('d.dat',d,fmt='%.18e',delimiter=' ',newline='\n', header='', footer='', comments='# ', encoding=None)

d 可以是一个数组或者列表，也可以是由 np.column_stack() 函数将多个数组进行组合的结果。
fmt，数据格式，
delimiter，分隔符，默认为空格   
newline，换行符，默认为 '\n' 
header，文件开头注释行的内容 
footer，文件结尾注释行的内容
comments， 注释行的开头，默认为 #
encoding，编码格式，默认为 'latin1'

# 读取
d=np.loadtxt('d.dat',dtype='float',comments='#',skiprows=0,delimiter=None,usecols=None,unpack=False )

dtype，数据类型， 默认为 float 
comments， 注释行的开头，默认为 #
skiprows，从文件开头跳过（不读取）的行数，默认为 0；当有注释时，skiprows=0 会自动跳过所有注释；有注释时，若 skiprows 不等于 0 则会按照 skiprows 的值进行跳过。
delimiter，分隔符，默认为所有的空格 
usecols，只读取指定的列，比如 usecols=(0,2) 读取第1，3列，默认读取所有列
unpack，若为真，则可以如此赋值，d1,d2,d3=np.loadtxt('data.dat',usecols=(0,1,2),unpack=True)；默认为 False

m = np.loadtxt(open("file.csv","rb"),delimiter=",",skiprows=1)  # 导入csv文件 

# 读取文本(字符串和数字混合)
from io import StringIO

text='''
1 male
2 female
3 male
'''

nums, sex = np.loadtxt(StringIO(text),dtype='int, U32',unpack=True) # 得到的nums 和 sex，分别是整数和字符串

保存为二进制格式

np.load和np.save函数以NumPy专用的二进制类型处理数据，这两个函数会自动处理元素类型和shape等信息。
但是np.save输出的文件很难被其它语言编写的程序读入：

np.save("a.npy", a)
c = np.load( "a.npy" )

如果你想将多个数组保存到一个文件中的话，可以使用np.savez函数

基本运算

　　数组的算术运算是按元素逐个运算

>>> a= np.array([20,30,40,50])  
>>> b= np.array([0, 1, 2, 3])  
>>> c= a-b  
>>> c  
    array([20, 29, 38, 47])  
    
>>> b**2  
    array([0, 1, 4, 9])  

>>> 10*np.sin(a)  
    array([ 9.12945251,-9.88031624, 7.4511316, -2.62374854])  

>>> a<35  
    array([True, True, False, False], dtype=bool)  

# 有些操作符如 += 和 *= 用来更改已存在数组而不创建一个新的数组
>>> a*= 3  
>>> b+= a

　　与其他矩阵语言不同，NumPy中的乘法运算符*按元素逐个计算，矩阵乘法可以使用dot函数或创建矩阵对象实现(后续章节会介绍)

>>> A= np.array([[1,1], [0,1]])  
>>> B= np.array([[2,0], [3,4]])  
>>> A*B                    # 逐个元素相乘  
    array([[2, 0], [0, 4]])  
>>> np.dot(A,B)            # 矩阵相乘  
    array([[5, 4], [3, 4]])

　　求和、求最值：

>>> a= np.arange(12).reshape(3,4)
>>> a  
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])

>>> a.sum()    # output: 66
>>> a.min()    # output: 0 
>>> a.max()    # output: 11
>>> a.argmax() # output: 11，返回最大值的index 
      
以上运算将数组看作是一维线性列表。但可通过指定axis参数对指定的轴做相应的运算：

>>> b.sum(axis=0)     # 计算每一列的和，注意理解轴的含义，参考数组的第一篇文章  
    array([12, 15, 18, 21])  
>>> b.min(axis=1)     # 获取每一行的最小值  
    array([0, 4, 8])  
>>> b.cumsum(axis=1)  # 计算每一行的累积和  
    array([[ 0, 1, 3, 6],  
           [ 4, 9, 15, 22],  
           [ 8, 17, 27, 38]])

　　
## 索引，切片和迭代　　和列表以及其它Python序列一样，一维数组可以进行索引、切片和迭代操作。

>>> a= np.arange(10)**3
>>> a                # output: array([0, 1, 8, 27, 64, 125, 216, 343, 512, 729])  
>>> a[2]             # output: 8
>>> a[2:5]           # output: array([ 8, 27, 64])  
     
>>> a[:6:2]= -1000   # 等同于a[0:6:2]= -1000，从开始到第6个位置，每隔一个元素将其赋值为-1000  
>>> a                # output: array([-1000, 1,-1000, 27,-1000, 125, 216, 343, 512, 729])  
    
>>> a[: :-1] # 反转a  
    array([ 729, 512, 343, 216, 125,-1000, 27,-1000, 1,-1000])  
>>>for i in a: print(i**(1/3.)) 
    nan 1.0 nan 3.0 nan 5.0 6.0 7.0 8.0 9.0

　　多维数组可以每个轴有一个索引。这些索引由一个逗号分割的元组给出。

>>> a= np.arange(12).reshape(3,4)
>>> a  
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])

>>> a[2,3]      # output: 11
>>> a[0:3, 1]   # 每行的第二个元素  
    array([1, 5, 9])
>>> a[:, 1]     # 与前面的效果相同  
    array([1, 5, 9])
>>> a[1:3, :]   # 第二，三行的元素
    array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
         
# 当少于提供的索引数目少于轴数时，已给出的数值按秩的顺序复制，缺失的索引则默认为是整个切片：       
>>> a[-1] # 最后一行，等同于a[-1,:]，-1是第一个轴，而缺失的认为是：，相当于整个切片。  
    array([ 8,  9, 10, 11])        

# 三维数组（两个2维数组叠加而成） 
>>> c= array( [ [[ 0, 1, 2], [ 10, 12, 13]], [[100,101,102], [110,112,113]]] )  
>>> c.shape  
    (2, 2, 3)  
>>> c[1,...]     # 等同于c[1,:,:] 或 c[1]  
    array([[100, 101, 102],  
           [110, 112, 113]])  
>>> c[...,2]     # 等同于c[:,:,2]  
    array([[ 2, 13],  
           [102, 113]])

　　多维数组的遍历是以是第一个轴为基础的：

>>>for row in b:     # 每一个 row 是一行
...    print(row)  
...  
[0 1 2 3]  
[10 11 12 13]  
[20 21 22 23]  
[30 31 32 33]  
[40 41 42 43]

　　如果想对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：

>>>for element in b.flat:  
...    print(element)   

0 1 2 3 10 11 12 13 20 21 22 23 30 31 32 33 40 41 42 43

形状（shape）操作

　　数组的形状取决于其每个轴上的元素个数：

>>> a= np.arange(12).reshape(3,4)
>>> a  
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
>>> a.shape  
    (3, 4) 

# 可以用多种方式修改数组的形状：
>>> b=a.flatten()   # 展开一个numpy数组为1维数组 
>>> b=a.ravel()     # 展开一个numpy数组为1维数组  
>>> a.shape= (6, 2) 
>>> a
    array([[ 0,  1],
           [ 2,  3],
           [ 4,  5],
           [ 6,  7],
           [ 8,  9],
           [10, 11]])

>>> a.transpose()    # 转置 
    array([[ 0,  2,  4,  6,  8, 10],
       [ 1,  3,  5,  7,  9, 11]])

>>> a.reshape(3,4)            # reshape函数有返回值，不改变原数组
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])

>>> a.resize(3,4)             # resize函数改变原数组
>>> a
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])

>>> a.reshape(2,-1)            # 在reshape操作中指定一个维度为-1，那么其真实值将根据实际情况计算得到
    array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11]])

组合函数

　　这里介绍以不同的方式组合函数。首先创建两个数组：

>>> a = np.arange(9).reshape(3,3)  
>>> a  
    array([[0, 1, 2],  
           [3, 4, 5],  
           [6, 7, 8]])  
>>> b = a+10 
>>> b  
    array([[10, 11, 12],
           [13, 14, 15],
           [16, 17, 18]])

## 水平组合

>>> np.hstack((a, b))  
    array([[ 0,  1,  2, 10, 11, 12],
           [ 3,  4,  5, 13, 14, 15],
           [ 6,  7,  8, 16, 17, 18]])

>>> np.c_[a,b]
>>> np.concatenate((a, b), axis=1)     # 也可通过concatenate函数并指定相应的轴来获得这一效果

## 垂直组合

>>> np.vstack((a, b))  
    array([[ 0,  1,  2],
           [ 3,  4,  5],
           [ 6,  7,  8],
           [10, 11, 12],
           [13, 14, 15],
           [16, 17, 18]])

>>> np.r_[a,b]
>>> concatenate((a, b), axis=0)        # 可通过concatenate函数，并指定相应的轴来获得这一效果

## 深度组合　　另外，还有深度方面的组合函数dstack。顾名思义，就是在数组的第三个轴（即深度）上组合。如下：

>>> np.dstack((a, b))  
array([[[ 0, 10],
        [ 1, 11],
        [ 2, 12]],

       [[ 3, 13],
        [ 4, 14],
        [ 5, 15]],

       [[ 6, 16],
        [ 7, 17],
        [ 8, 18]]])

分割数组

　　在NumPy中，分割数组的函数有hsplit、vsplit、dsplit和split。可将数组分割成相同大小的子数组，或指定原数组分割的位置。

水平分割

>>> a = np.arange(9).reshape(3,3)  
>>> a  
array([[0, 1, 2],  
       [3, 4, 5],  
       [6, 7, 8]])  
       
>>> np.hsplit(a, 3)  
[array([[0],  
       [3],  
       [6]]),  
 array([[1],  
       [4],  
       [7]]),  
 array([[2],  
       [5],  
       [8]])]  
       
>>> np.split(a, 3, axis=1)    # 也调用split函数并指定轴为1来获得这样的效果

垂直分割

>>> vsplit(a, 3)  
    [array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]  
    
>>> np.split(a, 3, axis=0)    # 同样，也可通过solit函数并指定轴为1来获得这样的效果

面向深度的分割

　　dsplit函数使用的是面向深度的分割方式：

1 2	>>> c = arange(27).reshape(3, 3, 3) >>> dsplit(c, 3)

复制和镜像（View）

　　当运算和处理数组时，它们的数据有时被拷贝到新的数组，有时不是。这通常是新手的困惑之源。这有三种情况:

完全不复制

# 简单的赋值，而不复制数组对象或它们的数据
>>> a = np.arange(12)  
>>> b = a            # 不创建新对象  
>>> b is a           # output: True     # a和b是同一个数组对象的两个名字  
>>> b.shape = 3,4     
>>> a.shape          # output: (3, 4)   # 也改变了a的形状

视图(view)和浅复制

# 不同的数组对象分享同一个数据。视图方法创造一个新的数组对象指向同一数据。
>>> c = a.view()  
>>> c is a           # output: False  
>>> c.base is a      # output: True     # c是a持有数据的镜像  
>>> c.flags.owndata  # output： False  
  
>>> c.shape = 2,6      
>>> a.shape          # output：(3, 4)     # a的形状没变  
 
>>> c[0,4] = 1234      
>>> a                # a的数据改变了  
    array([[   0,    1,    2,    3],  
           [1234,    5,    6,    7],  
           [   8,    9,   10,   11]])  

# 切片数组返回它的一个视图：
>>> s = a[ : , 1:3]      # 获得第2，3列的元素  
>>> s[:] = 10            # s[:] 是s的镜像。注意区别s=10 and s[:]=10  
>>> a                    # a的元素改变了
    array([[   0,   10,   10,    3],  
       [1234,   10,   10,    7],  
       [   8,   10,   10,   11]])

深复制

# 这个复制方法完全复制数组和它的数据
>>> d = a.copy()       # 创建了一个含有新数据的新数组对象  
>>> d is a             # output: False
>>> d.base is a        # output: False   # d和a现在没有任何关系  
>>> d[0,0] = 9999  
>>> a  
array([[   0,   10,   10,    3],  
       [1234,   10,   10,    7],  
       [   8,   10,   10,   11]])

线性代数模块（linalg）

结合numpy提供的基本函数，可以对向量，矩阵进行一些基本的运算：

>>> a = np.array([3, 4])
>>> np.linalg.norm(a)      # 范数

>>> b = np.arange(9).reshape(3,3)
>>> c = np.array([1, 0, 1])

# 矩阵和向量之间的乘法
np.dot(b, c)
np.dot(c, b.T)

np.trace(b)             	# 矩阵的迹
np.linalg.det(b)        	# 矩阵的行列式值
np.linalg.matrix_rank(b)	# 求矩阵的秩，2，不满秩，因为行与行之间等差

d = np.array([[2, 1],[1, 2]])
u, v = np.linalg.eig(d)     # 特征值、特征向量

l = np.linalg.cholesky(d)   # Cholesky分解并重建

e = np.array([[1, 2], [3, 4]])

# 对不正定矩阵，进行SVD分解并重建
U, s, V = np.linalg.svd(e)

S = np.array([
    [s[0], 0],
    [0, s[1]]
])

np.dot(U, np.dot(S, V))

matrix对象

　　NumPy和Matlab不一样，对于多维数组的运算，默认情况下并不使用矩阵运算，如果你希望对数组进行矩阵运算的话，可以调用相应的函数。　　numpy库提供了matrix类，使用matrix类创建的是矩阵对象，它们的加减乘除运算默认采用矩阵方式计算，因此用法和matlab十分类似。但是由于NumPy中同时存在ndarray和matrix对象，因此用户很容易将两者弄混。这有违Python的“显式优于隐式”的原则，因此并不推荐在较复杂的程序中使用matrix。下面是使用matrix的一个例子：

>>> a = np.matrix([[1,2,3],[5,5,6],[7,9,9]])
>>> a*a**-1
matrix([[  1.00000000e+00,   1.66533454e-16,  -8.32667268e-17],
        [ -2.77555756e-16,   1.00000000e+00,  -2.77555756e-17],
        [  1.66533454e-16,   5.55111512e-17,   1.00000000e+00]])

Others

计算皮尔森相关系数矩阵

　　使用np.corrcoef(a)可计算矩阵a的行与行之间的相关系数，np.corrcoef(a,rowvar=0)用于计算各列之间的相关系数R，返回值为相关系数矩阵。

计算斯皮尔曼等级系数矩阵

　　使用scipy.stats.spearmanr(a)可计算矩阵a的列与列之间的相关系数R，scipy.stats.spearmanr(a,axis=1)用于计算各行之间的相关系数R。　　返回两个值，第一个为相关系数矩阵，第二个为 p-value 。

mask

　　使用 numpy.ma 模块可以将array中的某些元素标记为 invalid。

import numpy as np 
import numpy.ma as ma 

x=np.array([1,2,3,4,0.5]) 
mx=ma.masked_array(x,mask=[0,0,0,1,0]) 
mx 
x.mean() 
mx.mean() 

x=np.array([1,2,3,4,0.5]) 
y=np.array([1,2,3,4,0.5,0.6]).reshape(2,3) 

mx=ma.masked_array(x,mask=[0,0,0,1,0]) 
mx=ma.array(x,mask=[0,0,0,1,0])                   # mask the 4-th element 
mx=ma.masked_values(x,0.5)                        # mask values close to 0.5 

masked_equal(x, value[, copy])	                  # Mask an array where equal to a given value.
masked_values(x, value[, rtol, atol, copy, …])	  # Mask using floating point equality.
masked_greater(x, value[, copy])	              # Mask an array where greater than a given value.
masked_greater_equal(x, value[, copy])	          # Mask an array where greater than or equal to a given value.
masked_inside(x, v1, v2[, copy])	              # Mask an array inside a given interval.
masked_outside(x, v1, v2[, copy])	              # Mask an array outside a given interval.
masked_less(x, value[, copy])	                  # Mask an array where less than a given value.
masked_less_equal(x, value[, copy])	              # Mask an array where less than or equal to a given value.
masked_not_equal(x, value[, copy])	              # Mask an array where not equal to a given value.
masked_invalid(a[, copy])	                      # Mask an array where invalid values occur (NaNs or infs).
masked_object(x, value[, copy, shrink])	          # Mask the array x where the data are exactly equal to value.
masked_where(condition, a[, copy])	              # Mask an array where a condition is met.

fix_invalid() # Return input with invalid data masked and replaced by a fill value

getmask and getmaskarray functions

x = ma.array([[1, 2], [3, 4]], mask=[[0, 1], [1, 0]])
x[~x.mask]

x.compressed()

mx.filled()     # Suppose now that we wish to print that same data, but with the missing values replaced by the average value.

Sources: - NumPy简明教程（二、数组1） - NumPy简明教程（二、数组2） - NumPy简明教程（二、数组3） - NumPy-快速处理数据 - 用Python做科学计算