Why does "hello" is "hello" produce True in Python?
I read the following here:
If two string literals are equal, they have been put to same
memory location. A string is an immutable entity. No harm can
be done.
So there is one and only one place in memory for every Python string? Sounds pretty strange. What’s going on here?
Answers:
Thank you for visiting the Q&A section on Magenaut. Please note that all the answers may not help you solve the issue immediately. So please treat them as advisements. If you found the post helpful (or not), leave a comment & I’ll get back to you as soon as possible.
Method 1
Python (like Java, C, C++, .NET) uses string pooling / interning. The interpreter realises that “hello” is the same as “hello”, so it optimizes and uses the same location in memory.
Another goodie: "hell" + "o" is "hello" ==> True
Method 2
So there is one and only one place in memory for every Python string?
No, only ones the interpreter has decided to optimise, which is a decision based on a policy that isn’t part of the language specification and which may change in different CPython versions.
eg. on my install (2.6.2 Linux):
>>> 'X'*10 is 'X'*10 True >>> 'X'*30 is 'X'*30 False
similarly for ints:
>>> 2**8 is 2**8 True >>> 2**9 is 2**9 False
So don’t rely on ‘string’ is ‘string’: even just looking at the C implementation it isn’t safe.
Method 3
Literal strings are probably grouped based on their hash or something similar. Two of the same literal strings will be stored in the same memory, and any references both refer to that.
Memory Code ------- | myLine = "hello" | / |hello < | | myLine = "hello" -------
Method 4
The is operator returns true if both arguments are the same object. Your result is a consequence of this, and the quoted bit.
In the case of string literals, these are interned, meaning they are compared to known strings. If an identical string is already known, the literal takes that value, instead of an alternative one. Thus, they become the same object, and the expression is true.
Method 5
The Python interpreter/compiler parses the string literals, i.e. the quoted list of characters. When it does this, it can detect “I’ve seen this string before”, and use the same representation as last time. It can do this since it knows that strings defined in this way cannot be changed.
Method 6
Why is it strange. If the string is immutable it makes a lot of sense to only store it once. .NET has the same behavior.
Method 7
I think if any two variables (not just strings) contain the same value, the value will be stored only once not twice and both the variables will point to the same location. This saves memory.
All methods was sourced from stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0