# Numpy array assignment with copy

## Question:

For example, if we have a `numpy` array `A`, and we want a `numpy` array `B` with the same elements.

What is the difference between the following (see below) methods? When is additional memory allocated, and when is it not?

1. `B = A`
2. `B[:] = A` (same as `B[:]=A[:]`?)
3. `numpy.copy(B, A)`

1. `B=A` creates a reference
2. `B[:]=A` makes a copy
3. `numpy.copy(B,A)` makes a copy

the last two need additional memory.

To make a deep copy you need to use `B = copy.deepcopy(A)`

All three versions do different things:

1. `B = A`

This binds a new name `B` to the existing object already named `A`. Afterwards they refer to the same object, so if you modify one in place, you’ll see the change through the other one too.

2. `B[:] = A` (same as `B[:]=A[:]`?)

This copies the values from `A` into an existing array `B`. The two arrays must have the same shape for this to work. `B[:] = A[:]` does the same thing (but `B = A[:]` would do something more like 1).

3. `numpy.copy(B, A)`

This is not legal syntax. You probably meant `B = numpy.copy(A)`. This is almost the same as 2, but it creates a new array, rather than reusing the `B` array. If there were no other references to the previous `B` value, the end result would be the same as 2, but it will use more memory temporarily during the copy.

Or maybe you meant `numpy.copyto(B, A)`, which is legal, and is equivalent to 2?

This is the only working answer for me:

``````B=numpy.array(A)
``````
Categories: questions Tags: , ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.