起步

前面虚拟机的行为分析大半. 为了更进一步了解整个python运行时的行为. 从起点开始, python程序被执行, 一步一步的跟随python的踪迹. 真正有意义的初始化从 _Py_InitializeCore 开始的.

线程模型

在对Python初始化介绍之前, 需要先知道python的运行模式, 或者说线程模型. 在前面将指令调用函数有稍微提到这个线程模型. 对此,要重新认识一下线程:

[pystate.h]
typedef struct _is {

    struct _is *next;
    struct _ts *tstate_head;// 模拟进程环境中的线程集合

    int64_t id;

    PyObject *modules;
    PyObject *modules_by_index;
    PyObject *sysdict;
    PyObject *builtins;
    PyObject *importlib;

    ...
} PyInterpreterState;

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

    struct _frame *frame;// 帧栈对象, 模拟线程中函数调用堆栈
    ...
}PyThreadState;

PyInterpreterState 结构是对进程的模拟, 而 PyThreadState 是对线程的模拟, 这个结构组成了用来运行字节码的巨大的for和switc的:

for(;;) {
    ...
    switch(opcode) {
        ...
    }
    ...
}

以及进程, 线程, 栈帧布局大致关系:

进程->next 进程 -> next 进程
 \
  线程->next 线程 -> next 线程
   |                       |
  栈帧(frame)             ...
   |
  f_back
   |
  f_back
   |
  ...

线程环境初始化

当执行一个可执行文件时, 操作系统首先会创建一个进程内核对象, 同样, python模拟的进程也要, 通过 PyInterpreterState_New 来创建一个 PyInterpreterState 对象:

[pystate.c]
static PyInterpreterState *interp_head = NULL;
static int64_t _next_interp_id = -1;

PyInterpreterState * PyInterpreterState_New(void)
{
    PyInterpreterState *interp = (PyInterpreterState *) PyMem_RawMalloc(sizeof(PyInterpreterState));
    if (interp != NULL) {
        HEAD_INIT();
        interp->modules = NULL;
        interp->modules_by_index = NULL;
        interp->sysdict = NULL;
        ... // 域初始很多null
        HEAD_LOCK();
        interp->next = interp_head;
        if (interp_main == NULL) {
            interp_main = interp;
        }
        interp_head = interp;
        if (_next_interp_id < 0) {
            PyErr_SetString(PyExc_RuntimeError,
                            "failed to get an interpreter ID");
            interp = NULL;
        } else {
            interp->id = _next_interp_id;
            _next_interp_id += 1;
        }
        HEAD_UNLOCK();
    }
    return interp;
}

在Python的运行时环境中, 创建的进程对象会通过 next 域形成一个链表, 表头就是 interp_head . _next_interp_id 是进程的一个编号, 依次递增. 得到进程对象后还需要创建一个全新的线程对象, 一个进程至少包含一个线程:

[pystate.c]
PyThreadState * PyThreadState_New(PyInterpreterState *interp)
{
    return new_threadstate(interp, 1);
}

static PyThreadState * new_threadstate(PyInterpreterState *interp, int init)
{
    PyThreadState *tstate = (PyThreadState *)PyMem_RawMalloc(sizeof(PyThreadState));

    if (_PyThreadState_GetFrame == NULL)    // 设置获得线程中函数调用栈的操作
        _PyThreadState_GetFrame = threadstate_getframe;

    if (tstate != NULL) {   // 在线程对象中关联进程对象
        tstate->interp = interp;

        tstate->frame = NULL;
        tstate->recursion_depth = 0;
        tstate->overflowed = 0;
        ... // 域初始很多null

        if (init)
            _PyThreadState_Init(tstate);

        HEAD_LOCK();
        tstate->prev = NULL;
        tstate->next = interp->tstate_head;
        if (tstate->next)
            tstate->next->prev = tstate;
        interp->tstate_head = tstate;   // 在进程对象中关联线程
        HEAD_UNLOCK();
    }

    return tstate;
}

可以看出在 PyThreadState 也有 next 指针, 线程的next指针都设为了关联的进程对象的 tstate_head , 而tstate_head 是进程对象中用来存放线程的列表, 这部分和多线程有关. 进程对象和线程对象都彼此建立了关系, 使得在他们之间穿梭变得很容易.

在python运行环境中, 有一个全局变量 _PyThreadState_Current ,这个变量用来维护当前活动的线程. 初始时为NULL:

[pystate.c]
_Py_atomic_address _PyThreadState_Current = {0};

[pyatomic.h]
typedef struct _Py_atomic_address {
    atomic_uintptr_t _value;
} _Py_atomic_address;

在 _Py_atomic_address 类型中声明了 _value 是 原子变量 . 原子变量的操作是使用原子API进行的. 所谓的 原子操作 是指该操作绝不会在执行完毕前被任何其他任务或事件打断. 也就是说它是最小的执行单位, 没有比它更小的了. 所以在同时执行多个线程的情境中, 当一个线程对一个原子类型的对象执行原子操作时，其他线程不能访问该对象。 对原子变量的操作都要通过系统提供的API来进行:

[pystate.c]
#define GET_TSTATE() \
    ((PyThreadState*)_Py_atomic_load_relaxed(&_PyThreadState_Current))
#define SET_TSTATE(value) \
    _Py_atomic_store_relaxed(&_PyThreadState_Current, (uintptr_t)(value))

// 对于赋值语句的宏进行展开
[pyatomic.h]
#define _Py_atomic_store_relaxed(ATOMIC_VAL, NEW_VAL) \
    _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, _Py_memory_order_relaxed)

#define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \
    atomic_store_explicit(&(ATOMIC_VAL)->_value, NEW_VAL, ORDER)    

atomic_store_explicit 就是在系统头文件 stdatomic.h 定义的API. 关于 _PyThreadState_Current 的修改可以说是线程安全的.

在python启动后的第一个 PyThreadState 对象后, 会调用 PyThreadState_Swap 来设置这个变量:

[pystate.c]
PyThreadState * PyThreadState_Swap(PyThreadState *newts)
{
    PyThreadState *oldts = GET_TSTATE();

    SET_TSTATE(newts);
    return oldts;
}

接着, python的初始化动作开始类型系统的初始化, 接下来的动作是全局变量 __builtins__ , 这个变量在创建新的 PyFrameObject 对象时发挥作用.

在此之后就是一些其他边边角角的杂碎的动作, 如 _PyLong_Init 里创建小整数池等. 而后还需要进入一个环节:设置系统module

系统 module 初始化

module的初始化简单的两句话完成:

interp->modules = PyDict_New();
bimod = _PyBuiltin_Init();

内建对象主要由 _PyBuiltin_Init 来完成, 在调用它之前 interp->modules 先创建一个dict对象, 这个对象将维护系统所有module, 这也是所有线程对象所共享的资源:

[bltinmodule.c]
PyObject * _PyBuiltin_Init(void)
{
    PyObject *mod, *dict, *debug;
    mod = PyModule_Create(&builtinsmodule);
    if (mod == NULL)
        return NULL;
    dict = PyModule_GetDict(mod);
    // 将所有内建类型加入到 __builtins__ 中
    #define SETBUILTIN(NAME, OBJECT) \
    if (PyDict_SetItemString(dict, NAME, (PyObject *)OBJECT) < 0)       \
        return NULL;

    SETBUILTIN("None",                  Py_None);
    SETBUILTIN("False",                 Py_False);
    SETBUILTIN("True",                  Py_True);
    SETBUILTIN("bool",                  &PyBool_Type);
    SETBUILTIN("bytes",                 &PyBytes_Type);
    SETBUILTIN("classmethod",           &PyClassMethod_Type);
    SETBUILTIN("complex",               &PyComplex_Type);
    SETBUILTIN("dict",                  &PyDict_Type);
    SETBUILTIN("enumerate",             &PyEnum_Type);
    SETBUILTIN("filter",                &PyFilter_Type);
    SETBUILTIN("float",                 &PyFloat_Type);
    SETBUILTIN("frozenset",             &PyFrozenSet_Type);
    SETBUILTIN("property",              &PyProperty_Type);
    SETBUILTIN("int",                   &PyLong_Type);
    SETBUILTIN("list",                  &PyList_Type);
    SETBUILTIN("map",                   &PyMap_Type);
    SETBUILTIN("str",                   &PyUnicode_Type);  
    ...

    return mod;
}

_PyBuiltin_Init 的功能就是设置好 __builtins__ 这个module. 模块的申请由 PyModule_Create 完成:

[modsupport.h]
#define PyModule_Create(module) \
        PyModule_Create2(module, PYTHON_API_VERSION)

[moduleobject.c]
PyObject * PyModule_Create2(struct PyModuleDef* module, int module_api_version)
{
    const char* name;
    PyModuleObject *m;
    ...
    name = module->m_name;
    m = (PyModuleObject*)PyModule_New(name);
    if (module->m_size > 0) {
        m->md_state = PyMem_MALLOC(module->m_size);
        memset(m->md_state, 0, module->m_size);
    }

    if (module->m_methods != NULL) {
        // 遍历methods指定module对象中应包含的操作集合
        if (PyModule_AddFunctions((PyObject *) m, module->m_methods) != 0) {
            Py_DECREF(m);
            return NULL;
        }
    }
    if (module->m_doc != NULL) {    // 设置文档说明
        if (PyModule_SetDocString((PyObject *) m, module->m_doc) != 0) {
            Py_DECREF(m);
            return NULL;
        }
    }
    m->md_def = module;
    return (PyObject*)m;
}

这部分做了两件事, 一个是创建module对象, 一个是将方法放置到刚创建的module中.

创建对象

module对象通过 PyModule_New 函数创建, 参数是模块名:

[moduleobject.c]
typedef struct {
    PyObject_HEAD
    PyObject *md_dict;
    struct PyModuleDef *md_def;
    void *md_state;
    PyObject *md_weaklist;
    PyObject *md_name;  /* for logging purposes after md_dict is cleared */
} PyModuleObject;

PyObject * PyModule_New(const char *name)
{
    PyObject *nameobj, *module;
    nameobj = PyUnicode_FromString(name);
    if (nameobj == NULL)
        return NULL;
    module = PyModule_NewObject(nameobj);
    Py_DECREF(nameobj);
    return module;
}

PyObject * PyModule_NewObject(PyObject *name)
{
    PyModuleObject *m;
    m = PyObject_GC_New(PyModuleObject, &PyModule_Type);
    if (m == NULL)
        return NULL;
    m->md_def = NULL;
    m->md_state = NULL;
    m->md_weaklist = NULL;
    m->md_name = NULL;
    m->md_dict = PyDict_New();
    if (module_init_dict(m, m->md_dict, name, NULL) != 0)
        goto fail;
    PyObject_GC_Track(m);
    return (PyObject *)m;

 fail:
    Py_DECREF(m);
    return NULL;
}

可见, PyModule_NewObject 才是幕后创建模块对象的英雄, 创建后 m->md_dict 是个字典, 需要进行一些基础的设置 module_init_dict :

[moduleobject.c]
static int module_init_dict(PyModuleObject *mod, PyObject *md_dict, PyObject *name, PyObject *doc)
{
    _Py_IDENTIFIER(__name__);
    _Py_IDENTIFIER(__doc__);
    _Py_IDENTIFIER(__package__);
    _Py_IDENTIFIER(__loader__);
    _Py_IDENTIFIER(__spec__);

    if (md_dict == NULL)
        return -1;
    if (doc == NULL)
        doc = Py_None;

    if (_PyDict_SetItemId(md_dict, &PyId___name__, name) != 0)
        return -1;
    if (_PyDict_SetItemId(md_dict, &PyId___doc__, doc) != 0)
        return -1;
    if (_PyDict_SetItemId(md_dict, &PyId___package__, Py_None) != 0)
        return -1;
    if (_PyDict_SetItemId(md_dict, &PyId___loader__, Py_None) != 0)
        return -1;
    if (_PyDict_SetItemId(md_dict, &PyId___spec__, Py_None) != 0)
        return -1;
    if (PyUnicode_CheckExact(name)) {
        Py_INCREF(name);
        Py_XSETREF(mod->md_name, name);
    }

    return 0;
}

也可以这么说, PyModuleObject 是对 PyDictObject 的包装. 所以, 在 PyModule_New 创建模块对象时, 虽然有放入基础的 __name__ 和 __doc__ , 但还是算一个空的module, 没有包含操作和数据.

设置 module 对象

创建完module对象后, 将代码回溯到函数 PyModule_Create2 中的 m = (PyModuleObject*)PyModule_New(name); 之后, dict = PyModule_GetDict(mod); 就是获取module对象中的m_dict域:

[moduleobject.c]
PyObject * PyModule_GetDict(PyObject *m)
{
    PyObject *d;
    if (!PyModule_Check(m)) {
        PyErr_BadInternalCall();
        return NULL;
    }
    d = ((PyModuleObject *)m) -> md_dict;
    assert(d != NULL);
    return d;
}

接着就是通过 PyModule_AddFunctions((PyObject *) m, module->m_methods) 将 builtin_methods 中的方法遍历, 加入到module中, 先来看看 builtin_methods :

[methodobject.h]
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[] = {
    ...
    {"dir",             builtin_dir,        METH_VARARGS, dir_doc},
    {"getattr",         (PyCFunction)builtin_getattr, METH_FASTCALL, getattr_doc},
    {"print",           (PyCFunction)builtin_print,      METH_FASTCALL | METH_KEYWORDS, print_doc},
    ...
    {NULL,              NULL},
}

这些都是python的内置函数, 对于每个 PyMethodDef 结构, python都会为它创建一个 PyCFunctionObject 对象, 这个对象是对函数指针的包装:

[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 */
    PyObject    *m_weakreflist; /* List of weak references */
} 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);
        (void)PyObject_INIT(op, &PyCFunction_Type);
        numfree--;
    }
    else {
        op = PyObject_GC_New(PyCFunctionObject, &PyCFunction_Type);
        if (op == NULL)
            return NULL;
    }
    op->m_weakreflist = 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;
}

free_list 看得出来这边也使用了缓冲池策略. 参数中的 self 也就是调用时传入的module, func = PyCFunction_NewEx(fdef, (PyObject*)module, name); , 差点被参数列表搞混了. 也就是说每个PyCFunctionObject对象的域 m_self 都指向自己所属的module. 而 m_module 存放的则是一个PyUnicodeObject对象, 这个则是对应这PyModuleObject对象的名字.

小结一下, 初始化函数 _Py_InitializeCore 数里面, 先创建一个进程, 一个线程, 并进行关联; 对类型系统进行初始化主要调用 _Py_ReadyTypes 进行各个类型的Ready操作. 调用每个类型中的初始函数 *_Init() ; 为进程创建dict对象用来存放modules; 初始化内建函数和对象 __builtins__:

[pylifecycle.c]
void _Py_InitializeCore(const _PyCoreConfig *config)
{
    ... // 一些环境设置
    _PyInterpreterState_Init();
    interp = PyInterpreterState_New();  // 创建进程对象
    tstate = PyThreadState_New(interp); // 创建线程对象
    (void) PyThreadState_Swap(tstate);  // 设置当前活动线程指针

    _Py_ReadyTypes();   // 类型系统初始化

    // 各个类型的init函数
    if (!_PyFrame_Init())
        Py_FatalError("Py_InitializeCore: can't init frames");

    if (!_PyLong_Init())
        Py_FatalError("Py_InitializeCore: can't init longs");
    ...
    interp->modules = PyDict_New();
    bimod = _PyBuiltin_Init();      // 设置内建函数和对象
    interp->builtins = PyModule_GetDict(bimod);

    ....    // 后续动作
}

后续的动作也是很重要的, 设置完 interp->builtins ,照猫画虎的设置 interp->sysdict .

创建 sys module

[pylifecycle.c]
void _Py_InitializeCore(const _PyCoreConfig *config)
{
    ...
    interp->builtins = PyModule_GetDict(bimod);

    // sys模块
    sysmod = _PySys_BeginInit();
    interp->sysdict = PyModule_GetDict(sysmod);
    _PyImport_FixupBuiltin(sysmod, "sys");  // 备份sys模块
    PyDict_SetItemString(interp->sysdict, "modules", interp->modules);
    ...
}

_PySys_BeginInit 函数中主要是对 sys 模块中加入python的基本信息, 如python版本, copyright, api版本等.在完成对 __builtin__ 和 sys 两个module设置后, 他们在内存中的情形如图.

[示意图]

图中sys和builtin对象以虚线引出的 PyDictObject 对象表示PyModuleObject内部维护的字典对象,即md_dict. 从前面的分析可以看到 interp->builtins 和 interp->sysdict 指向的确实是PyDictObject对象, 而不是PyModuleObject对象.

对于扩展的模块, 为了避免对sys再进行初始化, python会将所有扩展module通过一个全局的PyDIctObject对象来进行维护.备份sys的动作中 _PyImport_FixupExtensionObject 完成:

[import.c]
int _PyImport_FixupBuiltin(PyObject *mod, const char *name)
{
    int res;
    PyObject *nameobj;
    nameobj = PyUnicode_InternFromString(name);
    if (nameobj == NULL)
        return -1;
    res = _PyImport_FixupExtensionObject(mod, nameobj, nameobj);
    Py_DECREF(nameobj);
    return res;
}

备份的实际动作是 _PyImport_FixupExtensionObject :

[import.c]
static PyObject *extensions = NULL; // 全局变量, 一个dict对象

int _PyImport_FixupExtensionObject(PyObject *mod, PyObject *name, PyObject *filename)
{
    PyObject *modules, *dict, *key;
    struct PyModuleDef *def;
    int res;
    if (extensions == NULL) {   // 如果extensions为空, 创建dict对象
        extensions = PyDict_New();
    }

    def = PyModule_GetDef(mod); // 获得mod中的md_def域,是一个PyMethodDef. 这里的mod是 sysmod

    modules = PyImport_GetModuleDict();         // 获得interp->modules
    if (PyDict_SetItem(modules, name, mod) < 0) // 设置(name, mod)的对应关系
        return -1;
    if (_PyState_AddModule(mod, def) < 0) {
        PyDict_DelItem(modules, name);
        return -1;
    }
    if (def->m_size == -1) {
        if (def->m_base.m_copy) {
            Py_CLEAR(def->m_base.m_copy);
        }
        dict = PyModule_GetDict(mod);
        def->m_base.m_copy = PyDict_Copy(dict); // 对dict进行拷贝
        if (def->m_base.m_copy == NULL)
            return -1;
    }
    key = PyTuple_Pack(2, filename, name);
    if (key == NULL)
        return -1;
    res = PyDict_SetItem(extensions, key, (PyObject *)def); // 将存有拷贝的新的dict的PyMethodDef存储在extensions中
    Py_DECREF(key);
    if (res < 0)
        return -1;
    return 0;
}

python内部有个全局变量 extensions 用来存放所有已经被加载的module中的PyMethodDef. 当python谢勇的module集合中某个扩展被删除后又被重新加载时, python就不需要再次为其初始化了. 只需要用extensions中备份的PyMethodDef即可. 后文再说明.

设置 module 搜索路径

在此需要为如 import xxx 设置搜索顺序:

[pylifecycle.c]
int _Py_InitializeMainInterpreter(const _PyMainInterpreterConfig *config)
{
    ...
    PySys_SetPath(Py_GetPath());
    ...
}

[sysmodule.c]
void PySys_SetPath(const wchar_t *path)
{
    PyObject *v;
    if ((v = makepathobject(path, DELIM)) == NULL)
        Py_FatalError("can't create sys.path");
    if (_PySys_SetObjectId(&PyId_path, v) != 0)
        Py_FatalError("can't assign sys.path");
    Py_DECREF(v);
}

int _PySys_SetObjectId(_Py_Identifier *key, PyObject *v)
{
    PyThreadState *tstate = PyThreadState_GET();
    PyObject *sd = tstate->interp->sysdict;
    if (v == NULL) {
        if (_PyDict_GetItemId(sd, key) == NULL)
            return 0;
        else
            return _PyDict_DelItemId(sd, key);
    }
    else
        return _PyDict_SetItemId(sd, key, v);
}

省略了 makepathobject(path, DELIM) 的代码, 在它函数内, 会创建一个PyListObject对象, 这个list包含PyStringObject, 其顺序就是import模块时的搜索顺序

最终这个表示路径搜索顺序的list对呗放置到 interp->sysdict 中, 这个列表就是 sys.path 看到的.

回到 _Py_InitializeCore 函数的动作中, 再其备份 sys 模块后, 设置错误输出流 stderr . 然后初始化 import 机制. 关于import机制下一篇再说. 会有动态模块加载. 初始化import机制, 函数 _Py_InitializeCore 就算是完成工作了. 但对于python的初始化来说, 初始化还未完成. 不过也就剩一个步骤了, 就是内建异常初始化:

[pylifecycle.c]
int _Py_InitializeMainInterpreter(const _PyMainInterpreterConfig *config)
{
    ...
    if (_PySys_EndInit(interp->sysdict) < 0)
        Py_FatalError("Py_InitializeMainInterpreter: can't finish initializing sys");
    initexternalimport(interp);

    /* initialize the faulthandler module */
    if (_PyFaulthandler_Init())
        Py_FatalError("Py_InitializeMainInterpreter: can't initialize faulthandler");

    if (initfsencoding(interp) < 0)
        Py_FatalError("Py_InitializeMainInterpreter: unable to load the file system codec");

    if (config->install_signal_handlers)
        initsigs(); /* Signal handling stuff, including initintr() */

    if (_PyTraceMalloc_Init() < 0)
        Py_FatalError("Py_InitializeMainInterpreter: can't initialize tracemalloc");
    initmain(interp); /* Module __main__ */
    ...
    _Py_Initialized = 1;    // 初始化已完成
}

创建 main 模块

在python初始化接近尾声时, python将创建一个非常特殊的模块, 名为 "__main__" 的模块.

[pylifecycle.c]
static void initmain(PyInterpreterState *interp)
{
    PyObject *m, *d, *loader, *ann_dict;
    // 创建 __main__ 模块, 并将其插入至 interp->modules 中
    m = PyImport_AddModule("__main__");
    d = PyModule_GetDict(m);    // 获得 __main__ 模块中的dict
    ann_dict = PyDict_New();

    Py_DECREF(ann_dict);
    if (PyDict_GetItemString(d, "__builtins__") == NULL) {
        // 获得interp->modules中的 __builtins__
        PyObject *bimod = PyImport_ImportModule("builtins");
        // 将 ("__builtins__", builtin module) 插入到__mian__模块中
        if (PyDict_SetItemString(d, "__builtins__", bimod) < 0) {
            Py_FatalError("Failed to initialize __main__.__builtins__");
        }
        Py_DECREF(bimod);
    }

    // 设置 __loader__ 这部分讲解跳过
    loader = PyDict_GetItemString(d, "__loader__");
    if (loader == NULL || loader == Py_None) {
        PyObject *loader = PyObject_GetAttrString(interp->importlib,
        if (PyDict_SetItemString(d, "__loader__", loader) < 0) {
            Py_FatalError("Failed to initialize __main__.__loader__");
        }
        Py_DECREF(loader);
    }
}

这个 __main__ 模块,就是我们经常写的:

if __name__ == "__main__":
    pass

这样的单元测试机制. 在 PyImport_AddModule("__main__") 中, 创建一个名为 main 的模块, 并且并将这个名称已PyUnicodeObject的形式赋值给模块中dict的 __name__ . 这个模块作为主程序运行的python源文件被视为主模块.

当以 python xxx.py 的方式运行时, python在沿着名字空间查找 __name__ 时, 就会最终在 main 模块中发现name了. 而如果一个py文件是以import方式加载的, 那么该文件里的name不会是"main".

你现在是不是有疑惑, 根据变量搜索的LGB规则, 在builtin内建中是有name的, 为什么不会找到这里面的而是去main模块中找呢.

>>> getattr(__builtins__, '__name__')
'builtins'

这个的答案在名字空间初始化中.

设置 site-packages

一般来说, 第三方模块放在 %PythonHome%\Lib\site-packages 目录下, Python初始化过程中也有 PySys_SetPath(Py_GetPath()) 来设置模块的搜索路径, 但遗憾的事, site-packages 并不在其中.

设置这个路径到module的搜索路径中是 %PythonHome%\Lib\site.py .

[pylifecycle.c]
int _Py_InitializeMainInterpreter(const _PyMainInterpreterConfig *config)
{
    ...
    initmain(interp); /* Module __main__ */
    if (!Py_NoSiteFlag)
            initsite(); /* Module site */
}

static void initsite(void)
{
    PyObject *m;
    m = PyImport_ImportModule("site");
    if (m == NULL) {
        fprintf(stderr, "Failed to import the site module\n");
        PyErr_Print();
        Py_Finalize();
        exit(1);
    }
    else {
        Py_DECREF(m);
    }
}

在 initsite() 函数中, 只是调用了 PyImport_ImportModule 函数, 这个函数也就是python的import机制的核心所在.

激活虚拟机

在这步之前, python已经完成了执行程序所必须的基础设施, 通常我们以 python xxx.py 方式来启动, 在初始化 _Py_InitializeCore 函数后调用 run_file 最终通过 PyRun_AnyFileExFlags :

[Modules/main.c]
int Py_Main(int argc, wchar_t **argv)
{
    ...
    FILE *fp = stdin;   // 默认以stdin作为输入流
    _Py_InitializeCore(&core_config);
    ...
    _Py_ReadMainInterpreterConfig(&config);
    _Py_InitializeMainInterpreter(&config);
    ...
    if (sts==-1 && cmdline.filename != NULL) {  // 如果有指定py脚本
        fp = _Py_wfopen(cmdline.filename, L"r");
    }
    if (sts == -1)
        sts = run_file(fp, cmdline.filename, &cf);
    ...
    return sts;
}

static int run_file(FILE *fp, const wchar_t *filename, PyCompilerFlags *p_cf)
{
    PyObject *unicode, *bytes = NULL;
    char *filename_str;
    int run;
    ...
    if (filename) {
        unicode = PyUnicode_FromWideChar(filename, wcslen(filename));
        ...
    }
    else
        filename_str = "<stdin>";

    run = PyRun_AnyFileExFlags(fp, filename_str, filename != NULL, p_cf);
    Py_XDECREF(bytes);
    return run != 0;
}

当python指令后面没有跟上py文件名的时候, 文件名会默认设置为 filename_str = "<stdin>"; , 会为PyRun_AnyFileExFlags 传入, 这意思是以系统标准输入流stdin.

[pythonrun.c]
int PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit, PyCompilerFlags *flags)
{
    if (filename == NULL)
        filename = "???";
    // 根据fp是否交互环境还是py脚本
    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);
}

python有两种启动模式, 一种是 python xxx.py 运行python脚本, 一种是单单 python 命令进入交互模式. 这个判断采用 Py_FdIsInteractive(fp, filename) 来进行区分. 如果是交互式, 那它就进入 PyRun_InteractiveLoopFlags 来等待下一个输入.

交互式运行方式

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

    filename = PyUnicode_DecodeFSDefault(filename_str);

    // 创建交互式提示符 >>>
    v = _PySys_GetObjectId(&PyId_ps1);
    if (v == NULL) {
        _PySys_SetObjectId(&PyId_ps1, v = PyUnicode_FromString(">>> "));
        Py_XDECREF(v);
    }
    // 创建交互式提示符 ...
    v = _PySys_GetObjectId(&PyId_ps2);
    if (v == NULL) {
        _PySys_SetObjectId(&PyId_ps2, v = PyUnicode_FromString("... "));
        Py_XDECREF(v);
    }
    err = -1;
    // 进入交互式环境
    for (;;) {
        ret = PyRun_InteractiveOneObject(fp, filename, flags);
        _PY_DEBUG_PRINT_TOTAL_REFS();
        if (ret == E_EOF) {
            err = 0;
            break;
        }
    }
    Py_DECREF(filename);
    return err;
}

int PyRun_InteractiveOneObject(FILE *fp, PyObject *filename, PyCompilerFlags *flags)
{
    PyObject *m, *d, *v, *w, *oenc = NULL, *mod_name;
    mod_ty mod;
    PyArena *arena;
    const char *ps1 = "", *ps2 = "", *enc = NULL;
    int errcode = 0;
    _Py_IDENTIFIER(encoding);
    _Py_IDENTIFIER(__main__);

    mod_name = _PyUnicode_FromId(&PyId___main__); /* borrowed */
    ...
    v = _PySys_GetObjectId(&PyId_ps1);

    w = _PySys_GetObjectId(&PyId_ps2);
    // 编译交互环境中输入的语句
    arena = PyArena_New();

    mod = PyParser_ASTFromFileObject(fp, filename, enc,
                                     Py_single_input, ps1, ps2,
                                     flags, &errcode, arena);

    m = PyImport_AddModuleObject(mod_name); // 获得__main__ 模块
    if (m == NULL) {
        PyArena_Free(arena);
        return -1;
    }
    d = PyModule_GetDict(m);
    v = run_mod(mod, filename, d, d, flags, arena); // 执行用户的python语句
    PyArena_Free(arena);
    if (v == NULL) {
        PyErr_Print();
        flush_io();
        return -1;
    }
    Py_DECREF(v);
    flush_io();
    return 0;
}

这部分创建了交互环境用到的 ">>>" 和 "..." 的提示符, 调用 PyParser_ASTFromFileObject 对用户输入python语句进行编译, 其结果是结构与python语句一样的抽象语法树AST. 调用 run_mod 将最终完成对输入语句的执行. 这里的参数d就将作为当前活动的frame对象的local名字空间和global名字空间.

脚本文件运行方式

如果有执行运行的py脚本, 那么程序会调用 PyRun_SimpleFileExFlags(fp, filename, closeit, flags); :

[compile.h]
#define Py_file_input 257
int PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit,
                        PyCompilerFlags *flags)
{
    PyObject *m, *d, *v;
    const char *ext;
    int set_file_name = 0, ret = -1;
    size_t len;

    m = PyImport_AddModule("__main__");
    Py_INCREF(m);
    d = PyModule_GetDict(m);
    if (PyDict_GetItemString(d, "__file__") == NULL) {// 设置__main__中__file__属性
        PyObject *f;
        f = PyUnicode_DecodeFSDefault(filename);
        PyDict_SetItemString(d, "__file__", f);
        set_file_name = 1;
    }
    len = strlen(filename);
    ext = filename + len - (len > 4 ? 4 : 0);
    if (maybe_pyc_file(fp, filename, ext, closeit)) {
        // 如果是pyc文件
    } else {
        ...
        v = PyRun_FileExFlags(fp, filename, Py_file_input, d, d,
                              closeit, flags);
    }
    ...
}

PyObject * PyRun_FileExFlags(FILE *fp, const char *filename_str, int start, PyObject *globals,
                  PyObject *locals, int closeit, PyCompilerFlags *flags)
{
    PyObject *ret = NULL;
    mod_ty mod;
    PyArena *arena = NULL;
    PyObject *filename;

    filename = PyUnicode_DecodeFSDefault(filename_str);
    arena = PyArena_New();
    if (arena == NULL)
        goto exit;
    // 编译
    mod = PyParser_ASTFromFileObject(fp, filename, NULL, start, 0, 0,
                                     flags, NULL, arena);
    if (closeit)
        fclose(fp);
    // 执行
    ret = run_mod(mod, filename, globals, locals, flags, arena);

exit:
    Py_XDECREF(filename);
    if (arena != NULL)
        PyArena_Free(arena);
    return ret;
}

很显然, 脚本文件的执行流程和交互式方式有着相同的动作. 脚本文件一样经过编译最后进入 run_mod . 而且一样把 main 模块中的dict作为local名字空间和global名字空间传入. 是时候看看 run_mod 里发生什么了.

启动虚拟机

从 run_mod 开始, python就剩下启动字节码虚拟机了, 待执行的python代码都已经编译过了.

[pythonrun.c]
static PyObject * run_mod(mod_ty mod, PyObject *filename, PyObject *globals, PyObject *locals,
            PyCompilerFlags *flags, PyArena *arena)
{
    PyCodeObject *co;
    PyObject *v;
    co = PyAST_CompileObject(mod, filename, flags, -1, arena);
    if (co == NULL)
        return NULL;
    v = PyEval_EvalCode((PyObject*)co, globals, locals);
    Py_DECREF(co);
    return v;
}

在参数含有已经处理过的AST, 从中获得PyCodeObject对象, 开始通过 PyEval_EvalCode 来唤醒字节码虚拟机.

[ceval.c]
PyObject * PyEval_EvalCode(PyObject *co, PyObject *globals, PyObject *locals)
{
    return PyEval_EvalCodeEx(co,
                      globals, locals,
                      (PyObject **)NULL, 0,
                      (PyObject **)NULL, 0,
                      (PyObject **)NULL, 0,
                      NULL, NULL);
}

PyObject * PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals,
           PyObject **args, int argcount, PyObject **kws, int kwcount,
           PyObject **defs, int defcount, PyObject *kwdefs, PyObject *closure)
{
    return _PyEval_EvalCodeWithName(_co, globals, locals,
                                    args, argcount,
                                    kws, kws != NULL ? kws + 1 : NULL,
                                    kwcount, 2,
                                    defs, defcount,
                                    kwdefs, closure,
                                    NULL, NULL);
}

PyObject *
_PyEval_EvalCodeWithName(PyObject *_co, PyObject *globals, PyObject *locals,
           PyObject **args, Py_ssize_t argcount,
           PyObject **kwnames, PyObject **kwargs,
           Py_ssize_t kwcount, int kwstep,
           PyObject **defs, Py_ssize_t defcount,
           PyObject *kwdefs, PyObject *closure,
           PyObject *name, PyObject *qualname)
{
    ...
    retval = PyEval_EvalFrameEx(f,0);
    return retval;
}

正如 <<虚拟机框架>> 那篇介绍的, PyEval_EvalFrameEx 就是推到多米诺骨牌的第一篇骨牌. 在此, python进程被创建, python字节码虚拟机被唤醒, 之后就是执行引擎循环往复的执行字节码了.

名字空间

对于主模块来说, 它的local名字空间等于global名字空间没什么问题. main 模块维护的dict就作为local的名字空间, 这也是为什么 __name__ 取的不是内建 __builtins__ 里的, 因为它在local名字空间就命中了.

在新创建的PyFunctionObject中设置的builtin名字空间实际上也是 __builtins__ , 这意味着python所有线程都共享builtin名字空间.