理解 numpy.where

Question

I want to get first index of numpy array element which is greater than some specific element of that same array. I tried following:

>>> Q5=[[1,2,3],[4,5,6]]
>>> Q5 = np.array(Q5)
>>> Q5[0][Q5>Q5[0,0]]
array([2, 3])
>>> np.where(Q5[0]>Q5[0,0])
(array([1, 2], dtype=int32),)
>>> np.where(Q5[0]>Q5[0,0])[0][0]
1

Q1. Is above correct way to obtain first index of an element in Q5[0] greater than Q5[0,0] ?

I am more concerned with np.where(Q5[0]>Q5[0,0]) returning tuple (array([1, 2], dtype=int32),) and hence requiring me to double index [0][0] at the end of np.where(Q5[0]>Q5[0,0])[0][0] .

Q2. Why this return tuple, but below returns proper numpy array?

>>> np.where(Q5[0]>Q5[0,0],Q5[0],-1)
array([-1,  2,  3])

So that I can index directly:

>>> np.where(Q5[0]>Q5[0,0],Q5[0],-1)[1]
2

Answer 1

Using argmax with a boolean array will give you the index of the first True.

In [54]: q
Out[54]: 
array([[1, 2, 3],
       [4, 5, 6]])

In [55]: q > q[0,0]
Out[55]: 
array([[False,  True,  True],
       [ True,  True,  True]], dtype=bool)

argmax can take an axis/dimension argument.

In [56]: np.argmax(q > q[0,0], 0)
Out[56]: array([1, 0, 0], dtype=int64)

That says the first True is index one for column zero and index zero for columns one and two.

In [57]: np.argmax(q > q[0,0], 1)
Out[57]: array([1, 0], dtype=int64)

That says the first True is index one for row zero and index zero for row one.

---

Q1. Is above correct way to obtain first index of an element in Q5[0] greater than Q5[0,0]?

No I would use argmax with 1 for the axis argument then select the first item from that result.

Q2. Why this return tuple

You told it to return -1 for False values and return Q5[0] items for True values.

Q2 ...but below returns proper numpy array?

You got lucky and chose the correct index.

Answer 2

In [58]: A = np.arange(1,10).reshape(3,3)
In [59]: A.shape
Out[59]: (3, 3)
In [60]: A
Out[60]: 
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

np.where with just the condition is really np.nonzero .

Generate a boolean array:

In [63]: A==6
Out[63]: 
array([[False, False, False],
       [False, False,  True],
       [False, False, False]])

Find where that is true:

In [64]: np.nonzero(A==6)
Out[64]: (array([1]), array([2]))

The result is a tuple, one element per dimension of the condition. Each element is an indexing array, together they define the location of the True(s)

Another test with several True

In [65]: (A%3)==1
Out[65]: 
array([[ True, False, False],
       [ True, False, False],
       [ True, False, False]])
In [66]: np.nonzero((A%3)==1)
Out[66]: (array([0, 1, 2]), array([0, 0, 0]))

Using the tuple to index the original array:

In [67]: A[np.nonzero((A%3)==1)]
Out[67]: array([1, 4, 7])

Using the 3 argument where to create a new array with a mix of values from A and A+10

In [68]: np.where((A%3)==1,A+10, A)
Out[68]: 
array([[11,  2,  3],
       [14,  5,  6],
       [17,  8,  9]])

If the condition has multiple True, nonzero isn't the test tool for finding the "first", since it necessarily finds all.

The nonzero tuple can be turned into a 2d array with a transpose . It actually may be easier to get the "first" from this array:

In [73]: np.argwhere((A%3)==1)
Out[73]: 
array([[0, 0],
       [1, 0],
       [2, 0]])

---

You are looking in a 1d array, a row of A:

In [77]: A[0]>A[0,0]
Out[77]: array([False,  True,  True])
In [78]: np.nonzero(A[0]>A[0,0])
Out[78]: (array([1, 2]),)            # 1 element tuple
In [79]: np.argwhere(A[0]>A[0,0])
Out[79]: 
array([[1],
       [2]])
In [81]: np.where(A[0]>A[0,0], 100, 0)     # 3 argument where
Out[81]: array([  0, 100, 100])

So whether you are searching a 1d array or a 2d (or 3 or 4), nonzero returns a tuple with one array element per dimension. That way it can always be used to index a like sized array. The 1d tuple might look redundant, but it is consistent with other dimensional results.

When trying understand operations like this, read the docs carefully, and look at individual steps. Here I look at the conditional matrix, the nonzero result, and its various uses.

Answer 3

numpy.where() is like a for loop with an if.

numpy.where(condition, values, new_value)

condition - just like if conditions.
values - The values to iterate on
new_value - if the condition is true for a value , its going to change to the new_value

---

If we would like to write it for a 1-dimensional array it should look something like this:

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

---

Example:

 >>> a = np.arange(10) >>> a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> np.where(a < 5, a, 10*a) array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90])

First we create an array with numbers from 0 to 9 (0, 1, 2 ... 7, 8, 9)
and then we are checking for all the values in the array that are greater from 5 and multiplying their value by 10.
So now all the values in the array that are less then 5 stayed the same and all the values that are greater multiplied by 10