Shallow And Deep Copy Operations in Python

In the world of Python programming, there is a common concept that often trips up newcomers: the difference between Shallow and Deep Copy Operations in Python. While both terms sound similar, they have distinct meanings and use cases that every Python developer should understand.

 

Shallow Copy: When you create a shallow copy of an object, you’re essentially creating a new object that references the original elements. In other words, the copied object is a separate entity, but its contents (such as lists or dictionaries) still point to the same memory locations as the original object.

 

Deep Copy: On the other hand, a deep copy creates a new object and recursively copies all nested objects within it. In simple terms, a deep copy duplicates everything, including the nested objects, so that the copied object is entirely independent of the original.

 

Why Do We Need Them?

Understanding the difference between shallow copy and deep copy is crucial for managing data structures, especially when dealing with complex objects like lists of lists or dictionaries of dictionaries.

 

Shallow Copy Use Cases:

• Creating a Modifiable Copy: Shallow copies are useful when you want to create a modified version of an object without altering the original.
• Sharing Data Structures: When you need multiple objects to share the same data structure, but still be independent entities, shallow copies come in handy.

 

For Free, Demo classes Call: 02071171500

Registration Link: Click Here!

 

Deep Copy Use Cases:

 

• Preventing Unintended Side Effects: Deep copies are essential when you want to ensure that modifying the copied object doesn’t affect the original or vice versa.
• Working with Nested Objects: Deep copies are necessary when dealing with deeply nested data structures, ensuring that each level of nesting is duplicated properly.

 

In Python, you can use the copy module to perform shallow and deep copies.

 

import copy

 

# Original List

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

 

# Shallow Copy

shallow_copied_list = copy.copy(original_list)

 

# Deep Copy

deep_copied_list = copy.deepcopy(original_list)

 

# Modify the original list

original_list.append(6)

original_list[2].append(7)

 

print(“Original List:”, original_list)

print(“Shallow Copied List:”, shallow_copied_list)

print(“Deep Copied List:”, deep_copied_list)

 

# Output:

# Original List: [1, 2, [3, 4, 7], 5, 6]

# Shallow Copied List: [1, 2, [3, 4, 7], 5]

# Deep Copied List: [1, 2, [3, 4], 5]

 

In this example:

 

• We create an original list [1, 2, [3, 4], 5].
• We make a shallow copy of the original list using copy.copy(), resulting in shallow_copied_list.
• We make a deep copy of the original list using copy.deepcopy(), resulting in deep_copied_list.
• We then modify the original list by appending 6 to it and appending 7 to the nested list [3, 4].
• We print out all three lists to see the effects of the modifications.

 

As you can see from the output:

 

• The changes made to the original list reflect in the shallow copied list because shallow copy only creates a new list object, but still refers to the same nested list object [3, 4].
• The changes made to the original list do not reflect in the deep copied list because deep copy creates a completely independent copy of all nested objects.

 

Conclusion:

Understanding the distinction between deep copy and shallow copy is crucial for writing robust Python code, especially when dealing with complex data structures. By knowing when to use each type of copy, you can prevent bugs, ensure data integrity, and write more maintainable code.

 

Do watch our Channel to learn more: Click Here

Author:

Karishma Pawar

Call the Trainer and Book your free demo Class For Python Call now!!!
| SevenMentor Pvt Ltd.

© Copyright 2021 | SevenMentor Pvt Ltd.