In Python, Assignment statements do not copy objects, they create bindings between a target and an object. When we use
= operator user thinks that this creates a new object; well, it doesn’t. It only creates a new variable that shares the reference of the original object. Sometimes a user wants to work with mutable objects, in order to do that user looks for a way to create “real copies” or “clones” of these objects. Or, sometimes a user wants copies that user can modify without automatically modifying the original at the same time, in order to do that we create copies of objects.
A copy is sometimes needed so one can change one copy without changing the other. In Python, there are two ways to create copies :
- Deep copy
- Shallow copy
In order to make these copy, we use
copy module. We use
copy module for shallow and deep copy operations. For Example
In the above code, the
copy() returns a shallow copy of list and
deepcopy() return a deep copy of list.
Deep copy is a process in which the copying process occurs recursively. It means first constructing a new collection object and then recursively populating it with copies of the child objects found in the original. In case of deep copy, a copy of object is copied in other object. It means that any changes made to a copy of object do not reflect in the original object. In python, this is implemented using “deepcopy()” function.
The original elements before deep copying 1 2 [3, 5] 4 The new list of elements after deep copying 1 2 [7, 5] 4 The original elements after deep copying 1 2 [3, 5] 4
In the above example, the change made in the list did not effect in other lists, indicating the list is deep copied.
A shallow copy means constructing a new collection object and then populating it with references to the child objects found in the original. The copying process does not recurse and therefore won’t create copies of the child objects themselves. In case of shallow copy, a reference of object is copied in other object. It means that any changes made to a copy of object do reflect in the original object. In python, this is implemented using “copy()” function.
The original elements before shallow copying 1 2 [3, 5] 4 The original elements after shallow copying 1 2 [7, 5] 4
In the above example, the change made in the list did effect in other list, indicating the list is shallow copied.
The difference between shallow and deep copying is only relevant for compound objects (objects that contain other objects, like lists or class instances):
- A shallow copy constructs a new compound object and then (to the extent possible) inserts references into it to the objects found in the original.
- A deep copy constructs a new compound object and then, recursively, inserts copies into it of the objects found in the original.
Attention geek! Strengthen your foundations with the Python Programming Foundation Course and learn the basics.
To begin with, your interview preparations Enhance your Data Structures concepts with the Python DS Course.
- Difference between Shallow and Deep copy of a class
- NLP | Creating Shallow Tree
- MoviePy – Shallow copying Video File Clip
- Deep Neural net with forward and back propagation from scratch - Python
- Deep dive into Parameters and Arguments in Python
- Avengers Endgame and Deep learning | Image Caption Generation using the Avengers EndGames Characters
- Differential Privacy and Deep Learning
- Deep Learning with PyTorch | An Introduction
- NLP | Flattening Deep Tree
- Prediction of Wine type using Deep Learning
- Deep Q-Learning
- Implementing Deep Q-Learning using Tensorflow
- Human Activity Recognition - Using Deep Learning Model
- Residual Networks (ResNet) - Deep Learning
- ML - Saving a Deep Learning model in Keras
- Deep Convolutional GAN with Keras
- Deep Neural Network With L - Layers
- Image Caption Generator using Deep Learning on Flickr8K dataset
- Python | Difference between Pandas.copy() and copying through variables
- Python | Move or Copy Files and Directories