Using list of lists of indices to slice columns and obtain the row-wise vector length

Here is an answer without a loop – kind of. The basic idea is to replace your lists of indices, my_idxs, with equivalent "boolean masks", my_masks, where contained indices are marked with 1 and others with 0. You can then calculate the norm after weighting with the masks. A solution could thus look as follows:

import numpy as np

my_arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# Replace index lists with boolean masks: [0, 1] → [1, 1, 0], [2] → [0, 0, 1]
my_masks = [[1, 1, 0], [0, 0, 1]]

result = np.linalg.norm(my_arr[:, np.newaxis, :] * my_masks, axis=-1)
print(result)
# >>> [[ 2.23606798  3.        ]
#      [ 6.40312424  6.        ]
#      [10.63014581  9.        ]]

Note that I replaced your values in my_arr with different values for each row, to confirm that the approach actually works as expected. Furthermore, I am quite sure an equivalent solution could be implemented using masked arrays.

In any case, now here is the catch: I did not find an approach that is not using a for loop to convert your lists of indices into my masks. So, in a way, I am just moving the problem. However, depending on how you determine your lists of indices in the first place, using masks in their place might still be a solution to consider.

You're looking to compute the row-wise norms of vectors formed by selecting columns from a NumPy array using varying lengths of index lists. You aim to achieve this efficiently, preferably without using explicit loops over the index sets.

Solution: You can use a list comprehension to address the challenge posed by index sets of varying lengths. While this isn't a single slicing operation (which is impossible due to irregular shapes), it's a concise approach that utilizes the power of NumPy's operations.

Here's how you can implement this:

import numpy as np

# Define your array
my_arr = np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]])

# Define your list of index sets
my_idxs = [[0, 1], [2]]

# Compute the norm for each set of indices using a list comprehension
result = np.array([np.linalg.norm(my_arr[:, idx], axis=1) for idx in my_idxs]).T

# Print the result
print(result)

Output:

 [[2.23606798 3.        ]
 [2.23606798 3.        ]
 [2.23606798 3.        ]]

Explanation:

List Comprehension: Loops through each set of indices in my_idxs. For each set, it selects the corresponding columns from my_arr and calculates the norm across the rows (axis=1).

Transpose (T): The result of the list comprehension is a list where each element is an array representing the norms calculated for each set of indices. np.array(...) converts this list into a 2D NumPy array. The transpose is then applied to align the output correctly so that each row corresponds to the original rows of my_arr, and each column represents the norm results for each index set.

This approach efficiently handles your requirement to compute vector norms from subsets of array columns, even when the subsets vary in length. It maximizes the use of NumPy's capabilities to avoid explicit performance penalties associated with looping through array rows.

Conclusion: Although directly slicing with varying index lengths into a single operation isn't feasible due to the non-uniform dimensions that would result, the solution provided achieves your goal using a compact and efficient line of Python code.