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[0]) == id(d[0])    # True - d[0] is the same object as c[0]

Using a shallow copy:

    d = copy.copy(c)

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

Using a deep copy:

    d = copy.deepcopy(c)

    print id(c) == id(d)          # False - d is now a new object
    print id(c[0]) == id(d[0])    # False - d[0] is now a new object

From: stackoverflow.com/q/17246693

Back to homepage or read more recommendations: