深入理解python之模块系统

深入理解python之模块系统

一个python工程中的代码是通过模块与包的形式组织的。概括的说，一个python的文件在运行时对应一个模块，而一个文件夹（包含有init.py）对应于一个包。一个模块对于其他模块或者包中内容的引用是通过import 关键字来实现的。在成规模的项目开发中，不同的模块，包之间的引用关系，以及搜索路径常常使人困扰。因此，认识python模块的本质，理清python底层import的处理机制，是有意义的。

本文分四个部分梳理python的模块系统 。第一部分介绍python module 对象的具体数据结构；第二部分介绍python的包与模块；第三部分详细梳理import 语句的底层逻辑；最后一部分，会围绕python 的import机制谈谈在开发过程中的一些细节。

PyModuleObject 对象

无论是与py文件对应的模块，还是与文件夹对应的包，在python的底层实现中，都是用一个PyModuleObject类型的对象去描述的。

typedef struct {
    PyObject_Head
    PyObject *md_dict
}PyModuleObject;

可以看出，PyModuleObject 对象里的主体是一个字典对象。由此我们可以看出。其实一个python module 就是一个python字典。站在更高层次上来看，一个python module 主要就是提供了一个命名空间，用于保存各类对象（变量，函数，类。。。）。一个module对象持有的命名空间里保存的内容，可以通过dir函数等方法访问

import xxx
dir(xxx)

模块与包

在python项目中，运行时内存的一个模块对象，对应于一个py文件，而一个包对象则对应于python项目中的一个包含了 __ init __. py文件的文件夹。

无论是一个模块对象还是一个包对象，在python底层都统一用一个PyModuleObject 对象来保存。

    >>>import os #包
    >>> import os.path #模块 
    >>> type(os)
        <type 'module'>
    >>> type(os.path)
        <type 'module'>

如我们所知，对于一个与py文件对应的模块，其在首次import的过程中，会执行其中的逻辑。

与之对应的是，一个包在首次import的过程中,会执行包中__ init __.py中的逻辑。

import 内幕

在python实现中，import 机制的核心实现位于import_module_level 函数中。

static PyObject *import_module_level(char *name, PyObject *globals, PyObject *locals,PyObject *fromlist, int level)
{
    // 获取当前import 语句的执行环境
    parent = get_parent(globals, buf, &buflen, level);
    ...
    
    // 沿着import 路径链，依次加载包与模块
    head = load_next(parent, level < 0 ? Py_None : parent, &name, buf,&buflen);
    tail = head;
    while (name) {
        next = load_next(tail, tail, &name, buf, &buflen);
        tail = next;
    }
    
    ...
}

获取import 语句执行环境

在import_module_level函数中，第一个核心的操作是获取import 语句的执行环境。这个操作是通过get_parent 函数来获得的。所谓import 的执行环境，即为当前import 语句所在模块所属的package。

举例来说，假设当前有一个包叫做test_pkg，内含有py文件test_mod.py。test_mod.py 内含有一个import语句。

# test_mod.py

import x.y.z

那么当虚拟机执行import语句，并触发import_module_level 函数调用后，其中的get_parent 操作返回的执行环境，即为test_pkg。如前文所述，test_pkg 此时也是通过一个PyModuleObject 描述的。

向下接续探究get_parent 可以发现，该函数大部分情况下是通过解析当前模块的__ name __ 属性获取到上层package 的名称，从而在全局的sys.modules 查询到package 对象的。

正常情况下 test_mod.py 对应的模块其 __ name __ 属性的值为“test_pkg.test_mod" 。根据最后一个"."符号的位置，可以获取到上层package 名称。

一个特殊情况是，假如我们将test_mod 定为启动模块（执行python test_mod.py）这个时候test_mod模块的 __ name __ 属性值为 “__ main __” 。此时其上层执行环境被设置为 Py_None。

沿import 路径链依次加载包与模块

在获取了执行环境之后，接下来就要正式开始加载包与模块了。对于语句 import x.y.z 。

x->y->z 可以看做是一个链表，import_module_level函数中，会做一个类似于链表遍历的操作，对于每个节点，都执行加载操作。

// 沿着import 路径链，依次加载包与模块
    head = load_next(parent, level < 0 ? Py_None : parent, &name, buf,&buflen);
    tail = head;
    while (name) {
        next = load_next(tail, tail, &name, buf, &buflen);
        tail = next;
    }

load_next 中的核心函数是 import_submodule 函数

static PyObject *import_submodule(PyObject *mod, char *subname, char *fullname){
    
    // 检查模块是否已经被加载到sys.modules 中
    if ((m = PyDict_GetItemString(modules, fullname)) != NULL) {
    Py_INCREF(m); 
}

    // 试图从mod.__path__ 获取包或者模块的加载路径
    if (mod == Py_None)
        path = NULL;
    else {
        path = PyObject_GetAttrString(mod, "__path__");
        if (path == NULL) {
            PyErr_Clear();
            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    // 搜索模块
    fdp = find_module(fullname, subname, path, buf, MAXPATHLEN+1,
                      &fp, &loader);
   
    // 加载模块
    m = load_module(fullname, fp, buf, fdp->type, loader);
    Py_XDECREF(loader);
    
    // 将目标模块加入到上层package 对象的名字空间中
    if (!add_submodule(mod, m, fullname, subname, modules)) {
        Py_XDECREF(m);
        m = NULL;
    }
    
}

    return m;
}

在import_submodule 函数中，

首先会检测目标名称对应的PyModuleObject 对象是否已经被加载到sys.modules字典中。

如果 sys.modules 中没有找到这个模块对象，那么说明这个模块是全局第一次被加载。会接着执行下列操作。

• 根据当前传入package对象的__ path __ 属性获取目标包或者模块的搜索路径。如果传入package对象为PyNone （对应于__ name __ == "__ main __" 等情况），那么路径为NULL。

• 在获取了path之后，python底层通过find_module 函数搜索 目标 包 或者 模块的 文件系统句柄。

  find_module的模块搜索策略是这样的：首先在传入的path（也就是父级package的路径）下搜索目标，如果path为NULL，或者在path下搜索失败，则依次在sys.path 列表中出现的路径下进行搜索。

• load_module 执行模块或者包的实际加载动作。

  load_module 会根据目标PyModuleObject 对象的预期类型做不同的操作：

load_module(){
    
    switch(type){
        
        case py_source:
            // 如果模块是py
            1.编译
            2.执行代码
            3.创建 module 对象
            4.将执行时的global 空间 放入到module->m_dict 中
            5. 返回 module 对象
            break
        case py_complied:
            // 如果模块是pyc，则没有编译那个过程
            1.执行代码
            2.创建 module 对象
            3.将执行时的global 空间 放入到module->m_dict 中
            4. 返回 module 对象
            break
        case c_extension：
            // 如果模块是c 扩展
            1. 加载动态链接库
            2. 执行initmodule 函数,其中要调用Py_InitModule api
            break
        case pkg：
            // 如果模块是 package
            1.创建模块
            2.加载__init__.py,  load_module(__init__.py).
            break
        }
    }

• add_submodule 函数将load进来的目标PyModuleObject 插入到父级PyModuleObject中。