碼上歡樂
相關內容    簡體    繁體

NumPy簡明教程

本文轉載自   查看原文   2016-04-22 10:16   3882    python/django

源地址：http://blog.csdn.net/sunny2038/article/details/9002531

http://blog.csdn.net/sunny2038/article/details/9023797

http://blog.csdn.net/sunny2038/article/details/8907736

NumPy數組（1、數組初探）

更新

目前我的工作是將NumPy引入到Pyston中（一款Dropbox實現的Python編譯器/解釋器）。在工作過程中，我深入接觸了NumPy源碼，了解其實現並提交了PR修復NumPy的bug。在與NumPy源碼以及NumPy開發者打交道的過程中，我發現當今中文NumPy教程大部分都是翻譯或參考英文文檔，因此導致了許多疏漏。比如NumPy數組中的broadcast功能，幾乎所有中文文檔都翻譯為“廣播”。而NumPy的開發者之一，回復到“broadcast is a compound -- native English speakers can see that it's " broad" + "cast" = "cast (scatter, distribute) broadly, I guess "cast (scatter, distribute) broadly" probably is closer to the meaning（NumPy中的含義）"。有鑒於此，我打算啟動一個項目，以我對NumPy使用以及源碼層面的了解編寫一個系列的教程。

地址隨后會更新。CSDN的排版（列表）怎么顯示不正常了。。。

 

NumPy數組

NumPy數組是一個多維數組對象，稱為ndarray。其由兩部分組成：

  • 實際的數據
  • 描述這些數據的元數據

大部分操作僅針對於元數據，而不改變底層實際的數據。

關於NumPy數組有幾點必需了解的：

  • NumPy數組的下標從0開始。
  • 同一個NumPy數組中所有元素的類型必須是相同的。

NumPy數組屬性

 

在詳細介紹NumPy數組之前。先詳細介紹下NumPy數組的基本屬性。NumPy數組的維數稱為秩（rank），一維數組的秩為1，二維數組的秩為2，以此類推。在NumPy中，每一個線性的數組稱為是一個軸（axes），秩其實是描述軸的數量。比如說，二維數組相當於是兩個一維數組，其中第一個一維數組中每個元素又是一個一維數組。所以一維數組就是NumPy中的軸（axes），第一個軸相當於是底層數組，第二個軸是底層數組里的數組。而軸的數量——秩，就是數組的維數。

NumPy的數組中比較重要ndarray對象屬性有：

  • ndarray.ndim：數組的維數（即數組軸的個數），等於秩。最常見的為二維數組（矩陣）。

  • ndarray.shape：數組的維度。為一個表示數組在每個維度上大小的整數元組。例如二維數組中，表示數組的“行數”和“列數”。ndarray.shape返回一個元組，這個元組的長度就是維度的數目，即ndim屬性。

  • ndarray.size：數組元素的總個數，等於shape屬性中元組元素的乘積。

  • ndarray.dtype：表示數組中元素類型的對象，可使用標准的Python類型創建或指定dtype。另外也可使用前一篇文章中介紹的NumPy提供的數據類型。

  • ndarray.itemsize：數組中每個元素的字節大小。例如，一個元素類型為float64的數組itemsiz屬性值為8(float64占用64個bits，每個字節長度為8，所以64/8，占用8個字節），又如，一個元素類型為complex32的數組item屬性為4（32/8）。

  • ndarray.data：包含實際數組元素的緩沖區，由於一般通過數組的索引獲取元素，所以通常不需要使用這個屬性。

創建數組

　　先來介紹創建數組。創建數組的方法有很多。如可以使用array函數從常規的Python列表和元組創造數組。所創建的數組類型由原序列中的元素類型推導而來。　　　
[python] view plain copy
 
  1. >>> from numpy import *  
  2. 　　　  
  3. >>> a = array( [2,3,4] )　　　  
  4. >>> a  
  5.     array([2, 3, 4])  
  6. >>> a.dtype  
  7.     dtype('int32')  
  8. >>> b = array([1.2, 3.5, 5.1])　　　  
  9. >>> b.dtype  
  10.     dtype('float64')  

使用array函數創建時，參數必須是由方括號括起來的列表，而不能使用多個數值作為參數調用array。　　　

[python]  view plain  copy
 
  1. >>> a = array(1,2,3,4)    # 錯誤  
  2. >>> a = array([1,2,3,4])  # 正確  

可使用雙重序列來表示二維的數組，三重序列表示三維數組，以此類推。

[python]  view plain  copy
 
  1. >>> b = array( [ (1.5,2,3), (4,5,6) ] )　　  
  2. >>> b  
  3.     array([[ 1.5,  2. ,  3. ],  
  4. 　　　     [ 4. ,  5. ,  6. ]])  

可以在創建時顯式指定數組中元素的類型

[python]  view plain  copy
 
  1. >>> c = array( [ [1,2], [3,4] ], dtype=complex)  
  2. >>> c  
  3.     array([[ 1.+0.j,  2.+0.j],  
  4. 　　　    [ 3.+0.j,  4.+0.j]])  

通常，剛開始時數組的元素未知，而數組的大小已知。因此，NumPy提供了一些使用占位符創建數組的函數。這些函數有助於滿足除了數組擴展的需要，同時降低了高昂的運算開銷。

用函數zeros可創建一個全是0的數組，用函數ones可創建一個全為1的數組，函數empty創建一個內容隨機並且依賴與內存狀態的數組。默認創建的數組類型(dtype)都是float64。

可以喲娜特d.dtype.itemsize來查看數組中元素占用的字節數目。

[python]  view plain  copy
 
  1. >>> d = zeros((3,4))  
  2. >>> d.dtype  
  3. dtype('float64')  
  4. >>> d  
  5. array([[ 0.,  0.,  0.,  0.],  
  6. 　　   [ 0.,  0.,  0.,  0.],  
  7. 　　   [ 0.,  0.,  0.,  0.]])  
  8. >>> d.dtype.itemsize  
  9. 8  

也可以自己制定數組中元素的類型

[python]  view plain  copy
 
  1. >>> ones( (2,3,4), dtype=int16 )  #手動指定數組中元素類型  
  2.       array([[[1, 1, 1, 1],  
  3. 　　　        [1, 1, 1, 1],  
  4. 　　　        [1, 1, 1, 1]],  
  5. 　　　  
  6. 　　　       [[1, 1, 1, 1],  
  7. 　　　        [1, 1, 1, 1],  
  8. 　　　        [1, 1, 1, 1]]], dtype=int16)  
  9. >>> empty((2,3))  
  10. 　　　array([[  2.65565858e-316,   0.00000000e+000,   0.00000000e+000],  
  11. 　　　       [  0.00000000e+000,   0.00000000e+000,   0.00000000e+000]])  

NumPy提供一個類似arange的函數返回一個數列形式的數組:

[python]  view plain  copy
 
  1. >>> arange(10, 30, 5)  
  2.     array([10, 15, 20, 25])  

以10開始，差值為5的等差數列。該函數不僅接受整數，還接受浮點參數：　

[python]  view plain  copy
 
  1. >>> arange(0,2,0.5)  
  2.     array([ 0. ,  0.5,  1. ,  1.5])  

當arange使用浮點數參數時，由於浮點數精度有限，通常無法預測獲得的元素個數。因此，最好使用函數linspace去接收我們想要的元素個數來代替用range來指定步長。linespace用法如下，將在通用函數一節中詳細介紹。

[python]  view plain  copy
 
  1. >>> numpy.linspace(-1, 0, 5)  
  2.         array([-1.  , -0.75, -0.5 , -0.25,  0.  ])  

數組中的元素是通過下標來訪問的，可以通過方括號括起一個下標來訪問數組中單一一個元素，也可以以切片的形式訪問數組中多個元素。關於切片訪問，將在切片一節介紹。

 

知識點：NumPy中的數據類型
對於科學計算來說，Python中自帶的整型、浮點型和復數類型遠遠不夠，因此NumPy中添加了許多數據類型。如下：

NumPy中的基本數據類型
名稱 描述
bool 用一個字節存儲的布爾類型（True或False）
inti 由所在平台決定其大小的整數（一般為int32或int64）
int8 一個字節大小，-128 至 127
int16 整數，-32768 至 32767
int32 整數，-2 ** 31 至 2 ** 32 -1
int64 整數，-2 ** 63 至 2 ** 63 - 1
uint8 無符號整數，0 至 255
uint16 無符號整數，0 至 65535
uint32 無符號整數，0 至 2 ** 32 - 1
uint64 無符號整數，0 至 2 ** 64 - 1
float16 半精度浮點數：16位，正負號1位，指數5位，精度10位
float32 單精度浮點數：32位，正負號1位，指數8位，精度23位
float64或float 雙精度浮點數：64位，正負號1位，指數11位，精度52位
complex64 復數，分別用兩個32位浮點數表示實部和虛部
complex128或complex 復數，分別用兩個64位浮點數表示實部和虛部

 

NumPy類型轉換方式如下：

[python]  view plain  copy
 
  1. >>> float64(42)  
  2.     42.0  
  3. >>> int8(42.0)  
  4.     42  
  5. >>> bool(42)  
  6.     True  
  7. >>> bool(42.0)  
  8.     True  
  9. >>> float(True)  
  10.     1.0  

許多函數的參數中可以指定參數的類型，當然，這個類型參數是可選的。如下：

[python]  view plain  copy
 
  1. >>> arange(7, dtype=uint16)  
  2.     array([0, 1, 2, 3, 4, 5, 6], dtype=uint16)  

輸出數組

    當輸出一個數組時，NumPy以特定的布局用類似嵌套列表的形式顯示：
  • 第一行從左到右輸出
  • 每行依次自上而下輸出
  • 每個切片通過一個空行與下一個隔開
  • 一維數組被打印成行，二維數組成矩陣，三維數組成矩陣列表。
 　　　
[python] view plain copy
 
  1. >>> a = arange(6)                         # 1d array  
  2. >>> print a  
  3.     [0 1 2 3 4 5]  
  4. 　　　  
  5. >>> b = arange(12).reshape(4,3)           # 2d array  
  6. >>> print b  
  7.     [[ 0  1  2]  
  8.     [ 3  4  5]  
  9.     [ 6  7  8]  
  10.     [ 9 10 11]]　　　  
  11. >>> c = arange(24).reshape(2,3,4)         # 3d array  
  12. >>> print c  
  13.     [[[ 0  1  2  3]  
  14.     [ 4  5  6  7]  
  15.     [ 8  9 10 11]]  
  16. 　　　  
  17.     [[12 13 14 15]  
  18.     [16 17 18 19]  
  19.     [20 21 22 23]]]  
    reshape將在下一篇文章中介紹　
    如果一個數組太長，則NumPy自動省略中間部分而只打印兩端的數據：　　　
[python] view plain copy
 
  1. >>> print arange(10000)  
  2. 　　　[   0    1    2 ..., 9997 9998 9999]  
  3. 　　　  
  4. >>> print arange(10000).reshape(100,100)  
  5. 　　　[[   0    1    2 ...,   97   98   99]  
  6. 　　　 [ 100  101  102 ...,  197  198  199]  
  7. 　　　 [ 200  201  202 ...,  297  298  299]  
  8. 　　　 ...,  
  9. 　　　 [9700 9701 9702 ..., 9797 9798 9799]  
  10. 　　　 [9800 9801 9802 ..., 9897 9898 9899]  
  11. 　　　 [9900 9901 9902 ..., 9997 9998 9999]]  

　　可通過設置printoptions參數來禁用NumPy的這種行為並強制打印整個數組。

基本運算

數組的算術運算是按元素逐個運算。數組運算后將創建包含運算結果的新數組。

[python]  view plain  copy
 
  1. >>> a= np.array([20,30,40,50])  
  2. >>> b= np.arange( 4)  
  3. >>> b  
  4. array([0, 1, 2, 3])  
  5. >>> c= a-b  
  6. >>> c  
  7. array([20, 29, 38, 47])  
  8. >>> b**2  
  9. array([0, 1, 4, 9])  
  10. >>> 10*np.sin(a)  
  11. array([ 9.12945251,-9.88031624, 7.4511316, -2.62374854])  
  12. >>> a<35  
  13. array([True, True, False, False], dtype=bool)  

與其他矩陣語言不同，NumPy中的乘法運算符*按元素逐個計算，矩陣乘法可以使用dot函數或創建矩陣對象實現(后續章節會介紹)

 

 

[python]  view plain  copy
 
  1. >>> A= np.array([[1,1],  
  2. ...[0,1]])  
  3. >>> B= np.array([[2,0],  
  4. ...[3,4]])  
  5. >>> A*B # 逐個元素相乘  
  6. array([[2, 0],  
  7.     　　 [0, 4]])  
  8. >>> np.dot(A,B) # 矩陣相乘  
  9. array([[5, 4],  
  10.     　　 [3, 4]])  

 

　有些操作符如+=和*=用來更改已存在數組而不創建一個新的數組。

 

[python]  view plain  copy
 
  1. >>> a= np.ones((2,3), dtype=int)  
  2. >>> b= np.random.random((2,3))  
  3. >>> a*= 3  
  4. >>> a  
  5. array([[3, 3, 3],  
  6.     　　 [3, 3, 3]])  
  7. >>> b+= a  
  8. >>> b  
  9. array([[ 3.69092703, 3.8324276, 3.0114541],  
  10.     　　　 [ 3.18679111, 3.3039349, 3.37600289]])  
  11. >>> a+= b # b轉換為整數類型  
  12. >>> a  
  13. array([[6, 6, 6],  
  14.            [6, 6, 6]])  

 

當數組中存儲的是不同類型的元素時，數組將使用占用更多位（bit）的數據類型作為其本身的數據類型，也就是偏向更精確的數據類型 (這種行為叫做upcast)。

 

[python]  view plain  copy
 
  1. >>> a= np.ones(3, dtype=np.int32)  
  2. >>> b= np.linspace(0,np.pi,3)  
  3. >>> b.dtype.name  
  4. 'float64'  
  5. >>> c= a+b  
  6. >>> c  
  7. array([ 1., 2.57079633, 4.14159265])  
  8. >>> c.dtype.name  
  9. 'float64'  
  10. >>> d= exp(c*1j)  
  11. >>> d  
  12. array([ 0.54030231+0.84147098j,-0.84147098+0.54030231j,  
  13.     　　　 -0.54030231-0.84147098j])  
  14. >>> d.dtype.name  
  15. 'complex128'  

 

　　許多非數組運算，如計算數組所有元素之和，都作為ndarray類的方法來實現，使用時需要用ndarray類的實例來調用這些方法。
[python]  view plain  copy
 
  1. >>> a= np.random.random((2,3))  
  2. >>> a  
  3. array([[ 0.65806048, 0.58216761, 0.59986935],  
  4.            [ 0.6004008, 0.41965453, 0.71487337]])  
  5. >>> a.sum()  
  6. 　  3.5750261436902333  
  7. >>> a.min()  
  8.      0.41965453489104032  
  9. >>> a.max()  
  10.      0.71487337095581649  
這些運算將數組看作是一維線性列表。但可通過指定axis參數（即數組的行）對指定的軸做相應的運算：

 

[python]  view plain  copy
 
  1. >>> b= np.arange(12).reshape(3,4)  
  2. >>> b  
  3. array([[ 0, 1, 2, 3],  
  4.            [ 4, 5, 6, 7],  
  5.            [ 8, 9, 10, 11]])  
  6. >>> b.sum(axis=0) # 計算每一列的和，注意理解軸的含義，參考數組的第一篇文章  
  7. array([12, 15, 18, 21])  
  8. >>> b.min(axis=1) # 獲取每一行的最小值  
  9. array([0, 4, 8])  
  10. >>> b.cumsum(axis=1) # 計算每一行的累積和  
  11. array([[ 0, 1, 3, 6],  
  12.            [ 4, 9, 15, 22],  
  13.            [ 8, 17, 27, 38]])  

 

索引，切片和迭代

　　　和列表和其它Python序列一樣，一維數組可以進行索引、切片和迭代操作。

 

[python]  view plain  copy
 
  1. >>> a= np.arange(10)**3 #記住，操作符是對數組中逐元素處理的！  
  2. >>> a  
  3. array([0, 1, 8, 27, 64, 125, 216, 343, 512, 729])  
  4. >>> a[2]  
  5. 8  
  6. >>> a[2:5]  
  7. array([ 8, 27, 64])  
  8. >>> a[:6:2]= -1000 # 等同於a[0:6:2]= -1000，從開始到第6個位置，每隔一個元素將其賦值為-1000  
  9. >>> a  
  10. array([-1000, 1,-1000, 27,-1000, 125, 216, 343, 512, 729])  
  11. >>> a[: :-1] # 反轉a  
  12. array([ 729, 512, 343, 216, 125,-1000, 27,-1000, 1,-1000])  
  13. >>>for i in a:  
  14. ...    print i**(1/3.),  
  15. ...  
  16. nan 1.0 nan 3.0 nan 5.0 6.0 7.0 8.0 9.0  

 

　　　多維數組可以每個軸有一個索引。這些索引由一個逗號分割的元組給出。

 

[python]  view plain  copy
 
  1. >>>def f(x,y):  
  2. ...    return 10*x+y  
  3. ...  
  4. >>> b= np.fromfunction(f,(5,4),dtype=int) #fromfunction是一個函數，下篇文章介紹。  
  5. >>> b  
  6. array([[ 0, 1, 2, 3],  
  7.            [10, 11, 12, 13],  
  8.            [20, 21, 22, 23],  
  9.            [30, 31, 32, 33],  
  10.            [40, 41, 42, 43]])  
  11. >>> b[2,3]  
  12. 23  
  13. >>> b[0:5, 1] # 每行的第二個元素  
  14. array([ 1, 11, 21, 31, 41])  
  15. >>> b[: ,1] # 與前面的效果相同  
  16. array([ 1, 11, 21, 31, 41])  
  17. >>> b[1:3,: ] # 每列的第二和第三個元素  
  18. array([[10, 11, 12, 13],  
  19.            [20, 21, 22, 23]])  

 

　　　當少於提供的索引數目少於軸數時，已給出的數值按秩的順序復制，確失的索引則默認為是整個切片：

 

[python]  view plain  copy
 
  1. >>> b[-1] # 最后一行，等同於b[-1,:]，-1是第一個軸，而缺失的認為是：，相當於整個切片。  
  2. array([40, 41, 42, 43])  

 

    b[i]中括號中的表達式被當作i和一系列:，來代表剩下的軸。NumPy也允許你使用“點”像b[i,...]。
    點(…)代表許多產生一個完整的索引元組必要的分號。如果x是秩為5的數組(即它有5個軸)，那么:　　　
  • x[1,2,…] 等同於 x[1,2,:,:,:],  
  • x[…,3] 等同於 x[:,:,:,:,3]
  • x[4,…,5,:] 等同 x[4,:,:,5,:]　

 

[python]  view plain  copy
 
  1. >>> c= array( [ [[ 0, 1, 2], #三維數組（兩個2維數組疊加而成）  
  2. ...[ 10, 12, 13]],  
  3. ...  
  4. ...[[100,101,102],  
  5. ...[110,112,113]]] )  
  6. >>> c.shape  
  7.  (2, 2, 3)  
  8. >>> c[1,...] #等同於c[1,:,:]或c[1]  
  9. array([[100, 101, 102],  
  10.            [110, 112, 113]])  
  11. >>> c[...,2] #等同於c[:,:,2]  
  12. array([[ 2, 13],  
  13.            [102, 113]])  

 

多維數組的遍歷是以是第一個軸為基礎的：

 

[python]  view plain  copy
 
  1. >>>for row in b:  
  2. ...    print row  
  3. ...  
  4. [0 1 2 3]  
  5. [10 11 12 13]  
  6. [20 21 22 23]  
  7. [30 31 32 33]  
  8. [40 41 42 43]  

 

如果想對數組中每個元素都進行處理，可以使用flat屬性，該屬性是一個數組元素迭代器：

 

[python]  view plain  copy
 
  1. >>>for element in b.flat:  
  2. ...    print element,  
  3. ...  
  4. 0 1 2 3 10 11 12 13 20 21 22 23 30 31 32 33 40 41 42 43  

 

更多關於[]、…、newaxis、ndenumerate、indices、index exp的內容請參考NumPy示例

形狀（shape）操作

更改數組的形狀

數組的形狀取決於其每個軸上的元素個數：

 

[python]  view plain  copy
 
  1. >>> a= np.floor(10*np.random.random((3,4)))  
  2. >>> a  
  3. array([[ 7., 5., 9., 3.],  
  4.            [ 7., 2., 7., 8.],  
  5.            [ 6., 8., 3., 2.]])  
  6. >>> a.shape  
  7. (3, 4)  

 

可以用多種方式修改數組的形狀：

 

[python]  view plain  copy
 
  1. >>> a.ravel() # 平坦化數組  
  2. array([ 7., 5., 9., 3., 7., 2., 7., 8., 6., 8., 3., 2.])  
  3. >>> a.shape= (6, 2)  
  4. >>> a.transpose()  
  5. array([[ 7., 9., 7., 7., 6., 3.],  
  6.            [ 5., 3., 2., 8., 8., 2.]])  

 

由ravel()展平的數組元素的順序通常是“C風格”的，就是以行為基准，最右邊的索引變化得最快，所以元素a[0,0]之后是a[0,1]。如果數組改變成其它形狀(reshape)，數組仍然是“C風格”的。NumPy通常創建一個以這個順序保存數據的數組，所以ravel()通常不需要創建起調用數組的副本。但如果數組是通過切片其它數組或有不同尋常的選項時，就可能需要創建其副本。還可以同過一些可選參數函數讓reshape()和ravel()構建FORTRAN風格的數組，即最左邊的索引變化最快。

reshape函數改變調用數組的形狀並返回該數組，而resize函數改變調用數組自身。

 

[python]  view plain  copy
 
  1. >>> a  
  2. array([[ 7., 5.],  
  3.            [ 9., 3.],  
  4.            [ 7., 2.],  
  5.            [ 7., 8.],  
  6.            [ 6., 8.],  
  7.            [ 3., 2.]])  
  8. >>> a.resize((2,6))  
  9. >>> a  
  10. array([[ 7., 5., 9., 3., 7., 2.],  
  11.            [ 7., 8., 6., 8., 3., 2.]])  

 

如果在reshape操作中指定一個維度為-1，那么其准確維度將根據實際情況計算得到

前兩篇文章對NumPy數組做了基本的介紹，本篇文章對NumPy數組進行較深入的探討。首先介紹自定義類型的數組，接着數組的組合，最后介紹數組復制方面的問題。

 

自定義結構數組

 

通過NumPy也可以定義像C語言那樣的結構類型。在NumPy中定義結構的方法如下：

定義結構類型名稱；定義字段名稱，標明字段數據類型。

 

[python]  view plain  copy
 
  1. student= dtype({'names':['name', 'age', 'weight'], 'formats':['S32', 'i','f']}, align = True)  

這里student是自定義結構類型的名稱，使用dtype函數創建，在第一個參數中，'names'和'formats'不能改變，names中列出的是結構中字段名稱，formats中列出的是對應字段的數據類型。S32表示32字節長度的字符串，i表示32位的整數，f表示32位長度的浮點數。最后一個參數為True時，表示要求進行內存對齊。

字段中使用NumPy的字符編碼來表示數據類型。更詳細的數據類型見下表。

數據類型 字符編碼
整數 i
無符號整數 u
單精度浮點數 f
雙精度浮點數 d
布爾值 b
復數 D
字符串 S
Unicode U
Void V
在定義好結構類型之后，就可以定義以該類型為元素的數組了：

 

 

[python]  view plain  copy
 
  1. a= array([(“Zhang”, 32, 65.5), (“Wang”, 24, 55.2)], dtype =student)  

除了在每個元素中依次列出對應字段的數據外，還需要在array函數中最后一個參數指定其所對應的數據類型。

注：例子來源於張若愚的Python科學計算藝術的29頁。更多關於dtype的內容請參考《NumPy for Beginner》一書的第二章。

組合函數

這里介紹以不同的方式組合函數。首先創建兩個數組：

[python]  view plain  copy
 
  1. >>> a = arange(9).reshape(3,3)  
  2. >>> a  
  3. array([[0, 1, 2],  
  4.            [3, 4, 5],  
  5.            [6, 7, 8]])  
  6. >>> b = 2 * a  
  7. >>> b  
  8. array([[ 0, 2, 4],  
  9.        [ 6, 8, 10],  
  10.        [12, 14, 16]])  

水平組合

[python]  view plain  copy
 
  1. >>> hstack((a, b))  
  2. array([[ 0, 1, 2, 0, 2, 4],  
  3.        [ 3, 4, 5, 6, 8, 10],  
  4.        [ 6, 7, 8, 12, 14, 16]])  
也可通過concatenate函數並指定相應的軸來獲得這一效果：
[python]  view plain  copy
 
  1. >>> concatenate((a, b), axis=1)  
  2. array([[ 0, 1, 2, 0, 2, 4],  
  3.        [ 3, 4, 5, 6, 8, 10],  
  4.        [ 6, 7, 8, 12, 14, 16]])  

垂直組合

[python]  view plain  copy
 
  1. >>> vstack((a, b))  
  2. array([[ 0, 1, 2],  
  3.        [ 3, 4, 5],  
  4.        [ 6, 7, 8],   
  5.        [ 0, 2, 4],  
  6.        [ 6, 8, 10],  
  7.        [12, 14, 16]])  
同樣，可通過concatenate函數，並指定相應的軸來獲得這一效果。
[python]  view plain  copy
 
  1. >>> concatenate((a, b), axis=0)  
  2. array([[ 0, 1, 2],  
  3.        [ 3, 4, 5],  
  4.        [ 6, 7, 8],  
  5.        [ 0, 2, 4],  
  6.        [ 6, 8, 10],  
  7.        [12, 14, 16]])  

深度組合

另外，還有深度方面的組合函數dstack。顧名思義，就是在數組的第三個軸（即深度）上組合。如下：

[python]  view plain  copy
 
  1. >>> dstack((a, b))  
  2. array([[[ 0, 0],  
  3.         [ 1, 2],  
  4.         [ 2, 4]],  
  5.   
  6.        [[ 3, 6],  
  7.         [ 4, 8],  
  8.         [ 5, 10]],  
  9.   
  10.        [[ 6, 12],  
  11.         [ 7, 14],  
  12.         [ 8, 16]]])  
仔細觀察，發現對應的元素都組合成一個新的列表，該列表作為新的數組的元素。

行組合

行組合可將多個一維數組作為新數組的每一行進行組合：

[python]  view plain  copy
 
  1. >>> one = arange(2)  
  2. >>> one  
  3. array([0, 1])  
  4. >>> two = one + 2  
  5. >>> two  
  6. array([2, 3])  
  7. >>> row_stack((one, two))  
  8. array([[0, 1],  
  9.        [2, 3]])  

對於2維數組，其作用就像垂直組合一樣。

 

列組合

列組合的效果應該很清楚了。如下：

[python]  view plain  copy
 
  1. >>> column_stack((oned, twiceoned))  
  2. array([[0, 2],  
  3.        [1, 3]])  
對於2維數組，其作用就像水平組合一樣。

 

分割數組

在NumPy中，分割數組的函數有hsplit、vsplit、dsplit和split。可將數組分割成相同大小的子數組，或指定原數組分割的位置。

水平分割

[python]  view plain  copy
 
  1. >>> a = arange(9).reshape(3,3)  
  2. >>> a  
  3. array([[0, 1, 2],  
  4.        [3, 4, 5],  
  5.        [6, 7, 8]])  
  6. >>> hsplit(a, 3)  
  7. [array([[0],  
  8.        [3],  
  9.        [6]]),  
  10.  array([[1],  
  11.        [4],  
  12.        [7]]),  
  13.  array([[2],  
  14.        [5],  
  15.        [8]])]  
也調用split函數並指定軸為1來獲得這樣的效果：
[python]  view plain  copy
 
  1. split(a, 3, axis=1)  

垂直分割

垂直分割是沿着垂直的軸切分數組：

[python]  view plain  copy
 
  1. >>> vsplit(a, 3)  
  2. >>> [array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]  
同樣，也可通過solit函數並指定軸為1來獲得這樣的效果：
[python]  view plain  copy
 
  1. >>> split(a, 3, axis=0)  

 

面向深度的分割

dsplit函數使用的是面向深度的分割方式：

[python]  view plain  copy
 
  1. >>> c = arange(27).reshape(3, 3, 3)  
  2. >>> c  
  3. array([[[ 0,  1,  2],  
  4.         [ 3,  4,  5],  
  5.         [ 6,  7,  8]],  
  6.   
  7.        [[ 9, 10, 11],  
  8.         [12, 13, 14],  
  9.         [15, 16, 17]],  
  10.   
  11.        [[18, 19, 20],  
  12.         [21, 22, 23],  
  13.         [24, 25, 26]]])  
  14. >>> dsplit(c, 3)  
  15. [array([[[ 0],  
  16.         [ 3],  
  17.         [ 6]],  
  18.   
  19.        [[ 9],  
  20.         [12],  
  21.         [15]],  
  22.   
  23.        [[18],  
  24.         [21],  
  25.         [24]]]),  
  26.  array([[[ 1],  
  27.         [ 4],  
  28.         [ 7]],  
  29.   
  30.        [[10],  
  31.         [13],  
  32.         [16]],  
  33.   
  34.        [[19],  
  35.         [22],  
  36.         [25]]]),  
  37.  array([[[ 2],  
  38.         [ 5],  
  39.         [ 8]],  
  40.   
  41.        [[11],  
  42.         [14],  
  43.         [17]],  
  44.   
  45.        [[20],  
  46.         [23],  
  47.         [26]]])]  

 

復制和鏡像（View）

　　　當運算和處理數組時，它們的數據有時被拷貝到新的數組有時不是。這通常是新手的困惑之源。這有三種情況:

完全不復制

　　　簡單的賦值，而不復制數組對象或它們的數據。

[python]  view plain  copy
 
  1. >>> a = arange(12)  
  2. >>> b = a      #不創建新對象  
  3. >>> b is a           # a和b是同一個數組對象的兩個名字  
  4. True  
  5. >>> b.shape = 3,4    #也改變了a的形狀  
  6. >>> a.shape  
  7. (3, 4)  

 

 　　　Python 傳遞不定對象作為參考4，所以函數調用不拷貝數組。

 

[python]  view plain  copy
 
  1. >>> def f(x):  
  2. ...     print id(x)  
  3. ...  
  4. >>> id(a)       #id是一個對象的唯一標識  
  5. 148293216  
  6. >>> f(a)  
  7. 148293216  

 

視圖(view)和淺復制

　　　不同的數組對象分享同一個數據。視圖方法創造一個新的數組對象指向同一數據。

[python]  view plain  copy
 
  1. >>> c = a.view()  
  2. >>> c is a  
  3. False  
  4. >>> c.base is a      #c是a持有數據的鏡像  
  5. True  
  6. >>> c.flags.owndata  
  7. False  
  8. >>>  
  9. >>> c.shape = 2,6    # a的形狀沒變  
  10. >>> a.shape  
  11. (3, 4)  
  12. >>> c[0,4] = 1234        #a的數據改變了  
  13. >>> a  
  14. array([[   0,    1,    2,    3],  
  15.        [1234,    5,    6,    7],  
  16.        [   8,    9,   10,   11]])  
切片數組返回它的一個視圖：
[python]  view plain  copy
 
  1. >>> s = a[ : , 1:3]     # 獲得每一行1，2處的元素  
  2. >>> s[:] = 10           # s[:] 是s的鏡像。注意區別s=10 and s[:]=10  
  3. >>> a  
  4. array([[   0,   10,   10,    3],  
  5.        [1234,   10,   10,    7],  
  6.        [   8,   10,   10,   11]])  

 

深復制

 　　這個復制方法完全復制數組和它的數據。

[python]  view plain  copy
 
  1. >>> d = a.copy()       #創建了一個含有新數據的新數組對象  
  2. >>> d is a  
  3. False  
  4. >>> d.base is a        #d和a現在沒有任何關系  
  5. False  
  6. >>> d[0,0] = 9999  
  7. >>> a  
  8. array([[   0,   10,   10,    3],  
  9.        [1234,   10,   10,    7],  
  10.        [   8,   10,   10,   11]])  

 

參考文獻： 

《Python科學計算》 
《Tentative NumPy Tutorial》
《NumPy for Beginner》

更多關於shape、reshape、resize和ravel的內容請參考NumPy示例

 
  1. set_printoptions(threshold='nan')  

這樣，輸出時數組的所有元素都會顯示出來。


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Dapper簡明教程 LaTeX簡明教程(二) MarkDown簡明教程 DEVONthink 簡明教程 tig簡明教程 Dapper簡明教程 vim簡明教程 Pytest 簡明教程 shell簡明教程 Kdenlive簡明教程-開始
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM