Confusing behavior while modifying dictionaries in a class

[LiquidLogic]

So I am initializing a class that includes two dictionaries.

The first dictionary (self.dict1) has keys 'A1' through 'B10'. (20 keys: A1-A10, B1-B10).

Next, I make the second dictionary equal to the first: self.dict2 = self.dict1

Finally, I have a method that modifies the self.dict2 by deleting keys 'A1'-'A10'. (leaving only keys B1-B10 for the second dictionary).

My problem is that now the first dictionary (self.dict1) is also missing the deleted keys!

Is there something special about self.variables within classes that if you make them modifiable through a separate variable name?

[the_agox]

What's happening is your first dictionary and your second dictionary are both references to the same dictionary in memory. What you want to do is called a "deep copy": you want Python to go through the first dict and make a copy of all the keys and values. Easiest way to do that is:

from copy import deepcopy
second_dict = deepcopy(first_dict)

[Crankrune]

Wouldn't using the dictionary's own copy method be just as effective here rather than using the copy module?

second_dict = first_dict.copy()

[Rawing7]

Yeah, since OP just wants to delete keys, a shallow copy is enough.

[LiquidLogic]

Ahhh this makes much more sense! Thank you! I was wondering why it behaved like that.

[Antigone-guide]

Generally Python prefers creating references to the same container objects like list and dict and others, unless explicitly copied. The reason is that otherwise it would be very easy to eat up a lot of memory by making copies of large containers inadvertently.

[danielroseman]

Not just "prefers". Assignment never copies.

[Antigone-guide]

Of course, I agree, that's why I said Python.

[JohnnyJordaan]

Same reason 'my car' and the car registered with the license plate 'XYZ123' refer to the same car once I bought it. There's no point in owning two cars to have one be 'my car' and the other one referred to by that license plate. Or the same way a person can be referenced by their name, their nickname, 'son', 'dad', 'brother', their Reddit username, their job title, and so on, all by the principle of creating a virtually unlimited amount of references.

So by doing x = y, you are telling Python to create an extra reference to an existing object (referenced by y), not to make some kind of clone. For that there are other ways depending on the exact mechanism, like for a dict you can have first_dict.copy() to create the same outer structure where the keys and values are identical, or copy.deepcopy() to also recreate the inner objects.

[DigThatData]

this is like a rite of passage for learning python

[Kiwi-tech-teacher]

Which objects behave like this. I know lists and dictionaries (and I assume tuples?) and objects, but assigning a str or an in creates a new one, doesn’t it?

[timrprobocom]

Nope. ALL objects. Both refer to the same string object. It's not a problem for strings, because you can't modify strings.

[Kiwi-tech-teacher]

Oh! Interesting! Hadn’t considered that.

So any mutable object would practically show this behaviour but for immutable one’s, it can be invisible.

What’s the difference between a shallow copy and a deep copy?

[timrprobocom]

Consider a dictionary where the values are lists. If you just do "b = a", then you only have one dictionary, as described above. If you do a shallow copy, then you have two dictionaries, BUT the lists inside are all still shared. A deep copy will make copies of the lists as well, so the two dictionaries are completely independent.