Skip to main content

Python NumPy: How to Fix "IndexError: boolean index did not match indexed array along dimension 0"

Boolean indexing (or masking) is a powerful feature in NumPy that allows you to select elements from an array based on a corresponding boolean array (the mask). A common error encountered with this technique is IndexError: boolean index did not match indexed array along dimension 0; dimension is X but corresponding boolean dimension is Y. This error explicitly states that the length of your boolean mask (Y) does not match the length of the array axis you are trying to index (X). NumPy requires these lengths to be identical for unambiguous element selection.

This guide will clearly explain why this IndexError occurs due to mismatched lengths, demonstrate common scenarios that trigger it, and provide robust solutions, focusing on ensuring your boolean mask has the correct length, or adjusting the array being indexed if appropriate.

Understanding the Error: Boolean Mask Length Requirement​

When you use a boolean array (the "mask") to index another NumPy array, like data_array[boolean_mask], NumPy expects the boolean_mask to have the same number of elements as the length of the axis of data_array being indexed.

  • For a 1D data_array, len(boolean_mask) must equal len(data_array).
  • For an N-D data_array, if boolean_mask is 1D, it's typically applied along the first axis (rows), so len(boolean_mask) must equal data_array.shape[0].

The boolean_mask acts as a filter:

  • If boolean_mask[i] is True, the element data_array[i] (or row data_array[i, :] for 2D) is selected.
  • If boolean_mask[i] is False, the element/row is excluded.

If the lengths don't match, NumPy can not perform this one-to-one correspondence for selection, hence the IndexError. The message "dimension is X but corresponding boolean dimension is Y" tells you the length of the data array's axis (X) and the length of your boolean mask (Y).

Reproducing the Error: Mismatched Array and Boolean Mask Lengths​

import numpy as np

data_to_filter = np.array([10, 20, 30, 40, 50]) # Length 5
print(f"Data array: {data_to_filter}, Length: {len(data_to_filter)}")

# Boolean mask with a different length
incorrect_boolean_mask = np.array([True, False, True]) # Length 3
print(f"Incorrect boolean mask: {incorrect_boolean_mask}, Length: {len(incorrect_boolean_mask)}")

try:
    # ⛔️ Incorrect: Length of data_to_filter (5) does not match length of incorrect_boolean_mask (3)
    filtered_data_error = data_to_filter[incorrect_boolean_mask]
    print(filtered_data_error)
except IndexError as e:
    print(f"Error: {e}")

Output:

Data array: [10 20 30 40 50], Length: 5
Incorrect boolean mask: [ True False  True], Length: 3
Error: boolean index did not match indexed array along axis 0; size of axis is 5 but size of corresponding boolean axis is 3

Solution 1: Ensure Boolean Mask Has the Same Length as the Indexed Array Axis (Most Common Fix)​

The primary solution is to ensure your boolean mask has the correct number of elements.

Verifying Array Lengths with len() or .shape​

Before indexing, you can check the lengths:

import numpy as np

data_array_check = np.array([5, 10, 15, 20])
mask_array_check = np.array([True, False, True]) # Intentionally shorter

print(f"Length of data_array_check: {len(data_array_check)}") # Or data_array_check.shape[0]
print(f"Length of mask_array_check: {len(mask_array_check)}")

Output:

Length of data_array_check: 4
Length of mask_array_check: 3

Correcting the Boolean Mask​

You need to adjust how your boolean mask is generated or defined so it has the same length as the axis you are indexing.

import numpy as np

data_to_filter = np.array([10, 20, 30, 40, 50]) # Length 5

# ✅ Correct: Boolean mask has the same length (5) as data_to_filter
correct_boolean_mask = np.array([True, False, True, False, True])
print(f"Correct boolean mask: {correct_boolean_mask}, Length: {len(correct_boolean_mask)}")

# Now boolean indexing works
filtered_data_correct = data_to_filter[correct_boolean_mask]
print(f"Filtered data with correct mask: {filtered_data_correct}")

Output:

Correct boolean mask: [ True False  True False  True], Length: 5
Filtered data with correct mask: [10 30 50]

Often, the boolean mask is derived from the data array itself (see Section 5), which naturally ensures matching lengths.

Solution 2: Slice the Data Array to Match a Shorter Boolean Mask (If Appropriate)​

If your boolean mask is intentionally shorter and is meant to apply to only a portion of the data array, you must first slice the data array to match the mask's length. This implies you are only interested in filtering a sub-section of your data.

import numpy as np

full_data_array = np.array([100, 200, 300, 400, 500, 600])  # Length 6
short_boolean_mask = np.array([True, False, True, False])   # Length 4

# ✅ Slice full_data_array to match the length of short_boolean_mask
# For example, take the first 4 elements of full_data_array
data_subset_to_filter = full_data_array[:len(short_boolean_mask)]
# Or: data_subset_to_filter = full_data_array[:4]
print(f"Data subset to filter: {data_subset_to_filter}\n")

# Now apply the short_boolean_mask to the equally short data_subset_to_filter
filtered_subset = data_subset_to_filter[short_boolean_mask]
print(f"Filtered subset using short mask: {filtered_subset}\n")

# Or, if the mask applies to a different part of the array:
# e.g., middle 4 elements: 
data_subset_middle = full_data_array[1:5]
if len(data_subset_middle) == len(short_boolean_mask):
    filtered_middle_subset = data_subset_middle[short_boolean_mask]
    print(filtered_middle_subset)

Output:

Data subset to filter: [100 200 300 400]

Filtered subset using short mask: [100 300]

[200 400]
note

This approach is valid only if your logic dictates applying a shorter mask to a specific, correspondingly sized slice of the larger data array.

Common Practice: Conditionally Creating the Boolean Array​

In most practical scenarios, the boolean mask is not manually created but is generated from a condition applied to the data array itself (or another array of the same length). This inherently produces a boolean mask of the correct length.

Using Vectorized Operations​

NumPy's vectorized operations are the standard way to create boolean masks.

import numpy as np

data_values = np.array([5, 12, 8, 25, 10, 3])

# Create a boolean mask where values are greater than 10
# This operation is element-wise, so boolean_mask_gt10 will have the same length as data_values.
boolean_mask_gt10 = (data_values > 10)
print(f"Data values: {data_values}")                        # [ 5 12  8 25 10  3]
print(f"Boolean mask (values > 10): {boolean_mask_gt10}\n") # [False  True False  True False False]

# Apply the mask
filtered_gt10 = data_values[boolean_mask_gt10]
print(f"Values greater than 10: {filtered_gt10}\n")         # [12 25]

# Example with modulo operator
numbers = np.array([1, 2, 3, 4, 5, 6])
is_even_mask = (numbers % 2 == 0)
print(f"Numbers: {numbers}")                                # [1 2 3 4 5 6]
print(f"Is_even mask: {is_even_mask}")                      # [False True False True False True]
print(f"Even numbers: {numbers[is_even_mask]}")             # [2 4 6]

Output:

Data values: [ 5 12  8 25 10  3]
Boolean mask (values > 10): [False  True False  True False False]

Values greater than 10: [12 25]

Numbers: [1 2 3 4 5 6]
Is_even mask: [False  True False  True False  True]
Even numbers: [2 4 6]

Using List Comprehensions (Results in a Python List, Needs Conversion for NumPy array)​

While possible, if your data is already a NumPy array, vectorized operations are preferred over list comprehensions for creating masks for performance reasons. If you do use a list comprehension, you might need to convert it back to a NumPy boolean array.

import numpy as np

data_values_lc = np.array([5, 12, 8, 25, 10, 3])

# List comprehension to create a boolean list
boolean_list_lc = [val > 10 for val in data_values_lc]
print(f"Boolean list from list comprehension: {boolean_list_lc}\n")            # [False, True, False, True, False, False]

# Convert Python boolean list to NumPy boolean array for indexing
boolean_mask_from_lc = np.array(boolean_list_lc)

filtered_lc = data_values_lc[boolean_mask_from_lc]
print(f"Values greater than 10 (via list comprehension mask): {filtered_lc}")  # [12 25]

Output:

Boolean list from list comprehension: [np.False_, np.True_, np.False_, np.True_, np.False_, np.False_]

Values greater than 10 (via list comprehension mask): [12 25]

Conclusion​

The NumPy IndexError: boolean index did not match indexed array along dimension 0... is a direct consequence of attempting to use a boolean mask whose length (number of boolean values) does not precisely match the length of the array axis it's intended to filter.

  1. Always ensure length consistency: The number of elements in your boolean array must equal the number of elements along the axis of the array you are indexing. Use len() or .shape to verify.
  2. Prefer conditional generation: The most common and robust way to create boolean masks is by applying vectorized conditions directly to your NumPy array (e.g., mask = (my_array > threshold)). This automatically ensures the mask has the correct length.
  3. Slice data array if mask is shorter: If you have a shorter boolean mask intended for a specific part of a larger array, slice the larger array first to match the mask's length before applying the mask.

By adhering to these principles, you can reliably use boolean indexing in NumPy without encountering this length mismatch error.

Table of Contents