Indexing numpy multidimensional arrays depends on a slicing method

Question

I have a 3-D array. When I take a 2-D slice of it the result depends on whether it is indexed with a list or with a slice. In the first case the result is transposed. Didn't find this behaviour in the manual.

>>> import numpy as np
>>> x = np.array([[[1,1,1],[2,2,2]], [[3,3,3],[4,4,4]]])
>>> x
array([[[1, 1, 1],
        [2, 2, 2]],
       [[3, 3, 3],
        [4, 4, 4]]])
>>> x[0,:,[0,1]]
array([[1, 2],
       [1, 2]])
>>> x[0,:,slice(2)]
array([[1, 1],
       [2, 2]])
>>>

Could anyone point a rationale for this?

Oddly enough `a[0][:, [0, 1]]` gives the same result as using slice(). — P. Camilleri, Apr 24 '17 at 10:08
Thank you, P. Camilleri. The 2-D arrays acts completely predictable. The problem is the three and probably more dimensions. — Evgeny P. Kurbatov, Apr 24 '17 at 10:16
http://stackoverflow.com/questions/27297445/combining-slicing-and-broadcasted-indexing-for-multi-dimensional-numpy-arrays - an earlier attempt to explain mixed indexing. The topic has come up before, but the trick is to find a good search term. — hpaulj, Apr 24 '17 at 16:42

juanpa.arrivillaga · Answer 1 · 2017-04-24T16:46:54.687

Because you are actually using advanced indexing when you use [0,1]. From the docs:

Combining advanced and basic indexing
When there is at least one slice (:), ellipsis (...) or np.newaxis in the index (or the array has more dimensions than there are advanced indexes), then the behaviour can be more complicated. It is like concatenating the indexing result for each advanced index element
In the simplest case, there is only a single advanced index. A single advanced index can for example replace a slice and the result array will be the same, however, it is a copy and may have a different memory layout. A slice is preferable when it is possible.

Pay attention to the two parts I've bolded above.

In particular, in this construction:

>>> x[0,:,[0,1]]
array([[1, 2],
       [1, 2]])

Is the case where there is at least once "slice, ellipsisi, or np.newaxis" in the index, and the behavior is like concatenating the indexing result for each advanced index element. So:

>>> x[0,:,[0]]
array([[1, 2]])
>>> x[0,:,[1]]
array([[1, 2]])
>>> np.concatenate((x[0,:,[0]], x[0,:,[1]]))
array([[1, 2],
       [1, 2]])

However, this construction is like the simple case: there is only a single advanced index, so it acts like a slice:

>>> x[0,:,slice(2)]
array([[1, 1],
       [2, 2]])
>>> x[slice(0,1),:,slice(2)]
array([[[1, 1],
        [2, 2]]])

Although note, that the later is actually three dimensional because the first part of the index acted as a slice, it's 3 slices so three dimensions.

It seems like your answer is missing its last part, was there something supposed to follow "Similarly," ? — P. Camilleri, Apr 24 '17 at 11:23
Thank you, juanpa.arrivillaga. Numpy should be styled more functional, in the meaning of optimization. — Evgeny P. Kurbatov, Apr 24 '17 at 12:17
In http://stackoverflow.com/questions/36207850/numpy-sub-array-assignment-with-advanced-mixed-indexing I found links to bug/issues for the case of `[scalar, slice, list]` indexing. For more SO discussions, search on '[numpy] advanced-and-basic-indexing'. — hpaulj, Apr 24 '17 at 16:49

kmario23 · Accepted Answer · 2017-04-24T12:33:42.853

As I understand it, NumPy is following the axis numbering philosophy when it spits out the result when given a list/tuple-like index.

array([[[1, 1, 1],
        [2, 2, 2]],

       [[3, 3, 3],
        [4, 4, 4]]])

When you already specify the first two indices (x[0, :, ]), now the next question is how to extract the third dimension. Now, when you specify a tuple (0,1), it first extracts the 0th slice axis wise, so it gets [1, 2] since it lies in 0th axis, next it extracts 1st slice likewise and stacks below the already existing row [1, 2].

[[1, 1, 1],          array([[1, 2],
 [2, 2, 2]]  =====>         [1, 2]])

(visualize this stacking as below (not on top of) the already existing row since axis-0 grows downwards)

Alternatively, it is following the slicing philosophy (start:stop:step) when slice(n) is given for the index. Note that using slice(2) is essentially equal to 0:2 in your example. So, it extracts [1, 1] first, then [2, 2]. Note, here to how [1, 1] comes on top of [2, 2], again following the same axis philosophy here since we didn't leave the third dimension yet. This is why this result is the transpose of the other.

array([[1, 1],
       [2, 2]])

Also, note that starting from 3-D arrays this consistency is preserved. Below is an example from 4-D array and the slicing results.

In [327]: xa
Out[327]: 
array([[[[ 0,  1,  2],
         [ 3,  4,  5],
         [ 6,  7,  8]],

        [[ 9, 10, 11],
         [12, 13, 14],
         [15, 16, 17]]],


       [[[18, 19, 20],
         [21, 22, 23],
         [24, 25, 26]],

        [[27, 28, 29],
         [30, 31, 32],
         [33, 34, 35]]]])

In [328]: xa[0, 0, :, [0, 1]]
Out[328]: 
array([[0, 3, 6],
       [1, 4, 7]])

In [329]: xa[0, 0, :, 0:2]
Out[329]: 
array([[0, 1],
       [3, 4],
       [6, 7]])

Indexing numpy multidimensional arrays depends on a slicing method

2 Answers2

Combining advanced and basic indexing

Linked

Related