# NumPy: Transpose ndarray (swap rows and columns, rearrange axes)

To transpose NumPy array `ndarray`

(swap rows and columns), use the `T`

attribute (`.T`

), the `ndarray`

method `transpose()`

and the `numpy.transpose()`

function.

With `ndarray.transpose()`

and `numpy.transpose()`

, you can not only transpose a 2D array (matrix) but also rearrange the axes of a multidimensional array in any order.

- numpy.ndarray.T — NumPy v1.16 Manual
- numpy.ndarray.transpose — NumPy v1.16 Manual
- numpy.transpose — NumPy v1.16 Manual

Here, the following contents will be described.

- Transpose two-dimensional array (matrix)
`T`

attribute`ndarray.transpose()`

`np.transpose()`

- 1D array and row vector, column vector
- Swap axes of multi-dimensional array (3D or higher)
- Default result
- Specify axis order with
`transpose()`

- Example: Transpose multiple matrices at once

If you want to swap rows and columns of `pandas.DataFrame`

or a two-dimensional list (list of lists), see the following post.

**Related:**pandas: Transpose DataFrame (swap rows and columns)**Related:**Transpose 2D list in Python (swap rows and columns)

## Transpose two-dimensional array (matrix)

### T attribute

You can get the transposed matrix of the original two-dimensional array (matrix) with the `T`

attribute.

```
import numpy as np
a_2d = np.arange(6).reshape(2, 3)
print(a_2d)
# [[0 1 2]
# [3 4 5]]
a_2d_T = a_2d.T
print(a_2d_T)
# [[0 3]
# [1 4]
# [2 5]]
```

The `T`

attribute returns a view of the original array, and changing one changes the other.

You can check if `ndarray`

refers to data in the same memory with `np.shares_memory()`

.

```
print(np.shares_memory(a_2d, a_2d_T))
# True
a_2d_T[0, 1] = 100
print(a_2d_T)
# [[ 0 100]
# [ 1 4]
# [ 2 5]]
print(a_2d)
# [[ 0 1 2]
# [100 4 5]]
a_2d[1, 0] = 3
print(a_2d)
# [[0 1 2]
# [3 4 5]]
print(a_2d_T)
# [[0 3]
# [1 4]
# [2 5]]
```

If you want to process it as separate data, make a copy with `copy()`

.

```
a_2d_T_copy = a_2d.T.copy()
print(a_2d_T_copy)
# [[0 3]
# [1 4]
# [2 5]]
print(np.shares_memory(a_2d, a_2d_T_copy))
# False
a_2d_T_copy[0, 1] = 100
print(a_2d_T_copy)
# [[ 0 100]
# [ 1 4]
# [ 2 5]]
print(a_2d)
# [[0 1 2]
# [3 4 5]]
```

### ndarray.transpose()

`transpose()`

is provided as a method of `ndarray`

. Like `T`

, the view is returned.

```
print(a_2d.transpose())
# [[0 3]
# [1 4]
# [2 5]]
print(np.shares_memory(a_2d, a_2d.transpose()))
# True
```

### np.transpose()

`numpy.transpose()`

function is also provided. Specify the original array to the first argument. This also returns a view.

```
print(np.transpose(a_2d))
# [[0 3]
# [1 4]
# [2 5]]
print(np.shares_memory(a_2d, np.transpose(a_2d)))
# True
```

## 1D array and row vector, column vector

Applying `T`

or `transpose()`

to a one-dimensional array only returns an array equivalent to the original array.

```
a_1d = np.arange(3)
print(a_1d)
# [0 1 2]
print(a_1d.T)
# [0 1 2]
print(a_1d.transpose())
# [0 1 2]
print(np.transpose(a_1d))
# [0 1 2]
```

A matrix with only one row is called a row vector, and a matrix with one column is called a column vector, but there is no distinction between rows and columns in a one-dimensional array of `ndarray`

.

A two-dimensional array is used to clearly indicate that only rows or columns are present.

Here, transform the shape by using `reshape()`

.

```
a_row = a_1d.reshape(1, -1)
print(a_row)
# [[0 1 2]]
print(a_row.shape)
# (1, 3)
print(a_row.ndim)
# 2
```

```
a_col = a_1d.reshape(-1, 1)
print(a_col)
# [[0]
# [1]
# [2]]
print(a_col.shape)
# (3, 1)
print(a_col.ndim)
# 2
```

As mentioned above, two-dimensional arrays can be transposed.

```
print(a_row.T)
# [[0]
# [1]
# [2]]
print(a_col.T)
# [[0 1 2]]
```

## Swap axes of multi-dimensional array (3D or higher)

### Default result

`T`

,`transpose ()`

can be applied to multi-dimensional arrays of 3D or higher.

The default result is as follows. `np.transpose ()`

has the same result.

```
a_3d = np.arange(24).reshape(2, 3, 4)
print(a_3d)
# [[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
#
# [[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]]
print(a_3d.T)
# [[[ 0 12]
# [ 4 16]
# [ 8 20]]
#
# [[ 1 13]
# [ 5 17]
# [ 9 21]]
#
# [[ 2 14]
# [ 6 18]
# [10 22]]
#
# [[ 3 15]
# [ 7 19]
# [11 23]]]
print(a_3d.T.shape)
# (4, 3, 2)
print(a_3d.transpose())
# [[[ 0 12]
# [ 4 16]
# [ 8 20]]
#
# [[ 1 13]
# [ 5 17]
# [ 9 21]]
#
# [[ 2 14]
# [ 6 18]
# [10 22]]
#
# [[ 3 15]
# [ 7 19]
# [11 23]]]
print(a_3d.transpose().shape)
# (4, 3, 2)
```

It is difficult to understand just by looking at the output result, but the order of the axis (dimension) of `(0th axis, 1st axis, 2nd axis)`

is reversed like `(2nd axis, 1st axis, 0th axis )`

.

In a 2D array, the order of `(0th axis, 1st axis) = (row, column)`

is changed to the order of `(1st axis, 0th axis) = (column, row)`

.

### Specify axis order with transpose()

Using `T`

always reverses the order, but using `transpose()`

, you can specify any order.

In the following example, specify the same reversed order as the default, and confirm that the result does not change.

In the `ndarray`

method `transpose()`

, specify the axis order with variable length arguments or tuple.

```
print(a_3d.transpose(2, 1, 0))
# [[[ 0 12]
# [ 4 16]
# [ 8 20]]
#
# [[ 1 13]
# [ 5 17]
# [ 9 21]]
#
# [[ 2 14]
# [ 6 18]
# [10 22]]
#
# [[ 3 15]
# [ 7 19]
# [11 23]]]
print(a_3d.transpose(2, 1, 0).shape)
# (4, 3, 2)
print(a_3d.transpose((2, 1, 0)).shape)
# (4, 3, 2)
```

In `np.transpose()`

, specify the order as the second argument with tuple. It cannot be specified with variable length arguments.

```
print(np.transpose(a_3d, (2, 1, 0)))
# [[[ 0 12]
# [ 4 16]
# [ 8 20]]
#
# [[ 1 13]
# [ 5 17]
# [ 9 21]]
#
# [[ 2 14]
# [ 6 18]
# [10 22]]
#
# [[ 3 15]
# [ 7 19]
# [11 23]]]
print(np.transpose(a_3d, (2, 1, 0)).shape)
# (4, 3, 2)
# print(np.transpose(a_3d, 2, 1, 0))
# TypeError: transpose() takes from 1 to 2 positional arguments but 4 were given
```

An error occurs if the number of specified axes does not match the number of dimensions of the original array, or if a dimension that does not exist is specified.

```
# print(a_3d.transpose(0, 1))
# ValueError: axes don't match array
# print(a_3d.transpose(0, 1, 2, 3))
# ValueError: axes don't match array
# print(a_3d.transpose(0, 1, 3))
# AxisError: axis 3 is out of bounds for array of dimension 3
```

### Example: Transpose multiple matrices at once

`transpose()`

is useful, for example, when a 3D array is a group of 2D arrays.

If the data of matrices are stored as a 3D array of shape `(n, row, column)`

, all matrices can be transposed as follows.

```
print(a_3d)
# [[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
#
# [[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]]
print(a_3d.shape)
# (2, 3, 4)
print(a_3d.transpose(0, 2, 1))
# [[[ 0 4 8]
# [ 1 5 9]
# [ 2 6 10]
# [ 3 7 11]]
#
# [[12 16 20]
# [13 17 21]
# [14 18 22]
# [15 19 23]]]
print(a_3d.transpose(0, 2, 1).shape)
# (2, 4, 3)
```

If the shape is `(row, column, n)`

, you can do as follows.

```
print(a_3d.transpose(1, 0, 2))
# [[[ 0 1 2 3]
# [12 13 14 15]]
#
# [[ 4 5 6 7]
# [16 17 18 19]]
#
# [[ 8 9 10 11]
# [20 21 22 23]]]
print(a_3d.transpose(1, 0, 2).shape)
# (3, 2, 4)
print(a_3d[:, :, 0])
# [[ 0 4 8]
# [12 16 20]]
print(a_3d.transpose(1, 0, 2)[:, :, 0])
# [[ 0 12]
# [ 4 16]
# [ 8 20]]
```