0x01 线程环境初始化

线程模型回顾

Python启动后，真正有意义的初始化动作是从Py_Initialize开始（当然Py_Initialize之前也做了很多复杂的动作），Py_Initialize中调用了Py_InitializeEx。

// python.c -- Minimal main program -- everything is loaded from the library
int
main(int argc, char **argv)
{
    /* 754 requires that FP exceptions run in "no stop" mode by default,
     * and until C vendors implement C99's ways to control FP exceptions,
     * Python requires non-stop mode.  Alas, some platforms enable FP
     * exceptions by default.  Here we disable them.
     */
#ifdef __FreeBSD__
    fp_except_t m;

    m = fpgetmask();
    fpsetmask(m & ~FP_X_OFL);
#endif
    return Py_Main(argc, argv);
}

// main.c -- Python interpreter main program
/* Main program */
int
Py_Main(int argc, char **argv)
{
    ......
    Py_Initialize
    ......
}

//Pythonrun.c
void
Py_Initialize(void)
{
    Py_InitializeEx(1);
}

void
Py_InitializeEx(int install_sigs)
{
    PyInterpreterState *interp;
    PyThreadState *tstate;
    PyObject *bimod, *sysmod;
    char *p;

    extern void _Py_ReadyTypes(void);

    if (initialized)
        return;
    initialized = 1;

    if ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0')
        Py_DebugFlag = add_flag(Py_DebugFlag, p);
    if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0')
        Py_VerboseFlag = add_flag(Py_VerboseFlag, p);
    if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0')
        Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p);
    // 创建进程状态
    interp = PyInterpreterState_New();
    if (interp == NULL)
        Py_FatalError("Py_Initialize: can't make first interpreter");
    // 创建线程状态
    tstate = PyThreadState_New(interp);
    if (tstate == NULL)
        Py_FatalError("Py_Initialize: can't make first thread");
    (void) PyThreadState_Swap(tstate);
    // 初始化类型模型
    _Py_ReadyTypes();

    if (!_PyFrame_Init())
        Py_FatalError("Py_Initialize: can't init frames");

    if (!_PyInt_Init())
        Py_FatalError("Py_Initialize: can't init ints");

    _PyFloat_Init();
    // 初始化modules
    interp->modules = PyDict_New();
    if (interp->modules == NULL)
        Py_FatalError("Py_Initialize: can't make modules dictionary");
    interp->modules_reloading = PyDict_New();
    if (interp->modules_reloading == NULL)
        Py_FatalError("Py_Initialize: can't make modules_reloading dictionary");
    // 初始化__built__ module
    bimod = _PyBuiltin_Init();
    if (bimod == NULL)
        Py_FatalError("Py_Initialize: can't initialize __builtin__");
    interp->builtins = PyModule_GetDict(bimod);
    if (interp->builtins == NULL)
        Py_FatalError("Py_Initialize: can't initialize builtins dict");
    Py_INCREF(interp->builtins);
    // 初始化sys module
    sysmod = _PySys_Init();
    if (sysmod == NULL)
        Py_FatalError("Py_Initialize: can't initialize sys");
    interp->sysdict = PyModule_GetDict(sysmod);
    if (interp->sysdict == NULL)
        Py_FatalError("Py_Initialize: can't initialize sys dict");
    Py_INCREF(interp->sysdict);
    _PyImport_FixupExtension("sys", "sys");
    // 设置module搜索路径集合
    PySys_SetPath(Py_GetPath());
    // 设置了sys.modules，他就是interp->modules
    PyDict_SetItemString(interp->sysdict, "modules",
                 interp->modules);
    // 初始化import机制的环境
    _PyImport_Init();

    /* initialize builtin exceptions */
    // 初始化Python内建的exceptions
    _PyExc_Init();
    // 备份exceptions module 和 __builtin__ module
    _PyImport_FixupExtension("exceptions", "exceptions");
    /* phase 2 of builtins */
    _PyImport_FixupExtension("__builtin__", "__builtin__");
    // 在sys module中添加一些对象，用于import机制
    _PyImportHooks_Init();

    if (install_sigs)
        initsigs(); /* Signal handling stuff, including initintr() */

    initmain(); /* Module __main__ */
    if (!Py_NoSiteFlag)
        initsite(); /* Module site */

    warnings_module = PyImport_ImportModule("warnings");
    if (!warnings_module)
        PyErr_Clear();
}

Py_InitializeEx中完成了一个重要工作就是加载多个基础的module（__builtin__，sys等），还会完成Python类型系统的初始化和异常系统初始化。

// pystate.h
typedef struct _is {

    struct _is *next;
    struct _ts *tstate_head;    // 模拟进程环境中的线程集合
    PyObject *modules;
    PyObject *sysdict;
    PyObject *builtins;
    PyObject *modules_reloading;

    PyObject *codec_search_path;
    PyObject *codec_search_cache;
    PyObject *codec_error_registry;
} PyInterpreterState;

typedef struct _ts {
    struct _ts *next;
    PyInterpreterState *interp;

    struct _frame *frame;    // 模拟线程中的函数调用堆栈
    int recursion_depth;
    int tracing;
    int use_tracing;

    Py_tracefunc c_profilefunc;
    Py_tracefunc c_tracefunc;
    PyObject *c_profileobj;
    PyObject *c_traceobj;

    PyObject *curexc_type;
    PyObject *curexc_value;
    PyObject *curexc_traceback;

    PyObject *exc_type;
    PyObject *exc_value;
    PyObject *exc_traceback;

    PyObject *dict;  /* Stores per-thread state */

    int tick_counter;

    int gilstate_counter;

    PyObject *async_exc; /* Asynchronous exception to raise */
    long thread_id; /* Thread id where this tstate was created */

    int trash_delete_nesting;
    PyObject *trash_delete_later;
} PyThreadState;

某时刻Python运行时的整个环境

初始化线程环境

在win32环境，当执行一个可执行文件时，操作系统首先会创建一个进程内核对象。同样，在Python中也是如此，在Py_InitializeEx的开始处，Python会首先调用PyInterpreterState_New创建一个崭新的PyInterpreterState对象。

// pystate.c
static PyInterpreterState *interp_head = NULL;

PyInterpreterState *
PyInterpreterState_New(void)
{
    PyInterpreterState *interp = (PyInterpreterState *)
                     malloc(sizeof(PyInterpreterState));

    if (interp != NULL) {
        HEAD_INIT();
#ifdef WITH_THREAD
        if (head_mutex == NULL)
            Py_FatalError("Can't initialize threads for interpreter");
#endif
        interp->modules = NULL;
        interp->modules_reloading = NULL;
        interp->sysdict = NULL;
        interp->builtins = NULL;
        interp->tstate_head = NULL;
        interp->codec_search_path = NULL;
        interp->codec_search_cache = NULL;
        interp->codec_error_registry = NULL;

        HEAD_LOCK();
        interp->next = interp_head;
        interp_head = interp;
        HEAD_UNLOCK();
    }
    return interp;
}

在Python的运行时环境中，有一个全局变量interp_head（一个PyInterpreterState链表）来管理PyInterpreterState对象，在Python运行时可能会有多个PyInterpreterState对象链接在一起（这个就是对操作系统多进程的模拟）。新创建的PyInterpreterState对象如下所示：

新创建的PyInterpreterState对象

在创建了PyInterpreterState（进程状态）对象之后，Python会调用PyThreadState_New函数来创建PyThreadState（线程状态）对象。

// pystate.c
PyThreadState *
PyThreadState_New(PyInterpreterState *interp)
{
    PyThreadState *tstate = (PyThreadState *)malloc(sizeof(PyThreadState));
    // 设置获得线程中函数调用栈的操作
    if (_PyThreadState_GetFrame == NULL)
        _PyThreadState_GetFrame = threadstate_getframe;

    if (tstate != NULL) {
        // 在PyThreadState对象中关联PyInterpreterState对象
        tstate->interp = interp;

        tstate->frame = NULL;
        tstate->recursion_depth = 0;
        tstate->tracing = 0;
        tstate->use_tracing = 0;
        tstate->tick_counter = 0;
        tstate->gilstate_counter = 0;
        tstate->async_exc = NULL;

        tstate->dict = NULL;

        tstate->curexc_type = NULL;
        tstate->curexc_value = NULL;
        tstate->curexc_traceback = NULL;

        tstate->exc_type = NULL;
        tstate->exc_value = NULL;
        tstate->exc_traceback = NULL;

        tstate->c_profilefunc = NULL;
        tstate->c_tracefunc = NULL;
        tstate->c_profileobj = NULL;
        tstate->c_traceobj = NULL;

        HEAD_LOCK();
        tstate->next = interp->tstate_head;
        // 在PyInterpreterState对象中关联PyThreadState对象
        interp->tstate_head = tstate;
        HEAD_UNLOCK();
    }

    return tstate;
}

与PyThreadState结构体中也存在一个next指针，PyThreadState在Python运行时也会创建一个链表（模拟多线程）。

还会设置从线程中获得函数调用栈（PyFrameObject对象链表）的方法（threadstate_getframe）。

然后建立PyThreadState对象和PyInterpreterState对象的关系，结果如下所示：

PyThreadState对象和PyInterpreterState对象的关系图示

在Python的运行时环境中，有一个全局变量_PyThreadState_Current（_PyThreadState_Current维护了当前活动的线程，更准确的说是当前活动线程对应的PyThreadState对象），初始化时该变量为NULL。创建完PyThreadState对象后，会通过PyThreadState_Swap函数设置_PyThreadState_Current的值。

// pystate.c
PyThreadState * PyThreadState_Swap(PyThreadState *newts)
{
    PyThreadState *oldts = _PyThreadState_Current;
    _PyThreadState_Current = newts;
    return oldts;
}

接下来会通过_Py_ReadyTypes函数初始化Python类型系统（参考类机制剖析）。

然后通过_PyFrame_Init函数设置全局变量builtin_object。

// pystate.c
static PyObject *builtin_object;

int _PyFrame_Init()
{
    builtin_object = PyString_InternFromString("__builtins__");
    return (builtin_object != NULL);
}

这个内容为__builtins__的PyStringObject对象builtin_object在PyFrame_New创建一个新的PyFrameObject对象时会发挥作用。

接下来会初始化一些边边角角的东西。

至此，Py_InitializeEx有了一个阶段性结果，创建了代表进程和线程的PyInterpreterState和PyThreadState对象，并且在他们之间建立了联系。接下来会进入相对独立的环节：设置系统module。

0x02 系统module初始化

创建__builtin__ module

在Py_INitializeEx中，当Python创建了PyThreadState和PyInterpreterState对象之后，就会开始通过_PyBuiltin_Init来设置系统的__builtin__ module了。在调用_PyBuiltin_Init之前，Python会通过interp->modules创建为一个PyDictObject对象，这个对象中维护着所有的PyThreadState对象共享的资源。

// Bltinmodule.c
PyObject *
_PyBuiltin_Init(void)
{
    PyObject *mod, *dict, *debug;
    // 创建并设置__builtin__ module
    mod = Py_InitModule4("__builtin__", builtin_methods,
                 builtin_doc, (PyObject *)NULL,
                 PYTHON_API_VERSION);
    if (mod == NULL)
        return NULL;
    // 将所有内建类型加到__builtin__ module中
    dict = PyModule_GetDict(mod);
        #ifdef Py_TRACE_REFS
    /* __builtin__ exposes a number of statically allocated objects
     * that, before this code was added in 2.3, never showed up in
     * the list of "all objects" maintained by Py_TRACE_REFS.  As a
     * result, programs leaking references to None and False (etc)
     * couldn't be diagnosed by examining sys.getobjects(0).
     */
#define ADD_TO_ALL(OBJECT) _Py_AddToAllObjects((PyObject *)(OBJECT), 0)
#else
#define ADD_TO_ALL(OBJECT) (void)0
#endif

#define SETBUILTIN(NAME, OBJECT) \
    if (PyDict_SetItemString(dict, NAME, (PyObject *)OBJECT) < 0)   \
        return NULL;                        \
    ADD_TO_ALL(OBJECT)

    SETBUILTIN("None",      Py_None);
    SETBUILTIN("Ellipsis",      Py_Ellipsis);
    SETBUILTIN("NotImplemented",    Py_NotImplemented);
    SETBUILTIN("False",     Py_False);
    SETBUILTIN("True",      Py_True);
    SETBUILTIN("basestring",    &PyBaseString_Type);
    SETBUILTIN("bool",      &PyBool_Type);
    SETBUILTIN("buffer",        &PyBuffer_Type);
    SETBUILTIN("classmethod",   &PyClassMethod_Type);
#ifndef WITHOUT_COMPLEX
    SETBUILTIN("complex",       &PyComplex_Type);
#endif
    SETBUILTIN("dict",      &PyDict_Type);
    SETBUILTIN("enumerate",     &PyEnum_Type);
    SETBUILTIN("file",      &PyFile_Type);
    SETBUILTIN("float",     &PyFloat_Type);
    SETBUILTIN("frozenset",     &PyFrozenSet_Type);
    SETBUILTIN("property",      &PyProperty_Type);
    SETBUILTIN("int",       &PyInt_Type);
    SETBUILTIN("list",      &PyList_Type);
    SETBUILTIN("long",      &PyLong_Type);
    SETBUILTIN("object",        &PyBaseObject_Type);
    SETBUILTIN("reversed",      &PyReversed_Type);
    SETBUILTIN("set",       &PySet_Type);
    SETBUILTIN("slice",     &PySlice_Type);
    SETBUILTIN("staticmethod",  &PyStaticMethod_Type);
    SETBUILTIN("str",       &PyString_Type);
    SETBUILTIN("super",     &PySuper_Type);
    SETBUILTIN("tuple",     &PyTuple_Type);
    SETBUILTIN("type",      &PyType_Type);
    SETBUILTIN("xrange",        &PyRange_Type);
#ifdef Py_USING_UNICODE
    SETBUILTIN("unicode",       &PyUnicode_Type);
#endif
    debug = PyBool_FromLong(Py_OptimizeFlag == 0);
    if (PyDict_SetItemString(dict, "__debug__", debug) < 0) {
        Py_XDECREF(debug);
        return NULL;
    }
    Py_XDECREF(debug);

    return mod;
#undef ADD_TO_ALL
#undef SETBUILTIN
}

整个函数的功能就是设置好__builtin__ module。总共分为两个步骤：

• 创建PyModuleObject对象，在Python中，module正是通过和这个对象来设置的
• 设置module，将Python中的所有的类型对象全塞进新创建的__builtin__ module中。

在第一步中已经设置好了大部分的内容，由函数Py_InitModule4实现：

// modsupport.c
PyObject *
Py_InitModule4(const char *name, PyMethodDef *methods, const char *doc,
           PyObject *passthrough, int module_api_version)
{
    PyObject *m, *d, *v, *n;
    PyMethodDef *ml;
    ......
    // 创建module对象
    if ((m = PyImport_AddModule(name)) == NULL)
        return NULL;
    // 设置module中的（符号，值）对应关系
    d = PyModule_GetDict(m);
    if (methods != NULL) {
        n = PyString_FromString(name);
        if (n == NULL)
            return NULL;
        // 遍历methods指定的module对象中应该包含的操作集合
        for (ml = methods; ml->ml_name != NULL; ml++) {
            if ((ml->ml_flags & METH_CLASS) ||
                (ml->ml_flags & METH_STATIC)) {
                PyErr_SetString(PyExc_ValueError,
                        "module functions cannot set"
                        " METH_CLASS or METH_STATIC");
                Py_DECREF(n);
                return NULL;
            }
            v = PyCFunction_NewEx(ml, passthrough, n);
            if (v == NULL) {
                Py_DECREF(n);
                return NULL;
            }
            if (PyDict_SetItemString(d, ml->ml_name, v) != 0) {
                Py_DECREF(v);
                Py_DECREF(n);
                return NULL;
            }
            Py_DECREF(v);
        }
        Py_DECREF(n);
    }
    if (doc != NULL) {
        v = PyString_FromString(doc);
        if (v == NULL || PyDict_SetItemString(d, "__doc__", v) != 0) {
            Py_XDECREF(v);
            return NULL;
        }
        Py_DECREF(v);
    }
    return m;
}

Py_InitModule4参数的含义：

• name：module的名称，在这里是__builtin__
• methods：该module中所包含的函数的集合，在这里是builtin_methods
• doc：module的文档，在这里是builtin_doc
• passthrough：这个参数在Python 2.5中没有使用，为NULL
• module_api_version：Python内部使用的version值，用于比较

Py_InitModule4函数可以分为2个独立的部分：创建module对象；将（符号，值）对应关系放置到module中。

创建module对象

// import.c
PyObject *
PyImport_AddModule(const char *name)
{
    // 获得Python维护的module集合
    PyObject *modules = PyImport_GetModuleDict();
    PyObject *m;
    // 如果module集合中没有名为name的module对象，就创建它，否则直接返回
    if ((m = PyDict_GetItemString(modules, name)) != NULL &&
        PyModule_Check(m))
        return m;
    m = PyModule_New(name);
    if (m == NULL)
        return NULL;
    // 将创建的module对象放入Python的全局module集合中
    if (PyDict_SetItemString(modules, name, m) != 0) {
        Py_DECREF(m);
        return NULL;
    }
    Py_DECREF(m); /* Yes, it still exists, in modules! */
    return m;
}

Python中维护了一个存放所有加载到内存中的module集合，在这个集合中，存放着所有的(module名，module对象)这样的对应关系，对应到Python中就是sys.modules。在创建一个新的module对象之前，会先到这个全局module中查看是否已经存在。通过PyImport_GetModuleDict函数获得PyInterpreterState（进程状态）对象中的module域的值。

如果全局modules字典中没有存在该name的module对象，则通过PyModule_New函数创建一个新的module对象，然后将(name，module)对应关系插入到modules集合中。

// moduleobject.c
typedef struct {
    PyObject_HEAD
    PyObject *md_dict;
} PyModuleObject;

PyObject * PyModule_New(const char *name)
{
    PyModuleObject *m;
    PyObject *nameobj;
    m = PyObject_GC_New(PyModuleObject, &PyModule_Type);
    if (m == NULL)
        return NULL;
    nameobj = PyString_FromString(name);
    m->md_dict = PyDict_New();
    if (m->md_dict == NULL || nameobj == NULL)
        goto fail;
    if (PyDict_SetItemString(m->md_dict, "__name__", nameobj) != 0)
        goto fail;
    if (PyDict_SetItemString(m->md_dict, "__doc__", Py_None) != 0)
        goto fail;
    Py_DECREF(nameobj);
    PyObject_GC_Track(m);
    return (PyObject *)m;

 fail:
    Py_XDECREF(nameobj);
    Py_DECREF(m);
    return NULL;
}

实际上，PyModuleObject对象就是对PyDictObject对象的简单包装，创建PyModuleObject对象的动作很简单，注意在这里设置了module的__name__属性，但是没有设置其__doc__属性。

至此，创建的PyModuleObject对象还算是空的，接下来就开始设置module对象。

设置module对象

设置module对象的流程回到Py_InitModule4函数中，设置属性主要依赖Py_InitModule4函数的第二个参数（methods），在这里为builtin_methods，遍历builtin_methods，处理其中的每一个元素。

// methodobject.h
typedef PyObject *(*PyCFunction)(PyObject *, PyObject *);
struct PyMethodDef {
    const char  *ml_name;   /* The name of the built-in function/method */
    PyCFunction  ml_meth;   /* The C function that implements it */
    int      ml_flags;  /* Combination of METH_xxx flags, which mostly
                   describe the args expected by the C func */
    const char  *ml_doc;    /* The __doc__ attribute, or NULL */
};
typedef struct PyMethodDef PyMethodDef;

// bltinmodule.c
static PyMethodDef builtin_methods[] = {
    {"__import__",  (PyCFunction)builtin___import__, METH_VARARGS | METH_KEYWORDS, import_doc},
    {"abs",     builtin_abs,        METH_O, abs_doc},
    {"all",     builtin_all,        METH_O, all_doc},
    {"any",     builtin_any,        METH_O, any_doc},
    {"apply",   builtin_apply,      METH_VARARGS, apply_doc},
    {"callable",    builtin_callable,   METH_O, callable_doc},
    {"chr",     builtin_chr,        METH_VARARGS, chr_doc},
    {"cmp",     builtin_cmp,        METH_VARARGS, cmp_doc},
    {"coerce",  builtin_coerce,     METH_VARARGS, coerce_doc},
    {"compile", builtin_compile,    METH_VARARGS, compile_doc},
    {"delattr", builtin_delattr,    METH_VARARGS, delattr_doc},
    {"dir",     builtin_dir,        METH_VARARGS, dir_doc},
    {"divmod",  builtin_divmod,     METH_VARARGS, divmod_doc},
    {"eval",    builtin_eval,       METH_VARARGS, eval_doc},
    {"execfile",    builtin_execfile,   METH_VARARGS, execfile_doc},
    {"filter",  builtin_filter,     METH_VARARGS, filter_doc},
    {"getattr", builtin_getattr,    METH_VARARGS, getattr_doc},
    {"globals", (PyCFunction)builtin_globals,    METH_NOARGS, globals_doc},
    {"hasattr", builtin_hasattr,    METH_VARARGS, hasattr_doc},
    {"hash",    builtin_hash,       METH_O, hash_doc},
    {"hex",     builtin_hex,        METH_O, hex_doc},
    {"id",      builtin_id,         METH_O, id_doc},
    {"input",   builtin_input,      METH_VARARGS, input_doc},
    {"intern",  builtin_intern,     METH_VARARGS, intern_doc},
    {"isinstance",  builtin_isinstance, METH_VARARGS, isinstance_doc},
    {"issubclass",  builtin_issubclass, METH_VARARGS, issubclass_doc},
    {"iter",    builtin_iter,       METH_VARARGS, iter_doc},
    {"len",     builtin_len,        METH_O, len_doc},
    {"locals",  (PyCFunction)builtin_locals,     METH_NOARGS, locals_doc},
    {"map",     builtin_map,        METH_VARARGS, map_doc},
    {"max",     (PyCFunction)builtin_max,        METH_VARARGS | METH_KEYWORDS, max_doc},
    {"min",     (PyCFunction)builtin_min,        METH_VARARGS | METH_KEYWORDS, min_doc},
    {"oct",     builtin_oct,        METH_O, oct_doc},
    {"open",    (PyCFunction)builtin_open,       METH_VARARGS | METH_KEYWORDS, open_doc},
    {"ord",     builtin_ord,        METH_O, ord_doc},
    {"pow",     builtin_pow,        METH_VARARGS, pow_doc},
    {"range",   builtin_range,      METH_VARARGS, range_doc},
    {"raw_input",   builtin_raw_input,  METH_VARARGS, raw_input_doc},
    {"reduce",  builtin_reduce,     METH_VARARGS, reduce_doc},
    {"reload",  builtin_reload,     METH_O, reload_doc},
    {"repr",    builtin_repr,       METH_O, repr_doc},
    {"round",   (PyCFunction)builtin_round,      METH_VARARGS | METH_KEYWORDS, round_doc},
    {"setattr", builtin_setattr,    METH_VARARGS, setattr_doc},
    {"sorted",  (PyCFunction)builtin_sorted,     METH_VARARGS | METH_KEYWORDS, sorted_doc},
    {"sum",     builtin_sum,        METH_VARARGS, sum_doc},
#ifdef Py_USING_UNICODE
    {"unichr",  builtin_unichr,     METH_VARARGS, unichr_doc},
#endif
    {"vars",    builtin_vars,       METH_VARARGS, vars_doc},
    {"zip",         builtin_zip,        METH_VARARGS, zip_doc},
    {NULL,      NULL},
};

len函数对应的PyMethodDef结构

对于builtin_methods中的每一个PyMethodDef结构，PyInitModule4都会基于它创建一个PyCFunctionObject对象（Python中对函数指针的包装）。

// methodobject.h
typedef struct {
    PyObject_HEAD
    PyMethodDef *m_ml; /* Description of the C function to call */
    PyObject    *m_self; /* Passed as 'self' arg to the C func, can be NULL */
    PyObject    *m_module; /* The __module__ attribute, can be anything */
} PyCFunctionObject;

// methodobject.c
PyObject *
PyCFunction_NewEx(PyMethodDef *ml, PyObject *self, PyObject *module)
{
    PyCFunctionObject *op;
    op = free_list;
    if (op != NULL) {
        free_list = (PyCFunctionObject *)(op->m_self);
        PyObject_INIT(op, &PyCFunction_Type);
    }
    else {
        op = PyObject_GC_New(PyCFunctionObject, &PyCFunction_Type);
        if (op == NULL)
            return NULL;
    }
    op->m_ml = ml;
    Py_XINCREF(self);
    op->m_self = self;
    Py_XINCREF(module);
    op->m_module = module;
    _PyObject_GC_TRACK(op);
    return (PyObject *)op;
}

PyCFunctionObject对象中的那个self，也就是在Py_InitModule4中传入的passthrough（之前说这个参数在Python 2.5中没用，所以这里的self也就为NULL）。

注意，PyCFunctionObject对象中的m_module域并不是指向一个真正的PyModuleObject对象，而是一个PyStringObject对象，但是这个PyStringObject对象正是PyModuleObject对象的名字（根据PyModuleObject对象的名字可以在全局modules中找到对应的PyModuleObject对象）。

创建完成的 __builtin__ module

__builtin__ module创建完以后，也就是bimod = _PyBuiltin_Init()执行完以后，将PyModuleObject对象中维护的那个PyDictObject对象赋值给interp->builtins。以后Python在需要访问__builtin__ module时，直接访问interp->builtins就行，不需要再到interp->modules中去找到__builtin__ module对象然后再去访问。因为Python中使用__builtin__ module非常频繁，这样的机制会速度会更快。

创建sys module

sys module的备份

Python在创建并设置了__builtin__ module之后，会类似的以同样流程设置sys module，并像设置interp->builtins一样设置interp->sysdict。

设置完成__builtin__和sys两个module之后，PyInterpreterState和PyThreadState对象在内存中的情形如下所示：

此时内存中情形

由于Python的module集合interp->modules是一个PyDictObject对象，而PyDictObject对象在Python中是一个可变对象（其中维护的(module name，PyModuleObject)元素对在运行时有可能被删除）。

对于Python的扩展module（sys等），为了避免被删除后的重新初始化，Python会将所有的扩展module通过一个全局PyDictObject对象来进行备份维护，这里通过_PyImport_FixupExtension("sys", "sys")函数完成：

// import.c
static PyObject *extensions = NULL;

PyObject *
_PyImport_FixupExtension(char *name, char *filename)
{
    PyObject *modules, *mod, *dict, *copy;
    // 如果extensions为空，则创建PyDictObject对象赋给extensions
    if (extensions == NULL) {
        extensions = PyDict_New();
        if (extensions == NULL)
            return NULL;
    }
    // 获得进程对象的modules集合，interp->modules
    modules = PyImport_GetModuleDict();
        // 在interp->modules中找到名字为name的module
    mod = PyDict_GetItemString(modules, name);
    if (mod == NULL || !PyModule_Check(mod)) {
        PyErr_Format(PyExc_SystemError,
          "_PyImport_FixupExtension: module %.200s not loaded", name);
        return NULL;
    }
    // 抽取module中的dict
    dict = PyModule_GetDict(mod);
    if (dict == NULL)
        return NULL;
    // 对dict进行拷贝
    copy = PyDict_Copy(dict);
    if (copy == NULL)
        return NULL;
    // 将拷贝得到的心dict存储在extensions中
    PyDict_SetItemString(extensions, filename, copy);
    Py_DECREF(copy);
    return copy;
}

上面代码介绍了备份的过程，第一次会创建一个新的PyDictObject对象，这个对象将维护所有已经被Python加载的module中的PyDictObject的一个佩芬。当系统中的modules集合中的某个标准扩展module被删除后又被重新加载时，Python就不需要再次初始化这些module，只需extensions中备份的PyDictObject对象来创建一个新的module即可。

设置module搜索路径

在创建完sys module以后，会在此module中设置Python搜索一个module时的默认搜索路径集合（PySys_SetPath(Py_GetPath())）。这个路径集合就是在Python执行import xyz时将查看的路径的集合。

// sysmodule.c
void
PySys_SetPath(char *path)
{
    PyObject *v;
    if ((v = makepathobject(path, DELIM)) == NULL)
        Py_FatalError("can't create sys.path");
    if (PySys_SetObject("path", v) != 0)
        Py_FatalError("can't assign sys.path");
    Py_DECREF(v);
}

int
PySys_SetObject(char *name, PyObject *v)
{
    PyThreadState *tstate = PyThreadState_GET();
    PyObject *sd = tstate->interp->sysdict;
    if (v == NULL) {
        if (PyDict_GetItemString(sd, name) == NULL)
            return 0;
        else
            return PyDict_DelItemString(sd, name);
    }
    else
        return PyDict_SetItemString(sd, name, v);
}

在makepathobject中会创建一个PyListObject对象，这个PyListObject对象中包含一组PyStringObject对象，每一个PyStringObject对象的内容就是一个module的搜索路径（也就是Python中的sys.path）。

最终，这个代表搜索路径集合的list对象会在PySys_SetObject中被插入到interp->sysdict这个PyDictObject对象（sys module中维护的那个PyDictObject对象）中。

接下来，Python会进行一些琐碎的动作，其中包含初始化Python的import环境，初始化Python的内建异常（其实就是调用PyType_Ready初始化各个异常类）。

创建__main__ module

在_PyImportHooks_Init之后，Python会创建一个非常特殊的module：__main__的module。

// pythonrun.c
/* Create __main__ module */
static void
initmain(void)
{
    PyObject *m, *d;
    // 创建__main__ module，并设置到interp->modules中
    m = PyImport_AddModule("__main__");
    if (m == NULL)
        Py_FatalError("can't create __main__ module");
    // 获得__main__ module中的dict
    d = PyModule_GetDict(m);
    if (PyDict_GetItemString(d, "__builtins__") == NULL) {
        // 获得interp->modules中的__builtin__ module 
        PyObject *bimod = PyImport_ImportModule("__builtin__");
        if (bimod == NULL ||
            // 将（“__builtins__”, __builtin__ module）插入到__main__ module中
            PyDict_SetItemString(d, "__builtins__", bimod) != 0)
            Py_FatalError("can't add __builtins__ to __main__");
        Py_DECREF(bimod);
    }
}

__main__ module是什么？在PyImport_AddModule时，创建了一个名为name的module后，会在module对应的PyDictObject对象（mp_dict）设置一个名为__name__的项。__main__ module的这一项就是"__main__"，作为主程序运行的Python源文件就可以被视为名为__main__的module。

当Python以python abc.py运行时，Python在沿着名字空间寻找__name__时，就会最终在__main__ module中发现__name__为"__main__"；而如果一个py文件是以import的方式加载的，则__name__不会为"__main__"。

设置site-specific的module的搜索路径

Python的第三方库通常都是由module提供，一般来说，一些规模较大的第三方库将放在%PythonHome%/lib/site-packages目录下，但是之前在初始化搜索路径集合的时候并没有将site-packages包含在内。

接下来Python通过initsite()函数将site-packages加入到搜索路径中。

// pythonrun.c
static void
initsite(void)
{
    PyObject *m, *f;
    // 获得interp->modules中的site module 
    m = PyImport_ImportModule("site");
    if (m == NULL) {
        f = PySys_GetObject("stderr");
        if (Py_VerboseFlag) {
            PyFile_WriteString(
                "'import site' failed; traceback:\n", f);
            PyErr_Print();
        }
        else {
            PyFile_WriteString(
              "'import site' failed; use -v for traceback\n", f);
            PyErr_Clear();
        }
    }
    else {
        Py_DECREF(m);
    }
}

PyImport_ImportModule函数时Python中import机制的核心，调用这个函数相当于Python中的import xxx，在这里进入site.py，其中会进行两个动作：

• 将site-packages路径加入到sys.path中，对于不同平台有不同操作
  • win32平台：%PythonHome%/lib/site-packages
    +Unix/Linux平台：
    • %sys.prefix%/lib/python<version>/site-packages（其中%sys.prefix%为Python的sys.predix）
    • %sys.prefix%/lib/site-python
    • %sys.exec_prefix%/lib/python<version>/site-packages
    • %sys.exec_prefix%/lib/site-python
• 处理site-packages目录下的所有.pth文件中的所有路径加入到sys.path中

至此，Python中绝大部分重要的初始化动作都已经完成了，下图是完成初始化后所有可以利用的资源：

完成初始化后的Python环境

0x03 激活Python虚拟机

上面部分算是完成了Python执行程序所必须的基础设施建设，但是初始化动作还没有真正完成，当Python真正进入到之前讲的字节码虚拟机后，初始化阶段才算真正完成。

Python在Py_Initialize成功完成后，最终将调用PyRun_AnyFileExFlags(fp, filename == NULL ? "<stdin>" : filename, filename != NULL, &cf)。如果以脚本方式运行Python，则filename是文件名；如果以交互方式运行Python，则filename会传入"<stdini>"。第一个参数fp指向打开的脚本或者是系统的标准输入流stdin。

// pythonrun.c
/* Parse input from a file and execute it */
int
PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit,
             PyCompilerFlags *flags)
{
    if (filename == NULL)
        filename = "???";
    // 根据fp是否代表交互环境，对程序流程进行分流
    if (Py_FdIsInteractive(fp, filename)) {
        int err = PyRun_InteractiveLoopFlags(fp, filename, flags);
        if (closeit)
            fclose(fp);
        return err;
    }
    else
        return PyRun_SimpleFileExFlags(fp, filename, closeit, flags);
}

通过Py_FdIsInteractive函数判断fp是否指向标准输入流。如果是，则进入PyRun_InteractiveLoopFlags，否则进入PyRun_SimpleFileExFlags。

交互式运行方式

// pythonrun.c
int
PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
{
    PyObject *v;
    int ret;
    PyCompilerFlags local_flags;

    if (flags == NULL) {
        flags = &local_flags;
        local_flags.cf_flags = 0;
    }
    // 创建交互式环境提示符“>>>”
    v = PySys_GetObject("ps1");
    if (v == NULL) {
        PySys_SetObject("ps1", v = PyString_FromString(">>> "));
        Py_XDECREF(v);
    }
    // 创建交互式环境提示符“...”
    v = PySys_GetObject("ps2");
    if (v == NULL) {
        PySys_SetObject("ps2", v = PyString_FromString("... "));
        Py_XDECREF(v);
    }
    // 进入一个死循环，即交互式环境
    for (;;) {
        ret = PyRun_InteractiveOneFlags(fp, filename, flags);
        PRINT_TOTAL_REFS();
        if (ret == E_EOF)
            return 0;
        /*
        if (ret == E_NOMEM)
            return -1;
        */
    }
}

int
PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
{
    PyObject *m, *d, *v, *w;
    mod_ty mod;
    PyArena *arena;
    char *ps1 = "", *ps2 = "";
    int errcode = 0;

    v = PySys_GetObject("ps1");
    if (v != NULL) {
        v = PyObject_Str(v);
        if (v == NULL)
            PyErr_Clear();
        else if (PyString_Check(v))
            ps1 = PyString_AsString(v);
    }
    w = PySys_GetObject("ps2");
    if (w != NULL) {
        w = PyObject_Str(w);
        if (w == NULL)
            PyErr_Clear();
        else if (PyString_Check(w))
            ps2 = PyString_AsString(w);
    }
    // 编译用户在交互式环境下输入的Python语句
    arena = PyArena_New();
    if (arena == NULL) {
        Py_XDECREF(v);
        Py_XDECREF(w);
        return -1;
    }
    mod = PyParser_ASTFromFile(fp, filename,
                   Py_single_input, ps1, ps2,
                   flags, &errcode, arena);
    Py_XDECREF(v);
    Py_XDECREF(w);
    if (mod == NULL) {
        PyArena_Free(arena);
        if (errcode == E_EOF) {
            PyErr_Clear();
            return E_EOF;
        }
        PyErr_Print();
        return -1;
    }
    // 获得<module __main__>中维护的dict
    m = PyImport_AddModule("__main__");
    if (m == NULL) {
        PyArena_Free(arena);
        return -1;
    }
    d = PyModule_GetDict(m);
    // 执行用户输入的Python语句
    v = run_mod(mod, filename, d, d, flags, arena);
    PyArena_Free(arena);
    if (v == NULL) {
        PyErr_Print();
        return -1;
    }
    Py_DECREF(v);
    if (Py_FlushLine())
        PyErr_Clear();
    return 0;
}

调用PyParser_ASTFromFile函数，对用户在交互式环境下输入的Python语句进行编译，其结果是构造与Python语句对应的抽象语法树（AST）。

然后调用run_mode，将最终完成对用户输入的语句的执行动作。需要注意的是：在进入run_mode之前，会将__main__ module中维护的PyDictObject对象取出，传递给run_mode，这个参数很重要，它将作为Python虚拟机开始执行时当前活动的frame对象的local名字空间和global名字空间。

脚本文件运行方式

// python.h
#define Py_file_input 257

// pythonrun.c
int
PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit,
            PyCompilerFlags *flags)
{
    PyObject *m, *d, *v;
    const char *ext;
    // 在__main__module中设置“__file__”属性
    m = PyImport_AddModule("__main__");
    if (m == NULL)
        return -1;
    d = PyModule_GetDict(m);
    if (PyDict_GetItemString(d, "__file__") == NULL) {
        PyObject *f = PyString_FromString(filename);
        if (f == NULL)
            return -1;
        if (PyDict_SetItemString(d, "__file__", f) < 0) {
            Py_DECREF(f);
            return -1;
        }
        Py_DECREF(f);
    }
    ext = filename + strlen(filename) - 4;
    // 首先尝试去执行pyc文件
    if (maybe_pyc_file(fp, filename, ext, closeit)) {
        /* Try to run a pyc file. First, re-open in binary */
        if (closeit)
            fclose(fp);
        if ((fp = fopen(filename, "rb")) == NULL) {
            fprintf(stderr, "python: Can't reopen .pyc file\n");
            return -1;
        }
        /* Turn on optimization if a .pyo file is given */
        if (strcmp(ext, ".pyo") == 0)
            Py_OptimizeFlag = 1;
        v = run_pyc_file(fp, filename, d, d, flags);
    } else {
        // 执行py脚本文件
        v = PyRun_FileExFlags(fp, filename, Py_file_input, d, d,
                      closeit, flags);
    }
        ......
    return 0;
}

PyObject *
PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals,
          PyObject *locals, int closeit, PyCompilerFlags *flags)
{
    PyObject *ret;
    mod_ty mod;
    PyArena *arena = PyArena_New();
    if (arena == NULL)
        return NULL;
    // 编译
    mod = PyParser_ASTFromFile(fp, filename, start, 0, 0,
                   flags, NULL, arena);
    if (closeit)
        fclose(fp);
    if (mod == NULL) {
        PyArena_Free(arena);
        return NULL;
    }
    // 执行
    ret = run_mod(mod, filename, globals, locals, flags, arena);
    PyArena_Free(arena);
    return ret;
}

同交互式执行方式一样，脚本文件的执行流程最后也进入了run_mode，也同样将__main__ module中维护的PyDictObject对象作为local和global名字空间传入run_mode中。

启动虚拟机

从run_mode开始，Python现在只剩下最后一件需要完成的工作了，那就是启动字节码虚拟机。

// pythonrun.c
static PyObject *
run_mod(mod_ty mod, const char *filename, PyObject *globals, PyObject *locals,
     PyCompilerFlags *flags, PyArena *arena)
{
    PyCodeObject *co;
    PyObject *v;
    // 基于AST编译字节码指令序列，创建PyCodeObject对象
    co = PyAST_Compile(mod, filename, flags, arena);
    if (co == NULL)
        return NULL;
    // 创建PyFrameObject对象，执行PyCodeObject对象中的字节码指令序列
    v = PyEval_EvalCode(co, globals, locals);
    Py_DECREF(co);
    return v;
}

首先是根据AST得到PyCodeObject对象，然后通过PyEval_EvalCode函数开始唤醒字节码虚拟机。

// ceval.c
PyObject *
PyEval_EvalCode(PyCodeObject *co, PyObject *globals, PyObject *locals)
{
    /* XXX raise SystemError if globals is NULL */
    return PyEval_EvalCodeEx(co,
              globals, locals,
              (PyObject **)NULL, 0,
              (PyObject **)NULL, 0,
              (PyObject **)NULL, 0,
              NULL);
}

PyObject *
PyEval_EvalCodeEx(PyCodeObject *co, PyObject *globals, PyObject *locals,
       PyObject **args, int argcount, PyObject **kws, int kwcount,
       PyObject **defs, int defcount, PyObject *closure)
{
    register PyFrameObject *f;
    register PyObject *retval = NULL;
    register PyObject **fastlocals, **freevars;
    PyThreadState *tstate = PyThreadState_GET();
    PyObject *x, *u;
    ......
    f = PyFrame_New(tstate, co, globals, locals);
    ......
    fastlocals = f->f_localsplus;
    freevars = f->f_localsplus + co->co_nlocals;
    ......
    // 真正的字节码虚拟机（伪CPU）
    retval = PyEval_EvalFrameEx(f,0);
    return retval;
}

从操作系统为Python创建进程开始，到Python虚拟机被唤醒，再到执行引擎循环执行字节码，这个过程已经很清晰了。

名字空间

在创建PyFrameObject对象时，设置的3个名字空间：local、global、builtin。

• builtin名字空间就是初始化时创建的__builtin__ module，Python所有线程都共享同样的builtin名字空间（节省空间，加快速度）
• global名字空间被设置为__main__ module的dict
• local名字空间和global名字空间一样

欢迎关注微信公众号（coder0x00）或扫描下方二维码关注，我们将持续搜寻程序员必备基础技能包提供给大家。