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.

Do you understand what transpose does to a 2d array? – hpaulj Feb 18 '17 at 15:22 — hpaulj, Feb 18 '17 at 15:22

score 37 · Answer 1 · answered Mar 29 '18 at 08:04

37

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].

answered Mar 29 '18 at 08:04

GoingMyWay

16,802
32
96
149

3

you're way of thinking is genius. I was just struggling for 4 hrs straight but now i got the whole math. – Vicrobot Jul 15 '19 at 12:07
1

@Vicrobot I am glad you like it. – GoingMyWay Jul 15 '19 at 15:16
you made it simple for us to understand, Thank you so much. – Alpha Green Dec 02 '20 at 00:22
1

@AlphaGreen I am very glad to hear that my answer is easy for you to understand `swapaxes` – GoingMyWay Dec 02 '20 at 06:25
really appreciate bud you made it very easy to understand especially last few lines – zaheer ahmad Jan 06 '21 at 16:50
@zaheerahmad I am glad you enjoy it. – GoingMyWay Jan 07 '21 at 01:57
1

@GaneshTata I am glad you like it. – GoingMyWay May 23 '21 at 03:03

hpaulj · Accepted Answer · 2017-02-18T08:36:11.417

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.

thank you. I understand now. the `strides` and `order` part is confusing, so I'll leave that for later. But I don't understand the connection between `swap` and `transpose`. I've learnt that only a square matrix can be transposed and that again results in 3*3 matrix. But the `swap` will result in 3*2 matrix, which I don't understand how it's related to transpose. — phoenix, Mar 15 '17 at 18:11
In `numpy` transpose works with any shape array. It's not restricted to square ones, or even 2d ones. If `x` is (2,3), the `x.T` and `x.swapaxes(0,1)` do the same thing. — hpaulj, Mar 15 '17 at 18:37

How does numpy.swapaxes work?

2 Answers2

Linked