Is是恒等运算符(功能类似于id(a) == id(b));只是两个相等的数不一定是同一个物体。出于性能考虑，有些小整数会被记忆，所以它们往往是相同的(这可以做到，因为它们是不可变的)。

另一方面，PHP的===运算符被描述为检查相等性和type: x == y和type(x) == type(y)，正如Paulo Freitas的注释所述。对于常见的数字，这就足够了，但与之不同的是，类以一种荒谬的方式定义__eq__:

class Unequal:
    def __eq__(self, other):
        return False

PHP显然也允许“内置”类(我指的是在C级实现的，而不是在PHP中)。稍微不那么荒谬的用法可能是timer对象，它每次作为数字使用时都有不同的值。这就是为什么你想要模拟Visual Basic的Now而不是用time。time()来显示它是一个求值，我不知道。

Greg Hewgill (OP)做了一个澄清性的评论:“我的目标是比较对象的同一性，而不是价值相等。除了数字，我想把对象的同一性视为价值相等。”

这将有另一个答案，因为我们必须将事物分类为数字，以选择是否与==或is进行比较。CPython定义了数字协议，包括PyNumber_Check，但这不能从Python本身访问。

我们可以尝试对已知的所有数字类型使用isinstance，但这不可避免地是不完整的。types模块包含一个StringTypes列表，但没有NumberTypes。从Python 2.6开始，内置的数字类有一个基类numbers。数字，但它有同样的问题:

import numpy, numbers
assert not issubclass(numpy.int16,numbers.Number)
assert issubclass(int,numbers.Number)

顺便说一下，NumPy将生成低数字的单独实例。

其实我不知道这个问题的答案。我认为理论上可以使用ctypes来调用PyNumber_Check，但即使是这个函数也存在争议，而且它肯定是不可移植的。我们现在只需要对测试的内容不那么挑剔。

最后，这个问题源于Python最初没有一个类型树的谓词，如Scheme的数字?，或者Haskell的类型类Num. is检查对象的身份，而不是值是否相等。PHP也有丰富多彩的历史，在PHP5中===显然只对对象起作用，而PHP4中没有。这就是跨语言(包括一种语言的不同版本)的成长之痛。

看看这个:

>>> 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被视为字面量，以上任何数字都被区别对待!

我迟到了，但你想要一些答案来源吗?我将试着以一种介绍性的方式来描述，这样更多的人可以跟上。

---

CPython的一个好处是你可以看到它的源代码。我将使用3.5版本的链接，但要找到对应的2。X个1是微不足道的。

在CPython中，处理创建新int对象的C-API函数是PyLong_FromLong(long v)。该函数的描述如下:

当前的实现为-5到256之间的所有整数保留了一个整数对象数组，当你在这个范围内创建一个int时，你实际上只是得到了对现有对象的引用。所以应该可以改变1的值。我怀疑Python在这种情况下的行为是未定义的。: -)

(斜体)

不知道你怎么想，但我看到这个就想:让我们找到那个数组!

如果你没有摆弄过实现CPython的C代码，你应该;一切都很有条理，可读。对于我们的例子，我们需要查看主源代码目录树的Objects子目录。

PyLong_FromLong处理的是长对象，因此不难推断我们需要查看longobject.c内部。在看了里面之后，你可能会认为一切都很混乱;它们是，但不用担心，我们要找的函数在第230行等待我们检查。它是一个较小的函数，所以主体(不包括声明)可以很容易地粘贴在这里:

PyObject *
PyLong_FromLong(long ival)
{
    // omitting declarations

    CHECK_SMALL_INT(ival);

    if (ival < 0) {
        /* negate: cant write this as abs_ival = -ival since that
           invokes undefined behaviour when ival is LONG_MIN */
        abs_ival = 0U-(unsigned long)ival;
        sign = -1;
    }
    else {
        abs_ival = (unsigned long)ival;
    }

    /* Fast path for single-digit ints */
    if (!(abs_ival >> PyLong_SHIFT)) {
        v = _PyLong_New(1);
        if (v) {
            Py_SIZE(v) = sign;
            v->ob_digit[0] = Py_SAFE_DOWNCAST(
                abs_ival, unsigned long, digit);
        }
        return (PyObject*)v; 
}

现在，我们不是C master-code-haxxorz但我们也不笨，我们可以看到CHECK_SMALL_INT(ival);诱惑地窥视我们所有人;我们可以理解它与此有关。让我们来看看:

#define CHECK_SMALL_INT(ival) \
    do if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS) { \
        return get_small_int((sdigit)ival); \
    } while(0)

所以它是一个宏，如果值ival满足条件，就调用函数get_small_int:

if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS)

什么是NSMALLNEGINTS和nsmallpoints ?宏!他们是:

#ifndef NSMALLPOSINTS
#define NSMALLPOSINTS           257
#endif
#ifndef NSMALLNEGINTS
#define NSMALLNEGINTS           5
#endif

所以我们的条件是if (-5 <= ival && ival < 257)调用get_small_int。

接下来让我们看看get_small_int的所有荣耀(好吧，我们只看它的主体，因为有趣的东西在那里):

PyObject *v;
assert(-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS);
v = (PyObject *)&small_ints[ival + NSMALLNEGINTS];
Py_INCREF(v);

好的，声明一个PyObject，断言前面的条件成立并执行赋值:

v = (PyObject *)&small_ints[ival + NSMALLNEGINTS];

Small_ints看起来很像我们一直在搜索的数组，而且确实如此!我们只要看看那该死的文件就知道了!：

/* Small integers are preallocated in this array so that they
   can be shared.
   The integers that are preallocated are those in the range
   -NSMALLNEGINTS (inclusive) to NSMALLPOSINTS (not inclusive).
*/
static PyLongObject small_ints[NSMALLNEGINTS + NSMALLPOSINTS];

没错，这就是我们要找的人。当你想在[NSMALLNEGINTS, nsmallpoints)范围内创建一个新的int时，你只会得到一个已经存在的对象的引用，这个对象已经被预先分配了。

由于引用引用的是同一个对象，因此直接发出id()或检查与is的标识将返回完全相同的结果。

但是，什么时候分配呢?

在_PyLong_Init的初始化过程中，Python会很高兴地进入一个for循环来为你做这件事:

for (ival = -NSMALLNEGINTS; ival <  NSMALLPOSINTS; ival++, v++) {

查看源代码以阅读循环体!

我希望我的解释让你现在明白了事情(双关语)。

---

但是，257就是257?有什么事吗?

这实际上更容易解释，我已经尝试过这样做;这是因为Python会将这个交互语句作为一个单独的块执行:

>>> 257 is 257

在编译此语句期间，CPython将看到您有两个匹配的字面量，并将使用相同的PyLongObject表示257。如果你自己编译并检查它的内容，你可以看到这一点:

>>> codeObj = compile("257 is 257", "blah!", "exec")
>>> codeObj.co_consts
(257, None)

当CPython执行这个操作时，它现在只是加载相同的对象:

>>> import dis
>>> dis.dis(codeObj)
  1           0 LOAD_CONST               0 (257)   # dis
              3 LOAD_CONST               0 (257)   # dis again
              6 COMPARE_OP               8 (is)

所以is会返回True。

Python 3.8新增功能:Python行为的变化:

编译器现在在标识检查(is和 Is not)用于某些类型的字面量(例如字符串，int)。 在CPython中，这些通常可以意外地工作，但不能保证 该警告建议用户使用相等性测试(== 和!=)代替。

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

是检查它们是否是相同的对象，而不仅仅是相等。较小的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__属性来指定行为。