Python NumPy: How to Fix "IndexError: only integers, slices, ellipsis, newaxis, and integer/boolean arrays are valid indices"

NumPy provides a rich set of indexing capabilities far beyond standard Python list indexing. However, this power comes with specific rules about what types of objects can be used as indices. The IndexError: only integers, slices (:), ellipsis (...), numpy.newaxis (None) and integer or boolean arrays are valid indices is a common error that arises when you attempt to index a NumPy array using a value or an array of a data type that NumPy doesn't recognize for positional or advanced indexing, most notably floating-point numbers.

This guide will thoroughly dissect this IndexError, pinpointing why using non-approved indexer types like floats leads to this failure, and equip you with robust solutions, primarily focusing on ensuring your indexers are of the correct integer (or boolean for masking) type, often by using int() conversion or ndarray.astype(int).

Understanding NumPy's Valid Index Types

NumPy's indexing mechanism is very flexible but has strict rules for the types of objects it accepts as indices. The error message itself lists the valid types:

• Integers (Scalars): To select a single element along an axis (e.g., arr[0], arr[5, 2]).
• Slices (:): To select a range of elements (e.g., arr[1:5], arr[:, 0]).
• Ellipsis (...): To represent as many full slices (:) as needed to fill the dimensions.
• numpy.newaxis (or None): To add a new axis of length one.
• Integer Arrays (or lists of integers): For "fancy indexing," selecting specific elements or rows/columns based on a list of their integer positions (e.g., arr[[0, 2, 4]]).
• Boolean Arrays: For "boolean masking," selecting elements where the corresponding value in the boolean array is True (e.g., arr[arr > 10]).

The error occurs when the object you place inside the square brackets arr[...] is not one of these types, most commonly when it's a float or an array of floats.

Reproducing the Error: Using Invalid Index Types

Indexing with a Float Scalar

import numpy as np

my_array = np.array([10, 20, 30, 40, 50])
float_index = 2.0 # A float, even if it represents a whole number

print(f"Array: {my_array}")
print(f"Float index: {float_index}, type: {type(float_index)}")

try:
    # ⛔️ Incorrect: Using a float scalar as an index
    selected_element = my_array[float_index]
    print(selected_element)
except IndexError as e: # Actually a TypeError often, but IndexError is what the title suggests
    print(f"Error (float scalar index): {e}")

Output:

Array: [10 20 30 40 50]
Float index: 2.0, type: <class 'float'>
Error (float scalar index): only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices

note

NumPy can not use 2.0 directly as a positional index; it needs the integer 2.

Indexing with a List or NumPy Array of Floats (Fancy Indexing with Invalid Type)

import numpy as np

# my_array defined as above
my_array = np.array([10, 20, 30, 40, 50])

# List of floats intended as indices
float_indices_list = [0.0, 2.0, 4.0]
# NumPy array of floats intended as indices
float_indices_np_array = np.array([1.0, 3.5, 0.9])

print(f"List of float indices: {float_indices_list}")
print(f"NumPy array of float indices: {float_indices_np_array}, dtype: {float_indices_np_array.dtype}")

try:
    # ⛔️ Incorrect: Using a list of floats for fancy indexing
    selected_from_list = my_array[float_indices_list]
    print(selected_from_list)
except IndexError as e:
    print(f"Error (list of floats index): {e}")

try:
    # ⛔️ Incorrect: Using a NumPy array of floats for fancy indexing
    selected_from_np_array = my_array[float_indices_np_array]
    print(selected_from_np_array)
except IndexError as e:
    print(f"Error (NumPy array of floats index): {e}")

Output:

List of float indices: [0.0, 2.0, 4.0]
NumPy array of float indices: [1.  3.5 0.9], dtype: float64
Error (list of floats index): only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices
Error (NumPy array of floats index): arrays used as indices must be of integer (or boolean) type

Solution 1: Convert Float Scalar Index to Integer using int()

If your index is a single float that represents a whole number, convert it to an integer using Python's built-in int() function.

import numpy as np

my_array = np.array([10, 20, 30, 40, 50])
float_index = 2.0

# ✅ Convert float scalar to int before indexing
integer_index = int(float_index)
selected_element_correct = my_array[integer_index]

print(f"Selected element using int({float_index}): {selected_element_correct}")

Output:

Selected element using int(2.0): 30

note

int() truncates, e.g., int(2.7) becomes 2. If rounding is needed: my_array[int(round(2.7))]

Solution 2: Convert Float Array/List Indexer to Integer Type using astype(int) or List Comprehension

If your indexer is a list or NumPy array of floats, convert all its elements to integers.

• For a NumPy array of floats: Use the .astype(int) method.

  import numpy as np
  
  my_array = np.array([10, 20, 30, 40, 50])
  float_indices_np = np.array([0.1, 2.8, 4.0]) # Floats
  
  # ✅ Convert NumPy array of floats to integer type
  integer_indices_np = float_indices_np.astype(int)
  print(f"Float indices NP: {float_indices_np}")
  print(f"Integer indices NP (after astype(int), truncated): {integer_indices_np}")
  
  selected_elements_astype = my_array[integer_indices_np]
  print(f"Selected elements using astype(int) on indexer: {selected_elements_astype}")

  Output:

  Float indices NP: [0.1 2.8 4. ]
  Integer indices NP (after astype(int), truncated): [0 2 4]
  Selected elements using astype(int) on indexer: [10 30 50]

• For a Python list of floats: Use a list comprehension with int().

  import numpy as np
  
  my_array = np.array([10, 20, 30, 40, 50])
  float_indices_list = [0.9, 1.1, 3.5]
  
  # ✅ Convert list of floats to list of integers
  integer_indices_list = [int(f_idx) for f_idx in float_indices_list]
  print(f"Float indices list: {float_indices_list}")
  print(f"Integer indices list (truncated): {integer_indices_list}")
  
  selected_elements_list_comp = my_array[integer_indices_list]
  print(f"Selected elements using list comprehension for indices: {selected_elements_list_comp}")

  Output:

  Float indices list: [0.9, 1.1, 3.5]
  Integer indices list (truncated): [0, 1, 3]
  Selected elements using list comprehension for indices: [10 20 40]

note

Again, be mindful that int() and astype(int) truncate decimal parts. If rounding to the nearest integer is desired before indexing, incorporate np.round(): rounded_integer_indices = np.round(float_indices_np).astype(int)

Using Floor Division // to Ensure Integer Results for Calculated Indices

If your indices are the result of a division operation, ensure you use floor division // if integer indices are required. Standard division / in Python 3 always produces a float.

import numpy as np

my_array = np.array(['a', 'b', 'c', 'd', 'e', 'f'])
denominator = 2

# Calculated index using standard division (results in float)
index_float_calc = len(my_array) / denominator # e.g., 6 / 2 = 3.0 (float)
print(f"Index from standard division: {index_float_calc} (type: {type(index_float_calc)})")
try:
    print(my_array[index_float_calc])
except IndexError as e: # Actually TypeError, but the error text is what matters
    print(f"Error with float calculated index: {e}")

# ✅ Calculated index using floor division (results in int)
index_int_calc = len(my_array) // denominator # e.g., 6 // 2 = 3 (int)
print(f"Index from floor division: {index_int_calc} (type: {type(index_int_calc)})")
print(f"Element at floor division index: {my_array[index_int_calc]}")

Output:

Index from standard division: 3.0 (type: <class 'float'>)
Error with float calculated index: only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices
Index from floor division: 3 (type: <class 'int'>)
Element at floor division index: d

Valid Indexing Examples (Recap)

Just to reiterate what NumPy does accept for indexing:

import numpy as np

arr_valid_idx = np.array([[1,2,3],[4,5,6],[7,8,9]])

# Integer scalar
print(f"arr_valid_idx[0]:\n{arr_valid_idx[0]}")             # First row

# Slice
print(f"arr_valid_idx[0:2, 1:]:\n{arr_valid_idx[0:2, 1:]}") # Rows 0-1, Columns 1-end

# Ellipsis
print(f"arr_valid_idx[..., 0]:\n{arr_valid_idx[..., 0]}")   # First column

# numpy.newaxis
print(f"arr_valid_idx[np.newaxis, :, :].shape: {arr_valid_idx[np.newaxis, :, :].shape}") # Adds new leading axis

# Integer array (fancy indexing)
print(f"arr_valid_idx[[0,2]]:\n{arr_valid_idx[[0,2]]}")     # Rows 0 and 2

# Boolean array (masking)
mask = np.array([True, False, True])
print(f"arr_valid_idx[mask]:\n{arr_valid_idx[mask]}")       # Rows where mask is True

Output:

arr_valid_idx[0]:
[1 2 3]
arr_valid_idx[0:2, 1:]:
[[2 3]
 [5 6]]
arr_valid_idx[..., 0]:
[1 4 7]
arr_valid_idx[np.newaxis, :, :].shape: (1, 3, 3)
arr_valid_idx[[0,2]]:
[[1 2 3]
 [7 8 9]]
arr_valid_idx[mask]:
[[1 2 3]
 [7 8 9]]

Debugging Tip: Check the dtype of Your Indexer

When this IndexError occurs, immediately inspect the data type of the variable you are using as an index:

# problematic_indexer = ... your variable causing the error
print(type(problematic_indexer))
if isinstance(problematic_indexer, np.ndarray):
    print(problematic_indexer.dtype)

This will confirm if it's a float, an array of floats, or another non-supported type.

Conclusion

The NumPy IndexError: only integers, slices (:), ellipsis (...), numpy.newaxis (None) and integer or boolean arrays are valid indices is a clear message that the data type of your indexer is incompatible with NumPy's indexing rules. The primary solution is to ensure your indexers are of an integer type (for positional/fancy indexing) or boolean type (for masking).

• For scalar float indices, convert using int(your_float_index).
• For arrays or lists of float indices, convert using your_float_array.astype(int) or a list comprehension [int(x) for x in your_float_list]. Remember that this truncates; use np.round() first if nearest-integer logic is needed.
• When calculating indices through division, use floor division // to guarantee integer results.

By ensuring your indexers conform to NumPy's type expectations, you can perform powerful array selections and manipulations without this error.