前言

Python一种动态类型，解释性的语言，对于很多开发者来说，Python运行慢是众所周知的事情，其万物皆对象的特性，就是导致其运行慢的一个原因，这篇文章就是想聊聊这里面的一些细节。

慢的原因

由于各种原因，Python比Fortran和C语言慢。

动态类型

Pythn是动态类型而不是静态类型的，这意味着，在程序执行时，解释器并不知道变量的类型。下图可以用来说明C变量和Python变量的区别

对C语言来说，编译器在声明变量的时候就知道其类型了；对Python来说，程序执行时只知道一个变量是某种Python对象。

对于下面的C代码

int a = 1;
int b = 2;
int c = a + b;

编译器始终知道a和b是整型，在执行相加运算时，流程如下:

1. 把<int> 1赋值给a
2. 把<int> 2赋值给b
3. 调用binary_add<int, int>(a, b)
4. 把结果赋值给c

实现同样功能的Python代码如下

a = 1
b = 2
c = a + b

解释器只知道1和2是对象，但是并不知道这个对象的类型。所以解释器必须检查每个变量的PyObject_HEAD才能知道变量类型，然后执行对应的相加操作，最后要创建一个新的Python对象来保存返回值，大致流程如下：

1. 把1赋值给a

   • 设置a->PyObject_HEAD->typecode为整型
   • 设置a->val = 1

2. 把2赋值给b

   • 设置a->PyObject_HEAD->typecode为整型
   • 设置b->val = 2

3. 调用binary_add<int, int>(a, b)

   • a->PyObject_HEAD获取类型编码
   • a是一个整型；值为a->val
   • b->PyObject_HEAD获取类型编码
   • b是一个整型，值为b->val
   • 调用binary_add<int, int>(a->val, b->val)
   • 结果为整型，存在result中

4. 创建对象c

   • 设c->PyObject_HEAD->typecode为整型
   • 设置c->val为result

动态类型意味着任何操作都会涉及更多的步骤。这是Python对数值操作比C语言慢的主要原因

Python是解释型语言

上面介绍了解释型代码和编译型代码的一个区别。智能的编译器可以提前预见并优化重复或不需要的操作，这会带来性能的提升。编译器是一个大的话题，这里不会展开。

Python的对象模型会带来低效的内存访问

和C语言的整数对比时，我们指出了Python多了额外一层信息。现在来看看数组的情况。在Python中我们可以使用标准库中提供的List对象；而在C语言中我们会使用基于缓冲区的数组。

最简单的NumPy数组是围绕C数据构建的Python对象，也就是说它有一个指向连续数据缓存区的指针。而Python的list具有指向连续的指针缓冲区的指针，这些指针每个都指向一个Python对象，结合上面的例子，这些Python对象是一个整数对象。这个结构像下面这样

很容易看出，如果你正在执行按顺序逐步完成数据的操作，numpy的内存布局比Python的内存布局更为高效，无论是存储成本还是访问的时间成本。

为什么使用Python

鉴于Python天生的低效率，我们为什么还要使用Python呢？种种理由大致可以归结为：动态类型使得Python比C更容易使用。Python非常的灵活和宽容，这种灵活性可以有效地利用开发时间，并且在那些确实需要C和Fortran优化的场合，Python可以轻松链接到已编译的库中。这也是Python在科学社区的使用率不断增长的原因。

一探究竟

上面已经提到了一些结论性的东西，下面我们用Python的一些工具来做一些验证。

下面的实验使用到了python, ipython, numpy，版本信息如下：

1. python:3.6.5
2. 1.13.3

In [1]: import sys
In [2]: import numpy
In [3]: sys.version[:5]
Out[3]: '3.6.5'
In [4]: numpy.__version__
Out[4]: '1.13.3'

本次实验使用机器64位的机器，如果是32位的机器话，下面提到的一些struct可能会有所不同。

整数

Python的整数使用起来非常简单。

In [5]: x = 42
In [6]: print(x)
42

接口的简单性掩盖了底层的复杂。在之前的内容里有提到过Python整数的内存布局。现在我们使用Python内置的ctypes模块来自省整数类型，前提是需要知道在C API中Python整数类型的定义。

在CPython中，变量x存储在一个名为_longobject的struct中，源码见Include/longintrepr.h

struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
}

其中PyObject_VAR_HEAD是一个宏，在Include/object.h中定义的结构如下

typedef struct {
    PyObject ob_base;
    Py_ssize_t ob_size;
} PyVarObject;

其中PyObject在Include/object.h中定义如下

typedef struct _object {
    _PyObject_HEAD_EXTRA
    Py_ssize_t ob_refcnt;
    struct _typeobject *ob_type;
}

其中_PyObject_HEAD_EXTRA是一个在Python版本中通常不使用的宏。

将上面的信息结合起来，可以得到下面的结构

struct _longobject {
    long ob_refcnt;
    PyTypeObject *ob_type;
    size_t ob_size;
    long ob_digit[1];
}

这里面ob_refcnt变量是对象的引用计数，ob_type是指向包含该对象所有类型信息和方法定义的结构的指针，ob_digit保存实际的数值。

有了上面的知识，可以开始使用ctypes模块来观察时间的对象结构并提取上面的信息。

现在来用Python定义一个C的struct

In [7]: import ctypes
In [9]: class IntStruct(ctypes.Structure):
   ...:     _fields_ = [
   ...:         ("ob_refcnt", ctypes.c_long),
   ...:         ("ob_type", ctypes.c_void_p),
   ...:         ("ob_size", ctypes.c_ulong),
   ...:         ("ob_digit", ctypes.c_long)
   ...:     ]
   ...:     
   ...:     def __repr__(self):
   ...:         return (
   ...:             "IntStruct(ob_digit)={self.ob_digit}, refcount={self.ob_refcnt}"
   ...:         ).format(self=self)
   ...:     

现在用42来做实验。在Python中，id方法会返回对象的内存地址：

In [10]: num = 42
In [11]: IntStruct.from_address(id(42))
Out[11]: IntStruct(ob_digit)=42, refcount=61

可以看到ob_digit指向了内存中的正确位置。但是这里只创建了一个对象，为什么引用次数是61呢？

事实证明，这是一个性能优化，Python使用了很多小的整数，如果为每一个数字都创建一个PyObject，会消耗掉不少内存。出于这个考虑，Python将一些常用的数字做了单例实现，这样每个数字在内存中只有一份拷贝。换句话说，如果在这个范围内创建一个新的Python整数时，只是创建了一个对该数值对象的引用。

In [16]: x = 42
In [17]: y = 42
In [18]: id(x) == id(y)
Out[18]: True

上面的例子中，x和y都指向了同一个内存地址。在使用更大的数的时候，等式就不成立了

In [19]: x = 1234
In [20]: y = 1234
In [21]: id(x) == id(y)
Out[21]: False

Python解释器启动时候会创建很多的整数对象；可以看看这些对象的引用分布

%matplotlib osx
import matplotlib.pyplot as plt
import sys
plt.loglog(range(1000), [sys.getrefcount(i) for i in range(1000)])
plt.xlabel('integer value')
plt.ylabel('reference count')
Out[8]: Text(0,0.5,'reference count')

可以看到0被引用了数千次，一般情况下，引用的频率随着整数值的增加而减少。

再来看看ob_digit对应的值

In [8]: all(i == IntStruct.from_address(id(i)).ob_digit for i in range(256))
Out[8]: True

如果更细心一点，就可以发现，对于大于256的值，ob_digit就不能对应到正确的值了：在Objects/longobject.c中对数值有一些移位操作，这也是Python对一些大整数的处理方式。

比如

In [11]: 2 ** 100
Out[11]: 1267650600228229401496703205376

这个值显然是超过了long类型的范围了。

List类型

现在来看看一个更复杂的数据类型：List。同样能在Include/listobject.h中找到List类型的struct结构：

typedef struct {
    PyObject_VAR_HEAD
    PyObject **ob_item;
    Py_ssize_t allocated;
} PyListObject;

和之前一样，得到有效的结构体如下：

typedef struct {
    long ob_refcnt;
    PyTypeObject *ob_type;
    Py_ssize_t ob_size;
    PyObject **ob_item;
    long allocated;
} PyListObject;

其中PyObject **ob_item指向list的数据，ob_size指出list中数据的个数。

In [3]: class ListStruct(ctypes.Structure):
   ...:     _fields_ = [("ob_refcnt", ctypes.c_long),
   ...:                 ("ob_type", ctypes.c_void_p),
   ...:                 ("ob_size", ctypes.c_ulong),
   ...:                 ("ob_item", ctypes.c_long),  # PyObject** pointer cast t
   ...: o long
   ...:                 ("allocated", ctypes.c_ulong)]
   ...:
   ...:     def __repr__(self):
   ...:         return ("ListStruct(len={self.ob_size}, "
   ...:                 "refcount={self.ob_refcnt})").format(self=self)

试验一下

In [8]: L = [1, 2, 3, 4]
In [9]: ListStruct.from_address(id(L))
Out[9]: ListStruct(len=4, refcount=1)

为确保得到的结果是正确的，对这个list增加几个引用，看看会不会影响引用计数：

In [10]: tup = [L, L]
In [11]: ListStruct.from_address(id(L))
Out[11]: ListStruct(len=4, refcount=3)

使用ctypes可以创建由之前IntStruct对象组成的复合结构

In [20]: Lstruct = ListStruct.from_address(id(L))
In [21]: PtrArray = Lstruct.ob_size * ctypes.POINTER(IntStruct)
In [22]: L_values = PtrArray.from_address(Lstruct.ob_item)

看看每个元素的值

In [23]: [ptr[0] for ptr in L_values]
Out[23]:
[IntStruct(ob_digit=1, refcount=4705),
 IntStruct(ob_digit=2, refcount=1102),
 IntStruct(ob_digit=3, refcount=559),
 IntStruct(ob_digit=4, refcount=726)]

NumPy的数组

同样的，我们来看看numpy中的数组。其C-API定义的结构见numpy/core/include/numpy/ndarraytypes.h，这里用的numpy版本是1.13.3，不同版本的结构可能有所不同。

In [25]: np.__version__
Out[25]: '1.13.3'

现在用ctypes来创建一个numpy数组的结构吧。

In [31]: class NumpyStruct(ctypes.Structure):
    ...:     _fields_ = [("ob_refcnt", ctypes.c_long),
    ...:                 ("ob_type", ctypes.c_void_p),
    ...:                 ("ob_data", ctypes.c_long),  # char* pointer cast to long
    ...:                 ("ob_ndim", ctypes.c_int),
    ...:                 ("ob_shape", ctypes.c_voidp),
    ...:                 ("ob_strides", ctypes.c_voidp)]
    ...:
    ...:     @property
    ...:     def shape(self):
    ...:         return tuple((self.ob_ndim * ctypes.c_int64).from_address(self.ob_shape))
    ...:
    ...:     @property
    ...:     def strides(self):
    ...:         return tuple((self.ob_ndim * ctypes.c_int64).from_address(self.ob_strides))
    ...:
    ...:     def __repr__(self):
    ...:         return ("NumpyStruct(shape={self.shape}, "
    ...:                 "refcount={self.ob_refcnt})").format(self=self)

新建一个numpy数组试试

In [32]: x = np.random.random((10, 20))
In [33]: xstruct = NumpyStruct.from_address(id(x))
In [34]: xstruct
Out[34]: NumpyStruct(shape=(10, 20), refcount=1)

可以看到已经拿到了正确的shape。现在看看引用计数的情况

In [35]: L = [x, x, x]
In [36]: xstruct
Out[36]: NumpyStruct(shape=(10, 20), refcount=4)

现在可以看看里面的数据了。

In [37]: x = np.arange(10)
In [38]: xstruct = NumpyStruct.from_address(id(x))
In [39]: size = np.prod(xstruct.shape)
In [40]: arraytype = size * ctypes.c_long
In [41]: data = arraytype.from_address(xstruct.ob_data)
In [42]: [d for d in data]
Out[42]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

上面的data变量存储了Numpy数组中定义的连续的内存块，可以改一下其中的值。

In [43]: x[4] = 555
In [44]: [d for d in data]
Out[44]: [0, 1, 2, 3, 555, 5, 6, 7, 8, 9]

上面的例子可以证明x和data指向了同一块连续内存。

比较Python的list和numpy的ndarray的内部结构，明显可以看出numpy的数据对于表示同类型的数据列表来说简单的多。

结语

Python很慢，正如上面所说，一个重要原因是类型的间接寻址，这也是Python对开发者友好的原因。同时，Python本身也提供了可用于破解Python对象的工具，通过使用这些工具可以解析CPython的一些内部行为。