Python Initialization Lifecycle and Startup Sequence

Python's initialization lifecycle is the deterministic sequence of operations the CPython interpreter executes to transition from an operating system invocation to a fully functional execution environment. This process involves establishing low-level memory allocators, configuring system and environment variables, constructing the core interpreter and thread states, loading built-in types and foundational modules, configuring search paths via the site module, and ultimately executing the target entry point.

1. Pre-Initialization

The startup sequence begins before the primary runtime is fully active, orchestrated at the C level via Py_PreInitialize. During this phase, Python establishes low-level runtime configurations without relying on a functional Python environment.

• Memory Allocation Setup: Python configures its internal memory allocators (such as pymalloc and raw memory allocators).
• Locale and Encoding Configuration: The interpreter reads system locales, specifically LC_CTYPE, to ensure proper handling of command-line arguments and environment variables. UTF-8 mode is evaluated and activated if requested.
• Pre-configuration Flags: The runtime inspects environment variables (such as PYTHONMALLOC, PYTHONUTF8, and PYTHONNODEBUGRANGES) and preliminary command-line arguments to establish basic runtime constraints.

2. Core Runtime Initialization

Once pre-initialization is complete, the runtime initializes the internal CPython infrastructure via Py_InitializeFromConfig and internal calls like Py_InitializeCore.

• Interpreter and Thread State: CPython allocates and configures the PyInterpreterState structure, which holds process-wide global state, followed by the initial PyThreadState, representing the main execution thread.
• Global Interpreter Lock (GIL): The GIL synchronization primitive is created and initialized.
• Core Built-in Types: Essential type objects (such as object, type, tuple, dict, and str) are bootstrapped. Because these types depend on each other cyclically, the runtime performs manual pointer wiring before Python-level instantiation mechanisms are available.
• Runtime Constants: Small integer caching, singletons (such as None, True, False, and Ellipsis), and interned string pools are allocated.

3. Main Interpreter and Module System Setup

With the core structures operational, Python transitions to building the user-facing runtime via _Py_InitializeMain.

• The builtins and sys Modules: The interpreter creates builtins and sys. The sys module is populated with runtime attributes, including standard streams (sys.stdin, sys.stdout, sys.stderr), version data, and implementation details.
• Import System Bootstrap: The import mechanism relies on pure Python code via _frozen_importlib and _frozen_importlib_external. These frozen bytecodes are loaded directly from memory to allow importing before the disk-based import infrastructure is running.
• Signal Handlers: The signal subsystem is established to route POSIX or Windows signals (such as SIGINT for keyboard interrupts) to the main thread's execution loop.

4. Path Calculation and Site Configuration

Before user code can execute, the interpreter must resolve filesystem paths and load extended system configurations.

• Path Calculation: The engine computes the installation prefix and standard library locations, populating sys.path. It searches for markers like os.py or standard library zip files, considering environment overrides like PYTHONPATH.
• Execution of site.py: Unless invoked with the -S flag, Python automatically imports the site module. This module determines third-party package locations, appends site-packages directories to sys.path, processes path configuration files (.pth), and establishes standard aliasing.

5. Execution Phase and Termination

With the environment fully constructed, the runtime transfers control to the user:

• Entry Point Invocation: Depending on how Python was invoked, control delegates to the appropriate handler: executing a script file (PyRun_SimpleFile), running a module (-m), evaluating a string (-c), or launching the interactive REPL.
• Shutdown Sequence (Py_FinalizeEx): When execution concludes, Python shuts down systematically. It flushes standard streams, executes atexit handlers, destroys remaining thread and interpreter states, releases memory, and returns an exit code to the host operating system.