In this article, we will discuss indexing in the Numpy module and how to access the first index in various ways.

The Numpy package is designed for scientific computing in Python. Numpy provides an array object called “ndarray”. It is much faster and more efficient than traditional Python lists. Numpy arrays are commonly used in data science, where efficiency and resource management is vital.

Contents

## Installing the Module

Numpy is an open-source project. The module is not part of the Python standard library. Therefore, install it manually using PIP.

`pip install numpy`

Note that the above command works for Windows, macOS, and Linux users.

## How To Return The First Index of a Value in Numpy

Using the `numpy.where()`

function, it is possible to return the first index of a value. Here is an example demonstration:

```
indexValue = numpy.where(arrayName == arrayItem)
```

The above command returns a tuple consisting of all the first row and column indices.

## How to Access the First Element of a Numpy Array

Numpy arrays follow traditional Python indexing. It’s possible to access an array element by passing its index position. The first element is technically the 0th element due to 0-based indexing.

```
import numpy as np
myArray = np.array([2,4,6,8,10])
print(myArray[0])
```

### Output

2

## How to Access the First Element of a Numpy Array with N number of Dimensions

The previous heading demonstrates how the first element of a 1D array is grabbed. Let’s see how we can access the first element of N-dimensional arrays using the

method.**.flat**

```
import numpy as np
myArray = np.array([[1, 2, 3], [4, 5, 6]])
firstElement = myArray.flat[0]
print(firstElement)
```

### Output

1

## How To Access the First Index of Each Row in Numpy

With the help of **Python List** indexing, we are able to access the first element of each multi-dimensional array. Let’s refer to the following program, which works with a 3D array.

```
import numpy as np
myArray = np.array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
myArray[:, :, 0]
```

### Output

array([[ 0, 4, 8], [12, 16, 20]])

## Difference Between Numpy Take and Fancy Indexing

Numpy Take | Numpy Fancy Indexing |
---|---|

Numpy `take` fetches elements from a ndarray along its axis. | Numpy fancy indexing means passing an array of multiple indices to gain access to multiple elements simultaneously. |

Numpy `take` is similar to Fancy indexing; however, it’s easier to access elements across an axis using `take` . | Numpy Fancy indexing allows us to gain access to all elements of any index position. |

Numpy `take` is considerably faster compared to Fancy indexing. | Numpy fancy indexing can be slightly slower and error-prone. |

## How To Fetch The First Non Zero Index Value of Each Column in Numpy

Using the `np.argmax()`

function along the axis, we can retrieve the first non-zero indices.

Let’s refer to the following program:

```
import numpy as np
myArray = np.array([[0, 3, 0],
[12, 5, 0],
[0, 3, 56]])
(myArray!=0).argmax(axis=0)
```

By passing axis = 0, the `.argmax`

function is passed along the zeroth axis

### Output

array([1, 0, 1])

## How To Fetch the First Element Bigger Than Existing Value

The `numpy.argmax()`

function will allow us to find the first occurrence of a greater value. np.argmax() will stop at the first `True`

case of its condition. Let’s look at the following example.

```
import numpy as np
values = np.arange(0,10)
np.argmax(values>5)
```

The third line of the program (values>5) denotes the first value greater than 5 must be returned.

### Output

6

## How To Find the Index of First Occurrence

Using the numpy.where() function, we can find the index of the first occurrence of an element.

Here’s the function syntax:

`numpy.where(condition)`

In the following program, we will be locating the first occurrences of the integer 10. Numpy.where will return a tuple of arrays containing the row and column indices.

```
import numpy as np
myArray = [[22,10],
[46,10]]
occurrence10 = np.where(myArray == 10)
print(occurrence10)
```

### Output

(array([0, 1]), array([1, 1]))

## FAQs on Numpy’s first index

**Does NumPy support number indexing?**

Yes. You can access array elements by passing index numbers.

**How do I get the Index position of an array element?**

With the where() function, you can specify the index position of an array element.

**Is NumPy array 0-based index or 1-based index?**

The index values in NumPy arrays begin with the 0th(zeroth) value. Therefore, NumPy follows Python’s 0-based indexing.

## Conclusion

In this article, we’ve discussed Python indexing and how to fetch the first value off of various conditions. We’ve discussed how Numpy provides functions that allow conditioning to retrieve the first index positions of arrays. We have also discussed how fancy indexing varies from `numpy take`

.