Numpy切片和索引
ndarray對象的內容可以通過索引或切片來訪問和修改，與 Python 中 list 的切片操作一樣。
ndarray 數組可以基于 0 ~ n-1 的下標進行索引，切片對象可以通過內置的 slice 函數，并設置 start, stop 及 step 參數進行，從原數組中切割出一個新數組。
切片還可以包括省略號 …，來使選擇元組的長度與數組的維度相同。 如果在行位置使用省略號，它將返回包含行中元素的 ndarray。
高級索引
整數數組索引
以下實例獲取數組中 (0,0)，(1,1) 和 (2,0) 位置處的元素。
a = np.array([[0,1,2], [3,4,5], [6,7,8], [9,10,11]])
print(a)
print('-' * 20)
rows = np.array([[0,0], [3,3]])
cols = np.array([[0,2], [0,2]])
b = a[rows, cols]
print(b)
print('-' * 20)
rows = np.array([[0,1], [2,3]])
cols = np.array([[0,2], [0,2]])
c = a[rows, cols]
print(c)
print('-' * 20)
rows = np.array([[0,1,2], [1,2,3], [1,2,3]])
cols = np.array([[0,1,2], [0,1,2], [0,1,2]])
d = a[rows, cols]
print(d)
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
--------------------
[[ 0 2]
[ 9 11]]
--------------------
[[ 0 5]
[ 6 11]]
--------------------
[[ 0 4 8]
[ 3 7 11]
[ 3 7 11]]
返回的結果是包含每個角元素的 ndarray 對象。
可以借助切片 : 或 … 與索引數組組合。如下面例子：
a = np.array([[1,2,3], [4,5,6], [7,8,9]])
print(a)
print('-' * 20)
b = a[1:3, 1:3]
print(b)
print('-' * 20)
c = a[1:3, [0,2]]
print(c)
print('-' * 20)
d = a[..., 1:]
print(d)
[[1 2 3]
[4 5 6]
[7 8 9]]
--------------------
[[5 6]
[8 9]]
--------------------
[[4 6]
[7 9]]
--------------------
[[2 3]
[5 6]
[8 9]]
布爾索引
我們可以通過一個布爾數組來索引目標數組。
布爾索引通過布爾運算（如：比較運算符）來獲取符合指定條件的元素的數組。
以下實例獲取大于 5 的元素：
a = np.array([[1,2,3], [4,5,6], [7,8,9]])
print(a)
print('-' * 20)
print(a[a > 5])
[[1 2 3]
[4 5 6]
[7 8 9]]
--------------------
[6 7 8 9]
以下實例使用了 ~（取補運算符）來過濾 NaN。
a = np.array([np.nan, 1, 2, np.nan, 3, 4, 5])
print(a)
print('-' * 20)
print(a[~np.isnan(a)])
[nan 1. 2. nan 3. 4. 5.]
--------------------
[1. 2. 3. 4. 5.]
以下實例演示如何從數組中過濾掉非復數元素。
a = np.array([1, 3+4j, 5, 6+7j])
print(a)
print('-' * 20)
print(a[np.iscomplex(a)])
[1.+0.j 3.+4.j 5.+0.j 6.+7.j]
--------------------
[3.+4.j 6.+7.j]
花式索引
花式索引指的是利用整數數組進行索引。
花式索引根據索引數組的值作為目標數組的某個軸的下標來取值。
對于使用一維整型數組作為索引，如果目標是一維數組，那么索引的結果就是對應位置的元素，如果目標是二維數組，那么就是對應下標的行。
花式索引跟切片不一樣，它總是將數據復制到新數組中。
一維數組
a = np.arange(2, 10)
print(a)
print('-' * 20)
b = a[[0,6]]
print(b)
[2 3 4 5 6 7 8 9]
--------------------
[2 8]
二維數組
1、傳入順序索引數組
a = np.arange(32).reshape(8, 4)
print(a)
print('-' * 20)
print(a[[4, 2, 1, 7]])
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]
[24 25 26 27]
[28 29 30 31]]
--------------------
[[16 17 18 19]
[ 8 9 10 11]
[ 4 5 6 7]
[28 29 30 31]]
2、傳入倒序索引數組
a = np.arange(32).reshape(8, 4)
print(a[[-4, -2, -1, -7]])
[[16 17 18 19]
[24 25 26 27]
[28 29 30 31]
[ 4 5 6 7]]
3、傳入多個索引數組（要使用 np.ix_）
np.ix_ 函數就是輸入兩個數組，產生笛卡爾積的映射關系。
笛卡爾乘積是指在數學中，兩個集合 X 和 Y 的笛卡爾積（Cartesian product），又稱直積，表示為 X×Y，第一個對象是X的成員而第二個對象是 Y 的所有可能有序對的其中一個成員。
例如 A={a,b}, B={0,1,2}，則：
A×B={(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)}
B×A={(0, a), (0, b), (1, a), (1, b), (2, a), (2, b)}a = np.arange(32).reshape(8, 4)
print(a[np.ix_([1,5,7,2], [0,3,1,2])])
[[ 4 7 5 6]
[20 23 21 22]
[28 31 29 30]
[ 8 11 9 10]]
廣播(Broadcast)
廣播(Broadcast)是 numpy 對不同形狀(shape)的數組進行數值計算的方式， 對數組的算術運算通常在相應的元素上進行。
如果兩個數組 a 和 b 形狀相同，即滿足 a.shape == b.shape，那么 a*b 的結果就是 a 與 b 數組對應位相乘。這要求維數相同，且各維度的長度相同。
a = np.arange(1, 5)
b = np.arange(1, 5)
c = a * b
print(c)
當運算中的 2 個數組的形狀不同時，numpy 將自動觸發廣播機制。如：
a = np.array([
[0, 0, 0],
[10, 10, 10],
[20, 20, 20],
[30, 30, 30]
])
b = np.array([0, 1, 2])
print(a + b)
[[ 0 1 2]
[10 11 12]
[20 21 22]
[30 31 32]]
下面的圖片展示了數組 b 如何通過廣播來與數組 a 兼容。
tile擴展數組
a = np.array([1, 2])
b = np.tile(a, (6, 1))
print(b)
print('-' * 20)
c = np.tile(a, (2, 3))
print(c)
[[1 2]
[1 2]
[1 2]
[1 2]
[1 2]
[1 2]]
--------------------
[[1 2 1 2 1 2]
[1 2 1 2 1 2]]
4x3 的二維數組與長為 3 的一維數組相加，等效于把數組 b 在二維上重復 4 次再運算：
a = np.array([
[0, 0, 0],
[10, 10, 10],
[20, 20, 20],
[30, 30, 30]
])
b = np.array([0, 1, 2])
bb = np.tile(b, (4, 1))
print(a + bb)
[[ 0 1 2]
[10 11 12]
[20 21 22]
[30 31 32]]
廣播的規則:
- 讓所有輸入數組都向其中形狀最長的數組看齊，形狀中不足的部分都通過在前面加 1 維補齊。
- 輸出數組的形狀是輸入數組形狀的各個維度上的最大值。
- 如果輸入數組的某個維度和輸出數組的對應維度的長度相同或者其長度為 1 時，這個數組能夠用來計算，否則出錯。
- 當輸入數組的某個維度的長度為 1 時，沿著此維度運算時都用此維度上的第一組值。
簡單理解：對兩個數組，分別比較他們的每一個維度（若其中一個數組沒有當前維度則忽略），滿足：
- 數組擁有相同形狀。
- 當前維度的值相等。
- 當前維度的值有一個是 1。
若條件不滿足，拋出 "ValueError: frames are not aligned" 異常。
