本文为senlie原创，转载请保留此地址：http://blog.csdn.net/zhengsenlie

1.
Python虚拟机会从编译得到的PyCodeObject对象中依次读入每一条字节码指令，
并在当前的上下文环境中执行这条字节码指令。
Python虚拟机实际上是在模拟操作中执行文件的过程
PyCodeObject对象中包含了字节码指令以及程序的所有静态信息，但没有包含
程序运行时的动态信息——执行环境（PyFrameObject）


2.Python源码中的PyFrameObject

typedef struct _frame{
	PyObject_VAR_HEAD //"运行时栈"的大小是不确定的
	struct _frame *f_back; //执行环境链上的前一个frame，很多个PyFrameObject连接起来形成执行环境链表
	PyCodeObject *f_code; //PyCodeObject 对象，这个frame就是这个PyCodeObject对象的上下文环境
	PyObject *f_builtins; //builtin名字空间
	PyObject *f_globals;  //global名字空间
	PyObject *f_locals;   //local名字空间
	PyObject **f_valuestack; //"运行时栈"的栈底位置
	PyObject **f_stacktop;   //"运行时栈"的栈顶位置
	//...
	int f_lasti;  //上一条字节码指令在f_code中的偏移位置
	int f_lineno; //当前字节码对应的源代码行
	//...
	
	//动态内存，维护(局部变量+cell对象集合+free对象集合+运行时栈)所需要的空间
	PyObject *f_localsplus[1];	
} PyFrameObject;

PyFrameObject *PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals, PyCodeObject *locals)
{
	PyFrameObject *f;
	Py_ssize_t extras, ncells, nfrees, i;
	ncells = PyTuple_GET_SIZE(code->co_cellvars);
	nfrees = PyTuple_GET_SIZE(code->co_freevars);
	//这四部分构成了 PyFrameObject维护的动态内存区，其大小由extras确定
	extras = code->co_stacksize + code->co_nlocals + ncells + nfrees;
	f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type, extras);
	//计算初始化时运行时栈的栈顶
	extras = code->co_nlocals + ncells + nfrees;
	//f_valuestack维护运行时栈的栈底，f_stacktop维护运行时栈的栈顶
	f->f_valuestack = f->f_localsplus + extras;
	f->f_stacktop = f->f_valuestack;
	return f;
}

在Python中访问 PyFrameObject对象
8.1.3的caller.py我运行失败了，在f_globals.keys()处出错
看不懂frame_getter.py

3.名字、作用域和名字空间
对于python这类动态语言来说，名字的意义远比C这类的静态语言大，因为名字是python
在运行时能够找到其所对应的东西的唯一途径。

名字： 一个标识符就是一个名字，比如变量名、函数名、类名等
作用域：作用域是指约束起作用的程序正文区域。Python是具有静态作用域(词法作用域)的。
在Python中，一个约束在程序正文的某个位置是否起作用，是由该约束在文本中的位置唯一决定的，
而不是运行时动态决定的。
名字空间：由一个 PyDictObject对象实现，每一个名字空间都与一个作用域对应

module
1.将逻辑相关的代码放在一起，实现代码复用
2.为系统划分名字空间（一个module定义了一个独立的名字空间）

赋值语句会影响名字空间（“拥有赋值行为、拥有设置对象属性的行为”）
1.创建一个对象obj
2.将obj"赋给"一个名字name

a = 1
def f()
class A(object)
import abc

<span style="font-family: Arial, Helvetica, sans-serif; font-size: 12px;"></span><pre name="code" class="cpp">#----------------------
a = 1 #[1]

def f():
	a = 2 #[2]
	print a #[3] 輸出2
print a #[4] 輸出1
#----------------------
#闭包。在执行func = f()的时候，会执行函数f中的def g():语句，这时Python会将约束a = 2与函数g对应的函数对象捆绑在一起

#将捆绑后的结果返回

a = 1

def f():
	a = 2
	def g():
		print a #[1]：输出结果为2
	return g
func = f()
func() #[2]
#----------------------

<pre name="code" class="cpp">#由一个赋值语句引进的名字在这个赋值语句所在的作用域是可见的。在 第9章 Python虚拟机中的一般表达式 这章有说明实现原理
#[1]pint a语句处，a已经存在了这个Code Block对应的PyFrameObject对应的co_names符号表里了，但由于还没执行[2]的赋值语句，
#在PyFrameObject的f_locals里并没有这个键值对，所以在[1]处会出现“local variable 'a' referenced before assignment”的错误

/* Interpreter main loop */ 
PyObject* PyEval_EvalFrame(PyFrameObject *f) 
{
	//…… 
	why = WHY_NOT;//指示了在退出for循环时Python执行引擎的状态
	for (;;) {
	//…… 
	fast_next_opcode: 
		f->f_lasti = INSTR_OFFSET();
		/* 获得字节码指令和参数*/
		opcode = NEXTOP();
		oparg = 0;  
		/* 如果指令需要参数，获得指令参数*/
		if (HAS_ARG(opcode))
			oparg = NEXTARG();
	dispatch_opcode: 
		switch (opcode) {
		case NOP:
		goto fast_next_opcode;
		case LOAD_FAST:
		//…… 
		} 
}

//进程
typedef struct _is{
	struct _is *next;
	struct _ts *tstate_head; //模拟进程环境中的线程集合
	
	PyObject *modules;
	PyObject *sysdict;
	PyObject *builtins;
	
	//...
} PyInterpreterState
//线程
typedef struct _ts{
	struct _ts *next
	PyInterpreterState *interp;
	struct _frame *frame; //模拟线程中的函数调用堆栈
	int recursion_depth;
	//...
	PyObject *dict;
	//...
	long thread_id;
} PyThreadState;