Whats the difference between `arr[tuple(seq)]` and `arr[seq]`? Relating to Using a non-tuple sequence for multidimensional indexing is deprecated

问题

I am using an ndarray to slice another ndarray. Normally I use arr[ind_arr]. numpy seems to not like this and raises a FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated use arr[tuple(seq)] instead of arr[seq].

What's the difference between arr[tuple(seq)] and arr[seq]?

Other questions on StackOverflow seem to be running into this error in scipy and pandas and most people suggest the error to be in the particular version of these packages. I am running into the warning running purely in numpy.

Example posts:

FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated use `arr[tuple(seq)]` instead of `arr[seq]`

FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated use `arr[tuple(seq)]`

FutureWarning with distplot in seaborn

MWE reproducing warning:

import numpy as np

# generate a random 2d array
A = np.random.randint(20, size=(7,7))
print(A, '\n')

# define indices
ind_i = np.array([1, 2, 3])  # along i
ind_j = np.array([5, 6])  # along j

# generate index array using meshgrid
ind_ij = np.meshgrid(ind_i, ind_j, indexing='ij')

B = A[ind_ij]
print(B, '\n')

C = A[tuple(ind_ij)]
print(C, '\n')

# note: both produce the same result

回答1:

meshgrid returns a list of arrays:

In [50]: np.meshgrid([1,2,3],[4,5],indexing='ij')                                                      
Out[50]: 
[array([[1, 1],
        [2, 2],
        [3, 3]]), array([[4, 5],
        [4, 5],
        [4, 5]])]
In [51]: np.meshgrid([1,2,3],[4,5],indexing='ij',sparse=True)                                          
Out[51]: 
[array([[1],
        [2],
        [3]]), array([[4, 5]])]

ix_ does the same thing, but returns a tuple:

In [52]: np.ix_([1,2,3],[4,5])                                                                         
Out[52]: 
(array([[1],
        [2],
        [3]]), array([[4, 5]]))

np.ogrid also produces the list.

In [55]: arr = np.arange(24).reshape(4,6)

indexing with the ix tuple:

In [56]: arr[_52]                                                                                      
Out[56]: 
array([[10, 11],
       [16, 17],
       [22, 23]])

indexing with the meshgrid list:

In [57]: arr[_51]                                                                                      
/usr/local/bin/ipython3:1: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.
  #!/usr/bin/python3
Out[57]: 
array([[10, 11],
       [16, 17],
       [22, 23]])

Often the meshgrid result is used with unpacking:

In [62]: I,J = np.meshgrid([1,2,3],[4,5],indexing='ij',sparse=True)                                    
In [63]: arr[I,J]                                                                                      
Out[63]: 
array([[10, 11],
       [16, 17],
       [22, 23]])

Here [I,J] is the same as [(I,J)], making a tuple of the 2 subarrays.

Basically they are trying to remove a loophole that existed for historical reasons. I don't know if they can change the handling of meshgrid results without causing further compatibility issues.

来源：https://stackoverflow.com/questions/56579536/whats-the-difference-between-arrtupleseq-and-arrseq-relating-to-using

标签

numpy

numpy-ndarray