如何用切片列表索引维度更多的NumPy数组？

Great question! The core issue here is that when you pass a list of slices directly as an index in NumPy, it treats the entire list as an index for a single dimension rather than distributing each slice across separate dimensions. This is why you get an IndexError when your array has more dimensions than your slice list.

The Simple Fix: Tuples + Ellipsis (...) #

NumPy accepts tuples as index objects, where each element in the tuple maps to a single dimension of the array. By converting your slice list to a tuple and combining it with NumPy's ... (ellipsis), you can automatically fill in the remaining dimensions with slice(None) (the equivalent of :) without manual calculation.

Here's how it works with your example:

import numpy as np

# Setup your arrays and slice list
arr = np.arange(25).reshape(5, 5)
slice_list = list(map(lambda i: slice(i, i+2), [1, 2]))  # [slice(1, 3), slice(2, 4)]
arr3d = arr[np.newaxis, :, :]  # Shape: (1, 5, 5)

Example 1: Slice List in Middle Dimensions

To replicate arr3d[:, slice_list[0], slice_list[1]], convert the slice list to a tuple and prepend a slice(None) (or use ... if it's simpler):

# Option 1: Explicitly add slice(None) for the first dimension
result = arr3d[(slice(None), *slice_list)]

# Option 2: Use ... to auto-fill leading dimensions (same result here)
result = arr3d[(..., *slice_list)]

print(result)
# Output:
# [[[ 7  8]
#   [12 13]]]

Example 2: Slice List at the Start

If you have a higher-dimensional array and want to apply the slice list to the first few dimensions:

arr4d = arr[np.newaxis, np.newaxis, :, :]  # Shape: (1, 1, 5, 5)
result = arr4d[(*slice_list, ...)]
print(result.shape)  # (1, 1, 2, 2)

Example 3: Slice List with Trailing Dimensions

To apply the slice list and keep trailing dimensions intact:

arr3d_trans = arr3d.transpose(1, 2, 0)  # Shape: (5, 5, 1)
result = arr3d_trans[(*slice_list, ...)]
print(result)
# Output:
# [[[ 7]
#   [12]]
#  [[ 8]
#   [13]]]

Helper Function for Even More Flexibility #

If you want to avoid remembering tuple syntax every time, you can wrap this logic into a helper function that handles different positions (start, middle, end) for your slice list:

def index_with_slices(arr, slice_list, position='end'):
    """
    Flexible indexing with a list of slices, no manual slice(None) required.
    
    Args:
        arr: NumPy array to index
        slice_list: List of slice objects to apply across dimensions
        position: Where to place the slice list relative to other dimensions
                  Options: 'start', 'middle', 'end'
    """
    slice_tuple = tuple(slice_list)
    dim_count = arr.ndim
    slice_count = len(slice_tuple)
    
    if position == 'start':
        idx = (*slice_tuple, ...)
    elif position == 'end':
        idx = (..., *slice_tuple)
    elif position == 'middle':
        if dim_count < slice_count + 2:
            raise ValueError("Not enough dimensions to place slice list in the middle")
        # Split remaining dimensions evenly before and after the slice list
        pre_count = (dim_count - slice_count) // 2
        idx = (slice(None),)*pre_count + slice_tuple + (...)
    else:
        raise ValueError("Position must be 'start', 'middle', or 'end'")
    
    return arr[idx]

Usage Examples:

# Slice list at the end of a 3D array
print(index_with_slices(arr3d, slice_list, 'end'))

# Slice list in the middle of a 4D array
result = index_with_slices(arr4d, slice_list, 'middle')
print(result.shape)  # (1, 2, 2, 1)

Why This Works #

• Tuples vs Lists: NumPy interprets lists as index arrays (for integer/boolean indexing) rather than multi-dimension slice collections. Tuples, however, are treated as dimension-wise index specifications.
• Ellipsis (...): This special index automatically expands to enough slice(None) values to match the array's remaining dimensions, eliminating the need to calculate how many : you need to add manually.

内容的提问来源于stack exchange，提问作者tenhjo