PyWideStringList

PyWideStringList is a list of wchar_t* strings.

PyWideStringList structure fields:

• length (Py_ssize_t)
• items (wchar_t**)

Methods:

• PyStatus PyWideStringList_Append(PyWideStringList *list, const wchar_t *item): Append item to list.
• PyStatus PyWideStringList_Insert(PyWideStringList *list, Py_ssize_t index, const wchar_t *item): Insert item into list at index. If index is greater than list length, just append item to list.

If length is non-zero, items must be non-NULL and all strings must be non-NULL.

PyStatus

PyStatus is a structure to store the status of an initialization function: success, error or exit. For an error, it can store the C function name which created the error.

Example:

PyStatus alloc(void **ptr, size_t size)
{
    *ptr = PyMem_RawMalloc(size);
    if (*ptr == NULL) {
        return PyStatus_NoMemory();
    }
    return PyStatus_Ok();
}

int main(int argc, char **argv)
{
    void *ptr;
    PyStatus status = alloc(&ptr, 16);
    if (PyStatus_Exception(status)) {
        Py_ExitStatusException(status);
    }
    PyMem_Free(ptr);
    return 0;
}

PyStatus fields:

• exitcode (int): Argument passed to exit().
• err_msg (const char*): Error message.
• func (const char *): Name of the function which created an error, can be NULL.
• private _type field: for internal usage only.

Functions to create a status:

• PyStatus_Ok(): Success.
• PyStatus_Error(err_msg): Initialization error with a message.
• PyStatus_NoMemory(): Memory allocation failure (out of memory).
• PyStatus_Exit(exitcode): Exit Python with the specified exit code.

Functions to handle a status:

• PyStatus_Exception(status): Is the result an error or an exit? If true, the exception must be handled; by calling Py_ExitStatusException(status) for example.
• PyStatus_IsError(status): Is the result an error?
• PyStatus_IsExit(status): Is the result an exit?
• Py_ExitStatusException(status): Call exit(exitcode) if status is an exit. Print the error messageand exit with a non-zero exit code if status is an error. Must only be called if PyStatus_Exception(status) is true.

Preinitialization with PyPreConfig

The PyPreConfig structure is used to preinitialize Python:

• Set the Python memory allocator
• Configure the LC_CTYPE locale
• Set the UTF-8 mode

Example using the preinitialization to enable the UTF-8 Mode:

PyStatus status;
PyPreConfig preconfig;

PyPreConfig_InitPythonConfig(&preconfig);

preconfig.utf8_mode = 1;

status = Py_PreInitialize(&preconfig);
if (PyStatus_Exception(status)) {
    Py_ExitStatusException(status);
}

/* at this point, Python will speak UTF-8 */

Py_Initialize();
/* ... use Python API here ... */
Py_Finalize();

Function to initialize a preconfiguration:

• PyStatus PyPreConfig_InitIsolatedConfig(PyPreConfig *preconfig)
• PyStatus PyPreConfig_InitPythonConfig(PyPreConfig *preconfig)

Functions to preinitialize Python:

• PyStatus Py_PreInitialize(const PyPreConfig *preconfig)
• PyStatus Py_PreInitializeFromBytesArgs(const PyPreConfig *preconfig, int argc, char * const *argv)
• PyStatus Py_PreInitializeFromArgs(const PyPreConfig *preconfig, int argc, wchar_t * const * argv)

The caller is responsible to handle exceptions (error or exit) using PyStatus_Exception() and Py_ExitStatusException().

For Python Configuration (PyPreConfig_InitPythonConfig()), if Python is initialized with command line arguments, the command line arguments must also be passed to preinitialize Python, since they have an effect on the pre-configuration like encodings. For example, the -X utf8 command line option enables the UTF-8 Mode.

PyPreConfig fields:

• allocator (int): Name of the memory allocator (ex: PYMEM_ALLOCATOR_MALLOC). Valid values:
  • PYMEM_ALLOCATOR_NOT_SET (0): don’t change memory allocators (use defaults)
  • PYMEM_ALLOCATOR_DEFAULT (1): default memory allocators
  • PYMEM_ALLOCATOR_DEBUG (2): default memory allocators with debug hooks
  • PYMEM_ALLOCATOR_MALLOC (3): force usage of malloc()
  • PYMEM_ALLOCATOR_MALLOC_DEBUG (4): force usage of malloc() with debug hooks
  • PYMEM_ALLOCATOR_PYMALLOC (5): Python “pymalloc” allocator
  • PYMEM_ALLOCATOR_PYMALLOC_DEBUG (6): Python “pymalloc” allocator with debug hooks
  • Note: PYMEM_ALLOCATOR_PYMALLOC and PYMEM_ALLOCATOR_PYMALLOC_DEBUG are not supported if Python is configured using --without-pymalloc
• configure_locale (int): Set the LC_CTYPE locale to the user preferred locale? If equals to 0, set coerce_c_locale and coerce_c_locale_warn to 0.
• coerce_c_locale (int): If equals to 2, coerce the C locale; if equals to 1, read the LC_CTYPE locale to decide if it should be coerced.
• coerce_c_locale_warn (int): If non-zero, emit a warning if the C locale is coerced.
• dev_mode (int): See PyConfig.dev_mode.
• isolated (int): See PyConfig.isolated.
• legacy_windows_fs_encoding (int, Windows only): If non-zero, disable UTF-8 Mode, set the Python filesystem encoding to mbcs, set the filesystem error handler to replace.
• parse_argv (int): If non-zero, Py_PreInitializeFromArgs() and Py_PreInitializeFromBytesArgs() parse their argv argument the same way the regular Python parses command line arguments: see Command Line Arguments.
• use_environment (int): See PyConfig.use_environment.
• utf8_mode (int): If non-zero, enable the UTF-8 mode.

The legacy_windows_fs_encoding field is only available on Windows. #ifdef MS_WINDOWS macro can be used for Windows specific code.

PyPreConfig private fields, for internal use only:

• _config_init (int): Function used to initialize PyConfig, used for preinitialization.

PyMem_SetAllocator() can be called after Py_PreInitialize() and before Py_InitializeFromConfig() to install a custom memory allocator. It can be called before Py_PreInitialize() if allocator is set to PYMEM_ALLOCATOR_NOT_SET (default value).

Python memory allocation functions like PyMem_RawMalloc() must not be used before Python preinitialization, whereas calling directly malloc() and free() is always safe. Py_DecodeLocale() must not be called before the preinitialization.

Initialization with PyConfig

The PyConfig structure contains most parameters to configure Python.

Example setting the program name:

void init_python(void)
{
    PyStatus status;

    PyConfig config;
    PyConfig_InitPythonConfig(&config);

    /* Set the program name. Implicitly preinitialize Python. */
    status = PyConfig_SetString(&config, &config.program_name,
                                L"/path/to/my_program");
    if (PyStatus_Exception(status)) {
        goto fail;
    }

    status = Py_InitializeFromConfig(&config);
    if (PyStatus_Exception(status)) {
        goto fail;
    }
    PyConfig_Clear(&config);
    return;

fail:
    PyConfig_Clear(&config);
    Py_ExitStatusException(status);
}

PyConfig methods:

• void PyConfig_InitPythonConfig(PyConfig *config) Initialize configuration with Python Configuration.
• void PyConfig_InitIsolatedConfig(PyConfig *config): Initialize configuration with Isolated Configuration.
• PyStatus PyConfig_SetString(PyConfig *config, wchar_t * const *config_str, const wchar_t *str): Copy the wide character string str into *config_str. Preinitialize Python if needed.
• PyStatus PyConfig_SetBytesString(PyConfig *config, wchar_t * const *config_str, const char *str): Decode str using Py_DecodeLocale() and set the result into *config_str. Preinitialize Python if needed.
• PyStatus PyConfig_SetArgv(PyConfig *config, int argc, wchar_t * const *argv): Set command line arguments from wide character strings. Preinitialize Python if needed.
• PyStatus PyConfig_SetBytesArgv(PyConfig *config, int argc, char * const *argv): Set command line arguments: decode bytes using Py_DecodeLocale(). Preinitialize Python if needed.
• PyStatus PyConfig_Read(PyConfig *config): Read all Python configuration. Fields which are already initialized are left unchanged. Preinitialize Python if needed.
• void PyConfig_Clear(PyConfig *config): Release configuration memory.

Most PyConfig methods preinitialize Python if needed. In that case, the Python preinitialization configuration in based on the PyConfig. If configuration fields which are in common with PyPreConfig are tuned, they must be set before calling a PyConfig method:

• dev_mode
• isolated
• parse_argv
• use_environment

Moreover, if PyConfig_SetArgv() or PyConfig_SetBytesArgv() is used, this method must be called first, before other methods, since the preinitialization configuration depends on command line arguments (if parse_argv is non-zero).

Functions to initialize Python:

• PyStatus Py_InitializeFromConfig(const PyConfig *config): Initialize Python from config configuration.

The caller of these methods and functions is responsible to handle exceptions (error or exit) using PyStatus_Exception() and Py_ExitStatusException().

PyConfig fields:

• argv (PyWideStringList): Command line arguments, sys.argv. See parse_argv to parse argv the same way the regular Python parses Python command line arguments. If argv is empty, an empty string is added to ensure that sys.argv always exists and is never empty.
• base_exec_prefix (wchar_t*): sys.base_exec_prefix.
• base_prefix (wchar_t*): sys.base_prefix.
• buffered_stdio (int): If equals to 0, enable unbuffered mode, making the stdout and stderr streams unbuffered.
• bytes_warning (int): If equals to 1, issue a warning when comparing bytes or bytearray with str, or comparing bytes with int. If equal or greater to 2, raise a BytesWarning exception.
• check_hash_pycs_mode (wchar_t*): --check-hash-based-pycs command line option value (see PEP 552). Valid values: always, never and default. The default value is default.
• configure_c_stdio (int): If non-zero, configure C standard streams (stdio, stdout, stdout). For example, set their mode to O_BINARY on Windows.
• dev_mode (int): Development mode
• dump_refs (int): If non-zero, dump all objects which are still alive at exit. Require a special Python build with Py_REF_DEBUG macro defined.
• exec_prefix (wchar_t*): sys.exec_prefix.
• executable (wchar_t*): sys.executable.
• faulthandler (int): If non-zero, call faulthandler.enable().
• filesystem_encoding (wchar_t*): Filesystem encoding, sys.getfilesystemencoding().
• filesystem_errors (wchar_t*): Filesystem encoding errors, sys.getfilesystemencodeerrors().
• use_hash_seed (int), hash_seed (unsigned long): Randomized hash function seed.
• home (wchar_t*): Python home directory.
• import_time (int): If non-zero, profile import time.
• inspect (int): Enter interactive mode after executing a script or a command.
• install_signal_handlers (int): Install signal handlers?
• interactive (int): Interactive mode.
• isolated (int): If greater than 0, enable isolated mode:
  • sys.path contains neither the script’s directory (computed from argv[0] or the current directory) nor the user’s site-packages directory.
  • Python REPL doesn’t import readline nor enable default readline configuration on interactive prompts.
  • Set use_environment and user_site_directory to 0.
• legacy_windows_stdio (int, Windows only): If non-zero, use io.FileIO instead of WindowsConsoleIO for sys.stdin, sys.stdout and sys.stderr.
• malloc_stats (int): If non-zero, dump statistics on pymalloc memory allocator at exit. The option is ignored if Python is built using --without-pymalloc.
• pythonpath_env (wchar_t*): Module search paths as a string separated by DELIM (usually : character). Initialized from PYTHONPATH environment variable value by default.
• module_search_paths_set (int), module_search_paths (PyWideStringList): sys.path. If module_search_paths_set is equal to 0, the module_search_paths is overridden by the function computing the Path Configuration.
• optimization_level (int): Compilation optimization level:
  • 0: Peephole optimizer (and __debug__ is set to True)
  • 1: Remove assertions, set __debug__ to False
  • 2: Strip docstrings
• parse_argv (int): If non-zero, parse argv the same way the regular Python command line arguments, and strip Python arguments from argv: see Command Line Arguments.
• parser_debug (int): If non-zero, turn on parser debugging output (for expert only, depending on compilation options).
• pathconfig_warnings (int): If equal to 0, suppress warnings when computing the path configuration (Unix only, Windows does not log any warning). Otherwise, warnings are written into stderr.
• prefix (wchar_t*): sys.prefix.
• program_name (wchar_t*): Program name.
• pycache_prefix (wchar_t*): .pyc cache prefix.
• quiet (int): Quiet mode. For example, don’t display the copyright and version messages even in interactive mode.
• run_command (wchar_t*): python3 -c COMMAND argument.
• run_filename (wchar_t*): python3 FILENAME argument.
• run_module (wchar_t*): python3 -m MODULE argument.
• show_alloc_count (int): Show allocation counts at exit? Need a special Python build with COUNT_ALLOCS macro defined.
• show_ref_count (int): Show total reference count at exit? Need a debug build of Python (Py_REF_DEBUG macro should be defined).
• site_import (int): Import the site module at startup?
• skip_source_first_line (int): Skip the first line of the source?
• stdio_encoding (wchar_t*), stdio_errors (wchar_t*): Encoding and encoding errors of sys.stdin, sys.stdout and sys.stderr.
• tracemalloc (int): If non-zero, call tracemalloc.start(value).
• user_site_directory (int): If non-zero, add user site directory to sys.path.
• verbose (int): If non-zero, enable verbose mode.
• warnoptions (PyWideStringList): Options of the warnings module to build warnings filters.
• write_bytecode (int): If non-zero, write .pyc files.
• xoptions (PyWideStringList): sys._xoptions.

The legacy_windows_stdio field is only available on Windows. #ifdef MS_WINDOWS macro can be used for Windows specific code.

If parse_argv is non-zero, argv arguments are parsed the same way the regular Python parses command line arguments, and Python arguments are stripped from argv: see Command Line Arguments.

The xoptions options are parsed to set other options: see -X Options.

PyConfig private fields, for internal use only:

• _config_init (int): Function used to initialize PyConfig, used for preinitialization.
• _install_importlib (int): Install importlib?
• _init_main (int): If equal to 0, stop Python initialization before the “main” phase (see PEP 432).

More complete example modifying the default configuration, read the configuration, and then override some parameters:

PyStatus init_python(const char *program_name)
{
    PyStatus status;

    PyConfig config;
    PyConfig_InitPythonConfig(&config);

    /* Set the program name before reading the configuration
       (decode byte string from the locale encoding).

       Implicitly preinitialize Python. */
    status = PyConfig_SetBytesString(&config, &config.program_name,
                                  program_name);
    if (PyStatus_Exception(status)) {
        goto done;
    }

    /* Read all configuration at once */
    status = PyConfig_Read(&config);
    if (PyStatus_Exception(status)) {
        goto done;
    }

    /* Append our custom search path to sys.path */
    status = PyWideStringList_Append(&config.module_search_paths,
                                  L"/path/to/more/modules");
    if (PyStatus_Exception(status)) {
        goto done;
    }

    /* Override executable computed by PyConfig_Read() */
    status = PyConfig_SetString(&config, &config.executable,
                                L"/path/to/my_executable");
    if (PyStatus_Exception(status)) {
        goto done;
    }

    status = Py_InitializeFromConfig(&config);

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

Isolated Configuration

PyPreConfig_InitIsolatedConfig() and PyConfig_InitIsolatedConfig() functions create a configuration to isolate Python from the system. For example, to embed Python into an application.

This configuration ignores global configuration variables, environments variables and command line arguments (argv is not parsed). The C standard streams (ex: stdout) and the LC_CTYPE locale are left unchanged by default.

Configuration files are still used with this configuration. Set the Path Configuration (“output fields”) to ignore these configuration files and avoid the function computing the default path configuration.

Python Configuration

PyPreConfig_InitPythonConfig() and PyConfig_InitPythonConfig() functions create a configuration to build a customized Python which behaves as the regular Python.

Environments variables and command line arguments are used to configure Python, whereas global configuration variables are ignored.

This function enables C locale coercion (PEP 538) and UTF-8 Mode (PEP 540) depending on the LC_CTYPE locale, PYTHONUTF8 and PYTHONCOERCECLOCALE environment variables.

Example of customized Python always running in isolated mode:

int main(int argc, char **argv)
{
    PyStatus status;

    PyConfig config;
    PyConfig_InitPythonConfig(&config);

    config.isolated = 1;

    /* Decode command line arguments.
       Implicitly preinitialize Python (in isolated mode). */
    status = PyConfig_SetBytesArgv(&config, argc, argv);
    if (PyStatus_Exception(status)) {
        goto fail;
    }

    status = Py_InitializeFromConfig(&config);
    if (PyStatus_Exception(status)) {
        goto fail;
    }
    PyConfig_Clear(&config);

    return Py_RunMain();

fail:
    PyConfig_Clear(&config);
    if (PyStatus_IsExit(status)) {
        return status.exitcode;
    }
    /* Display the error message and exit the process with
       non-zero exit code */
    Py_ExitStatusException(status);
}

This example is a basic implementation of the “System Python Executable” discussed in PEP 432.

Path Configuration

PyConfig contains multiple fields for the path configuration:

• Path configuration input fields:
  • home
  • pythonpath_env
  • pathconfig_warnings
• Path configuration output fields:
  • exec_prefix
  • executable
  • prefix
  • module_search_paths_set, module_search_paths

If at least one “output field” is not set, Python computes the path configuration to fill unset fields. If module_search_paths_set is equal to 0, module_search_paths is overridden and module_search_paths_set is set to 1.

It is possible to completely ignore the function computing the default path configuration by setting explicitly all path configuration output fields listed above. A string is considered as set even if it is non-empty. module_search_paths is considered as set if module_search_paths_set is set to 1. In this case, path configuration input fields are ignored as well.

Set pathconfig_warnings to 0 to suppress warnings when computing the path configuration (Unix only, Windows does not log any warning).

If base_prefix or base_exec_prefix fields are not set, they inherit their value from prefix and exec_prefix respectively.

Py_RunMain() and Py_Main() modify sys.path:

• If run_filename is set and is a directory which contains a __main__.py script, prepend run_filename to sys.path.
• If isolated is zero:
  • If run_module is set, prepend the current directory to sys.path. Do nothing if the current directory cannot be read.
  • If run_filename is set, prepends the directory of the filename to sys.path.
  • Otherwise, prepends an empty string to sys.path.

If site_import is non-zero, sys.path can be modified by the site module. If user_site_directory is non-zero and the user’s site-package directory exists, the site module appends the user’s site-package directory to sys.path.

See also Configuration Files used by the path configuration.

Py_BytesMain()

Python 3.7 provides a high-level Py_Main() function which requires to pass command line arguments as wchar_t* strings. It is non-trivial to use the correct encoding to decode bytes. Python has its own set of issues with C locale coercion and UTF-8 Mode.

This PEP adds a new Py_BytesMain() function which takes command line arguments as bytes:

int Py_BytesMain(int argc, char **argv)

Py_RunMain()

The new Py_RunMain() function executes the command (PyConfig.run_command), the script (PyConfig.run_filename) or the module (PyConfig.run_module) specified on the command line or in the configuration, and then finalizes Python. It returns an exit status that can be passed to the exit() function.

int Py_RunMain(void);

See Python Configuration for an example of customized Python always running in isolated mode using Py_RunMain().

Multi-Phase Initialization Private Provisional API

This section is a private provisional API introducing multi-phase initialization, the core feature of the PEP 432:

• “Core” initialization phase, “bare minimum Python”:
  • Builtin types;
  • Builtin exceptions;
  • Builtin and frozen modules;
  • The sys module is only partially initialized (ex: sys.path doesn’t exist yet);
• “Main” initialization phase, Python is fully initialized:
  • Install and configure importlib;
  • Apply the Path Configuration;
  • Install signal handlers;
  • Finish sys module initialization (ex: create sys.stdout and sys.path);
  • Enable optional features like faulthandler and tracemalloc;
  • Import the site module;
  • etc.

Private provisional API:

• PyConfig._init_main: if set to 0, Py_InitializeFromConfig() stops at the “Core” initialization phase.
• PyStatus _Py_InitializeMain(void): move to the “Main” initialization phase, finish the Python initialization.

No module is imported during the “Core” phase and the importlib module is not configured: the Path Configuration is only applied during the “Main” phase. It may allow to customize Python in Python to override or tune the Path Configuration, maybe install a custom sys.meta_path importer or an import hook, etc.

It may become possible to compute the Path Configuration in Python, after the Core phase and before the Main phase, which is one of the PEP 432 motivation.

The “Core” phase is not properly defined: what should be and what should not be available at this phase is not specified yet. The API is marked as private and provisional: the API can be modified or even be removed anytime until a proper public API is designed.

Example running Python code between “Core” and “Main” initialization phases:

void init_python(void)
{
    PyStatus status;

    PyConfig config;
    PyConfig_InitPythonConfig(&config);

    config._init_main = 0;

    /* ... customize 'config' configuration ... */

    status = Py_InitializeFromConfig(&config);
    PyConfig_Clear(&config);
    if (PyStatus_Exception(status)) {
        Py_ExitStatusException(status);
    }

    /* Use sys.stderr because sys.stdout is only created
       by _Py_InitializeMain() */
    int res = PyRun_SimpleString(
        "import sys; "
        "print('Run Python code before _Py_InitializeMain', "
               "file=sys.stderr)");
    if (res < 0) {
        exit(1);
    }

    /* ... put more configuration code here ... */

    status = _Py_InitializeMain();
    if (PyStatus_Exception(status)) {
        Py_ExitStatusException(status);
    }
}

Comparison of Python and Isolated Configurations

Differences between PyPreConfig_InitPythonConfig() and PyPreConfig_InitIsolatedConfig():

Differences between PyConfig_InitPythonConfig() and PyConfig_InitIsolatedConfig():

Priority and Rules

Priority of configuration parameters, highest to lowest:

• PyConfig
• PyPreConfig
• Configuration files
• Command line options
• Environment variables
• Global configuration variables

Priority of warning options, highest to lowest:

• PyConfig.warnoptions
• PySys_AddWarnOption()
• PyConfig.bytes_warning (add "error::BytesWarning" filter if greater than 1, add "default::BytesWarning filter if equals to 1)
• -W opt command line argument
• PYTHONWARNINGS environment variable
• PyConfig.dev_mode (add "default" filter)

Rules on PyConfig parameters:

• If isolated is non-zero, use_environment and user_site_directory are set to 0.
• If dev_mode is non-zero, allocator is set to "debug", faulthandler is set to 1, and "default" filter is added to warnoptions. But the PYTHONMALLOC environment variable has the priority over dev_mode to set the memory allocator.
• If base_prefix is not set, it inherits prefix value.
• If base_exec_prefix is not set, it inherits exec_prefix value.
• If the python._pth configuration file is present, isolated is set to 1 and site_import is set to 0; but site_import is set to 1 if python._pth contains import site.

Rules on PyConfig and PyPreConfig parameters:

• If PyPreConfig.legacy_windows_fs_encoding is non-zero, set PyPreConfig.utf8_mode to 0, set PyConfig.filesystem_encoding to mbcs, and set PyConfig.filesystem_errors to replace.

Configuration Files

Python configuration files used by the Path Configuration:

• pyvenv.cfg
• python._pth (Windows only)
• pybuilddir.txt (Unix only)

Global Configuration Variables

Global configuration variables mapped to PyPreConfig fields:

(NOT) means that the PyPreConfig value is the opposite of the global configuration variable value. Py_LegacyWindowsFSEncodingFlag is only available on Windows.

Global configuration variables mapped to PyConfig fields:

(NOT) means that the PyConfig value is the opposite of the global configuration variable value. Py_LegacyWindowsStdioFlag is only available on Windows.

Command Line Arguments

Usage:

python3 [options]
python3 [options] -c COMMAND
python3 [options] -m MODULE
python3 [options] SCRIPT

Command line options mapped to pseudo-action on PyPreConfig fields:

Command line options mapped to pseudo-action on PyConfig fields:

-h, -? and -V options are handled without PyConfig.

-X Options

-X options mapped to pseudo-action on PyConfig fields:

Environment Variables

Environment variables mapped to PyPreConfig fields:

Environment variables mapped to PyConfig fields:

PYTHONLEGACYWINDOWSFSENCODING and PYTHONLEGACYWINDOWSSTDIO are specific to Windows.

Default Python Configuration

PyPreConfig_InitPythonConfig():

• allocator = PYMEM_ALLOCATOR_NOT_SET
• coerce_c_locale_warn = -1
• coerce_c_locale = -1
• configure_locale = 1
• dev_mode = -1
• isolated = 0
• legacy_windows_fs_encoding = -1
• use_environment = 1
• utf8_mode = -1

PyConfig_InitPythonConfig():

• argv = []
• base_exec_prefix = NULL
• base_prefix = NULL
• buffered_stdio = 1
• bytes_warning = 0
• check_hash_pycs_mode = NULL
• configure_c_stdio = 1
• dev_mode = 0
• dump_refs = 0
• exec_prefix = NULL
• executable = NULL
• faulthandler = 0
• filesystem_encoding = NULL
• filesystem_errors = NULL
• hash_seed = 0
• home = NULL
• import_time = 0
• inspect = 0
• install_signal_handlers = 1
• interactive = 0
• isolated = 0
• malloc_stats = 0
• module_search_path_env = NULL
• module_search_paths = []
• optimization_level = 0
• parse_argv = 1
• parser_debug = 0
• pathconfig_warnings = 1
• prefix = NULL
• program_name = NULL
• pycache_prefix = NULL
• quiet = 0
• run_command = NULL
• run_filename = NULL
• run_module = NULL
• show_alloc_count = 0
• show_ref_count = 0
• site_import = 1
• skip_source_first_line = 0
• stdio_encoding = NULL
• stdio_errors = NULL
• tracemalloc = 0
• use_environment = 1
• use_hash_seed = 0
• user_site_directory = 1
• verbose = 0
• warnoptions = []
• write_bytecode = 1
• xoptions = []
• _init_main = 1
• _install_importlib = 1

Default Isolated Configuration

PyPreConfig_InitIsolatedConfig():

• allocator = PYMEM_ALLOCATOR_NOT_SET
• coerce_c_locale_warn = 0
• coerce_c_locale = 0
• configure_locale = 0
• dev_mode = 0
• isolated = 1
• legacy_windows_fs_encoding = 0
• use_environment = 0
• utf8_mode = 0

PyConfig_InitIsolatedConfig():

• argv = []
• base_exec_prefix = NULL
• base_prefix = NULL
• buffered_stdio = 1
• bytes_warning = 0
• check_hash_pycs_mode = NULL
• configure_c_stdio = 0
• dev_mode = 0
• dump_refs = 0
• exec_prefix = NULL
• executable = NULL
• faulthandler = 0
• filesystem_encoding = NULL
• filesystem_errors = NULL
• hash_seed = 0
• home = NULL
• import_time = 0
• inspect = 0
• install_signal_handlers = 0
• interactive = 0
• isolated = 1
• malloc_stats = 0
• module_search_path_env = NULL
• module_search_paths = []
• optimization_level = 0
• parse_argv = 0
• parser_debug = 0
• pathconfig_warnings = 0
• prefix = NULL
• program_name = NULL
• pycache_prefix = NULL
• quiet = 0
• run_command = NULL
• run_filename = NULL
• run_module = NULL
• show_alloc_count = 0
• show_ref_count = 0
• site_import = 1
• skip_source_first_line = 0
• stdio_encoding = NULL
• stdio_errors = NULL
• tracemalloc = 0
• use_environment = 0
• use_hash_seed = 0
• user_site_directory = 0
• verbose = 0
• warnoptions = []
• write_bytecode = 1
• xoptions = []
• _init_main = 1
• _install_importlib = 1

Python 3.7 API

Python 3.7 has 4 functions in its C API to initialize and finalize Python:

• Py_Initialize(), Py_InitializeEx(): initialize Python
• Py_Finalize(), Py_FinalizeEx(): finalize Python

Python 3.7 can be configured using Global Configuration Variables, Environment Variables, and the following functions:

• PyImport_AppendInittab()
• PyImport_ExtendInittab()
• PyMem_SetAllocator()
• PyMem_SetupDebugHooks()
• PyObject_SetArenaAllocator()
• Py_SetPath()
• Py_SetProgramName()
• Py_SetPythonHome()
• Py_SetStandardStreamEncoding()
• PySys_AddWarnOption()
• PySys_AddXOption()
• PySys_ResetWarnOptions()

There is also a high-level Py_Main() function and PyImport_FrozenModules variable which can be overridden.

See Initialization, Finalization, and Threads documentation.