What is the difference between a shallow copy and a deep copy of a list in Python?
Alex K

In Python, when you want to create a copy of a list, you can choose between a shallow copy and a deep copy. Both copies are separate lists, but they differ in how they handle the elements within the list. Here's a detailed explanation of the differences between a shallow copy and a deep copy: Shallow Copy: - Definition: A shallow copy creates a new list object but maintains references to the elements of the original list. In other words, the new list contains references to the same objects as the original list, rather than creating new copies of the objects themselves. - Behavior: Modifying an element of the shallow copy will also affect the original list since they both reference the same objects. However, if you append or remove elements from the shallow copy, it won't affect the original list. - Creating a Shallow Copy: You can create a shallow copy of a list using thecopy() method or the slice operator ([:]).

1
2
3
4
5
6
7
8
9

original_list = [1, [2, 3], 4]
shallow_copy = original_list.copy()

original_list[0] = 10
original_list[1][0] = 20

print(original_list)  # Output: [10, [20, 3], 4]
print(shallow_copy)   # Output: [1, [20, 3], 4]

In this example, modifyingoriginal_list[0] affects onlyoriginal_list, while modifyingoriginal_list[1][0] affects bothoriginal_list andshallow_copy since they share the same nested list. Deep Copy: - Definition: A deep copy creates a completely independent copy of the original list and its elements. It recursively creates new copies of the nested objects, ensuring that any changes made to the elements of the deep copy do not affect the original list. - Behavior: Modifying an element of the deep copy does not affect the original list or any other copies. Each copy has its own separate set of objects. - Creating a Deep Copy: You can create a deep copy of a list using thedeepcopy() function from thecopy module.

1
2
3
4
5
6
7
8
9
10
11

import copy

original_list = [1, [2, 3], 4]
deep_copy = copy.deepcopy(original_list)

original_list[0] = 10
original_list[1][0] = 20

print(original_list)  # Output: [10, [20, 3], 4]
print(deep_copy) # Output: [1, [2, 3], 4]

In this example, modifying eitheroriginal_list[0] ororiginal_list[1][0] does not affectdeep_copy since it is an independent copy. Summary: In summary, a shallow copy of a list creates a new list with references to the same objects as the original list, while a deep copy creates a new list with independent copies of all the objects in the original list, recursively copying nested objects. Modifying elements of a shallow copy affects the original list, while modifying elements of a deep copy does not affect the original list or any other copies. Understanding the differences between shallow copy and deep copy helps ensure that you choose the appropriate copy method based on your specific needs and the nature of the objects contained within the list.

Similar Questions