# Where in 2D¶

This follows from where and argmin.

That page covers how `np.where`

and `np.argmin`

work for one-dimensional
arrays.

This page covers what happens for `np.where`

with arrays of two dimensions and
more.

## Arrays can have two dimensions¶

```
import numpy as np
```

So far we have only seen one-dimensional arrays.

A *vector* is another term for a one-dimensional array.

Here’s a one-dimensional array (vector):

```
arr_one_d = np.array([2, 99, -1, 4, 99])
arr_one_d
```

```
array([ 2, 99, -1, 4, 99])
```

Notice the `shape`

of the array:

```
arr_one_d.shape
```

```
(5,)
```

You can also think of this one-dimensional array as a single *row*.

In fact you can have arrays with more than one row, like this:

```
arr_two_d = np.array([[1, 2, 3, -2, -3], [10, 11, 12, -3, -13]])
arr_two_d
```

```
array([[ 1, 2, 3, -2, -3],
[ 10, 11, 12, -3, -13]])
```

Notice the `shape`

. This array has 2 rows, each with 5 columns.

```
arr_two_d.shape
```

```
(2, 5)
```

Remember, we can ask for a single element from a one-dimensional array, using *indexing* with an integer between square brackets. The integer gives the *position* (or offset) of the element we want.

```
arr_one_d[1]
```

```
99
```

With a two-dimensional array, we need to specify the row *and* column of the element we want:

```
arr_two_d[1, 4]
```

```
-13
```

The first value between the brackets is the row position, and the second is the column position.

## Revision - using where on one-dimensional arrays¶

`np.where`

gets the indices of the True values in a Boolean array.

```
# A Boolean array.
equal_to_99 = arr_one_d == 99
equal_to_99
```

```
array([False, True, False, False, True])
```

```
# Indices of the True values.
indices = np.where(equal_to_99)
indices
```

```
(array([1, 4]),)
```

We can use the returned `indices`

to index into the array, using square brackets.

```
arr_one_d[indices]
```

```
array([99, 99])
```

## The two-dimensional case¶

This also works in two or more dimensions.

`np.where`

now returns two index arrays, one for the rows, and one for the
columns.

```
indices2d = np.where(arr_two_d == -3)
indices2d
```

```
(array([0, 1]), array([4, 3]))
```

Just as for the one-dimensional case, we can use the returned indices to index into the array, and get the elements.

```
arr_two_d[indices2d]
```

```
array([-3, -3])
```