伪代码概述

以下是修改后的导入器如何运行的概述。日志记录或错误处理和无效状态处理等细节被省略，C 代码以简洁的类 Python 语法呈现。

调用导入器的框架在 PEP 451 中进行了说明。

importlib/_bootstrap.py

class BuiltinImporter:
    def create_module(self, spec):
        module = _imp.create_builtin(spec)

    def exec_module(self, module):
        _imp.exec_dynamic(module)

    def load_module(self, name):
        # use a backwards compatibility shim
        _load_module_shim(self, name)

importlib/_bootstrap_external.py

class ExtensionFileLoader:
    def create_module(self, spec):
        module = _imp.create_dynamic(spec)

    def exec_module(self, module):
        _imp.exec_dynamic(module)

    def load_module(self, name):
        # use a backwards compatibility shim
        _load_module_shim(self, name)

Python/import.c（_imp 模块）

def create_dynamic(spec):
    name = spec.name
    path = spec.origin

    # Find an already loaded module that used single-phase init.
    # For multi-phase initialization, mod is NULL, so a new module
    # is always created.
    mod = _PyImport_FindExtensionObject(name, name)
    if mod:
        return mod

    return _PyImport_LoadDynamicModuleWithSpec(spec)

def exec_dynamic(module):
    if not isinstance(module, types.ModuleType):
        # non-modules are skipped -- PyModule_GetDef fails on them
        return

    def = PyModule_GetDef(module)
    state = PyModule_GetState(module)
    if state is NULL:
        PyModule_ExecDef(module, def)

def create_builtin(spec):
    name = spec.name

    # Find an already loaded module that used single-phase init.
    # For multi-phase initialization, mod is NULL, so a new module
    # is always created.
    mod = _PyImport_FindExtensionObject(name, name)
    if mod:
        return mod

    for initname, initfunc in PyImport_Inittab:
        if name == initname:
            m = initfunc()
            if isinstance(m, PyModuleDef):
                def = m
                return PyModule_FromDefAndSpec(def, spec)
            else:
                # fall back to single-phase initialization
                module = m
                _PyImport_FixupExtensionObject(module, name, name)
                return module

Python/importdl.c

def _PyImport_LoadDynamicModuleWithSpec(spec):
    path = spec.origin
    package, dot, name = spec.name.rpartition('.')

    # see the "Non-ASCII module names" section for export_hook_name
    hook_name = export_hook_name(name)

    # call platform-specific function for loading exported function
    # from shared library
    exportfunc = _find_shared_funcptr(hook_name, path)

    m = exportfunc()
    if isinstance(m, PyModuleDef):
        def = m
        return PyModule_FromDefAndSpec(def, spec)

    module = m

    # fall back to single-phase initialization
    ....

Objects/moduleobject.c

def PyModule_FromDefAndSpec(def, spec):
    name = spec.name
    create = None
    for slot, value in def.m_slots:
        if slot == Py_mod_create:
            create = value
    if create:
        m = create(spec, def)
    else:
        m = PyModule_New(name)

    if isinstance(m, types.ModuleType):
        m.md_state = None
        m.md_def = def

    if def.m_methods:
        PyModule_AddFunctions(m, def.m_methods)
    if def.m_doc:
        PyModule_SetDocString(m, def.m_doc)

def PyModule_ExecDef(module, def):
    if isinstance(module, types.module_type):
        if module.md_state is NULL:
            # allocate a block of zeroed-out memory
            module.md_state = _alloc(module.md_size)

    if def.m_slots is NULL:
        return

    for slot, value in def.m_slots:
        if slot == Py_mod_exec:
            value(module)

模块创建阶段

模块对象的创建——即 ExecutionLoader.create_module 的实现——受 Py_mod_create 槽控制。

PyObject* (*PyModuleCreateFunction)(PyObject *spec, PyModuleDef *def)

模块执行阶段

模块执行——即 ExecutionLoader.exec_module 的实现——受“执行槽”控制。本 PEP 仅添加了一个，Py_mod_exec，但在未来可能会添加其他槽。

执行阶段是在与模块对象关联的 PyModuleDef 上完成的。对于不是 PyModule_Type 子类的对象（对于它们，PyModule_GetDef 会失败），执行阶段会被跳过。

执行槽可以多次指定，并且按照它们在槽数组中出现的顺序进行处理。在使用默认导入机制时，它们在设置 PEP 451 中指定的与导入相关的属性（例如 __name__ 或 __loader__）之后以及模块被添加到 sys.modules 中之后进行处理。

int (*PyModuleExecFunction)(PyObject* module)

传统初始化

向后兼容的单阶段初始化仍然受支持。在这个方案中，PyInit 函数返回一个完全初始化的模块，而不是一个 PyModuleDef 对象。在这种情况下，PyInit 钩子实现了创建阶段，执行阶段是无操作的。

需要在旧版本的 Python 上保持不变的模块应该坚持使用单阶段初始化，因为它带来的好处无法回溯。以下是一个支持多阶段初始化的模块示例，在为旧版本的 CPython 编译时会回退到单阶段初始化。它主要作为一个说明启用多阶段 init 所需更改的示例。

#include <Python.h>

static int spam_exec(PyObject *module) {
    PyModule_AddStringConstant(module, "food", "spam");
    return 0;
}

#ifdef Py_mod_exec
static PyModuleDef_Slot spam_slots[] = {
    {Py_mod_exec, spam_exec},
    {0, NULL}
};
#endif

static PyModuleDef spam_def = {
    PyModuleDef_HEAD_INIT,                      /* m_base */
    "spam",                                     /* m_name */
    PyDoc_STR("Utilities for cooking spam"),    /* m_doc */
    0,                                          /* m_size */
    NULL,                                       /* m_methods */
#ifdef Py_mod_exec
    spam_slots,                                 /* m_slots */
#else
    NULL,
#endif
    NULL,                                       /* m_traverse */
    NULL,                                       /* m_clear */
    NULL,                                       /* m_free */
};

PyMODINIT_FUNC
PyInit_spam(void) {
#ifdef Py_mod_exec
    return PyModuleDef_Init(&spam_def);
#else
    PyObject *module;
    module = PyModule_Create(&spam_def);
    if (module == NULL) return NULL;
    if (spam_exec(module) != 0) {
        Py_DECREF(module);
        return NULL;
    }
    return module;
#endif
}

内置模块

任何扩展模块都可以通过将其链接到可执行文件并将其包含在 inittab 中（在运行时使用 PyImport_AppendInittab，或在配置时使用 freeze 等工具）来用作内置模块。

为了保持这种可能性，本 PEP 中引入的扩展模块加载的所有更改也将应用于内置模块。唯一的例外是非 ASCII 模块名称，将在下面解释。

子解释器和解释器重新加载

使用新的初始化方案的扩展预计要正确支持子解释器和多个 Py_Initialize/Py_Finalize 周期，避免 Python 文档 [6] 中提到的问题。该机制的设计旨在使这变得容易，但扩展作者仍然需要小心。任何用户定义的函数、方法或实例都不能泄漏到不同的解释器。为了实现这一点，所有模块级状态应保留在模块字典中，或在模块对象的存储中通过 PyModule_GetState 访问。一个简单的经验法则是：不要定义任何静态数据，除了没有可变或用户可设置类属性的内置类型。

与多阶段初始化不兼容的函数

当在具有非 NULL m_slots 指针的 PyModuleDef 结构上使用时，PyModule_Create 函数将失败。该函数没有访问多阶段初始化所需的 ModuleSpec 对象。

PyState_FindModule 函数将返回 NULL，PyState_AddModule 和 PyState_RemoveModule 也将在具有非 NULL m_slots 的模块上失败。PyState 注册被禁用，因为可能从同一个 PyModuleDef 创建多个模块对象。

模块状态和 C 级回调

由于 PyState_FindModule 的不可用，任何需要访问模块级状态的函数（包括在模块级别定义的函数、类或异常）都必须直接或间接地接收对模块对象（或其需要的特定对象）的引用。这在当前的两种情况下很困难

• 类的 Method，它接收对类的引用，但没有接收对类的模块的引用
• 具有 C 级回调的库，除非回调可以接收在回调注册时设置的自定义数据

修复这些情况超出了本 PEP 的范围，但对于新机制对所有模块有用来说是必要的。在 import-sig 邮件列表 [5] 上讨论了适当的修复方案。

一般来说，依赖于 PyState_FindModule 的模块目前不适合移植到新机制。

新函数

将添加一个实现模块创建阶段的新函数和宏。它们类似于 PyModule_Create 和 PyModule_Create2，除了它们接受一个额外的 ModuleSpec 参数，并处理具有非 NULL 槽的模块定义。

PyObject * PyModule_FromDefAndSpec(PyModuleDef *def, PyObject *spec)
PyObject * PyModule_FromDefAndSpec2(PyModuleDef *def, PyObject *spec,
                                    int module_api_version)

将添加一个实现模块执行阶段的新函数。它分配每个模块的狀態（如果尚未分配），并始终处理执行槽。导入机制在执行模块时调用此方法，除非正在重新加载模块。

PyAPI_FUNC(int) PyModule_ExecDef(PyObject *module, PyModuleDef *def)

将引入另一个函数来初始化 PyModuleDef 对象。这个幂等函数填充类型、引用计数和模块索引。它返回其参数转换为 PyObject*，因此可以直接从 PyInit 函数返回。

PyObject * PyModuleDef_Init(PyModuleDef *);

此外，将添加两个助手来设置模块的 docstring 和方法。

int PyModule_SetDocString(PyObject *, const char *)
int PyModule_AddFunctions(PyObject *, PyMethodDef *)

导出钩子名称

由于可移植的 C 标识符仅限于 ASCII，因此必须对模块名称进行编码以形成 PyInit 钩子名称。

对于 ASCII 模块名称，导入钩子名为 PyInit_<modulename>，其中 <modulename> 是模块的名称。

对于包含非 ASCII 字符的模块名称，导入钩子名为 PyInitU_<encodedname>，其中名称使用 CPython 的“punycode”编码 (Punycode，后缀为小写字母)，并将连字符 (“-”) 替换为下划线 (“_”)。

在 Python 中

def export_hook_name(name):
    try:
        suffix = b'_' + name.encode('ascii')
    except UnicodeEncodeError:
        suffix = b'U_' + name.encode('punycode').replace(b'-', b'_')
    return b'PyInit' + suffix

示例

对于具有非 ASCII 名称的模块，不支持单阶段初始化。

在本 PEP 的初始实现中，不支持具有非 ASCII 名称的内置模块。

模块重新加载

使用 importlib.reload() 重新加载扩展模块将继续没有任何效果，除了重新设置与导入相关的属性。

由于共享库加载的限制（包括 POSIX 上的 dlopen 和 Windows 上的 LoadModuleEx），在磁盘上更改后通常不可能加载修改后的库。

除了尝试使用模块的新版本之外，重新加载的其他用例过于罕见，无法要求所有模块作者都记住重新加载。如果需要类似重新加载的功能，作者可以为其导出专用函数。

一个库中的多个模块

为了在一个共享库中支持多个 Python 模块，库可以导出除与库文件名对应的 PyInit* 符号之外的其他符号。

请注意，此机制目前只能用于加载额外的模块，而不能用于查找它们。（这是加载器机制的限制，本 PEP 不会尝试修改。）为了解决缺少合适的查找器的問題，可以使用以下代码

import importlib.machinery
import importlib.util
loader = importlib.machinery.ExtensionFileLoader(name, path)
spec = importlib.util.spec_from_loader(name, loader)
module = importlib.util.module_from_spec(spec)
loader.exec_module(module)
return module

在支持符号链接的平台上，可以使用符号链接将一个库安装在多个名称下，并将所有导出的模块公开给正常的导入机制。

测试和初始实现

为了进行测试，将创建一个新的内置模块 _testmultiphase。该库将使用“一个库中的多个模块”中描述的机制导出几个额外的模块。

模块 _testcapi 将保持不变，并将无限期地使用单阶段初始化（或者直到不再支持它）。

模块 array 和 xx* 将被转换为使用多阶段初始化，作为初始实现的一部分。

向后兼容性

现有模块将继续与新版本的 Python 具有源代码和二进制兼容性。使用多阶段初始化的模块将与未实现本 PEP 的 Python 版本不兼容。

函数 init_builtin 和 load_dynamic 将从模块 _imp 中删除（但不会从模块 imp 中删除）。

所有更改的加载器（BuiltinImporter 和 ExtensionFileLoader）将保持向后兼容；方法 load_module 将被垫片替换。

将删除 Python/import.c 和 Python/importdl.c 的内部函数。（具体来说，这些是 _PyImport_GetDynLoadFunc、_PyImport_GetDynLoadWindows 和 _PyImport_LoadDynamicModule。）