CODEWITHSUNDEEP
pythondictionary
sans0909
sans0909

Reputation: 435

Python Dictionary copy method

I have question with dictionary copy method for example lets say i have

>> d = {'pears': 200, 'apples': 400, 'oranges': 500, 'bananas': 300}

>> copy_dict = d.copy()

Now if I check id's of both d and copy_dict, both are different

>> id(d)
o/p = 140634603873176

>> id(copy_dict)
o/p = 140634603821328

but if I check the id of objects in the dictionaries they are same meaning id(d['pears']) = id(copy_dict['pears'])

>> id(d['pears'])
o/p = 140634603971648
>> id (copy_dict['pears'])
o/p = 140634603971648

All objects in the new dict are references to the same objects as the original dict.

Now if I change the value of key 'pears' in d, there is no change in same key in copy_dict and when I check the id's now, id(d['pears']) != id(copy_dict['pears'])

>> d['pears'] = 700
>> print copy_dict['pears']
o/p = 200

My question is if the objects in the new dict are references to the same objects as the original dict why is the value of the new dict did not change when the value in the original dictionary got changed and how did Python immediately change the id's as soon as it saw the value changed?

Can you please give me full description of difference between deep and shallow copy?

Upvotes: 5

Views: 762

Answers (2)

tdelaney
tdelaney

Reputation: 77337

The reason is that you performed an assignment operation which replaces values, not a value modification operation. 

copy_dict = d.copy()

Caused a new dict to be created and its keys/values were initialized from d. You noted the important point - these are separate objects with different ids that just happen to reference the same keys and values.

d['pears'] = 700

removed the reference to 200 from d['pears'] and added a reference to 700. This reassignment was made on the d object itself so it naturally would not be seen by other dicts that were simply initialized by the same keys and values.

In contrast, supposed you had simply assigned the original dict to a second variable

copy_dict = d

Here, since both d and copy_dict reference the same dict, reassignment on that dict would be seen by both variables because they reference the same object.

Upvotes: 0

lciamp
lciamp

Reputation: 685

by changing the value, you are changing what the key is pointing at. Changing the value in the original dictionary isn't going to change what the key in the copy is pointing to.

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.

When you copy something it copies the original values of the object it is copying, but it creates a new object. It doesn't mirror the original object.

Upvotes: 2

Related Questions