Python 笔试集（2）：你不知道的 Python 整数

面试题

分别给出下述代码在终端(e.g. IPyhon)中和在程序中的运行结果：

a = 256
b = 256

c = 257
d = 257

def foo():
      e = 257
      f = 257

      print('a is b: %s' % (a is b))
      print('c is d: %s' % (c is d))
      print('c is e: %s' % (c is e))
      print('e is f: %s' % (e is f))

foo()

• IPython 中运行的结果：

In [31]: a = 256

In [32]: b = 256

In [33]: c = 257

In [34]: d = 257

In [35]: def foo():
    ...:         e = 257
    ...:         f = 257
    ...:
    ...:         print('a is b: %s' % (a is b))
    ...:         print('c is d: %s' % (c is d))
    ...:         print('c is e: %s' % (c is e))
    ...:         print('e is f: %s' % (e is f))
    ...:
In [36]: foo()
a is b: True
c is d: False
c is e: False
e is f: True

• 在程序中运行的结果：

$ python foo.py

a is b: True
c is d: True
c is e: False
e is f: True

Emmmmm~ 显然两次执行的结果不尽相同，实际上在这个简单的代码之中包含了两个鲜为人知的 Python 技术内幕。

小整数与大整数

整数是最为简单且常用的数据类型，尤其在极端的科学计算场景中，上百万次计算就发生在数秒之间。对于这些场景，如果 Python 仍单纯的使用 malloc/free 函数来完成内存的分配与释放，那么其运行性能将会及其低下，并且会造成很大的浪费。所以，出于性能的考虑，Python 在内部对整数的实现做了许多优化工作，而优化的核心就是减少 malloc/free 函数的调用。

同时又因为在实际的应用中，应用程序对整数的使用有明显的数值区间划分。例如，数值较小的整数会更频繁的被使用，而数值较大的整数虽然使用得不那么频繁，但却要占用更大的内存空间。为了更好的区分优化，在 Python 的源码实现中，将整数的定义细分为「小整数」和「大整数」，前者的数值范围在 [-5, 257) 之间，其余的数值均归为后者。

小整数对象缓存池

小整数的使用是最为频繁的，为了避免反复创建和销毁带来的资源开销，Pyhton 干脆直接将这些小整数都缓存到一个特定的 small_ints 链表中，该链表会存在于 Python 解释器的整个生命周期中，但凡需要使用小整数时，则直接从链表中获取。这就是Python 的「小整数对象缓存池技术」，简单来说就是小整数对象会在 Python 全局解释器范围内被重复引用，且永远不会被 GC 回收。那么对于小整数而言，只会在初始化 small_ints 时调用 malloc/free 函数。

通用整数对象缓冲池

Python 运行环境会为大整数对象分配一定的缓冲内存空间，该内存空间会被大整数对象轮流使用，直到占满为止，再继续再开辟一块新的内存空间。这就是 Python 的「通用整数对象缓冲池技术」。

通用整数对象缓冲池相关的结构体定义：

struct _intblock {  
    struct _intblock *next;  
    PyIntObject objects[N_INTOBJECTS];  
};  

typedef struct _intblock PyIntBlock;

static PyIntBlock *block_list = NULL;  
static PyIntObject *free_list = NULL;  

PyIntObject（Python 整数对象）会以数组的形式存在于 PyIntBlock 中，一个 block 大约能够存放 82 个 PyIntObject。block_list 用于维护分配给 PyIntObject 所有的内存空间，而 free_list 则用于维护 PyIntObject 可用的剩余内存空间。只有当 free_list 为 NULL（剩余空间为 0）时，Python 才会调用 fill_free_list 函数再 malloc 出来一个 block。并且当一个大整数对象的引用计数为 0 而需要被回收时，其占有的内存并不会归还给系统，而是重新回到 free_list，供新创建的整数对象使用。由此可见，通用整数对象缓冲池同样能够有效的减少 malloc/free 函数的调用。

在理解了大、小整数实现的不同后，再看看下面的运行结果，我想大家应该不会再感到奇怪：

In [25]: a = 256

In [26]: b = 256

In [27]: a is b
Out[27]: True

In [28]: c = 257

In [29]: d = 257

In [30]: c is d
Out[30]: False

但这依旧不足以解释面试题中同为大整数的变量 c、d、e、f，为什么 c/d、e/f 的内存地址却是两两相同的结果。这就涉及到了另一个知识点——「Python 的解析模式」。

逐行解释与整体解释的差异

整体解释

整体解释指的是通过应用程序的方式来运行 Python 代码，对应面试题在程序中运行的结果。对于此时的 Python 代码而言，解析器 CPython 的「编译单元」是一个函数（Python 顶层代码也被当作一个函数来进行编译），即题目中的函数 foo 会被单独编译，而得到一个 PyFunctionObject 对象，该对象中包含了字节码、常量池等信息。
每个 PyFunctionObject 都拥有有一个独立的常量池，如果在同一个 PyFunctionObject 里创建了值相同的常量，那么这些常量只会在常量池里出现一份。也就是说位于顶层的变量 c、d 和位于 foo 函数中 e、f 实际上都分别引用了来自同一个 PyFunctionObject 的常量池中的内存对象，所以变量 c/d、e/f 的内存地址才会两两相同。同理，因为变量 c 和 e 分别存在于两个不同的 PyFunctionObject 中，所以即便两者的值相同，也不是同一个内存对象。

需要注意的是这里提到的「常量」，通常指的是整数类型对象。又因为整型中的小整数具有小整数缓存池机制，所以即便是在不同的 PyFunctionObject 中，小整数变量也依旧会引用同一个内存对象。

逐行解释

在交互式解释器中执行 Python 代码，对应面试题中在 IPython 中运行的代码。每输入一行语句就会立即执行，所以此时的「编译单元」为一行语句。注意这里所说的“一行”指的是一次完整性输入，例如：

In [33]: c = 257

In [34]: d = 257

In [35]: def foo():
    ...:     e = 257
    ...:     f = 257
    ...:
    ...:     print('a is b: %s' % (a is b))
    ...:     print('c is d: %s' % (c is d))
    ...:     print('c is e: %s' % (c is e))
    ...:     print('e is f: %s' % (e is f))
    ...:

上述代码块实际上属于 3 次完整性输入，分别得到了 3 个不同的 PyFunctionObject，所以变量 c、d 自然也就不存在于同一个常量池中，所以 (c is d) == False。

最后

实际上这一个看是并没有什么卵用的知识点，掌握与否并不会影响到日常的编程任务。但往往是这种“大隐隐与市”的知识点，最能区别出开发者对一门语言的理解，以及开发者是否具有专研精神的考量。
其次，我们能通过 Python 对整数实现的优化得到一些启发，就是 pool 的设计与机制是一种能够降低应用系统中性能损耗的有效手段。