Python源码剖析笔记4-内建数据类型

Python源码剖析笔记4-内建数据类型

Python内建数据类型包括整数对象PyIntObject，字符串对象PyStringObject，列表对象PyListObject以及字典对象PyDictObject等。整数对象之前已经分析过了，这一篇文章准备分析下余下几个对象，这次在《python源码剖析》中已经写的很详细的部分就不赘述了，主要是总结一些之前看书时疑惑的地方。

1 整数对象-PyIntObject

参见 python整数对象。

2 字符串对象-PyStringObject

2.1 基本定义

python中的字符串对象PyStringObject，对应的类型对象是PyString_Type。PyStringObject对象的定义如下：

#define PyObject_VAR_HEAD   \
  Py_ssize_t ob_refcnt;     struct _typeobject *ob_type;    Py_ssize_t ob_size;

typedef struct {
    PyObject_VAR_HEAD //对象头
    long ob_shash; //字符串哈希值
    int ob_sstate; //对象状态
    char ob_sval[1]; //字符串内容

    /* Invariants:
     *     ob_sval contains space for ‘ob_size+1‘ elements.
     *     ob_sval[ob_size] == 0.
     *     ob_shash is the hash of the string or -1 if not computed yet.
     *     ob_sstate != 0 iff the string object is in stringobject.c‘s
     *       ‘interned‘ dictionary; in this case the two references
     *       from ‘interned‘ to this object are *not counted* in ob_refcnt.
     */
} PyStringObject;

字符串长度在头部PyObject_VAR_HEAD的ob_size字段中维护，而ob_sval则是指向一段长度为ob_size+1个字节的内存，比如字符串’hello’，ob_size=5，而ob_sval长度为6，ob_sval[6] = ‘\0’。 ob_sstate是字符串状态，标示字符串是否经过intern机制处理。ob_shash是字符串的哈希值，在字典以及字符串比较等多处有用到这个哈希值。

2.2 字符串interned机制

当然在字符串对象中一个比较重要的就是intern机制。那么问题来了，什么样的字符串才会interned呢？实验一下先，可以发现如果字符串有空格是不会被interned的，实际上，字符串中的字符必须都是属于"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"才会interned。例子中的hello world因为有空格不在interned字符集中，所以该字符串不会interned。这个是在构建PyCodeObject对象的时候进行的。之前已经分析过，python的py文件需要编译成字节码执行，当然直接执行和import导入模块有所不同，不过都会构建PyCodeObject对象。在构建PyCodeObject对象函数PyCode_New(Objects/codeObject.c文件)中，会执行变量名、常量等字符串的interned操作。

另外一个需要说明的是，在编译py文件成字节码并保存到pyc文件过程中，字符串对象分为三种情况处理。其一是非interned字符串，比如刚刚说的hello world字符串，对象标识是s。其二是interned字符串，比如hello，对象标识是t。其三是已经interned过的字符串，在pyc中记录的对象标识是R。之所以有R标记的字符串，是为了节省空间，因为它最终只记录一个字符串的偏移位置。比如之前已经有了字符串’hello’,则写入标记s以及字符串内容’hello’,第二次遇到’hello’时则只是写入标记R以及’hello’在常量元组co_consts中的索引值。这样从pyc内容中构建PyCodeObject对象的时候，根据R标识类型字符串记录的索引得到字符串。

#测试intern机制test_interned.py
a = ‘hello world‘
b = ‘hello‘

def test():
    c = ‘hello world‘
    d = ‘hello‘
    print c is a  #False，‘hello world‘ 没有interned
    print d is b  #True， ‘hello‘ 已经interned

test()

关于R标记，还要多说一点，我之前看书的时候也有点疑惑什么情况下会用到R标记呢，因为你在一个模块里面对一个字符串多次引用，在PyCodeObject对象的co_consts中还是只会存在一份的。比如下面的代码，显然s和t针对test.py对应的PyCodeObject对象，只会有一个常量’hello’,虽然这个字符串会被interned，那么R标记是用在哪里呢？其实是用在另外的PyCodeObject中。比如下面的代码，对应两个PyCodeObject，其中test_stringref.py本身一个，以及函数test对应一个PyCodeObject。编译后得到的pyc文件内容如下所示，根据前面的文章pyc格式分析，可以看到在test_stringref.py本身对应的PyCodeObject中，co_consts为(‘hello‘, <code object test at 0x10c130af8, file "str.py"", line 4>, None)，这里看到s和t引用的是同一个字符串，这一点通过字节码指令也可以看到。 在pyc中’hello’存储的是标识t以及字符串内容。而函数test对应的PyCodeObject中，对应的co_consts为(None, hello)，但是在pyc中对应字符串hello存储的是标记R以及索引0。

此外，如果直接运行python xxx.py，虽然也会编译成PyCodeObject对象，但是不会生成pyc文件，也不会有R标识类型这些东西了，不过interned机制在运行的时候同样会生效。不同的地方在于，如果是从pyc文件运行会根据R标识类型来将对应字符串指向同一个对象，而如果是直接运行的，则需要通过interned字典来对后面遇到的相同的可以interned字符串对象赋值为interned字符串对象的地址，进行并回收后面遇到的那个字符串。

单个字符和空字符都会interned，这个可以很简单的验证。

#测试字符串类型标识 test_stringref.py
s = ‘hello‘
t = ‘hello‘
def test():
    k = ‘hello‘

#test_stringref.py对应的字节码
          0 LOAD_CONST          0 (0)
          3 STORE_NAME          0 (0)
          6 LOAD_CONST          0 (0)
          9 STORE_NAME          1 (1)
         12 LOAD_CONST          1 (1)
         15 MAKE_FUNCTION       0
         18 STORE_NAME          2 (2)
         21 LOAD_CONST          2 (2)
         24 RETURN_VALUE   

#test_stringref.pyc文件
00000000  03 f3 0d 0a 78 3e 99 55  63 00 00 00 00 00 00 00  |....x>.Uc.......|
00000010  00 01 00 00 00 40 00 00  00 73 19 00 00 00 64 00  |[email protected]|
00000020  00 5a 00 00 64 00 00 5a  01 00 64 01 00 84 00 00  |.Z..d..Z..d.....|
00000030  5a 02 00 64 02 00 53 28  03 00 00 00 74 05 00 00  |Z..d..S(....t...|
00000040  00 68 65 6c 6c 6f 63 00  00 00 00 01 00 00 00 01  |.helloc.........|
00000050  00 00 00 43 00 00 00 73  0a 00 00 00 64 01 00 7d  |...C...s....d..}|
00000060  00 00 64 00 00 53 28 02  00 00 00 4e 52 00 00 00  |..d..S(....NR...|
00000070  00 28 00 00 00 00 28 01  00 00 00 74 01 00 00 00  |.(....(....t....|
00000080  6b 28 00 00 00 00 28 00  00 00 00 73 1d 00 00 00  |k(....(....s....|
00000090  2f 55 73 65 72 73 2f 73  73 6a 2f 50 72 6f 67 2f  |/Users/ssj/Prog/|
000000a0  70 79 74 68 6f 6e 2f 73  74 72 2e 70 79 74 04 00  |python/str.pyt..|
000000b0  00 00 74 65 73 74 04 00  00 00 73 02 00 00 00 00  |..test....s.....|
000000c0  01 4e 28 03 00 00 00 74  01 00 00 00 73 74 01 00  |.N(....t....st..|
000000d0  00 00 74 52 02 00 00 00  28 00 00 00 00 28 00 00  |..tR....(....(..|
000000e0  00 00 28 00 00 00 00 73  1d 00 00 00 2f 55 73 65  |..(....s..../Use|
000000f0  72 73 2f 73 73 6a 2f 50  72 6f 67 2f 70 79 74 68  |rs/ssj/Prog/pyth|
00000100  6f 6e 2f 73 74 72 2e 70  79 74 08 00 00 00 3c 6d  |on/str.pyt....<m|
00000110  6f 64 75 6c 65 3e 01 00  00 00 73 04 00 00 00 06  |odule>....s.....|
00000120  01 06 02                                          |...|
00000123

2.3 字符串拼接效率问题

另外一个需要注意的就是字符串拼接的效率问题。如果是简单的 s1+s2+s3这样拼接，那么每次拼接都要分配一次内存，这样需要分配两次内存。而如果通过‘‘.join([s1, s2, s3])来拼接，则只需要分配一次内存，在拼接字符串较多的时候，通过join操作拼接字符串效率会有大幅提高。

3 列表对象-PyListObject

Python中的List对象实现有点类似STL中的vector，依托的是数组形式来实现列表。定义如下：

typedef struct {
    PyObject_VAR_HEAD
    /* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */
    PyObject **ob_item;
    Py_ssize_t allocated;
} PyListObject;

可以看到前面跟PyStringObject是一样的头部，其中的ob_size是当前列表元素数目，而allocated是分配的空间大小， ob_size <= allocated，也就是说一般情况下会多分配一点空间，以减少多次分配带来性能问题。列表初始化分为两部分，列表本身结构初始化和列表维护的对象列表ob_item初始化。当然，列表本身初始化也采用了缓冲池机制，如果缓冲池列表中有空闲的列表可以用，就可以直接拿来用而不需要再次分配内存了。当然，虽然列表结构本身可以通过缓冲池复用，但是其中维护的对象列表ob_item是不会复用的，从缓冲池中得到列表结构后还需要给ob_item分配空间（空间大小为 size * sizeof(PyObject *),size为创建的列表大小）。

列表分配的空间大小allocated在通过insert，append操作插入元素时或者通过remove, del操作时会进行调整，也就是说即可能变大也可能变小。调整列表大小的函数是list_resize()，调整条件如下:

(1) newsize <= allocated && newsize >= allocated / 2:简单调整ob_size的值，不需要扩容。
(2) 否则，调整大小为 new_allocated = (newsize >> 3) + (newsize < 9 ? 3: 6) + newsize.

那么，假定有一个语句如下list = [1]，则字节码其实就是创建一个大小为1(ob_size和allocated此时都是1)的列表，然后将列表list中的ob_item的第0个元素设置为整数对象1。需要注意的是，当你创建一个空列表然后直接赋值则会出错的，比如下面那样，这是因为你创建一个空列表时ob_item被设置为NULL，并没有分配内存，因此会报错。

##test1.py 未分配对象列表内存导致赋值错误
list = []
list[0] = 1 #错误

还是继续刚刚那个栗子，现在有列表list=[1]，然后执行list.append(2)，此时ob_size=2，而根据上面的策略，allocated调整为5.再执行list.append(3)插入3，则此时ob_size=3，而allocated=5不变。如果接着list.remove(2)，则ob_size=2，allocated=5不变。此时如果再执行list.remove(3)，则根据上面的调整公式，ob_size=1，allocated减小到4。

4 字典对象-PyDictObject

python字典对象采用的散列冲突解决方法为开放定址法，不同于STL中的开链法。python采用的开放定址法在发生散列冲突时，会根据一个冲突探测函数计算下一个探测的位置，直到找到一个不冲突的位置。而在删除元素的时候，并不会直接删除，而是设置一个dummy标记，这样可以保证在冲突探测的时候不出错，此外这个dummy标记的元素下次插入新元素时可以被再次利用。

字典中的一个键值对称为一个entry，字典由PyDictEntry的数组构成。定义如下：

typedef struct {
  Py_ssize_t me_hash; //me_key的哈希值
  PyObject *me_key;
  PyObject *me_value;
} PyDictEntry;  

#define PyDict_MINSIZE 8
typedef struct _dictobject PyDictObject;
struct _dictobject {
  PyObject_HEAD
  Py_ssize_t ma_fill;  /* # Active + # Dummy */
  Py_ssize_t ma_used;  /* # Active */
  Py_ssize_t ma_mask;
  PyDictEntry *ma_table;
  PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
  PyDictEntry ma_smalltable[PyDict_MINSIZE];
};

键值对有active， dummy以及unused三个状态。初始为unused状态，me_key == NULL, me_value == NULL。而如果是active状态，则me_key != NULL, me_key != dummy, me_value != NULL,如果是dummy状态，则me_key == dummy, me_value == NULL.三个状态的转换则是：执行插入操作则由unused或者dummy状态变成active状态，执行删除操作则从active状态变成dummy状态。

PyDictObject定义如上面所示，其中ma_fill是元素总数目，包括active和dummy状态的键值对。而ma_used是active键值对数目，ma_mask用来定位元素在数组中的索引，大小为数组长度减一。如果数组ma_table为8，则ma_mask值为7.注意，这里还有个ma_smalltable，大小初始为8,初始化时，字典的ma_table会指向ma_smalltable，当装载率大于等于2/3时，字典扩容。(即ma_fill / (ma_mask + 1)) >=2/3)，会将ma_table指向新分配的空间，并搬移键值对到新的table中。

PyDictObject也采用了缓冲池机制，其原理类似PyListObject，这里不再赘述。需要额外提到的一点是字典中的元素搜索机制，这里说下常用的lookdict_string函数，其针对的是字符串键的查找。查找流程如下：

a. 查找的时候会先根据字符串hash值获取键值对索引，如果对应的键值对entry为unused状态，则表示搜索失败，如果freeslot不为NULL，则返回freeslot（freeslot指向dummy状态的entry），否则返回entry。
b. 如果entry为其他状态，则检查me_key引用是否相同，相同则返回该entry.
c. 如果me_key引用不同，则检查me_key值是否相同(即比较hash值以及me_key的值)，如果相同，则返回entry，否则继续下一轮查询。

python中冲突探测函数如下，其中j为当前的索引，perturb初始化为me_key的hash值，通过不断调整j和perturb值，会不断探测ma_table数组中的元素。由于perturb值是不断减小的，所以最终会退化为j = 5 * j + 1，假定元素数为8，初始j = 0， 使用退化后的探测函数探测到的索引依次是 0, 1, 6, 7, 4, 5, 2, 3, 0。这个探测函数顺序有一定随机性，这其实是通过一个线性同余方程来获取2**i范围内的伪随机数作为索引，比线性探测函数如f(x) = x + 1效果要好一些。其中2**i是哈希表大小。至于为什么 j = (5*j) + 1; j % 2**i;这样能够得到0...2**i-1范围内的数字后再从头开始循环，证明方法暂时没有找到，不过简单验证确实是没有问题的。

 j = (5*j) + 1 + perturb; // perturb初始值为键的hash值
 perturb >>= PERTURB_SHIFT; // PERTURB_SHIFT=5，据说效果比较好
 use j % 2**i as the next table index;

根据这个冲突探测算法，可以看到字典中插入键值对时的冲突探测和解决流程。具体例子参见http://www.laurentluce.com/posts/python-dictionary-implementation/

版权声明：本文为博主原创文章，未经博主允许不得转载。

时间： 2024-10-21 16:37:02

Python源码剖析笔记4-内建数据类型的相关文章

python源码剖析笔记1——Python对象初见

python源码剖析笔记1--Python对象初见 工作整两年了,用python最多,然而对于python内部机制不一定都清楚,每天沉醉于增删改查的简单逻辑编写,实在耗神.很多东西不用就忘记了,比如C语言,正好,python源码用C写的,分析python源码的同时又能温故C语言基础,实在是件很好的事情.另外,还有陈儒大神的<python源码剖析>做指引,分析也不至于没头没脑.期望在一个月的业余时间,能有所小成,以此为记. 1 python中的对象 python中,一切东西都是对象,在c语言实现

Python源码剖析笔记3-Python执行原理初探

Python源码剖析笔记3-Python执行原理初探 本文简书地址:http://www.jianshu.com/p/03af86845c95 之前写了几篇源码剖析笔记,然而慢慢觉得没有从一个宏观的角度理解python执行原理的话,从底向上分析未免太容易让人疑惑,不如先从宏观上对python执行原理有了一个基本了解,再慢慢探究细节,这样也许会好很多.这也是最近这么久没有更新了笔记了,一直在看源码剖析书籍和源码,希望能够从一个宏观层面理清python执行原理.人说读书从薄读厚,再从厚读薄方是理解了

Python源码剖析笔记2-Python整数对象

Python源码剖析笔记2-Python整数对象 本文简书地址: http://www.jianshu.com/p/0136ed90cd46 千里之行始于足下,从简单的类别开始分析,由浅入深也不至于自己丧失信心.先来看看Python整数对象,也就是python中的PyIntObject对象,对应的类型对象是PyInt_Type. 1 Python整数对象概览 为了性能考虑,python中对小整数有专门的缓存池,这样就不需要每次使用小整数对象时去用malloc分配内存以及free释放内存.pyth

Python源码剖析笔记0 ——C语言基础

python源码剖析笔记0--C语言基础回顾 要分析python源码,C语言的基础不能少,特别是指针和结构体等知识.这篇文章先回顾C语言基础,方便后续代码的阅读. 1 关于ELF文件 linux中的C编译得到的目标文件和可执行文件都是ELF格式的,可执行文件中以segment来划分,目标文件中,我们是以section划分.一个segment包含一个或多个section,通过readelf命令可以看到完整的section和segment信息.看一个栗子: char pear[40]; static

Python源码剖析笔记6-函数机制

Python的函数机制是很重要的部分,很多时候用python写脚本,就是几个函数简单解决问题,不需要像java那样必须弄个class什么的. 本文简书地址:http://www.jianshu.com/p/d00108741a18 1 函数对象PyFunctionObject PyFunctionObject对象的定义如下: typedef struct { PyObject_HEAD PyObject *func_code; /* A code object */ PyObject *func

Python源码剖析笔记5-模块机制

本文简书地址: http://www.jianshu.com/p/14586ec50ab6 python中经常用到模块,比如import xxx,from xxx import yyy这样子,里面的机制也是需要好好探究一下的,这次主要从黑盒角度来探测模块机制,源码分析点到为止,详尽的源码分析见陈儒大神的<python源码剖析>第14章. 1 如何导入模块 首先来看一个导入模块的例子.创建一个文件夹demo5,文件夹中有如下几个文件. [email protected] ~/demo5 $ ls

《python源码剖析》笔记 python虚拟机中的一般表达式

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie 1.字节码指令 LOAD_CONST:从consts表中读取序号为i的元素并压入到运行时栈中 STORE_NAME:改变local名字空间.从符号表names取序号为i的元素作为变量名, 取运行时栈的栈顶元素作为变量值,完成从变量名到变量值的映射关系的创建. BUILD_MAP:创建一个空的PyDictObject对象,并压入运行时栈 DUP_TOP:将栈顶元素的引用计数增加1,并将它再次

《python源码剖析》笔记 python对象初探

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie 1.      在python中,对象就是为C中的结构体在堆上申请的一块内存.对象不能被静态初始化,也不能在栈空间生存.但内建的类型对象都是被静态初始化的. 2.      对象创建后大小不变.可变对象有一指针指向可变大小的内存区域. 3.      对象机制的基石:PyObject 定长对象: typedef struct _object{ PyObject_HEAD }PyObject

《python源码剖析》笔记 python多线程机制

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie 1.GIL与线程调度 Python中的线程是操作系统的原生线程,Python虚拟机使用一个全局解释器锁(Global Interpreter Lock)来互斥线程对Python虚拟机的使用 为了支持多线程机制,一个基本的要求就是需要实现不同线程对共享资源访问的互斥,所以引入了GIL. GIL:在一个线程拥有了解释器的访问权之后,其他的所有线程都必须等待它释放解释器的访问权,即使这些线程的下