How does numpy.swapaxes work?

Question

I created a sample array:

a = np.arange(18).reshape(9,2)

On printing, I get this as output:

[[ 0  1]
[ 2  3]
[ 4  5]
[ 6  7]
[ 8  9]
[10 11]
[12 13]
[14 15]
[16 17]]

On executing this reshaping:

b = a.reshape(2,3,3).swapaxes(0,2)

I get:

[[[ 0  9]
[ 3 12]
[ 6 15]]

[[ 1 10]
[ 4 13]
[ 7 16]]

[[ 2 11]
[ 5 14]
[ 8 17]]]

I went through this question, but it does not solve my problem.

Reshape an array in NumPy

The documentation is not useful either.

https://docs.scipy.org/doc/numpy/reference/generated/numpy.swapaxes.html

I need to know how the swapping is working(which is x-axis, y-axis, z-axis). A diagrammatic explanation would be most helpful.

Answer 1

Start with the reshape

In [322]: a = np.arange(18).reshape(2,3,3)
In [323]: a
Out[323]: 
array([[[ 0,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8]],

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

This displays as 2 planes, and each plane is a 3x3. Is that part clear? The fact that the array was shaped (9,2) at one point isn't significant. Reshaping doesn't change the order of elements.

Apply the swapaxes. Shape is now (3,3,2). 3 planes, each is 3x2. This particular swap is the same as a transpose

np.arange(18).reshape(2,3,3).transpose(2,1,0)

The middle axis is unchanged. There are still columns of [0,3,6], [9,12,15], etc.

It may be easier to visualize the change with 3 different sized axes

In [335]: a=np.arange(2*3*4).reshape(2,3,4)
In [336]: a
Out[336]: 
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]]])
In [337]: a.swapaxes(0,2)
Out[337]: 
array([[[ 0, 12],
        [ 4, 16],
        [ 8, 20]],

       [[ 1, 13],
        [ 5, 17],
        [ 9, 21]],

       [[ 2, 14],
        [ 6, 18],
        [10, 22]],

       [[ 3, 15],
        [ 7, 19],
        [11, 23]]])

Notice what happens when I flatten the array

In [338]: a.swapaxes(0,2).ravel()
Out[338]: 
array([ 0, 12,  4, 16,  8, 20,  1, 13,  5, 17,  9, 21,  2, 14,  6, 18, 10,
       22,  3, 15,  7, 19, 11, 23])

the order of terms has been shuffled. As created it was [0,1,2,3...]. Now the 1 is the 6th term (2x3).

Under the covers numpy actually performs the swap or transpose by changing shape, strides and order, without changing the data buffer (i.e. it's a view). But further reshaping, including raveling, forces it to make a copy. But that might be more confusing than helpful at this stage.

In numpy axes are numbered. Terms like x,y,z or planes, rows, columns may help you map those on to constructs that you can visualize, but they aren't 'built-in'. Describing the swap or transpose in words is tricky.

Answer 2

Here is my understanding of swapaxes

Suppose you have an array

In [1]: arr = np.arange(16).reshape((2, 2, 4))

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

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])

And the shape of arr is (2, 2, 4), for the value 7, you can get the value by

In [3]: arr[0, 1, 3]
Out[3]: 7

There are 3 axes 0, 1 and 2, now, we swap axis 0 and 2

In [4]: arr_swap = arr.swapaxes(0, 2)

In [5]: arr_swap
Out[5]: 
array([[[ 0,  8],
        [ 4, 12]],

       [[ 1,  9],
        [ 5, 13]],

       [[ 2, 10],
        [ 6, 14]],

       [[ 3, 11],
        [ 7, 15]]])

And as you can guess, the index of 7 is (3, 1, 0), with axis 1 unchanged,

In [6]: arr_swap[3, 1, 0]
Out[6]: 7

So, now from the perspective of the index, swapping axis is just change the index of values. For example

In [7]: arr[0, 0, 1]
Out[7]: 1

In [8]: arr_swap[1, 0, 0]
Out[8]: 1

In [9]: arr[0, 1, 2]
Out[9]: 6

In [9]: arr_swap[2, 1, 0]
Out[9]: 6

So, if you feel difficult to get the swapped-axis array, just change the index, say arr_swap[2, 1, 0] = arr[0, 1, 2].