如何在NumPy中基于可变索引边界批量赋值数组元素？

Great question! The core issue here is that NumPy doesn’t natively support variable-length slice indexing with standard vectorized operations—your initial attempt fails because bounds[ind][0]:bounds[ind][1] tries to create slices of different lengths per row, which doesn’t play nice with NumPy’s broadcasting rules.

Luckily, we can work around this by converting the 2D row-column slice ranges into flat linear indices, which NumPy handles seamlessly. Here’s a fully vectorized solution that avoids explicit loops (critical for performance with frequent calls):

import numpy as np

def __assign(arr, bounds, value):
    # Calculate how many elements we need to assign per row
    slice_lengths = bounds[:, 1] - bounds[:, 0]
    
    # Repeat row indices matching the number of elements per row
    row_indices = np.repeat(np.arange(arr.shape[0]), slice_lengths)
    
    # Generate all column indices across all slices, then concatenate into a single array
    col_indices = np.concatenate([np.arange(start, end) for start, end in bounds])
    
    # Convert 2D indices to flat linear indices for the array
    flat_indices = row_indices * arr.shape[1] + col_indices
    
    # Perform the assignment in one go
    arr.flat[flat_indices] = value

How to Test It #

Let’s run your example to verify:

bounds = np.array([[1,2], [1,3], [1,4]])
array = np.zeros((3,4))
__assign(array, bounds, 1)
print(array)

This will output exactly what you’re looking for:

[[0. 1. 0. 0.]
 [0. 1. 1. 0.]
 [0. 1. 1. 1.]]

Why This Works #

• Row indices: We use np.repeat to duplicate each row index exactly as many times as there are elements in its target slice (e.g., row 0 gets repeated once, row 1 twice, etc.).
• Column indices: We generate the range of columns for each row’s slice and concatenate them into a single 1D array—this is the only part that uses a list comprehension, but it’s lightweight and far faster than a full loop over rows.
• Flat indices: By converting the 2D (row, column) pairs into linear indices, we can assign to all target positions in one vectorized operation, which is optimal for NumPy’s performance.

Why Your Initial Approach Failed #

NumPy’s advanced indexing requires that all index arrays have compatible shapes. When you try array[ind, bounds[ind][0]:bounds[ind][1]], you’re trying to index each row with a slice of a different length—this creates a mismatch that NumPy can’t resolve with standard indexing, hence the unexpected behavior or errors.

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