Summary

The provided content discusses the concepts of shallow and deep copying in Python, explaining their differences, use cases, and implications for memory management and object independence.

Abstract

The article titled "Shallow Copy and Deep Copy in Python" delves into the nuances of object copying within Python. It begins by clarifying that the = operator in Python does not create a new object but rather a new reference to the existing object, which is particularly relevant for mutable objects like lists. The article introduces the copy module as a solution for creating independent copies of lists, distinguishing between shallow copy (copy.copy()) and deep copy (copy.deepcopy()). A shallow copy creates a new list but retains references to nested objects, while a deep copy recursively copies all nested objects, ensuring complete independence. The author emphasizes the importance of understanding these concepts for efficient memory usage and maintaining data integrity, especially when dealing with complex, nested data structures. The article concludes with a caution about the potential performance cost of deep copying large nested structures and directs readers to additional Python tutorials.

Opinions

The author suggests that using the = operator for assignment in Python is not suitable for creating independent copies of mutable objects.
The copy module is presented as a powerful tool for copying objects in a controlled manner, with the choice between shallow and deep copying depending on the programmer's needs.
Shallow copying is seen as an efficient method for copying the first level of a nested object, balancing the need for independence with performance considerations.
Deep copying is recommended when a complete, independent copy of an object with nested structures is necessary, despite the associated computational cost.
The article implies that Python's design philosophy prioritizes efficiency, as evidenced by the default pass-by-reference assignment and the "lazy" performance of shallow copying.
The author provides a practical tip to avoid using deep copying on large objects to prevent performance degradation, indicating a concern for computational efficiency.
A promotional opinion is included at the end, recommending an AI service that offers similar capabilities to ChatGPT Plus (GPT-4) at a lower cost, suggesting a value-for-money perspective.

Shallow Copy and Deep Copy in Python

Introduction

As we all know, the = operation in Python means passing by reference. Simply put, it means giving a new name to the object. For a mutable object, such as a list, we can modify it by any of its name.

As the above example shown, B and A are both references to the list, so when we modified the list by B , the A was changed as well.

Now, there is a question: how to copy the list from A to B? In other words, how to modify B without affecting the values of A ?

It’s the best time to know the copy module in Python!

Shallow Copy

The copy module in Python helps us copy objects more flexible. Let’s look an example:

As the above example shown, we can use B = A.copy() or B = copy.copy(A) to implement the copy operation. After that, B and A are independent with each other. We can modify B without affecting A .

How it Works?

The above figure demonstrate all secrets.

The assignment statement did not really create a new list in memory address, it just created a new reference B for the list. In other words, A and B are two references for the same list. Therefore, no matter you modify A or B, you modify the same list.

The copy function really created a new list with the same value of the original list. Therefore, you can modify A or B independently.

Why does the Shallow Mean?

The B = A.copy() or B = copy.copy(A) are both shallow copy. “Shallow” means they can’t create a 100% copy of nested objects, instead it just copies the first level of the nested objects. For example:

Now, the list has two level. The above results show that the first level was copied, but the second level was still assigned by reference. When we modified B[0] , the A[0] was changed as well.

In a nutshell, the copy.copy() function only applies to the first level of a nested object. The deep levels are still assigned by reference.

This “lazy” performance can improve the efficiency of copy operations and it conforms to Python’s design philosophy. Because the copy method needs to create new lists, which costs time.

However, what can we do if we really want a totally copy operation?

Deep Copy

We can use copy.deepcopy() to copy a nested object completely no matter how many nested levels of it.

As the above example shown, no matter how we modified B , A will never be affected. Because the B is a 100% copy of A , there is no assignment by reference in a deepcopy() operation.

Note: Because a deepcopy() operation always totally copies all nested objects, it will cost lots of time if the objects are too large.

Conclusion

In order to improve the efficiency, the = operation in Python is designed to pass by reference rather than by value. If we really need to copy objects (pass by value), we should use the copy.copy() method for shallow copy or the copy.deepcopy() method for deep copy. We must be careful when using deepcopy() for large objects, cause it costs lots of time.

Thanks for reading, more Python tutorials are here:

The Ultimate Python Tutorial (Keep Updating)

The most valuable Python Tutorial you should save!

medium.com