摘要：轉(zhuǎn)載地址在中一切皆是對(duì)象，而在實(shí)現(xiàn)的語言中，這些對(duì)象只不過是一些比較復(fù)雜的結(jié)構(gòu)體而已。由于和引用的是同一個(gè)整數(shù)對(duì)象，因此和的值同時(shí)發(fā)生了變化。用來創(chuàng)建大小不固定的結(jié)構(gòu)體對(duì)象，首先搜索名為的字段，并將其類型保存到中。

轉(zhuǎn)載地址：http://hyry.dip.jp/tech/slice/slice.html/10

在 Python 中一切皆是對(duì)象，而在實(shí)現(xiàn) Python 的 C 語言中，這些對(duì)象只不過是一些比較復(fù)雜的結(jié)構(gòu)體而已。本文通過 ctypes 訪問對(duì)象對(duì)應(yīng)的結(jié)構(gòu)體中的數(shù)據(jù)，加深對(duì) Python 對(duì)象的理解。

Python 所有對(duì)象結(jié)構(gòu)體中的頭兩個(gè)字段都是相同的：

refcnt：對(duì)象的引用次數(shù)，若引用次數(shù)為 0 則表示此對(duì)象可以被垃圾回收了。

typeid：指向描述對(duì)象類型的對(duì)象的指針。

通過 ctypes，我們可以很容易定義一個(gè)這樣的結(jié)構(gòu)體：PyObject。

注意：本文只描述在 32 位操作系統(tǒng)下的情況，如果讀者使用的是 64 位操作系統(tǒng)，需要對(duì)程序中的一些字段類型做一些改變。

from ctypes import *

class PyObject(Structure):
    _fields_ = [("refcnt", c_size_t),
                ("typeid", c_void_p)]

下面讓我們用 PyObject 做一些實(shí)驗(yàn)幫助理解這兩個(gè)字段的含義：

>>> a = "this is a string"
>>> obj_a = PyObject.from_address(id(a)) ?
>>> obj_a.refcnt ?
1L
>>> b = [a]*10
>>> obj_a.refcnt ?
11L
>>> obj_a.typeid ?
505269056
>>> id(type(a))
505269056
>>> id(str)
505269056

?通過 id(a) 可以獲得對(duì)象 a 的內(nèi)存地址，而 PyObject.from_address()可以將指定的內(nèi)存地址的內(nèi)容轉(zhuǎn)換為一個(gè) PyObject 對(duì)象。通過此 PyObject 對(duì)象obj_a 可以訪問對(duì)象 a 的結(jié)構(gòu)體中的內(nèi)容。
?查看對(duì)象 a 的引用次數(shù)，由于只有 a 這個(gè)名字引用它，因此值為 1。接下來創(chuàng)建一個(gè)列表，此列表中的每個(gè)元素都是對(duì)象 a，因此此列表應(yīng)用了它 10 次，?所以引用次數(shù)變?yōu)榱?11。
?查看對(duì)象 a 的類型對(duì)象的地址，它和 id(type(a)) 相同，而由于對(duì)象a的類型為str，因此也就是 id(str)。

下面查看str類型對(duì)象的這兩個(gè)字段：

>>> obj_str = PyObject.from_address(id(str))
>>> obj_str.refcnt
252L
>>> obj_str.typeid
505208152
>>> id(type)
505208152

可以看到 str 的類型就是type。再看看 type 對(duì)象：

>>> type_obj = PyObject.from_address(id(type))
>>> type_obj.typeid
505208152

type 對(duì)象的類型指針就指向它自己，因?yàn)?type(type) is type。

接下來看看整數(shù)和浮點(diǎn)數(shù)對(duì)象，這兩個(gè)對(duì)象除了有 PyObject 中的兩個(gè)字段之外，還有一個(gè) val 字段保存實(shí)際的值。因此 Python 中一個(gè)整數(shù)占用 12 個(gè)字節(jié)，而一個(gè)浮點(diǎn)數(shù)占用 16 個(gè)字節(jié)：

>>> sys.getsizeof(1)
12
>>> sys.getsizeof(1.0)
16

我們無需重新定義 refcnt 和 typeid 這兩個(gè)字段，通過繼承 PyObject，可以很方便地定義整數(shù)和浮點(diǎn)數(shù)對(duì)應(yīng)的結(jié)構(gòu)體，它們會(huì)繼承父類中定義的字段：

class PyInt(PyObject):
    _fields_ = [("val", c_long)]

class PyFloat(PyObject):
    _fields_ = [("val", c_double)]

下面是使用 PyInt 查看整數(shù)對(duì)象的例子：

>>> i = 2000
>>> i_obj = PyInt.from_address(id(a))
>>> i_obj.refcnt
1L
>>> i_obj.val
2000

通過 PyInt 對(duì)象，還可以修改整數(shù)對(duì)象的內(nèi)容：
修改不可變對(duì)象的內(nèi)容會(huì)造成嚴(yán)重的程序錯(cuò)誤，請(qǐng)不要用于實(shí)際的程序中。

>>> j = i
>>> i_obj.val = 2012
>>> j
2012

由于i和j引用的是同一個(gè)整數(shù)對(duì)象，因此i和j的值同時(shí)發(fā)生了變化。

表示字符串和長(zhǎng)整型數(shù)的結(jié)構(gòu)體的大小不是固定的，這些結(jié)構(gòu)體在 C 語言中使用了一種特殊的字段定義技巧，使得結(jié)構(gòu)體中最后一個(gè)字段的大小可以改變。由于結(jié)構(gòu)體需要知道最后一個(gè)字段的長(zhǎng)度，因此這種結(jié)構(gòu)中包含了一個(gè) size 字段，保存最后一個(gè)字段的長(zhǎng)度。在 ctypes 中無法表示這種長(zhǎng)度不固定的字段，因此我們使用了動(dòng)態(tài)創(chuàng)建結(jié)構(gòu)體類的方法。

class PyVarObject(PyObject):
    _fields_ = [("size", c_size_t)]

class PyStr(PyVarObject):
    _fields_ = [("hash", c_long),
                ("state", c_int),
                ("_val", c_char*0)]  ?

class PyLong(PyVarObject):
    _fields_ = [("_val", c_uint16*0)]

def create_var_object(struct, obj):
    inner_type = None
    for name, t in struct._fields_:
        if name == "_val":                      ?
            inner_type = t._type_
    if inner_type is not None:
        tmp = PyVarObject.from_address(id(obj))  ?
        size = tmp.size
        class Inner(struct):              ?
            _fields_ = [("val", inner_type*size)]
        Inner.__name__ = struct.__name__
        struct = Inner
    return struct.from_address(id(obj))

?在定義長(zhǎng)度不固定的字段時(shí)，使用長(zhǎng)度為 0 的數(shù)組定義一個(gè)不占內(nèi)存的偽字段 _val。 create_var_object() 用來創(chuàng)建大小不固定的結(jié)構(gòu)體對(duì)象，?首先搜索名為 _val 的字段，并將其類型保存到 inner_type 中。?然后創(chuàng)建一個(gè)PyVarObject 結(jié)構(gòu)體讀取obj對(duì)象中的 size 字段。?再通過 size 字段的大小創(chuàng)建一個(gè)對(duì)應(yīng)的 Inner 結(jié)構(gòu)體類，它可以從 struct 繼承，因?yàn)?struct 中的 _val 字段不占據(jù)內(nèi)存。
下面我們用上面的程序做一些實(shí)驗(yàn)：

>>> s_obj = create_var_object(PyStr, s)
>>> s_obj.size
9L
>>> s_obj.val
"abcdegfgh"

當(dāng)整數(shù)的范圍超過了 0x7fffffff 時(shí)，Python 將使用長(zhǎng)整型整數(shù)：

>>> l = 0x1234567890abcd
>>> l_obj = create_var_object(PyLong, l)
>>> l_obj.size
4L
>>> val = list(l_obj.val)
>>> val
[11213, 28961, 20825, 145]

可以看到 Python 用了 4 個(gè) 16 位的整數(shù)表示 0x1234567890abcd，下面我們看看長(zhǎng)整型數(shù)是如何用數(shù)組表示的：

>>> hex((val[3] << 45) + (val[2] << 30) + (val[1] << 15) + val[0])
"0x1234567890abcdL"

即數(shù)組中的后面的元素表示高位，每個(gè) 16 為整數(shù)中有 15 位表示數(shù)值。

列表對(duì)象的長(zhǎng)度是可變的，因此不能采用字符串那樣的結(jié)構(gòu)體，而是使用了一個(gè)指針字段items指向可變長(zhǎng)度的數(shù)組，而這個(gè)數(shù)組本身是一個(gè)指向 PyObject 的指針。 allocated 字段表示這個(gè)指針數(shù)組的長(zhǎng)度，而 size 字段表示指針數(shù)組中已經(jīng)使用的元素個(gè)數(shù)，即列表的長(zhǎng)度。列表結(jié)構(gòu)體本身的大小是固定的。

class PyList(PyVarObject):
    _fields_ = [("items", POINTER(POINTER(PyObject))),
                ("allocated", c_size_t)]

    def print_field(self):
        print self.size, self.allocated, byref(self.items[0])

我們用下面的程序查看往列表中添加元素時(shí)，列表結(jié)構(gòu)體中的各個(gè)字段的變化：

def test_list():
    alist = [1,2.3,"abc"]
    alist_obj = PyList.from_address(id(alist))

    for x in xrange(10):
        alist_obj.print_field()
        alist.append(x)

運(yùn)行 test_list() 得到下面的結(jié)果：

>>> test_list()
3 3   ?
4 7   ?
5 7 
6 7 
7 7 
8 12 
9 12 
10 12 
11 12 
12 12 

?一開始列表的長(zhǎng)度和其指針數(shù)組的長(zhǎng)度都是 3，即列表處于飽和狀態(tài)。因此?往列表中添加新元素時(shí)，需要重新分配指針數(shù)組，因此指針數(shù)組的長(zhǎng)度變?yōu)榱?7，而地址也發(fā)生了變化。這時(shí)列表的長(zhǎng)度為 4，因此指針數(shù)組中還有 3 個(gè)空位保存新的元素。由于每次重新分配指針數(shù)組時(shí)，都會(huì)預(yù)分配一些額外空間，因此往列表中添加元素的平均時(shí)間復(fù)雜度為 O(1)。

下面再看看從列表刪除元素時(shí)，各個(gè)字段的變化：

def test_list2():
    alist = [1] * 10000
    alist_obj = PyList.from_address(id(alist))

    alist_obj.print_field()
    del alist[10:]
    alist_obj.print_field()

運(yùn)行test_list2()得到下面的結(jié)果：

>>> test_list2()
10000 10000 
10 17 

可以看出大指針數(shù)組的位置沒有發(fā)生變化，但是后面額外的空間被回收了。