Is there a NumPy function to return the first index of something in an array?

Dig deeper with numpy.where

Finding the true first occurrence

np.argmax keeps things simple, but if you're dealing with multiple occurrences and need the first one genuinely, you can employ numpy.where. Here's how to squeeze that first index out of it:

first_index = np.where(array == element)[0][0] if (array == element).any() else None


If your desired element doesn't exist in the array, you'll get None instead of a IndexError.

Numpy ndenumerate for the win

If you're working with bigger arrays, consider using np.ndenumerate. It's like enumerate on steroids, supercharged with NumPy's array-indexing capabilities:

first_index = next((i for i, x in np.ndenumerate(array) if x == element), None)


The next function here grabs the first item from the generator expression, i.e., the index where the element matches your target.

Handling multidimensional arrays like a pro

In multidimensional arrays, finding the first occurrence can be a bit trickier. You can use np.argwhere to get all indices, then pick the first tuple like so:

first_tuple = np.argwhere(array == element)[0] if (array == element).any() else None


Mind you, first_tuple is going to be a tuple of indices illustrating the position across dimensions of the array.

Watch out for the pitfalls

Dealing with np.argmax zero-indecisiveness

An important point to note is that np.argmax returns a 0 if it can't find the element. This can be confusing if 0 is a valid index. To overcome this, you can use a safety net:

index = np.argmax(array == element) if (array == element).any() else -1


Here, if the element doesn't exist in the array, index is -1 — making it clear as an unmuddied lake that the index is not found.

Taming the StopIteration beast

Without a default, next can raise an unnecessary StopIteration exception if no element in the array matches your search. Always provide a default:

first_index = next((i for i, x in np.ndenumerate(array) if x == element), -1)


The -1 here indicates that the element was not found, exterminating possible confusion.

Power-ups for performance

Turbocharge with numba

For heavy-duty computations on large arrays where index finding becomes a frequent task, consider numba, a just-in-time compiler optimizing Python and NumPy code:

from numba import njit

@njit
def find_first_index(array, element):
    return np.argmax(array == element)


This decorator can make the execution of your search function faster than a cheetah on a caffeine rush.

Beware the list conversion trap

Turning a NumPy array into a list to use list.index() might seem like a good idea, but it's a siren song. NumPy's built-in functions are optimized for working with arrays, so stick with them to keep your performance shipshape.

Practical implementations

Crunch data like a pro

In data science, finding the first occurrence of a value is often vital — think identifying the first purchase date in your sales data timeline or the first bad rating in a customer review dataset.

Ace machine learning tasks

In machine learning, you could need to pinpoint the first instance of a classified event — like the initial detection of a unique pattern or signal in a large dataset.

Tap into image processing potential

With image processing, a similar methodology applies when you need to find the first occurrence of a pixel pattern or specific color tone in an image array.