When working with mutable objects (like lists, dictionaries, sets, etc.), copying them can behave differently depending on how deep the copy goes.
Python provides two main ways to copy objects:
✅ Shallow Copy
✅ Deep Copy
Let’s understand both with clear examples and visuals 👇
🔹 1. What is a Copy in Python?
When you assign one variable to another:
a = [1, 2, 3]
b = a➡️ Both a and b point to the same memory location.
If you modify b, a will change too — because no actual copy is made.
Example:
a = [1, 2, 3]
b = a
b.append(4)
print(a)Output:
[1, 2, 3, 4]✅ Both a and b refer to the same list.
To actually copy objects, you can use:
- Shallow Copy →
copy.copy(obj) - Deep Copy →
copy.deepcopy(obj)
🔹 2. Import the copy Module
Before using either, you need:
import copy🔹 3. Shallow Copy
A shallow copy creates a new object, but does not create copies of nested objects inside it.
Instead, it just copies references to the inner objects.
✅ Syntax:
copy.copy(object)🧩 Example: Shallow Copy of Nested List
import copy
original = [[1, 2, 3], [4, 5, 6]]
shallow = copy.copy(original)
shallow[0][0] = 99
print("Original:", original)
print("Shallow:", shallow)Output:
Original: [[99, 2, 3], [4, 5, 6]]
Shallow: [[99, 2, 3], [4, 5, 6]]✅ Changing the inner list in shallow also changed original —
because nested objects were not copied, only referenced.
🧠 Visualization:
original → [[1, 2, 3], [4, 5, 6]]
↑ ↑
└── shared ─┘ (same nested lists)
shallow → [[1, 2, 3], [4, 5, 6]]Both original and shallow share the same inner lists.
🧩 However, modifying the top-level list works independently:
shallow.append([7, 8])
print("Original:", original)
print("Shallow:", shallow)Output:
Original: [[99, 2, 3], [4, 5, 6]]
Shallow: [[99, 2, 3], [4, 5, 6], [7, 8]]✅ The outer list is different (copied),
but inner lists still share memory.
🔹 4. Deep Copy
A deep copy creates a completely independent copy of the original object —
including all nested objects.
That means any modification in one object will not affect the other.
✅ Syntax:
copy.deepcopy(object)🧩 Example: Deep Copy of Nested List
import copy
original = [[1, 2, 3], [4, 5, 6]]
deep = copy.deepcopy(original)
deep[0][0] = 99
print("Original:", original)
print("Deep Copy:", deep)Output:
Original: [[1, 2, 3], [4, 5, 6]]
Deep Copy: [[99, 2, 3], [4, 5, 6]]✅ Changes made to deep do not affect original.
All nested elements are fully cloned.
🧠 Visualization:
original → [[1, 2, 3], [4, 5, 6]]
↑ ↑
deep → [[1, 2, 3], [4, 5, 6]]✅ Completely new objects at all levels — no shared references.
🔹 5. Shallow vs Deep Copy — Side-by-Side Example
import copy
original = [[1, 2], [3, 4]]
shallow = copy.copy(original)
deep = copy.deepcopy(original)
# Modify inner list
original[0][0] = 99
print("Original:", original)
print("Shallow:", shallow)
print("Deep:", deep)Output:
Original: [[99, 2], [3, 4]]
Shallow: [[99, 2], [3, 4]]
Deep: [[1, 2], [3, 4]]✅ Only the deep copy remains unaffected.
🔹 6. Shallow Copy Using Built-in Methods
You can create shallow copies using:
list.copy()
list[:]
copy.copy()Example:
a = [1, 2, 3]
b = a.copy() # shallow copy
c = a[:] # shallow copy
print(a == b == c) # True
print(a is b) # False (different objects)✅ Works fine for 1D lists (no nesting).
But not safe for nested structures — still shares references.
🔹 7. Performance Note
| Operation | Speed | Memory Usage |
|---|---|---|
| Shallow Copy | 🟢 Fast | Low |
| Deep Copy | 🔴 Slower | High (copies all nested data) |
✅ Use shallow copy when you only need a duplicate of the outer object.
✅ Use deep copy when you need a fully independent copy of nested structures.
🧾 Summary Table
| Feature | Shallow Copy | Deep Copy |
|---|---|---|
| Function | copy.copy() | copy.deepcopy() |
| Copies Outer Object? | ✅ Yes | ✅ Yes |
| Copies Inner Objects? | ❌ No (references only) | ✅ Yes (new copies) |
| Independent? | Partially | Completely |
| Speed | Faster | Slower |
| Memory Usage | Less | More |
| Example Effect | Change in nested list affects both | Changes isolated |
| Use When | Nested data won’t be modified | Independent copy needed |
🔹 8. Real-Life Example — Students’ Marks
import copy
students = [["Alice", [85, 90]], ["Bob", [75, 80]]]
shallow = copy.copy(students)
deep = copy.deepcopy(students)
# Modify one student’s marks
students[0][1][0] = 100
print("Original:", students)
print("Shallow:", shallow)
print("Deep:", deep)Output:
Original: [['Alice', [100, 90]], ['Bob', [75, 80]]]
Shallow: [['Alice', [100, 90]], ['Bob', [75, 80]]]
Deep: [['Alice', [85, 90]], ['Bob', [75, 80]]]✅ shallow reflects the inner list change;
✅ deep remains untouched.
✅ In short:
- Shallow Copy (
copy.copy())
→ Copies the object, but shares nested references.- Deep Copy (
copy.deepcopy())
→ Creates a fully independent clone of the object, including nested ones.
🧩 Final Example (Quick Recap)
import copy
data = [[1, 2, 3], [4, 5, 6]]
shallow = copy.copy(data)
deep = copy.deepcopy(data)
data[0][0] = 999
print("Original:", data)
print("Shallow:", shallow)
print("Deep:", deep)Output:
Original: [[999, 2, 3], [4, 5, 6]]
Shallow: [[999, 2, 3], [4, 5, 6]]
Deep: [[1, 2, 3], [4, 5, 6]]✅ Shallow copy shares nested references.
✅ Deep copy makes a complete, independent clone.