Shallow & Deep Copy in Python

Friendly Python

In Python, copying objects is a common operation when working with mutable data structures like lists, dictionaries, and custom objects. Python offers two types of copying techniques: shallow copy and deep copy. Understanding the difference between these techniques is crucial to avoid unexpected behavior and ensure data integrity. In this article, we will delve into the concepts of shallow copy and deep copy, explore their implementation in Python, and learn when to use each technique effectively.

Shallow Copy basic Concept :

Shallow copy creates a new object but references the existing elements of the original object. In other words, it creates a new container object but keeps the references to the elements inside. Any changes made to the elements of the new object will affect the original object as well.

Deep Copy basic Concept :

Deep copy creates a completely independent copy of the object and its elements. It recursively copies all nested objects, ensuring that any modifications made to the new object do not affect the original object or its elements.

Shallow Copy in detail :

In Python, the copy module provides the copy() function to perform shallow copy operations.

Here's an example:

              
                
                  import copy

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

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

In this example, a shallow copy of the original_list is created using copy.copy(). Both the original and shallow copy lists are modified when an element is appended to the nested list.

Deep Copy in detail :

The copy module also provides the deepcopy() function to perform deep copy operations.

Here's an example:

              
                
                  import copy

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

                  original_list[2].append(5)
                  print(original_list)      # Output: [1, 2, [3, 4, 5]]
                  print(deep_copy_list)     # Output: [1, 2, [3, 4]]

In this example, a deep copy of the original_list is created using copy.deepcopy(). Even after modifying the original list, the deep copy remains unaffected.

Where to use Shallow Copy and Deep Copy :

The choice between shallow copy and deep copy depends on the specific requirements of your code.

Consider the following guidelines:

Shallow Copy:
- Use shallow copy when we need a new object that shares references to the elements of the original object.
- Shallow copy is suitable when we want to create a lightweight copy or when the elements are immutable.
- Be cautious when modifying the elements of a shallow copy, as it affects the original object.

Deep Copy:
- Use deep copy when we need a completely independent copy of the object, including all its nested objects.
- Deep copy is necessary when we want to modify the copied object without affecting the original object or its elements.
- Deep copy is ideal for handling complex data structures or when the elements of the object are mutable.

Performance Considerations :

It's important to note that deep copy operations can be slower and consume more memory compared to shallow copy operations. If performance is a concern and we don't require a completely independent copy, we should consider using a shallow copy.

Nested Objects and Copying Behavior :

When performing copy operations, it's crucial to understand the behavior of nested objects. Both shallow copy and deep copy operations are recursive and ensure the integrity of nested objects based on the chosen copy technique.