>>> 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.]])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.]])]完全不复制（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]])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]])包含求逆、奇异值分解、生成对角矩阵、解线性方程组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]]))Numpy API文档：https://docs.scipy.org/doc/