# Concatenate two numpy arrays in the 4th dimension

## Question:

I have two numpy arrays with three dimensions (3 x 4 x 5) and I want to concatenate them so the result has four dimensions (3 x 4 x 5 x 2). In Matlab, this can be done with `cat(4, a, b)`

, but not in Numpy.

For example:

```
a = ones((3,4,5))
b = ones((3,4,5))
c = concatenate((a,b), axis=3) # error!
```

To clarify, I wish `c[:,:,:,0]`

and `c[:,:,:,1]`

to correspond to the original two arrays.

## Answers:

This works for me:

```
c = numpy.array([a,b])
```

Though it would be nice if it worked your way, too.

How about the following:

```
c = concatenate((a[:,:,:,None],b[:,:,:,None]), axis=3)
```

This gives a (3 x 4 x 5 x 2) array, which I believe is laid out in the manner you require.

Here, `None`

is synonymous to `np.newaxis`

: Numpy: Should I use newaxis or None?

**edit** As suggested by @Joe Kington, the code could be cleaned up a little bit by using an ellipsis:

```
c = concatenate((a[...,None],b[...,None]), axis=3)
```

Here you go:

```
import numpy as np
a = np.ones((3,4,5))
b = np.ones((3,4,5))
c = np.concatenate((a[...,np.newaxis],b[...,np.newaxis]),axis=3)
```

It’s not necessarily the most elegant, but I’ve used variations of

```
c = rollaxis(array([a,b]), 0, 4)
```

in the past.

The accepted answer above is great. But I’ll add the following because I’m a math dork and it’s a nice use of the fact that `a.shape`

is `a.T.shape[::-1]`

…i.e. taking a transpose reverses the order of the indices of a numpy array. So if you have your building blocks in an array called blocks, then the solution above is:

```
new = np.concatenate([block[..., np.newaxis] for block in blocks],
axis=len(blocks[0].shape))
```

but you could also do

```
new2 = np.array([block.T for block in blocks]).T
```

which I think reads more cleanly. It’s worth noting that the already-accepted answer runs more quickly:

```
%%timeit
new = np.concatenate([block[..., np.newaxis] for block in blocks],
axis=len(blocks[0].shape))
1000 loops, best of 3: 321 µs per loop
```

while

```
%%timeit
new2 = np.array([block.T for block in blocks]).T
1000 loops, best of 3: 407 µs per loop
```

What about

```
c = np.stack((a,b), axis=3)
```