What is the use of the "copy.deepcopy" function in Python?

Question

Jayant Kumar · Accepted Answer

Table of Contents
Introduction
When working with complex or nested objects in Python, simply copying an object might not be enough if you need to ensure that changes in the copied object don’t affect the original. This is where Python’s copy.deepcopy function comes in. It creates a deep copy of an object, ensuring that all nested objects are fully independent from the original.
What is copy.deepcopy()?
1. Definition of **copy.deepcopy()**
The copy.deepcopy() function in Python creates a deep copy of the given object. Unlike a shallow copy (which copies only references to nested objects), a deep copy duplicates both the object and all objects it references. This ensures that changes to the copied object do not affect the original object.

Syntax:
import copy
deep_copied_object = copy.deepcopy(original_object)

2. How deepcopy Works
copy.deepcopy() recursively copies all objects within the original object. This includes any nested objects like lists, dictionaries, or custom objects, making them entirely independent from the original structure.
import copy

# Example: Using copy.deepcopy() for deep copy
original_list = [[1, 2, 3], [4, 5, 6]]
deep_copy_list = copy.deepcopy(original_list)

# Modifying the inner list in the deep copy
deep_copy_list[0][0] = 10

print("Original:", original_list)  # Output: [[1, 2, 3], [4, 5, 6]]
print("Deep Copy:", deep_copy_list)  # Output: [[10, 2, 3], [4, 5, 6]]

In the above example, changing the inner list of the deep copy does not affect the original list because deepcopy creates an entirely new copy of all nested objects.
Key Features of copy.deepcopy()

Full Independence: All nested objects and references are copied, creating a new object tree. Any changes to the copied object will not affect the original object and vice versa.
Handling of Mutable Objects: The function is particularly useful when dealing with mutable objects (e.g., lists, sets, dictionaries) that contain nested mutable elements.
Performance Consideration: Because deepcopy recursively duplicates all objects, it can be slower and more memory-intensive compared to a shallow copy. Therefore, it should be used when necessary to avoid unintended side effects.

Practical Examples of copy.deepcopy()
1. Copying Nested Lists or Dictionaries
When working with deeply nested lists or dictionaries, copy.deepcopy() ensures that modifications to one copy do not affect the other.
# Example: Deep copying a nested dictionary
original_dict = {
    "user": {"name": "Alice", "age": 25},
    "preferences": {"theme": "dark", "notifications": True}
}
deep_copy_dict = copy.deepcopy(original_dict)

# Modifying the deep copy
deep_copy_dict["user"]["name"] = "Bob"

print("Original:", original_dict)  # Output: {'user': {'name': 'Alice', 'age': 25}, 'preferences': {'theme': 'dark', 'notifications': True}}
print("Deep Copy:", deep_copy_dict)  # Output: {'user': {'name': 'Bob', 'age': 25}, 'preferences': {'theme': 'dark', 'notifications': True}}

2. Deep Copying Custom Objects
When copying instances of user-defined classes, copy.deepcopy() ensures that every instance attribute is copied independently, even if they are references to other objects.
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

original_person = Person("Alice", 25)
deep_copy_person = copy.deepcopy(original_person)

# Modifying the deep copy
deep_copy_person.name = "Bob"

print(original_person.name)  # Output: Alice
print(deep_copy_person.name)  # Output: Bob

Conclusion
The copy.deepcopy() function in Python is an essential tool for creating fully independent copies of complex objects. It ensures that all nested objects and references are copied, preventing any unintended changes from propagating between the original and copied objects. Use deepcopy when working with deeply nested or mutable objects where independence between copies is crucial.

What is the use of the "copy.deepcopy" function in Python?

Table of Contents

Introduction

What is `copy.deepcopy()`?

1. Definition of `copy.deepcopy()`

2. How `deepcopy` Works

Key Features of `copy.deepcopy()`

Practical Examples of `copy.deepcopy()`

1. Copying Nested Lists or Dictionaries

2. Deep Copying Custom Objects

Conclusion

Similar Questions