Copy - Shallow and deep copy operations in Python

In Python a variable is just a reference to object. Hence when it is assigned to another variable, it doesn’t copy the object, rather it acts as another reference to same object. This can be verified by using id() function

>>> L1 = [1,2,3]
>>> L2 = L1
>>> id(L1), id(L2)
(2165544063496, 2165544063496)

Result of above code shows that id() for both list objects is same, which means both refer to same object. The L2 is said to be a shallow copy of L1. Since both refer to same object, any change in either will reflect in other object.

>>> L1 = [1,2,3]
>>> L2 = L1
>>> L2[1] = 100
>>> L1,L2
([1, 100, 3], [1, 100, 3])

In above example, item at index no. 1 of L2 is changed. We see this change appearing in both.

When an entirely new object is created with the copying operation, with copies of nested objects too are recursively added to it, the copy is called deep copy.

The copy module of Python standard library provides two methods:

• copy.copy() – creates a shallow copy
• copy.deepcopy() – creates a deep copy

A shallow copy creates a new object and stores the reference of the original elements but doesn't create a copy of nested objects. It just copies the reference of nested objects. As a result, copy process is not recursive.

>>> import copy
>>> L1 = [[1,2,3], [4,5,6]]
>>> L2 = copy.copy(L1)
>>> L1,L2
([[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]])
>>> L2.append([10,10,10])
>>> L1,L2
([[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6], [10, 10, 10]])

Here L1 is a nested list and L2 is its shallow copy. Although reference to parent list object is copied into L2, its nested elements are not copied. Hence, when we append another list to L2, it is not reflected in L1

However, if we try to modify an element in child element, its effect will be seen in both lists

>>> L1 = [[1,2,3], [4,5,6]]
>>> L2 = copy.copy(L1)
>>> L1,L2
([[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]])
>>> L2[1][0] = 100
>>> L1,L2
([[1, 2, 3], [100, 5, 6]], [[1, 2, 3], [100, 5, 6]])

A deep copy however, creates a new object and recursively adds the copies of nested objects too, present in the original elements.

In following example, L2 is a deep copy of L2. Now if we change any element of inner list, this will not show in other list.

>>> L1 = [[1,2,3], [4,5,6]]
>>> L2 = copy.deepcopy(L1)
>>> L1,L2
([[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]])
>>> L2[1][0] = 100
>>> L1,L2
([[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [100, 5, 6]])

Effect of deep copy is thus verified by the output.

Nitya Raut

Published on 16-Apr-2019 11:41:10

• Related Questions & Answers
• Python Shallow and Deep Copy operations
• Deep Copy and Shallow Copy in Java
• What is the difference between shallow copy and deep copy in Java?
• What is Shallow Copy and how it is different from Deep Copy in C#?
• Return a shallow copy of IdentityHashMap in Java
• How to shallow copy the objects in JavaScript?
• Deep Copy of Struct Member Arrays in C
• How would you deep copy an Object in Javascript?
• What is shallow copy? Explain with an example in Java.
• How to create a shallow copy of Hashtable in C#?
• How to create a shallow copy of ArrayList in C#?
• What is deep copy? Explain with an example in Java.
• How to create a shallow copy of the BitArray in C#?
• How to create a shallow copy of SortedList Object in C#?
• set copy() in python