This document is for an old version of Python that is no longer supported. You should upgrade, and read the Python documentation for the current stable release.

# Конфігурація ініціалізації Python

Нове в версії 3.8.

Structures:

- `PyConfig`

- `PyPreConfig`

- `PyStatus`

- `PyWideStringList`

Functions:

- `PyConfig_Clear()`

- `PyConfig_InitIsolatedConfig()`

- `PyConfig_InitPythonConfig()`

- `PyConfig_Read()`

- `PyConfig_SetArgv()`

- `PyConfig_SetBytesArgv()`

- `PyConfig_SetBytesString()`

- `PyConfig_SetString()`

- `PyConfig_SetWideStringList()`

- `PyPreConfig_InitIsolatedConfig()`

- `PyPreConfig_InitPythonConfig()`

- `PyStatus_Error()`

- `PyStatus_Exception()`

- `PyStatus_Exit()`

- `PyStatus_IsError()`

- `PyStatus_IsExit()`

- `PyStatus_NoMemory()`

- `PyStatus_Ok()`

- `PyWideStringList_Append()`

- `PyWideStringList_Insert()`

- `Py_ExitStatusException()`

- `Py_InitializeFromConfig()`

- `Py_PreInitialize()`

- `Py_PreInitializeFromArgs()`

- `Py_PreInitializeFromBytesArgs()`

- `Py_RunMain()`

- `Py_GetArgcArgv()`

The preconfiguration (`PyPreConfig` type) is stored in `_PyRuntime.preconfig` and the configuration (`PyConfig` type) is stored in `PyInterpreterState.config`.

Дивіться також Ініціалізація, фіналізація та потоки.

Дивись також

PEP 587 «Конфігурація ініціалізації Python».

## PyWideStringList

`PyWideStringList`

  Список рядків `wchar_t*`.

  Якщо length не дорівнює нулю, items не мають бути `NULL`, а всі рядки мають бути не `NULL`.

  Методи:

  PyStatus `PyWideStringList_Append`( PyWideStringList *list, const wchar_t *item)

    Додайте елемент до списку.

    Щоб викликати цю функцію, Python має бути попередньо ініціалізований.

  PyStatus `PyWideStringList_Insert`( PyWideStringList *list, Py_ssize_t index, const wchar_t *item)

    Вставте елемент у список за індексом.

    Якщо index більше або дорівнює довжині list, додайте item до list.

    index must be greater than or equal to 0.

    Щоб викликати цю функцію, Python має бути попередньо ініціалізований.

  Поля структури:

  Py_ssize_t `length`

    Довжина списку.

  wchar_t** `items`

    Список елементів.

## PyStatus

`PyStatus`

  Структура для збереження стану функції ініціалізації: успіх, помилка або вихід.

  Для помилки він може зберегти назву функції C, яка створила помилку.

  Поля структури:

  int `exitcode`

    Код виходу. Аргумент, переданий до `exit()`.

  const char *`err_msg`

    Повідомлення про помилку.

  const char *`func`

    Ім’я функції, яка створила помилку, може бути `NULL`.

  Функції для створення статусу:

  PyStatus `PyStatus_Ok`(void)

    Успіх.

  PyStatus `PyStatus_Error`(const char *err_msg)

    Помилка ініціалізації з повідомленням.

  PyStatus `PyStatus_NoMemory`(void)

    Помилка виділення пам’яті (брак пам’яті).

  PyStatus `PyStatus_Exit`(int exitcode)

    Вийдіть із Python із вказаним кодом виходу.

  Функції для обробки статусу:

  int `PyStatus_Exception`( PyStatus status)

    Статус помилка чи вихід? Якщо істина, виняток потрібно обробити; наприклад, викликом `Py_ExitStatusException()`.

  int `PyStatus_IsError`( PyStatus status)

    Чи є результат помилкою?

  int `PyStatus_IsExit`( PyStatus status)

    Результат – це вихід?

  void `Py_ExitStatusException`( PyStatus status)

    Викличте `exit(exitcode)`, якщо status є виходом. Роздрукуйте повідомлення про помилку та вийдіть із ненульовим кодом виходу, якщо статус є помилкою. Потрібно викликати, лише якщо `PyStatus_Exception(status)` не дорівнює нулю.

Примітка

Внутрішньо Python використовує макроси, які встановлюють `PyStatus.func`, тоді як функції для створення стану встановлюють `func` на `NULL`.

Приклад:

    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;
    }

## PyPreConfig

`PyPreConfig`

  Structure used to preinitialize Python:

  - Set the Python memory allocator

  - Configure the LC_CTYPE locale

  - Set the UTF-8 mode

  Функція ініціалізації попередньої конфігурації:

  void `PyPreConfig_InitPythonConfig`( PyPreConfig *preconfig)

    Ініціалізуйте попередню конфігурацію за допомогою Налаштування Python.

  void `PyPreConfig_InitIsolatedConfig`( PyPreConfig *preconfig)

    Ініціалізуйте попередню конфігурацію за допомогою Ізольованої конфігурації.

  Поля структури:

  int `allocator`

    Name of the memory allocator:

    - `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 memory allocator

    - `PYMEM_ALLOCATOR_PYMALLOC_DEBUG` (`6`): Python pymalloc memory allocator with debug hooks

    `PYMEM_ALLOCATOR_PYMALLOC` and `PYMEM_ALLOCATOR_PYMALLOC_DEBUG` are not supported if Python is configured using `--without-pymalloc`

    Перегляньте Керування пам’яттю.

  int `configure_locale`

    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.

  int `coerce_c_locale`

    If equals to 2, coerce the C locale; if equals to 1, read the LC_CTYPE locale to decide if it should be coerced.

  int `coerce_c_locale_warn`

    Якщо значення відмінне від нуля, видати попередження, якщо локаль C виведена примусово.

  int `dev_mode`

    See `PyConfig.dev_mode`.

  int `isolated`

    See `PyConfig.isolated`.

  int `legacy_windows_fs_encoding`(Windows only)

    If non-zero, disable UTF-8 Mode, set the Python filesystem encoding to `mbcs`, set the filesystem error handler to `replace`.

    Доступно лише для Windows. Макрос `#ifdef MS_WINDOWS` можна використовувати для спеціального коду Windows.

  int `parse_argv`

    Якщо значення відмінне від нуля, `Py_PreInitializeFromArgs()` і `Py_PreInitializeFromBytesArgs()` аналізують свій аргумент `argv` так само, як звичайний Python аналізує аргументи командного рядка: див. Аргументи командного рядка.

  int `use_environment`

    See `PyConfig.use_environment`.

  int `utf8_mode`

    If non-zero, enable the UTF-8 mode.

## Preinitialization with PyPreConfig

Функції для попередньої ініціалізації Python:

PyStatus `Py_PreInitialize`(const PyPreConfig *preconfig)

  Попередньо ініціалізуйте Python із попередньої конфігурації preconfig.

PyStatus `Py_PreInitializeFromBytesArgs`(const PyPreConfig *preconfig, int argc, char * const *argv)

  Preinitialize Python from preconfig preconfiguration and command line arguments (bytes strings).

PyStatus `Py_PreInitializeFromArgs`(const PyPreConfig *preconfig, int argc, wchar_t * const * argv)

  Preinitialize Python from preconfig preconfiguration and command line arguments (wide strings).

Виклик відповідає за обробку винятків (помилка або вихід) за допомогою `PyStatus_Exception()` і `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.

`PyMem_SetAllocator()` можна викликати після `Py_PreInitialize()` і перед `Py_InitializeFromConfig()`, щоб встановити спеціальний розподільник пам’яті. Його можна викликати перед `Py_PreInitialize()`, якщо `PyPreConfig.allocator` має значення `PYMEM_ALLOCATOR_NOT_SET`.

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.

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();

## PyConfig

`PyConfig`

  Структура, що містить більшість параметрів для налаштування Python.

  Методи будови:

  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)

    Скопіюйте широкий символьний рядок str у `*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_SetWideStringList`( PyConfig *config, PyWideStringList *list, Py_ssize_t length, wchar_t **items)

    Установіть для списку широких рядків list значення length і items.

    Preinitialize Python if needed.

  PyStatus `PyConfig_Read`( PyConfig *config)

    Прочитайте всю конфігурацію Python.

    Поля, які вже ініціалізовані, залишаються без змін.

    Preinitialize Python if needed.

  void `PyConfig_Clear`( PyConfig *config)

    Звільніть конфігураційну пам’ять.

  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).

  Виклик цих методів відповідає за обробку винятків (помилка або вихід) за допомогою `PyStatus_Exception()` і `Py_ExitStatusException()`.

  Поля структури:

  PyWideStringList `argv`

    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.

  wchar_t* `base_exec_prefix`

    `sys.base_exec_prefix`.

  wchar_t* `base_executable`

    `sys._base_executable`: `__PYVENV_LAUNCHER__` environment variable value, or copy of `PyConfig.executable`.

  wchar_t* `base_prefix`

    `sys.base_prefix`.

  wchar_t* `platlibdir`

    `sys.platlibdir`: platform library directory name, set at configure time by `--with-platlibdir`, overrideable by the `PYTHONPLATLIBDIR` environment variable.

    Нове в версії 3.9.

  int `buffered_stdio`

    If equals to 0, enable unbuffered mode, making the stdout and stderr streams unbuffered.

    stdin завжди відкривається в режимі буферизації.

  int `bytes_warning`

    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.

  wchar_t* `check_hash_pycs_mode`

    Control the validation behavior of hash-based `.pyc` files (see PEP 552): `--check-hash-based-pycs` command line option value.

    Valid values: `always`, `never` and `default`.

    The default value is: `default`.

  int `configure_c_stdio`

    If non-zero, configure C standard streams (`stdio`, `stdout`, `stdout`). For example, set their mode to `O_BINARY` on Windows.

  int `dev_mode`

    Якщо не нуль, увімкніть Режим розробки Python.

  int `dump_refs`

    Якщо значення відмінне від нуля, скинути всі об’єкти, які ще живі при виході.

    `Py_TRACE_REFS` macro must be defined in build.

  wchar_t* `exec_prefix`

    `sys.exec_prefix`.

  wchar_t* `executable`

    `sys.executable`.

  int `faulthandler`

    Якщо не нуль, викликати `faulthandler.enable()` під час запуску.

  wchar_t* `filesystem_encoding`

    Filesystem encoding, `sys.getfilesystemencoding()`.

  wchar_t* `filesystem_errors`

    Filesystem encoding errors, `sys.getfilesystemencodeerrors()`.

  unsigned long `hash_seed`
  int `use_hash_seed`

    Рандомізоване початкове значення хеш-функції.

    If `use_hash_seed` is zero, a seed is chosen randomly at Pythonstartup, and `hash_seed` is ignored.

  wchar_t* `home`

    Python home directory.

    Initialized from `PYTHONHOME` environment variable value by default.

  int `import_time`

    Якщо не нуль, час імпорту профілю.

  int `inspect`

    Увійти в інтерактивний режим після виконання сценарію або команди.

  int `install_signal_handlers`

    Install signal handlers?

  int `interactive`

    Interactive mode.

  int `isolated`

    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 не імпортує `readline` і не вмикає стандартну конфігурацію readline в інтерактивних підказках.

    - Set `use_environment` and `user_site_directory` to 0.

  int `legacy_windows_stdio`

    If non-zero, use `io.FileIO` instead of `io.WindowsConsoleIO` for `sys.stdin`, `sys.stdout` and `sys.stderr`.

    Доступно лише для Windows. Макрос `#ifdef MS_WINDOWS` можна використовувати для спеціального коду Windows.

  int `malloc_stats`

    Якщо значення відмінне від нуля, вивести статистику на Python pymalloc memory allocator при виході.

    The option is ignored if Python is built using `--without-pymalloc`.

  wchar_t* `pythonpath_env`

    Module search paths as a string separated by `DELIM` (`os.path.pathsep`).

    Initialized from `PYTHONPATH` environment variable value by default.

  PyWideStringList `module_search_paths`
  int `module_search_paths_set`

    `sys.path`. If `module_search_paths_set` is equal to 0, the `module_search_paths` is overridden by the function calculating the Path Configuration.

  int `optimization_level`

    Рівень оптимізації компіляції:

    - 0: Peephole optimizer (and `__debug__` is set to `True`)

    - 1: Remove assertions, set `__debug__` to `False`

    - 2: Strip docstrings

  int `parse_argv`

    If non-zero, parse `argv` the same way the regular Python command line arguments, and strip Python arguments from `argv`: see Command Line Arguments.

  int `parser_debug`

    If non-zero, turn on parser debugging output (for expert only, depending on compilation options).

  int `pathconfig_warnings`

    If equal to 0, suppress warnings when calculating the Path Configuration (Unix only, Windows does not log any warning). Otherwise, warnings are written into `stderr`.

  wchar_t* `prefix`

    `sys.prefix`.

  wchar_t* `program_name`

    Program name. Used to initialize `executable`, and in early error messages.

  wchar_t* `pycache_prefix`

    `sys.pycache_prefix`: `.pyc` cache prefix.

    Якщо `NULL`, `sys.pycache_prefix` має значення `None`.

  int `quiet`

    Quiet mode. For example, don’t display the copyright and version messages in interactive mode.

  wchar_t* `run_command`

    `python3 -c COMMAND` argument. Used by `Py_RunMain()`.

  wchar_t* `run_filename`

    `python3 FILENAME` argument. Used by `Py_RunMain()`.

  wchar_t* `run_module`

    `python3 -m MODULE` argument. Used by `Py_RunMain()`.

  int `show_ref_count`

    Show total reference count at exit?

    Set to 1 by `-X showrefcount` command line option.

    Need a debug build of Python (`Py_REF_DEBUG` macro must be defined).

  int `site_import`

    Імпортувати модуль `site` під час запуску?

  int `skip_source_first_line`

    Skip the first line of the source?

  wchar_t* `stdio_encoding`
  wchar_t* `stdio_errors`

    Encoding and encoding errors of `sys.stdin`, `sys.stdout` and `sys.stderr`.

  int `tracemalloc`

    Якщо не нуль, викликати `tracemalloc.start()` під час запуску.

  int `use_environment`

    If greater than 0, use environment variables.

  int `user_site_directory`

    If non-zero, add user site directory to `sys.path`.

  int `verbose`

    If non-zero, enable verbose mode.

  PyWideStringList `warnoptions`

    `sys.warnoptions`: options of the `warnings` module to build warnings filters: lowest to highest priority.

    Модуль `warnings` додає `sys.warnoptions` у зворотному порядку: останній елемент `PyConfig.warnoptions` стає першим елементом `warnings.filters`, який є перевіряється першим (найвищий пріоритет).

  int `write_bytecode`

    If non-zero, write `.pyc` files.

    `sys.dont_write_bytecode` ініціалізується інвертованим значенням `write_bytecode`.

  PyWideStringList `xoptions`

    `sys._xoptions`.

  int `_use_peg_parser`

    Enable PEG parser? Default: 1.

    Set to 0 by `-X oldparser` and `PYTHONOLDPARSER`.

    See also PEP 617.

    Deprecated since version 3.9, will be removed in version 3.10.

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` option.

Змінено в версії 3.9: Поле `show_alloc_count` видалено.

## Ініціалізація за допомогою PyConfig

Function to initialize Python:

PyStatus `Py_InitializeFromConfig`(const PyConfig *config)

  Initialize Python from config configuration.

Виклик відповідає за обробку винятків (помилка або вихід) за допомогою `PyStatus_Exception()` і `Py_ExitStatusException()`.

Якщо `PyImport_FrozenModules()`, `PyImport_AppendInittab()` або `PyImport_ExtendInittab()` використовуються, їх потрібно встановити або викликати після попередньої ініціалізації Python та перед ініціалізацією Python. Якщо Python ініціалізовано кілька разів, перед кожною ініціалізацією Python потрібно викликати `PyImport_AppendInittab()` або `PyImport_ExtendInittab()`.

Приклад налаштування імені програми:

    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);
    }

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;
    }

## Ізольована конфігурація

Функції `PyPreConfig_InitIsolatedConfig()` і `PyConfig_InitIsolatedConfig()` створюють конфігурацію для ізоляції Python від системи. Наприклад, щоб вбудувати Python у програму.

Ця конфігурація ігнорує глобальні змінні конфігурації, змінні середовища, аргументи командного рядка (`PyConfig.argv` не аналізується) і каталог сайту користувача. Стандартні потоки C (наприклад: `stdout`) і локаль LC_CTYPE залишаються без змін. Обробники сигналів не встановлені.

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

Функції `PyPreConfig_InitPythonConfig()` і `PyConfig_InitPythonConfig()` створюють конфігурацію для створення налаштованого Python, який веде себе як звичайний Python.

Для налаштування Python використовуються змінні середовища та аргументи командного рядка, тоді як глобальні змінні конфігурації ігноруються.

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.

Приклад налаштованого Python, який завжди працює в ізольованому режимі:

    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);
    }

## Path Configuration

`PyConfig` містить кілька полів для конфігурації шляху:

- Вхідні дані конфігурації шляху:

  - `PyConfig.home`

  - `PyConfig.platlibdir`

  - `PyConfig.pathconfig_warnings`

  - `PyConfig.program_name`

  - `PyConfig.pythonpath_env`

  - поточний робочий каталог: щоб отримати абсолютні шляхи

  - Змінна середовища `PATH`, щоб отримати повний шлях до програми (з `PyConfig.program_name`)

  - Змінна середовища `__PYVENV_LAUNCHER__`

  - (Лише для Windows) Шляхи програм у реєстрі в розділі «SoftwarePythonPythonCoreX.YPythonPath» HKEY_CURRENT_USER і HKEY_LOCAL_MACHINE (де X.Y — версія Python).

- Поля виведення конфігурації шляху:

  - `PyConfig.base_exec_prefix`

  - `PyConfig.base_executable`

  - `PyConfig.base_prefix`

  - `PyConfig.exec_prefix`

  - `PyConfig.executable`

  - `PyConfig.module_search_paths_set`, `PyConfig.module_search_paths`

  - `PyConfig.prefix`

If at least one «output field» is not set, Python calculates 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 calculating 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 calculating the path configuration (Unix only, Windows does not log any warning).

Якщо поля `base_prefix` або `base_exec_prefix` не встановлені, вони успадковують свої значення від `prefix` і `exec_prefix` відповідно.

`Py_RunMain()` і `Py_Main()` змінюють `sys.path`:

- Якщо `run_filename` встановлено і це каталог, який містить сценарій `__main__.py`, додайте `run_filename` до `sys.path`.

- Якщо `isolated` дорівнює нулю:

  - Якщо встановлено `run_module`, додайте поточний каталог до `sys.path`. Нічого не робити, якщо поточний каталог неможливо прочитати.

  - Якщо встановлено `run_filename`, додайте каталог імені файлу перед `sys.path`.

  - В іншому випадку додайте порожній рядок до `sys.path`.

Якщо `site_import` не дорівнює нулю, `sys.path` можна змінити за допомогою модуля `site`. Якщо `user_site_directory` не дорівнює нулю, а каталог пакетів сайту користувача існує, модуль `site` додає каталог пакетів сайту користувача до `sys.path`.

У конфігурації шляху використовуються такі файли конфігурації:

- `pyvenv.cfg`

- `python._pth` (Windows only)

- `pybuilddir.txt` (лише Unix)

The `__PYVENV_LAUNCHER__` environment variable is used to set `PyConfig.base_executable`

## Py_RunMain()

int `Py_RunMain`(void)

  Execute 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.

  By default and when if `-i` option is used, run the REPL.

  Finally, finalizes Python and returns an exit status that can be passed to the `exit()` function.

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

## Py_GetArgcArgv()

void `Py_GetArgcArgv`(int *argc, wchar_t ***argv)

  Отримайте оригінальні аргументи командного рядка до того, як Python їх змінив.

## Приватний тимчасовий API багатофазної ініціалізації

Цей розділ є приватним тимчасовим API, який представляє багатофазову ініціалізацію, основну функцію PEP 432:

- Фаза ініціалізації «Core», «мінімум Python»:

  - Вбудовані типи;

  - Вбудовані винятки;

  - Вбудовані та заморожені модулі;

  - Модуль `sys` ініціалізовано лише частково (наприклад: `sys.path` ще не існує).

- «Основна» фаза ініціалізації, Python повністю ініціалізовано:

  - Встановити та налаштувати `importlib`;

  - Застосуйте Конфігурацію шляху;

  - встановити обробники сигналів;

  - Завершити ініціалізацію модуля `sys` (наприклад, створити `sys.stdout` і `sys.path`);

  - Увімкнути додаткові функції, такі як `faulthandler` і `tracemalloc`;

  - Імпортуйте модуль `site`;

  - тощо

Приватний тимчасовий API:

- `PyConfig._init_main`: if set to 0, `Py_InitializeFromConfig()` stops at the «Core» initialization phase.

- `PyConfig._isolated_interpreter`: if non-zero, disallow threads, subprocesses and fork.

PyStatus `_Py_InitializeMain`(void)

  Перейдіть до фази ініціалізації «Main», завершіть ініціалізацію Python.

Жоден модуль не імпортується під час фази «Core», а модуль `importlib` не налаштовано: Конфігурація шляху застосовується лише під час фази «Main». Це може дозволити налаштувати Python у Python, щоб перевизначити або налаштувати Конфігурацію шляху, можливо, встановити спеціальний імпортер `sys.meta_path` або хук імпорту тощо.

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

Фаза «Core» не визначена належним чином: що має бути, а що не має бути доступним на цій фазі, ще не визначено. API позначено як приватний і тимчасовий: API можна змінити або навіть видалити в будь-який час, доки не буде розроблено відповідний публічний API.

Приклад виконання коду Python між фазами ініціалізації «Core» і «Main»:

    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);
        }
    }