李燕西 2018-05-29
1 shape变化及转置
a = np.floor(10*np.random.random((3,4)))
a
array([[ 2., 8., 0., 6.],
[ 4., 5., 1., 1.],
[ 8., 9., 3., 6.]])
a.shape
(3, 4)
a.ravel() # 转化为一维数组
array([ 2., 8., 0., 6., 4., 5., 1., 1., 8., 9., 3., 6.])
a.reshape(6,2) # 将数组a转化为指定shape的数组
array([[ 2., 8.],
[ 0., 6.],
[ 4., 5.],
[ 1., 1.],
[ 8., 9.],
[ 3., 6.]])
a.T # 数组的转置
array([[ 2., 4., 8.],
[ 8., 5., 9.],
[ 0., 1., 3.],
[ 6., 1., 6.]])
a.T.shape
(4, 3)
a.shape
(3, 4)
注意对数组进行reshape操作不会改变原有数组a,但resize会在原有数组a上进行改变:
a.resize((2,6))
a
array([[ 2., 8., 0., 6., 4., 5.],
[ 1., 1., 8., 9., 3., 6.]])
当reshape方法中有参数为-1,则表示numpy会自己计算-1位置的维数,这在很多深度学习模型中可以见到。
a.reshape(3,-1)
array([[ 2., 8., 0., 6.],
[ 4., 5., 1., 1.],
[ 8., 9., 3., 6.]])
2 数组的合并与拆分
concatenate连接
x = numpy.array([[1, 2, 3], [4, 5, 6]])
y = numpy.array([[7, 8, 9], [10, 11, 12]])
numpy.concatenate([x, y], axis = 0) # 竖直组合
[[ 1 2 3][ 4 5 6][ 7 8 9][10 11 12]]
numpy.concatenate([x, y], axis = 1) # 水平组合
[[ 1 2 3 7 8 9][ 4 5 6 10 11 12]]
横向合并,沿第一个轴进行堆叠,比如:vstack或row_stack
a = np.floor(10*np.random.random((2,2)))
a
array([[ 8., 8.],
[ 0., 0.]])
b = np.floor(10*np.random.random((2,2)))
b
array([[ 1., 8.],
[ 0., 4.]])
np.vstack((a,b))
array([[ 8., 8.],
[ 0., 0.],
[ 1., 8.],
[ 0., 4.]])
纵向合并,沿着第二个轴进行堆叠,比如hstack和column_stack,两者不一样,column_stack在对一维数组进行堆叠时会先将一维数组转化为二维数组,最终返回二维数组。
np.hstack((a,b)) #使用hstack对二维数组进行纵向合并
array([[ 8., 8., 1., 8.],
[ 0., 0., 0., 4.]])
np.column_stack((a,b)) #使用column_stack对二维数组进行纵向合并
array([[ 8., 8., 1., 8.],
[ 0., 0., 0., 4.]])
a = np.array([4.,2.])
b = np.array([3.,8.])
np.column_stack((a,b)) #使用column_stack对一维数组进行纵向合并,返回二维数组
array([[ 4., 3.],
[ 2., 8.]])
np.hstack((a,b)) #使用hstack对一维数组进行纵向合并,返回一维数组
array([ 4., 2., 3., 8.])
array_split ,numpy.array_split(ary, indices_or_sections, axis=0),沿着第一个轴从左至右的顺序切分:
x = np.arange(8.0)
np.array_split(x, 3)
[array([ 0., 1., 2.]), array([ 3., 4., 5.]), array([ 6., 7.])]
x = np.arange(7.0)
np.array_split(x, 3)
[array([ 0., 1., 2.]), array([ 3., 4.]), array([ 5., 6.])]
vsplit,沿着第一个轴切分,相当于split方法中参数axis=0
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.vsplit(x, 2)
[array([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.]]),
array([[ 8., 9., 10., 11.],
[ 12., 13., 14., 15.]])]
hsplit,沿着第二个轴切分,相当于split方法中参数axis=1
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.]])]
3 数组的复制
完全不复制(No Copy at All)
a = np.arange(12)
b = a # no new object is created
b is a # a and b are two names for the same ndarray object
True
b.shape = 3,4 # changes the shape of a
a.shape
(3, 4)
这种方式的“复制”其实没有实际复制,只是将变量b在内存的索引指向了变量a所在的内存,这样变量a和变量b均指向同一块内存,这时候改变了b就相当于改变了a。
浅复制
使用view方法来创建一个新的数组对象,并把将被复制的数组a的视图(view)复制到新的数组对象c中,这时的c数据完全来自于a,和a保持完全一致,换句话说,c的数据完全由a保管,他们两个的数据变化是一致的:
c = a.view()
c is a
False
c.base is a # c只是a的视图
True
c.flags.owndata
False
c.shape = 2,6 # a的shape不会变化
a.shape
(3, 4)
c[0,4] = 1234 # a的值会相应的变化
a
array([[ 0, 1, 2, 3],
[1234, 5, 6, 7],
[ 8, 9, 10, 11]])
切片也是一种浅复制:
s = a[ : , 1:3] # 将a的第2列与第三列浅复制给s
s[:] = 10 # 将s的所有元素重新赋值为10,也会改变a相应位置的值
a
array([[ 0, 10, 10, 3],
[1234, 10, 10, 7],
[ 8, 10, 10, 11]])
深复制
使用copy方法,不仅将被复制数组的索引复制到新的数组中,也将被复制数组的元素复制到新的数组中。
d = a.copy() # 创建一个新的数组
d is a
False
d.base is a
False
d[0,0] = 9999
a
array([[ 0, 10, 10, 3],
[1234, 10, 10, 7],
[ 8, 10, 10, 11]])
4 Fancy indexing与布尔索引
Fancy indexing是指传递索引数组以便一次得到多个数组元素。使用Fancy indexing时返回数组的shape是索引数组的shape而不是被索引的原数组的shape。
一维数组的Fancy indexing
a = np.arange(12)**2
i = np.array( [ 1,1,3,8,5 ] ) # 索引数组
a[i]
array([ 1, 1, 9, 64, 25])
j = np.array( [ [ 3, 4], [ 9, 7 ] ] )
a[j]
array([[ 9, 16],
[81, 49]])
多维数组的Fancy indexing
a = np.arange(12).reshape(3,4)
a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
i = np.array( [ [0,1], # 横向索引
... [1,2] ] )
j = np.array( [ [2,1], # 纵向索引
... [3,3] ] )
a[i,j]
array([[ 2, 5],
[ 7, 11]])
a[i,2]
array([[ 2, 6],
[ 6, 10]])
a[:,j]
array([[[ 2, 1],
[ 3, 3]],
[[ 6, 5],
[ 7, 7]],
[[10, 9],
[11, 11]]])
如果索引数组包含多个相同的索引,那么最后的索引会覆盖前面的索引。
a = np.arange(5)
a[[0,0,2]]=[1,2,3]
a
array([2, 1, 3, 3, 4])
但对于类似“+=”累加的操作却不会叠加两次:
a = np.arange(5)
a[[0,0,2]]+=1
a
array([1, 1, 3, 3, 4])
布尔索引
索引数组元素为布尔类型的值:
a = np.arange(12).reshape(3,4)
b = a 4
b
array([[False, False, False, False],
[False, True, True, True],
[ True, True, True, True]])
a[b]
array([ 5, 6, 7, 8, 9, 10, 11])
a[b] = 0
a
array([[0, 1, 2, 3],
[4, 0, 0, 0],
[0, 0, 0, 0]])
索引数组有多个
a = np.arange(12).reshape(3,4)
b1 = np.array([False,True,True])
b2 = np.array([True,False,True,False]) 、
a[b1,:]
array([[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
a[b1]
array([[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
a[:,b2]
array([[ 0, 2],
[ 4, 6],
[ 8, 10]])
5 Numpy的线性代数(Linear Algebra)
包含求逆、奇异值分解、生成对角矩阵、解线性方程组Ax=b、计算特征值与特征向量等
import numpy as np
a = np.array([[1.0, 2.0], [3.0, 4.0]])
print(a)
[[ 1. 2.]
[ 3. 4.]]
a.transpose() # 转置
array([[ 1., 3.],
[ 2., 4.]])
np.linalg.inv(a) # 求逆
array([[-2. , 1. ],
[ 1.5, -0.5]])
u = np.eye(2) # 生成对角矩阵
u
array([[ 1., 0.],
[ 0., 1.]])
j = np.array([[0.0, -1.0], [1.0, 0.0]])
np.dot (j, j) # 矩阵乘
array([[-1., 0.],
[ 0., -1.]])
np.trace(u) # 求对角线元素和
2.0
y = np.array([[5.], [7.]])
np.linalg.solve(a, y) # 解线性方程组Ax=b
array([[-3.],
[ 4.]])
np.linalg.eig(j) #计算特征值与特征向量
(array([ 0.+1.j, 0.-1.j]), array([[ 0.70710678+0.j , 0.70710678-0.j ],
[ 0.00000000-0.70710678j, 0.00000000+0.70710678j]]))
什么是数组数组是一种线性表数据结构,它用一组连续的内存空间来存储一组具有相同类型的数据。典型的线性表有数组、链表、队列和栈。直接将第 k 位的数据搬移到数组元素最后,然后把新的元素直接放在第 k 位。