Please help me understand this output. I don't get how Python handles Strings

Question

I expected a == b and not a is b.
But if a is b then I expected a is c+d.
At least a is e.
Did I miss a lesson?

https://code.sololearn.com/c1nRq9S5pMOb/?ref=app

Answer 1

That's what namespacing concept is all about.. To avoid memory wastage, python provides namespace. Since a and b has same values, they refer to same memory. It was designed in such a way,

For ex:-

I have a variable called 'a' which consists of value 10 which occupies some space in some random free memory location "200"(assume) .

Now, I defined another variable 'b' with same value 10. Now, Whenever python sees that stmt, it feels like the value 10 was already stored somewhere. So, no need to store it again, just refer that b to same memory location "200" (where 10 was previously stored).

Same concept here..

Hope you got it this time..!!

Answer 2

c and d are not tuples.

You need to write:

([stuff],)

Answer 3

https://realpython.com/courses/JUMP_LINK__&&__python__&&__JUMP_LINK-is-identity-vs-equality/

#hope this helps you

Answer 4

Frogged You missed HonFu's tutorial.

https://code.sololearn.com/c89ejW97QsTN/?ref=app

Answer 5

Frogged

quote from you: " .... but why do a and b have same id?
They are different variables."

quote from linked code: "A variable in Python is always only a 'reference' to the actual value."

Answer 6

I think the specifics went somehow like this:

For immutable objects, it doesn't matter if two similar objects are conflated to one.

So a Python version is permitted to do it whichever way. One version may conflate two similar objects in one memory location while another doesn't, and even within one version, depending on the context, conflation may happen or not.

This is something you aren't, as a user, supposed to care about. ;-)

For mutable objects however, a Python version has to guarantee that conflation never ever happens.

Answer 7

Hehe, I understand, we always want to know. :)

It might be one of these cases where you'd have to look into the source code.

In ALL the versions's source codes.

If you do all these tests with mutable objects, you should always get exactly the result you expect.

Answer 8

First, you should be very clear abt == and "is" operators and the concept called "Namespacing" . "==" compares the values irrespective of the memory they're located in, where as "is" operator results in True only when they're referring to same memory space.

Now, namespacing is something where if two variables are having same values,then they refer to same memory. It is one of the beautiful feature that is provided by python (avoids memory wastage).

Apply these concepts to the code written by you.
Since, variable 'a' and 'b' are having same values, they refer to same memory where as the memory location of 'c','d' and 'c+d' are totally different.

a = "Hello World"
b = "Hello World"
c = "Hello "
d = "World"
print(a == b,a is b,a== c+d,a is c+d)

print(id(c+d)," ",id(a)," ",id(b)) #140136967668016 140136967556272 140136967556272
You can figure it out yourselves by adding this line.

Answer 9

sarada lakshmi In short is checks identity of an object. Just like is equals methods in Java?

Answer 10

Mihai Apostol HonFu does not cover this part.
sarada lakshmi s explanation about namespacing although missing the very last step that lets me understand completely.

Answer 11

HonFu but I care about. 😇😇😇

I understood Python like this:
🤔🤔🤔🤔
Ohhh b is immutable lets see if this String is already in memory....ahhh yes. I won't waste memory space.

🤔🤔🤔🤔
Now e. Oh....it is an expression.... I must evaluate before I can decide...🤪nope I won't waste memory but also not time.

Answer 12

ok .... got it.
For all those who discusses with me and might be interested:

Python does not allocate new memory space at variable declaration, if an immutable object of same value is already in memory space.
The right side must not be an expression but a value.

Like so often:

It is a behaviour not of all immutable objects but hashable objects.
You can see in the last example, where tuples are immutable but not hashable.

Answer 13

HonFu yep fixed. But result is the same

Answer 14

As you are concatenating c and d and comparing it with a it is not valid because they aren't referred to same memory

#I am not a python programmer so after reading the article I have figured out this answer. Sorry if it is wrong

Answer 15

Atul it increases my confusion.
a and b are different objects.
But a is b.

Answer 16

The reason why this is the output is because, as you see the first three are true. a is b as “Hello World” is “Hello World”. However it is false for a is c+d as you have formed something new, which cant be identical as it is formed from two variables.

Hope this helps

Answer 17

https://youtu.be/mO_dS3rXDIs

#Frogged I hope this will definitely help you

Answer 18

sarada lakshmi
sure .... but why do a and b have same id?
They are different variables.
and why than not e...(I added it)

Answer 19

sarada lakshmi almost.....
After your explanation I would expect id(e)==id(a).
It also consists Hello World

Answer 20

Frogged Like the way you understand Python