最后一次更新日期： 2019/4/13

NumPy 是一個 Python 包窃诉。 它代表 “Numeric Python”。 它是一個由多維數(shù)組對象(ndarray)和用于處理數(shù)組的例程集合組成的庫奥洼。
使用NumPy巷疼，開發(fā)人員可以執(zhí)行以下操作：

• 數(shù)組的算數(shù)和邏輯運(yùn)算。
• 傅立葉變換和用于圖形操作的例程灵奖。
• 與線性代數(shù)有關(guān)的操作嚼沿。 NumPy 擁有線性代數(shù)和隨機(jī)數(shù)生成的內(nèi)置函數(shù)。

使用前先導(dǎo)入模塊：
import numpy as np

此篇為匯總瓷患，點(diǎn)擊下方鏈接可前往各小節(jié)
使用指南1 - 屬性 (數(shù)據(jù)類型骡尽，形狀，維數(shù)擅编，元素?cái)?shù)攀细，元素大小，字節(jié)數(shù)爱态，順序)
使用指南2 - 創(chuàng)建 (從已有數(shù)據(jù)創(chuàng)建谭贪，快速填充)
使用指南3 - 運(yùn)算 (數(shù)組/集合/位/字符串/統(tǒng)計(jì)/線性代數(shù)運(yùn)算，常量肢藐，廣播)
使用指南4 - 查找 (索引故河，遍歷，抽樣吆豹，視圖)
使用指南5 - 變更 (更新鱼的，擴(kuò)增，刪除)
使用指南6 - 重構(gòu) (類型轉(zhuǎn)換痘煤，重塑凑阶，排序，去重衷快，拆分)
使用指南7 - 讀寫 (保存宙橱，讀取)
使用指南8 - 其他 (矩陣類型，張量運(yùn)算，傅里葉變換师郑，圖像處理)

一. 屬性

1. 數(shù)據(jù)類型

ndarray.dtype

numpy常用數(shù)據(jù)類型

注：同一種dtype可以通過多種字符串標(biāo)識去聲明的环葵，見 | 分割的多項(xiàng)。
python的基本數(shù)據(jù)類型可被numpy識別宝冕，轉(zhuǎn)換為對應(yīng)類別下的默認(rèn)類型张遭，int對應(yīng)np.int32，float對應(yīng)np.float64地梨，complex對應(yīng)np.complex128菊卷。

dtype與type的轉(zhuǎn)換

獲取dtype的type：dtype.type
通過type創(chuàng)建dtype：dtype(type)

dtype與type可以直接進(jìn)行比較

np.dtype('int')==np.int32

dtype的字節(jié)順序

np.dtype('<i8')

字節(jié)順序是通過對數(shù)據(jù)類型預(yù)先設(shè)定"<"或">"來決定的。"<"意味著小端法(最小值存儲在最小的地址宝剖，即低位組放在最前面)洁闰。">"意味著大端法(最重要的字節(jié)存儲在最小的地址，即高位組放在最前面)万细。一般情況下采用默認(rèn)設(shè)置即可扑眉。

2. 元素個數(shù)

ndarray.size

3. 元素的子節(jié)大小

ndarray.itemsize

由數(shù)據(jù)類型決定，每8位為1字節(jié)雅镊。

4. 總字節(jié)數(shù)

ndarray.nbytes

由size和itemsize計(jì)算得到襟雷。

5. 維數(shù)

ndarray.ndim

ndarray的每一個維度被描述為軸(axis)，維數(shù)即軸的個數(shù)仁烹，軸的編號從0開始耸弄。

6. 形狀

ndarray.shape

tuple類型，每一位對應(yīng)到每個軸卓缰，例如0軸方向長為10個元素计呈，1軸方向長為5個元素的數(shù)組形狀為(10,5)。

7. 內(nèi)存布局

numpy有兩種數(shù)據(jù)存儲的方式征唬，一種是C-order捌显，即行序優(yōu)先，另一種是Fortran-order总寒，即列序優(yōu)先扶歪，未顯式指定時默認(rèn)C-order。由于內(nèi)部的優(yōu)化機(jī)制摄闸，多數(shù)情況下兩者在使用時沒有明顯區(qū)別善镰，一般不需要更改默認(rèn)設(shè)置。
但在使用諸如迭代器之類的方法時年枕，可通過order參數(shù)指定元素訪問順序炫欺，其中'C'指代C-order，'F'指代F-order熏兄。

二. 創(chuàng)建

1. 從已有數(shù)據(jù)創(chuàng)建

(1). 從list創(chuàng)建

#一維數(shù)組
a1=np.array([1,2])
#二維數(shù)組
a2=np.array([[1.,2.],[3.,4.]])
#三維數(shù)組
a3=np.array([[[1,2],[3,4]],[[5,6],[7,8]]],dtype='float')
#以此類推

從嵌套的序列結(jié)構(gòu)創(chuàng)建多維數(shù)組時品洛，最外面的一層對應(yīng)數(shù)組第一個軸树姨，以此類推。
第二個參數(shù)dtype可以顯式聲明數(shù)組的數(shù)據(jù)類型桥状，可傳入dtype或type(python基礎(chǔ)數(shù)據(jù)類型或numpy數(shù)據(jù)類型)或與dtype對應(yīng)的字符串標(biāo)識帽揪，不聲明的情況下會根據(jù)傳入數(shù)據(jù)自動采用最合適的數(shù)據(jù)類型。

(2). 從tuple創(chuàng)建

a=np.array((1,2))

與list是一樣辅斟，list與tuple的嵌套同理台丛。

(3). 從dict創(chuàng)建(不合適)

In [138]: np.array({"x1":1,"x2":2})
Out[138]: array({'x1': 1, 'x2': 2}, dtype=object)

無法正常轉(zhuǎn)換，整個dict會作為一個對象存入數(shù)組砾肺，可以嘗試用pandas庫去處理。

(4). 從其他類數(shù)組結(jié)構(gòu)中創(chuàng)建防嗡，如PIL的圖片類型

from PIL import Image
image= Image.open("D:\\test.jpg")
a=np.asarray(image)

np.asarray在多數(shù)情況下與np.array等效变汪，區(qū)別在于np.asarray會避免沒有必要的重復(fù)創(chuàng)建，當(dāng)數(shù)據(jù)源同樣是ndarray且dtype無變化時蚁趁，不會返回新的數(shù)組裙盾。

2. 快速填充

(1). 0/1填充

#填充0
a1=np.zeros((2,2))
#填充1
a2=np.ones((2,2))
#聲明類型
a2=np.ones((2,2),dtype='int')

第一個參數(shù)shape為數(shù)組形狀，必須賦值他嫡；
默認(rèn)數(shù)據(jù)類型為float64番官，可通過dtype參數(shù)指定類型。

(2). 對角矩陣

In [151]: np.eye(3,3,0)
Out[151]: 
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])

In [150]: np.eye(3,3,1)
Out[150]: 
array([[ 0.,  1.,  0.],
       [ 0.,  0.,  1.],
       [ 0.,  0.,  0.]])

第一個參數(shù)N為0軸長度钢属，必須賦值徘熔；
第二個參數(shù)M為1軸長度，不賦值時與N值一致淆党；
第一個參數(shù)k為對角線偏移量酷师，默認(rèn)0，正數(shù)向上偏移染乌，負(fù)數(shù)向下偏移山孔。
對角矩陣固定為二維數(shù)組。

(3).單位矩陣

In [5]: np.identity(1)
Out[5]: array([[ 1.]])

In [6]: np.identity(2)
Out[6]: 
array([[ 1.,  0.],
       [ 0.,  1.]])

第一個參數(shù)n為統(tǒng)一的軸長度荷憋，必須賦值台颠；
單位矩陣固定為二維數(shù)組。

(4). 指定值填充

a=np.full((2,2),'a')

第一個參數(shù)shape為數(shù)組形狀勒庄，必須賦值串前；
第二個參數(shù)fill_value為填充值，必須賦值锅铅。

(5). 空值填充

a=np.empty((2,2))

第一個參數(shù)shape為數(shù)組形狀酪呻，必須賦值。
創(chuàng)建一個數(shù)組盐须，但不初始化其中的值玩荠。

(6). 參考已有數(shù)組形狀創(chuàng)建

a=np.ones((2,2))
a2=np.zeros_like(a)
a3=np.full_like(a,'a')

(7). 等差數(shù)列

#方法一
a1=np.arange(0,100,1)
#方法二
a2=np.linspace(0,99,100)

方法一，類似range函數(shù)，默認(rèn)int類型阶冈，
三個參數(shù)分別為：開始闷尿，結(jié)束，步長（區(qū)間前閉后開）女坑；
方法二填具，線性空間，默認(rèn)float類型匆骗，
和range不一樣劳景，結(jié)束值默認(rèn)是包含于區(qū)間的，
且第三個參數(shù)不是步長而是元素個數(shù)碉就。

(8). 隨機(jī)數(shù)

浮點(diǎn)數(shù)隨機(jī)數(shù)

#[0,1]浮點(diǎn)隨機(jī)數(shù)
a1=np.random.rand(5,5)
#標(biāo)準(zhǔn)正太分布隨機(jī)數(shù)
a2=np.random.randn(5,5)

需要注意的是盟广，上面的方法不通過shape而通過全部參數(shù)來定義數(shù)組形狀。

整數(shù)隨機(jī)數(shù)

#產(chǎn)生指定范圍的整數(shù)隨機(jī)數(shù)
a=np.random.randint(0,10,(4,3))

第一個參數(shù)low表示區(qū)間下限瓮钥，必須賦值筋量；
第二個參數(shù)high表示區(qū)間上限，未賦值時會將low作為上限碉熄，0作為下限桨武；
第三個參數(shù)size表示數(shù)組形狀，未賦值時函數(shù)會返回標(biāo)量值锈津。

正態(tài)分布隨機(jī)數(shù)

a=np.random.normal(100,10,(4,3))

第一個參數(shù)loc表示分布的平均值呀酸；
第二個參數(shù)scale表示分布的標(biāo)準(zhǔn)偏差；
第三個參數(shù)size表示數(shù)組形狀一姿，未賦值時函數(shù)會返回標(biāo)量值七咧。

均勻分布隨機(jī)數(shù)

a=np.random.uniform(0,10,(4,3))

第一個參數(shù)low表示區(qū)間下限，必須賦值叮叹；
第二個參數(shù)high表示區(qū)間上限艾栋，未賦值時會將low作為上限，0作為下限蛉顽；
第三個參數(shù)size表示數(shù)組形狀蝗砾，未賦值時函數(shù)會返回標(biāo)量值。

泊松分布隨機(jī)數(shù)

a=np.random.poisson(1.0,(4,3))

第一個參數(shù)lam是lambda系數(shù)携冤；
第二個參數(shù)size表示數(shù)組形狀悼粮，未賦值時函數(shù)會返回標(biāo)量值。

(9). 網(wǎng)格數(shù)據(jù)

In [26]: X,Y=np.mgrid[1:2:2j,1:3:3j]

In [27]: X
Out[27]: 
array([[ 1.,  1.,  1.],
       [ 2.,  2.,  2.]])

In [28]: Y
Out[28]: 
array([[ 1.,  2.,  3.],
       [ 1.,  2.,  3.]])

In [33]: x=np.array([1,2,3])

In [34]: y=np.array([1,2])

In [35]: X,Y=np.meshgrid(x,y)

In [36]: X
Out[36]: 
array([[1, 2, 3],
       [1, 2, 3]])

In [37]: Y
Out[37]: 
array([[1, 1, 1],
       [2, 2, 2]])

np.mgrid通過索引選取的方式直接獲得網(wǎng)格數(shù)據(jù)曾棕，j表示步數(shù)且包含停止值扣猫，去掉j該項(xiàng)代表步長且不包含停止值，第一個索引位聲明X在軸0方向上的增長翘地，第二個索引位聲明Y在軸1方向上的增長申尤，然后將X和Y廣播至相同大小癌幕，存在更多索引位時以此類推。
np.meshgrid在已有數(shù)據(jù)基礎(chǔ)上構(gòu)造網(wǎng)格數(shù)據(jù)昧穿，跟mgrid不一樣勺远，第一個參數(shù)是表示第二個軸方向上增長的向量，第二個參數(shù)對應(yīng)第一個軸时鸵，第三個參數(shù)對應(yīng)第三個軸胶逢，第四個參數(shù)對應(yīng)第四個軸，之后以此類推饰潜。
網(wǎng)格數(shù)據(jù)常用于繪圖初坠。

(10). 復(fù)制

a1=np.zeros((2,2))
a2=np.copy(a1)

三. 運(yùn)算

1. 運(yùn)算符

numpy對python中的運(yùn)算符作了重載，可通過同樣的用法實(shí)現(xiàn)數(shù)組運(yùn)算彭雾。

數(shù)組與標(biāo)量值的運(yùn)算

In [191]: a=np.arange(0, 4)

In [192]: a
Out[192]: array([0, 1, 2, 3])

In [193]: a+1
Out[193]: array([1, 2, 3, 4])

In [193]: a*2
Out[194]: array([0, 2, 4, 6])

數(shù)組與數(shù)組的運(yùn)算

In [199]: a1=np.arange(0, 4);a2=np.arange(4, 8)

In [200]: a1,a2
Out[200]: (array([0, 1, 2, 3]), array([4, 5, 6, 7]))

In [201]: a1+a2
Out[201]: array([ 4,  6,  8, 10])

In [202]: a2**a1
Out[202]: array([  1,   5,  36, 343], dtype=int32)

2. 標(biāo)量值函數(shù)

標(biāo)量值函數(shù)會對數(shù)組中每一個元素進(jìn)行同樣的計(jì)算某筐。

一元函數(shù)

多元函數(shù)

3. 聚合函數(shù)

聚合函數(shù)會減少數(shù)組的維數(shù)严肪，通常可以指定一個軸方向axis進(jìn)行聚合谦屑，結(jié)果數(shù)組會減少一個維度驳糯，不指定方向時會在所有軸方向上聚合，結(jié)果為一個標(biāo)量值氢橙。
大多數(shù)既可以靜態(tài)調(diào)用酝枢，也可以直接調(diào)用ndarray對象的方法。

np.max和np.min有對應(yīng)的np.argmax和np.argmin的方法用于返回索引悍手，詳見查找章節(jié)帘睦。

(以下是部分示例)

np.sum

In [313]: a=np.array([[1,3],[4,2]])

In [314]: a
Out[314]: 
array([[1, 3],
       [4, 2]])

In [315]: a.sum()
Out[315]: 10

In [316]: a.sum(axis=0)
Out[316]: array([5, 5])

In [317]: a.sum(axis=1)
Out[317]: array([4, 6])

np.all

In [322]: a=np.array([[True,False],[True,True]])

In [323]: a
Out[323]: 
array([[ True, False],
       [ True,  True]], dtype=bool)

In [324]: a.all()
Out[324]: False

In [325]: a.all(axis=0)
Out[325]: array([ True, False], dtype=bool)

4. 復(fù)合統(tǒng)計(jì)函數(shù)

(以下是部分示例)

np.cumsum

In [317]: a=np.array([[1,3],[4,2]])

In [319]: a.cumsum()
Out[319]: array([ 1,  4,  8, 10], dtype=int32)

In [320]: a.cumsum(axis=0)
Out[320]: 
array([[1, 3],
       [5, 5]], dtype=int32)

np.average

In [331]: a=np.array([[1,3],[4,2]])

In [332]: w=np.array([[0.4,0.1],[0.2,0.3]])

In [333]: np.average(a)
Out[333]: 2.5

In [334]: np.average(a,weights=w)
Out[334]: 2.1000000000000001

5. 字符串函數(shù)

(以下是部分示例)

np.char.add

In [301]: a1=np.array(['a','b']);a2=np.array(['c','d'])

In [302]: np.char.add(a1,a2)
Out[302]: 
array(['ac', 'bd'],
      dtype='<U2')

np.char.multiply

In [303]: a=np.array(['a','b'])

In [304]: np.char.multiply(a,3)
Out[304]: 
array(['aaa', 'bbb'],
      dtype='<U3')

np.char.center

In [305]: a=np.array(['a','b'])

In [306]: np.char.center(a,10,'*')
Out[306]: 
array(['****a*****', '****b*****'],
      dtype='<U10')

np.char.split

In [307]: a=np.array(['a,b','c,d'])

In [308]: np.char.split(a,',')
Out[308]: array([list(['a', 'b']), list(['c', 'd'])], dtype=object)

np.char.join

In [309]: a=np.array(['ab','cd'])

In [310]: np.char.join(',',a)
Out[310]: 
array(['a,b', 'c,d'],
      dtype='<U3')

In [311]: a=np.array(['a,b','c,d'])

In [312]: np.char.join(',',np.char.split(a,','))
Out[312]: 
array(['a,b', 'c,d'],
      dtype='<U3')

注意赤兴，該方法無法實(shí)現(xiàn)多維數(shù)組的聚合計(jì)算妖滔。在數(shù)組元素為字符串時，會對字符串中的每個元素進(jìn)行拼接桶良；在數(shù)組元素為字符串序列時座舍，會對序列中的字符串進(jìn)行拼接。
與split互為逆運(yùn)算陨帆。

6. 線性代數(shù)運(yùn)算

(以下是部分示例)

np.dot, np.vdot, np.inner, np.matmul

In [339]: a=np.array([1,2]);b=np.array([[3,4],[5,6]])

In [340]: np.dot(a,a), np.vdot(a,a), np.inner(a,a), np.matmul(a,a)
Out[340]: (5, 5, 5, 5)

In [341]: np.dot(a,b), np.dot(b,a)
Out[341]: (array([13, 16]), array([11, 17]))

In [342]: np.vdot(a,b)
Traceback (most recent call last):

  File "<ipython-input-358-f2388a21d848>", line 1, in <module>
    np.vdot(a,b)

ValueError: cannot reshape array of size 4 into shape (2,)

In [343]: np.inner(a,b), np.inner(b,a)
Out[343]: (array([11, 17]), array([11, 17]))

In [344]: np.matmul(a,b), np.matmul(b,a)
Out[344]: (array([13, 16]), array([11, 17]))

In [345]: np.dot(b,b)
Out[345]: 
array([[29, 36],
       [45, 56]])

In [346]: np.vdot(b,b)
Out[346]: 86

In [347]: np.inner(b,b)
Out[347]: 
array([[25, 39],
       [39, 61]])

In [348]: np.matmul(b,b)
Out[348]: 
array([[29, 36],
       [45, 56]])

這四個方法執(zhí)行的運(yùn)算都基于向量內(nèi)積识啦，非常相似负蚊，但在具體行為上有區(qū)別，很容易混淆颓哮。

dot是將數(shù)組看作向量的集合家妆，第一個數(shù)組的最后一個軸和第二個數(shù)組的倒數(shù)第二個軸作為向量的軸，抽取每個向量兩兩匹配進(jìn)行點(diǎn)積運(yùn)算冕茅，因此這兩個軸需要長度一致揩徊。例如，a.shape=(2,3,4)嵌赠，b.shape=(5,4,6)塑荒，則np.dot(a,b).shape=(2,3,5,6)。在二維情況下姜挺，實(shí)現(xiàn)的計(jì)算即是矩陣乘法齿税。

vdot的規(guī)則比較簡單，會將數(shù)組展開為向量再計(jì)算點(diǎn)積炊豪，要求數(shù)組的size一致凌箕。

inner與dot類似拧篮，但規(guī)則更簡單，兩個數(shù)組均以最后一個軸作為向量的軸牵舱，即最后一個軸長度要保持一致串绩。例如，a.shape=(2,3,4)芜壁，b.shape=(5,6,4)礁凡，則np.dot(a,b).shape=(2,3,5,6)。

matmul的計(jì)算針對矩陣慧妄，和dot一樣在二維情況下表示矩陣乘法顷牌，二維以上視作元素為矩陣的數(shù)組，參與運(yùn)算的兩個數(shù)組均以最后兩個軸作為矩陣的軸塞淹，逐個元素進(jìn)行矩陣乘法并向其他軸方向上廣播窟蓝。例如，a.shape=(1,3,4)饱普，b.shape=(5,4,6)运挫，則np.dot(a,b).shape=(5,3,6)，如果a.shape=(2,3,4)套耕，計(jì)算就會報(bào)錯滑臊，因?yàn)椴粷M足廣播的規(guī)則。

7. 集合運(yùn)算

以上方法適用于一維數(shù)組。

(以下是部分示例)

In [810]: x=np.array([1,3,4])

In [811]: y=np.array([2,3,5])

In [812]: np.intersect1d(x,y)
Out[812]: array([3])

In [813]: np.union1d(x,y)
Out[813]: array([1, 2, 3, 4, 5])

In [814]: np.setdiff1d(x,y)
Out[814]: array([1, 4])

In [815]: np.setxor1d(x,y)
Out[815]: array([1, 2, 4, 5])

8. 位運(yùn)算

(以下是部分示例)

In [858]: a=np.array([2,3,5,8,13])

In [859]: b=np.array([3,4,7,11,18])

In [860]: np.invert(a)
Out[860]: array([ -3,  -4,  -6,  -9, -14], dtype=int32)

In [862]: bin(a[4]),bin(~a[4])
Out[862]: ('0b1101', '-0b1110')

In [863]: np.bitwise_and(a,b)
Out[863]: array([2, 0, 5, 8, 0], dtype=int32)

bin(a[3]),bin(b[3]),bin(a[3]&b[3])
Out[865]: ('0b1000', '0b1011', '0b1000')

np.invert對于有符號整數(shù)鬓椭，取對應(yīng)二進(jìn)制數(shù)的補(bǔ)碼颠猴，然后 +1。二進(jìn)制數(shù)形式的最高位為0表示正數(shù)小染，最高位為 1 表示負(fù)數(shù)翘瓮。

9. 廣播

numpy在進(jìn)行不同形狀的數(shù)組之間的計(jì)算時，會自動沿長度不足且長度為1的軸方向進(jìn)行廣播裤翩。當(dāng)維數(shù)不一致時资盅，會向前補(bǔ)齊，這要求后面的軸長度相同或是有一方長度等于1踊赠，即從后至前進(jìn)行軸長比對呵扛，例如形狀(a,b,c)與(b,c)可計(jì)算，(a,b,c)與(b,1)可計(jì)算筐带，(a,b,c)與(a,b,1)可計(jì)算今穿，(a,b,c)與(a,b)不可計(jì)算，(a,b,c)與(a,c,b)不可計(jì)算伦籍。

In [414]: a1=np.zeros((2,3,4))
         ...: a2=np.random.randint(0,10,(3,4))
         ...: a3=np.random.randint(0,10,(2,3))
         ...: a4=np.random.randint(0,10,(2,3,1))

In [418]: a1+a2
Out[418]: 
array([[[ 3.,  6.,  0.,  6.],
        [ 9.,  6.,  3.,  4.],
        [ 2.,  3.,  1.,  5.]],

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

In [419]: a1+a3
Traceback (most recent call last):

  File "<ipython-input-419-d778f9717621>", line 1, in <module>
    a1+a3

ValueError: operands could not be broadcast together with shapes (2,3,4) (2,3) 

In [420]: a1+a4
Out[420]: 
array([[[ 0.,  0.,  0.,  0.],
        [ 9.,  9.,  9.,  9.],
        [ 1.,  1.,  1.,  1.]],

       [[ 4.,  4.,  4.,  4.],
        [ 0.,  0.,  0.,  0.],
        [ 2.,  2.,  2.,  2.]]])

10. 常量

四. 查找

1. 索引

通過ndarray[index1,index2...]的形式指定索引蓝晒。

(1). 定位元素

In [452]: a=np.array([[1,2],[3,4]])

In [453]: a[1,1]
Out[453]: 4

(2). 數(shù)據(jù)切片

In [454]: a[:,1]
Out[454]: array([2, 4])

In [455]: a[0:1,:]
Out[455]: array([[1, 2]])

通過low:high的形式限定索引范圍腮出，區(qū)間前閉后開，上下限留空表示不限制芝薇。
標(biāo)量值索引會使對應(yīng)維度消失胚嘲，范圍索引則不會。

(3). 倒序索引

In [457]: a[-1,:-1]
Out[457]: array([3])

-n表示倒數(shù)第n個洛二。

(4). 按步長選取

In [458]: a[0:2:2]
Out[458]: array([[1, 2]])

通過low:high:step的形式限定索引范圍和步長馋劈。

(5). 序列反轉(zhuǎn)

In [459]: a[::-1]
Out[459]: 
array([[3, 4],
       [1, 2]])

等效于a[-1:-len(a)-1:-1]。

(6). 布爾索引

In [460]: a>2
Out[460]: 
array([[False, False],
       [ True,  True]], dtype=bool)

In [461]: (a>2)&(a<4)
Out[461]: 
array([[False, False],
       [ True, False]], dtype=bool)

In [462]: a[(a>2)&(a<4)]
Out[462]: array([3])

對ndarray應(yīng)用邏輯運(yùn)算符會得到布爾索引灭红，布爾索引標(biāo)識了每個元素符合邏輯判斷條件的情況侣滩，使用該索引篩選數(shù)組將得到所有滿足條件的元素構(gòu)成的一維數(shù)組。

(7). 數(shù)組索引

In [463]: a[[0,1],[1]]
Out[463]: array([2, 4])

In [464]: a[[0,1],[1,0]]
Out[464]: array([2, 3])

將對應(yīng)軸上需要選取的索引以數(shù)組形式傳入变擒，當(dāng)在多個軸上傳入數(shù)組索引時君珠，索引會被一一對應(yīng)。支持list,tuple,ndarray娇斑，支持倒序索引策添。

(8). 綜合示例

獲取第二列大于2的行的第一列

In [465]: a[a[:,1]>2,0]
Out[465]: array([3])

獲取二維數(shù)組的頂角元素

In [466]: a[[0,-1]][:,[0,-1]]
Out[466]: 
array([[1, 2],
       [3, 4]])

In [467]: a[[0,0,-1,-1],[0,-1,0,-1]].reshape((2,2))
Out[467]: 
array([[1, 2],
       [3, 4]])

此處使用的reshape重塑方法會在重構(gòu)章節(jié)講到。

(9). 獲取布爾索引指示的位置

In [473]: a>2
Out[473]: 
array([[False, False],
       [ True,  True]], dtype=bool)

In [474]: np.where(a>2)
Out[474]: (array([1, 1], dtype=int64), array([0, 1], dtype=int64))

In [476]: a[np.where(a>2)]
Out[476]: array([3, 4])

In [477]: np.where(a>2,a,-a)
Out[477]: 
array([[-1, -2],
       [ 3,  4]])

只輸入數(shù)組時毫缆，內(nèi)部會調(diào)用nonzero方法唯竹，返回值為一個tuple，包含每個軸上的索引值序列苦丁。
通過第二個參數(shù)x和第三個參數(shù)y浸颓，可以根據(jù)是否滿足條件對元素進(jìn)行不同的計(jì)算，返回同樣形狀的數(shù)組旺拉。

(10). 特定值查找

指定值序列

In [655]: a=np.arange(5)

In [656]: np.isin(a,[3,4])
Out[656]: array([False, False, False,  True,  True], dtype=bool)

第二個參數(shù)test_elements為指定值序列产上，返回布爾索引。

值排序搜索

In [683]: a=np.array([1,3,5,7,9])

In [684]: np.searchsorted(a,[3,6])
Out[684]: array([1, 3], dtype=int64)

第一個參數(shù)a為升序一維數(shù)組蛾狗，非升序可通過第四個參數(shù)指定排序sorter=np.argsort(a)晋涣，第二個參數(shù)v為需要被插入a的值或值序列，第三個參數(shù)side為判斷方式沉桌，'left'表示a[i-1] < v <= a[i]谢鹊，'right'表示a[i-1] <= v < a[i]。該方法將逐個搜索v的每個元素在升序數(shù)組a中合適的插入位置留凭，返回?cái)?shù)組索引佃扼。

空值

In [661]: a=np.array([np.nan,1,2,3])

In [662]: np.isnan(a)
Out[662]: array([ True, False, False, False], dtype=bool)

返回布爾索引。

(11). 返回索引的方法

2. 遍歷

(1). 序列結(jié)構(gòu)遍歷

a=np.array([[1,2],[3,4]])

for buf1 in a:
    for buf2 in buf1:
        print(buf2)

(2). 索引遍歷

for i in range(a.shape[0]):
    for j in range(a.shape[1]):
        print(a[i,j])

以上兩種方法在遍歷元素時，維數(shù)是多少就要嵌套多少層循環(huán)挎扰，效率不算高翠订，但可以在每一層循環(huán)中嵌入額外的計(jì)算巢音。

(3). 快速迭代器遍歷

for item in np.nditer(a):
    print(item)

默認(rèn)選擇元素的順序是和數(shù)組內(nèi)存布局一致的，而不是使用標(biāo)準(zhǔn)C或者Fortran順序尽超。這是為了使用效率而設(shè)計(jì)的官撼，這反映了默認(rèn)情況下只需訪問每個元素，而無需考慮其特定順序似谁“列澹可通過order參數(shù)來指定特定的順序來訪問數(shù)組。

(4). 平鋪迭代器遍歷

for item in a.flat:
    print(item)

將數(shù)組轉(zhuǎn)換為1-D的迭代器巩踏。

3. 抽樣

(1). 無放回抽樣

In [506]: a=np.array([[1,2],[3,4]])

In [507]: idx=np.random.choice(np.arange(a.shape[0]),size=1,replace=False)

In [508]: a[idx]
Out[508]: array([[3, 4]])

(2). 有放回抽樣

In [511]: idx=np.random.randint(0,a.shape[0],size=3)

In [512]: a[idx]
Out[512]: 
array([[1, 2],
       [3, 4],
       [1, 2]])

也可使用np.random.choice(np.arange(a.shape[0]),size=3)生成索引秃诵。
以上都是在單個軸方向上抽樣夺颤，如果想在多個軸方向上抽樣佑附，由于抽樣后必然會破壞數(shù)組結(jié)構(gòu)莹桅，建議先將用于抽樣的軸展開垂券，比如用reshape方法，見下面的示例嘴办，關(guān)于reshape方法的說明在重構(gòu)章節(jié)十艾。

(3). 多軸方向抽樣

In [524]: a=np.array([[[1,2],[3,4]],[[5,6],[7,8]]])

In [525]: a2=a.reshape((2,4))

In [526]: idx=np.random.randint(0,a2.shape[0],size=2)

In [527]: a2[:,idx]
Out[527]: 
array([[1, 2],
       [5, 6]])

4. 視圖

在對數(shù)組進(jìn)行了索引切片后芬为，返回的通常是原數(shù)組的一個視圖派近，不會完整的拷貝數(shù)據(jù)攀唯，因此在這種情況下進(jìn)行更新操作會影響到原數(shù)組和所有視圖。
可通過ndarray.view()方法獲得一個完整視圖渴丸，等效于ndarray[:,:,...]侯嘀。
想將視圖轉(zhuǎn)換為拷貝可使用ndarray.copy()方法。

In [542]: a=np.array([[1,2],[3,4]])

In [543]: a2=a[1,:]

In [544]: a2
Out[544]: array([3, 4])

In [545]: a2[:]=0

In [546]: a
Out[546]: 
array([[1, 2],
       [0, 0]])

五. 變更

1. 更新

(1). 更新整個數(shù)組

In [555]: a=np.array([[1,2],[3,4]])

In [556]: a=a+1

In [557]: a
Out[557]: 
array([[2, 3],
       [4, 5]])

In [558]: a[:,:]=a-1

In [559]: a
Out[559]: 
array([[1, 2],
       [3, 4]])

兩種方式都能更新整個數(shù)組谱轨，第一種將計(jì)算得到的新數(shù)組的引用重新賦給了a戒幔，第二種根據(jù)計(jì)算得到的新數(shù)組更新了原數(shù)組中相應(yīng)位置的值。

(2). 更新指定位置

In [569]: a[a>2]+=1

In [570]: a
Out[570]: 
array([[1, 2],
       [4, 5]])

In [571]: a[a>2]=a[a>2]+1

In [572]: a
Out[572]: 
array([[1, 2],
       [5, 6]])

In [573]: a[0,:]=0

In [574]: a
Out[574]: 
array([[0, 0],
       [5, 6]])

In [575]: a[a>2]=[3,4]

In [576]: a
Out[576]: 
array([[0, 0],
       [3, 4]])

值數(shù)組形狀需要與篩選后的原數(shù)組一致或遵循廣播的規(guī)則碟嘴。

(3). 定值填充

In [9]: a.fill(1)

In [10]: a
Out[10]: 
array([[1, 1],
       [1, 1]])

當(dāng)填充值數(shù)據(jù)類型與數(shù)組數(shù)據(jù)類型不一致時，會嘗試轉(zhuǎn)換囊卜，失敗時才會報(bào)錯娜扇。

2. 擴(kuò)增

(1). 插入

In [577]: a=np.array([[1,2],[3,4]])

In [578]: np.insert(a,1,[5,6],axis=0)
Out[578]: 
array([[1, 2],
       [5, 6],
       [3, 4]])

第二個參數(shù)obj是插入的位置索引，第三個參數(shù)values是待插入的值栅组，需要與指定軸方向上的切片形狀一致或滿足廣播規(guī)則雀瓢，第四個參數(shù)axis是指定的軸。不影響原數(shù)組玉掸，返回的是一個拷貝刃麸。

(2). 附加

In [578]: np.append(a,[[5,6]],axis=0)
Out[578]: 
array([[1, 2],
       [3, 4],
       [5, 6]])

第二個參數(shù)values是待插入的值，需要與指定軸方向上的切片形狀一致或滿足廣播規(guī)則司浪，第三個參數(shù)axis是指定的軸泊业。只能將新數(shù)據(jù)附加到數(shù)組末尾把沼。不影響原數(shù)組，返回的是一個拷貝吁伺。

(3). 堆疊

In [589]: np.c_[a,a]
Out[589]: 
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])

In [590]: np.column_stack((a,a))
Out[590]: 
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])

In [591]: np.concatenate((a,a),axis=1)
Out[591]: 
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])

In [592]: np.r_[a,a]
Out[592]: 
array([[1, 2],
       [3, 4],
       [1, 2],
       [3, 4]])

In [593]: np.row_stack((a,a))
Out[593]: 
array([[1, 2],
       [3, 4],
       [1, 2],
       [3, 4]])

In [594]: np.concatenate((a,a),axis=0)
Out[594]: 
array([[1, 2],
       [3, 4],
       [1, 2],
       [3, 4]])

In [595]: np.stack((a,a),axis=0)
Out[595]: 
array([[[1, 2],
        [3, 4]],

       [[1, 2],
        [3, 4]]])

np.c_和np.column_stack是沿軸1進(jìn)行堆疊饮睬，其他軸長度需要相同或滿足廣播規(guī)則，等效于np.concatenate(axis=1)篮奄。
np.r_和np.row_stack是沿軸0進(jìn)行堆疊捆愁，其他軸長度需要相同或滿足廣播規(guī)則，等效于np.concatenate(axis=0)窟却。
np.stack是沿新軸進(jìn)行堆疊昼丑，所有軸長度需要相同或滿足廣播規(guī)則。

(4). 重復(fù)

In [93]: a.repeat(3,axis=1)
Out[93]: 
array([[1, 1, 1, 2, 2, 2],
       [3, 3, 3, 4, 4, 4]])

In [96]: a.reshape((2,2,1)).repeat(3,axis=2)
Out[96]: 
array([[[1, 1, 1],
        [2, 2, 2]],

       [[3, 3, 3],
        [4, 4, 4]]])

In [98]: a.repeat(3).reshape((2,2,3))
Out[98]: 
array([[[1, 1, 1],
        [2, 2, 2]],

       [[3, 3, 3],
        [4, 4, 4]]])

In [99]: np.tile(a,2)
Out[99]: 
array([[1, 2, 1, 2],
       [3, 4, 3, 4]])

In [100]: np.tile(a,[2,2])
Out[100]: 
array([[1, 2, 1, 2],
       [3, 4, 3, 4],
       [1, 2, 1, 2],
       [3, 4, 3, 4]])

In [101]: np.tile(a.ravel(),2)
Out[101]: array([1, 2, 3, 4, 1, 2, 3, 4])

repeat方法將數(shù)組中的元素重復(fù)夸赫，可通過axis參數(shù)指定軸方向菩帝，默認(rèn)會將數(shù)組展開后在唯一的軸方向上重復(fù)元素°咀悖可配合ndarray.reshape在新軸上復(fù)制元素胁附。
tile方法將數(shù)組重復(fù)，注意滓彰，重復(fù)的是整個數(shù)組控妻，不是單個元素，得到的結(jié)果中同元素不一定是緊挨著的揭绑。

3. 刪除

(1). 索引篩選

In [616]: a[~(a[0]==1),:]
Out[616]: array([[3, 4]])

通過索引篩選可得到刪除指定內(nèi)容的數(shù)組弓候。

(2). 刪除方法

In [617]: np.delete(a,[0,1],axis=0)
Out[617]: array([], shape=(0, 2), dtype=int32)

通過相應(yīng)方法獲得刪除指定索引位置內(nèi)容的數(shù)組。第二個參數(shù)obj為索引位置他匪，第三個參數(shù)axis為指定軸菇存。

六. 重構(gòu)

1. 類型轉(zhuǎn)換

In [619]: a=np.array([[1,2],[3,4]])

In [620]: a.dtype
Out[620]: dtype('int32')

In [621]: a=a.astype('float64')

In [622]: a.dtype
Out[622]: dtype('float64')

In [623]: a=np.int32(a)

In [624]: a.dtype
Out[624]: dtype('int32')

使用ndarray.astype方法或是使用數(shù)據(jù)類型同名方法都可以轉(zhuǎn)換類型，關(guān)于numpy支持的數(shù)據(jù)類型可以查看屬性章節(jié)邦蜜。轉(zhuǎn)換類型后返回一個新數(shù)組依鸥。

2. 重塑

(1). 改變形狀

In [625]: a=np.array([[1,2],[3,4]])

In [626]: a.reshape((1,4))
Out[626]: array([[1, 2, 3, 4]])

In [627]: a.reshape((-1,4))
Out[627]: array([[1, 2, 3, 4]])

使用tuple類型的參數(shù)聲明新的形狀。允許有一個新軸的大小為-1悼沈，表示自動計(jì)算贱迟。
改變前后元素?cái)?shù)size需要保持一致。元素在軸上的排列是從最后一個軸開始往前面的軸方向上堆疊絮供，見如下圖示衣吠，可通過order參數(shù)指定其他排序方式。軸的相對位置不會改變壤靶，所以一些復(fù)雜的變形可能需要結(jié)合transpose或swapaxes此類軸交換方法使用缚俏。

(2). 平鋪

In [640]: a.ravel()
Out[640]: array([1, 2, 3, 4])

In [641]: a.flatten()
Out[641]: array([1, 2, 3, 4])

將數(shù)組平鋪為向量，等效于reshape((-1,))，可通過order參數(shù)指定其他排序方式忧换。

(3). 轉(zhuǎn)置

In [643]: a.T
Out[643]: 
array([[1, 3],
       [2, 4]])

數(shù)組為一維時轉(zhuǎn)置無效恬惯，為二維時即矩陣的轉(zhuǎn)置，多于二維時交換第一個和最后一個軸包雀。

(4). 軸交換

In [646]: a.swapaxes(0,1)
Out[646]: 
array([[1, 3],
       [2, 4]])

In [647]: a.transpose([1,0])
Out[647]: 
array([[1, 3],
       [2, 4]])

swapaxes一次只能指定兩個軸進(jìn)行交換宿崭，transpose可以重新為所有軸排序。

3. 排序

(1). 直接排序

In [734]: a=np.array([[2,3],[1,4]])

In [735]: np.sort(a,axis=None)
Out[735]: array([1, 2, 3, 4])

In [736]: a.sort(axis=0)

In [737]: a
Out[737]: 
array([[1, 3],
       [2, 4]])

ndarray.sort會直接在原數(shù)組上排序才写，可通過第一個參數(shù)axis指定排序的軸葡兑，會將沿著該軸方向的每個向量單獨(dú)排序，默認(rèn)-1赞草，除沿最后一個軸外讹堤，指定其他軸都會在排序時生成數(shù)據(jù)的臨時副本，因此沿最后一個軸排序最快厨疙。
等效方法np.sort洲守，返回的是排序后的副本，還可指定axis=None沾凄，會將數(shù)組展開再排序梗醇。
當(dāng)數(shù)組的維度具備實(shí)際含義時，直接排序會打亂數(shù)據(jù)結(jié)構(gòu)撒蟀，得到不被期望的結(jié)果叙谨，這種情況下需要使用間接排序。

(2). 間接排序

In [740]: a=np.array([[2,3,5],[1,1,4],[1,2,3]])

In [741]: a
Out[741]: 
array([[2, 3, 5],
       [1, 1, 4],
       [1, 2, 3]])

In [742]: idx1=np.argsort(a[:,0])

In [743]: a[idx1]
Out[743]: 
array([[1, 1, 4],
       [1, 2, 3],
       [2, 3, 5]])

In [744]: idx2=np.lexsort((a[:,0],a[:,2]))

In [745]: a[idx2]
Out[745]: 
array([[1, 2, 3],
       [1, 1, 4],
       [2, 3, 5]])

argsort可用于單鍵間接排序保屯，lexsort可用于多鍵間接排序手负。

(3). 隨機(jī)排序

In [763]: a=np.arange(12).reshape((3,4))

In [764]: a
Out[764]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

In [765]: np.random.shuffle(a)

In [766]: a
Out[766]: 
array([[ 4,  5,  6,  7],
       [ 0,  1,  2,  3],
       [ 8,  9, 10, 11]])

In [768]: idx=np.random.permutation(a.shape[1])

In [769]: a[:,idx]
Out[769]: 
array([[ 4,  5,  7,  6],
       [ 0,  1,  3,  2],
       [ 8,  9, 11, 10]])

方法一np.random.shuffle只能沿第一個軸進(jìn)行隨機(jī)排序，方法二是通過np.random.permutation姑尺，該方法也只能沿第一個軸隨機(jī)排序竟终，但在輸入?yún)?shù)x為int類型時，會對np.arange(x)進(jìn)行隨機(jī)排序切蟋，可以快速生成亂序索引统捶，再通過索引查找得到亂序數(shù)組。

(4). 分區(qū)排序

In [799]: a=np.array([2,3,1,5,4,0,8])

In [800]: np.partition(a,1)
Out[800]: array([0, 1, 3, 5, 4, 2, 8])

In [801]: np.partition(a,4)
Out[801]: array([0, 1, 2, 3, 4, 5, 8])

分區(qū)排序是一種不完整的排序柄粹，用于不需要獲取完整排序序列的情況下喘鸟。該方法只保證kth指定位置的元素是正確排序的，其他小于該元素的元素前移镰惦，大于的后移迷守∪蓿可用于快速找出第k大或第k小的元素旺入。
也可通過ndarray.partition調(diào)用，axis參數(shù)指定軸方向，還有對應(yīng)的np.argpartition用于獲取分區(qū)后的索引茵瘾。

4. 去重

In [775]: a=np.array([3,2,2,3,1,1,4])

In [776]: np.unique(a,return_index=True,return_inverse=True,return_counts=True,axis=None)
Out[776]: 
(array([1, 2, 3, 4]),
 array([4, 1, 0, 6], dtype=int64),
 array([2, 1, 1, 2, 0, 0, 3], dtype=int64),
 array([2, 2, 2, 1], dtype=int64))

In [777]: a=np.array([[1,3],[2,4],[1,3]])

In [778]: np.unique(a,axis=0)
Out[778]: 
array([[1, 3],
       [2, 4]])

axis指定去重的軸礼华，默認(rèn)None會將數(shù)組展開后再去重。
返回值一為去重后的有序值列表拗秘；
返回值二為唯一值在原數(shù)組中的索引圣絮，僅在return_index=True時提供；
返回值三為根據(jù)唯一值重建原數(shù)組的索引雕旨，僅在return_inverse=True時提供扮匠；
返回值四為唯一值的出現(xiàn)計(jì)數(shù)，僅在return_counts=True時提供凡涩。

5. 拆分

(1). 索引拆分

In [780]: a=np.arange(9).reshape((3,3))

In [781]: a[:2,:],a[2:,:]
Out[781]: 
(array([[0, 1, 2],
        [3, 4, 5]]), array([[6, 7, 8]]))

In [782]: a[a>2],a[~(a>2)]
Out[782]: (array([3, 4, 5, 6, 7, 8]), array([0, 1, 2]))

In [790]: idx=np.random.permutation(a.shape[0])

In [791]: sp_idx=int(a.shape[0]*0.8)

In [792]: a[idx[:sp_idx]],a[idx[sp_idx:]]
Out[792]: 
(array([[3, 4, 5],
        [6, 7, 8]]), array([[0, 1, 2]]))

最靈活的方式棒搜，復(fù)雜的拆分需要寫較多的代碼，可使用其他方法配合生成用于拆分的索引活箕，比如使用np.digitize進(jìn)行分箱力麸。

(2). 拆分方法

In [802]: a=np.arange(8)

In [803]: np.split(a,2)
Out[803]: [array([0, 1, 2, 3]), array([4, 5, 6, 7])]

In [805]: np.split(a,[2,5])
Out[805]: [array([0, 1]), array([2, 3, 4]), array([5, 6, 7])]

In [806]: a=a.reshape((2,4))

In [807]: a
Out[807]: 
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])

In [809]: np.split(a,[1,3],axis=1)
Out[809]: 
[array([[0],
        [4]]), array([[1, 2],
        [5, 6]]), array([[3],
        [7]])]

第二個參數(shù)indices_or_sections指定分割方式，int類型表示等分?jǐn)?shù)量育韩，一維數(shù)組類型表示用于分割的索引值克蚂，例如[2,5]表示分割為a[:2],a[2:5],a[5:]。
第三個參數(shù)axis可以指定軸方向筋讨。

七. 讀寫

numpy 可使用專用的npy和npz格式或常見的txt格式存儲ndarray的數(shù)據(jù)埃叭。

1. 保存

In [803]: a=np.array([1,2,3,4])

In [804]: b=np.array([[5,6],[7,8]])

In [805]: np.save('D:\\out.npy',a)

In [806]: np.savez('D:\\out.npz',a,b=b)

In [807]: np.savetxt('D:\\out.txt',b,fmt="%d", delimiter=",")

拓展名可以省略，會自動補(bǔ)全版仔。無法自動創(chuàng)建文件夾游盲。
save用于保存單個數(shù)組為npy格式文件。
savez用于保存多個數(shù)組為npz格式文件蛮粮，沒有使用關(guān)鍵字參數(shù)傳遞的數(shù)組會自動命名為arr_0,arr_1,...益缎。
savetxt用于保存單個數(shù)組為txt格式文件，參數(shù)fmt指定保存時的字符串轉(zhuǎn)換然想，參數(shù)delimiter指定分隔符莺奔，注意在讀取時也需要指定分隔符。分隔符的設(shè)置對一維數(shù)組無效变泄，二維以上的數(shù)組不適合用該方法保存令哟。

2. 加載

In [835]: np.load('D:\\out.npy')
Out[835]: array([1, 2, 3, 4])

In [836]: npz=np.load('D:\\out.npz')

In [837]: npz['arr_0']
Out[837]: array([1, 2, 3, 4])

In [838]: npz['b']
Out[838]: 
array([[5, 6],
       [7, 8]])

In [841]: np.loadtxt('D:\\out.txt',dtype='int',delimiter=',')
Out[841]: 
array([[5, 6],
       [7, 8]])

np.load讀取npz格式文件會得到一個NpzFile對象，之后通過保存時設(shè)置的名稱進(jìn)行[]索引可以取得每一個數(shù)組妨蛹。

八. 其他

1. 矩陣類型

numpy提供了一個專用的矩陣對象matrix屏富，是基于 ndarray作了進(jìn)一步的封裝得到的，能夠更加快捷地進(jìn)行一些矩陣相關(guān)的運(yùn)算蛙卤，但相比ndarray沒有性能上的優(yōu)勢且維數(shù)限制在二維狠半，并不推薦使用噩死。

(1). 創(chuàng)建

In [79]: m1=np.matrix([[1,2],[3,4]])

In [81]: m1
Out[81]: 
matrix([[1, 2],
        [3, 4]])

創(chuàng)建方式與ndarray類似。

(2). 與 ndarray的相互轉(zhuǎn)換

In [82]: a=np.array([[5,6],[7,8]])

In [83]: m2=np.matrix([[5,6],[7,8]])

In [84]: np.asmatrix(a)
Out[84]: 
matrix([[5, 6],
        [7, 8]])

In [85]: np.matrix(a)
Out[85]: 
matrix([[5, 6],
        [7, 8]])

In [88]: np.asarray(m2)
Out[88]: 
array([[5, 6],
       [7, 8]])

In [89]: np.array(m2)
Out[89]: 
array([[5, 6],
       [7, 8]])

In [90]: m2.base
Out[90]: 
array([[5, 6],
       [7, 8]])

(3). 矩陣運(yùn)算

In [94]: m1*m2
Out[94]: 
matrix([[19, 22],
        [43, 50]])

In [95]: m1.I
Out[95]: 
matrix([[-2. ,  1. ],
        [ 1.5, -0.5]])

In [96]: m1.T
Out[96]: 
matrix([[1, 3],
        [2, 4]])

運(yùn)算符*用在matrix上表示矩陣乘法神年，等效于np.dot(m1,m2)已维，要實(shí)現(xiàn)元素相乘需要使用np.multiply(m1,m2)。
matrix.T表示轉(zhuǎn)置矩陣已日，matrix.I表示逆矩陣垛耳。
matrix可以使用大部分ndarray的方法，比如max飘千、sum堂鲜、sort等。

2. 張量運(yùn)算

張量是向量护奈、矩陣這類概念的推廣泡嘴，標(biāo)量是0階張量，向量是1階張量逆济，矩陣是2階張量酌予。
numpy提供了廣義的張量點(diǎn)積運(yùn)算np.tensordot。

In [2]: a=np.arange(1,9).reshape((2,2,2))

In [3]: b=np.arange(1,5).reshape((2,2))

In [4]: a
Out[4]: 
array([[[1, 2],
        [3, 4]],

       [[5, 6],
        [7, 8]]])

In [5]: b
Out[5]: 
array([[1, 2],
       [3, 4]])

In [8]: np.tensordot(a,b,axes=1)
Out[8]: 
array([[[ 7, 10],
        [15, 22]],

       [[23, 34],
        [31, 46]]])

In [9]: np.tensordot(a,b,axes=(-1,0))
Out[9]: 
array([[[ 7, 10],
        [15, 22]],

       [[23, 34],
        [31, 46]]])

In [10]: np.tensordot(a,b,axes=2)
Out[10]: array([30, 70])

In [12]: np.tensordot(a,b,axes=([-2,-1],[0,1]))
Out[12]: array([30, 70])

In [13]: np.dot(a,b)
Out[13]: 
array([[[ 7, 10],
        [15, 22]],

       [[23, 34],
        [31, 46]]])

In [14]: np.tensordot(a,b,axes=(-1,-2))
Out[14]: 
array([[[ 7, 10],
        [15, 22]],

       [[23, 34],
        [31, 46]]])

In [15]: np.inner(a,b)
Out[15]: 
array([[[ 5, 11],
        [11, 25]],

       [[17, 39],
        [23, 53]]])

In [16]: np.tensordot(a,b,axes=(-1,-1))
Out[16]: 
array([[[ 5, 11],
        [11, 25]],

       [[17, 39],
        [23, 53]]])

前兩個參數(shù)a和b為參與運(yùn)算的兩個張量奖慌。
第三個參數(shù)axes用于指定收縮的軸抛虫，完整格式形如([a_axis1,a_axis2,...],[b_axis1,b_axis2,...])，兩個序列分別指定a和b的軸简僧，軸方向上的元素會按照被指定的順序?qū)?yīng)建椰、相乘并相加；可使用(a_axis,b_axis)的形式僅指定一個軸岛马；
可使用int類型快速指定a中最后N個軸和b中前N個軸用于收縮棉姐，即0等效于([],[])，對應(yīng)張量積運(yùn)算啦逆，1等效于([-1],[0])伞矩，對應(yīng)張量內(nèi)積運(yùn)算，2等效于([-2,-1],[0,1])夏志，對應(yīng)張量雙收縮運(yùn)算乃坤，axes的默認(rèn)值為2。
np.dot沟蔑、np.inner這類運(yùn)算可視作該函數(shù)表示的幾個特例湿诊，np.dot(a1,a2)等效于np.tensordot(a1,a2,axes=(-1,-2))，np.inner(a1,a2)等效于np.tensordot(a1,a2,axes=(-1,-1))瘦材。

3. 傅里葉變換

(1) 頻率序列

In [12]: np.fft.fftfreq(10,1.0)
Out[12]: array([ 0. ,  0.1,  0.2,  0.3,  0.4, -0.5, -0.4, -0.3, -0.2, -0.1])

返回離散傅里葉變換采樣頻率厅须，第一個參數(shù)n為窗口長度，int類型食棕，第二個參數(shù)d為采樣間距（采樣率的倒數(shù)）朗和，默認(rèn)為1.0颁湖，返回值單位與采樣間距單位相對應(yīng)。
返回值序列的計(jì)算方式：
如果n是偶數(shù)例隆，f = [0, 1, ..., n/2-1, -n/2, ..., -1] / (d*n)；
如果n是奇數(shù)抢蚀，f = [0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n)镀层。

(2) 快速傅里葉變換

In [13]: x=np.cos(np.linspace(0,2*np.pi,30))

In [14]: y=np.fft.fft(x)

In [15]: x2=np.fft.ifft(y)

In [16]: np.abs(x2-x).max()
Out[16]: 3.8864883384594504e-16

np.fft和np.ifft互為逆運(yùn)算，用于一維快速傅里葉變換皿曲，經(jīng)np.fft變換后的序列可通過np.ifft近似還原為原序列唱逢。
第二個參數(shù)n指定輸出的變換軸長度，超長裁剪屋休，不足補(bǔ)0坞古；
第三個參數(shù)axis指定用于變換的軸，默認(rèn)最后一個軸劫樟。

(3) 移頻

In [21]: x=np.linspace(0,2*np.pi,8)

In [22]: y=np.fft.fft(x)

In [23]: y2=np.fft.fftshift(y)

In [24]: y3=np.fft.ifftshift(y2)

In [32]: np.abs(y3-y).max()
Out[32]: 0.0

np.fftshift和np.ifftshift互為逆運(yùn)算痪枫，用于將傅里葉變換輸出中的直流分量移動到頻譜的中央。第二個參數(shù)axis可指定用于轉(zhuǎn)移的軸叠艳。

4. 圖像處理

圖像數(shù)據(jù)的存儲方式是類似于數(shù)組的奶陈，可借助PIL庫讀取圖片，再將圖像數(shù)據(jù)轉(zhuǎn)成ndarray進(jìn)行計(jì)算處理附较。
以下提供一些使用numpy配合PIL處理圖片數(shù)據(jù)的方法:

(1) 圖片的創(chuàng)建吃粒、讀取、縮放拒课、保存

In [2]: from PIL import Image
   ...: image1= Image.open("D:\\test.jpg")

In [3]: image1.size
Out[3]: (1015, 610)

In [4]: image2=image1.resize((500,300))

In [5]: image2.save("D:\\test2.jpg")

In [6]: image0=Image.new('RGB',image2.size)

In [7]: image2
Out[7]: 

Image.open用于打開一張圖片徐勃，mode可以設(shè)置讀取模式，最常用的是'L'灰度圖和'RGB'彩色圖早像，一般會自動匹配不需要設(shè)置僻肖。
圖片對象的resize方法可以縮放圖片，大小參數(shù)以tuple類型(width,height)格式傳入卢鹦。
圖片對象的save方法可以保存圖片檐涝，通過保存路徑中的文件拓展名或是format參數(shù)指定保存文件類型，quality參數(shù)可以設(shè)置保存圖像的質(zhì)量法挨，取值1（最差）~ 95（最佳）谁榜，默認(rèn)75。
Image.new用于創(chuàng)建一個新的圖片凡纳，mode參數(shù)指定模式窃植，size指定大小。
在IPython中荐糜，直接輸入圖片變量名就可以顯示圖片巷怜。

(2) 圖片與數(shù)組之間的轉(zhuǎn)換

In [7]: a=np.asarray(image2)

In [8]: a.shape
Out[8]: (300, 500, 3)

In [9]: image3=Image.fromarray(a,'RGB')

np.asarray或np.array可以將圖片轉(zhuǎn)換為ndarray葛超，np.asarray返回圖片數(shù)據(jù)的ndarray類型視圖，不能更改延塑。根據(jù)類型的不同绣张，得到的數(shù)組形狀也不一樣，常見的兩種关带，灰度圖轉(zhuǎn)換得到形狀為(height,width)的數(shù)組侥涵，彩色圖轉(zhuǎn)換得到形狀為(height,width,channel)的數(shù)組，channel即顏色通道宋雏，RGB模式下channel=3芜飘，分別對應(yīng)紅綠藍(lán)。
Image.fromarray可以將ndarray轉(zhuǎn)換為圖片磨总，可通過mode參數(shù)指定模式嗦明，默認(rèn)會根據(jù)數(shù)組形狀自動匹配，當(dāng)指定某個模式時蚪燕，數(shù)組形狀也需要匹配娶牌。
注意，數(shù)組轉(zhuǎn)圖片需要是uint8數(shù)據(jù)類型馆纳，取值0~255裙戏，如不符合要進(jìn)行另外的轉(zhuǎn)換。

(3) 像素點(diǎn)繪制

In [10]: a0=np.array(image0)

In [11]: a0+=np.random.randint(0,256,a.shape,dtype='uint8')

In [12]: image4=Image.fromarray(a0)

In [13]: image4.putpixel((0,0),(255,255,255))

In [14]: image4 
Out[14]: 

圖片對象的putpixel方法可以添加單個像素點(diǎn)厕诡，第一個參數(shù)xy以(x,y)的形式聲明添加像素點(diǎn)的位置累榜，第二個參數(shù)value指定像素點(diǎn)的值，例如灵嫌，L灰度圖模式下為標(biāo)量值壹罚，RGB彩色圖模式下為(r,g,b)形式的tuple，取值均在0~255之間寿羞。該方法一次只能繪制一個像素點(diǎn)猖凛，效率低，在需要批量繪制時建議轉(zhuǎn)換為ndarray處理绪穆。
上面的示例中使用ndarray的方法為新圖片的每一個像素點(diǎn)添加了隨機(jī)色彩辨泳。

(4) 灰度圖和彩色圖之間的轉(zhuǎn)換

In [72]: a2=np.asarray(image2,dtype='float')

In [73]: a5=(11*a2[:,:,0]+16*a2[:,:,1]+5*a2[:,:,2])/32

In [74]: image5=Image.fromarray(np.uint8(a5))

In [75]: a6=a5.repeat(3).reshape(a5.shape+(3,))

In [76]: image6=Image.fromarray(np.uint8(a6))

In [77]: image5
Out[77]: 

(5) 圖片的翻轉(zhuǎn)摹闽、旋轉(zhuǎn)蹄咖、裁剪

In [84]:a2=np.asarray(image2)

In [85]:Image.fromarray(a2[::-1,::-1,:])
Out[85]: 

In [90]:Image.fromarray(a2.transpose([1,0,2]))
Out[90]: 

In [91]:Image.fromarray(a2[:150,:,:])
Out[91]: 

以上示例展示了 左右翻轉(zhuǎn)+上下翻轉(zhuǎn)，左右翻轉(zhuǎn)+逆時針轉(zhuǎn)90°付鹿，截取上半部分 三種情況澜汤，借助倒序索引和軸交換的組合可以得到90°倍數(shù)旋轉(zhuǎn)和上下左右翻轉(zhuǎn)的所有組合情形。精確的旋轉(zhuǎn)需要使用矩陣運(yùn)算倘屹，此處不作展開。