# What exactly is the difference between shallow copy, deepcopy and normal assignment operation?

```    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?

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
```

From: stackoverflow.com/q/17246693