这取决于你要看的是两个物体是否相等，还是同一个物体。

是检查它们是否是相同的对象，而不仅仅是相等。较小的int可能指向相同的内存位置以提高空间效率

In [29]: a = 3
In [30]: b = 3
In [31]: id(a)
Out[31]: 500729144
In [32]: id(b)
Out[32]: 500729144

您应该使用==来比较任意对象的相等性。你可以用__eq__和__ne__属性来指定行为。

正如你可以检入源文件inobject .c一样，Python缓存小整数以提高效率。每次创建对小整数的引用时，引用的都是缓存的小整数，而不是新对象。257不是一个小整数，所以它是作为一个不同的对象计算的。

为了这个目的，最好使用==。

还有一个问题，在现有的任何答案中都没有指出。Python允许合并任何两个不可变的值，并且预先创建的小int值并不是发生这种情况的唯一方式。Python实现从来不保证这样做，但它们都不仅仅是对小int型进行这样做。

首先，还有一些其他预先创建的值，比如空元组、str和bytes，以及一些短字符串(在CPython 3.6中，它是256个单字符Latin-1字符串)。例如:

>>> a = ()
>>> b = ()
>>> a is b
True

但是，即使非预先创建的值也可以是相同的。考虑以下例子:

>>> c = 257
>>> d = 257
>>> c is d
False
>>> e, f = 258, 258
>>> e is f
True

这并不局限于int值:

>>> g, h = 42.23e100, 42.23e100
>>> g is h
True

显然，CPython没有为42.23e100提供预先创建的浮点值。那么，这里发生了什么?

CPython编译器会在同一个编译单元中合并一些已知不可变类型的常量值，比如int、float、str、bytes。对于一个模块，整个模块是一个编译单元，但在交互式解释器中，每条语句都是一个单独的编译单元。因为c和d是在单独的语句中定义的，所以它们的值不会合并。由于e和f在同一个语句中定义，它们的值被合并。

您可以通过分解字节码来了解发生了什么。试着定义一个函数执行e, f = 128, 128然后调用dis。dis，你会看到只有一个常量值(128,128)

>>> def f(): i, j = 258, 258
>>> dis.dis(f)
  1           0 LOAD_CONST               2 ((128, 128))
              2 UNPACK_SEQUENCE          2
              4 STORE_FAST               0 (i)
              6 STORE_FAST               1 (j)
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE
>>> f.__code__.co_consts
(None, 128, (128, 128))
>>> id(f.__code__.co_consts[1], f.__code__.co_consts[2][0], f.__code__.co_consts[2][1])
4305296480, 4305296480, 4305296480

你可能会注意到编译器将128作为一个常量存储，尽管字节码实际上并没有使用它，这让你知道CPython编译器所做的优化是多么少。这意味着(非空的)元组实际上不会被合并:

>>> k, l = (1, 2), (1, 2)
>>> k is l
False

把它放到一个函数中，dis它，然后看看co_consts -有一个1和一个2，两个(1,2)元组共享相同的1和2，但不相同，还有一个((1,2)，(1,2))元组，它有两个不同的相等元组。

CPython还做了一项优化:字符串实习。与编译器常量折叠不同，这并不局限于源代码字面量:

>>> m = 'abc'
>>> n = 'abc'
>>> m is n
True

另一方面，它仅限于str类型，以及内部存储类型为"ascii compact"、"compact"或"legacy ready"的字符串，并且在许多情况下只有"ascii compact"会被捕获。

无论如何，关于什么值必须是、可能是或不能是不同的规则在不同的实现之间、在相同实现的版本之间、甚至在相同实现的同一副本上运行相同代码之间都是不同的。

为了好玩，学习特定Python的规则是值得的。但是在代码中依赖它们是不值得的。唯一安全的规则是:

不要编写假定两个相同但单独创建的不可变值相同的代码(不要使用x is y，使用x == y) 不要编写假定两个相同但分别创建的不可变值是不同的代码(不要使用x不是y，使用x != y)

或者，换句话说，唯一的用途是测试文档化的单例对象(如None)或只在代码中的一个地方创建的单例对象(如_sentinel = object()习惯用法)。

看看这个:

>>> a = 256
>>> b = 256
>>> id(a)
9987148
>>> id(b)
9987148
>>> a = 257
>>> b = 257
>>> id(a)
11662816
>>> id(b)
11662828

以下是我在“普通整数对象”的文档中找到的:

当前的实现为-5到256之间的所有整数保留了一个整数对象数组。当你在这个范围内创建一个int型时，你实际上只是得到了一个对现有对象的引用。

我认为你的假设是正确的。实验id(对象的身份):

In [1]: id(255)
Out[1]: 146349024

In [2]: id(255)
Out[2]: 146349024

In [3]: id(257)
Out[3]: 146802752

In [4]: id(257)
Out[4]: 148993740

In [5]: a=255

In [6]: b=255

In [7]: c=257

In [8]: d=257

In [9]: id(a), id(b), id(c), id(d)
Out[9]: (146349024, 146349024, 146783024, 146804020)

似乎数字<= 255被视为字面量，以上任何数字都被区别对待!

它也发生在字符串上:

>>> s = b = 'somestr'
>>> s == b, s is b, id(s), id(b)
(True, True, 4555519392, 4555519392)

现在一切似乎都好了。

>>> s = 'somestr'
>>> b = 'somestr'
>>> s == b, s is b, id(s), id(b)
(True, True, 4555519392, 4555519392)

这也是意料之中的。

>>> s1 = b1 = 'somestrdaasd ad ad asd as dasddsg,dlfg ,;dflg, dfg a'
>>> s1 == b1, s1 is b1, id(s1), id(b1)
(True, True, 4555308080, 4555308080)

>>> s1 = 'somestrdaasd ad ad asd as dasddsg,dlfg ,;dflg, dfg a'
>>> b1 = 'somestrdaasd ad ad asd as dasddsg,dlfg ,;dflg, dfg a'
>>> s1 == b1, s1 is b1, id(s1), id(b1)
(True, False, 4555308176, 4555308272)

这是意料之外的。