Numpy的那些事兒

時間 2019-11-17

標籤 numpy 那些事兒简体版

原文原文鏈接

2　NumPy-快速處理數據

標準安裝的Python中用列表(list)保存一組值，能夠用來看成數組使用，不過因爲列表的元素能夠是任何對象，所以列表中所保存的是對象的指針。這樣爲了保存一個簡單的[1,2,3]，須要有3個指針和三個整數對象。對於數值運算來講這種結構顯然比較浪費內存和CPU計算時間。html

此外Python還提供了一個array模塊，array對象和列表不一樣，它直接保存數值，和C語言的一維數組比較相似。可是因爲它不支持多維，也沒有各類運算函數，所以也不適合作數值運算。python

NumPy的誕生彌補了這些不足，NumPy提供了兩種基本的對象：ndarray（N-dimensional array object）和 ufunc（universal function object）。ndarray(下文統一稱之爲數組)是存儲單一數據類型的多維數組，而ufunc則是可以對數組進行處理的函數。小程序

2.1　ndarray對象

函數庫的導入數組

本書的示例程序假設用如下推薦的方式導入NumPy函數庫:數據結構

 
        import numpy as np  
       

2.1.1　建立

首先須要建立數組才能對其進行其它操做。app

咱們能夠經過給array函數傳遞Python的序列對象建立數組，若是傳遞的是多層嵌套的序列，將建立多維數組(下例中的變量c):dom

 
        >>> a = np.array([1, 2, 3, 4]) >>> b = np.array((5, 6, 7, 8)) >>> c = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]]) >>> b array([5, 6, 7, 8]) >>> c array([[1, 2, 3, 4],  [4, 5, 6, 7],  [7, 8, 9, 10]]) >>> c.dtype dtype('int32')  
       

數組的大小能夠經過其shape屬性得到：ide

 
        >>> a.shape (4,) >>> c.shape (3, 4)  
       

數組a的shape只有一個元素，所以它是一維數組。而數組c的shape有兩個元素，所以它是二維數組，其中第0軸的長度爲3，第1軸的長度爲4。還能夠經過修改數組的shape屬性，在保持數組元素個數不變的狀況下，改變數組每一個軸的長度。下面的例子將數組c的shape改成(4,3)，注意從(3,4)改成(4,3)並非對數組進行轉置，而只是改變每一個軸的大小，數組元素在內存中的位置並無改變：函數

 
        >>> c.shape = 4,3 >>> c array([[ 1, 2, 3],  [ 4, 4, 5],  [ 6, 7, 7],  [ 8, 9, 10]])  
       

當某個軸的元素爲-1時，將根據數組元素的個數自動計算此軸的長度，所以下面的程序將數組c的shape改成了(2,6)：oop

 
        >>> c.shape = 2,-1 >>> c array([[ 1, 2, 3, 4, 4, 5],  [ 6, 7, 7, 8, 9, 10]])  
       

使用數組的reshape方法，能夠建立一個改變了尺寸的新數組，原數組的shape保持不變：

 
        >>> d = a.reshape((2,2)) >>> d array([[1, 2],  [3, 4]]) >>> a array([1, 2, 3, 4])  
       

數組a和d其實共享數據存儲內存區域，所以修改其中任意一個數組的元素都會同時修改另一個數組的內容：

 
        >>> a[1] = 100 # 將數組a的第一個元素改成100 >>> d # 注意數組d中的2也被改變了 array([[ 1, 100],  [ 3, 4]])  
       

數組的元素類型能夠經過dtype屬性得到。上面例子中的參數序列的元素都是整數，所以所建立的數組的元素類型也是整數，而且是32bit的長整型。能夠經過dtype參數在建立時指定元素類型:

 
        >>> np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]], dtype=np.float) array([[ 1., 2., 3., 4.],  [ 4., 5., 6., 7.],  [ 7., 8., 9., 10.]]) >>> np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]], dtype=np.complex) array([[ 1.+0.j, 2.+0.j, 3.+0.j, 4.+0.j],  [ 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j],  [ 7.+0.j, 8.+0.j, 9.+0.j, 10.+0.j]])  
       

上面的例子都是先建立一個Python序列，而後經過array函數將其轉換爲數組，這樣作顯然效率不高。所以NumPy提供了不少專門用來建立數組的函數。下面的每一個函數都有一些關鍵字參數，具體用法請查看函數說明。

arange函數相似於python的range函數，經過指定開始值、終值和步長來建立一維數組，注意數組不包括終值:
```
>>> np.arange(0,1,0.1) array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]) 
```

linspace函數經過指定開始值、終值和元素個數來建立一維數組，能夠經過endpoint關鍵字指定是否包括終值，缺省設置是包括終值:

 
          >>> np.linspace(0, 1, 12) array([ 0. , 0.09090909, 0.18181818, 0.27272727, 0.36363636,  0.45454545, 0.54545455, 0.63636364, 0.72727273, 0.81818182,  0.90909091, 1. ])  
         

logspace函數和linspace相似，不過它建立等比數列，下面的例子產生1(10^0)到100(10^2)、有20個元素的等比數列:

 
          >>> np.logspace(0, 2, 20) array([ 1. , 1.27427499, 1.62377674, 2.06913808,  2.6366509 , 3.35981829, 4.2813324 , 5.45559478,  6.95192796, 8.8586679 , 11.28837892, 14.38449888,  18.32980711, 23.35721469, 29.76351442, 37.92690191,  48.32930239, 61.58482111, 78.47599704, 100. ])  
         

此外，使用frombuffer, fromstring, fromfile等函數能夠從字節序列建立數組，下面以fromstring爲例:

 
        >>> s = "abcdefgh"  
       

Python的字符串其實是字節序列，每一個字符佔一個字節，所以若是從字符串s建立一個8bit的整數數組的話，所獲得的數組正好就是字符串中每一個字符的ASCII編碼:

 
        >>> np.fromstring(s, dtype=np.int8) array([ 97, 98, 99, 100, 101, 102, 103, 104], dtype=int8)  
       

若是從字符串s建立16bit的整數數組，那麼兩個相鄰的字節就表示一個整數，把字節98和字節97看成一個16位的整數，它的值就是98*256+97 = 25185。能夠看出內存中是以little endian(低位字節在前)方式保存數據的。

 
        >>> np.fromstring(s, dtype=np.int16) array([25185, 25699, 26213, 26727], dtype=int16) >>> 98*256+97 25185  
       

若是把整個字符串轉換爲一個64位的雙精度浮點數數組，那麼它的值是:

 
        >>> np.fromstring(s, dtype=np.float) array([ 8.54088322e+194])  
       

顯然這個例子沒有什麼意義，可是能夠想象若是咱們用C語言的二進制方式寫了一組double類型的數值到某個文件中，那們能夠今後文件讀取相應的數據，並經過fromstring函數將其轉換爲float64類型的數組。

咱們能夠寫一個Python的函數，它將數組下標轉換爲數組中對應的值，而後使用此函數建立數組：

 
        >>> def func(i): ... return i%4+1 ... >>> np.fromfunction(func, (10,)) array([ 1., 2., 3., 4., 1., 2., 3., 4., 1., 2.])  
       

fromfunction函數的第一個參數爲計算每一個數組元素的函數，第二個參數爲數組的大小(shape)，由於它支持多維數組，因此第二個參數必須是一個序列，本例中用(10,)建立一個10元素的一維數組。

下面的例子建立一個二維數組表示九九乘法表，輸出的數組a中的每一個元素a[i, j]都等於func2(i, j)：

 
        >>> def func2(i, j): ... return (i+1) * (j+1) ... >>> a = np.fromfunction(func2, (9,9)) >>> a array([[ 1., 2., 3., 4., 5., 6., 7., 8., 9.],  [ 2., 4., 6., 8., 10., 12., 14., 16., 18.],  [ 3., 6., 9., 12., 15., 18., 21., 24., 27.],  [ 4., 8., 12., 16., 20., 24., 28., 32., 36.],  [ 5., 10., 15., 20., 25., 30., 35., 40., 45.],  [ 6., 12., 18., 24., 30., 36., 42., 48., 54.],  [ 7., 14., 21., 28., 35., 42., 49., 56., 63.],  [ 8., 16., 24., 32., 40., 48., 56., 64., 72.],  [ 9., 18., 27., 36., 45., 54., 63., 72., 81.]])  
       

2.1.2　存取元素

數組元素的存取方法和Python的標準方法相同：

 
        >>> a = np.arange(10) >>> a[5] # 用整數做爲下標能夠獲取數組中的某個元素 5 >>> a[3:5] # 用範圍做爲下標獲取數組的一個切片，包括a[3]不包括a[5] array([3, 4]) >>> a[:5] # 省略開始下標，表示從a[0]開始 array([0, 1, 2, 3, 4]) >>> a[:-1] # 下標可使用負數，表示從數組後往前數 array([0, 1, 2, 3, 4, 5, 6, 7, 8]) >>> a[2:4] = 100,101 # 下標還能夠用來修改元素的值 >>> a array([ 0, 1, 100, 101, 4, 5, 6, 7, 8, 9]) >>> a[1:-1:2] # 範圍中的第三個參數表示步長，2表示隔一個元素取一個元素 array([ 1, 101, 5, 7]) >>> a[::-1] # 省略範圍的開始下標和結束下標，步長爲-1，整個數組頭尾顛倒 array([ 9, 8, 7, 6, 5, 4, 101, 100, 1, 0]) >>> a[5:1:-2] # 步長爲負數時，開始下標必須大於結束下標 array([ 5, 101])  
       

和Python的列表序列不一樣，經過下標範圍獲取的新的數組是原始數組的一個視圖。它與原始數組共享同一塊數據空間：

 
        >>> b = a[3:7] # 經過下標範圍產生一個新的數組b，b和a共享同一塊數據空間 >>> b array([101, 4, 5, 6]) >>> b[2] = -10 # 將b的第2個元素修改成-10 >>> b array([101, 4, -10, 6]) >>> a # a的第5個元素也被修改成10 array([ 0, 1, 100, 101, 4, -10, 6, 7, 8, 9])  
       

除了使用下標範圍存取元素以外，NumPy還提供了兩種存取元素的高級方法。

使用整數序列

當使用整數序列對數組元素進行存取時，將使用整數序列中的每一個元素做爲下標，整數序列能夠是列表或者數組。使用整數序列做爲下標得到的數組不和原始數組共享數據空間。

 
        >>> x = np.arange(10,1,-1) >>> x array([10, 9, 8, 7, 6, 5, 4, 3, 2]) >>> x[[3, 3, 1, 8]] # 獲取x中的下標爲3, 3, 1, 8的4個元素，組成一個新的數組 array([7, 7, 9, 2]) >>> b = x[np.array([3,3,-3,8])] #下標能夠是負數 >>> b[2] = 100 >>> b array([7, 7, 100, 2]) >>> x # 因爲b和x不共享數據空間，所以x中的值並無改變 array([10, 9, 8, 7, 6, 5, 4, 3, 2]) >>> x[[3,5,1]] = -1, -2, -3 # 整數序列下標也能夠用來修改元素的值 >>> x array([10, -3, 8, -1, 6, -2, 4, 3, 2])  
       

使用布爾數組

當使用布爾數組b做爲下標存取數組x中的元素時，將收集數組x中全部在數組b中對應下標爲True的元素。使用布爾數組做爲下標得到的數組不和原始數組共享數據空間，注意這種方式只對應於布爾數組，不能使用布爾列表。

 
        >>> x = np.arange(5,0,-1) >>> x array([5, 4, 3, 2, 1]) >>> x[np.array([True, False, True, False, False])] >>> # 布爾數組中下標爲0，2的元素爲True，所以獲取x中下標爲0,2的元素 array([5, 3]) >>> x[[True, False, True, False, False]] >>> # 若是是布爾列表，則把True看成1, False看成0，按照整數序列方式獲取x中的元素 array([4, 5, 4, 5, 5]) >>> x[np.array([True, False, True, True])] >>> # 布爾數組的長度不夠時，不夠的部分都看成False array([5, 3, 2]) >>> x[np.array([True, False, True, True])] = -1, -2, -3 >>> # 布爾數組下標也能夠用來修改元素 >>> x array([-1, 4, -2, -3, 1])  
       

布爾數組通常不是手工產生，而是使用布爾運算的ufunc函數產生，關於ufunc函數請參照 ufunc運算一節。

 
        >>> x = np.random.rand(10) # 產生一個長度爲10，元素值爲0-1的隨機數的數組 >>> x array([ 0.72223939, 0.921226 , 0.7770805 , 0.2055047 , 0.17567449,  0.95799412, 0.12015178, 0.7627083 , 0.43260184, 0.91379859]) >>> x>0.5 >>> # 數組x中的每一個元素和0.5進行大小比較，獲得一個布爾數組，True表示x中對應的值大於0.5 array([ True, True, True, False, False, True, False, True, False, True], dtype=bool) >>> x[x>0.5] >>> # 使用x>0.5返回的布爾數組收集x中的元素，所以獲得的結果是x中全部大於0.5的元素的數組 array([ 0.72223939, 0.921226 , 0.7770805 , 0.95799412, 0.7627083 ,  0.91379859])  
       

2.1.3　多維數組

多維數組的存取和一維數組相似，由於多維數組有多個軸，所以它的下標須要用多個值來表示，NumPy採用組元(tuple)做爲數組的下標。如圖2.1所示，a爲一個6x6的數組，圖中用顏色區分了各個下標以及其對應的選擇區域。

組元不須要圓括號

雖然咱們常常在Python中用圓括號將組元括起來，可是其實組元的語法定義只須要用逗號隔開便可，例如 x,y=y,x 就是用組元交換變量值的一個例子。

圖2.1 使用數組切片語法訪問多維數組中的元素

如何建立這個數組

你也許會對如何建立a這樣的數組感到好奇，數組a其實是一個加法表，縱軸的值爲0, 10, 20, 30, 40, 50；橫軸的值爲0, 1, 2, 3, 4, 5。縱軸的每一個元素都和橫軸的每一個元素求和，就獲得圖中所示的數組a。你能夠用下面的語句建立它，至於其原理咱們將在後面的章節進行討論：

 
         >>> np.arange(0, 60, 10).reshape(-1, 1) + np.arange(0, 6) array([[ 0, 1, 2, 3, 4, 5],  [10, 11, 12, 13, 14, 15],  [20, 21, 22, 23, 24, 25],  [30, 31, 32, 33, 34, 35],  [40, 41, 42, 43, 44, 45],  [50, 51, 52, 53, 54, 55]])  
        

多維數組一樣也可使用整數序列和布爾數組進行存取。

圖2.2 使用整數序列和布爾數組訪問多維數組中的元素

a[(0,1,2,3,4),(1,2,3,4,5)] : 用於存取數組的下標和仍然是一個有兩個元素的組元，組元中的每一個元素都是整數序列，分別對應數組的第0軸和第1軸。從兩個序列的對應位置取出兩個整數組成下標： a[0,1], a[1,2], ..., a[4,5]。
a[3:, [0, 2, 5]] : 下標中的第0軸是一個範圍，它選取第3行以後的全部行；第1軸是整數序列，它選取第0, 2, 5三列。
a[mask, 2] : 下標的第0軸是一個布爾數組，它選取第0，2，5行；第1軸是一個整數，選取第2列。

2.1.4　結構數組

在C語言中咱們能夠經過struct關鍵字定義結構類型，結構中的字段佔據連續的內存空間，每一個結構體佔用的內存大小都相同，所以能夠很容易地定義結構數組。和C語言同樣，在NumPy中也很容易對這種結構數組進行操做。只要NumPy中的結構定義和C語言中的定義相同，NumPy就能夠很方便地讀取C語言的結構數組的二進制數據，轉換爲NumPy的結構數組。

假設咱們須要定義一個結構數組，它的每一個元素都有name, age和weight字段。在NumPy中能夠以下定義：

 
        import numpy as np persontype = np.dtype({ 'names':['name', 'age', 'weight'], 'formats':['S32','i', 'f']}) a = np.array([("Zhang",32,75.5),("Wang",24,65.2)], dtype=persontype)  
       

咱們先建立一個dtype對象persontype，經過其字典參數描述結構類型的各個字段。字典有兩個關鍵字：names，formats。每一個關鍵字對應的值都是一個列表。names定義結構中的每一個字段名，而formats則定義每一個字段的類型：

S32 : 32個字節的字符串類型，因爲結構中的每一個元素的大小必須固定，所以須要指定字符串的長度
i : 32bit的整數類型，至關於np.int32
f : 32bit的單精度浮點數類型，至關於np.float32

而後咱們調用array函數建立數組，經過關鍵字參數 dtype=persontype，指定所建立的數組的元素類型爲結構persontype。運行上面程序以後，咱們能夠在IPython中執行以下的語句查看數組a的元素類型

 
        >>> a.dtype dtype([('name', '|S32'), ('age', '<i4'), ('weight', '<f4')])  
       

這裏咱們看到了另一種描述結構類型的方法：一個包含多個組元的列表，其中形如 (字段名, 類型描述) 的組元描述告終構中的每一個字段。類型描述前面爲咱們添加了 '|', '<' 等字符，這些字符用來描述字段值的字節順序：

| : 忽視字節順序
< : 低位字節在前
> : 高位字節在前

結構數組的存取方式和通常數組相同，經過下標可以取得其中的元素，注意元素的值看上去像是組元，實際上它是一個結構：

 
        >>> a[0] ('Zhang', 32, 75.5) >>> a[0].dtype dtype([('name', '|S32'), ('age', '<i4'), ('weight', '<f4')])  
       

a[0]是一個結構元素，它和數組a共享內存數據，所以能夠經過修改它的字段，改變原始數組中的對應字段：

 
        >>> c = a[1] >>> c["name"] = "Li" >>> a[1]["name"] "Li"  
       

結構像字典同樣能夠經過字符串下標獲取其對應的字段值：

 
        >>> a[0]["name"] 'Zhang'  
       

咱們不但能夠得到結構元素的某個字段，還能夠直接得到結構數組的字段，它返回的是原始數組的視圖，所以能夠經過修改b[0]改變a[0]["age"]：

 
        >>> b=a[:]["age"] # 或者a["age"] >>> b array([32, 24]) >>> b[0] = 40 >>> a[0]["age"] 40  
       

經過調用a.tostring或者a.tofile方法，能夠直接輸出數組a的二進制形式：

 
        >>> a.tofile("test.bin")  
       

利用下面的C語言程序能夠將test.bin文件中的數據讀取出來。

內存對齊

C語言的結構體爲了內存尋址方便，會自動的添加一些填充用的字節，這叫作內存對齊。例如若是把下面的name[32]改成name[30]的話，因爲內存對齊問題，在name和age中間會填補兩個字節，最終的結構體大小不會改變。所以若是numpy中的所配置的內存大小不符合C語言的對齊規範的話，將會出現數據錯位。爲了解決這個問題，在建立dtype對象時，能夠傳遞參數align=True，這樣numpy的結構數組的內存對齊和C語言的結構體就一致了。

 
        #include <stdio.h>

struct person { char name[32]; int age; float weight; }; struct person p[2]; void main () { FILE *fp; int i; fp=fopen("test.bin","rb"); fread(p, sizeof(struct person), 2, fp); fclose(fp); for(i=0;i<2;i++) printf("%s %d %f\n", p[i].name, p[i].age, p[i].weight); getchar(); }

結構類型中能夠包括其它的結構類型，下面的語句建立一個有一個字段f1的結構，f1的值是另一個結構，它有字段f2，其類型爲16bit整數。

 
        >>> np.dtype([('f1', [('f2', np.int16)])]) dtype([('f1', [('f2', '<i2')])])  
       

當某個字段類型爲數組時，用組元的第三個參數表示，下面描述的f1字段是一個shape爲(2,3)的雙精度浮點數組:

 
        >>> np.dtype([('f0', 'i4'), ('f1', 'f8', (2, 3))]) dtype([('f0', '<i4'), ('f1', '<f8', (2, 3))])  
       

用下面的字典參數也能夠定義結構類型，字典的關鍵字爲結構中字段名，值爲字段的類型描述，可是因爲字典的關鍵字是沒有順序的，所以字段的順序須要在類型描述中給出，類型描述是一個組元，它的第二個值給出字段的字節爲單位的偏移量，例如age字段的偏移量爲25個字節：

 
        >>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)}) dtype([('surname', '|S25'), ('age', '|u1')])  
       

2.1.5　內存結構

下面讓咱們來看看ndarray數組對象是如何在內存中儲存的。如圖2.3所示，關於數組的描述信息保存在一個數據結構中，這個結構引用兩個對象：一塊用於保存數據的存儲區域和一個用於描述元素類型的dtype對象。

圖2.3 ndarray數組對象在內存中的儲存方式

數據存儲區域保存着數組中全部元素的二進制數據，dtype對象則知道如何將元素的二進制數據轉換爲可用的值。數組的維數、大小等信息都保存在ndarray數組對象的數據結構中。圖中顯示的是以下數組的內存結構：

 
        >>> a = np.array([[0,1,2],[3,4,5],[6,7,8]], dtype=np.float32)  
       

strides中保存的是當每一個軸的下標增長1時，數據存儲區中的指針所增長的字節數。例如圖中的strides爲12,4，即第0軸的下標增長1時，數據的地址增長12個字節：即a[1,0]的地址比a[0,0]的地址要高12個字節，正好是3個單精度浮點數的總字節數；第1軸下標增長1時，數據的地址增長4個字節，正好是單精度浮點數的字節數。

若是strides中的數值正好和對應軸所佔據的字節數相同的話，那麼數據在內存中是連續存儲的。然而數據並不必定都是連續儲存的，前面介紹過經過下標範圍獲得新的數組是原始數組的視圖，即它和原始視圖共享數據存儲區域：

 
        >>> b = a[::2,::2] >>> b array([[ 0., 2.],  [ 6., 8.]], dtype=float32) >>> b.strides (24, 8)  
       

因爲數組b和數組a共享數據存儲區，而b中的第0軸和第1軸都是數組a中隔一個元素取一個，所以數組b的strides變成了24,8，正好都是數組a的兩倍。對照前面的圖很容易看出數據0和2的地址相差8個字節，而0和6的地址相差24個字節。

元素在數據存儲區中的排列格式有兩種：C語言格式和Fortan語言格式。在C語言中，多維數組的第0軸是最上位的，即第0軸的下標增長1時，元素的地址增長的字節數最多；而Fortan語言的多維數組的第0軸是最下位的，即第0軸的下標增長1時，地址只增長一個元素的字節數。在NumPy中，元素在內存中的排列缺省是以C語言格式存儲的，若是你但願改成Fortan格式的話，只須要給數組傳遞order="F"參數：

 
        >>> c = np.array([[0,1,2],[3,4,5],[6,7,8]], dtype=np.float32, order="F") >>> c.strides (4, 12)  
       

2.2　ufunc運算

ufunc是universal function的縮寫，它是一種能對數組的每一個元素進行操做的函數。NumPy內置的許多ufunc函數都是在C語言級別實現的，所以它們的計算速度很是快。讓咱們來看一個例子：

 
       >>> x = np.linspace(0, 2*np.pi, 10) # 對數組x中的每一個元素進行正弦計算，返回一個一樣大小的新數組 >>> y = np.sin(x) >>> y array([ 0.00000000e+00, 6.42787610e-01, 9.84807753e-01,  8.66025404e-01, 3.42020143e-01, -3.42020143e-01,  -8.66025404e-01, -9.84807753e-01, -6.42787610e-01,  -2.44921271e-16])  
      

先用linspace產生一個從0到2*PI的等距離的10個數，而後將其傳遞給sin函數，因爲np.sin是一個ufunc函數，所以它對x中的每一個元素求正弦值，而後將結果返回，而且賦值給y。計算以後x中的值並無改變，而是新建立了一個數組保存結果。若是咱們但願將sin函數所計算的結果直接覆蓋到數組x上去的話，能夠將要被覆蓋的數組做爲第二個參數傳遞給ufunc函數。例如：:

 
       >>> t = np.sin(x,x) >>> x array([ 0.00000000e+00, 6.42787610e-01, 9.84807753e-01,  8.66025404e-01, 3.42020143e-01, -3.42020143e-01,  -8.66025404e-01, -9.84807753e-01, -6.42787610e-01,  -2.44921271e-16]) >>> id(t) == id(x) True  
      

sin函數的第二個參數也是x，那麼它所作的事情就是對x中的每給值求正弦值，而且把結果保存到x中的對應的位置中。此時函數的返回值仍然是整個計算的結果，只不過它就是x，所以兩個變量的id是相同的(變量t和變量x指向同一塊內存區域)。

我用下面這個小程序，比較了一下numpy.math和Python標準庫的math.sin的計算速度：:

 
       import time import math import numpy as np x = [i * 0.001 for i in xrange(1000000)] start = time.clock() for i, t in enumerate(x): x[i] = math.sin(t) print "math.sin:", time.clock() - start x = [i * 0.001 for i in xrange(1000000)] x = np.array(x) start = time.clock() np.sin(x,x) print "numpy.sin:", time.clock() - start # 輸出 # math.sin: 1.15426932753 # numpy.sin: 0.0882399858083  
      

在個人電腦上計算100萬次正弦值，numpy.sin比math.sin快10倍多。這得利於numpy.sin在C語言級別的循環計算。numpy.sin一樣也支持對單個數值求正弦，例如：numpy.sin(0.5)。不過值得注意的是，對單個數的計算math.sin則比numpy.sin快得多了，讓咱們看下面這個測試程序：

 
       x = [i * 0.001 for i in xrange(1000000)] start = time.clock() for i, t in enumerate(x): x[i] = np.sin(t) print "numpy.sin loop:", time.clock() - start # 輸出 # numpy.sin loop: 5.72166965355  
      

請注意numpy.sin的計算速度只有math.sin的1/5。這是由於numpy.sin爲了同時支持數組和單個值的計算，其C語言的內部實現要比math.sin複雜不少，若是咱們一樣在Python級別進行循環的話，就會看出其中的差異了。此外，numpy.sin返回的數的類型和math.sin返回的類型有所不一樣，math.sin返回的是Python的標準float類型，而numpy.sin則返回一個numpy.float64類型：

 
       >>> type(math.sin(0.5)) <type 'float'> >>> type(np.sin(0.5)) <type 'numpy.float64'>  
      

經過上面的例子咱們瞭解瞭如何最有效率地使用math庫和numpy庫中的數學函數。由於它們各有長短，所以在導入時不建議使用*號所有載入，而是應該使用import numpy as np的方式載入，這樣咱們能夠根據須要選擇合適的函數調用。

NumPy中有衆多的ufunc函數爲咱們提供各式各樣的計算。除了sin這種單輸入函數以外，還有許多多個輸入的函數，add函數就是一個最經常使用的例子。先來看一個例子:

 
       >>> a = np.arange(0,4) >>> a array([0, 1, 2, 3]) >>> b = np.arange(1,5) >>> b array([1, 2, 3, 4]) >>> np.add(a,b) array([1, 3, 5, 7]) >>> np.add(a,b,a) array([1, 3, 5, 7]) >>> a array([1, 3, 5, 7])  
      

add函數返回一個新的數組，此數組的每一個元素都爲兩個參數數組的對應元素之和。它接受第3個參數指定計算結果所要寫入的數組，若是指定的話，add函數就再也不產生新的數組。

因爲Python的操做符重載功能，計算兩個數組相加能夠簡單地寫爲a+b，而np.add(a,b,a)則能夠用a+=b來表示。下面是數組的運算符和其對應的ufunc函數的一個列表，注意除號"/"的意義根據是否激活__future__.division有所不一樣。

y = x1 + x2:	add(x1, x2 [, y])
y = x1 - x2:	subtract(x1, x2 [, y])
y = x1 * x2:	multiply (x1, x2 [, y])
y = x1 / x2:	divide (x1, x2 [, y]), 若是兩個數組的元素爲整數，那麼用整數除法
y = x1 / x2:	true divide (x1, x2 [, y]), 老是返回精確的商
y = x1 // x2:	floor divide (x1, x2 [, y]), 老是對返回值取整
y = -x:	negative(x [,y])
y = x1**x2:	power(x1, x2 [, y])
y = x1 % x2:	remainder(x1, x2 [, y]), mod(x1, x2, [, y])

數組對象支持這些操做符，極大地簡化了算式的編寫，不過要注意若是你的算式很複雜，而且要運算的數組很大的話，會由於產生大量的中間結果而下降程序的運算效率。例如：假設a b c三個數組採用算式x=a*b+c計算，那麼它至關於:

 
       t = a * b x = t + c del t  
      

也就是說須要產生一個數組t保存乘法的計算結果，而後再產生最後的結果數組x。咱們能夠經過手工將一個算式分解爲x = a*b; x += c，以減小一次內存分配。

經過組合標準的ufunc函數的調用，能夠實現各類算式的數組計算。不過有些時候這種算式不易編寫，而針對每一個元素的計算函數卻很容易用Python實現，這時能夠用frompyfunc函數將一個計算單個元素的函數轉換成ufunc函數。這樣就能夠方便地用所產生的ufunc函數對數組進行計算了。讓咱們來看一個例子。

咱們想用一個分段函數描述三角波，三角波的樣子如圖2.4所示：

圖2.4 三角波能夠用分段函數進行計算

咱們很容易根據上圖所示寫出以下的計算三角波某點y座標的函數:

 
       def triangle_wave(x, c, c0, hc): x = x - int(x) # 三角波的週期爲1，所以只取x座標的小數部分進行計算 if x >= c: r = 0.0 elif x < c0: r = x / c0 * hc else: r = (c-x) / (c-c0) * hc return r  
      

顯然triangle_wave函數只能計算單個數值，不能對數組直接進行處理。咱們能夠用下面的方法先使用列表包容(List comprehension)，計算出一個list，而後用array函數將列表轉換爲數組：

 
       x = np.linspace(0, 2, 1000) y = np.array([triangle_wave(t, 0.6, 0.4, 1.0) for t in x])  
      

這種作法每次都須要使用列表包容語法調用函數，對於多維數組是很麻煩的。讓咱們來看看如何用frompyfunc函數來解決這個問題：

 
       triangle_ufunc = np.frompyfunc( lambda x: triangle_wave(x, 0.6, 0.4, 1.0), 1, 1) y2 = triangle_ufunc(x)  
      

frompyfunc的調用格式爲frompyfunc(func, nin, nout)，其中func是計算單個元素的函數，nin是此函數的輸入參數的個數，nout是此函數的返回值的個數。雖然triangle_wave函數有4個參數，可是因爲後三個c, c0, hc在整個計算中值都是固定的，所以所產生的ufunc函數其實只有一個參數。爲了知足這個條件，咱們用一個lambda函數對triangle_wave的參數進行一次包裝。這樣傳入frompyfunc的函數就只有一個參數了。這樣子作，效率並非過高，另外還有一種方法：

 
       def triangle_func(c, c0, hc): def trifunc(x): x = x - int(x) # 三角波的週期爲1，所以只取x座標的小數部分進行計算 if x >= c: r = 0.0 elif x < c0: r = x / c0 * hc else: r = (c-x) / (c-c0) * hc return r # 用trifunc函數建立一個ufunc函數，能夠直接對數組進行計算, 不過經過此函數 # 計算獲得的是一個Object數組，須要進行類型轉換 return np.frompyfunc(trifunc, 1, 1) y2 = triangle_func(0.6, 0.4, 1.0)(x)  
      

咱們經過函數triangle_func包裝三角波的三個參數，在其內部定義一個計算三角波的函數trifunc，trifunc函數在調用時會採用triangle_func的參數進行計算。最後triangle_func返回用frompyfunc轉換結果。

值得注意的是用frompyfunc獲得的函數計算出的數組元素的類型爲object，由於frompyfunc函數沒法保證Python函數返回的數據類型都徹底一致。所以還須要再次 y2.astype(np.float64)將其轉換爲雙精度浮點數組。

2.2.1　廣播

當咱們使用ufunc函數對兩個數組進行計算時，ufunc函數會對這兩個數組的對應元素進行計算，所以它要求這兩個數組有相同的大小(shape相同)。若是兩個數組的shape不一樣的話，會進行以下的廣播(broadcasting)處理：

讓全部輸入數組都向其中shape最長的數組看齊，shape中不足的部分都經過在前面加1補齊
輸出數組的shape是輸入數組shape的各個軸上的最大值
若是輸入數組的某個軸和輸出數組的對應軸的長度相同或者其長度爲1時，這個數組可以用來計算，不然出錯
當輸入數組的某個軸的長度爲1時，沿着此軸運算時都用此軸上的第一組值

上述4條規則理解起來可能比較費勁，讓咱們來看一個實際的例子。

先建立一個二維數組a，其shape爲(6,1)：

 
        >>> a = np.arange(0, 60, 10).reshape(-1, 1) >>> a array([[ 0], [10], [20], [30], [40], [50]]) >>> a.shape (6, 1)  
       

再建立一維數組b，其shape爲(5,)：

 
        >>> b = np.arange(0, 5) >>> b array([0, 1, 2, 3, 4]) >>> b.shape (5,)  
       

計算a和b的和，獲得一個加法表，它至關於計算a,b中全部元素組的和，獲得一個shape爲(6,5)的數組：

 
        >>> c = a + b >>> c array([[ 0, 1, 2, 3, 4],  [10, 11, 12, 13, 14],  [20, 21, 22, 23, 24],  [30, 31, 32, 33, 34],  [40, 41, 42, 43, 44],  [50, 51, 52, 53, 54]]) >>> c.shape (6, 5)  
       

因爲a和b的shape長度(也就是ndim屬性)不一樣，根據規則1，須要讓b的shape向a對齊，因而將b的shape前面加1，補齊爲(1,5)。至關於作了以下計算：

 
        >>> b.shape=1,5 >>> b array([[0, 1, 2, 3, 4]])  
       

這樣加法運算的兩個輸入數組的shape分別爲(6,1)和(1,5)，根據規則2，輸出數組的各個軸的長度爲輸入數組各個軸上的長度的最大值，可知輸出數組的shape爲(6,5)。

因爲b的第0軸上的長度爲1，而a的第0軸上的長度爲6，所以爲了讓它們在第0軸上可以相加，須要將b在第0軸上的長度擴展爲6，這至關於：

 
        >>> b = b.repeat(6,axis=0) >>> b array([[0, 1, 2, 3, 4],  [0, 1, 2, 3, 4],  [0, 1, 2, 3, 4],  [0, 1, 2, 3, 4],  [0, 1, 2, 3, 4],  [0, 1, 2, 3, 4]])  
       

因爲a的第1軸的長度爲1，而b的第一軸長度爲5，所以爲了讓它們在第1軸上可以相加，須要將a在第1軸上的長度擴展爲5，這至關於：

 
        >>> a = a.repeat(5, axis=1) >>> a array([[ 0, 0, 0, 0, 0],  [10, 10, 10, 10, 10],  [20, 20, 20, 20, 20],  [30, 30, 30, 30, 30],  [40, 40, 40, 40, 40],  [50, 50, 50, 50, 50]])  
       

通過上述處理以後，a和b就能夠按對應元素進行相加運算了。

固然，numpy在執行a+b運算時，其內部並不會真正將長度爲1的軸用repeat函數進行擴展，若是這樣作的話就太浪費空間了。

因爲這種廣播計算很經常使用，所以numpy提供了一個快速產生如上面a,b數組的方法： ogrid對象：

 
        >>> x,y = np.ogrid[0:5,0:5] >>> x array([[0],  [1],  [2],  [3],  [4]]) >>> y array([[0, 1, 2, 3, 4]])  
       

ogrid是一個頗有趣的對象，它像一個多維數組同樣，用切片組元做爲下標進行存取，返回的是一組能夠用來廣播計算的數組。其切片下標有兩種形式：

開始值:結束值:步長，和np.arange(開始值, 結束值, 步長)相似
開始值:結束值:長度j，當第三個參數爲虛數時，它表示返回的數組的長度，和np.linspace(開始值, 結束值, 長度)相似：
```
>>> x, y = np.ogrid[0:1:4j, 0:1:3j] >>> x array([[ 0. ],  [ 0.33333333],  [ 0.66666667],  [ 1. ]]) >>> y array([[ 0. , 0.5, 1. ]]) 
```

ogrid爲何不是函數

根據Python的語法，只有在中括號中才能使用用冒號隔開的切片語法，若是ogrid是函數的話，那麼這些切片必須使用slice函數建立，這顯然會增長代碼的長度。

利用ogrid的返回值，我能很容易計算x, y網格面上各點的值，或者x, y, z網格體上各點的值。下面是繪製三維曲面 x * exp(x**2 - y**2) 的程序：

 
        import numpy as np from enthought.mayavi import mlab x, y = np.ogrid[-2:2:20j, -2:2:20j] z = x * np.exp( - x**2 - y**2) pl = mlab.surf(x, y, z, warp_scale="auto") mlab.axes(xlabel='x', ylabel='y', zlabel='z') mlab.outline(pl)  
       

此程序使用mayavi的mlab庫快速繪製如圖2.5所示的3D曲面，關於mlab的相關內容將在從此的章節進行介紹。

圖2.5 使用ogrid建立的三維曲面

2.2.2　ufunc的方法

ufunc函數自己還有些方法，這些方法只對兩個輸入一個輸出的ufunc函數有效，其它的ufunc對象調用這些方法時會拋出ValueError異常。

reduce 方法和Python的reduce函數相似，它沿着axis軸對array進行操做，至關於將<op>運算符插入到沿axis軸的全部子數組或者元素當中。

<op>.reduce (array=, axis=0, dtype=None)

例如：

 
        >>> np.add.reduce([1,2,3]) # 1 + 2 + 3 6 >>> np.add.reduce([[1,2,3],[4,5,6]], axis=1) # 1,4 + 2,5 + 3,6 array([ 6, 15])  
       

accumulate 方法和reduce方法相似，只是它返回的數組和輸入的數組的shape相同，保存全部的中間計算結果：

 
        >>> np.add.accumulate([1,2,3]) array([1, 3, 6]) >>> np.add.accumulate([[1,2,3],[4,5,6]], axis=1) array([[ 1, 3, 6],  [ 4, 9, 15]])  
       

reduceat 方法計算多組reduce的結果，經過indices參數指定一系列reduce的起始和終了位置。reduceat的計算有些特別，讓咱們經過一個例子來解釋一下：

 
        >>> a = np.array([1,2,3,4]) >>> result = np.add.reduceat(a,indices=[0,1,0,2,0,3,0]) >>> result array([ 1, 2, 3, 3, 6, 4, 10])  
       

對於indices中的每一個元素都會調用reduce函數計算出一個值來，所以最終計算結果的長度和indices的長度相同。結果result數組中除最後一個元素以外，都按照以下計算得出：

if indices[i] < indices[i+1]:
    result[i] = np.reduce(a[indices[i]:indices[i+1]])
else:
    result[i] = a[indices[i]

而最後一個元素以下計算:

 
        np.reduce(a[indices[-1]:])  
       

所以上面例子中，結果的每一個元素以下計算而得：

1 : a[0] = 1
2 : a[1] = 2
3 : a[0] + a[1] = 1 + 2
3 : a[2] = 3
6 : a[0] + a[1] + a[2] =  1 + 2 + 3 = 6
4 : a[3] = 4
10: a[0] + a[1] + a[2] + a[4] = 1+2+3+4 = 10

能夠看出result[::2]和a相等，而result[1::2]和np.add.accumulate(a)相等。

outer 方法，<op>.outer(a,b)方法的計算等同於以下程序：

 
        >>> a.shape += (1,)*b.ndim >>> <op>(a,b) >>> a = a.squeeze()  
       

其中squeeze的功能是剔除數組a中長度爲1的軸。若是你看不太明白這個等同程序的話，讓咱們來看一個例子：

 
        >>> np.multiply.outer([1,2,3,4,5],[2,3,4]) array([[ 2, 3, 4],  [ 4, 6, 8],  [ 6, 9, 12],  [ 8, 12, 16],  [10, 15, 20]])  
       

能夠看出經過outer方法計算的結果是以下的乘法表：

 
        #    2, 3, 4
# 1 # 2 # 3 # 4 # 5

若是將這兩個數組按照等同程序一步一步的計算的話，就會發現乘法表最終是經過廣播的方式計算出來的。

2.3　矩陣運算

NumPy和Matlab不同，對於多維數組的運算，缺省狀況下並不使用矩陣運算，若是你但願對數組進行矩陣運算的話，能夠調用相應的函數。

matrix對象

numpy庫提供了matrix類，使用matrix類建立的是矩陣對象，它們的加減乘除運算缺省採用矩陣方式計算，所以用法和matlab十分相似。可是因爲NumPy中同時存在ndarray和matrix對象，所以用戶很容易將二者弄混。這有違Python的「顯式優於隱式」的原則，所以並不推薦在較複雜的程序中使用matrix。下面是使用matrix的一個例子：

 
        >>> a = np.matrix([[1,2,3],[5,5,6],[7,9,9]]) >>> a*a**-1 matrix([[ 1.00000000e+00, 1.66533454e-16, -8.32667268e-17],  [ -2.77555756e-16, 1.00000000e+00, -2.77555756e-17],  [ 1.66533454e-16, 5.55111512e-17, 1.00000000e+00]])  
       

由於a是用matrix建立的矩陣對象，所以乘法和冪運算符都變成了矩陣運算，因而上面計算的是矩陣a和其逆矩陣的乘積，結果是一個單位矩陣。

矩陣的乘積可使用dot函數進行計算。對於二維數組，它計算的是矩陣乘積，對於一維數組，它計算的是其點積。當須要將一維數組看成列矢量或者行矢量進行矩陣運算時，推薦先使用reshape函數將一維數組轉換爲二維數組：

 
       >>> a = array([1, 2, 3]) >>> a.reshape((-1,1)) array([[1],  [2],  [3]]) >>> a.reshape((1,-1)) array([[1, 2, 3]])  
      

除了dot計算乘積以外，NumPy還提供了inner和outer等多種計算乘積的函數。這些函數計算乘積的方式不一樣，尤爲是當對於多維數組的時候，更容易搞混。

dot : 對於兩個一維的數組，計算的是這兩個數組對應下標元素的乘積和(數學上稱之爲內積)；對於二維數組，計算的是兩個數組的矩陣乘積；對於多維數組，它的通用計算公式以下，即結果數組中的每一個元素都是：數組a的最後一維上的全部元素與數組b的倒數第二位上的全部元素的乘積和：
```
dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m]) 
```
下面以兩個3爲數組的乘積演示一下dot乘積的計算結果：

首先建立兩個3維數組，這兩個數組的最後兩維知足矩陣乘積的條件：
```
>>> a = np.arange(12).reshape(2,3,2) >>> b = np.arange(12,24).reshape(2,2,3) >>> c = np.dot(a,b) 
```
dot乘積的結果c能夠看做是數組a,b的多個子矩陣的乘積：
```
>>> np.alltrue( c[0,:,0,:] == np.dot(a[0],b[0]) ) True >>> np.alltrue( c[1,:,0,:] == np.dot(a[1],b[0]) ) True >>> np.alltrue( c[0,:,1,:] == np.dot(a[0],b[1]) ) True >>> np.alltrue( c[1,:,1,:] == np.dot(a[1],b[1]) ) True 
```

inner : 和dot乘積同樣，對於兩個一維數組，計算的是這兩個數組對應下標元素的乘積和；對於多維數組，它計算的結果數組中的每一個元素都是：數組a和b的最後一維的內積，所以數組a和b的最後一維的長度必須相同：

 
          inner(a, b)[i,j,k,m] = sum(a[i,j,:]*b[k,m,:])  
         

下面是inner乘積的演示：

 
          >>> a = np.arange(12).reshape(2,3,2) >>> b = np.arange(12,24).reshape(2,3,2) >>> c = np.inner(a,b) >>> c.shape (2, 3, 2, 3) >>> c[0,0,0,0] == np.inner(a[0,0],b[0,0]) True >>> c[0,1,1,0] == np.inner(a[0,1],b[1,0]) True >>> c[1,2,1,2] == np.inner(a[1,2],b[1,2]) True  
         

outer : 只按照一維數組進行計算，若是傳入參數是多維數組，則先將此數組展平爲一維數組以後再進行運算。outer乘積計算的列向量和行向量的矩陣乘積：
```
>>> np.outer([1,2,3],[4,5,6,7]) array([[ 4, 5, 6, 7],  [ 8, 10, 12, 14],  [12, 15, 18, 21]]) 
```

矩陣中更高級的一些運算能夠在NumPy的線性代數子庫linalg中找到。例如inv函數計算逆矩陣，solve函數能夠求解多元一次方程組。下面是solve函數的一個例子：

 
       >>> a = np.random.rand(10,10) >>> b = np.random.rand(10) >>> x = np.linalg.solve(a,b) >>> np.sum(np.abs(np.dot(a,x) - b)) 3.1433189384699745e-15  
      

solve函數有兩個參數a和b。a是一個N*N的二維數組，而b是一個長度爲N的一維數組，solve函數找到一個長度爲N的一維數組x，使得a和x的矩陣乘積正好等於b，數組x就是多元一次方程組的解。

有關線性代數方面的內容將在從此的章節中詳細介紹。

2.4　文件存取

NumPy提供了多種文件操做函數方便咱們存取數組內容。文件存取的格式分爲兩類：二進制和文本。而二進制格式的文件又分爲NumPy專用的格式化二進制類型和無格式類型。

使用數組的方法函數tofile能夠方便地將數組中數據以二進制的格式寫進文件。tofile輸出的數據沒有格式，所以用numpy.fromfile讀回來的時候須要本身格式化數據：

 
       >>> a = np.arange(0,12) >>> a.shape = 3,4 >>> a array([[ 0, 1, 2, 3],  [ 4, 5, 6, 7],  [ 8, 9, 10, 11]]) >>> a.tofile("a.bin") >>> b = np.fromfile("a.bin", dtype=np.float) # 按照float類型讀入數據 >>> b # 讀入的數據是錯誤的 array([ 2.12199579e-314, 6.36598737e-314, 1.06099790e-313,  1.48539705e-313, 1.90979621e-313, 2.33419537e-313]) >>> a.dtype # 查看a的dtype dtype('int32') >>> b = np.fromfile("a.bin", dtype=np.int32) # 按照int32類型讀入數據 >>> b # 數據是一維的 array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) >>> b.shape = 3, 4 # 按照a的shape修改b的shape >>> b # 此次終於正確了 array([[ 0, 1, 2, 3],  [ 4, 5, 6, 7],  [ 8, 9, 10, 11]])  
      

從上面的例子能夠看出，須要在讀入的時候設置正確的dtype和shape才能保證數據一致。而且tofile函數無論數組的排列順序是C語言格式的仍是Fortran語言格式的，統一使用C語言格式輸出。

此外若是fromfile和tofile函數調用時指定了sep關鍵字參數的話，數組將以文本格式輸入輸出。

numpy.load和numpy.save函數以NumPy專用的二進制類型保存數據，這兩個函數會自動處理元素類型和shape等信息，使用它們讀寫數組就方便多了，可是numpy.save輸出的文件很難和其它語言編寫的程序讀入：

 
       >>> np.save("a.npy", a) >>> c = np.load( "a.npy" ) >>> c array([[ 0, 1, 2, 3],  [ 4, 5, 6, 7],  [ 8, 9, 10, 11]])  
      

若是你想將多個數組保存到一個文件中的話，可使用numpy.savez函數。savez函數的第一個參數是文件名，其後的參數都是須要保存的數組，也可使用關鍵字參數爲數組起一個名字，非關鍵字參數傳遞的數組會自動起名爲arr_0, arr_1, ...。savez函數輸出的是一個壓縮文件(擴展名爲npz)，其中每一個文件都是一個save函數保存的npy文件，文件名對應於數組名。load函數自動識別npz文件，而且返回一個相似於字典的對象，能夠經過數組名做爲關鍵字獲取數組的內容：

 
       >>> a = np.array([[1,2,3],[4,5,6]]) >>> b = np.arange(0, 1.0, 0.1) >>> c = np.sin(b) >>> np.savez("result.npz", a, b, sin_array = c) >>> r = np.load("result.npz") >>> r["arr_0"] # 數組a array([[1, 2, 3],  [4, 5, 6]]) >>> r["arr_1"] # 數組b array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]) >>> r["sin_array"] # 數組c array([ 0. , 0.09983342, 0.19866933, 0.29552021, 0.38941834,  0.47942554, 0.56464247, 0.64421769, 0.71735609, 0.78332691])  
      

若是你用解壓軟件打開result.npz文件的話，會發現其中有三個文件：arr_0.npy， arr_1.npy， sin_array.npy，其中分別保存着數組a, b, c的內容。

使用numpy.savetxt和numpy.loadtxt能夠讀寫1維和2維的數組：

 
       >>> a = np.arange(0,12,0.5).reshape(4,-1) >>> np.savetxt("a.txt", a) # 缺省按照'%.18e'格式保存數據，以空格分隔 >>> np.loadtxt("a.txt") array([[ 0. , 0.5, 1. , 1.5, 2. , 2.5],  [ 3. , 3.5, 4. , 4.5, 5. , 5.5],  [ 6. , 6.5, 7. , 7.5, 8. , 8.5],  [ 9. , 9.5, 10. , 10.5, 11. , 11.5]]) >>> np.savetxt("a.txt", a, fmt="%d", delimiter=",") #改成保存爲整數，以逗號分隔 >>> np.loadtxt("a.txt",delimiter=",") # 讀入的時候也須要指定逗號分隔 array([[ 0., 0., 1., 1., 2., 2.],  [ 3., 3., 4., 4., 5., 5.],  [ 6., 6., 7., 7., 8., 8.],  [ 9., 9., 10., 10., 11., 11.]])  
      

文件名和文件對象

本節介紹所舉的例子都是傳遞的文件名，也能夠傳遞已經打開的文件對象，例如對於load和save函數來講，若是使用文件對象的話，能夠將多個數組儲存到一個npy文件中：

 
        >>> a = np.arange(8) >>> b = np.add.accumulate(a) >>> c = a + b >>> f = file("result.npy", "wb") >>> np.save(f, a) # 順序將a,b,c保存進文件對象f >>> np.save(f, b) >>> np.save(f, c) >>> f.close() >>> f = file("result.npy", "rb") >>> np.load(f) # 順序從文件對象f中讀取內容 array([0, 1, 2, 3, 4, 5, 6, 7]) >>> np.load(f) array([ 0, 1, 3, 6, 10, 15, 21, 28]) >>> np.load(f) array([ 0, 2, 5, 9, 14, 20, 27, 35])
轉載來自：http://old.sebug.net/paper/books/scipydoc/numpy_intro.html