源码位置：cpython\Python\pylifecycle.c

一.Py_InitializeFromConfig

Py_InitializeFromConfig函数是Python解释器初始化的关键入口点，它根据提供的配置参数完成整个解释器的初始化过程。

`PyStatus
Py_InitializeFromConfig(const PyConfig *config)
{
if (config == NULL) {
return _PyStatus_ERR("initialization config is NULL");
}

PyStatus status;

status = _PyRuntime_Initialize();
if (_PyStatus_EXCEPTION(status)) {
return status;
}
_PyRuntimeState *runtime = &_PyRuntime;

PyThreadState *tstate = NULL;
status = pyinit_core(runtime, config, &tstate);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
config = _PyInterpreterState_GetConfig(tstate->interp);

if (config->_init_main) {
status = pyinit_main(tstate);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}

return _PyStatus_OK();
}
`

函数执行流程如下：

1.参数验证：

首先检查传入的config参数是否为NULL，确保有有效的配置信息。

2.运行时初始化

调用_PyRuntime_Initialize()初始化Python运行时环境，这是整个初始化过程的基础。

3.核心初始化

调用pyinit_core(runtime, config, &tstate)进行核心初始化，包括：

4.更新配置引用

核心初始化完成后，更新config指向解释器状态中的配置，确保后续使用最新配置。

5.主模块初始化

如果config->_init_main为真，调用pyinit_main(tstate)执行进一步初始化：

该函数是现代Python（3.8+）中基于配置的初始化机制的核心，它提供了灵活且结构化的方式来定制Python解释器的启动过程。

二.pyinit_core

源码位置：cpython\Python\pylifecycle.c

pyinit_core函数负责Python解释器的初始化工作，这是整个初始化过程的核心部分。此函数负责初始化Python解释器的基本环境，创建第一个线程和解释器状态，但尚未完全启用所有功能。

`/ Begin interpreter initialization

On return, the first thread and interpreter state have been created,
but the compiler, signal handling, multithreading and
multiple interpreter support, and codec infrastructure are not yet
available.

The import system will support builtin and frozen modules only.
The only supported io is writing to sys.stderr

If any operation invoked by this function fails, a fatal error is
issued and the function does not return.

Any code invoked from this function should not assume it has access
to the Python C API (unless the API is explicitly listed as being
safe to call without calling Py_Initialize first)
/
static PyStatus
pyinit_core(_PyRuntimeState runtime,
const PyConfig *src_config,
PyThreadState **tstate_p)
{
PyStatus status;

status = _Py_PreInitializeFromConfig(src_config, NULL);
if (_PyStatus_EXCEPTION(status)) {
return status;
}

PyConfig config;
PyConfig_InitPythonConfig(&config);

status = _PyConfig_Copy(&config, src_config);
if (_PyStatus_EXCEPTION(status)) {
goto done;
}

// Read the configuration, but don't compute the path configuration
// (it is computed in the main init).
status = _PyConfig_Read(&config, 0);
if (_PyStatus_EXCEPTION(status)) {
goto done;
}

if (!runtime->core_initialized) {
status = pyinit_config(runtime, tstate_p, &config);
}
else {
status = pyinit_core_reconfigure(runtime, tstate_p, &config);
}
if (_PyStatus_EXCEPTION(status)) {
goto done;
}

done:
PyConfig_Clear(&config);
return status;
}
`

1.执行流程

（1）预初始化阶段

调用_Py_PreInitializeFromConfig进行运行时的基本配置
如果预初始化失败，直接返回错误状态

（2）配置处理

创建临时配置对象并初始化为Python默认配置
从源配置src_config复制到临时配置
读取配置但不计算路径配置（这会在主初始化中完成）

（3）核心初始化/重配置

根据运行时状态决定执行路径：
- 如果runtime->core_initialized为假，调用pyinit_config进行首次初始化
- 如果已初始化，则调用pyinit_core_reconfigure进行重新配置
检查状态，如有异常则跳转到清理阶段

（4）清理和返回

释放临时配置对象
返回操作状态

2.初始化后的状态

初始化完成后：

第一个线程和解释器状态已创建
导入系统仅支持内置模块和冻结模块
仅支持向sys.stderr写入数据
编译器、信号处理、多线程、多解释器支持等功能尚未可用

3.安全性说明

任何从此函数调用的代码不应假定能访问完整的Python C API，除非该API明确标记为可在Py_Initialize调用前安全使用。

三._PyInterpreterState_GetConfig

源码位置：cpython\Python\pystate.c

这段代码是Python解释器的一个内部API函数，用于获取Python解释器的配置信息。这个函数为其他内部代码提供了一种统一的方式来获取解释器的配置信息，而不需要直接访问解释器状态的内部结构。返回值是常量指针表明调用者只能读取配置，不应该修改它。

const PyConfig* _PyInterpreterState_GetConfig(PyInterpreterState *interp) { return &interp->config; }

函数解析，如下所示：

函数名称：_PyInterpreterState_GetConfig（前缀下划线表示这是内部API）
参数：PyInterpreterState *interp – 指向Python解释器状态的指针
返回值：const PyConfig* – 指向解释器配置的常量指针（只读）
功能：简单地返回解释器状态结构体中config字段的地址

在Python运行时，可能存在多个解释器实例，每个实例都有自己的配置。这个函数允许根据特定解释器实例获取其对应的配置信息。

四.pyinit_main

源码位置：cpython\Python\pylifecycle.c

这段代码定义了pyinit_main函数，负责根据配置设置更新Python解释器状态。

`/ Update interpreter state based on supplied configuration settings

After calling this function, most of the restrictions on the interpreter
are lifted. The only remaining incomplete settings are those related
to the main module (sys.argv[0], main metadata)

Calling this when the interpreter is not initializing, is already
initialized or without a valid current thread state is a fatal error.
Other errors should be reported as normal Python exceptions with a
non-zero return code.
/
static PyStatus
pyinit_main(PyThreadState tstate)
{
PyInterpreterState *interp = tstate->interp;
if (!interp->runtime->core_initialized) {
return _PyStatus_ERR("runtime core not initialized");
}

if (interp->runtime->initialized) {
return pyinit_main_reconfigure(tstate);
}

PyStatus status = init_interp_main(tstate);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
return _PyStatus_OK();
}
`

函数目的，如下所示：

根据提供的配置更新解释器状态
执行后，解释器的大多数限制将被解除
仅保留与主模块相关的设置(如sys.argv[0]和__main__元数据)未完成

1.获取解释器状态

从当前线程状态获取解释器状态指针。

PyInterpreterState *interp = tstate->interp;

2.检查核心初始化

确保运行时核心已经初始化，否则返回错误。

if (!interp->runtime->core_initialized) { return _PyStatus_ERR("runtime core not initialized"); }

3.处理已初始化状态

如果解释器已完全初始化，则调用pyinit_main_reconfigure重新配置解释器。

if (interp->runtime->initialized) { return pyinit_main_reconfigure(tstate); }

4.执行主要初始化

PyStatus status = init_interp_main(tstate);

如果是首次初始化，调用init_interp_main执行完整初始化过程，包括:

5.检查初始化结果

检查初始化结果，失败则返回错误状态，成功则返回OK状态。

if (_PyStatus_EXCEPTION(status)) { return status; } return _PyStatus_OK();

这个函数是Python解释器初始化过程中的关键环节，在核心运行时设置后被调用，完成解释器的完整初始化。

五.init_interp_main

源码位置：cpython\Python\pylifecycle.c

这个函数负责Python解释器的主要初始化工作，它接收一个线程状态指针并完成解释器的核心子系统设置。

`static PyStatus
init_interp_main(PyThreadState *tstate)
{
assert(!_PyErr_Occurred(tstate));

PyStatus status;
int is_main_interp = _Py_IsMainInterpreter(tstate->interp);
PyInterpreterState interp = tstate->interp;
const PyConfig config = _PyInterpreterState_GetConfig(interp);

if (!config->_install_importlib) {
/ Special mode for freeze_importlib: run with no import system

This means anything which needs support from extension modules
or pure Python code in the standard library won't work.
*/
if (is_main_interp) {
interp->runtime->initialized = 1;
}
return _PyStatus_OK();
}

// Initialize the import-related configuration.
status = _PyConfig_InitImportConfig(&interp->config);
if (_PyStatus_EXCEPTION(status)) {
return status;
}

if (interpreter_update_config(tstate, 1) < 0) {
return _PyStatus_ERR("failed to update the Python config");
}

status = _PyImport_InitExternal(tstate);
if (_PyStatus_EXCEPTION(status)) {
return status;
}

if (is_main_interp) {
/ initialize the faulthandler module /
status = _PyFaulthandler_Init(config->faulthandler);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}

status = _PyUnicode_InitEncodings(tstate);
if (_PyStatus_EXCEPTION(status)) {
return status;
}

if (is_main_interp) {
if (_PySignal_Init(config->install_signal_handlers) < 0) {
return _PyStatus_ERR("can't initialize signals");
}

if (config->tracemalloc) {
if (_PyTraceMalloc_Start(config->tracemalloc) < 0) {
return _PyStatus_ERR("can't start tracemalloc");
}
}

ifdef PY_HAVE_PERF_TRAMPOLINE

if (config->perf_profiling) {
_PyPerf_Callbacks *cur_cb;
if (config->perf_profiling == 1) {
cur_cb = &_Py_perfmap_callbacks;
}
else {
cur_cb = &_Py_perfmap_jit_callbacks;
}
if (_PyPerfTrampoline_SetCallbacks(cur_cb) < 0 ||
_PyPerfTrampoline_Init(config->perf_profiling) < 0) {
return _PyStatus_ERR("can't initialize the perf trampoline");
}
}

endif

}

status = init_sys_streams(tstate);
if (_PyStatus_EXCEPTION(status)) {
return status;
}

status = init_set_builtins_open();
if (_PyStatus_EXCEPTION(status)) {
return status;
}

ifdef ANDROID

status = init_android_streams(tstate);
if (_PyStatus_EXCEPTION(status)) {
return status;
}

endif

if defined(APPLE) && HAS_APPLE_SYSTEM_LOG

if (config->use_system_logger) {
status = init_apple_streams(tstate);
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}

endif

ifdef Py_DEBUG

run_presite(tstate);

endif

status = add_main_module(interp);
if (_PyStatus_EXCEPTION(status)) {
return status;
}

if (is_main_interp) {
/ Initialize warnings. /
PyObject warnoptions;
if (_PySys_GetOptionalAttrString("warnoptions", &warnoptions) < 0) {
return _PyStatus_ERR("can't initialize warnings");
}
if (warnoptions != NULL && PyList_Check(warnoptions) &&
PyList_Size(warnoptions) > 0)
{
PyObject warnings_module = PyImport_ImportModule("warnings");
if (warnings_module == NULL) {
fprintf(stderr, "'import warnings' failed; traceback:\n");
_PyErr_Print(tstate);
}
Py_XDECREF(warnings_module);
}
Py_XDECREF(warnoptions);

interp->runtime->initialized = 1;
}

if (config->site_import) {
status = init_import_site();
if (_PyStatus_EXCEPTION(status)) {
return status;
}
}

if (is_main_interp) {

ifndef MS_WINDOWS

emit_stderr_warning_for_legacy_locale(interp->runtime);

endif

}

// Turn on experimental tier 2 (uops-based) optimizer
// This is also needed when the JIT is enabled

ifdef _Py_TIER2

if (is_main_interp) {
int enabled = 1;

if _Py_TIER2 & 2

enabled = 0;

endif

char env = Py_GETENV("PYTHON_JIT");
if (env && env != '\0') {
// PYTHON_JIT=0|1 overrides the default
enabled = *env != '0';
}
if (enabled) {

ifdef _Py_JIT

// perf profiler works fine with tier 2 interpreter, so
// only checking for a "real JIT".
if (config->perf_profiling > 0) {
(void)PyErr_WarnEx(
PyExc_RuntimeWarning,
"JIT deactivated as perf profiling support is active",
0);
} else

endif

{
interp->jit = true;
}
}
}

endif

if (!is_main_interp) {
// The main interpreter is handled in Py_Main(), for now.
if (config->sys_path_0 != NULL) {
PyObject path0 = PyUnicode_FromWideChar(config->sys_path_0, -1);
if (path0 == NULL) {
return _PyStatus_ERR("can't initialize sys.path[0]");
}
PyObject sysdict = interp->sysdict;
if (sysdict == NULL) {
Py_DECREF(path0);
return _PyStatus_ERR("can't initialize sys.path[0]");
}
PyObject *sys_path = PyDict_GetItemWithError(sysdict, &_Py_ID(path));
if (sys_path == NULL) {
Py_DECREF(path0);
return _PyStatus_ERR("can't initialize sys.path[0]");
}
int res = PyList_Insert(sys_path, 0, path0);
Py_DECREF(path0);
if (res) {
return _PyStatus_ERR("can't initialize sys.path[0]");
}
}
}

interp->dict_state.watchers[0] = &builtins_dict_watcher;
if (PyDict_Watch(0, interp->builtins) != 0) {
return _PyStatus_ERR("failed to set builtin dict watcher");
}

assert(!_PyErr_Occurred(tstate));

return _PyStatus_OK();
}
`

函数执行流程，如下所示：