numpy

在討論numpy的具體函式和方法之前，我要先說明一下兩個問題：1，numpy中的陣列和向量。2，numpy中的“多軸陣列”。

維度vs軸數

numpy中裡有多維陣列，為了避免和線性代數中的多維陣列區別開，這裡暫時稱之為多軸陣列。

我們首先生成一個三維陣列，裡面存放數字0-36：

arr = np.arange(36).reshape(3, 4, 3)

我們可以將這個三軸陣列看作一個立方體：每一個小立方體代表一個數字，這些數字按照一定的方式堆砌（排列組合）成一個3*4*3的立方體。三個軸分別為axis0, axis1, axis2。

那麼這個reshape方法中的3個引數3，4，3到底指的是什麼呢？其實，它們規定了：

這個軸的方向上有幾個維度！

注意，我們說的numpy中的二維陣列（比如是n階的），實際上是線性代數中的n維陣列，或者稱為n階方陣。我們在python裡把它叫做二維陣列，並不表明這個陣列線上性空間中是2階的，而是這個陣列可以在二維平面中表示出來。比如我們舉的這個例子，三軸陣列就不能在二維平面中表現出來，但我們可以在三維空間裡將它形象化。

有了上面的解釋，我們便可以知道：axis0方向上有三個維度，axis1方向上有4個維度，axis2方向上有3個維度。

從axis0的方向上看過去，一共有3個維度，每一維都是4*3的”二軸陣列“。

從axis1的方向上看過去，一共有4個維度，每一維都是3*3的”二軸陣列“。

從axis2的方向上看過去，一共有3個維度，每一維都是3*4的”二軸陣列“。

好了，其實我們只要知道python中的多維陣列，和線性代數中的多維陣列完全不同就可以了。我們通常還是隻使用二軸陣列，只要不造成歧義，表述成“二維n階陣列”也是可以的。

numpy中按軸進行的操作有很多，我們將軸的概念理解好，會對矩陣操作帶來很大的方便，接下來舉幾個例子：

import numpy as np
​
arr = np.arange(12).reshape(4, 3)
mean0 = np.mean(arr,axis=0)#在axis0方向（向下，列方向）上操作，即對每一列求均值
mean1 = np.mean(arr,axis=1)#每一行的均值
sum0 = np.sum(arr,axis=0
 
)#每一列的和
sum1 = np.sum(arr,axis=1)#每一行的和
min0 = arr.min(0)#每一列的最小值
min1 = arr.min(1)#每一行的最小值
max0 = arr.max(0)#每一列的最大值
min1 = arr.max(1)#每一行的最大值
​
mean0
Out[8]: array([4.5, 5.5, 6.5])
mean1
Out[9]: array([ 1.,  4.,  7., 10.])
sum0
Out[12]: array([18, 22, 26])
sum1
Out[11]: array([ 3, 12, 21, 30])

我們定義了一個4*3的矩陣。axis0方向的長度是4，axis1方向的長度是3.從axis0的方向看過去矩陣是3個4維列向量，從axis1的方向看過去是4個3維的行向量。

所以，按axis=0操作時，都是按照（axis1個）列向量操作的；按axis=1操作時都是按照（axis0個）列向量操作的；

我們按照axis0來求每個列向量平均數，得到了一個3階陣列；按照axis1來求每個行向量平均數，得到了一個4階陣列。

我們已經將arr reshape成了一個4*3的矩陣，axis0對應的軸上應該有四個維度（4行），按axis0軸求和就是將這四個維度（中的4個數據）求和，之後再按axis1的方向移動求另外三個資料的和，一共移動3次。

當然也可以簡記為：axis=0是按列，axis=1是按行操作。

向量vs陣列

我們用shape方法來獲取一個矩陣的形狀，它會會返回一個元組，還會用到T方法來進行矩陣轉置。舉一個簡單的例子：

arr1 = np.arange(36)
​
arr1.shape
Out[14]: (36,)
​
arr1.T.shape
Out[15]: (36,)

對於arr1這個陣列，轉置沒有效果。這說明我們有一個錯誤的觀念：多維陣列就是矩陣，一維陣列就是列向量。這句話的前半句沒有任何問題，但一維陣列只是“一組有順序的數”，並不是向量。你瞧它的形狀是(36,)，而非(36,1)。欲將其變為列向量或者行向量也簡單，需要用到numpy中的expand_dims方法，需要給他兩個引數，第二個是給定的軸（在這個軸的方向上增加維度）。也可以直接用matrix生成矩陣。

arr2 = np.expand_dims(arr1, axis=0)#朝著axis0的方向，即行
arr3 = np.expand_dims(arr1, axis=1)#朝著axis1的方向，即列
arr4 = np.matrix([1, 2, 3])
arr5 = np.matrix([1, 2, 3]).T
​
arr2.shape
Out[17]: (1, 36)#行向量
arr3.shape
Out[18]: (36, 1)#列向量
arr4.shape
Out[19]: (1, 3)#行向量
arr5.shape
Out[20]: (3, 1)#列向量

除了expand_dims方法外，還有其他的構造向量的方法，我們用下面的例子做一個測試，探索一下array函式構造矩陣的原理：

test1 = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8])
test2 = np.array([[0, 1, 2, 3, 4, 5, 6, 7, 8]])
​
test1.shape
Out[25]: (9,)
test2.shape
Out[26]: (1, 9)

可以看出test1的方式是構造了一個數組，而test2的方式是構造了一個行向量。分析一下array構造矩陣的原理：

np.array([[#, #, #],
[#, #, #],
[#, #, #]])

array方法中，傳入的引數是一個列表。這個列表中存在n個子列表，便構造n行的矩陣，每個子列表中有m列元素就構造m列的矩陣。所以array的維度是由傳入的列表中，子列表的個數n，和子列表中的元素個數m共同確定的。

那麼特例就是：子列表的個數為1，相當於構造了一個1行的矩陣，即行向量。子列表有多個，但每個子列表中元素個數為1，那麼這就是一個列向量咯。

數乘vs點乘

arr1 = np.array([[1, 2, 3],
                 [4, 5, 6],
                 [7, 8, 9]])
arr2 = np.arange(1, 10).reshape((3, 3))
arr3 = np.eye(3)
arr4 = np.matrix([1,2,3]).T
​
arr1 + 10
Out[65]:
[[11 12 13]
 [14 15 16]
 [17 18 19]]
​
arr1 + arr4
Out[77]: 
matrix([[ 2,  3,  4],
        [ 6,  7,  8],
        [10, 11, 12]])

arr1*arr3
Out[66]:
[[1. 0. 0.]
 [0. 5. 0.]
 [0. 0. 9.]]

arr1.dot(arr3)#等同於np.dot(arr1,arr3)
Out[67]:
[[1. 2. 3.]
 [4. 5. 6.]
 [7. 8. 9.]]

2**arr1
Out[68]:
[[  2   4   8]
 [ 16  32  64]
 [128 256 512]]

arr1**2
Out[69]:
[[ 1  4  9]
 [16 25 36]
 [49 64 81]]

數與矩陣相加，即與矩陣每一個元素相加。列向量與矩陣相加，即列向量與每一列相加。

np.dot(arr1,arr3)進行的是常規的矩陣乘法，兩個矩陣的形狀必須遵循“前列等後行“的規則。而arr1*arr3就是對應位置的元素作乘積，需要兩個矩陣的形狀相同。

切片vs拷貝

我們之間已經知道列表的切片就等於淺拷貝。那麼對於陣列也一樣嗎。

myarr16 = myarr[1]
myarr17 = myarr[1, 2]
myarr18 = myarr[1][2]
myarr19 = myarr[:, ::-1]
myarr20 = myarr[::-1, ::-1] 
myarr21 = myarr[::-1].copy()
​
np.may_share_memory(myarr19, myarr)
Out[46]: True
np.may_share_memory(myarr20, myarr)
Out[47]: True
np.may_share_memory(myarr21, myarr)
Out[48]: False
​

陣列的切片有兩種方法，如myarr17和myarr18。為了和列表切片區分開來，習慣於用myarr18的構造方式。

用numpy中的方法may_share_memory來檢視，兩個陣列是否共享記憶體，也即是否為新陣列創了新記憶體。可以發現切片始終與原陣列共享記憶體，而copy方法進行了記憶體的建立，賦值。

高階切片

array的切片的元素可以是一個列表，表示抽取除這些行，或列。

myarr22 = np.random.randint(0, 20 ,10).reshape(2, 5)
myarr23 = myarr22[:, [4, 2]] 
​
myarr23
Out[54]: 
array([[17,  4],
       [ 1, 15]])

myarr22是一個2*5的矩陣，我們得到的myarr23是抽取出每一行的第5列，和第3列組成的新陣列。

重新排序

myarr19 = myarr[:, ::-1]
myarr20 = myarr[::-1, ::-1] 
myarr21 = myarr[::-1].copy()

其實我們利用切片就可以對陣列進行逆序排列。

myarr19進行列逆序排列, 第一個:不能少。因為np是預設按行進行操作的，如果只給一個引數，如myarr21會將該切片操作應用到每一行上，即將myarr的行之間逆序。

陣列沒有列表的原地排序的sort方法。

array0 = np.array([[9, 8, 7, 6],
[6, 5, 4, 3],
[3, 2, 1, 0]])
array1 = np.sort(array0, axis=0)#朝著axis0的維度，對每一個列向量排序
array2 = np.argsort(array0, axis=0)
array3 = np.sort(array0, axis=1)#朝著axis1的維度，對每一個行向量排序
array4 = np.argsort(array0, axis=1) 
​
array1
Out[50]: 
array([[3, 2, 1, 0],
       [6, 5, 4, 3],
       [9, 8, 7, 6]])
​
array2
Out[51]: 
array([[2, 2, 2, 2],
       [1, 1, 1, 1],
       [0, 0, 0, 0]], dtype=int64)
​
array3
Out[52]: 
array([[6, 7, 8, 9],
       [3, 4, 5, 6],
       [0, 1, 2, 3]])
​
array4
Out[53]: 
array([[3, 2, 1, 0],
       [3, 2, 1, 0],
       [3, 2, 1, 0]], dtype=int64)

array2是按列排序返回順序列表，返回矩陣中的列向量表示：原矩陣中對應列向量從小到大排列之後，對應元素在原列表中的位置。也即是array1中列向量的元素在array0中對應列向量的索引。

相關推薦