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)#