# NumPy-快速處理數據
標準安裝的Python中用列表(list)保存一組值，可以用來當作數組使用，不過由于列表的元素可以是任何對象，因此列表中所保存的是對象的指針。這樣為了保存一個簡單的[1,2,3]，需要有3個指針和三個整數對象。對于數值運算來說這種結構顯然比較浪費內存和CPU計算時間。
此外Python還提供了一個array模塊，array對象和列表不同，它直接保存數值，和C語言的一維數組比較類似。但是由于它不支持多維，也沒有各種運算函數，因此也不適合做數值運算。
NumPy的誕生彌補了這些不足，NumPy提供了兩種基本的對象：ndarray（N-dimensional array object）和 ufunc（universal function object）。ndarray(下文統一稱之為數組)是存儲單一數據類型的多維數組，而ufunc則是能夠對數組進行處理的函數。
## ndarray對象
函數庫的導入
本書的示例程序假設用以下推薦的方式導入NumPy函數庫:
```
import numpy as np
```
### 創建
首先需要創建數組才能對其進行其它操作。
我們可以通過給array函數傳遞Python的序列對象創建數組，如果傳遞的是多層嵌套的序列，將創建多維數組(下例中的變量c):
```
>>> 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屬性獲得：
```
>>> 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)：
```
>>> 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.]])
```
### 存取元素
數組元素的存取方法和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])
```
### 多維數組
多維數組的存取和一維數組類似，因為多維數組有多個軸，因此它的下標需要用多個值來表示，NumPy采用組元(tuple)作為數組的下標。如[下圖](#fig-numpyintro02)所示，a為一個6x6的數組，圖中用顏色區分了各個下標以及其對應的選擇區域。
組元不需要圓括號
雖然我們經常在Python中用圓括號將組元括起來，但是其實組元的語法定義只需要用逗號隔開即可，例如 x,y=y,x 就是用組元交換變量值的一個例子。
使用數組切片語法訪問多維數組中的元素
如何創建這個數組
你也許會對如何創建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]])
```
多維數組同樣也可以使用整數序列和布爾數組進行存取。
使用整數序列和布爾數組訪問多維數組中的元素
* 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列。
### 結構數組
在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')])
```
### 內存結構
下面讓我們來看看ndarray數組對象是如何在內存中儲存的。如[下圖](#fig-numpymemorystruct)所示，關于數組的描述信息保存在一個數據結構中，這個結構引用兩個對象：一塊用于保存數據的存儲區域和一個用于描述元素類型的dtype對象。
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)
```
## 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函數對數組進行計算了。讓我們來看一個例子。
我們想用一個分段函數描述三角波，三角波的樣子如[下圖](#fig-numpyintro01)所示：
三角波可以用分段函數進行計算
我們很容易根據上圖所示寫出如下的計算三角波某點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)將其轉換為雙精度浮點數組。
### 廣播
當我們使用ufunc函數對兩個數組進行計算時，ufunc函數會對這兩個數組的對應元素進行計算，因此它要求這兩個數組有相同的大小(shape相同)。如果兩個數組的shape不同的話，會進行如下的廣播(broadcasting)處理：
1. 讓所有輸入數組都向其中shape最長的數組看齊，shape中不足的部分都通過在前面加1補齊
2. 輸出數組的shape是輸入數組shape的各個軸上的最大值
3. 如果輸入數組的某個軸和輸出數組的對應軸的長度相同或者其長度為1時，這個數組能夠用來計算，否則出錯
4. 當輸入數組的某個軸的長度為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庫快速繪制如[下圖](#fig-numpyintro04)所示的3D曲面，關于mlab的相關內容將在今后的章節進行介紹。
使用ogrid創建的三維曲面
### ufunc的方法
ufunc函數本身還有些方法，這些方法只對兩個輸入一個輸出的ufunc函數有效，其它的ufunc對象調用這些方法時會拋出ValueError異常。
**reduce** 方法和Python的reduce函數類似，它沿著axis軸對array進行操作，相當于將<op>運算符插入到沿axis軸的所有子數組或者元素當中。
```
>>> 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數組中除最后一個元素之外，都按照如下計算得出：
```
np.reduce(a[indices[-1]:])
```
因此上面例子中，結果的每個元素如下計算而得：
```
>>> 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
```
如果將這兩個數組按照等同程序一步一步的計算的話，就會發現乘法表最終是通過廣播的方式計算出來的。
## 矩陣運算
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就是多元一次方程組的解。
有關線性代數方面的內容將在今后的章節中詳細介紹。
## 文件存取
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])
```
- 用Python做科學計算
- 軟件包的安裝和介紹
- NumPy-快速處理數據
- SciPy-數值計算庫
- matplotlib-繪制精美的圖表
- Traits-為Python添加類型定義
- TraitsUI-輕松制作用戶界面
- Chaco-交互式圖表
- TVTK-三維可視化數據
- Mayavi-更方便的可視化
- Visual-制作3D演示動畫
- OpenCV-圖像處理和計算機視覺
- Traits使用手冊
- 定義Traits
- Trait事件處理
- 設計自己的Trait編輯器
- Visual使用手冊
- 場景窗口
- 聲音的輸入輸出
- 數字信號系統
- FFT演示程序
- 頻域信號處理
- Ctypes和NumPy
- 自適應濾波器和NLMS模擬
- 單擺和雙擺模擬
- 分形與混沌
- 關于本書的編寫
- 最近更新
- 源程序集
- 三角波的FFT演示
- 在traitsUI中使用的matplotlib控件
- CSV文件數據圖形化工具
- NLMS算法的模擬測試
- 三維標量場觀察器
- 頻譜泄漏和hann窗
- FFT卷積的速度比較
- 二次均衡器設計
- 單擺擺動周期的計算
- 雙擺系統的動畫模擬
- 繪制Mandelbrot集合
- 迭代函數系統的分形
- 繪制L-System的分形圖