Master Python Shallow vs Deep Copy: When and How to Use Them

1. Shallow and Deep Copy

In Python, assigning a variable creates a reference, not a copy; to avoid unintended modifications you need to create explicit copies of objects.

2. Assignment

l1 = [1, 2, 3, [22, 33]]
l2 = l1
l1.append(666)
print(l1)  # [1, 2, 3, [22, 33], 666]
print(l2)  # [1, 2, 3, [22, 33], 666]

Note: l2 = l1 is just a reference, not a copy.

3. Shallow Copy

A shallow copy creates a new outer list, but inner objects still reference the original memory.

# Example 1: Adding element to outer list
l1 = [1, 2, 3, [22, 33]]
l2 = l1.copy()
l1.append(666)
print(l1)  # [1, 2, 3, [22, 33], 666]
print(l2)  # [1, 2, 3, [22, 33]]

# Example 2: Modifying inner list
l1 = [1, 2, 3, [22, 33]]
l2 = l1.copy()
l1[-1].append(666)
print(l1)  # [1, 2, 3, [22, 33, 666]]
print(l2)  # [1, 2, 3, [22, 33, 666]]

# Example 3: Changing first element
l1 = [1, 2, 3, [22, 33]]
l2 = l1.copy()
l1[0] = 6
print(l1)  # [6, 2, 3, [22, 33]]
print(l2)  # [1, 2, 3, [22, 33]]

4. Deep Copy

Deep copy recursively copies all mutable objects, creating independent copies.

import copy
l1 = [1, 2, 3, [22, 33]]
l2 = copy.deepcopy(l1)
l1.append(666)
print(l1)  # [1, 2, 3, [22, 33], 666]
print(l2)  # [1, 2, 3, [22, 33]]

Python optimizes deep copy by reusing immutable objects and recreating mutable ones.

5. Why Python defaults to shallow copy

Time: shallow copy is faster.

Space: uses less memory.

Efficiency: only copies top‑level references.

Conclusion

Immutable objects get new space on assignment.

Mutable objects share references unless copied.

Shallow copy copies only the first level; changes to nested mutable objects affect both copies.

Deep copy copies recursively until all nested mutable objects are duplicated.

Python provides several ways to shallow copy: copy.copy, list .copy(), slicing, etc.

In most cases, shallow copy is sufficient unless a true independent copy is required.

Advantages of shallow copy: fast, low memory usage, high efficiency.