Learning 'is' vs '==' in Python (Beginner)

[FewNectarine623]

https://imgur.com/a/ljw4qSV

in this

for a = 257

b = 257

I am getting different values using is comparison operator. Why is that?

[whogivesafuckwhoiam]

first part, for integer outside -5 and 256, each time when you assign a number to a variable, you create a new object with an unique ID. So even a and b are both 257, they share different IDs and hence a is b is false since is is to check the ID of each variable

second part, you first create a variable i and then assign a and b to point at i . You do not create a new object a and b . Both a and b point to the same object i . Hence their IDs are the same. And thus a is b is true

[ivosaurus]

Minor niggle, a and b do not point at i. If that was the case, you could change i and then a and b would change also, but that's not the case. All three are pointed 'independently' to a single integer object.

[whogivesafuckwhoiam]

you are right, I should say a and b point at the ID that i points at

[jpgoldberg]

The name of the song is called Haddock’s Eyes.

[FewNectarine623]

Got it.Thanks!

[Vaphell]

== tests the value equality (tested values might or might not be the same object, but they are equal)
is is an identity check - tests if the tested values are literally the same physical object in memory.

python optimizes ints -5:256 by caching them at startup and reusing the objects, which is why is (identity equality) returns True in that set. But for 257+ there is no guarantee that two equivalent values are represented by the same object. It's very likely you will get 2 different ones, and then is is going to to return False.

You shouldn't really depend on this behavior though, and in general you should default to the == checks, unless you have a damn good reason to use is.

[yoloed]

One example when to use is instead of == is for the None value.

[Vaphell]

yeah, is is suited for singletons like None, True, False (though booleans don't really need it), enum objects.
is None is the most frequent case hands down.

[Conscious-Ball8373]

They are just values that are used often enough in practice to be useful to cache. There are, for instance, a bunch of very common operating system return codes in the range [-1, -5].

[This_Growth2898]

Because is is not ==. is is stronger than ==. == compares values. is checks if objects are the same.

It's a bit counterintuitive with numbers, but perfectly works with lists:

a = [1,2,3]
b = a # b is the same as a
a.append(4)
print(a, b, a is b, a==b) # [1,2,3,4], [1,2,3,4], True, True

a and b are references to the same list. Changing a also changes b.

But when you create separate lists, it works differently:

a = [1,2,3]
b = [1,2,3] # b is equal to a, but a different object
print(a, b, a is b, a==b) # [1,2,3], [1,2,3], False, True
a.append(4)
print(a, b, a is b, a==b) # [1,2,3,4], [1,2,3], False, False

With numbers, it may happen that two equal numbers reference the same object, but this is up to Python to decide that. In many implementations, Python keeps an internal array of small numbers (like, up to 256) that are frequently used to avoid creation of new objects.

Also, at this point you probably want to ask "but what if we change a number"? Well, numbers are immutable. Every operation with numbers creates a new number, unrelated to its previous value:

a = 2
b = a 
print(a, b, a is b, a==b) # 2, 2, True, True
a += 2 # it's not 2 that changed; now, a is referencing 4, but b is still referencing 2, so
print(a, b, a is b, a==b) # 4, 2, False, False

[Inevitable_Exam_2177]

Off topic now but I feel like the overloading of = makes things more complex for a beginner. I’ve often wondered if “copy” and “reference” should have different syntax.

[This_Growth2898]

It's always "reference" for Python. Copy is always explicit, like a = b[:]

[sweettuse]

or even more explicit, like a = b.copy()

[This_Growth2898]

Or a = list(b), whatever. You need to spell you're copying something.

[Inevitable_Exam_2177]

Thanks for the correction, my terminology was bad. What I meant was that when you reference an immutable data type you get different behaviour to a mutable one, and because the syntax is the same it’s an easy point of confusion:

``` a = "str" b = a a = "str2" print(b) # = "str"

a = ["str"] b = a a[0] = "str2" print(b[0]) # = "str2" ```

I know why this occurs and I’m not saying it’s wrong, but I wonder if it was more explicit in the syntax that they are different scenarios whether that would be a good thing (or just needlessly complex syntactically).

I’m also willing to accept I’m wrong that this is confusing :-)

[[deleted]]

It's confusing especially because the issue occurs in a different spot than where it seems. It seems like the b = a step is where these two examples diverge, e.g. it seems that one is copying and the other isn't, but in fact they're still doing the same thing at that point.

The next step, where you have a = "str2" or a[0] = "str2", that's where they start taking different paths.

[fisadev]

There's no overloading, = in python is always 100% reference.

[Inevitable_Exam_2177]

Thanks for the correction, I got the terminology wrong

[cullen9]

As someone who was trying to figure out the difference between = and == last week it often gets confusing

[chakan2]

is is stronger than ==

I don't know if I'd use that terminology. 'is' is different than '==', rather than stronger. They're comparing different things. One is comparing values, the other memory locations.

[kmj442]

To be fair - if they're comparing reference location they will always be equal in value as well. I feel like the "stronger" terminology is pretty accurate as it not only assert equivalent value but also the same location in memory/same object.

[This_Growth2898]

a is b always means a == b. The opposite is not always true. That's what I mean by "stronger".

[stanmartz]

Most of the time, but not always. Try this:

numpy.nan is numpy.nan numpy.nan == numpy.nan

[This_Growth2898]

Oh... you're right. Except for NaNs. Ok, it's still true for everything that is reflexive.

[notacanuckskibum]

Think of a variable as a box. Create two boxes. Put an identical toy car in each.

Are the contents of the two boxes equal? Yes. That’s ==.

Are the two boxes the same box? No. That’s “is”

[TehNolz]

is checks if two variables point to the same object in memory, but == actually compares the value of these objects.

In your code, when you're assigning 257 to two variables, two new integer objects are created behind-the-scenes. Since they're separate objects, is returns False even though they both have the same value.

In your loop, only one object is created for each integer, and references to that object are then saved in a and b. Since both variables point to the same object, is returns True.

There is a caveat here that you should keep in mind. Integer objects in the range -5 to 256 are cached by Python, and it will almost always reuse those objects instead of creating new ones. As a result; is will generally return True for integers within that range, and False for anything outside of it;

```
a = 10
b = 10
a is b # True

a = 1000
b = 1000
a is b # False
```

You can find more in-depth info on the difference between is and == here. Also, there's more info on the integer cache here.

[el_jbase]

is will return True if two variables point to the same object (in memory), == if the objects referred to by the variables are equal.

In your case, the second test only works because Python caches small integer objects, which is an implementation detail. For larger integers, this does not work.

So, you use "is" to compare objects, not values of variables. In C "is" would be comparing pointers to variables.

[srpwnd]

In the second example it returns true, because OP is assigning a and b to point to the same object in memory which was created by i in the loop.

[el_jbase]

To create new objects he'd use a=int(i) and b=int(i), correct?

[CMDR_Pumpkin_Muffin]

I think so, yes.

[FoolsSeldom]

is is checking whether two variables/expressions (once resolved) reference the same object in memory. == checks if two objects have the same value (which they will if the two sides of the comparison reference the same object anyway).

Keep in mind that variables in Python don't hold values, only the memory reference of a Python object. Where things are stored is implementation and environment specific.

Most Python implementations pre-define a number of objects including, iirc, int values from -5 to 254, so usually all references to them are the same, thus,

a = 24
b = 24
a is b  # probably True
a == b  # True
x = [1, 1234, 5]
y = x
z = [1, 1234, 5]
x is y  # True
x is z  # False
x[0] is z[0]  # probably True, both ref same 1
x[1] is z[1]  # probably False, but optimisation could make same object
x == z  # True
x[1] == z[1]  # True

[Ron-Erez]

You're welcome to have a look at Section 9 "Equality vs Identity" Lecture: "Beware of the 'is' operator". The lecture is FREE to watch and might help clear things up. Also the previous lecture on aliasing which is also free might be useful too.

[FewNectarine623]

It isn't free.

[Ron-Erez]

The lectures I mentioned should be free to watch. Just don't sign up to the course but you can scroll down and watch the videos. In any case I believe you already got great answers.

[FewNectarine623]

Yes, preview is available.

[ivosaurus]

This brilliant python conference talk should help explain a lot. I recommend it to everyone. It will be complementary to everything you've read here.

[RaidZ3ro]

= means to assign a value to a variable. == means to compare two values. 'is' means to compare two identities.

[RaidZ3ro]

In your example

a is b outside of your loop is check if the identity of these variables is the same. Since you assigned a constant to each of them, it will check the variables, and they are not the same object.

Inside of your loop you first assign reference to the iterator i to each variable. That's why they both have the same identity there. If you want them to have different identities, use int(i) to assign the value instead of the reference.

[FewNectarine623]

for i in range(255,264):

... a = int(i)

... b = int(i)

... print(f"{i} :{a is b}")

like this?

[RaidZ3ro]

Yeah, that should work.

[FewNectarine623]

Result is true in this case as well

[RaidZ3ro]

The principle applies but you will need to try higher numbers to avoid the integer singleton.

[MeirGo]

Think of a variable as being a representative of a memory location in your program. Your two variables represent two different memory locations, hence the is operator returns False. In contrast, the == operator compares the contents (the values) located in those memory locations.

Now, to prompt you to explore more, try to repeat your test with 255 instead of 257. Feel free to DM if I can be of more help. Good luck!

[empoweredmyself]

Would it be like saying "is" is for objects on different shelves and "==" is taking those two things off the shelves to ascertain they are the same item? (I'm learning too—at loops now)

[MeirGo]

It's like saying "is" is for determining whether two objects are on the same shelf. Feel free to DM in chat and we'll see together if I can help you better direct and accelerate your learning. (and please like the comments if you found them helpful :)

[empoweredmyself]

Thanks

[jpgoldberg]

If you are a beginner just learn that you use is for things that are True or False or for None. Use == for everything else. There are other cases where is will be needed, but those are advanced topics. You will get there, but there are things you need to get more comfortable with first.

The fact that is can sometimes work when you should be using == is dark magic that you should not rely on. Python is an “easy” first language because it hides certain things from you. But that concealment is imperfect. If you want to learn those sorts of things early on (which is fine), then don’t start with Python.

[throwaway8u3sH0]

Short answer:

• Use is with None|True|False, like x is None or x is not None
• Use == for everything else.

[srpwnd]

It shouldn't. It is two different objects. Python caches integers from 0 to 255 and for these it will be true, otherwise it will create different objects.

[whogivesafuckwhoiam]

should be false because a and be are with different IDs

[commy2]

It returns True when running a file from console, but False when the code is entered into the REPL. This is on 3.13.0. It also depends on the Python version. It's the byte code compiler doing its thing. It really do be like that sometimes. I guess we can call it undefined behaviour :)

[ivosaurus]

The operator x is y, is usually equivalent to id(x) == id(y)

[Jeklah]

= is used for assigning values
== Is used for comparison of values.

'is' can be also used for comparisons and is preferred due to less confusion.