# Clone a List in Python With Shallow and Deep Copy

> Create independent copies of Python lists using list.copy, slicing, the list constructor for shallow copies, or copy.deepcopy for nested structures

**URL:** https://sentry.io/answers/clone-a-list-in-python/

---

## The Problem

After I attempt to copy a list by setting `new_list = old_list`, any modifications to `new_list` also affect `old_list`. What is the proper way to clone a list and avoid this?

## The Solution

The code `new_list = old_list` does not create a second list, but merely causes `new_list` to reference the same list object as `old_list`. To make `new_list` an independent copy of `old_list`, we must explicitly copy the list. We can do this in two ways: 

- **Shallow copy**: Creates a new list, but does not create copies of the objects that the original list references. Both the original and the cloned list will still reference the same objects.
- **Deep copy**: Creates a new list and creates copies of every object in the original list references, recursively, ensuring that the two lists are entirely independent.

Performing a shallow copy is sufficient for lists containing simple, immutable types, such as numbers and strings. If a list contains other lists, dictionaries, or custom objects, a deep copy will be required.

We can use one of three methods to make a shallow copy:

1. **`list.copy`**:
    The [`list.copy`](https://docs.python.org/3/builtins/stdtypes.html#mutable-sequence-types) method makes a *shallow copy* of the original list:
    ```python
    old_list = [1, 2, 3, 4, 5]
    new_list = old_list.copy()
    ```

2. **List slicing**:
    We can also create a clone of a list using list slicing:

    ```python
    new_list = old_list[:]
    ```

    This creates a new list by slicing the old list from its first to its final element. It is identical to `list.copy` but may be less clear.

3. **Using the `list` constructor**:
    We can also create a new list from the existing list by passing it to the `list` constructor.

    ```python
    new_list = list(old_list)
    ```

    Again, this syntax produces identical results to the `copy` method but may be less clear.

To make a deep copy of the list, we must use the [`deepcopy`](https://docs.python.org/3/library/copy.html#copy.deepcopy) function from Python's built-in [`copy`](https://docs.python.org/3/library/copy.html) module:

```python
import copy

old_list = [[1, 2], [3, 4]]
new_list = copy.deepcopy(old_list)

new_list[0][1] = 5 # change inner list in copy

print(old_list) # will print [[1, 2], [3, 4]]
print(new_list) # will print [[1, 5], [3, 4]]
```

---

*Source: [sentry.io/answers/clone-a-list-in-python/](https://sentry.io/answers/clone-a-list-in-python/)*