# Reshaping and three-dimensional arrays

## Contents

# Reshaping and three-dimensional arrays#

```
import numpy as np
```

## Into the third dimension#

As we discussed in the three-dimensional arrays page page, one-dimensional and two-dimensional arrays are easy to think about. For example we can think of a 2D array as a table or a spreadsheet, with rows and columns.

A three-dimensional array takes a little bit more work to visualize, and get used to.

## Reshaping a three-dimensional array#

You have already seen the algorithm for reshaping in one and two dimensions.

NumPy uses the same algorithm for reshaping a three-dimensional array.

We start with a one-dimensional array:

```
arr_1d = np.arange(24)
arr_1d.shape
```

```
(24,)
```

```
arr_1d
```

```
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])
```

Then, reshape to three dimensions.

```
arr_3d = np.reshape(arr_1d, (2, 3, 4))
arr_3d
```

```
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]]])
```

Remember from the three-dimensional arrays page page that we can
read the shape of `arr_3d`

- `(2, 3, 4)`

- as “two rows, three columns, four
planes”.

Let us translate that into the output of `arr_3d`

as NumPy shows it. If we
picture `arr_3d`

in physical space, it would be four planes stacked in a line,
each containing 2 rows and 3 columns.

Notice too that Numpy has filled in the 3D array in the order:

plane, then

column, then

row.

That is, it fills in the *last* axis first, then the *second* to last, then the
*first* axis.

This is the same way Numpy works for 2D arrays, when it fills in by:

column (last axis), then

row (first axis).

That means, as in the diagram above, that the first *plane* will get every 4th
value from the original 1D array, because:

0, 1, 2, 3 fills the first row,

**first**column, over the planes. We see 0 in the first row, first column of the first plane.4, 5, 6, 7 fills the first row,

**second**column, over the planes. We see 4 in the first row, second column, first plane. And so on.

For example, here, as in the diagram, is the first *plane*.

```
# The First plane.
arr_3d[:, :, 0]
```

```
array([[ 0, 4, 8],
[12, 16, 20]])
```

However, you will see above, and below, that NumPy is showing us the two
slices over the *first* dimension, when we ask to see the array values:

```
# The default display shows the array by *rows*.
# Each row is 3 columns and 4 planes.
arr_3d
```

```
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]]])
```

```
print('First row of data from 3D array:\n', arr_3d[0, :, :])
print('Second row of data from 3D array:\n', arr_3d[1, :, :])
```

```
First row of data from 3D array:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
Second row of data from 3D array:
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]
```

To think about what array this is, imagine tipping the bottom of each 2D array towards you from the plane of the screen, and look at these tipped planes from the left, so the 0 sits nearly on top of 12, in the plane of the screen, and 4 sits nearly on top of 16, a little forward of the plane of the screen.

Compare the NumPy outputs to the image above, to make sure you can visualize the array from both perspectives.

We can reshape to one dimension in the same way as we did for the 2D arrays:

```
# Reshape to 1D array with 24 elements.
np.reshape(arr_3d, (24,))
```

```
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])
```

```
# Reshape to 1D array, using all the elements (24 in this case).
np.reshape(arr_3d, (-1,))
```

```
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])
```

```
# Reshape to 1D using dedicated Numpy function.
np.ravel(arr_3d)
```

```
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])
```

To get the elements of the 1D array, NumPy first fetches values across the last axis (the depth or plane axis), then the second to last (column) axis, then the first (row) axis.

When reshaping to three dimensions, NumPy fills out the last, then second, then first dimensions (last to first):

```
arr_3d = np.reshape(arr_1d, (2, 3, 4))
arr_3d
```

```
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]]])
```