Name: Python源码剖析
ISBN: 9787121068744

作者: 陈儒
出版社: 电子工业出版社
出品方: 博文视点
副标题: 深度探索动态语言核心技术
出版年: 2008-6
页数: 480
定价: 69.80元
装帧: 平装
ISBN: 9787121068744

豆瓣评分

8.7

731人评价

5星

48.0%
4星

41.7%
3星

8.9%
2星

0.7%
1星

0.7%

评价:

内容简介 · · · · · ·

作为主流的动态语言，Python不仅简单易学、移植性好，而且拥有强大丰富的库的支持。此外，Python强大的可扩展性，让开发人员既可以非常容易地利用C/C++编写Python的扩展模块，还能将Python嵌入到C/C++程序中，为自己的系统添加动态扩展和动态编程的能力。.

为了更好地利用Python语言，无论是使用Python语言本身，还是将Python与C/C++交互使用，深刻理解Python的运行原理都是非常重要的。本书以CPython为研究对象，在C代码一级，深入细致地剖析了Python的实现。书中不仅包括了对大量Python内置对象的剖析，更将大量的篇幅用于对Python虚拟机及Python高级特性的剖析。通过此书，读者能够透彻地理解Python中的一般表达式、控制结构、异常机制、类机制、多线程机制、模块的动态加载机制、内存管理机制等核心技术...

(展开全部)

在线试读前往豆瓣阅读试读本书

目录 · · · · · ·

第0章 Python源码剖析——编译Python
0.1 Python总体架构
0.2 Python源代码的组织
0.3 Windows环境下编译Python
0.4 Unix/Linux环境下编译Python
0.5 修改Python源代码
· · · · · · (更多)

豆瓣成员常用的标签(共242个) · · · · · ·

python 编程 Python 计算机编译原理程序语言 programming 程序设计

喜欢读"Python源码剖析"的人也喜欢的电子书 · · · · · ·

支持 Web、iPhone、iPad、Android 阅读器

: 自制编程语言

39.99元

: CoffeeScript小书

1.99元

: 七周七并发模型

24.99元

: 深入理解Nginx：模块开发与架构解析

30.00元

: 编程大师访谈录

24.99元

喜欢读"Python源码剖析"的人也喜欢 · · · · · ·

: UNIX编程艺术

: 程序员的自我修养

: 计算机程序的构造和解释

: STL源码剖析

: 深度探索C++对象模型

: 集体智慧编程

: UNIX环境高级编程

: Python高级编程

: 深入理解计算机系统

: 精通正则表达式

我来说两句

短评 · · · · · · ( 全部 166 条 )

Python源码剖析的话题 · · · · · · ( 全部条 )

什么是话题

无论是一部作品、一个人，还是一件事，都往往可以衍生出许多不同的话题。将这些话题细分出来，分别进行讨论，会有更多收获。

我要写书评

Python源码剖析的书评 · · · · · · ( 全部 23 条 )

万众期待的优秀著作

Python 是公认的优秀语言，而很多人可能并不知道，标准python实现，同样是非常优秀的C源码项目。它利用中立的标准C语言，洗练的实现了动态面向对象环境，使得Python语言的灵活和优雅得以充分体现。Python平台的C源码，本身就具体很高的学习价值。然而像其它成功的大型开源项目... (展开)

6 29回应

LipingTaBaBa 2012-01-12 00:13:02

态度诚恳，但是缺乏洞见

这本书其实不是面向python用户的，而是剖析python的运行时实现。更适合于进阶C程序员以提高C语言能力。不过不知道是作者功底不够，还是时间太紧，很多地方作者罗里罗嗦的写了好几页纸，比人家源代码还长，可还没有源代码里的注释讲得清楚。我仔细看过的有第十六章《Python... (展开)

8回应

E.T 2009-07-10 22:25:09

只说不足的

好的方面已经有很多读者说过了，这里提一下我认为做得不好的几点，概括起来是“二多一缺”：二多：“口水话”多，本人认为对增进理解或过渡没有太大作用；typo 多，需要质疑一下校对者的水平。一缺：缺少参考书目，经常读国外技术书籍的人应该不会对bibliography这个词感到... (展开)

3 7回应

丸子(^.^)v 2011-04-03 17:50:54

貌似是第一本对python的实现进行讲解的书

对平台对编译器的熟悉的重要性已经不需要再强调了吧～虽然表面上跟很多职位没有直接的联系～个人觉得对android源码的解读对python perl以及一切优秀开源的底层产品的解读标志着你在公司里是不是不可取代的～最近甚至觉得，对于拿着文档用一套API编程的位置，... (展开)

2 6回应

Fenng 2008-07-09 10:12:00

我写的推荐序

非常高兴看到又一本原创 Python 图书的出版。说起来，我和 Python 还算有一点缘分。在 2000 年的时候，非常偶然的一次机会接触到Python，当时网上资料非常之少，不知天高地厚的我竟冒失地接手了国内第一本引进 Python 图书的合作翻译工作，往事不堪回首。记得当时经常有人问... (展开)

24 11回应

simonliu 2012-01-30 11:31:57

国内技术书籍神作

这篇书评可能有关键情节透露

其实这本书已经在我书桌上摆了很久，断断续续看完了，后来又从头看了一遍，总体感觉呢就两个字“佩服”。作者在 Python 研究方面不一定是国内最牛的，关于作者的文笔风格争议也颇多，但是作者是第一个把研究 Python 的收获传播出来的人，光是这一点就比那些成天在那里嚷嚷说... (展开)

1 0回应

海猫 2008-07-27 21:38:49

国内称得上“著”的书不多，这本书不但是著，而是著得不错。

互动网会员名：fullsail　　　　我在书店已经买到了，国内称得上“著”的书不多，这本书不但是著，而是著得不错。看完第一个部分就已经收益不浅啦： 1、了解int、string，list，dict的内部机理，这样你可以避免一些很低效的使用模式。诸如多个字符串连接时如何做效率最好之类... (展开)

2 0回应

jeremychen 2009-02-10 17:15:44

非常好的书，要了解虚拟机的可以看下

写python半年后的一天,看书名不错，随便买了看看，想不到物超所值，为自己省下了不少了解python的时间： 1：文章很大篇幅讲了python虚拟机如何模拟类似x86机器语言的堆栈运行机制，很多地方作者很负责的配了流程图和测试代码。 2：书中描述了Python设计者如何在对象分配等缓存... (展开)

1 1回应

ggarlic 2016-03-23 14:13:36

正副标题应该换换

我觉得这本书只是恰好用python讲而已，其实这是一本讲c跟编程语言实现的书，反正我看完了c功力见长：内置数据结构各种课本标准实现，还有各种拿c搞继承跟多态。虚拟机挺好玩，各种模拟基于堆栈的方式。见到了传说中的GIL的实现。还有各种层面进行缓存，以及增加cache友好性。... (展开)

1 0回应

gashero 2008-07-03 15:14:09

期待啊

网上拍下了这本书，邮寄中，应该明天就到了。这也是我买的第一本Python书籍，作者研究Python源码的过程我也是经常关注的，一直等到出书。 (展开)

12回应

> 更多书评23篇

读书笔记 · · · · · · (共45篇)

我来写笔记

按有用程度
按页码先后
最新笔记

展开收起
第五章 Python中的dict对象

goorockey

由于python很多地方都用字典类型实现，对速度要求高，所以： 1、python的字典通过散列表实现，搜索的时间复杂读为O(1)（C++的STL的map是用红黑树来实现，搜索的时间复杂度为O(log2N)） 2、通过开放定址法处理冲突（SGI STL的散列map通过开链法处理冲突）开放定址法在发生冲突时，通过探测函数继续寻找可用的节点，直到找到可用的为止，这就形成了多条以探测函数为索引的探测链。则删除节点时，不能直接去除，而只能做标记...
2013-01-09 21:58 6人喜欢

由于python很多地方都用字典类型实现，对速度要求高，所以：
1、python的字典通过散列表实现，搜索的时间复杂读为O(1)（C++的STL的map是用红黑树来实现，搜索的时间复杂度为O(log2N)）
2、通过开放定址法处理冲突（SGI STL的散列map通过开链法处理冲突）
开放定址法在发生冲突时，通过探测函数继续寻找可用的节点，直到找到可用的为止，这就形成了多条以探测函数为索引的探测链。
则删除节点时，不能直接去除，而只能做标记（伪删除）。否则会打断所在的探测链，使得其后面的探测链节点不能被索引到。
每个节点entry的结构：
typedef struct {
/* Cached hash code of me_key. Note that hash codes are C longs.
* We have to use Py_ssize_t instead because dict_popitem() abuses
* me_hash to hold a search finger.
*/
Py_ssize_t me_hash;
PyObject *me_key;
PyObject *me_value;
} PyDictEntry;
每个entry都有三种状态：
Unused：me_key == NULL && me_value == NULL
Active： me_key != NULL && me__key != dummy && me_value != NULL
Dummy：me_key == dummy && me_value == NULL
字典对象的定义：
typedef struct _dictobject PyDictObject;
struct _dictobject {
PyObject_HEAD
Py_ssize_t ma_fill; /* # Active + # Dummy */
Py_ssize_t ma_used; /* # Active */
/* The table contains ma_mask + 1 slots, and that's a power of 2.
* We store the mask instead of the size because the mask is more
* frequently needed.
*/
Py_ssize_t ma_mask;
/* ma_table points to ma_smalltable for small tables, else to
* additional malloc'ed memory. ma_table is never NULL! This rule
* saves repeated runtime null-tests in the workhorse getitem and
* setitem calls.
*/
PyDictEntry *ma_table;
PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
PyDictEntry ma_smalltable[PyDict_MINSIZE];
};
每个字典对象都有PyDict_MINSIZE（默认为8）个初始申请了的节点的ma_smalltable，ma_table开始会指向ma_smalltable
哈希函数lookdict：
通过直接把key和ma_mask做与运算求得哈希值，其中的技巧(trick)：
ma_mask是散列表容量减一，表示散列表索引的最大值(0~ma_mask)
把key和ma_mask做与运算，得到的值肯定小于等于ma_mask，则索引值肯定在散列表内
散列表容量都设为2的幂，使得ma_mask的二进制位肯定都是1，则可以减少与运算得到的冲突，即：
如果不全为1，例如ma_mask是110，则对于key为10和11会得到相同的索引值，因为最低为被掩盖，索引值最低位肯定为0，增加了冲突率
在搜索时，用freeslot记录搜索到的dummy节点，
在搜索到key相同的节点前搜索到Unused节点时，如果freeslot不为空，即之前找到一个可用的dummy节点，则返回这个freeslot的节点，否则返回Unused节点
散列表装载率大于2／3时，发生冲突的概率会大大增加
缓存池
PyDictObject也使用跟PyListObject一样的缓存池机制：回收已申请的dict对象，来给新创建的dict对象用

推荐

回应 2013-01-09 21:58
展开收起
第479页
[已注销]
Python 拥有两套垃圾回收机制。除了引用计数，还有个专门处理循环引用的 GC。通常提到垃圾回收时，都是指这个 "Reference Cycle Garbage Collection"。能引发循环引用用问题的，都是那种容器类对象，比如 list、set、object 等。对于这类对象，虚拟机在为其分配内存时，会额外添加⽤用于追踪的 PyGC_Head。这些对象被添加到特殊链表里，以便GC 进行管理。同 .NET、JAVA 一样，Python GC 同样将要回收的对象..
2013-02-02 21:49 2人喜欢
Python 拥有两套垃圾回收机制。除了引用计数，还有个专门处理循环引用的 GC。
通常提到垃圾回收时，都是指这个 "Reference Cycle Garbage Collection"。
能引发循环引用用问题的，都是那种容器类对象，比如 list、set、object 等。对于这类对象，虚拟机在为其分配内存时，会额外添加⽤用于追踪的 PyGC_Head。这些对象被添加到特殊链表里，以便GC 进行管理。
同 .NET、JAVA 一样，Python GC 同样将要回收的对象分成 3 级代龄。GEN0 管理新近加入的年轻对象，GEN1 则是在上次回收中依然存活的对象，剩下 GEN2 存储的都是生命周期极长的家伙。每级代龄都有一个最大容量阀值，每次 GEN0 对象数量超出阀值时，都将引发垃圾回收操作。
===================================================
包含 __del__ 方法的循环引用对象，永远不会被 GC 回收，直至进程终止。
*因 IPython 对 GC 存在干扰，对GC的测试最好在原生 shell 中进行。
*连空的__del__也不行，GC就是没办法！
===================================================
其他有可能影响垃圾回收的因素：
*对象变量名，Python的内存回收顺序与字典先后顺序有关，如官网说：
Warning Due to the precarious circumstances under which __del__() methods are invoked, exceptions that occur during their execution are ignored, and a warning is printed to sys.stderr instead. Also, when __del__() is invoked in response to a module being deleted (e.g., when execution of the program is done), other globals referenced by the __del__() method may already have been deleted or in the process of being torn down (e.g. the import machinery shutting down). For this reason, __del__() methods should do the absolute minimum needed to maintain external invariants. Starting with version 1.5, Python guarantees that globals whose name begins with a single underscore are deleted from their module before other globals are deleted; if no other references to such globals exist, this may help in assuring that imported modules are still available at the time when the __del__() method is called.
====================================================
对于不能处理的__del___，Python的实现过程是这样的：
*将所有在unreachable链表当中的带有__del__方法的对象及其包含的子对象放到finalizer链表当中：
gc_list_init(&finalizers); move_finalizers(&unreachable, &finalizers); move_finalizer_reachable(&finalizers);
*接下来在delete_garbage里调用unreachable链表当中的对象的tp_clear方法，该方法会将引用环打破，使得对象能够正常析构掉。
m += handle_weakrefs(&unreachable, old); delete_garbage(&unreachable, old);
*所有的GC回收也在这里完成了，接下来还有一部分代码是统计成功回收的对象个数，统计finalizers带有里面__del__方法无法回收的垃圾对象个数，并且将finalizers所有对象移动到garbage这个列表当中，留给程序设计者去决定怎么释放这些对象。

推荐

回应 2013-02-02 21:49
展开收起
Python代码对象

goorockey

一个Code Block算一个名字空间，一个Code Block指一个名字空间或者作用域一个名字空间对应编译出一个PyCodeObject，对应一个pyc文件 PyCodeObject是python的编译结果，运行结束后，可以把一个PyCodeObject保存为pyc文件，下次运行可以直接从pyc文件中读取该PyCodeObject，而不用再编译 pyc文件只是PyCodeObject的硬盘表现 /* Bytecode object */ typedef struct { PyObject_HEAD int co_argcount; /...
2013-01-09 22:04 2人喜欢

一个Code Block算一个名字空间，一个Code Block指一个名字空间或者作用域
一个名字空间对应编译出一个PyCodeObject，对应一个pyc文件
PyCodeObject是python的编译结果，
运行结束后，可以把一个PyCodeObject保存为pyc文件，下次运行可以直接从pyc文件中读取该PyCodeObject，而不用再编译
pyc文件只是PyCodeObject的硬盘表现
/* Bytecode object */
typedef struct {
PyObject_HEAD
int co_argcount; /* #arguments, except *args */
int co_nlocals; /* #local variables */
int co_stacksize; /* #entries needed for evaluation stack */
int co_flags; /* CO_..., see below */
PyObject *co_code; /* instruction opcodes */
PyObject *co_consts; /* list (constants used) */
PyObject *co_names; /* list of strings (names used) */
PyObject *co_varnames; /* tuple of strings (local variable names) */
PyObject *co_freevars; /* tuple of strings (free variable names) */
PyObject *co_cellvars; /* tuple of strings (cell variable names) */
/* The rest doesn't count for hash/cmp */
PyObject *co_filename; /* string (where it was loaded from) */
PyObject *co_name; /* string (name, for reference) */
int co_firstlineno; /* first source line number */
PyObject *co_lnotab; /* string (encoding addr<->lineno mapping) See
Objects/lnotab_notes.txt for details. */
void *co_zombieframe; /* for optimization only (see frameobject.c) */
PyObject *co_weakreflist; /* to support weakrefs to code objects */
} PyCodeObject;
co_code是这个PyCodeObject的字节码
co_consts记录这个PyCodeObject内的所有常量对象（指除了PyStringObject的所有对象，PyStringObject保存在co_names和 co_varnames），所以这里包内了这个PyCodeObject中嵌套的PyCodeObject
co_lnotab是字节码指令在源码中的偏移h
WFILE结构体：
typedef struct {
FILE *fp;
int error; /* see WFERR_* values */
int depth;
/* If fp == NULL, the following are valid: */
PyObject *str;
char *ptr;
char *end;
PyObject *strings; /* dict on marshal, list on unmarshal */
int version;
} WFILE;
其中的strings是用于管理intern的PyStringObject的，
在保存PyStringObject时，strings是dict对象，记录intern了的PyStringObject的值到一个索引值的映射，
读取PyStringObject时，string是一个list对象，记录已经读到的intern了的PyStringObject索引和它内容的关系
字节码：
字节码定义在opcode.h，大于90的是有入参的字节码
可以通过dis.dis来解析pyc文件的字节码：
第一列是字节码对应pcy文件的第几行
第二列是字节码在co_code的偏移
第三列是当前的字节码
第四列是当前字节码需要的参数

推荐

回应 2013-01-09 22:04
展开收起
第8页
梦里醉逍遥 (愚者暗于成事，知者见于未萌。)
作者使用的是Python 2.5的源码，与现在我用的（2.7.3）略有不同。比如在int_print中添加PyObject_Print的部分，书中是放在fprintf(fp, "%ld", v->ob_ival)一句前面——后来的Python在这一句前后添加了Py_BEGIN_ALLOW_THREADS和Py_END_ALLOW_THREADS两个宏，如果把PyObject_Print加在这两个宏之间运行时会出现"Fatal Python error: PyEval_SaveThread: NULL tstate"的错误，原因我暂时还不知道。解决方法.. (1回应)
2013-02-12 22:22 1人喜欢
作者使用的是Python 2.5的源码，与现在我用的（2.7.3）略有不同。
比如在int_print中添加PyObject_Print的部分，书中是放在fprintf(fp, "%ld", v->ob_ival)一句前面——后来的Python在这一句前后添加了Py_BEGIN_ALLOW_THREADS和Py_END_ALLOW_THREADS两个宏，如果把PyObject_Print加在这两个宏之间运行时会出现"Fatal Python error: PyEval_SaveThread: NULL tstate"的错误，原因我暂时还不知道。解决方法就是把这句话放到第一个宏的前面。如下：
static int int_print(PyIntObject *v, FILE *fp, int flags) /* flags -- not used but required by interface */ { long int_val = v->ob_ival; // Added by Yao Li PyObject* str = PyString_FromString("Blahblahblah..."); PyObject_Print(str, stdout, 0); printf("\n"); Py_BEGIN_ALLOW_THREADS fprintf(fp, "%ld", int_val); Py_END_ALLOW_THREADS return 0; }

推荐

1回应 2013-02-12 22:22

展开收起
第8页
bombadil
其实要打印到正确的输出设备，这样就行了， /代码内容已省略/ 因为 int_print 函数第二个参数正好是输出设备 fp。没必要通过 PySys_GetObject("stdout")。
2012-07-12 17:02
其实要打印到正确的输出设备，这样就行了，
PyObject_Print(s, fp, 0);
因为 int_print 函数第二个参数正好是输出设备 fp。没必要通过 PySys_GetObject("stdout")。

推荐

回应 2012-07-12 17:02
展开收起
第8页
梦里醉逍遥 (愚者暗于成事，知者见于未萌。)
作者使用的是Python 2.5的源码，与现在我用的（2.7.3）略有不同。比如在int_print中添加PyObject_Print的部分，书中是放在fprintf(fp, "%ld", v->ob_ival)一句前面——后来的Python在这一句前后添加了Py_BEGIN_ALLOW_THREADS和Py_END_ALLOW_THREADS两个宏，如果把PyObject_Print加在这两个宏之间运行时会出现"Fatal Python error: PyEval_SaveThread: NULL tstate"的错误，原因我暂时还不知道。解决方法.. (1回应)
2013-02-12 22:22 1人喜欢
作者使用的是Python 2.5的源码，与现在我用的（2.7.3）略有不同。
比如在int_print中添加PyObject_Print的部分，书中是放在fprintf(fp, "%ld", v->ob_ival)一句前面——后来的Python在这一句前后添加了Py_BEGIN_ALLOW_THREADS和Py_END_ALLOW_THREADS两个宏，如果把PyObject_Print加在这两个宏之间运行时会出现"Fatal Python error: PyEval_SaveThread: NULL tstate"的错误，原因我暂时还不知道。解决方法就是把这句话放到第一个宏的前面。如下：
static int int_print(PyIntObject *v, FILE *fp, int flags) /* flags -- not used but required by interface */ { long int_val = v->ob_ival; // Added by Yao Li PyObject* str = PyString_FromString("Blahblahblah..."); PyObject_Print(str, stdout, 0); printf("\n"); Py_BEGIN_ALLOW_THREADS fprintf(fp, "%ld", int_val); Py_END_ALLOW_THREADS return 0; }

推荐

1回应 2013-02-12 22:22
展开收起
第17页
梦里醉逍遥 (愚者暗于成事，知者见于未萌。)
书中的版本ob_refcnt是int类型，在2.7.3中则是Py_ssize_t，后者在Include/pyport.h中定义： /代码内容已省略/ 根据PEP 353[1]的说明，这个修改应该在2.5左右就已经进行了，主要是由于64位机器越来越流行，所以引入了一个platform-specific index type Py_ssize_t。同理，书中很多其他地方的int也被改成了Py_ssize_t. [1]: http://www.python.org/dev/peps/pep-0353/
2013-02-13 16:10
书中的版本ob_refcnt是int类型，在2.7.3中则是Py_ssize_t，后者在Include/pyport.h中定义：
/* Py_ssize_t is a signed integral type such that sizeof(Py_ssize_t) == * sizeof(size_t). C99 doesn't define such a thing directly (size_t is an * unsigned integral type). See PEP 353 for details. */ #ifdef HAVE_SSIZE_T typedef ssize_t Py_ssize_t; #elif SIZEOF_VOID_P == SIZEOF_SIZE_T typedef Py_intptr_t Py_ssize_t; #else # error "Python needs a typedef for Py_ssize_t in pyport.h." #endif
根据PEP 353[1]的说明，这个修改应该在2.5左右就已经进行了，主要是由于64位机器越来越流行，所以引入了一个platform-specific index type Py_ssize_t。同理，书中很多其他地方的int也被改成了Py_ssize_t.
[1]: http://www.python.org/dev/peps/pep-0353/

推荐

回应 2013-02-13 16:10
展开收起
第17页

烟雨 (烟锁重楼千里尽，雨打芭蕉万点残)

[A.py] from B import D class C: pass [B.py] from A import C class D: pass 上面这两段代码不能相互调用，因为循环引用了在图的左边，是Python提供的大量的模块、库以及用户自定义的模块。比如在执行import os时，这个os就是Python内建的模块，当然用户还可以通过自定义模块来扩展Python系统。右边，是Python的运行时环境，包括对象/类型系统（Object/Type structures）、内存分配器（Memory Allocator...
2017-01-24 14:25

[A.py] from B import D class C: pass [B.py] from A import C class D: pass
上面这两段代码不能相互调用，因为循环引用了

在图的左边，是Python提供的大量的模块、库以及用户自定义的模块。比如在执行import os时，这个os就是Python内建的模块，当然用户还可以通过自定义模块来扩展Python系统。
右边，是Python的运行时环境，包括对象/类型系统（Object/Type structures）、内存分配器（Memory Allocator）和运行时状态信息（Current State of Python）。运行时状态维护了解释器在执行字节码时不同的状态（比如正常状态和异常状态）之间切换的动作，我们可以将它视为一个巨大而复杂的有穷状态机。内存分配器则全权负责Python中创建对象时，对内存的申请工作，实际上它就是Python运行时与C中malloc的一层接口。而对象/类型系统则包含了Python中存在的各种内建对象，比如整数、list和dict，以及各种用户自定义的类型和对象。
在中间的部分，可以看到Python的核心——解释器（interpreter），或者称为虚拟机。在解析器中，箭头的方向指示了Python运行过程中的数据流方向。其中Scanner对应词法分析，将文件输入的Python源代码或从命令行输入的一行行Python代码切分为一个的token；Parser 使用运行时里的object/type 来解析语法，这就体现了先定义后使用的原则。对后来的语法解析要仰仗于前文的定义。Parser对应语法分析，在Scanner的分析结果上进行语法分析，建立抽象语法树（AST）；Scanner 简单理解就是把代码的文本文件转化为parser可以解析的一个一个单元，其实就是个扫描的过程。Compiler是根据建立的AST生成指令集合——Python字节码（byte code），就像Java编译器和C#编译器所做的那样；最后由Code Evaluator来执行这些字节码。因此，Code Evaluator又可以被称为虚拟机。
图中，在解释器与右边的对象/类型系统、内存分配器之间的箭头表示“使用”关系；而与运行时状态之间的箭头表示“修改”关系，即Python在执行的过程中会不断地修改当前解释器所处的状态，在不同的状态之间切换。

推荐

回应 2017-01-24 14:25

展开收起
第38页
烟雨 (烟锁重楼千里尽，雨打芭蕉万点残)
对于字符串，列表之类的单一类型变量重复多次的变量，用PyVarObject来存放 /代码内容已省略/ 可以说，变长对象都是定长对象的容器。对于字符串来说，是定长对象char的容器。 ob_size指明的是所容纳元素的个数，而不是字节的数量 PyDictObject的定义里有PyObject_HEAD，而不是PyObject_VAR_HEAD，所以dict是一个定长对象而不是变长对象在_typeobject的定义中包含了许多的信息，主要可以分为...
2017-01-24 16:53
对于字符串，列表之类的单一类型变量重复多次的变量，用PyVarObject来存放
[object.h] #define PyObject_VAR_HEAD \ PyObject_HEAD \ int ob_size; /* Number of items in variable part */ typedef struct { PyObject_VAR_HEAD } PyVarObject;
可以说，变长对象都是定长对象的容器。对于字符串来说，是定长对象char的容器。
ob_size指明的是所容纳元素的个数，而不是字节的数量
PyDictObject的定义里有PyObject_HEAD，而不是PyObject_VAR_HEAD，所以dict是一个定长对象而不是变长对象
在_typeobject的定义中包含了许多的信息，主要可以分为4类： □ 类型名，tp_name，主要是Python内部以及调试的时候使用； □ 创建该类型对象时分配内存空间大小的信息，即tp_basicsize和tp_itemsize； □ 与该类型对象相关联的操作信息（就是诸如tp_print这样的许多的函数指针）； □ 我们在下面将要描述的类型的类型信息。

API。Python的C API分成两类，一类称为范型的API，或者称为AOL（Abstract Object Layer）。这类API都具有诸如PyObject_***的形式，可以应用在任何Python对象身上，比如输出对象的PyObject_Print，你可以PyObject_Print(int object)，也可以PyObject_Print(string object)，API内部会有一整套机制确定最终调用的函数是哪一个。对于创建一个整数对象，我们可以采用如下的表达式：PyObject* intObj = PyObject_New(PyObject, &PyInt_Type)。另一类是与类型相关的API，或者称为COL（Concrete Object Layer）。这类API通常只能作用在某一种类型的对象上，对于每一种内建对象，PyObject *intObj = PyInt_FromLong(10)，这样就创建了一个值为10的整数对象。

推荐

回应 2017-01-24 16:53
展开收起
第30页
烟雨 (烟锁重楼千里尽，雨打芭蕉万点残)
malloc与new的不同点：从函数声明上可以看出。malloc 和 new 至少有两个不同: new 返回指定类型的指针，并且可以自动计算所需要大小。而 malloc 则必须由我们计算要字节数，并且在返回后强行转换为实际类型的指针。第一、malloc 函数返回的是 void * 类型，如果你写成：p = malloc (sizeof(int)); 则程序无法通过编译，报错：“不能将 void* 赋值给 int * 类型变量”。所以必须通过 (int *) 来将强制转换。第二、函数的实..
2017-01-24 16:18
malloc与new的不同点：
从函数声明上可以看出。malloc 和 new 至少有两个不同: new 返回指定类型的指针，并且可以自动计算所需要大小。
而 malloc 则必须由我们计算要字节数，并且在返回后强行转换为实际类型的指针。
第一、malloc 函数返回的是 void * 类型，如果你写成：p = malloc (sizeof(int)); 则程序无法通过编译，报错：“不能将 void* 赋值给 int * 类型变量”。所以必须通过 (int *) 来将强制转换。
第二、函数的实参为 sizeof(int) ，用于指明一个整型数据需要的大小。
另外有一点不能直接看出的区别是，malloc 只管分配内存，并不能对所得的内存进行初始化，所以得到的一片新内存中，其值将是随机的。
除了分配及最后释放的方法不一样以外，通过malloc或new得到指针，在其它操作上保持一致。
对象是数据以及基于这些数据的操作的集合。
对象的存储位置：
global variables -------> data
static variables -------> data
constant data types -----> code and/or data. Consider string literals for a situation when a constant itself would be stored in the data segment, and references to it would be embedded in the code
local variables(declared and defined in functions) --------> stack
variables declared and defined in main function -----> stack
pointers(ex: char *arr, int *arr) -------> data or stack, depending on the context. C lets you declare a global or a static pointer, in which case the pointer itself would end up in the data segment.
dynamically allocated space(using malloc, calloc, realloc) --------> heap
上文来自：http://stackoverflow.com/questions/14588767/where-in-memory-are-my-variables-stored-in-c
PyObject是整个Python对象机制的核心。

[object.h] typedef struct _object { PyObject_HEAD PyObject_HEAD } PyObject;
typedef struct _object { _PyObject_HEAD_EXTRA Py_ssize_t ob_refcnt; struct _typeobject *ob_type; } PyObject;

在PyObject的定义中，整型变量ob_refcnt与Python的内存管理机制有关，它实现了基于引用计数的垃圾收集机制。对于某一个对象A，当有一个新的PyObject *引用该对象时，A的引用计数应该增加；而当这个PyObject *被删除时，A的引用计数应该减少。当A的引用计数减少到0时，A就可以从堆上被删除，以释放出内存供别的对象使用。
在Python中，对象机制的核心其实非常简单，一个是引用计数，一个就是类型对象指针。
举个类型对象的例子：
[intobject.h] typedef struct { PyObject_HEAD long ob_ival; } PyIntObject;

推荐

回应 2017-01-24 16:18
展开收起
第20页
烟雨 (烟锁重楼千里尽，雨打芭蕉万点残)
Include ：该目录下包含了Python提供的所有头文件，如果用户需要自己用C或C++来编写自定义模块扩展Python，那么就需要用到这里提供的头文件。 Lib ：该目录包含了Python自带的所有标准库，Lib中的库都是用Python语言编写的。 Modules ：该目录中包含了所有用C语言编写的模块，比如random、cStringIO等。Modules中的模块是那些对速度要求非常严格的模块，而有一些对速度没有太严格要求的模块，比如os，就是用Python编写，并且放在...
2017-01-24 14:50
Include ：该目录下包含了Python提供的所有头文件，如果用户需要自己用C或C++来编写自定义模块扩展Python，那么就需要用到这里提供的头文件。 Lib ：该目录包含了Python自带的所有标准库，Lib中的库都是用Python语言编写的。 Modules ：该目录中包含了所有用C语言编写的模块，比如random、cStringIO等。Modules中的模块是那些对速度要求非常严格的模块，而有一些对速度没有太严格要求的模块，比如os，就是用Python编写，并且放在Lib目录下的。 Parser ：该目录中包含了Python解释器中的Scanner和Parser部分，即对Python源代码进行词法分析和语法分析的部分。除了这些，Parser目录下还包含了一些有用的工具，这些工具能够根据Python语言的语法自动生成Python语言的词法和语法分析器，与YACC非常类似。 Objects ：该目录中包含了所有Python的内建对象，包括整数、list、dict等。同时，该目录还包括了Python在运行时需要的所有的内部使用对象的实现。 Python ：该目录下包含了Python解释器中的Compiler和执行引擎部分，是Python运行的核心所在。 PCBuild ：包含了Visual Studio 2003的工程文件，研究Python源代码就从这里开始（本书将采用VS2003对Python进行编译）。 PCBuild8 ：包含了Visual Stuido 2005使用的工程文件。
Yacc (Yet Another Compiler Compiler), Unix, BNF, LALR(1); Lex (Lexical analyzer)
导入库和静态库的区别很大，他们实质是不一样的东西。静态库本身就包含了实际执行代码、符号表等等，而对于导入库而言，其实际的执行代码位于动态库中，导入库只包含了地址符号表等，确保程序找到对应函数的一些基本地址信息。
简单的说，静态库和应用程序编译在一起，在任何情况下都能运行，而动态库是动态链接，顾名思义就是在应用程序启动的时候才会链接，所以，当用户的系统上没有该动态库时，应用程序就会运行失败。
再看它们的特点：
动态库： 1.共享：多个应用程序可以使用同一个动态库，启动多个应用程序的时候，只需要将动态库加载到内存一次即可； 2.开发模块好：要求设计者对功能划分的比较好。
静态库：代码的装载速度快，执行速度也比较快，因为编译时它只会把你需要的那部分链接进去，应用程序相对比较大。但是如果多个应用程序使用的话，会被装载多次，浪费内存。
[intobject.c] static int int_print(PyIntObject *v, FILE *fp, int flags) { //add by Robert PyObject* str = PyString_FromString(“i am in int_print”); PyObject_Print(str, stdout, 0); printf(“\n”); fprintf(fp, "%ld", v->ob_ival); return 0; }
下面的代码显示了如何输出到重定向后的标准输出：
static PyObject* int_repr(PyIntObject *v) { …… //add by Robert If(PyInt_AsLong(v) == -999) { PyObject* str = PyString_FromString("i am in int_repr"); PyObject* out = PySys_GetObject("stdout"); if(out != NULL) { PyObject_Print(str, stdout, 0); printf("\n"); }

推荐

回应 2017-01-24 14:50
展开收起
第17页

烟雨 (烟锁重楼千里尽，雨打芭蕉万点残)

[A.py] from B import D class C: pass [B.py] from A import C class D: pass 上面这两段代码不能相互调用，因为循环引用了在图的左边，是Python提供的大量的模块、库以及用户自定义的模块。比如在执行import os时，这个os就是Python内建的模块，当然用户还可以通过自定义模块来扩展Python系统。右边，是Python的运行时环境，包括对象/类型系统（Object/Type structures）、内存分配器（Memory Allocator...
2017-01-24 14:25

[A.py] from B import D class C: pass [B.py] from A import C class D: pass
上面这两段代码不能相互调用，因为循环引用了

在图的左边，是Python提供的大量的模块、库以及用户自定义的模块。比如在执行import os时，这个os就是Python内建的模块，当然用户还可以通过自定义模块来扩展Python系统。
右边，是Python的运行时环境，包括对象/类型系统（Object/Type structures）、内存分配器（Memory Allocator）和运行时状态信息（Current State of Python）。运行时状态维护了解释器在执行字节码时不同的状态（比如正常状态和异常状态）之间切换的动作，我们可以将它视为一个巨大而复杂的有穷状态机。内存分配器则全权负责Python中创建对象时，对内存的申请工作，实际上它就是Python运行时与C中malloc的一层接口。而对象/类型系统则包含了Python中存在的各种内建对象，比如整数、list和dict，以及各种用户自定义的类型和对象。
在中间的部分，可以看到Python的核心——解释器（interpreter），或者称为虚拟机。在解析器中，箭头的方向指示了Python运行过程中的数据流方向。其中Scanner对应词法分析，将文件输入的Python源代码或从命令行输入的一行行Python代码切分为一个的token；Parser 使用运行时里的object/type 来解析语法，这就体现了先定义后使用的原则。对后来的语法解析要仰仗于前文的定义。Parser对应语法分析，在Scanner的分析结果上进行语法分析，建立抽象语法树（AST）；Scanner 简单理解就是把代码的文本文件转化为parser可以解析的一个一个单元，其实就是个扫描的过程。Compiler是根据建立的AST生成指令集合——Python字节码（byte code），就像Java编译器和C#编译器所做的那样；最后由Code Evaluator来执行这些字节码。因此，Code Evaluator又可以被称为虚拟机。
图中，在解释器与右边的对象/类型系统、内存分配器之间的箭头表示“使用”关系；而与运行时状态之间的箭头表示“修改”关系，即Python在执行的过程中会不断地修改当前解释器所处的状态，在不同的状态之间切换。

推荐

回应 2017-01-24 14:25

> 更多读书笔记（共45篇）

论坛 · · · · · ·


绝版了？？会重印吗？？？	来自黑罗伊此言差矣	22 回应	2018-01-31
看着本书需要什么基础吗？	来自天空之城在哭泣	3 回应	2017-09-17
看完才发现Python没有JIT compiler	来自爱是寂寞人	2 回应	2014-02-13
发现python代码注释都是'//'	来自蛇口的男爵	3 回应	2012-04-05
求购或借阅 @深圳	来自Gemini		2011-08-04