Python中神秘的-5到256

注：本文不区分作为编程语言的Python和作为语言实现的Python。后者均默认为CPython。

了解他人对Python源代码的掌握情况，我喜欢问这样一个问题

请问，在Python中，256和257的主要区别是什么？

我期望的回答是

Python内部，对这两个数采取了不同的对象创建策略

1.做一个实验

我们知道，在一个对象的生存期内，可以用id()函数得到这个对象的唯一标识。即，id返回值相同的对象一定是同一个对象。

启动Python的交互模式（主流版本的Python 2和Python 3均可），输入以下语句并观察结果。

>>> a = 0
>>> b = 0
>>> id(a) == id(b)
True
>>> a = -5
>>> b = -5
>>> id(a) == id(b)
True
>>> a = -6
>>> b = -6
>>> id(a) == id(b)
False
>>> a = 256
>>> b = 256
>>> id(a) == id(b)
True
>>> a = 257
>>> b = 257
>>> id(a) == id(b)
False
>>> a = -1.0
>>> b = -1.0
>>> id(a) == id(b)
False

你也可以写一个带有for循环的脚本，更加全面的验证这样一个结论：

Python中，对于整数对象，如果其值处于[-5,256]的闭区间内，则值相同的对象是同一个对象

您有可能想到了，这也许和Python内部的某种机制有关。让我们更加深入的使用API来验证这个结论。

2. 使用Python API

以Python 2为例，可以使用这样的代码得到与Python脚本等价的结论：

#include <Python.h>

int main(int argc,char ** argv) {
  PyObject *a,*b;
  Py_SetProgramName(argv[0]);
  Py_Initialize();
  a = PyInt_FromLong(256);
  b = PyInt_FromLong(256);
  printf("a=%p,b=%p
",a,b); //value should be the same
  a = PyInt_FromLong(257);
  b = PyInt_FromLong(257);
  printf("a=%p,b=%p
",a,b);  //value should be different
  Py_Finalize();
  return 0;
}

如果使用Python3 ，PyInt_FromLong要替换为PyLong_FromLong。

从运行结果可以看到，从256产生的两个PyObject*，指向了内存中相同的地址，但是从257产生的PyObject则是相互独立的。

3.没有什么好奇怪的

为什么是-5到256之间的这200多个数？其实没有什么奇怪的，Python本身就是这样实现的。

让我们打开源代码一看究竟。首先看看Python2的实现方式。下面的代码是以本文写作时最新的2.7.14为例子的。

在Python自身的main函数里，会调用Py_Initialize这个函数初始化Python内部的一系列模块。（Modules/main.c，551行）。在初始化过程中，_PyInt_Init会被调用（Python/pythonrun.c，210行）。_PyInt_Init的唯一作用就是初始化small_ints数组（Objects/intobject.c，1452行）：

int
_PyInt_Init(void)
{
    PyIntObject *v;
    int ival;
#if NSMALLNEGINTS + NSMALLPOSINTS > 0
    for (ival = -NSMALLNEGINTS; ival < NSMALLPOSINTS; ival++) {
        if (!free_list && (free_list = fill_free_list()) == NULL)
            return 0;
        /* PyObject_New is inlined */
        v = free_list;
        free_list = (PyIntObject *)Py_TYPE(v);
        (void)PyObject_INIT(v, &PyInt_Type);
        v->ob_ival = ival;
        small_ints[ival + NSMALLNEGINTS] = v;
    }
#endif
    return 1;
}

我们看到了两个宏：NSMALLNEGINTS 和NSMALLPOSINTS 。在intobject.c的头部找到它们的定义：

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

从_PyInt_Init的实现上，我们可以看到被放入small_ints的数字范围是-5到256。因此，你可以通过修改源代码的方式，将这个范围任意的扩展。

如果你不对这两个宏进行改动，那么在Python启动的时候，会先创建一个200多PyObject大小的数组，默认的把-5从256的所有整数创建完毕。

我们知道，Python在遇到诸如 a = 5这样的语句的时候，最终会落到PyInt_FromLong这个函数里。我们看看这个函数是怎么写的（intobject.c，86行）：

PyObject *
PyInt_FromLong(long ival)
{
    register PyIntObject *v;
#if NSMALLNEGINTS + NSMALLPOSINTS > 0
    if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS) {
        v = small_ints[ival + NSMALLNEGINTS];
        Py_INCREF(v);
#ifdef COUNT_ALLOCS
        if (ival >= 0)
            quick_int_allocs++;
        else
            quick_neg_int_allocs++;
#endif
        return (PyObject *) v;
    }
#endif
    if (free_list == NULL) {
        if ((free_list = fill_free_list()) == NULL)
            return NULL;
    }
    /* Inline PyObject_New */
    v = free_list;
    free_list = (PyIntObject *)Py_TYPE(v);
    (void)PyObject_INIT(v, &PyInt_Type);
    v->ob_ival = ival;
    return (PyObject *) v;
}

这段代码很容易读懂，首先判断字面量的范围是不是在-5到256之间，如果是，直接从small_ints里面取得缓存的对象，如果不是，再通过PyObject_New来创建一个新的对象。

Python3 的代码以此类推，相似的代码在longobject.c里面。

4. 为什么要这样做

主要还是性能上的考虑。由于创建一个新的对象是比较折腾的：在内存池中分配空间，赋予对象的类别并赋予其初始的值。从-5到256这些小的整数，在Python脚本中使用的非常频繁，又因为他们是不可更改的，因此只创建一次，重复使用就可以了。

有兴趣的读者可以把负责缓存边界的两个宏改小，或者让它们的和是负数以取消这个功能，看看日常的脚本是否有性能的变化。

5. 一点扩展……

考虑这样的命令：

>>> a,b = 400,400
>>> id(a) == id(b)
True

您知道是为什么吗？

以上内容转载自知乎