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.

Without wasting your time, Let’s start This Article.

Table of Contents

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

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

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

**Also, Read**