"是"运算符与整数意外行为

为什么以下在Python中出现意外行为？

>>> a = 256
>>> b = 256
>>> a is b
True           # This is an expected result
>>> a = 257
>>> b = 257
>>> a is b
False          # What happened here? Why is this False?
>>> 257 is 257
True           # Yet the literal numbers compare properly

我使用的是Python 2.5.2.尝试一些不同版本的Python,似乎Python 2.3.3显示了99到100之间的上述行为.

基于以上所述,我可以假设Python在内部实现,使得"小"整数以不同于大整数的方式存储,is运算符可以区分.为什么泄漏抽象？当我不知道它们是否是数字时,比较两个任意对象以查看它们是否相同的更好的方法是什么？

看看这个:

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

编辑:这是我在Python 2文档中找到的,"普通整数对象"(Python 3也是如此):

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

Python的"is"运算符会出现意外的整数运算吗？

总之 - 让我强调:不要is用来比较整数.

这不是你应该有任何期望的行为.

相反,分别使用==和!=比较平等和不平等.例如:

>>> a = 1000
>>> a == 1000       # Test integers like this,
True
>>> a != 5000       # or this!
True
>>> a is 1000       # Don't do this! - Don't use `is` to test integers!!
False

说明

要了解这一点,您需要了解以下内容.

首先,做is什么？它是一个比较运算符.从文档:

对象标识的运算符is和is not测试:x is y当且仅当x和y是同一个对象时才为真.x is not y产生反向真值.

所以以下是等价的.

>>> a is b
>>> id(a) == id(b)

从文档:

id 返回对象的"标识".这是一个整数(或长整数),保证在该生命周期内该对象是唯一且恒定的.具有非重叠寿命的两个对象可以具有相同的id()值.

请注意,CPython中对象的id(Python的参考实现)是内存中的位置这一事实是一个实现细节.Python的其他实现(例如Jython或IronPython)可以很容易地实现不同的实现id.

那么用例是is什么？ PEP8描述:

与单身人士的比较None应始终使用is或者 is not从不使用相等运算符.

问题

您询问并说明以下问题(带代码):

为什么以下在Python中出现意外行为？

>>> a = 256
>>> b = 256
>>> a is b
True           # This is an expected result

这不是预期的结果.为什么会这样？它仅仅意味着价值整数256双方引用的a和b是整数的同一个实例.整数在Python中是不可变的,因此它们无法改变.这应该对任何代码都没有影响.不应该这样.它只是一个实现细节.

但也许我们应该感到高兴的是,每当我们声明一个值等于256时,内存中就没有新的单独实例.

>>> a = 257
>>> b = 257
>>> a is b
False          # What happened here? Why is this False?

看起来我们现在有两个单独的整数实例,其值257在内存中.由于整数是不可变的,这会浪费内存.让我们希望我们不要浪费太多.我们可能不是.但这种行为并不能保证.

>>> 257 is 257
True           # Yet the literal numbers compare properly

好吧,这看起来像你的Python的特定实现是试图聪明,而不是在内存中创建冗余值整数,除非它必须.您似乎表明您正在使用Python的引用实现,即CPython.适合CPython.

如果CPython可以在全球范围内实现这一目标可能会更好,如果它可以这么便宜(因为在查找中会有成本),或许可能是另一种实现.

但至于对代码的影响,您不应该关心整数是否是整数的特定实例.您应该只关心该实例的值是什么,并且您将使用正常的比较运算符,即==.

是什么is呢

is检查id两个对象是否相同.在CPython中,它id是内存中的位置,但它可能是另一个实现中的其他唯一标识号.用代码重述这个:

>>> a is b

是相同的

>>> id(a) == id(b)

那我们为什么要用is呢？

这可以是一个非常快速的检查,相比之下,检查两个非常长的字符串是否相等.但由于它适用于对象的唯一性,因此我们对它的使用情况有限.事实上,我们主要想用它来检查None,这是一个单例(一个存在于内存中的唯一实例).如果有可能将它们混为一谈,我们可能会创建其他单例,我们可能会检查它们is,但这些是非常罕见的.这是一个例子(将在Python 2和3中工作),例如

SENTINEL_SINGLETON = object() # this will only be created one time.

def foo(keyword_argument=None):
    if keyword_argument is None:
        print('no argument given to foo')
    bar()
    bar(keyword_argument)
    bar('baz')

def bar(keyword_argument=SENTINEL_SINGLETON):
    # SENTINEL_SINGLETON tells us if we were not passed anything
    # as None is a legitimate potential argument we could get.
    if keyword_argument is SENTINEL_SINGLETON:
        print('no argument given to bar')
    else:
        print('argument to bar: {0}'.format(keyword_argument))

foo()

哪个印刷品:

no argument given to foo
no argument given to bar
argument to bar: None
argument to bar: baz

因此,我们看到,使用is和一个标记,我们能够区分何时bar被调用,没有参数和何时被调用None.这些是主要的用例为is-做不使用它来测试整数,字符串,元组,或者其他喜欢这些东西的平等.

这取决于你是否想要看两件事是否相同,或者是同一个对象.

is检查它们是否是同一个对象,而不仅仅是相同的.小的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__属性指定行为.

我迟到了,你想要一些消息来源吗？^*

关于CPython的好处是你可以真正看到它的来源.我现在要使用链接进行int发布; 找到相应PyLong_FromLong(long v)的是微不足道的.

在CPython中,Objects处理创建新PyLong_FromLong对象的函数是long.该功能的描述是:

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

不知道你,但我看到了这一点并想:让我们找到那个阵列!

如果你还没有与拨弄longobject.c实现CPython的代码,你应该,一切都非常有组织性和可读性.对于我们而言,我们需要在看CHECK_SMALL_INT(ival);子目录中的主源代码目录树.

get_small_int处理ival对象因此不难推断出我们需要窥视内部NSMALLNEGINTS.看完后你可能会认为事情很混乱; 他们是,但不要担心,我们正在寻找的功能让我们NSMALLPOSINTS等待我们查看它.这是一个小功能,所以主体(不包括声明)很容易粘贴在这里:

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; 
}

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

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

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

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

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

/* 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];

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

>>> 257 is 257

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

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

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)

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

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

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

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

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

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

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

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