ctypes python dpi_使用Python的ctypes查看内存

Python是很高层的语言，本身没有像C那样的“指针”的概念，文档里涉及到指针的，基本都是"CPython implementation detail"。CPython本身是用C写的，所以肯定也是有“指针”的，这里看看怎么用Python的ctypes来查看内存。

NULL Access

在C里，有各种方式可以把一个程序弄崩溃，最经典的应该就是访问空指针了。在Python里访问一个空指针会怎么样呢？这里，把0强制类型转换成一个指向char的指针，然后访问这个char。

C：

char *p = NULL;

*p = 1;

不同的系统，不同的编译器，甚至不同的编译选项，上面两句的结果大概率是不尽相同的，也就是"undefined behavior"。

Python：

>>> from ctypes import *

>>> p = cast(0, POINTER(c_char))

>>> p.contents

Traceback (most recent call last):

File "", line 1, in

p.contents

ValueError: NULL pointer access

这里，c_char对应C里的char类型，POINTER对应C里的指针，POINTER(c_char)对应的就是C里的char*了，指向char的指针类型。 cast对应C里的强制类型转换，这里是把0转成char*，大概就是C里的char *p = NULL了。

p.contents是访问p指向的内容，p是个空指针，果然报错了 ，NULL pointer access。

Dump一个字节

CPython的实现里，是把一层层的结构体往上套，从数据层面实现类似继承的效果。每个对象的“基类”都是PyObject。看源码里的object.h

typedef struct _object {

_PyObject_HEAD_EXTRA

Py_ssize_t ob_refcnt;

struct _typeobject *ob_type;

} PyObject;

/* PyObject_HEAD defines the initial segment of every PyObject. */

#define PyObject_HEAD PyObject ob_base;

第零个数据在发布版的CPython里是没有的，这里忽略。第一个，ob_refcnt，是当前引用计数的数量。第二个，*ob_type是该PyObject对应的type对象指针，也就是类型对象。这里已经包含了非常多的信息，例如：CPython使用引用计数管理对象生命周期；

虽然没有指针，但也可以说所有的变量都是类似std::shared_ptr的“指针”；

对某个对象的操作，会转发给对应的类型对象，例如所有的int对象，其*ob_type大概是同一个。

所有的对象的头部都是一个ob_base，PyObject是类似最顶端的“基类”的存在。

幸运的是，Python有个叫id的函数，在CPython里，返回的就是PyObject(的“派生类”的对象)的内存地址，我们利用这个信息来看看ob_refcnt的值的变化情况。

>>> a = 12345678

>>> id(a)

2126985143664

>>> p = cast(id(a), POINTER(c_char))

>>> p.contents

c_char(b'\x01')

>>> b = a

>>> p.contents

c_char(b'\x02')

>>> c = a

>>> p.contents

c_char(b'\x03')

>>> del b

>>> p.contents

c_char(b'\x02')

>>> del c

>>> p.contents

c_char(b'\x01')

可以看到，引用每增加一个，refcnt的第一个字节就加1；引用每减少一个，refcnt的第一个字节就减1。我用的是window系统，整数是小端存储，先存储低位字节，所以恰好引用数量的变化反映在了refcnt的第一个字节上。

Dump一片内存

一个字节一个字节的看，有点慢，使用ctypes里的数组可以看成片的内存。

>>> from ctypes import *

>>> a = 1234.5678

>>> p = cast(id(a), POINTER(c_char * 32))

>>> p.contents.raw

b'\x01\x00\x00\x00\x00\x00\x00\x00\xb0$\xa0\x11\xff\x7f\x00\x00\xad\xfa\\mEJ\x93@T\xd1\xcc0\x00\x00\x00\x00'

这里和上面的区别，最主要的就是，原来的c_char变成了c_char * 32，就是变成了一个有32个元素组成的c_char数组，对应C里的char[32]。然后用POINTER包一下，这样，POINTER(c_char * 32)就对应C里的char (*p)[32]。

p.contents对应char[32]数组，而p.contents.raw直接就是Python里的一串bytes了，这就是实际的内存内容。

封装成几个好看点的函数。

import ctypes

def print_bytes(bs):

for i, b in enumerate(bs):

if i % 8 == 0 and i != 0:

print(' ', end='')

if i % 16 == 0 and i != 0:

print()

print('{:02X} '.format(b), end='')

print('\n')

def dump_mem(address, size):

p = ctypes.cast(address, ctypes.POINTER(ctypes.c_char * size))

return p.contents.raw

def print_mem(address, size):

mem = dump_mem(address, size)

print_bytes(mem)

def print_obj(obj, size):

print_mem(id(obj), size)

然后试一试。

>>> print_obj(1, 32)

35 03 00 00 00 00 00 00 10 3D A0 11 FF 7F 00 00

01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00

>>> print_obj(0xABCDEF, 32)

03 00 00 00 00 00 00 00 10 3D A0 11 FF 7F 00 00

01 00 00 00 00 00 00 00 EF CD AB 00 68 02 00 00

对于Python的两个int对象，可以看到，第一组8字节，是索引数量，可见索引数字1的有非常多，索引0xABCDEF的就没几个了。第二组8字节，是一模一样的，这里就是int的type object的地址，也就是PyObject里的*ob_type 。

>>> hex(id(int))

'0x7fff11a03d10'

int对象的type object，显然就是"int"了，可见地址果然完全对的上。

浮点数表示

Python3的int还是过于复杂了点，浮点数float相比之下就直接不少，这里再看看Python的浮点数表示。不妨先看CPython的源码，floatobject.h

typedef struct {

PyObject_HEAD

double ob_fval;

} PyFloatObject;

可见，相当于继承了PyObject，并且加了个double，ob_fval，这是浮点数实际的值，存在了一个C double里。

>>> print_obj(3.1415926, 8 * 3)

03 00 00 00 00 00 00 00 B0 24 A0 11 FF 7F 00 00

4A D8 12 4D FB 21 09 40

>>> print_obj(1234.5678, 8 * 3)

03 00 00 00 00 00 00 00 B0 24 A0 11 FF 7F 00 00

AD FA 5C 6D 45 4A 93 40

>>> hex(id(float))

'0x7fff11a024b0'

类似int，不过这里就更加一目了然了，第三组8字节就是C double，就是Python float值，就是在内存里的表示。

可以再用Python库里的array再确认一下，array类似C++里的std::vector。array.array('d')相当于std::vector。

>>> import array

>>> arr = array.array('d')

>>> arr.append(3.1415926)

>>> arr.append(1234.5678)

>>> arr

array('d', [3.1415926, 1234.5678])

>>> arr.buffer_info()

(2649580275632, 2)

buffer_info函数，返回了实际存储数组的内存的地址，和元素数量。看下这串内存：

>>> address, cnt = arr.buffer_info()

>>> print_mem(address, arr.itemsize * cnt)

4A D8 12 4D FB 21 09 40 AD FA 5C 6D 45 4A 93 40

可见，与本小节开头的结果完全对应。这个buffer_info可以用来和C做接口，非常有用。

其他

引用计数

sys.getrefcount是正常的获取引用计数的函数。gc.get_referrers可以看到底哪些东西引用着目标。

看内存的refcnt，感觉总是稍微大了一点，其实是有原因的。例如，编译后的code object也引用了一份：

>>> def f():

a = 1234.5678

print(sys.getrefcount(a))

print(gc.get_referrers(a))

>>> f()

3

[(None, 1234.5678)]

>>> f.__code__.co_consts

(None, 1234.5678)

这个3，我猜，分别是co_consts，a，和sys.getrefcount的parameter。

immutable

像C里面，通过指针改一个int的值大多是很正常的操作，在Python里面就完全不ok了，因为Python里的int是immutable的。a += 1在Python里创建了一个拥有新的值的新对象，原来的a已经不见了。 如果用指针强行把值改变，大概会出现完全不对的情况。

>>> a = 10

>>> print_mem(id(a), 32)

3E 00 00 00 00 00 00 00 10 3D A0 11 FF 7F 00 00

01 00 00 00 00 00 00 00 0A 00 00 00 00 00 00 00

>>> cast(id(a) + 8 * 3, POINTER(c_char)).contents

c_char(b'\n')

>>> cast(id(a) + 8 * 3, POINTER(c_char)).contents.value

b'\n'

>>> cast(id(a) + 8 * 3, POINTER(c_char)).contents.value = 11

>>> a

11

到这里看上去还算正常，但是，此10非彼10了：

>>> b = 10

>>> b

11

大量的10，变成了11。(因为整数是immutable的，小整数会被cache起来，不会每次都新建一个对象。)当然，操作array.array('i')里的应该没关系。