Skip to main content

Python NumPy: How to Fix "IndexError: too many indices for array"

The IndexError: too many indices for array is a common error in NumPy that arises when you attempt to access elements of an ndarray using more indices than the array actually has dimensions. For example, trying to use 2D-style indexing (like arr[row, col]) on a 1D array, or 3D-style indexing on a 2D array, will trigger this error. NumPy needs the number of indices provided to match the array's dimensionality (ndim).

This guide will clearly explain why this IndexError occurs due to a mismatch between the number of indices used and the array's actual dimensions. We'll demonstrate common scenarios that lead to this error, particularly when working with 1D arrays as if they were 2D, or when creating arrays from ragged lists, and provide robust solutions by ensuring correct indexing syntax for the array's true dimensions or by properly defining multi-dimensional arrays.

Understanding the Error: Array Dimensions vs. Number of Indices​

NumPy arrays have a specific number of dimensions (axes), accessible via the array.ndim attribute.

  • A 1D array (vector) has ndim=1 and is accessed with a single index or slice (e.g., arr[i], arr[start:stop]).
  • A 2D array (matrix) has ndim=2 and is accessed with two indices or slices (e.g., arr[row, col], arr[row_slice, col_slice]).
  • An N-D array has ndim=N and requires N indices/slices for full element specification.

The error "IndexError: too many indices for array: array is X-dimensional, but Y were indexed" means you provided Y indices (or slice objects separated by commas, implying Y dimensions of access) to an array that only has X dimensions, where Y > X.

Reproducing the Error: Using Too Many Indices for a 1D Array​

This is the most common scenario. You have a 1D array but try to index it as if it were 2D.

import numpy as np

# Create a 1D NumPy array
array_1d = np.array([10, 20, 30, 40, 50])
print(f"array_1d: {array_1d}")
print(f"Shape of array_1d: {array_1d.shape}")
print(f"Number of dimensions (ndim) for array_1d: {array_1d.ndim}")

try:
    # ⛔️ Incorrect: Attempting to use 2D indexing (row, column) on a 1D array.
    # The slice arr[:, 0] implies "all rows, first column".
    # A 1D array only has one dimension to index.
    element_error = array_1d[:, 0]
    print(element_error)
except IndexError as e:
    print(f"Error: {e}")

Output:

array_1d: [10 20 30 40 50]
Shape of array_1d: (5,)
Number of dimensions (ndim) for array_1d: 1
Error: too many indices for array: array is 1-dimensional, but 2 were indexed
note

The [:, 0] syntax is asking for "all elements along the first axis (rows)" and "the element at index 0 along the second axis (columns)". Since array_1d only has one axis, providing two indexers is too many.

Solution 1: Use Correct Indexing for 1D Arrays (Single Index or Slice)​

If your array is indeed 1D, you must use indexing appropriate for 1D arrays:

  • A single integer to get an element: array_1d[i]
  • A slice to get a sub-array: array_1d[start:stop:step]
  • A list or array of integers (fancy indexing) to get multiple specific elements: array_1d[[idx1, idx2]]
import numpy as np

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

# ✅ Correct indexing for a 1D array:
# Get a single element
element_at_index_1 = array_1d[1]
print(f"Element at index 1: {element_at_index_1}")

# Get a slice
slice_of_array = array_1d[1:4] # Elements from index 1 up to (not including) 4
print(f"Slice array_1d[1:4]: {slice_of_array}")

# Get specific elements using fancy indexing
fancy_indexed_elements = array_1d[[0, 3, 4]]
print(f"Elements at indices [0, 3, 4]: {fancy_indexed_elements}")

Output:

Element at index 1: 20
Slice array_1d[1:4]: [20 30 40]
Elements at indices [0, 3, 4]: [10 40 50]

Solution 2: Ensure You Have a Multi-dimensional Array if Using Multi-dimensional Indexing​

If your indexing syntax (like arr[i, j] or arr[:, j]) is intentional because you expect a 2D (or higher) array, then the problem might be in how the array was created—it might have ended up as 1D unintentionally.

Correctly Defining a 2D Array​

A 2D array is typically created from a list of lists (where inner lists are rows).

import numpy as np

# ✅ Correctly define a 2D array (e.g., 3 rows, 2 columns)
array_2d_correct = np.array([
    [11, 12],
    [21, 22],
    [31, 32]
])
print("Correctly defined 2D array:")
print(array_2d_correct)
print(f"Shape: {array_2d_correct.shape}")
print(f"ndim: {array_2d_correct.ndim}")

Output:

Correctly defined 2D array:
[[11 12]
 [21 22]
 [31 32]]
Shape: (3, 2)
ndim: 2

Correctly Indexing a 2D Array​

Once you have a 2D array, you can use two indices (or slices).

import numpy as np

# array_2d_correct defined as above
array_2d_correct = np.array([
    [11, 12],
    [21, 22],
    [31, 32]
])

# ✅ Get the first column (all rows, column at index 0)
first_column_2d = array_2d_correct[:, 0]
print(f"First column of 2D array: {first_column_2d}")

# ✅ Get the element at row 1, column 1
element_1_1 = array_2d_correct[1, 1] # Or array_2d_correct[1][1]
print(f"Element at [1, 1]: {element_1_1}")

# ✅ Get a slice: rows 0-1, column 1
slice_2d = array_2d_correct[0:2, 1]
print(f"Slice array_2d_correct[0:2, 1]: {slice_2d}")

Output:

First column of 2D array: [11 21 31]
Element at [1, 1]: 22
Slice array_2d_correct[0:2, 1]: [12 22]

Common Pitfall: Creating a 1D Array of Lists (Ragged Array) by Mistake​

If you try to create a NumPy array from a list of lists where the inner lists have different lengths, NumPy will not create a true 2D array. Instead, it will create a 1D array where each element is a Python list object (i.e., dtype=object). Attempting 2D indexing on such an array will lead to the "too many indices" error because the outer array is 1D.

How Ragged Lists Lead to 1D Arrays of Objects​

import numpy as np

# List of lists with inconsistent inner lengths (a "ragged" list)
ragged_list_of_lists = [
    [1, 2, 3],      # Length 3
    [4, 5],         # Length 2
    [6, 7, 8, 9]    # Length 4
]

# This creates a 1D array of Python list objects
array_from_ragged = np.array(ragged_list_of_lists, dtype=object) # dtype=object is often inferred
print("Array created from ragged list:")
print(array_from_ragged)

print(f"Shape of array_from_ragged: {array_from_ragged.shape}")
print(f"ndim of array_from_ragged: {array_from_ragged.ndim}")
print(f"dtype of array_from_ragged: {array_from_ragged.dtype}")

try:
    # ⛔️ Incorrect: array_from_ragged is 1D, can not use 2D indexing
    value_error = array_from_ragged[:, 0]
    print(value_error)
except IndexError as e:
    print(f"Error indexing array_from_ragged: {e}")

Output:

Array created from ragged list:
[list([1, 2, 3]) list([4, 5]) list([6, 7, 8, 9])]
Shape of array_from_ragged: (3,)
ndim of array_from_ragged: 1
dtype of array_from_ragged: object
Error indexing array_from_ragged: too many indices for array: array is 1-dimensional, but 2 were indexed

Solution: Ensure Inner Lists Have Consistent Lengths for True 2D Array​

To create a true 2D NumPy array from a list of lists, all inner lists must have the same length. You might need to pad shorter lists with a fill value (like np.nan or 0) or reconsider your data structure. If they must remain ragged, you'll have to iterate and process each inner list individually.

import numpy as np

# To make it a true 2D array, inner lists must have same length.
# Example: If you wanted to pad to make it 2D (this is a data transformation decision)
list_padded = [
    [1, 2, 3, np.nan],
    [4, 5, np.nan, np.nan],
    [6, 7, 8, 9]
]
true_2d_from_padded = np.array(list_padded)
print(true_2d_from_padded.shape) # (3,4)
print(true_2d_from_padded[:, 0]) # Would work

Output:

(3, 4)
[1. 4. 6.]

Debugging Tip: Check Array Shape and ndim​

When you encounter this IndexError, the very first step is to inspect the array you are trying to index:

import numpy as np

# your_array = ... the array causing the error
your_array = np.array([10, 20, 30, 40, 50])

print(f"Shape of your_array: {your_array.shape}")
print(f"Number of dimensions (ndim) for your_array: {your_array.ndim}")
print(f"Data type (dtype) of your_array: {your_array.dtype}") # Useful for ragged array case
print(f"Content of your_array: {your_array}")

Output:

Shape of your_array: (5,)
Number of dimensions (ndim) for your_array: 1
Data type (dtype) of your_array: int32
Content of your_array: [10 20 30 40 50]
note

This information will immediately tell you if the array has the dimensions you expect and if your indexing approach is appropriate for those dimensions.

Conclusion​

The NumPy IndexError: too many indices for array is a clear signal that the number of indices (or slices separated by commas) you've used in an indexing operation exceeds the actual number of dimensions (ndim) of the target array. To resolve this:

  1. Verify array.ndim and array.shape: Understand the true dimensionality of your array.
  2. For 1D Arrays: Use a single integer index (arr[i]), a single slice (arr[start:stop]), or a 1D list/array of indices for fancy indexing. Do not use comma-separated indices like arr[:, i].
  3. For Multi-dimensional Arrays: Ensure your array is truly multi-dimensional (e.g., created from a non-ragged list of lists). Then, use the correct number of indices or slices corresponding to its ndim.
  4. Beware of Ragged Inputs: Creating an array from a list of lists with varying lengths will result in a 1D array of object dtype, which can not be indexed like a true 2D array.

By ensuring your indexing syntax matches your array's dimensionality, you can avoid this common error.

Table of Contents