Numpy 数组基础操作--索引、组合、分割、复制、遍历、转换、序列化（四）

Numpy 数组基础操作

1.数组索引访问

#!/usr/bin/env python  
# encoding: utf-8  

import numpy as np

b = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]],dtype=int)

c = b[0,1]  #1行 第二个单元元素
# 输出： 2

d = b[:,1]  #所有行 第二个单元元素
# 输出： [ 2  5  8 11]

e = b[1,:]  #2行 所有单元元素
# 输出： [4 5 6]

f = b[1,1:]  #2行 第2个单元开始以后所有元素
# 输出： [5 6]

g = b[1,:2]  #2行 第1个单元开始到索引为2以前的所有元素
# 输出： [4 5]

2.数组的组合（函数）

"""
# 组合函数
#创建两个测试数组
# arange 创建一个含有9个元素的一维
# reshape方法，可以创建一个改变了尺寸的新数组，原数组的shape保持不变：
# 在这里 reshape(3,3) 将生成一个 3个元素为一组的 3维数组 
"""

#创建两个测试数组
a = np.arange(9).reshape(3,3)  
"""
 array([[0, 1, 2],  
           [3, 4, 5],  
           [6, 7, 8]])  
"""
b = 2 * a
"""
array([[ 0, 2, 4],  
       [ 6, 8, 10],  
       [12, 14, 16]])  

"""

#水平组合

np.hstack((a, b)) 
"""
array([[ 0, 1, 2, 0, 2, 4],  
       [ 3, 4, 5, 6, 8, 10],  
       [ 6, 7, 8, 12, 14, 16]]) 
"""

#通过concatenate函数并指定相应的轴 (axis=1 水平，axis=0 垂直)
con = np.concatenate((a, b), axis=1)
"""
array([[ 0, 1, 2, 0, 2, 4],  
       [ 3, 4, 5, 6, 8, 10],  
       [ 6, 7, 8, 12, 14, 16]])  
"""

#垂直组合

np.vstack((a, b))
"""
array([[ 0, 1, 2],  
       [ 3, 4, 5],  
       [ 6, 7, 8],   
       [ 0, 2, 4],  
       [ 6, 8, 10],  
       [12, 14, 16]])  

"""
#或者使用concatenate 
con = np.concatenate((a, b), axis=0)

#深度组合 dstack(就是在数组的第三个轴（即深度）上组合,生成一个新的列表数组)

np.dstack((a, b))  
"""
array([[[ 0, 0],  
        [ 1, 2],  
        [ 2, 4]],  
  
       [[ 3, 6],  
        [ 4, 8],  
        [ 5, 10]],  
  
       [[ 6, 12],  
        [ 7, 14],  
        [ 8, 16]]])  

"""

#行组合,行组合可将多个一维数组作为新数组的每一行进行组合
#对于2维数组，其作用就像垂直组合一样。

one = np.arange(2)
"""
array([0, 1])
"""

two = one + 2 
"""
array([2, 3])
"""

np.row_stack((one, two))
"""

array([[0, 1],  
       [2, 3]]) 
"""

#列组合(对于2维数组，其作用就像水平组合一样。)

np.column_stack((oned, twiceoned))  
"""
array([[0, 2],  
       [1, 3]])  
"""

3.数组分割

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

#水平分割

a = arange(9).reshape(3,3) 
"""
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]])] 

"""
#方法二：用split函数并指定轴为1
np.split(a, 3, axis=1)  

#垂直分割
#垂直分割是沿着垂直的轴切分数组：

np.vsplit(a, 3)  
"""
[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])] 
"""

#方法二
#solit函数并指定轴为1
np.split(a, 3, axis=0)

#面向深度的分割
#dsplit函数使用的是面向深度的分割

c = arange(27).reshape(3, 3, 3)  

"""
array([[[ 0,  1,  2],  
        [ 3,  4,  5],  
        [ 6,  7,  8]],  
  
       [[ 9, 10, 11],  
        [12, 13, 14],  
        [15, 16, 17]],  
  
       [[18, 19, 20],  
        [21, 22, 23],  
        [24, 25, 26]]])  

"""

np.dsplit(c, 3) 
"""
[array([[[ 0],  
        [ 3],  
        [ 6]],  
  
       [[ 9],  
        [12],  
        [15]],  
  
       [[18],  
        [21],  
        [24]]]),  
 array([[[ 1],  
        [ 4],  
        [ 7]],  
  
       [[10],  
        [13],  
        [16]],  
  
       [[19],  
        [22],  
        [25]]]),  
 array([[[ 2],  
        [ 5],  
        [ 8]],  
  
       [[11],  
        [14],  
        [17]],  
  
       [[20],  
        [23],  
        [26]]])]  
"""

4.判断数组是否共享内存，也是用来直接判断数据是复制的还是镜像的

#方法一：
a = np.arange(50)
b = a.reshape((5, 10))
print (b.base is a)

#方法二：
print (np.may_share_memory(a, b))

#方法三：
print (b.flags["OWNDATA"])  #False -- apparently this is a view
e = np.ravel(b[:, 2])
print (e.flags["OWNDATA"])  #True -- Apparently this is a new numpy object.

5.数组复制和镜像( view )

1.)完全不复制 ,简单的赋值，而不复制数组对象或它们的数据。

a = np.arange(12)  
b = a      #不创建新对象  
b is a     # a和b是同一个数组对象的两个名字
#  true
    
b.shape = 3,4    #也改变了a的形状 
print a.shape
"""
(3, 4)
"""

2.) view的用法 视图方法创造一个新的数组对象指向同一数据。

事实上，没有任何数据类型是固定的，主要取决于如何看待这片数据的内存区域。
在numpy.ndarray.view中，提供对内存区域不同的切割方式，来完成数据类型的转换，而无须要对数据进行额外的copy，来节约内存空间。

c = a.view()  
c is a  
# false

c.base is a      #c是a持有数据的镜像 
#true

c.shape = 2,6    # a的形状没变
print(a.shape)  # (3, 4) 

c[0,4] = 1234        #a的数据改变了
print  a
"""
array([[   0,    1,    2,    3],  
       [1234,    5,    6,    7],  
       [   8,    9,   10,   11]])
"""

3.)切片数组返回它的一个视图

s = a[ : , 1:3]     # 获得每一行1，2处的元素
s[:] = 10           # s[:] 是s的镜像。注意区别s=10 and s[:]=10 
print a
"""
array([[   0,   10,   10,    3],  
       [1234,   10,   10,    7],  
       [   8,   10,   10,   11]])  
"""

4.)深复制,这个复制方法完全复制数组和它的数据。

d = a.copy()       #创建了一个含有新数据的新数组对象
d is a
#False

d.base is a        #d和a现在没有任何关系
#False  

d[0,0] = 9999
print a
"""
array([[   0,   10,   10,    3],  
       [1234,   10,   10,    7],  
       [   8,   10,   10,   11]]) 
"""

5.）在图像处理中的应用

当需要对输入图像三个通道进行相同的处理时，使用cv2.split和cv2.merge是相当浪费资源的，因为任何一个通道的数据对处理来说都是一样的，我们可以用view来将其转换为一维矩阵后再做处理，这要不需要额外的内存开销和时间开销。

def createFlatView(array):  
    """Return a 1D view of an array of any dimensionality."""  
    flatView = array.view()  
    flatView.shape = array.size  
    return flatView  

5.数组遍历

a = np.arange(9).reshape(3,3) 
for row in a:
  print row 
"""
[0 1 2]
[3 4 5]
[6 7 8]

"""

#对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
for element in a.flat:
  print element
"""
0 1 2 3 4 5 6 7 8
"""

6.数据类型转换

np.float64(42) # to float64
#42.0

np.int8(42.0)  # to int8
#42

np.bool(42)   # to bool
#True  

np.bool(42.0)  # to bool
#True  

np.float(True)  # to float
#1.0 


#函数的参数中可以指定参数的类型
arange(7, dtype=uint16)  
    array([0, 1, 2, 3, 4, 5, 6], dtype=uint16)

6.数组序列化和反序列化

序列化是将对象状态转换为可保持或传输的形式的过程。序列化的补集是反序列化，后者将流转换为对象。这两个过程一起保证数据易于存储和传输。

python 提供pickle, cPickle 对象序列化/反序列化

这里使用numpy 提供的函数

#预定义数据栏位名称和类型  
table = np.loadtxt("example.txt",dtype="names": ("ID", "Result", "Type"),  
    "formats": ("S4", "f4", "i2"))  
np.savetxt("somenewfile.txt")#序列化  
#二进制文件加载，保存  
data = np.empty((1000, 1000))  
np.save("test.npy", data)  
np.savez("test.npz", data)#采用压缩  
newdata = np.load("test.npy")   

7.数组中最大值最小值

mat.max(0)#n维数组axis=0维度的最小值，最大值  
mat.min(0)# 

参考和转载：

http://blog.csdn.net/sunny2038/article/details/8907736