Why Doesn\'t Updating a Shallow Copy of a Python Dictionary Affect the Original?

Understanding Shallow Copying in Python Dictionaries: Why Updates in Copy Don't Affect the Original

When working with Python dictionaries, it's important to understand the distinction between shallow and deep copying. A shallow copy creates a new dictionary that contains references to the same objects as the original dictionary, while a deep copy creates a new dictionary with copies of the objects.

Shallow Copying with dict.copy()

The dict.copy() method performs a shallow copy of a dictionary. This means that the new dictionary will contain references to the same objects that are stored in the original dictionary. As a result, any changes made to the copy will also be reflected in the original dictionary.

Example:

original = {'a': 1, 'b': 2}
new = original.copy()
new.update({'c': 3})

print(original)  # {'a': 1, 'b': 2}
print(new)  # {'a': 1, 'c': 3, 'b': 2}

In this example, the dict.copy() method creates a new dictionary, new, that contains references to the same objects as the original dictionary. When we update the copy with {'c': 3}, both the original and the copy reflect this change.

Why Updates in Copy Don't Affect the Original

The reason why updates in a shallow copy do not affect the original is that the copy only contains references to the objects. When we update the copy, we are not changing the actual objects, but only the references.

This is in contrast to a list, where a shallow copy contains a reference to the list itself and not the elements within. When we update the copy of a list, we are updating the elements in the list, which affects both the copy and the original.

Deep Copying with copy.deepcopy()

To create a copy of a dictionary that is completely isolated from the original, we can use the copy.deepcopy() function. This function recursively copies all objects in the dictionary, creating a new structure with distinct references.

Example:

import copy

original = {'a': 1, 'b': 2}
new = copy.deepcopy(original)
new.update({'c': 3})

print(original)  # {'a': 1, 'b': 2}
print(new)  # {'a': 1, 'c': 3, 'b': 2}

In this example, the copy.deepcopy() function creates a new dictionary, new, that contains copies of the objects in the original dictionary. When we update the copy, the original dictionary remains unaffected.

The above is the detailed content of Why Doesn\'t Updating a Shallow Copy of a Python Dictionary Affect the Original?. For more information, please follow other related articles on the PHP Chinese website!