Home >Backend Development >Python Tutorial >Shallow vs. Deep Copy in Python Dictionaries: Why Doesn\'t `copy()` Update the Original?

Shallow vs. Deep Copy in Python Dictionaries: Why Doesn\'t `copy()` Update the Original?

Mary-Kate Olsen
Mary-Kate OlsenOriginal
2024-11-24 04:36:14783browse

Shallow vs. Deep Copy in Python Dictionaries: Why Doesn't `copy()` Update the Original?

Understanding Shallow and Deep Copying: Why Dictionary Shallow Copy Doesn't Update Original

When working with data structures in Python, it's crucial to understand the difference between shallow and deep copying. Shallow copying creates a new reference to the original data structure, while deep copying creates a completely new data structure with isolated content.

Let's examine the behavior of shallow copying in dictionaries. In the example provided:

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

Calling copy() on the dictionary original creates a new mapping object, new, that references the same content as original. This is known as shallow copying. When new is updated with {'c': 3}, only new is affected. Both original and new reference the same underlying data structure.

Representation after shallow copy:

original: |  {a: 1, b: 2}   |
new:     |  {a: 1, b: 2}   |

However, when shallow copying a mutable data structure, like a list:

original = [1, 2, 3]
new = original

Modifying the new list (new.append(4)) modifies the original list (original) as well.

Representation after shallow copy for lists:

original: |  [1, 2, 3]  |
new:     |  [1, 2, 3]  |

The key distinction between shallow and deep copying lies in how they handle nested data structures. Deep copying recursively copies all content by value, creating completely isolated data structures:

import copy
c = copy.deepcopy(a)
Representation after deep copy:

original: |  {a: [1, 2, 3]}  |
c:        |  {a: [1, 2, 3]}  |

In summary, shallow copying references the original data structure, while deep copying creates an entirely new, isolated structure. This distinction becomes especially important when modifying mutable data structures.

The above is the detailed content of Shallow vs. Deep Copy in Python Dictionaries: Why Doesn\'t `copy()` Update the Original?. For more information, please follow other related articles on the PHP Chinese website!

Statement:
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn