Configuración de inicialización de Python

Nuevo en la versión 3.8.

Estructuras:

• PyConfig

• PyPreConfig

• PyStatus

• PyWideStringList

Funciones:

• 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_Error()

• PyStatus_Error()

• PyStatus_IsError()

• PyStatus_IsExit()

• PyStatus_NoMemory()

• PyStatus_Ok()

• PyWideStringList_Append()

• PyWideStringList_Insert()

• Py_ExitStatusException()

• Py_InitializeFromConfig()

• Py_PreInitialize()

• Py_PreInitializeFromArgs()

• Py_PreInitializeFromBytesArgs()

• Py_RunMain()

La preconfiguración (tipo PyPreConfig) se almacena en _PyRuntime.preconfig y la configuración (tipo PyConfig) se almacena en PyInterpreterState.config.

Consulte también Inicialización, finalización y subprocesos.

Ver también

PEP 587 «Configuración de inicialización de Python».

PyWideStringList

PyWideStringList

Lista de cadenas de caracteres wchar_t*.

Si length no es cero, items no deben ser NULL y todas las cadenas de caracteres deben ser no NULL.

Métodos:

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

Agregar item a list.

Python debe estar preinicializado para llamar a esta función.

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

Inserta item en list en index.

Si index es mayor o igual que el largo de list, agrega item a list.

index debe ser mayor o igual que 0.

Python debe estar preinicializado para llamar a esta función.

Campos de estructura:

Py_ssize_t length

Longitud de la lista.

wchar_t** items

Elementos de la lista.

PyStatus

PyStatus

Estructura para almacenar el estado de una función de inicialización: éxito, error o salida.

Para un error, puede almacenar el nombre de la función C que creó el error.

Campos de estructura:

int exitcode

Código de salida El argumento pasó a exit().

const char *err_msg

Mensaje de error.

const char *func

El nombre de la función que creó un error puede ser NULL.

Funciones para crear un estado:

PyStatus PyStatus_Ok(void)

Éxito.

PyStatus PyStatus_Error(const char *err_msg)

Error de inicialización con un mensaje.

PyStatus PyStatus_NoMemory(void)

Error de asignación de memoria (sin memoria).

PyStatus PyStatus_Exit(int exitcode)

Sale de Python con el código de salida especificado.

Funciones para manejar un estado:

int PyStatus_Exception(PyStatus status)

¿Es el estado un error o una salida? Si es verdadero, la excepción debe ser manejada; por ejemplo llamando a Py_ExitStatusException().

int PyStatus_IsError(PyStatus status)

¿Es el resultado un error?

int PyStatus_IsExit(PyStatus status)

¿El resultado es una salida?

void Py_ExitStatusException(PyStatus status)

Llama a exit(exitcode) si status es una salida. Imprime el mensaje de error y sale con un código de salida distinto de cero si status es un error. Solo se debe llamar si PyStatus_Exception(status) no es cero.

Nota

Internamente, Python usa macros que establecen PyStatus.func, mientras que las funciones para crear un estado establecen func en NULL.

Ejemplo:

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

Estructura utilizada para preinicializar Python:

• Establece el asignador de memoria de Python

• Configure el entorno local LC_CTYPE

• Establece el modo UTF-8

Función para inicializar una preconfiguración:

void PyPreConfig_InitPythonConfig(PyPreConfig *preconfig)

Inicializa la preconfiguración con Configuración de Python.

void PyPreConfig_InitIsolatedConfig(PyPreConfig *preconfig)

Inicializa la preconfiguración con Configuración aislada.

Campos de estructura:

int allocator

Nombre del asignador de memoria:

• PYMEM_ALLOCATOR_NOT_SET (0): no cambie los asignadores de memoria (use los valores predeterminados)

• PYMEM_ALLOCATOR_DEFAULT (1): asignadores de memoria predeterminados

• PYMEM_ALLOCATOR_DEBUG (2): asignadores de memoria predeterminados con ganchos de depuración

• PYMEM_ALLOCATOR_MALLOC (3): fuerza el uso de malloc()

• PYMEM_ALLOCATOR_MALLOC_DEBUG (4): fuerza el uso de malloc() con ganchos de depuración

• PYMEM_ALLOCATOR_PYMALLOC (5): Python pymalloc memory allocator

• PYMEM_ALLOCATOR_PYMALLOC_DEBUG (6): Python pymalloc memory allocator con ganchos de depuración

PYMEM_ALLOCATOR_PYMALLOC y PYMEM_ALLOCATOR_PYMALLOC_DEBUG no son compatibles si Python está configurado con --with-pymalloc

Ver Administración de memorias.

int configure_locale

¿Establece la configuración regional LC_CTYPE en la configuración regional preferida por el usuario? Si es igual a 0, establece coerce_c_locale y coerce_c_locale_warn en 0.

int coerce_c_locale

Si es igual a 2, coaccione la configuración regional C; si es igual a 1, lea la configuración regional LC_CTYPE para decidir si debe ser forzado.

int coerce_c_locale_warn

Si no es cero, emita una advertencia si la configuración regional C está coaccionada.

int dev_mode

Ver PyConfig.dev_mode.

int isolated

Ver PyConfig.isolated.

int legacy_windows_fs_encoding(Windows only)

Si no es cero, desactive el modo UTF-8, configure la codificación del sistema de archivos Python en mbcs, configure el controlador de errores del sistema de archivos en replace.

Solo disponible en Windows. La macro #ifdef MS_WINDOWS se puede usar para el código específico de Windows.

int parse_argv

Si no es cero, Py_PreInitializeFromArgs() y Py_PreInitializeFromBytesArgs() analizan su argumento argv de la misma manera que Python analiza los argumentos de la línea de comandos: ver Argumentos de línea de comandos.

int use_environment

Ver PyConfig.use_environment.

int utf8_mode

Si no es cero, habilita el modo UTF-8.

Preinicialización con PyPreConfig

Funciones para preinicializar Python:

PyStatus Py_PreInitialize(const PyPreConfig *preconfig)

Preinicializa Python desde la preconfiguración preconfig.

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

Preinicializa Python desde la preconfiguración preconfig y argumentos de línea de comando (cadenas de caracteres de bytes).

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

Preinicializa Python desde la preconfiguración preconfig y argumentos de línea de comando (cadenas de caracteres anchas).

La persona que llama es responsable de manejar las excepciones (error o salida) usando PyStatus_Exception() y Py_ExitStatusException().

Para Configuración de Python (PyPreConfig_InitPythonConfig()), si Python se inicializa con argumentos de línea de comando, los argumentos de línea de comando también deben pasarse para preinicializar Python, ya que tienen un efecto en la preconfiguración como codificaciones. Por ejemplo, la opción de línea de comando -X utf8 habilita el modo UTF-8.

PyMem_SetAllocator() se puede llamar después de Py_PreInitialize() y antes Py_InitializeFromConfig() para instalar un asignador de memoria personalizado. Se puede llamar antes Py_PreInitialize() si PyPreConfig.allocator está configurado en PYMEM_ALLOCATOR_NOT_SET.

Las funciones de asignación de memoria de Python como PyMem_RawMalloc() no deben usarse antes de la preinicialización de Python, mientras que llamar directamente a malloc() y free() siempre es seguro. Py_DecodeLocale() no debe llamarse antes de la preinicialización.

Ejemplo usando la preinicialización para habilitar el modo UTF-8:

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

Estructura que contiene la mayoría de los parámetros para configurar Python.

Métodos de estructura:

void PyConfig_InitPythonConfig(PyConfig *config)

Inicializa la configuración con Configuración de Python.

void PyConfig_InitIsolatedConfig(PyConfig *config)

Inicializa la configuración con Configuración aislada.

PyStatus PyConfig_SetString(PyConfig *config, wchar_t * const *config_str, const wchar_t *str)

Copia la cadena de caracteres anchos str en *config_str.

Preinicializa Python si es necesario.

PyStatus PyConfig_SetBytesString(PyConfig *config, wchar_t * const *config_str, const char *str)

Decodifica str usando Py_DecodeLocale() y configure el resultado en *config_str.

Preinicializa Python si es necesario.

PyStatus PyConfig_SetArgv(PyConfig *config, int argc, wchar_t * const *argv)

Establezca argumentos de línea de comando a partir de cadenas de caracteres anchas.

Preinicializa Python si es necesario.

PyStatus PyConfig_SetBytesArgv(PyConfig *config, int argc, char * const *argv)

Establezca argumentos de línea de comando: decodifique bytes usando Py_DecodeLocale().

Preinicializa Python si es necesario.

PyStatus PyConfig_SetWideStringList(PyConfig *config, PyWideStringList *list, Py_ssize_t length, wchar_t **items)

Establece la lista de cadenas de caracteres anchas list a length y items.

Preinicializa Python si es necesario.

PyStatus PyConfig_Read(PyConfig *config)

Lee toda la configuración de Python.

Los campos que ya están inicializados no se modifican.

Preinicializa Python si es necesario.

void PyConfig_Clear(PyConfig *config)

Libera memoria de configuración.

La mayoría de los métodos PyConfig preinicializan Python si es necesario. En ese caso, la configuración de preinicialización de Python se basa en PyConfig. Si los campos de configuración que son comunes con PyPreConfig están ajustados, deben configurarse antes de llamar al método PyConfig:

• dev_mode

• isolated

• parse_argv

• use_environment

Además, si se utiliza PyConfig_SetArgv() o PyConfig_SetBytesArgv(), este método debe llamarse primero, antes que otros métodos, ya que la configuración de preinicialización depende de los argumentos de la línea de comandos (si parse_argv no es cero).

Quien llama de estos métodos es responsable de manejar las excepciones (error o salida) usando PyStatus_Exception() y Py_ExitStatusException().

Campos de estructura:

PyWideStringList argv

Argumentos de línea de comando, sys.argv. Consulta parse_argv para analizar argv de la misma manera que Python normal analiza los argumentos de la línea de comandos de Python. Si argv está vacío, se agrega una cadena de caracteres vacía para garantizar que sys.argv siempre exista y nunca esté vacío.

wchar_t* base_exec_prefix

sys.base_exec_prefix.

wchar_t* base_executable

sys._base_executable: __PYVENV_LAUNCHER__ valor de la variable de entorno, o copia de PyConfig.executable.

wchar_t* base_prefix

sys.base_prefix.

int buffered_stdio

Si es igual a 0, habilite el modo sin búfer, haciendo que las secuencias stdout y stderr no tengan búfer.

stdin siempre se abre en modo de búfer.

int bytes_warning

Si es igual a 1, emita una advertencia cuando compare bytes o bytearray con str, o compare bytes con int. Si es igual o mayor a 2, lanza una excepción BytesWarning.

wchar_t* check_hash_pycs_mode

Controla el comportamiento de validación de los archivos .pyc basados en hash (consulte PEP 552): con el valor de la opción de línea de comando --check-hash-based-pycs.

Valores válidos: always, never y default.

El valor predeterminado es: default.

int configure_c_stdio

Si no es cero, configure las secuencias estándar C (stdio, stdout, stdout). Por ejemplo, configure su modo en O_BINARY en Windows.

int dev_mode

Modo de desarrollo: ver -X dev.

int dump_refs

Si no es cero, volcar todos los objetos que aún están vivos en la salida.

Requerir una compilación de depuración de Python (la macro Py_REF_DEBUG debe estar definida).

wchar_t* exec_prefix

sys.exec_prefix.

wchar_t* executable

sys.executable.

int faulthandler

Si no es cero, llama a faulthandler.enable() al inicio.

wchar_t* filesystem_encoding

Codificación del sistema de archivos, sys.getfilesystemencoding().

wchar_t* filesystem_errors

Errores de codificación del sistema de archivos, sys.getfilesystemencodeerrors().

unsigned long hash_seed

int use_hash_seed

Funciones de semillas aleatorias hash.

Si use_hash_seed es cero, se elige una semilla aleatoriamente en Pythonstartup, y hash_seed se ignora.

wchar_t* home

Directorio de inicio de Python.

Inicializado desde valor de variable de entorno PYTHONHOME por defecto.

int import_time

Si no es cero, el tiempo de importación del perfil.

int inspect

Ingresa al modo interactivo después de ejecutar un script o un comando.

int install_signal_handlers

¿Instala manejadores de señal?

int interactive

Modo interactivo.

int isolated

Si es mayor que 0, habilite el modo aislado:

• sys.path no contiene ni el directorio del script (calculado a partir de argv[0] o el directorio actual) ni el directorio de paquetes del sitio del usuario.

• Python REPL no importa readline ni habilita la configuración predeterminada de readline en mensajes interactivos.

• Establece use_environment y user_site_directory en 0.

int legacy_windows_stdio

Si no es cero, usa io.FileIO en lugar de io.WindowsConsoleIO para sys.stdin, sys.stdout y sys.stderr.

Solo disponible en Windows. La macro #ifdef MS_WINDOWS se puede usar para el código específico de Windows.

int malloc_stats

Si no es cero, volcar las estadísticas en Asignador de memoria Python pymalloc en la salida.

La opción se ignora si Python se construye usando --without-pymalloc.

wchar_t* pythonpath_env

Módulo de rutas de búsqueda como una cadena separada por DELIM (os.path.pathsep).

Inicializado desde valor de variable de entorno PYTHONPATH por defecto.

PyWideStringList module_search_paths

int module_search_paths_set

sys.path. Si module_search_paths_set es igual a 0, el module_search_paths es anulado por la función que calcula Configuración de ruta .

int optimization_level

Nivel de optimización de compilación:

• 0: Optimizador de mirilla (y __debug__ está configurado como True)

• 1: Elimina las aserciones, establece __debug__ en False

• 2: Strip docstrings

int parse_argv

Si no es cero, analiza argv de la misma manera que los argumentos regulares de la línea de comandos de Python, y elimine los argumentos de Python de argv: vea Argumentos de línea de comando.

int parser_debug

Si no es cero, activa la salida de depuración del analizador (solo para expertos, dependiendo de las opciones de compilación).

int pathconfig_warnings

Si es igual a 0, suprime las advertencias al calcular Configuración de ruta (solo Unix, Windows no registra ninguna advertencia). De lo contrario, las advertencias se escriben en stderr.

wchar_t* prefix

sys.prefix.

wchar_t* program_name

Nombre del programa Se usa para inicializar executable, y en los primeros mensajes de error.

wchar_t* pycache_prefix

sys.pycache_prefix: prefijo de caché .pyc.

Si NULL, sys.pycache_prefix es establecido a None.

int quiet

Modo silencioso. Por ejemplo, no muestra los mensajes de copyright y versión en modo interactivo.

wchar_t* run_command

Argumento python3 -c COMMAND. Utilizado por Py_RunMain().

wchar_t* run_filename

Argumento python3 FILENAME. Utilizado por Py_RunMain().

wchar_t* run_module

Argumento python3 -m MODULE. Utilizado por Py_RunMain().

int show_alloc_count

¿Mostrar recuentos de asignación en la salida?

Establecido en 1 por la opción de línea de comandos -X showalloccount.

Necesita una compilación especial de Python con la macro COUNT_ALLOCS definida.

int show_ref_count

¿Mostrar el recuento de referencia total en la salida?

Establecido en 1 por la opción de línea de comandos -X showrefcount.

Necesita una compilación de depuración de Python (se debe definir la macro Py_REF_DEBUG).

int site_import

¿Importar el módulo site al inicio?

int skip_source_first_line

¿Saltar la primera línea de la fuente?

wchar_t* stdio_encoding

wchar_t* stdio_errors

Codificación y codificación de errores de sys.stdin, sys.stdout y sys.stderr.

int tracemalloc

Si no es cero, llama a tracemalloc.start() al inicio.

int use_environment

Si es mayor que 0, use variables de entorno.

int user_site_directory

Si no es cero, agrega el directorio del sitio del usuario a sys.path.

int verbose

Si no es cero, habilita el modo detallado.

PyWideStringList warnoptions

sys.warnoptions: opciones del módulo warnings para crear filtros de advertencia: de menor a mayor prioridad.

El módulo warnings agrega sys.warnoptions en el orden inverso: el último elemento PyConfig.warnoptions se convierte en el primer elemento de warnings.filters que es verificado primero (máxima prioridad).

int write_bytecode

Si no es cero, escribe los archivos .pyc.

sys.dont_write_bytecode se inicializa al valor invertido de write_bytecode.

PyWideStringList xoptions

sys._xoptions.

Si parse_argv no es cero, los argumentos argv se analizan de la misma manera que Python analiza los argumentos de línea de comando, y los argumentos de Python se eliminan de argv: ver Argumentos de línea de comando.

Las opciones xoptions se analizan para establecer otras opciones: ver la opción -X.

Inicialización con PyConfig

Función para inicializar Python:

PyStatus Py_InitializeFromConfig(const PyConfig *config)

Inicializa Python desde la configuración config.

La persona que llama es responsable de manejar las excepciones (error o salida) usando PyStatus_Exception() y Py_ExitStatusException().

Si se usan PyImport_FrozenModules, PyImport_AppendInittab() o PyImport_ExtendInittab(), deben configurarse o llamarse después de la preinicialización de Python y antes de la inicialización de Python.

Ejemplo de configuración del nombre del programa:

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

Ejemplo más completo que modifica la configuración predeterminada, lee la configuración y luego anula algunos parámetros

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

Configuración aislada

PyPreConfig_InitIsolatedConfig() y las funciones PyConfig_InitIsolatedConfig() crean una configuración para aislar Python del sistema. Por ejemplo, para incrustar Python en una aplicación.

Esta configuración ignora las variables de configuración global, las variables de entorno, los argumentos de la línea de comandos (PyConfig.argv no se analiza) y el directorio del sitio del usuario. Las transmisiones estándar C (por ejemplo, stdout) y el entorno local LC_CTYPE no se modifican. Los manejadores de señal no están instalados.

Los archivos de configuración todavía se usan con esta configuración. Configure Configuración de ruta («campos de salida») para ignorar estos archivos de configuración y evitar la función que calcula la configuración de ruta predeterminada.

Configuración de Python

PyPreConfig_InitPythonConfig() y las funciones PyConfig_InitPythonConfig() crean una configuración para construir un Python personalizado que se comporta como el Python normal.

Las variables de entorno y los argumentos de la línea de comandos se utilizan para configurar Python, mientras que las variables de configuración global se ignoran.

Esta función permite la coerción de configuración regional C (PEP 538) y el modo UTF-8 (PEP 540) dependiendo de la configuración regional LC_CTYPE, PYTHONUTF8 y variables de entorno PYTHONCOERCECLOCALE.

Ejemplo de Python personalizado que siempre se ejecuta en modo aislado:

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

Configuración de ruta

PyConfig contiene múltiples campos para la configuración de ruta:

• Entradas de configuración de ruta:

  • PyConfig.home

  • PyConfig.pathconfig_warnings

  • PyConfig.program_name

  • PyConfig.pythonpath_env

  • directorio de trabajo actual: para obtener rutas absolutas

  • Variable de entorno PATH para obtener la ruta completa del programa (de PyConfig.program_name)

  • Variable de entorno __PYVENV_LAUNCHER__

  • (Solo Windows) Rutas de aplicación en el registro en «SoftwarePythonPythonCoreX.YPythonPath» de HKEY_CURRENT_USER y HKEY_LOCAL_MACHINE (donde X.Y es la versión de Python).

• Campos de salida de configuración de ruta:

  • 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

Si no se establece al menos un «campo de salida», Python calcula la configuración de la ruta para completar los campos no definidos. Si module_search_paths_set es igual a 0, module_search_paths se reemplaza y module_search_paths_set se establece en 1.

Es posible ignorar por completo la función que calcula la configuración de ruta predeterminada al establecer explícitamente todos los campos de salida de configuración de ruta enumerados anteriormente. Una cadena de caracteres se considera como un conjunto, incluso si no está vacía. module_search_paths se considera como establecido si module_search_paths_set se establece en 1. En este caso, los campos de entrada de configuración de ruta también se ignoran.

Establezca pathconfig_warnings en 0 para suprimir las advertencias al calcular la configuración de la ruta (solo Unix, Windows no registra ninguna advertencia).

Si base_prefix o los campos base_exec_prefix no están establecidos, heredan su valor de prefix y exec_prefix respectivamente.

Py_RunMain() y Py_Main() modifican sys.path:

• Si run_filename está configurado y es un directorio que contiene un script __main__.py, anteponga run_filename a sys.path.

• Si isolated es cero:

  • Si run_module está configurado, anteponga el directorio actual a sys.path. No haga nada si el directorio actual no se puede leer.

  • Si run_filename está configurado, anteponga el directorio del nombre del archivo a sys.path.

  • De lo contrario, anteponga una cadena de caracteres vacía a sys.path.

Si site_import no es cero, sys.path puede ser modificado por el módulo site. Si user_site_directory no es cero y el directorio del paquete del sitio del usuario existe, el módulo site agrega el directorio del paquete del sitio del usuario a sys.path.

La configuración de ruta utiliza los siguientes archivos de configuración:

• pyvenv.cfg

• python._pth (sólo Windows)

• pybuilddir.txt (sólo Unix)

La variable de entorno __PYVENV_LAUNCHER__ se usa para establecer PyConfig.base_executable

Py_RunMain()

int Py_RunMain(void)

Ejecuta el comando (PyConfig.run_command), el script (PyConfig.run_filename) o el módulo (PyConfig.run_module) especificado en la línea de comando o en la configuración.

Por defecto y cuando se usa la opción -i, ejecuta el REPL.

Finalmente, finaliza Python y retorna un estado de salida que se puede pasar a la función exit().

Consulte Configuración de Python para ver un ejemplo de Python personalizado que siempre se ejecuta en modo aislado usando Py_RunMain().

API Provisional Privada de Inicialización Multifásica

Esta sección es una API provisional privada que presenta la inicialización de múltiples fases, la característica principal de PEP 432:

• Fase de inicialización «Core», «Python mínimo»:

  • Tipos incorporados;

  • Excepciones incorporadas;

  • Módulos incorporados y congelados;

  • El módulo sys solo se inicializa parcialmente (por ejemplo sys.path aún no existe).

• Fase de inicialización «principal», Python está completamente inicializado:

  • Instala y configura importlib;

  • Aplique la Configuración de ruta;

  • Instala manejadores de señal;

  • Finaliza la inicialización del módulo sys (por ejemplo: crea sys.stdout y sys.path);

  • Habilita características opcionales como faulthandler y tracemalloc;

  • Importe el módulo site;

  • etc.

API provisional privada:

• PyConfig._init_main: si se establece en 0, Py_InitializeFromConfig() se detiene en la fase de inicialización «Core».

PyStatus _Py_InitializeMain(void)

Vaya a la fase de inicialización «Principal», finalice la inicialización de Python.

No se importa ningún módulo durante la fase «Core» y el módulo importlib no está configurado: la Configuración de ruta solo se aplica durante la fase «Principal». Puede permitir personalizar Python en Python para anular o ajustar Configuración de ruta, tal vez instale un importador personalizado sys.meta_path o un enlace de importación, etc.

Puede ser posible calcular Configuración de ruta en Python, después de la fase Core y antes de la fase Main, que es una de las motivaciones PEP 432.

La fase «Núcleo» no está definida correctamente: lo que debería estar y lo que no debería estar disponible en esta fase aún no se ha especificado. La API está marcada como privada y provisional: la API se puede modificar o incluso eliminar en cualquier momento hasta que se diseñe una API pública adecuada.

Ejemplo de ejecución de código Python entre las fases de inicialización «Core» y «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);
    }
}