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
Release: 2024-11-24 04:36:14
Original
818 people have browsed it

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})
Copy after login

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}   |
Copy after login

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

original = [1, 2, 3]
new = original
Copy after login

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]  |
Copy after login

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)
Copy after login
Representation after deep copy:

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

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!

source:php.cn
Statement of this Website
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
Latest Articles by Author
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template