# Find indices of elements equal to zero in a NumPy array

## Question:

NumPy has the efficient function/method `nonzero()`

to identify the indices of non-zero elements in an `ndarray`

object. What is the most efficient way to obtain the indices of the elements that *do* have a value of zero?

## Answers:

numpy.where() is my favorite.

```
>>> x = numpy.array([1,0,2,0,3,0,4,5,6,7,8])
>>> numpy.where(x == 0)[0]
array([1, 3, 5])
```

The method `where`

returns a tuple of ndarrays, each corresponding to a different dimension of the input. Since the input is one-dimensional, the `[0]`

unboxes the tuple’s only element.

You can search for any scalar condition with:

```
>>> a = np.asarray([0,1,2,3,4])
>>> a == 0 # or whatver
array([ True, False, False, False, False], dtype=bool)
```

Which will give back the array as an boolean mask of the condition.

If you are working with a one-dimensional array there is a syntactic sugar:

```
>>> x = numpy.array([1,0,2,0,3,0,4,5,6,7,8])
>>> numpy.flatnonzero(x == 0)
array([1, 3, 5])
```

You can also use `nonzero()`

by using it on a boolean mask of the condition, because `False`

is also a kind of zero.

```
>>> x = numpy.array([1,0,2,0,3,0,4,5,6,7,8])
>>> x==0
array([False, True, False, True, False, True, False, False, False, False, False], dtype=bool)
>>> numpy.nonzero(x==0)[0]
array([1, 3, 5])
```

It’s doing exactly the same as `mtrw`

‘s way, but it is more related to the question ðŸ˜‰

```
import numpy as np
x = np.array([1,0,2,3,6])
non_zero_arr = np.extract(x>0,x)
min_index = np.amin(non_zero_arr)
min_value = np.argmin(non_zero_arr)
```

There is `np.argwhere`

,

```
import numpy as np
arr = np.array([[1,2,3], [0, 1, 0], [7, 0, 2]])
np.argwhere(arr == 0)
```

which returns all found indices as rows:

```
array([[1, 0], # Indices of the first zero
[1, 2], # Indices of the second zero
[2, 1]], # Indices of the third zero
dtype=int64)
```

I would do it the following way:

```
>>> x = np.array([[1,0,0], [0,2,0], [1,1,0]])
>>> x
array([[1, 0, 0],
[0, 2, 0],
[1, 1, 0]])
>>> np.nonzero(x)
(array([0, 1, 2, 2]), array([0, 1, 0, 1]))
# if you want it in coordinates
>>> x[np.nonzero(x)]
array([1, 2, 1, 1])
>>> np.transpose(np.nonzero(x))
array([[0, 0],
[1, 1],
[2, 0],
[2, 1])
```

You can use numpy.nonzero to find zero.

```
>>> import numpy as np
>>> x = np.array([1,0,2,0,3,0,0,4,0,5,0,6]).reshape(4, 3)
>>> np.nonzero(x==0) # this is what you want
(array([0, 1, 1, 2, 2, 3]), array([1, 0, 2, 0, 2, 1]))
>>> np.nonzero(x)
(array([0, 0, 1, 2, 3, 3]), array([0, 2, 1, 1, 0, 2]))
```

```
import numpy as np
arr = np.arange(10000)
arr[8000:8900] = 0
%timeit np.where(arr == 0)[0]
%timeit np.argwhere(arr == 0)
%timeit np.nonzero(arr==0)[0]
%timeit np.flatnonzero(arr==0)
%timeit np.amin(np.extract(arr != 0, arr))
```

```
23.4 Âµs Â± 1.5 Âµs per loop (mean Â± std. dev. of 7 runs, 10000 loops each)
34.5 Âµs Â± 680 ns per loop (mean Â± std. dev. of 7 runs, 10000 loops each)
23.2 Âµs Â± 447 ns per loop (mean Â± std. dev. of 7 runs, 10000 loops each)
27 Âµs Â± 506 ns per loop (mean Â± std. dev. of 7 runs, 10000 loops each)
109 Âµs Â± 669 ns per loop (mean Â± std. dev. of 7 runs, 10000 loops each)
```