它也发生在字符串上:

>>> 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)

这是意料之外的。

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

CPython的一个好处是你可以看到它的源代码。我将使用3．5版本的链接，但是找到相应的2.倍是微不足道的。

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

# EYZ0。所以应该可以改变1的值。我怀疑Python在这种情况下的行为是未定义的。: -)

(斜体)

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

如果你还没有修改过实现CPython 你应该的C代码;一切都很有条理，可读。对于我们的例子，我们需要在主要源代码目录树的# EYZ0子目录中查找。

PyLong_FromLong处理long对象，因此不难推断我们需要窥视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# EYZ1，但我们也不傻，我们可以看到CHECK_SMALL_INT(ival);在诱人地窥视我们;我们可以理解它与此有关。# EYZ2

#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和NSMALLPOSINTS是什么?宏!# EYZ2:

#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看起来很像我们一直在搜索的数组，它确实是!# EYZ1:

/* 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, NSMALLPOSINTS)范围内创建一个新的int时，你只会得到一个已经存在的对象的引用，这个对象已经被预先分配了。

由于引用引用了相同的对象，直接发出id()或检查它与is的身份将返回完全相同的东西。

但是，什么时候分配呢?

在_PyLong_Init初始化时 Python会很高兴地进入for循环为你做这件事:

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

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

我希望我的解释已经让你清楚C的事情(双关语明显的意图)。

但是,# EYZ0吗?有什么事吗?

这实际上更容易解释，我已经试过了;这是因为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允许合并任何两个不可变的值，并且预先创建的小int值并不是发生这种情况的唯一方式。Python实现从来都不是保证来做这件事，但它们都不仅仅是为小int型做这件事。

首先，还有一些其他预先创建的值，比如空的tuple、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提供预先创建的float值。那么，这里发生了什么?

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它，然后看# eyz1 -有一个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 is not y，使用x != y)

或者，换句话说，只使用is来测试记录的单例(如None)或只在代码中的一个地方创建的单例(如_sentinel = object()习惯用法)。

# EYZ0:

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

. !=)