Shallow vs. Deep Copies with the `copy` Module

The Foundation: Assignment Creates a Binding, Not a Copy

Before we dive into the copy module, let's solidify a core concept we've touched on previously. In Python, assignment statements do not copy objects; they create new bindings (references) to the same object.

Consider this simple list:

original_list = [1, 2, [3, 4]]
assigned_list = original_list

Here, assigned_list is just another name pointing to the exact same list object in memory as original_list. They are not two separate lists.

>>> assigned_list is original_list
True

Any modification made through one variable will be visible through the other, because they both refer to the single underlying object.

assigned_list[0] = 99
print(original_list)  # Output: [99, 2, [3, 4]]

This behavior is efficient, but it's not what we want when we need to create a distinct duplicate. This is where the copy module becomes essential. The following short video provides an excellent recap of this principle.

Shallow Copy: Duplicating the Top Level

A shallow copy creates a new compound object (like a new list or dictionary) but then populates it with references to the objects found in the original. It copies the object one level deep, but the references to any nested objects remain shared.

You can create a shallow copy in several ways, with copy.copy() being the most explicit:

import copy

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




# The outer list is a new object
print(original_list is shallow_copy_list)         # False




# But the nested list is the SAME object
print(original_list[2] is shallow_copy_list[2])   # True

Because the top-level container is a new object, modifying it won't affect the original.

shallow_copy_list.append(5)
print(original_list)      # [1, 2, [3, 4]]
print(shallow_copy_list)  # [1, 2, [3, 4], 5]

However—and this is the critical part—since the nested list [3, 4] is shared, a change to it through either variable affects both.

shallow_copy_list[2][0] = 'X'
print(original_list)      # [1, 2, ['X', 4]]
print(shallow_copy_list)  # [1, 2, ['X', 4], 5]

This unintended side effect is a classic source of bugs in programs that handle complex mutable state. The diagram below illustrates this concept visually. A change to the nested object (circled) is reflected in both the original SHALLOW structure and its copy.

The following video uses Python Tutor to provide an exceptional visualization of the memory layout during a shallow copy, making the concept of shared internal references crystal clear.

Deep Copy: Creating a Fully Independent Clone

To avoid the side effects of shallow copying, you need a deep copy. A deep copy constructs a new compound object and then, recursively, inserts copies of the objects found in the original. The result is a completely independent clone of the original object and all its children.

The copy module provides copy.deepcopy() for this purpose.

import copy

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




# The outer list is a new object
print(original_list is deep_copy_list)         # False




# The nested list is ALSO a new object
print(original_list[2] is deep_copy_list[2])   # False

Now, because every part of the data structure has been duplicated, you can modify any part of the deep_copy_list without any fear of side effects.

deep_copy_list[2][0] = 'Y'
print(original_list)    # [1, 2, [3, 4]]
print(deep_copy_list)   # [1, 2, ['Y', 4]]

For a comprehensive walkthrough of these concepts with a different, practical example, the following article is an excellent resource.

A particularly interesting challenge for deep copying is handling recursive objects (e.g., a list that contains a reference to itself). A naive recursive copy would enter an infinite loop. The copy.deepcopy() function cleverly avoids this by keeping a memo dictionary of objects it has already copied during a pass, preventing redundant duplication and infinite recursion.

Customizing Copying Behavior in Classes

As a senior engineer, you don't just use built-in types; you design your own. The default behavior of copy.copy() and copy.deepcopy() on custom objects is to create a new instance and then copy the attributes. For shallow copy, it copies the references to the attributes; for deep copy, it recursively calls deepcopy on the attributes.

This works for simple data-holding classes, but it fails when your object manages an external resource, like a file handle or a network connection, that cannot or should not be copied directly. In these cases, you can take control by implementing special methods.

• __copy__(self): Defines the behavior for copy.copy().
• __deepcopy__(self, memo): Defines the behavior for copy.deepcopy(). The memo dictionary must be passed to any internal calls to deepcopy to prevent issues with circular references.

The following reading demonstrates a powerful, practical use case: a class that manages a file. The default copy behavior is incorrect, and the article walks you through implementing __copy__ and __deepcopy__ to provide correct, resource-aware semantics.

Conclusion

In this lesson, we have moved from the abstract world of memory management to the practical application of object and reference manipulation. A solid grasp of copying is non-negotiable for writing correct and predictable Python code, especially when dealing with the complex, mutable state common in production applications.

Here are the essential takeaways:

• Assignment is not copying: new_var = old_var creates another reference to the same object.
• Shallow Copy (copy.copy()): Creates a new top-level object but shares references to all nested objects. It's fast but can lead to unintended side effects if nested objects are mutable.
• Deep Copy (copy.deepcopy()): Creates a fully independent clone by recursively copying every object in the hierarchy. It's safer for nested mutable structures but is slower and uses more memory.
• Decision Rule: Use a shallow copy when your data structure is flat or contains only immutable objects. Use a deep copy whenever you have nested, mutable objects and need to guarantee that the original and the copy are fully decoupled.
• Customization: You can and should implement __copy__ and __deepcopy__ for your custom classes when they manage resources or require specific copying logic that differs from the default attribute-by-attribute duplication.

Our exploration of Python's object model continues. In the next lesson, we will examine object interning, a CPython optimization for small integers and strings. This will further deepen our understanding of the is vs. == distinction and reveal another layer of how Python manages objects in memory for efficiency.