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.
- set copy() in python
- Python Dictionary copy()
- Python PIL | copy() method
- Python | Ways to Copy Dictionary
- Python | shutil.copy() method
- Python list | copy() method
- Python | Pandas Index.copy()
- numpy.ndarray.copy() in Python
- Python | Pandas TimedeltaIndex.copy
- Python | How to copy a nested list
- Python | Numpy matrix.copy()
- Python | How to copy data from one excel sheet to another
- Copy a directory recursively using Python (with examples)
- Python | Move or Copy Files and Directories
- Python | Pandas tseries.offsets.DateOffset.copy