Why Does Modifying a List Copy Sometimes Change the Original: Shallow vs. Deep Copy?

How to Deep Copy a List: Understanding Shallow vs. Deep Copies

Suppose you have a list E0 and create a copy E0_copy using list(E0). Intuitively, you might assume that E0_copy is a deep copy since their IDs differ. However, modifying E0_copy in a loop unexpectedly alters E0 as well. Why does this occur?

The Pitfall of Shallow Copies

list(...) creates a shallow copy, which means it only duplicates the outermost list while retaining references to the same inner lists. Therefore, when you manipulate an inner list of E0_copy, you also impact E0 because both lists point to the same internal structures.

The Solution: Deep Copying

To perform a deep copy, utilize the copy.deepcopy(...) function. It creates a genuine deep copy by recursively copying all objects, including nested structures. This operation ensures that changes made to the copy do not affect the original.

Demonstration

Consider the following code snippet, where list(...) results in a shallow copy:

a = [[1, 2, 3], [4, 5, 6]]
b = list(a)
print(a == b)  # True, indicates shallow copy

Now, using copy.deepcopy(...) for deep copying:

import copy
b = copy.deepcopy(a)
print(a == b)  # False, confirms deep copy

Now, modifying a does not affect b, demonstrating the isolation provided by deep copying.

The above is the detailed content of Why Does Modifying a List Copy Sometimes Change the Original: Shallow vs. Deep Copy?. For more information, please follow other related articles on the PHP Chinese website!