# Fix Python – What is the difference between shallow copy, deepcopy and normal assignment operation?

## Question

Asked By – deeshank

``````import copy

a = "deepak"
b = 1, 2, 3, 4
c = [1, 2, 3, 4]
d = {1: 10, 2: 20, 3: 30}

a1 = copy.copy(a)
b1 = copy.copy(b)
c1 = copy.copy(c)
d1 = copy.copy(d)

print("immutable - id(a)==id(a1)", id(a) == id(a1))
print("immutable - id(b)==id(b1)", id(b) == id(b1))
print("mutable - id(c)==id(c1)", id(c) == id(c1))
print("mutable - id(d)==id(d1)", id(d) == id(d1))
``````

I get the following results:

``````immutable - id(a)==id(a1) True
immutable - id(b)==id(b1) True
mutable - id(c)==id(c1) False
mutable - id(d)==id(d1) False
``````

If I perform deepcopy:

``````a1 = copy.deepcopy(a)
b1 = copy.deepcopy(b)
c1 = copy.deepcopy(c)
d1 = copy.deepcopy(d)
``````

results are the same:

``````immutable - id(a)==id(a1) True
immutable - id(b)==id(b1) True
mutable - id(c)==id(c1) False
mutable - id(d)==id(d1) False
``````

If I work on assignment operations:

``````a1 = a
b1 = b
c1 = c
d1 = d
``````

then results are:

``````immutable - id(a)==id(a1) True
immutable - id(b)==id(b1) True
mutable - id(c)==id(c1) True
mutable - id(d)==id(d1) True
``````

Can somebody explain what exactly makes a difference between the copies? Is it something related to mutable & immutable objects? If so, can you please explain it to me?

Now we will see solution for issue: What is the difference between shallow copy, deepcopy and normal assignment operation?

Normal assignment operations will simply point the new variable towards the existing object. The docs explain the difference between shallow and deep copies:

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.

Here’s a little demonstration:

``````import copy

a = [1, 2, 3]
b = [4, 5, 6]
c = [a, b]
``````

Using normal assignment operatings to copy:

``````d = c

print id(c) == id(d)          # True - d is the same object as c
print id(c) == id(d)    # True - d is the same object as c
``````

Using a shallow copy:

``````d = copy.copy(c)

print id(c) == id(d)          # False - d is now a new object
print id(c) == id(d)    # True - d is the same object as c
``````

Using a deep copy:

``````d = copy.deepcopy(c)

print id(c) == id(d)          # False - d is now a new object
print id(c) == id(d)    # False - d is now a new object
``````

This question is answered By – grc

This answer is collected from stackoverflow and reviewed by FixPython community admins, is licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0