# NumPy: numpy.copy() function

## numpy.copy() function

The numpy.copy() function is used to get an array copy of an given object.

The copy() function can be useful when you want to make changes to an array without modifying the original array. For example, if you want to perform a series of operations on an array and keep the original array intact, you can create a copy of the original array using the copy() function and perform the operations on the copy. This can also be useful when you want to pass a copy of an array to a function without modifying the original array.

**Syntax:**

numpy.copy(a, order='K')

**Parameters:**

Name | Description | Required / Optional |
---|---|---|

a | Input data. | Required |

order | Controls the memory layout of the copy. 'C' means C-order, 'F' means F-order, 'A' means 'F' if a is Fortran contiguous, 'C’ otherwise. 'K' means match the layout of a as closely as possible. (Note that this function and ndarray.copy are very similar, but have different default values for their order= arguments.) | optional |

**Return value:**

arr : ndarray

Array interpretation of a.

**Example: Shallow and Deep Copy in NumPy**

```
>>> import numpy as np
>>> a = np.array ( [2, 3, 4])
>>> b = a
>>> c = np.copy(a)
>>> a[0] = 15
>>> b[0] == b[0]
True
```

The above code demonstrates shallow and deep copy in NumPy. NumPy arrays support both shallow and deep copying.

Initially, an array 'a' is created with values [2, 3, 4]. Then, a reference to 'a' is assigned to 'b', and a copy of 'a' is created using np.copy() and assigned to 'c'.

When we change the value of the first element of 'a' to 15, it reflects in 'b' as well because 'b' is just a reference to the same memory location as 'a'. So, 'b' also contains [15, 3, 4].

However, the copy 'c' is unaffected by the change in 'a' because it is a deep copy and has its own separate memory location. So, 'c' contains the original values [2, 3, 4].

The expression 'b[0] == b[0]' evaluates to True because the value at index 0 in 'b' is still 15 (same as itself).

**Note that, when we modify a, b changes, but not c:**

```
>>> import numpy as np
>>> a[0] == c[0]
False
>>>
```

**Frequently asked questions (FAQ) - numpy. copy ()**

**1.** *What does numpy.copy() do*?

- numpy.copy() creates a deep copy of an array or a matrix in NumPy.
- It ensures that changes made to the copy do not affect the original array, and vice versa.

**2.** *When should we use numpy.copy()*?

- Use numpy.copy() when you need to modify an array independently of the original.
- It's useful for situations where you want to preserve the original data while making changes to a copy.

**3.** *How does numpy.copy() differ from assignment (=) or slicing*?

- Unlike assignment or slicing, numpy.copy() creates a completely new array with its own memory space.
- This ensures that changes made to the copied array do not affect the original array, whereas assignment or slicing may lead to unintended modifications.

**4.** *Can numpy.copy() be used with non-array data structures*?

- No, numpy.copy() is specifically designed for NumPy arrays and matrices.
- It may not work as expected with other Python data structures.

**5.** *Are there any performance considerations when using numpy.copy()*?

- numpy.copy() creates a full copy of the array, so it can be memory-intensive for large arrays.
- Consider using views or slices if memory usage is a concern.

**6.** *Does numpy.copy() handle nested arrays or matrices*?

- Yes, numpy.copy() can create copies of nested arrays or multi-dimensional matrices.
- It ensures that the copy is a deep copy, preserving the structure of nested arrays.

**Python - NumPy Code Editor:**

**Previous:** asmatrix()

**Next: ** fromfunction()

**Weekly Trends and Language Statistics**- Weekly Trends and Language Statistics