Numpy数组

数组维度变化

• numpy的基本类型是ndarray，即n维数组
• 想用ndarray进行矩阵运算，首先要保证运算对象是二维数组
• 一维数组并不等价于线性代数中的向量，它永远是一行，没有转置，如果想进行矩阵运算必须先升为二维数组：

a = a[:,None]                   # 方法一
a = np.expand_dims(a, axis=1)   # 方法二

例如：

In [1]: import numpy as np                                                                                                        
In [2]: a = np.array([1,2,3])                                                                                                     
In [3]: a                                                                                                                         
Out[3]: array([1, 2, 3])
In [4]: a.T                                                                                                                       
Out[4]: array([1, 2, 3])

In [5]: a = a[:,None]                                                                                                             
In [6]: a                                                                                                                         
Out[6]: 
array([[1],
       [2],
       [3]])
In [7]: a.T                                                                                                                       
Out[7]: array([[1, 2, 3]])

• 二维数组进行矩阵运算不改变数组的维数，即使结果是一个向量也是二维数组

In [8]: a=np.array([[1,2,3]])                                                                                                     
In [9]: b=a                                                                                                                       
In [10]: c=np.dot(a, b.T)                                                                                                         
In [11]: c                                                                                                                        
Out[11]: array([[14]])

• 二维数组通过索引取出一行/列时会降维

In [14]: a=np.ones((3,3))                                                                                                         
In [15]: a                                                                                                                        
Out[15]: 
array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])
In [16]: a[1,:]                                                                                                                   
Out[16]: array([1., 1., 1.])

• np.mean()等内置函数运算后会自动降维，否则要手动指定keepdims=True

In [17]: np.mean(a, axis=1)                                                                                                       
Out[17]: array([1., 1., 1.])
In [18]: np.mean(a, axis=1, keepdims=True)                                                                                        
Out[18]: 
array([[1.],
       [1.],
       [1.]])

• 所以在对ndarray进行运算之前先进行shape的检查是个好习惯

数组操作

• 调整某一维的元素顺序，或按照特定顺序取出部分数组。例如：

In [389]: y
Out[389]: 
array([[0, 1, 2, 3],
       [0, 1, 2, 3],
       [0, 1, 2, 3],
       [0, 1, 2, 3]])

In [390]: y[:, (2,1,0,3)]
Out[390]: 
array([[2, 1, 0, 3],
       [2, 1, 0, 3],
       [2, 1, 0, 3],
       [2, 1, 0, 3]])

常用函数集锦

• np.clip()
• np.percentile()
• np.indice()
• np.lexsort()
  np.lexsort完成了这下面几步：
  index: 0 1 2 3 5 6
  a: 1 5 1 4 3 4 4
  先根据 a 内的数据对每个元素从小到大进行排序可以得到
  index_sorted_v1: 0 2 4 3 5 6 1
  但是可以看到0, 2的大小同为1，3,5,6大小同为4，一般argsort的话会按照原本的顺序来拍，但这里是lexsort，并且我们有b，所以利用b内对应位置元素的大小来进行排序
  b_sorted_v1: 9 0 0 4 2 1 4
  index_sorted_v2: 2 0 4 6 5 3 1
  这就是我们得到的结果ind。