# How to copy a 2D array into a 3rd dimension, N times?

Hello Guys, How are you all? Hope You all Are Fine. Today We Are Going To learn about How to copy a 2D array into a 3rd dimension, N times in Python. So Here I am Explain to you all the possible Methods here.

## How to copy a 2D array into a 3rd dimension, N times?

1. How to copy a 2D array into a 3rd dimension, N times?

Broadcasting is a very powerful technique because it avoids the additional overhead involved in creating repeated copies of your input arrays in memory.

2. copy a 2D array into a 3rd dimension, N times

Broadcasting is a very powerful technique because it avoids the additional overhead involved in creating repeated copies of your input arrays in memory.

## Method 1

Probably the cleanest way is to use `np.repeat`:

```a = np.array([[1, 2], [1, 2]])
print(a.shape)
# (2,  2)

# indexing with np.newaxis inserts a new 3rd dimension, which we then repeat the
# array along, (you can achieve the same effect by indexing with None, see below)
b = np.repeat(a[:, :, np.newaxis], 3, axis=2)

print(b.shape)
# (2, 2, 3)

print(b[:, :, 0])
# [[1 2]
#  [1 2]]

print(b[:, :, 1])
# [[1 2]
#  [1 2]]

print(b[:, :, 2])
# [[1 2]
#  [1 2]]
```

Having said that, you can often avoid repeating your arrays altogether by using broadcasting. For example, let’s say I wanted to add a `(3,)` vector:

```c = np.array([1, 2, 3])
```

to `a`. I could copy the contents of `a` 3 times in the third dimension, then copy the contents of `c` twice in both the first and second dimensions, so that both of my arrays were `(2, 2, 3)`, then compute their sum. However, it’s much simpler and quicker to do this:

```d = a[..., None] + c[None, None, :]
```

Here, `a[..., None]` has shape `(2, 2, 1)` and `c[None, None, :]` has shape `(1, 1, 3)`*. When I compute the sum, the result gets ‘broadcast’ out along the dimensions of size 1, giving me a result of shape `(2, 2, 3)`:

```print(d.shape)
# (2,  2, 3)

print(d[..., 0])    # a + c[0]
# [[2 3]
#  [2 3]]

print(d[..., 1])    # a + c[1]
# [[3 4]
#  [3 4]]

print(d[..., 2])    # a + c[2]
# [[4 5]
#  [4 5]]
```

Broadcasting is a very powerful technique because it avoids the additional overhead involved in creating repeated copies of your input arrays in memory.

* Although I included them for clarity, the `None` indices into `c` aren’t actually necessary – you could also do `a[..., None] + c`, i.e. broadcast a `(2, 2, 1)` array against a `(3,)` array. This is because if one of the arrays has fewer dimensions than the other then only the trailing dimensions of the two arrays need to be compatible. To give a more complicated example:

```a = np.ones((6, 1, 4, 3, 1))  # 6 x 1 x 4 x 3 x 1
b = np.ones((5, 1, 3, 2))     #     5 x 1 x 3 x 2
result = a + b                # 6 x 5 x 4 x 3 x 2```

## Method 2

Another way is to use `numpy.dstack`. Supposing that you want to repeat the matrix `a` `num_repeats` times:

```import numpy as np
b = np.dstack([a]*num_repeats)
```

The trick is to wrap the matrix `a` into a list of a single element, then using the `*` operator to duplicate the elements in this list `num_repeats` times.

For example, if:

```a = np.array([[1, 2], [1, 2]])
num_repeats = 5
```

This repeats the array of `[1 2; 1 2]` 5 times in the third dimension. To verify (in IPython):

```In [110]: import numpy as np

In [111]: num_repeats = 5

In [112]: a = np.array([[1, 2], [1, 2]])

In [113]: b = np.dstack([a]*num_repeats)

In [114]: b[:,:,0]
Out[114]:
array([[1, 2],
[1, 2]])

In [115]: b[:,:,1]
Out[115]:
array([[1, 2],
[1, 2]])

In [116]: b[:,:,2]
Out[116]:
array([[1, 2],
[1, 2]])

In [117]: b[:,:,3]
Out[117]:
array([[1, 2],
[1, 2]])

In [118]: b[:,:,4]
Out[118]:
array([[1, 2],
[1, 2]])

In [119]: b.shape
Out[119]: (2, 2, 5)
```

At the end we can see that the shape of the matrix is `2 x 2`, with 5 slices in the third dimension.

## Conclusion

It’s all About this issue. Hope all Methods helped you a lot. Comment below Your thoughts and your queries. Also, Comment below which Method worked for you? Thank You.