本文部分內容參考Daetalus的部落格。

為什麼要用numpy

• Python中提供了list容器，可以當作陣列使用。但列表中的元素可以是任何物件，因此列表中儲存的是物件的指標，這樣一來，為了儲存一個簡單的列表[1,2,3]。就需要三個指標和三個整數物件。對於數值運算來說，這種結構顯然不夠高效。
• Python雖然也提供了array模組，但其只支援一維陣列，不支援多維陣列，也沒有各種運算函式。因而不適合數值運算。
• NumPy的出現彌補了這些不足。

（——摘自張若愚的《Python科學計算》）

import numpy as np

陣列建立

## 常規建立方法
a = np.array([2
 
,3,4])
b = np.array([2.0,3.0,4.0])
c = np.array([[1.0,2.0],[3.0,4.0]])
d = np.array([[1,2],[3,4]],dtype=complex) # 指定資料型別
print a, a.dtype
print b, b.dtype
print c, c.dtype
print d, d.dtype

[2 3 4] int32
[ 2.  3.  4.] float64
[[ 1.  2.]
 [ 3.  4.]] float64
[[ 1.+0.j  2.+0.j]
 [ 3.+0.j  4.+0.j]] complex128

## 建立陣列的常用函式
 

print np.arange(0,7,1,dtype=np.int16) # 0為起點，間隔為1時可預設(引起歧義下不可預設)
print np.ones((2,3,4),dtype=np.int16) # 2頁，3行，4列，全1，指定資料型別
print np.zeros((2,3,4)) # 2頁，3行，4列，全0
print np.empty((2,3)) #值取決於記憶體
print np.arange(0,10,2) # 起點為0，不超過10，步長為2
print np.linspace(-1,2,5) # 起點為-1，終點為2，取5個點 
print np.random.randint(0,3
 
,(2,3)) # 大於等於0，小於3，2行3列的隨機整數

[0 1 2 3 4 5 6]
[[[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]

 [[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]]
[[[ 0.  0.  0.  0.]
  [ 0.  0.  0.  0.]
  [ 0.  0.  0.  0.]]

 [[ 0.  0.  0.  0.]
  [ 0.  0.  0.  0.]
  [ 0.  0.  0.  0.]]]
[[  1.39069238e-309   1.39069238e-309   1.39069238e-309]
 [  1.39069238e-309   1.39069238e-309   1.39069238e-309]]
[0 2 4 6 8]
[-1.   -0.25  0.5   1.25  2.  ]
[[1 0 1]
 [0 1 0]]

## 型別轉換
print float(1)
print int(1.0)
print bool(2)
print float(True)

1.0
1
True
1.0

陣列輸出

• 從左到右，從上向下
• 一維陣列列印成行，二維陣列列印成矩陣，三維陣列列印成矩陣列表

print np.arange(1,6,2)
print np.arange(12).reshape(3,4) # 可以改變輸出形狀
print np.arange(24).reshape(2,3,4)# 2頁，3行，4頁

[1 3 5]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]

基本運算

## 元素級運算
a = np.array([1,2,3,4])
b = np.arange(4)
print a, b
print a-b
print a*b
print a**2
print 2*np.sin(a)
print a>2
print np.exp(a) # 指數

[1 2 3 4] [0 1 2 3]
[1 1 1 1]
[ 0  2  6 12]
[ 1  4  9 16]
[ 1.68294197  1.81859485  0.28224002 -1.51360499]
[False False  True  True]
[  2.71828183   7.3890561   20.08553692  54.59815003]

## 矩陣運算（二維陣列）
a = np.array([[1,2],[3,4]]) # 2行2列
b = np.arange(6).reshape((2,-1)) # 2行3列
print a,b
print a.dot(b) # 2行3列

[[1 2]
 [3 4]] [[0 1 2]
 [3 4 5]]
[[ 6  9 12]
 [12 19 26]]

## 非陣列運算，呼叫方法
a = np.random.randint(0,5,(2,3))
print a
print a.sum(),a.sum(axis=1),a.sum(0) # axis用於指定運算軸（預設全部，可指定0或1）
print a.min(),a.max(axis=1),a.mean(axis=1) # axis = 0: 按列計算，axis = 1: 按行計算
print a.cumsum(1) # 按行計算累積和

[[2 3 3]
 [0 2 1]]
11 [8 3] [2 5 4]
0 [3 2] [ 2.66666667  1.        ]
[[2 5 8]
 [0 2 3]]

索引，切片，迭代

## 一維陣列
a = np.arange(0,10,1)**2
print a 
print a[0],a[2],a[-1],a[-2] # 索引從0開始，-1表示最後一個索引
print a[2:5],a[-5:-1] # 包括起點，不包括終點
a[-1] = 100; print a # 賦值
a[1:4]=100; print a # 批量賦值
a[:6:2] = -100; print a # 從開始到第6個索引，每隔一個元素（步長=2）賦值
print a[: :-1];print a # 將a逆序輸出，a本身未發生改變
b = [np.sqrt(np.abs(i)) for i in a]; print b # 通過遍歷賦值

[ 0  1  4  9 16 25 36 49 64 81]
0 4 81 64
[ 4  9 16] [25 36 49 64]
[  0   1   4   9  16  25  36  49  64 100]
[  0 100 100 100  16  25  36  49  64 100]
[-100  100 -100  100 -100   25   36   49   64  100]
[ 100   64   49   36   25 -100  100 -100  100 -100]
[-100  100 -100  100 -100   25   36   49   64  100]
[10.0, 10.0, 10.0, 10.0, 10.0, 5.0, 6.0, 7.0, 8.0, 10.0]

## 多維陣列
a = np.arange(0,20).reshape((4,5))
print a, a[2,3], a[:,1], a[1:4,2], a[1:3,:]
print a[-1] # 相當於a[-1,:],即索引少於軸數時，確實的索引預設為整個切片

b = np.arange(0,24).reshape((2,3,4))
print b,b[1] # 相當於b[1,:,:] 和b[1,...]
print '-------------------'
for row in a:
    print row # 遍歷以第一個軸為基礎

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]] 13 [ 1  6 11 16] [ 7 12 17] [[ 5  6  7  8  9]
 [10 11 12 13 14]]
[15 16 17 18 19]
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]

 [[12 13 14 15]
 [16 17 18 19]
 [20 21 22 23]]
-------------------
[0 1 2 3 4]
[5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]

形狀操作

a = np.floor(10*np.random.random((3,4)))
print a, a.shape #輸出a的形狀
print a.ravel() # 輸出平坦化後的a（a本身不改變）
a.shape = (6,2); print a # 改變a的形狀
print a.transpose() # 輸出a的轉置

[[ 0.  4.  3.  2.]
 [ 1.  1.  3.  3.]
 [ 4.  4.  6.  5.]] (3, 4)
[ 0.  4.  3.  2.  1.  1.  3.  3.  4.  4.  6.  5.]
[[ 0.  4.]
 [ 3.  2.]
 [ 1.  1.]
 [ 3.  3.]
 [ 4.  4.]
 [ 6.  5.]]
[[ 0.  3.  1.  3.  4.  6.]
 [ 4.  2.  1.  3.  4.  5.]]

## 補充：reshape和resize
a = np.array([[1,2,3],[4,5,6]])
b = a
a.reshape((3,2))# 不改變陣列本身的形狀
print a
b.resize((3,2))# 改變陣列本身形狀
print b

[[1 2 3]
 [4 5 6]]
[[1 2]
 [3 4]
 [5 6]]