numpy之meshgrid和where

meshgrid

np.meshgrid()

np.meshgrid從坐標向量返回坐標矩陣。

這樣說可能很抽象。舉個例子。

x = np.arange(-2,2)
y = np.arange(0,3)#生成一位數組，其實也就是向量

x
Out[31]: array([-2, -1,  0,  1])

y
Out[32]: array([0, 1, 2])

z,s = np.meshgrid(x,y)#將兩個一維數組變為二維矩陣

z
Out[36]: 
array([[-2, -1,  0,  1],
       [-2, -1,  0,  1],
       [-2, -1,  0,  1]])

s
Out[37]: 
array([[0, 0, 0, 0],
       [1, 1, 1, 1],
       [2, 2, 2, 2]])

從代碼上看，我們得到了這樣一組值：

-2， -1， 0， 1，---- 0， 0， 0， 0
-2， -1， 0， 1，---- 1， 1， 1， 1

也就是說，它講 x 變成了矩陣 z 的行向量，y 變成了矩陣 s 的列向量。

反過來，也是一樣的：

z,s = np.meshgrid(y,x)

z
Out[40]: 
array([[0, 1, 2],
       [0, 1, 2],
       [0, 1, 2],
       [0, 1, 2]])

s
Out[41]: 
array([[-2, -2, -2],
       [-1, -1, -1],
       [ 0,  0,  0],
       [ 1,  1,  1]])

以上面這個例子來說，z 和 s 就構成了一個坐標矩陣，實際上也就是一個網格，不知道你沒有注意到，z 和 s 的維數是一樣的，是一個4 × 4的網格矩陣，也就是坐標矩陣。

meshgrid 方法的參數數量不受限，可以得到任意 N 維空間中的坐標矩陣。

注意到，傳入的對象是一維的。

想到這里，我覺得，這可能和方程式有關系（很可能我的感覺是錯的，等以后發現再改這句話，但是我覺得這樣的話，會很好理解這個函數方法），也就是行列式，但是方程式的右側的 y 只有一列。

a1x1 + b1x2 + c1x3 + d1x4 + ...... =y1
a2x1 + b2x2 + c2x3 + d2x4 + ...... =y2
...
...

x, y = np.meshgrid(np.arange(-1, 1, 0.01), np.arange(-1, 1, 0.01))

contor = np.sqrt(x ** 2 + y ** 2)
plt.imshow(contor)
plt.colorbar()
plt.show()

np.where()

where(condition, [x, y]) 當condition為True時，返回 x ， 否則返回 y。

其實，在x, y 為一維數組時，就相當於：

[xv if c else yv for (c,xv,yv) in zip(condition,x,y)]

測試：

In [3]: x = np.arange(9).reshape(3,3)#創建一個3×3的矩陣

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

In [5]: np.where(x>4) #只輸入condition
Out[5]: (array([1, 2, 2, 2], dtype=int64), array([2, 0, 1, 2], dtype=int64))

In [6]: np.where(x>7)# 只輸入condition
Out[6]: (array([2], dtype=int64), array([2], dtype=int64))

通過上面的例子，我們可以發現，只輸入condition的話，得到的結果是一個位置索引。它們就是滿足條件的元素的索引，即為True的元素。

說明下:返回的第一個第一個數組為行坐標，第二個為縱坐標。

我們還可以用where來這樣做：

In [8]: y = np.random.randn(3,3)

In [9]: y
Out[9]:
array([[ 1.59809956, -0.42735851,  1.46593089],
       [-0.26497622,  0.53948157, -2.01569974],
       [-0.11099139, -1.70616601, -1.34821361]])

In [10]: np.where(y > 0, 4, -4)
Out[10]:
array([[ 4, -4,  4],
       [-4,  4, -4],
       [-4, -4, -4]])

很顯然，np.where()是可以嵌套使用的，其類似於if..elif...else...，如果我們有多個條件的話。

大家都知道，布爾值在計算過程中是可以當做0和1處理的。
因此，我們還可以這樣：

result = 3 * (con2 & -cond1) + 2 * - (cond1 | cond2)