Configuración de inicialización de Python¶

Nuevo en la versión 3.8.

Estructuras:

PyConfig
PyPreConfig
PyStatus
PyWideStringList

Funciones:

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.