Inicialización, finalización e hilos
************************************

Consulte también Configuración de inicialización de Python.


Antes de la inicialización de Python
====================================

En una aplicación que incorpora Python, se debe llamar a la función
"Py_Initialize()" antes de usar cualquier otra función de API
Python/C; con la excepción de algunas funciones y variables de
configuración global.

Las siguientes funciones se pueden invocar de forma segura antes de
que se inicializa Python:

* Funciones de configuración:

  * "PyImport_AppendInittab()"

  * "PyImport_ExtendInittab()"

  * "PyInitFrozenExtensions()"

  * "PyMem_SetAllocator()"

  * "PyMem_SetupDebugHooks()"

  * "PyObject_SetArenaAllocator()"

  * "Py_SetPath()"

  * "Py_SetProgramName()"

  * "Py_SetPythonHome()"

  * "Py_SetStandardStreamEncoding()"

  * "PySys_AddWarnOption()"

  * "PySys_AddXOption()"

  * "PySys_ResetWarnOptions()"

* Funciones informativas:

  * "Py_IsInitialized()"

  * "PyMem_GetAllocator()"

  * "PyObject_GetArenaAllocator()"

  * "Py_GetBuildInfo()"

  * "Py_GetCompiler()"

  * "Py_GetCopyright()"

  * "Py_GetPlatform()"

  * "Py_GetVersion()"

* Utilidades:

  * "Py_DecodeLocale()"

* Asignadores de memoria:

  * "PyMem_RawMalloc()"

  * "PyMem_RawRealloc()"

  * "PyMem_RawCalloc()"

  * "PyMem_RawFree()"

Nota:

  Las siguientes funciones **no deben llamarse** antes de
  "Py_Initialize()": "Py_EncodeLocale()", "Py_GetPath()",
  "Py_GetPrefix()", "Py_GetExecPrefix()", "Py_GetProgramFullPath()",
  "Py_GetPythonHome()", "Py_GetProgramName()" y
  "PyEval_InitThreads()".


Variables de configuración global
=================================

Python tiene variables para la configuración global para controlar
diferentes características y opciones. De forma predeterminada, estos
indicadores están controlados por opciones de línea de comando.

Cuando una opción establece un indicador, el valor del indicador es la
cantidad de veces que se configuró la opción. Por ejemplo, "-b"
establece "Py_BytesWarningFlag" en 1 y "-bb" establece
"Py_BytesWarningFlag" en 2.

int Py_BytesWarningFlag

   This API is kept for backward compatibility: setting
   "PyConfig.bytes_warning" should be used instead, see Python
   Initialization Configuration.

   Emite una advertencia al comparar "bytes" o "bytearray" con "str" o
   "bytes" con "int". Emite un error si es mayor o igual a "2".

   Establecido por la opción "-b".

   Obsoleto desde la versión 3.12.

int Py_DebugFlag

   This API is kept for backward compatibility: setting
   "PyConfig.parser_debug" should be used instead, see Python
   Initialization Configuration.

   Activa la salida de depuración del analizador (solo para expertos,
   según las opciones de compilación).

   Establecido por la opción "-d" y la variable de entorno
   "PYTHONDEBUG".

   Obsoleto desde la versión 3.12.

int Py_DontWriteBytecodeFlag

   This API is kept for backward compatibility: setting
   "PyConfig.write_bytecode" should be used instead, see Python
   Initialization Configuration.

   Si se establece en un valor distinto de cero, Python no intentará
   escribir archivos ".pyc" en la importación de módulos fuente.

   Establecido por la opción "-B" y la variable de entorno
   "PYTHONDONTWRITEBYTECODE".

   Obsoleto desde la versión 3.12.

int Py_FrozenFlag

   This API is kept for backward compatibility: setting
   "PyConfig.pathconfig_warnings" should be used instead, see Python
   Initialization Configuration.

   Suprime los mensajes de error al calcular la ruta de búsqueda del
   módulo en "Py_GetPath()".

   Indicador privado utilizado por los programas "_freeze_module" y
   "frozenmain".

   Obsoleto desde la versión 3.12.

int Py_HashRandomizationFlag

   This API is kept for backward compatibility: setting
   "PyConfig.hash_seed" and "PyConfig.use_hash_seed" should be used
   instead, see Python Initialization Configuration.

   Se establece en "1" si la variable de entorno "PYTHONHASHSEED" se
   establece en una cadena de caracteres no vacía.

   Si el indicador no es cero, lee la variable de entorno
   "PYTHONHASHSEED" para inicializar la semilla de *hash* secreta.

   Obsoleto desde la versión 3.12.

int Py_IgnoreEnvironmentFlag

   This API is kept for backward compatibility: setting
   "PyConfig.use_environment" should be used instead, see Python
   Initialization Configuration.

   Ignore all "PYTHON*" environment variables, e.g. "PYTHONPATH" and
   "PYTHONHOME", that might be set.

   Establecido por las opciones "-E" y "-I".

   Obsoleto desde la versión 3.12.

int Py_InspectFlag

   This API is kept for backward compatibility: setting
   "PyConfig.inspect" should be used instead, see Python
   Initialization Configuration.

   Cuando se pasa una secuencia de comandos (*script*) como primer
   argumento o se usa la opción "-c", ingresa al modo interactivo
   después de ejecutar la secuencia de comandos o el comando, incluso
   cuando "sys.stdin" no parece ser un terminal.

   Establecido por la opción "-i" y la variable de entorno
   "PYTHONINSPECT".

   Obsoleto desde la versión 3.12.

int Py_InteractiveFlag

   This API is kept for backward compatibility: setting
   "PyConfig.interactive" should be used instead, see Python
   Initialization Configuration.

   Establecido por la opción "-i".

   Obsoleto desde la versión 3.12.

int Py_IsolatedFlag

   This API is kept for backward compatibility: setting
   "PyConfig.isolated" should be used instead, see Python
   Initialization Configuration.

   Ejecuta Python en modo aislado. En modo aislado "sys.path" no
   contiene ni el directorio de la secuencia de comandos (*script*) ni
   el directorio de paquetes del sitio del usuario (*site-pacages*).

   Establecido por la opción "-I".

   Added in version 3.4.

   Obsoleto desde la versión 3.12.

int Py_LegacyWindowsFSEncodingFlag

   This API is kept for backward compatibility: setting
   "PyPreConfig.legacy_windows_fs_encoding" should be used instead,
   see Python Initialization Configuration.

   Si la bandera no es cero, utilice la codificación "mbcs" con el
   gestor de errores "replace" en lugar de la codificación UTF-8 con
   el gestor de error "surrogatepass", para la *filesystem encoding
   and error handler* (codificación del sistema de archivos y gestor
   de errores).

   Establece en "1" si la variable de entorno
   "PYTHONLEGACYWINDOWSFSENCODING" está configurada en una cadena de
   caracteres no vacía.

   Ver **PEP 529** para más detalles.

   Availability: Windows.

   Obsoleto desde la versión 3.12.

int Py_LegacyWindowsStdioFlag

   This API is kept for backward compatibility: setting
   "PyConfig.legacy_windows_stdio" should be used instead, see Python
   Initialization Configuration.

   If the flag is non-zero, use "io.FileIO" instead of
   "io._WindowsConsoleIO" for "sys" standard streams.

   Establece en "1" si la variable de entorno
   "PYTHONLEGACYWINDOWSSTDIO" está configurada en una cadena de
   caracteres no vacía.

   Ver **PEP 528** para más detalles.

   Availability: Windows.

   Obsoleto desde la versión 3.12.

int Py_NoSiteFlag

   This API is kept for backward compatibility: setting
   "PyConfig.site_import" should be used instead, see Python
   Initialization Configuration.

   Deshabilita la importación del módulo "site" y las manipulaciones
   dependientes del sitio de "sys.path" que conlleva. También
   deshabilita estas manipulaciones si "site" se importa
   explícitamente más tarde (llama a "site.main()" si desea que se
   activen).

   Establecido por la opción "-S".

   Obsoleto desde la versión 3.12.

int Py_NoUserSiteDirectory

   This API is kept for backward compatibility: setting
   "PyConfig.user_site_directory" should be used instead, see Python
   Initialization Configuration.

   No agregue el "directorio de paquetes de sitio del usuario" (*site-
   packages*) a "sys.path".

   Establecido por las opciones "-s" y "-I", y la variable de entorno
   "PYTHONNOUSERSITE".

   Obsoleto desde la versión 3.12.

int Py_OptimizeFlag

   This API is kept for backward compatibility: setting
   "PyConfig.optimization_level" should be used instead, see Python
   Initialization Configuration.

   Establecido por la opción "-O" y la variable de entorno
   "PYTHONOPTIMIZE".

   Obsoleto desde la versión 3.12.

int Py_QuietFlag

   This API is kept for backward compatibility: setting
   "PyConfig.quiet" should be used instead, see Python Initialization
   Configuration.

   No muestre los mensajes de *copyright* y de versión incluso en modo
   interactivo.

   Establecido por la opción "-q".

   Added in version 3.2.

   Obsoleto desde la versión 3.12.

int Py_UnbufferedStdioFlag

   This API is kept for backward compatibility: setting
   "PyConfig.buffered_stdio" should be used instead, see Python
   Initialization Configuration.

   Obliga a las secuencias *stdout* y *stderr* a que no tengan búfer.

   Establecido por la opción "-u" y la variable de entorno
   "PYTHONUNBUFFERED".

   Obsoleto desde la versión 3.12.

int Py_VerboseFlag

   This API is kept for backward compatibility: setting
   "PyConfig.verbose" should be used instead, see Python
   Initialization Configuration.

   Imprime un mensaje cada vez que se inicializa un módulo, mostrando
   el lugar (nombre de archivo o módulo incorporado) desde el que se
   carga. Si es mayor o igual a "2", imprime un mensaje para cada
   archivo que se verifica al buscar un módulo. También proporciona
   información sobre la limpieza del módulo a la salida.

   Establecido por la opción "-v" y la variable de entorno
   "PYTHONVERBOSE".

   Obsoleto desde la versión 3.12.


Inicializando y finalizando el intérprete
=========================================

void Py_Initialize()
    * Part of the Stable ABI.*

   Inicializa el intérprete de Python. En una aplicación que incorpora
   Python, se debe llamar antes de usar cualquier otra función de API
   Python/C; vea Antes de la inicialización de Python para ver algunas
   excepciones.

   Esto inicializa la tabla de módulos cargados ("sys.modules") y crea
   los módulos fundamentales "builtins", "__main__" y "sys". También
   inicializa la ruta de búsqueda del módulo ("sys.path"). No
   establece "sys.argv"; use "PySys_SetArgvEx()" para eso. Este es un
   *no-op* cuando se llama por segunda vez (sin llamar primero a
   "Py_FinalizeEx()"). No hay valor de retorno; es un error fatal si
   falla la inicialización.

   Use the "Py_InitializeFromConfig()" function to customize the
   Python Initialization Configuration.

   Nota:

     En Windows, cambia el modo de consola de "O_TEXT" a "O_BINARY",
     lo que también afectará los usos de la consola que no sean de
     Python utilizando C *Runtime*.

void Py_InitializeEx(int initsigs)
    * Part of the Stable ABI.*

   Esta función funciona como "Py_Initialize()" si *initsigs* es "1".
   Si *initsigs* es "0", omite el registro de inicialización de los
   manejadores de señal, lo que podría ser útil cuando Python está
   incrustado.

   Use the "Py_InitializeFromConfig()" function to customize the
   Python Initialization Configuration.

int Py_IsInitialized()
    * Part of the Stable ABI.*

   Retorna verdadero (distinto de cero) cuando el intérprete de Python
   se ha inicializado, falso (cero) si no. Después de que se llama a
   "Py_FinalizeEx()", esto retorna falso hasta que "Py_Initialize()"
   se llama de nuevo.

int Py_FinalizeEx()
    * Part of the Stable ABI since version 3.6.*

   Undo all initializations made by "Py_Initialize()" and subsequent
   use of Python/C API functions, and destroy all sub-interpreters
   (see "Py_NewInterpreter()" below) that were created and not yet
   destroyed since the last call to "Py_Initialize()".  Ideally, this
   frees all memory allocated by the Python interpreter.  This is a
   no-op when called for a second time (without calling
   "Py_Initialize()" again first).

   Since this is the reverse of "Py_Initialize()", it should be called
   in the same thread with the same interpreter active.  That means
   the main thread and the main interpreter. This should never be
   called while "Py_RunMain()" is running.

   Normally the return value is "0". If there were errors during
   finalization (flushing buffered data), "-1" is returned.

   Esta función se proporciona por varias razones. Una aplicación de
   incrustación puede querer reiniciar Python sin tener que reiniciar
   la aplicación misma. Una aplicación que ha cargado el intérprete de
   Python desde una biblioteca cargable dinámicamente (o DLL) puede
   querer liberar toda la memoria asignada por Python antes de
   descargar la DLL. Durante una búsqueda de pérdidas de memoria en
   una aplicación, un desarrollador puede querer liberar toda la
   memoria asignada por Python antes de salir de la aplicación.

   **Bugs and caveats:** The destruction of modules and objects in
   modules is done in random order; this may cause destructors
   ("__del__()" methods) to fail when they depend on other objects
   (even functions) or modules.  Dynamically loaded extension modules
   loaded by Python are not unloaded.  Small amounts of memory
   allocated by the Python interpreter may not be freed (if you find a
   leak, please report it).  Memory tied up in circular references
   between objects is not freed.  Some memory allocated by extension
   modules may not be freed.  Some extensions may not work properly if
   their initialization routine is called more than once; this can
   happen if an application calls "Py_Initialize()" and
   "Py_FinalizeEx()" more than once.

   Genera un evento de auditoría "cpython._PySys_ClearAuditHooks" sin
   argumentos.

   Added in version 3.6.

void Py_Finalize()
    * Part of the Stable ABI.*

   Esta es una versión compatible con versiones anteriores de
   "Py_FinalizeEx()" que ignora el valor de retorno.


Parámetros de todo el proceso
=============================

int Py_SetStandardStreamEncoding(const char *encoding, const char *errors)

   Esta API se mantiene para la compatibilidad con versiones
   anteriores: en su lugar, se debe usar la configuración de
   "PyConfig.stdio_encoding" y "PyConfig.stdio_errors", consulta
   Configuración de inicialización de Python.

   Esta función debería llamarse antes de "Py_Initialize()", si es que
   se llama. Especifica qué codificación y manejo de errores usar con
   IO estándar, con los mismos significados que en "str.encode()".

   Reemplaza los valores "PYTHONIOENCODING", y permite incrustar
   código para controlar la codificación IO cuando la variable de
   entorno no funciona.

   *codificación* o *errores* pueden ser "NULL" para usar
   "PYTHONIOENCODING" o valores predeterminados (dependiendo de otras
   configuraciones).

   Tenga en cuenta que "sys.stderr" siempre usa el controlador de
   error "*backslashreplace*", independientemente de esta
   configuración (o cualquier otra).

   Si se llama a "Py_FinalizeEx()", será necesario volver a llamar a
   esta función para afectar las llamadas posteriores a
   "Py_Initialize()".

   Retorna "0" si tiene éxito, un valor distinto de cero en caso de
   error (por ejemplo, llamar después de que el intérprete ya se haya
   inicializado)

   Added in version 3.4.

   Obsoleto desde la versión 3.11.

void Py_SetProgramName(const wchar_t *name)
    * Part of the Stable ABI.*

   Esta API se mantiene para la compatibilidad con versiones
   anteriores: en su lugar, se debe usar la configuración de
   "PyConfig.program_name", consulta Configuración de inicialización
   de Python.

   Esta función debería llamarse antes "Py_Initialize()" se llama por
   primera vez, si es que se llama. Le dice al intérprete el valor del
   argumento "argv[0]" para la función "main()" del programa
   (convertido a caracteres anchos). Esto es utilizado por
   "Py_GetPath()" y algunas otras funciones a continuación para
   encontrar las bibliotecas de tiempo de ejecución de Python
   relativas al ejecutable del intérprete. El valor predeterminado es
   "'python'". El argumento debe apuntar a una cadena de caracteres
   anchos terminada en cero en almacenamiento estático cuyo contenido
   no cambiará mientras dure la ejecución del programa. Ningún código
   en el intérprete de Python cambiará el contenido de este
   almacenamiento.

   Use "Py_DecodeLocale()" to decode a bytes string to get a wchar_t*
   string.

   Obsoleto desde la versión 3.11.

wchar_t *Py_GetProgramName()
    * Part of the Stable ABI.*

   Retorna el nombre del programa establecido con
   "Py_SetProgramName()", o el valor predeterminado. La cadena de
   caracteres retornada apunta al almacenamiento estático; la persona
   que llama no debe modificar su valor.

   Esta función ya no se puede llamar antes de "Py_Initialize()", de
   otra forma retornará "NULL".

   Distinto en la versión 3.10: Todas las siguientes funciones deben
   llamarse después de "Py_Initialize()", de lo contrario retornará
   "NULL".

wchar_t *Py_GetPrefix()
    * Part of the Stable ABI.*

   Return the *prefix* for installed platform-independent files. This
   is derived through a number of complicated rules from the program
   name set with "Py_SetProgramName()" and some environment variables;
   for example, if the program name is "'/usr/local/bin/python'", the
   prefix is "'/usr/local'". The returned string points into static
   storage; the caller should not modify its value.  This corresponds
   to the **prefix** variable in the top-level "Makefile" and the "--
   prefix" argument to the **configure** script at build time.  The
   value is available to Python code as "sys.prefix". It is only
   useful on Unix.  See also the next function.

   Esta función ya no se puede llamar antes de "Py_Initialize()", de
   otra forma retornará "NULL".

   Distinto en la versión 3.10: Todas las siguientes funciones deben
   llamarse después de "Py_Initialize()", de lo contrario retornará
   "NULL".

wchar_t *Py_GetExecPrefix()
    * Part of the Stable ABI.*

   Retorna el *exec-prefix* para los archivos instalados
   *dependientes* de la plataforma. Esto se deriva a través de una
   serie de reglas complicadas del nombre del programa establecido con
   "Py_SetProgramName()" y algunas variables de entorno; por ejemplo,
   si el nombre del programa es "'/usr/local/bin/python'", el prefijo
   *exec* es "'/usr/local'". La cadena de caracteres retornada apunta
   al almacenamiento estático; la persona que llama no debe modificar
   su valor. Esto corresponde a la variable **exec_prefix** en el
   archivo de nivel superior "Makefile" y el argumento "--exec-prefix"
   a la secuencia de comandos (*script*) **configure** en tiempo de
   compilación. El valor está disponible para el código de Python como
   "sys.exec_prefix". Solo es útil en Unix.

   Antecedentes: el prefijo *exec* difiere del prefijo cuando los
   archivos dependientes de la plataforma (como ejecutables y
   bibliotecas compartidas) se instalan en un árbol de directorios
   diferente. En una instalación típica, los archivos dependientes de
   la plataforma pueden instalarse en el subárbol "/usr/local/plat"
   mientras que la plataforma independiente puede instalarse en
   "/usr/local".

   En términos generales, una plataforma es una combinación de
   familias de hardware y software, por ejemplo, las máquinas Sparc
   que ejecutan el sistema operativo Solaris 2.x se consideran la
   misma plataforma, pero las máquinas Intel que ejecutan Solaris 2.x
   son otra plataforma, y las máquinas Intel que ejecutan Linux son
   otra plataforma más. Las diferentes revisiones importantes del
   mismo sistema operativo generalmente también forman plataformas
   diferentes. Los sistemas operativos que no son Unix son una
   historia diferente; Las estrategias de instalación en esos sistemas
   son tan diferentes que el prefijo y el prefijo "exec" no tienen
   sentido y se configuran en la cadena vacía. Tenga en cuenta que los
   archivos de bytecode compilados de Python son independientes de la
   plataforma (¡pero no independientes de la versión de Python con la
   que fueron compilados!).

   Los administradores de sistemas sabrán cómo configurar los
   programas **mount** o **automount** para compartir "/usr/local"
   entre plataformas mientras que "/usr/local/plat" sea un sistema de
   archivos diferente para cada plataforma.

   Esta función ya no se puede llamar antes de "Py_Initialize()", de
   otra forma retornará "NULL".

   Distinto en la versión 3.10: Todas las siguientes funciones deben
   llamarse después de "Py_Initialize()", de lo contrario retornará
   "NULL".

wchar_t *Py_GetProgramFullPath()
    * Part of the Stable ABI.*

   Retorna el nombre completo del programa del ejecutable de Python;
   esto se calcula como un efecto secundario de derivar la ruta de
   búsqueda predeterminada del módulo del nombre del programa
   (establecido por "Py_SetProgramName()" arriba). La cadena de
   caracteres retornada apunta al almacenamiento estático; la persona
   que llama no debe modificar su valor. El valor está disponible para
   el código de Python como "sys.executable".

   Esta función ya no se puede llamar antes de "Py_Initialize()", de
   otra forma retornará "NULL".

   Distinto en la versión 3.10: Todas las siguientes funciones deben
   llamarse después de "Py_Initialize()", de lo contrario retornará
   "NULL".

wchar_t *Py_GetPath()
    * Part of the Stable ABI.*

   Retorna la ruta de búsqueda del módulo predeterminado; esto se
   calcula a partir del nombre del programa (establecido por
   "Py_SetProgramName()" antes mencionado) y algunas variables de
   entorno. La cadena de caracteres retornada consiste en una serie de
   nombres de directorio separados por un carácter delimitador
   dependiente de la plataforma. El carácter delimitador es "':'" en
   Unix y macOS, "';'" en Windows. La cadena de caracteres retornada
   apunta al almacenamiento estático; la persona que llama no debe
   modificar su valor. La lista "sys.path" se inicializa con este
   valor en el inicio del intérprete; se puede (y generalmente se
   realiza) modificar más adelante para cambiar la ruta de búsqueda
   para cargar módulos.

   Esta función ya no se puede llamar antes de "Py_Initialize()", de
   otra forma retornará "NULL".

   Distinto en la versión 3.10: Todas las siguientes funciones deben
   llamarse después de "Py_Initialize()", de lo contrario retornará
   "NULL".

void Py_SetPath(const wchar_t*)
    * Part of the Stable ABI since version 3.7.*

   Esta API se mantiene para la compatibilidad con versiones
   anteriores: en su lugar, se debe usar la configuración de
   "PyConfig.module_search_paths" y
   "PyConfig.module_search_paths_set", consulta Configuración de
   inicialización de Python.

   Establece la ruta de búsqueda del módulo predeterminado. Si se
   llama a esta función antes de "Py_Initialize()", entonces
   "Py_GetPath()" no intentará computar una ruta de búsqueda
   predeterminada, sino que utilizará la proporcionada en su lugar.
   Esto es útil si Python está incrustado por una aplicación que tiene
   pleno conocimiento de la ubicación de todos los módulos. Los
   componentes de la ruta deben estar separados por el carácter
   delimitador dependiente de la plataforma, el cual es "':'" en Unix
   y macOS, "';'" en Windows.

   Esto también hace que "sys.executable" se configure en la ruta
   completa del programa (consulte "Py_GetProgramFullPath()") y para
   "sys.prefix" y "sys.exec_prefix" a estar vacío. Depende de la
   persona que llama modificarlos si es necesario después de llamar
   "Py_Initialize()".

   Utilice "Py_DecodeLocale()" para decodificar una cadena de bytes
   para obtener una cadena de tipo wchar_*.

   El argumento de ruta se copia internamente, por lo que la persona
   que llama puede liberarlo después de que se complete la llamada.

   Distinto en la versión 3.8: La ruta completa del programa ahora se
   usa para "sys.executable", en lugar del nombre del programa.

   Obsoleto desde la versión 3.11.

const char *Py_GetVersion()
    * Part of the Stable ABI.*

   Retorna la versión de este intérprete de Python. Esta es una cadena
   de caracteres que se parece a

      "3.0a5+ (py3k:63103M, May 12 2008, 00:53:55) \n[GCC 4.2.3]"

   La primera palabra (hasta el primer carácter de espacio) es la
   versión actual de Python; los primeros tres caracteres son la
   versión mayor y menor separados por un punto. La cadena de
   caracteres retornada apunta al almacenamiento estático; la persona
   que llama no debe modificar su valor. El valor está disponible para
   el código Python como "sys.version".

   Consulta también la constante "Py_Version".

const char *Py_GetPlatform()
    * Part of the Stable ABI.*

   Retorna el identificador de plataforma para la plataforma actual.
   En Unix, esto se forma a partir del nombre "oficial" del sistema
   operativo, convertido a minúsculas, seguido del número de revisión
   principal; por ejemplo, para Solaris 2.x, que también se conoce
   como SunOS 5.x, el valor es "'sunos5'". En macOS, es "'darwin'". En
   Windows, es "'win'". La cadena de caracteres retornada apunta al
   almacenamiento estático; la persona que llama no debe modificar su
   valor. El valor está disponible para el código de Python como
   "sys.platform".

const char *Py_GetCopyright()
    * Part of the Stable ABI.*

   Retorna la cadena de caracteres de copyright oficial para la
   versión actual de Python, por ejemplo

   "'Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam'"

   La cadena de caracteres retornada apunta al almacenamiento
   estático; la persona que llama no debe modificar su valor. El valor
   está disponible para el código de Python como "sys.copyright".

const char *Py_GetCompiler()
    * Part of the Stable ABI.*

   Retorna una indicación del compilador utilizado para construir la
   versión actual de Python, entre corchetes, por ejemplo:

      "[GCC 2.7.2.2]"

   La cadena de caracteres retornada apunta al almacenamiento
   estático; la persona que llama no debe modificar su valor. El valor
   está disponible para el código Python como parte de la variable
   "sys.version".

const char *Py_GetBuildInfo()
    * Part of the Stable ABI.*

   Retorna información sobre el número de secuencia y la fecha y hora
   de compilación de la instancia actual de intérprete de Python, por
   ejemplo:

      "#67, Aug  1 1997, 22:34:28"

   La cadena de caracteres retornada apunta al almacenamiento
   estático; la persona que llama no debe modificar su valor. El valor
   está disponible para el código Python como parte de la variable
   "sys.version".

void PySys_SetArgvEx(int argc, wchar_t **argv, int updatepath)
    * Part of the Stable ABI.*

   Esta API se mantiene para la compatibilidad con versiones
   anteriores: en su lugar, se debe usar la configuración de
   "PyConfig.argv", "PyConfig.parse_argv" y "PyConfig.safe_path",
   consulta Configuración de inicialización de Python.

   Establece "sys.argv" basado en *argc* y *argv*. Estos parámetros
   son similares a los pasados a la función del programa "main()" con
   la diferencia de que la primera entrada debe referirse al archivo
   de la secuencia de comandos (*script*) que se ejecutará en lugar
   del ejecutable que aloja el intérprete de Python. Si no se ejecuta
   una secuencia de comandos (*script*), la primera entrada en *argv*
   puede ser una cadena de caracteres vacía. Si esta función no puede
   inicializar "sys.argv", una condición fatal se señala usando
   "Py_FatalError()".

   Si *updatepath* es cero, esto es todo lo que hace la función. Si
   *updatepath* no es cero, la función también modifica "sys.path" de
   acuerdo con el siguiente algoritmo:

   * Si el nombre de una secuencia de comandos (*script*) existente se
     pasa en "argv[0]", la ruta absoluta del directorio donde se
     encuentra el *script* se antepone a "sys.path".

   * De lo contrario (es decir, si *argc* es "0" o "argv[0]" no apunta
     a un nombre de archivo existente), una cadena de caracteres vacía
     se antepone a "sys.path", que es lo mismo que anteponer el
     directorio de trabajo actual (""."").

   Use "Py_DecodeLocale()" to decode a bytes string to get a wchar_t*
   string.

   Consulta también los miembros de "PyConfig.orig_argv" y
   "PyConfig.argv" de Python Initialization Configuration.

   Nota:

     It is recommended that applications embedding the Python
     interpreter for purposes other than executing a single script
     pass "0" as *updatepath*, and update "sys.path" themselves if
     desired. See **CVE 2008-5983**.En las versiones anteriores a
     3.1.3, puede lograr el mismo efecto quitando manualmente el
     primer elemento (*popping*) "sys.path" después de haber llamado
     "PySys_SetArgv()", por ejemplo usando

        PyRun_SimpleString("import sys; sys.path.pop(0)\n");

   Added in version 3.1.3.

   Obsoleto desde la versión 3.11.

void PySys_SetArgv(int argc, wchar_t **argv)
    * Part of the Stable ABI.*

   Esta API se mantiene para la compatibilidad con versiones
   anteriores: en su lugar, se debe usar la configuración de
   "PyConfig.argv" y "PyConfig.parse_argv", consulta Configuración de
   inicialización de Python.

   Esta función funciona como "PySys_SetArgvEx()" con *updatepath*
   establecido en "1" a menos que el intérprete **python** se haya
   iniciado con la opción "-I".

   Use "Py_DecodeLocale()" to decode a bytes string to get a wchar_t*
   string.

   Consulta también los miembros de "PyConfig.orig_argv" y
   "PyConfig.argv" de Python Initialization Configuration.

   Distinto en la versión 3.4: El valor *updatepath* depende de la
   opción "-I".

   Obsoleto desde la versión 3.11.

void Py_SetPythonHome(const wchar_t *home)
    * Part of the Stable ABI.*

   Esta API se mantiene para la compatibilidad con versiones
   anteriores: en su lugar, se debe usar la configuración de
   "PyConfig.home", consulta Configuración de inicialización de
   Python.

   Establece el directorio "inicio" (*"home"*) predeterminado, es
   decir, la ubicación de las bibliotecas estándar de Python. Ver
   "PYTHONHOME" para el significado de la cadena de caracteres de
   argumento.

   El argumento debe apuntar a una cadena de caracteres terminada en
   cero en el almacenamiento estático cuyo contenido no cambiará
   mientras dure la ejecución del programa. Ningún código en el
   intérprete de Python cambiará el contenido de este almacenamiento.

   Use "Py_DecodeLocale()" to decode a bytes string to get a wchar_t*
   string.

   Obsoleto desde la versión 3.11.

wchar_t *Py_GetPythonHome()
    * Part of the Stable ABI.*

   Retorna el "inicio" (*home*) predeterminado, es decir, el valor
   establecido por una llamada anterior a "Py_SetPythonHome()", o el
   valor de la variable de entorno "PYTHONHOME" si está configurado.

   Esta función ya no se puede llamar antes de "Py_Initialize()", de
   otra forma retornará "NULL".

   Distinto en la versión 3.10: Todas las siguientes funciones deben
   llamarse después de "Py_Initialize()", de lo contrario retornará
   "NULL".


Estado del hilo y el bloqueo global del intérprete
==================================================

El intérprete de Python no es completamente seguro para hilos
(*thread-safe*). Para admitir programas Python multiproceso, hay un
bloqueo global, denominado *global interpreter lock* o *GIL*, que debe
mantener el hilo actual antes de que pueda acceder de forma segura a
los objetos Python. Sin el bloqueo, incluso las operaciones más
simples podrían causar problemas en un programa de hilos múltiples:
por ejemplo, cuando dos hilos incrementan simultáneamente el conteo de
referencias del mismo objeto, el conteo de referencias podría terminar
incrementándose solo una vez en lugar de dos veces.

Por lo tanto, existe la regla de que solo el hilo que ha adquirido
*GIL* puede operar en objetos Python o llamar a funciones API
Python/C. Para emular la concurrencia de ejecución, el intérprete
regularmente intenta cambiar los hilos (ver
"sys.setswitchinterval()"). El bloqueo también se libera para bloquear
potencialmente las operaciones de E/S, como leer o escribir un
archivo, para que otros hilos de Python puedan ejecutarse mientras
tanto.

El intérprete de Python mantiene cierta información de contabilidad
específica de hilos dentro de una estructura de datos llamada
"PyThreadState". También hay una variable global que apunta a la
actual "PyThreadState": se puede recuperar usando
"PyThreadState_Get()".


Liberando el GIL del código de extensión
----------------------------------------

La mayoría del código de extensión que manipula el *GIL* tiene la
siguiente estructura simple

   Save the thread state in a local variable.
   Release the global interpreter lock.
   ... Do some blocking I/O operation ...
   Reacquire the global interpreter lock.
   Restore the thread state from the local variable.

Esto es tan común que existen un par de macros para simplificarlo:

   Py_BEGIN_ALLOW_THREADS
   ... Do some blocking I/O operation ...
   Py_END_ALLOW_THREADS

La macro "Py_BEGIN_ALLOW_THREADS" abre un nuevo bloque y declara una
variable local oculta; la macro "Py_END_ALLOW_THREADS" cierra el
bloque.

El bloque anterior se expande al siguiente código:

   PyThreadState *_save;

   _save = PyEval_SaveThread();
   ... Do some blocking I/O operation ...
   PyEval_RestoreThread(_save);

Así es como funcionan estas funciones: el bloqueo global del
intérprete se usa para proteger el puntero al estado actual del hilo.
Al liberar el bloqueo y guardar el estado del hilo, el puntero del
estado del hilo actual debe recuperarse antes de que se libere el
bloqueo (ya que otro hilo podría adquirir inmediatamente el bloqueo y
almacenar su propio estado de hilo en la variable global). Por el
contrario, al adquirir el bloqueo y restaurar el estado del hilo, el
bloqueo debe adquirirse antes de almacenar el puntero del estado del
hilo.

Nota:

  Llamar a las funciones de E/S del sistema es el caso de uso más
  común para liberar el GIL, pero también puede ser útil antes de
  llamar a cálculos de larga duración que no necesitan acceso a
  objetos de Python, como las funciones de compresión o criptográficas
  que operan sobre memorias intermedias. Por ejemplo, los módulos
  estándar "zlib" y "hashlib" liberan el GIL al comprimir o mezclar
  datos.


Hilos creados sin Python
------------------------

Cuando se crean hilos utilizando las API dedicadas de Python (como el
módulo "threading"), se les asocia automáticamente un estado del hilo
y, por lo tanto, el código que se muestra arriba es correcto. Sin
embargo, cuando los hilos se crean desde C (por ejemplo, por una
biblioteca de terceros con su propia administración de hilos), no
contienen el GIL, ni existe una estructura de estado de hilos para
ellos.

Si necesita llamar al código Python desde estos subprocesos (a menudo
esto será parte de una API de devolución de llamada proporcionada por
la biblioteca de terceros mencionada anteriormente), primero debe
registrar estos subprocesos con el intérprete creando una estructura
de datos de estado del subproceso, luego adquiriendo el GIL, y
finalmente almacenando su puntero de estado de hilo, antes de que
pueda comenzar a usar la API Python/C Cuando haya terminado, debe
restablecer el puntero del estado del hilo, liberar el GIL y
finalmente liberar la estructura de datos del estado del hilo.

Las funciones "PyGILState_Ensure()" y "PyGILState_Release()" hacen
todo lo anterior automáticamente. El idioma típico para llamar a
Python desde un hilo C es:

   PyGILState_STATE gstate;
   gstate = PyGILState_Ensure();

   /* Perform Python actions here. */
   result = CallSomeFunction();
   /* evaluate result or handle exception */

   /* Release the thread. No Python API allowed beyond this point. */
   PyGILState_Release(gstate);

Tenga en cuenta que las funciones "PyGILState_*"  asumen que solo hay
un intérprete global (creado automáticamente por "Py_Initialize()").
Python admite la creación de intérpretes adicionales (usando
"Py_NewInterpreter()"), pero la mezcla de varios intérpretes y la API
"PyGILState_*" no está soportada.


Precauciones sobre "fork()"
---------------------------

Otra cosa importante a tener en cuenta sobre los hilos es su
comportamiento frente a la llamada C "fork()". En la mayoría de los
sistemas con "fork()", después de que un proceso se bifurca, solo
existirá el hilo que emitió el *fork*. Esto tiene un impacto concreto
tanto en cómo se deben manejar las cerraduras como en todo el estado
almacenado en el tiempo de ejecución de CPython.

The fact that only the "current" thread remains means any locks held
by other threads will never be released. Python solves this for
"os.fork()" by acquiring the locks it uses internally before the fork,
and releasing them afterwards. In addition, it resets any Objetos tipo
lock in the child. When extending or embedding Python, there is no way
to inform Python of additional (non-Python) locks that need to be
acquired before or reset after a fork. OS facilities such as
"pthread_atfork()" would need to be used to accomplish the same thing.
Additionally, when extending or embedding Python, calling "fork()"
directly rather than through "os.fork()" (and returning to or calling
into Python) may result in a deadlock by one of Python's internal
locks being held by a thread that is defunct after the fork.
"PyOS_AfterFork_Child()" tries to reset the necessary locks, but is
not always able to.

El hecho de que todos los otros hilos desaparezcan también significa
que el estado de ejecución de CPython debe limpiarse correctamente, lo
que "os.fork()" lo hace. Esto significa finalizar todos los demás
objetos "PyThreadState" que pertenecen al intérprete actual y todos
los demás objetos "PyInterpreterState". Debido a esto y a la
naturaleza especial del intérprete "principal", "fork()" solo debería
llamarse en el hilo "principal" de ese intérprete, donde el CPython
global el tiempo de ejecución se inicializó originalmente. La única
excepción es si "exec()" se llamará inmediatamente después.


API de alto nivel
-----------------

Estos son los tipos y funciones más utilizados al escribir código de
extensión C o al incrustar el intérprete de Python:

type PyInterpreterState
    * Part of the Limited API (as an opaque struct).*

   Esta estructura de datos representa el estado compartido por varios
   subprocesos cooperantes. Los hilos que pertenecen al mismo
   intérprete comparten la administración de su módulo y algunos otros
   elementos internos. No hay miembros públicos en esta estructura.

   Los hilos que pertenecen a diferentes intérpretes inicialmente no
   comparten nada, excepto el estado del proceso como memoria
   disponible, descriptores de archivos abiertos y demás. El bloqueo
   global del intérprete también es compartido por todos los hilos,
   independientemente de a qué intérprete pertenezcan.

type PyThreadState
    * Part of the Limited API (as an opaque struct).*

   This data structure represents the state of a single thread.  The
   only public data member is:

   PyInterpreterState *interp

      This thread's interpreter state.

void PyEval_InitThreads()
    * Part of the Stable ABI.*

   Función deprecada que no hace nada.

   En Python 3.6 y versiones anteriores, esta función creaba el GIL si
   no existía.

   Distinto en la versión 3.9: La función ahora no hace nada.

   Distinto en la versión 3.7: Esta función ahora es llamada por
   "Py_Initialize()", por lo que ya no tiene que llamarla usted mismo.

   Distinto en la versión 3.2: Esta función ya no se puede llamar
   antes de "Py_Initialize()".

   Obsoleto desde la versión 3.9.

int PyEval_ThreadsInitialized()
    * Part of the Stable ABI.*

   Retorna un valor distinto de cero si se ha llamado a
   "PyEval_InitThreads()". Esta función se puede invocar sin mantener
   el GIL y, por lo tanto, se puede utilizar para evitar llamadas a la
   API de bloqueo cuando se ejecuta un solo hilo.

   Distinto en la versión 3.7: El término *GIL* ahora se inicializa
   con "Py_Initialize()".

   Obsoleto desde la versión 3.9.

PyThreadState *PyEval_SaveThread()
    * Part of the Stable ABI.*

   Libere el bloqueo global del intérprete (si se ha creado) y
   restablezca el estado del hilo a "NULL", retornando el estado del
   hilo anterior (que no es "NULL"). Si se ha creado el bloqueo, el
   hilo actual debe haberlo adquirido.

void PyEval_RestoreThread(PyThreadState *tstate)
    * Part of the Stable ABI.*

   Adquiera el bloqueo global del intérprete (si se ha creado) y
   establezca el estado del hilo en *tstate*, que no debe ser "NULL".
   Si se ha creado el bloqueo, el hilo actual no debe haberlo
   adquirido, de lo contrario se produce un *deadlock*.

   Nota:

     Calling this function from a thread when the runtime is
     finalizing will terminate the thread, even if the thread was not
     created by Python. You can use "_Py_IsFinalizing()" or
     "sys.is_finalizing()" to check if the interpreter is in process
     of being finalized before calling this function to avoid unwanted
     termination.

PyThreadState *PyThreadState_Get()
    * Part of the Stable ABI.*

   Retorna el estado actual del hilo. Se debe mantener el bloqueo
   global del intérprete. Cuando el estado actual del hilo es "NULL",
   esto genera un error fatal (por lo que la persona que llama no
   necesita verificar "NULL").

PyThreadState *PyThreadState_Swap(PyThreadState *tstate)
    * Part of the Stable ABI.*

   Cambia el estado del hilo actual con el estado del hilo dado por el
   argumento *tstate*, que puede ser "NULL". El bloqueo global del
   intérprete debe mantenerse y no se libera.

Las siguientes funciones utilizan almacenamiento local de hilos y no
son compatibles con subinterpretes:

PyGILState_STATE PyGILState_Ensure()
    * Part of the Stable ABI.*

   Asegúrese de que el subproceso actual esté listo para llamar a la
   API de Python C, independientemente del estado actual de Python o
   del bloqueo global del intérprete. Esto se puede invocar tantas
   veces como lo desee un subproceso siempre que cada llamada coincida
   con una llamada a "PyGILState_Release()". En general, se pueden
   usar otras API relacionadas con subprocesos entre
   "PyGILState_Ensure()" y "PyGILState_Release()" invoca siempre que
   el estado del subproceso se restablezca a su estado anterior antes
   del *Release()*. Por ejemplo, el uso normal de las macros
   "Py_BEGIN_ALLOW_THREADS" y "Py_END_ALLOW_THREADS" es aceptable.

   El valor de retorno es un "identificador" opaco al estado del hilo
   cuando "PyGILState_Ensure()" fue llamado, y debe pasarse a
   "PyGILState_Release()" para asegurar que Python se deje en el mismo
   estado. Aunque las llamadas recursivas están permitidas, estos
   identificadores *no* pueden compartirse; cada llamada única a
   "PyGILState_Ensure()" debe guardar el identificador para su llamada
   a "PyGILState_Release()".

   Cuando la función regrese, el hilo actual contendrá el GIL y podrá
   llamar a código arbitrario de Python. El fracaso es un error fatal.

   Nota:

     Calling this function from a thread when the runtime is
     finalizing will terminate the thread, even if the thread was not
     created by Python. You can use "_Py_IsFinalizing()" or
     "sys.is_finalizing()" to check if the interpreter is in process
     of being finalized before calling this function to avoid unwanted
     termination.

void PyGILState_Release(PyGILState_STATE)
    * Part of the Stable ABI.*

   Libera cualquier recurso previamente adquirido. Después de esta
   llamada, el estado de Python será el mismo que antes de la llamada
   correspondiente "PyGILState_Ensure()" (pero en general este estado
   será desconocido para la persona que llama, de ahí el uso de la API
   "GILState").

   Cada llamada a "PyGILState_Ensure()" debe coincidir con una llamada
   a "PyGILState_Release()" en el mismo hilo.

PyThreadState *PyGILState_GetThisThreadState()
    * Part of the Stable ABI.*

   Obtenga el estado actual del hilo para este hilo. Puede retornar
   "NULL" si no se ha utilizado la API "GILState" en el hilo actual.
   Tenga en cuenta que el subproceso principal siempre tiene dicho
   estado de subproceso, incluso si no se ha realizado una llamada de
   estado de subproceso automático en el subproceso principal. Esta es
   principalmente una función auxiliar y de diagnóstico.

int PyGILState_Check()

   Retorna "1" si el hilo actual mantiene el GIL y "0" de lo
   contrario. Esta función se puede llamar desde cualquier hilo en
   cualquier momento. Solo si se ha inicializado el hilo de Python y
   actualmente mantiene el GIL, retornará "1". Esta es principalmente
   una función auxiliar y de diagnóstico. Puede ser útil, por ejemplo,
   en contextos de devolución de llamada o funciones de asignación de
   memoria cuando saber que el GIL está bloqueado puede permitir que
   la persona que llama realice acciones confidenciales o se comporte
   de otra manera de manera diferente.

   Added in version 3.4.

Las siguientes macros se usan normalmente sin punto y coma final;
busque, por ejemplo, el uso en la distribución fuente de Python.

Py_BEGIN_ALLOW_THREADS
    * Part of the Stable ABI.*

   Esta macro se expande a "{PyThreadState *_save; _save =
   PyEval_SaveThread();". Tenga en cuenta que contiene una llave de
   apertura; debe coincidir con la siguiente macro
   "Py_END_ALLOW_THREADS". Ver arriba para una discusión más detallada
   de esta macro.

Py_END_ALLOW_THREADS
    * Part of the Stable ABI.*

   Esta macro se expande a "PyEval_RestoreThread(_save); }". Tenga en
   cuenta que contiene una llave de cierre; debe coincidir con una
   macro anterior "Py_BEGIN_ALLOW_THREADS". Ver arriba para una
   discusión más detallada de esta macro.

Py_BLOCK_THREADS
    * Part of the Stable ABI.*

   Esta macro se expande a "PyEval_RestoreThread(_save);": es
   equivalente a "Py_END_ALLOW_THREADS" sin la llave de cierre.

Py_UNBLOCK_THREADS
    * Part of the Stable ABI.*

   Esta macro se expande a "_save = PyEval_SaveThread();": es
   equivalente a "Py_BEGIN_ALLOW_THREADS" sin la llave de apertura y
   la declaración de variable.


API de bajo nivel
-----------------

Todas las siguientes funciones deben llamarse después de
"Py_Initialize()".

Distinto en la versión 3.7: "Py_Initialize()" ahora inicializa el
*GIL*.

PyInterpreterState *PyInterpreterState_New()
    * Part of the Stable ABI.*

   Crea un nuevo objeto de estado de intérprete. No es necesario
   retener el bloqueo global del intérprete, pero se puede retener si
   es necesario para serializar llamadas a esta función.

   Genera un evento de auditoría "python.PyInterpreterState_New" sin
   argumentos.

void PyInterpreterState_Clear(PyInterpreterState *interp)
    * Part of the Stable ABI.*

   Restablece toda la información en un objeto de estado de
   intérprete. Se debe mantener el bloqueo global del intérprete.

   Lanza una eventos de auditoría "python.PyInterpreterState Clear"
   sin argumentos.

void PyInterpreterState_Delete(PyInterpreterState *interp)
    * Part of the Stable ABI.*

   Destruye un objeto de estado de intérprete. No es necesario
   mantener el bloqueo global del intérprete. El estado del intérprete
   debe haberse restablecido con una llamada previa a
   "PyInterpreterState_Clear()".

PyThreadState *PyThreadState_New(PyInterpreterState *interp)
    * Part of the Stable ABI.*

   Crea un nuevo objeto de estado de hilo que pertenece al objeto de
   intérprete dado. No es necesario retener el bloqueo global del
   intérprete, pero se puede retener si es necesario para serializar
   llamadas a esta función.

void PyThreadState_Clear(PyThreadState *tstate)
    * Part of the Stable ABI.*

   Restablece toda la información en un objeto de estado de hilo. Se
   debe mantener el bloqueo global del intérprete.

   Distinto en la versión 3.9: Esta función ahora llama a la
   retrollamada "PyThreadState.on_delete". Anteriormente, eso sucedía
   en "PyThreadState_Delete()".

void PyThreadState_Delete(PyThreadState *tstate)
    * Part of the Stable ABI.*

   Destruye un objeto de estado de hilo. No es necesario mantener el
   bloqueo global del intérprete. El estado del hilo debe haberse
   restablecido con una llamada previa a "PyThreadState_Clear()".

void PyThreadState_DeleteCurrent(void)

   Destroy the current thread state and release the global interpreter
   lock. Like "PyThreadState_Delete()", the global interpreter lock
   must be held. The thread state must have been reset with a previous
   call to "PyThreadState_Clear()".

PyFrameObject *PyThreadState_GetFrame(PyThreadState *tstate)
    * Part of the Stable ABI since version 3.10.*

   Obtiene el marco actual del estado del hilo de Python *tstate*.

   Retorna una *strong reference* (referencia sólida). Retorna "NULL"
   si no se está ejecutando ningún cuadro.

   Vea también "PyEval_GetFrame()".

   *tstate* no debe ser "NULL".

   Added in version 3.9.

uint64_t PyThreadState_GetID(PyThreadState *tstate)
    * Part of the Stable ABI since version 3.10.*

   Obtiene el identificador de estado de subproceso único del estado
   del hilo de Python *tstate*.

   *tstate* no debe ser "NULL".

   Added in version 3.9.

PyInterpreterState *PyThreadState_GetInterpreter(PyThreadState *tstate)
    * Part of the Stable ABI since version 3.10.*

   Obtiene el intérprete del estado del hilo de Python *tstate*.

   *tstate* no debe ser "NULL".

   Added in version 3.9.

void PyThreadState_EnterTracing(PyThreadState *tstate)

   Suspender el seguimiento y el perfilado en el estado del hilo de
   Python *tstate*.

   Reanudelos usando la función "PyThreadState_LeaveTracing()".

   Added in version 3.11.

void PyThreadState_LeaveTracing(PyThreadState *tstate)

   Reanudar el seguimiento y el perfilado en el estado del hilo de
   Python *tstate* suspendido por la función
   "PyThreadState_EnterTracing()".

   Consulte también las funciones "PyEval_SetTrace()" y
   "PyEval_SetProfile()".

   Added in version 3.11.

PyInterpreterState *PyInterpreterState_Get(void)
    * Part of the Stable ABI since version 3.9.*

   Obtiene el intérprete actual.

   Emite un error fatal si no hay un estado actual del hilo de Python
   o no hay un intérprete actual. No puede retornar NULL.

   La persona que llama debe retener el GIL.

   Added in version 3.9.

int64_t PyInterpreterState_GetID(PyInterpreterState *interp)
    * Part of the Stable ABI since version 3.7.*

   Retorna la identificación única del intérprete. Si hubo algún error
   al hacerlo, entonces se retorna "-1" y se establece un error.

   La persona que llama debe retener el GIL.

   Added in version 3.7.

PyObject *PyInterpreterState_GetDict(PyInterpreterState *interp)
    * Part of the Stable ABI since version 3.8.*

   Retorna un diccionario en el que se pueden almacenar datos
   específicos del intérprete. Si esta función retorna "NULL", no se
   ha producido ninguna excepción y la persona que llama debe suponer
   que no hay disponible una instrucción específica del intérprete.

   Esto no reemplaza a "PyModule_GetState()", que las extensiones
   deben usar para almacenar información de estado específica del
   intérprete.

   Added in version 3.8.

typedef PyObject *(*_PyFrameEvalFunction)(PyThreadState *tstate, _PyInterpreterFrame *frame, int throwflag)

   Tipo de función de evaluación de marcos.

   El parámetro *throwflag* es usado por el método de generadores
   "throw()": si no es cero, maneja la excepción actual.

   Distinto en la versión 3.9: La función ahora recibe un parámetro
   *tstate*.

   Distinto en la versión 3.11: El parámetro *frame* cambió de
   "PyFrameObject*" a "_PyInterpreterFrame*".

_PyFrameEvalFunction _PyInterpreterState_GetEvalFrameFunc(PyInterpreterState *interp)

   Obtiene la función de evaluación de marcos.

   Consulte **PEP 523** "Adición de una API de evaluación de marcos a
   CPython".

   Added in version 3.9.

void _PyInterpreterState_SetEvalFrameFunc(PyInterpreterState *interp, _PyFrameEvalFunction eval_frame)

   Configura la función de evaluación del marco.

   Consulte **PEP 523** "Adición de una API de evaluación de marcos a
   CPython".

   Added in version 3.9.

PyObject *PyThreadState_GetDict()
    *Return value: Borrowed reference.** Part of the Stable ABI.*

   Retorna un diccionario en el que las extensiones pueden almacenar
   información de estado específica del hilo. Cada extensión debe usar
   una clave única para almacenar el estado en el diccionario. Está
   bien llamar a esta función cuando no hay un estado del hilo actual
   disponible. Si esta función retorna "NULL", no se ha producido
   ninguna excepción y la persona que llama debe asumir que no hay
   disponible ningún estado del hilo actual.

int PyThreadState_SetAsyncExc(unsigned long id, PyObject *exc)
    * Part of the Stable ABI.*

   Asynchronously raise an exception in a thread. The *id* argument is
   the thread id of the target thread; *exc* is the exception object
   to be raised. This function does not steal any references to *exc*.
   To prevent naive misuse, you must write your own C extension to
   call this.  Must be called with the GIL held. Returns the number of
   thread states modified; this is normally one, but will be zero if
   the thread id isn't found.  If *exc* is "NULL", the pending
   exception (if any) for the thread is cleared. This raises no
   exceptions.

   Distinto en la versión 3.7: El tipo del parámetro *id* cambia de
   long a unsigned long.

void PyEval_AcquireThread(PyThreadState *tstate)
    * Part of the Stable ABI.*

   Adquiere el bloqueo global del intérprete y establece el estado
   actual del hilo en *tstate*, que no debe ser "NULL". El bloqueo
   debe haber sido creado anteriormente. Si este hilo ya tiene el
   bloqueo, se produce un deadlock.

   Nota:

     Calling this function from a thread when the runtime is
     finalizing will terminate the thread, even if the thread was not
     created by Python. You can use "_Py_IsFinalizing()" or
     "sys.is_finalizing()" to check if the interpreter is in process
     of being finalized before calling this function to avoid unwanted
     termination.

   Distinto en la versión 3.8: Actualiza para ser coherente con
   "PyEval_RestoreThread()", "Py_END_ALLOW_THREADS()", y
   "PyGILState_Ensure()", y termina el hilo actual si se llama
   mientras el intérprete está finalizando.

   "PyEval_RestoreThread()" es una función de nivel superior que
   siempre está disponible (incluso cuando los subprocesos no se han
   inicializado).

void PyEval_ReleaseThread(PyThreadState *tstate)
    * Part of the Stable ABI.*

   Restablece el estado actual del hilo a "NULL" y libera el bloqueo
   global del intérprete. El bloqueo debe haberse creado antes y debe
   estar retenido por el hilo actual. El argumento *tstate*, que no
   debe ser "NULL", solo se usa para verificar que representa el
   estado actual del hilo --- si no lo es, se informa un error fatal.

   "PyEval_SaveThread()" es una función de nivel superior que siempre
   está disponible (incluso cuando los hilos no se han inicializado).

void PyEval_AcquireLock()
    * Part of the Stable ABI.*

   Adquiera el bloqueo global de intérprete. El bloqueo debe haber
   sido creado anteriormente. Si este hilo ya tiene el bloqueo, se
   produce un *deadlock*.

   Obsoleto desde la versión 3.2: Esta función no actualiza el estado
   actual del hilo. Utilice "PyEval_RestoreThread()" o
   "PyEval_AcquireThread()" en su lugar.

   Nota:

     Llamar a esta función desde un hilo cuando finalice el tiempo de
     ejecución terminará el hilo, incluso si Python no creó el hilo.
     Puede usar "_Py_IsFinalizing()" o "sys.is_finalizing()" para
     verificar si el intérprete está en proceso de finalización antes
     de llamar a esta función para evitar una terminación no deseada.

   Distinto en la versión 3.8: Actualiza para ser coherente con
   "PyEval_RestoreThread()", "Py_END_ALLOW_THREADS()", y
   "PyGILState_Ensure()", y termina el hilo actual si se llama
   mientras el intérprete está finalizando.

void PyEval_ReleaseLock()
    * Part of the Stable ABI.*

   Libere el bloqueo global del intérprete. El bloqueo debe haber sido
   creado anteriormente.

   Obsoleto desde la versión 3.2: Esta función no actualiza el estado
   actual del hilo. Utilice "PyEval_SaveThread()" o
   "PyEval_ReleaseThread()" en su lugar.


Soporte de subinterprete
========================

Si bien en la mayoría de los usos, solo incrustará un solo intérprete
de Python, hay casos en los que necesita crear varios intérpretes
independientes en el mismo proceso y tal vez incluso en el mismo hilo.
Los subinterpretes le permiten hacer eso.

El intérprete "principal" es el primero creado cuando se inicializa el
tiempo de ejecución. Suele ser el único intérprete de Python en un
proceso. A diferencia de los subinterpretes, el intérprete principal
tiene responsabilidades globales de proceso únicas, como el manejo de
señales. También es responsable de la ejecución durante la
inicialización del tiempo de ejecución y generalmente es el intérprete
activo durante la finalización del tiempo de ejecución. La función
"PyInterpreterState_Main()" retorna un puntero a su estado.

Puede cambiar entre subinterpretes utilizando la función
"PyThreadState_Swap()". Puede crearlos y destruirlos utilizando las
siguientes funciones:

type PyInterpreterConfig

   Structure containing most parameters to configure a sub-
   interpreter. Its values are used only in
   "Py_NewInterpreterFromConfig()" and never modified by the runtime.

   Added in version 3.12.

   Structure fields:

   int use_main_obmalloc

      If this is "0" then the sub-interpreter will use its own
      "object" allocator state. Otherwise it will use (share) the main
      interpreter's.

      If this is "0" then "check_multi_interp_extensions" must be "1"
      (non-zero). If this is "1" then "gil" must not be
      "PyInterpreterConfig_OWN_GIL".

   int allow_fork

      If this is "0" then the runtime will not support forking the
      process in any thread where the sub-interpreter is currently
      active. Otherwise fork is unrestricted.

      Note that the "subprocess" module still works when fork is
      disallowed.

   int allow_exec

      If this is "0" then the runtime will not support replacing the
      current process via exec (e.g. "os.execv()") in any thread where
      the sub-interpreter is currently active. Otherwise exec is
      unrestricted.

      Note that the "subprocess" module still works when exec is
      disallowed.

   int allow_threads

      If this is "0" then the sub-interpreter's "threading" module
      won't create threads. Otherwise threads are allowed.

   int allow_daemon_threads

      If this is "0" then the sub-interpreter's "threading" module
      won't create daemon threads. Otherwise daemon threads are
      allowed (as long as "allow_threads" is non-zero).

   int check_multi_interp_extensions

      If this is "0" then all extension modules may be imported,
      including legacy (single-phase init) modules, in any thread
      where the sub-interpreter is currently active. Otherwise only
      multi-phase init extension modules (see **PEP 489**) may be
      imported. (Also see "Py_mod_multiple_interpreters".)

      This must be "1" (non-zero) if "use_main_obmalloc" is "0".

   int gil

      This determines the operation of the GIL for the sub-
      interpreter. It may be one of the following:

      PyInterpreterConfig_DEFAULT_GIL

         Use the default selection ("PyInterpreterConfig_SHARED_GIL").

      PyInterpreterConfig_SHARED_GIL

         Use (share) the main interpreter's GIL.

      PyInterpreterConfig_OWN_GIL

         Use the sub-interpreter's own GIL.

      If this is "PyInterpreterConfig_OWN_GIL" then
      "PyInterpreterConfig.use_main_obmalloc" must be "0".

PyStatus Py_NewInterpreterFromConfig(PyThreadState **tstate_p, const PyInterpreterConfig *config)

   Crea un nuevo subinterprete. Este es un entorno (casi) totalmente
   separado para la ejecución de código Python. En particular, el
   nuevo intérprete tiene versiones separadas e independientes de
   todos los módulos importados, incluidos los módulos fundamentales
   "builtins", "__main__" y "sys". La tabla de módulos cargados
   ("sys.modules") y la ruta de búsqueda del módulo ("sys.path")
   también están separados. El nuevo entorno no tiene variable
   "sys.argv". Tiene nuevos objetos de archivo de flujo de E/S
   estándar "sys.stdin", "sys.stdout" y "sys.stderr" (sin embargo,
   estos se refieren a los mismos descriptores de archivo
   subyacentes).

   The given *config* controls the options with which the interpreter
   is initialized.

   Upon success, *tstate_p* will be set to the first thread state
   created in the new sub-interpreter.  This thread state is made in
   the current thread state. Note that no actual thread is created;
   see the discussion of thread states below.  If creation of the new
   interpreter is unsuccessful, *tstate_p* is set to "NULL"; no
   exception is set since the exception state is stored in the current
   thread state and there may not be a current thread state.

   Like all other Python/C API functions, the global interpreter lock
   must be held before calling this function and is still held when it
   returns.  Likewise a current thread state must be set on entry.  On
   success, the returned thread state will be set as current.  If the
   sub-interpreter is created with its own GIL then the GIL of the
   calling interpreter will be released.  When the function returns,
   the new interpreter's GIL will be held by the current thread and
   the previously interpreter's GIL will remain released here.

   Added in version 3.12.

   Sub-interpreters are most effective when isolated from each other,
   with certain functionality restricted:

      PyInterpreterConfig config = {
          .use_main_obmalloc = 0,
          .allow_fork = 0,
          .allow_exec = 0,
          .allow_threads = 1,
          .allow_daemon_threads = 0,
          .check_multi_interp_extensions = 1,
          .gil = PyInterpreterConfig_OWN_GIL,
      };
      PyThreadState *tstate = NULL;
      PyStatus status = Py_NewInterpreterFromConfig(&tstate, &config);
      if (PyStatus_Exception(status)) {
          Py_ExitStatusException(status);
      }

   Note that the config is used only briefly and does not get
   modified. During initialization the config's values are converted
   into various "PyInterpreterState" values.  A read-only copy of the
   config may be stored internally on the "PyInterpreterState".

   Los módulos de extensión se comparten entre (sub) intérpretes de la
   siguiente manera:

   * Para módulos que usan inicialización multifase, por ejemplo
     "PyModule_FromDefAndSpec()", se crea e inicializa un objeto de
     módulo separado para cada intérprete. Solo las variables
     estáticas y globales de nivel C se comparten entre estos objetos
     de módulo.

   * Para módulos que utilizan inicialización monofásica, por ejemplo
     "PyModule_Create()", la primera vez que se importa una extensión
     en particular, se inicializa normalmente y una copia
     (superficial) del diccionario de su módulo se guarda. Cuando otro
     (sub) intérprete importa la misma extensión, se inicializa un
     nuevo módulo y se llena con el contenido de esta copia; no se
     llama a la función "init" de la extensión. Los objetos en el
     diccionario del módulo terminan compartidos entre (sub)
     intérpretes, lo que puede causar un comportamiento no deseado
     (ver Errores y advertencias (Bugs and caveats) a continuación).

     Tenga en cuenta que esto es diferente de lo que sucede cuando se
     importa una extensión después de que el intérprete se haya
     reiniciado por completo llamando a "Py_FinalizeEx()" y
     "Py_Initialize()"; en ese caso, la función "initmodule" de la
     extensión *es* llamada nuevamente. Al igual que con la
     inicialización de múltiples fases, esto significa que solo se
     comparten variables estáticas y globales de nivel C entre estos
     módulos.

PyThreadState *Py_NewInterpreter(void)
    * Part of the Stable ABI.*

   Create a new sub-interpreter.  This is essentially just a wrapper
   around "Py_NewInterpreterFromConfig()" with a config that preserves
   the existing behavior.  The result is an unisolated sub-interpreter
   that shares the main interpreter's GIL, allows fork/exec, allows
   daemon threads, and allows single-phase init modules.

void Py_EndInterpreter(PyThreadState *tstate)
    * Part of the Stable ABI.*

   Destroy the (sub-)interpreter represented by the given thread
   state. The given thread state must be the current thread state.
   See the discussion of thread states below.  When the call returns,
   the current thread state is "NULL".  All thread states associated
   with this interpreter are destroyed.  The global interpreter lock
   used by the target interpreter must be held before calling this
   function.  No GIL is held when it returns.

   "Py_FinalizeEx()" will destroy all sub-interpreters that haven't
   been explicitly destroyed at that point.


A Per-Interpreter GIL
---------------------

Using "Py_NewInterpreterFromConfig()" you can create a sub-interpreter
that is completely isolated from other interpreters, including having
its own GIL.  The most important benefit of this isolation is that
such an interpreter can execute Python code without being blocked by
other interpreters or blocking any others.  Thus a single Python
process can truly take advantage of multiple CPU cores when running
Python code.  The isolation also encourages a different approach to
concurrency than that of just using threads. (See **PEP 554**.)

Using an isolated interpreter requires vigilance in preserving that
isolation.  That especially means not sharing any objects or mutable
state without guarantees about thread-safety.  Even objects that are
otherwise immutable (e.g. "None", "(1, 5)") can't normally be shared
because of the refcount.  One simple but less-efficient approach
around this is to use a global lock around all use of some state (or
object). Alternately, effectively immutable objects (like integers or
strings) can be made safe in spite of their refcounts by making them
"immortal". In fact, this has been done for the builtin singletons,
small integers, and a number of other builtin objects.

If you preserve isolation then you will have access to proper multi-
core computing without the complications that come with free-
threading. Failure to preserve isolation will expose you to the full
consequences of free-threading, including races and hard-to-debug
crashes.

Aside from that, one of the main challenges of using multiple isolated
interpreters is how to communicate between them safely (not break
isolation) and efficiently.  The runtime and stdlib do not provide any
standard approach to this yet.  A future stdlib module would help
mitigate the effort of preserving isolation and expose effective tools
for communicating (and sharing) data between interpreters.

Added in version 3.12.


Errores y advertencias
----------------------

Debido a que los subinterpretes (y el intérprete principal) son parte
del mismo proceso, el aislamiento entre ellos no es perfecto --- por
ejemplo, usando operaciones de archivos de bajo nivel como
"os.close()" pueden (accidentalmente o maliciosamente) afectar los
archivos abiertos del otro. Debido a la forma en que las extensiones
se comparten entre (sub) intérpretes, algunas extensiones pueden no
funcionar correctamente; esto es especialmente probable cuando se
utiliza la inicialización monofásica o las variables globales
(estáticas). Es posible insertar objetos creados en un subinterprete
en un espacio de nombres de otro (sub) intérprete; Esto debe evitarse
si es posible.

Se debe tener especial cuidado para evitar compartir funciones,
métodos, instancias o clases definidas por el usuario entre los
subinterpretes, ya que las operaciones de importación ejecutadas por
dichos objetos pueden afectar el diccionario (sub-) intérprete
incorrecto de los módulos cargados. Es igualmente importante evitar
compartir objetos desde los que se pueda acceder a lo anterior.

También tenga en cuenta que la combinación de esta funcionalidad con
"PyGILState_*" APIs es delicada, porque estas APIs suponen una
biyección entre los estados de hilo de Python e hilos a nivel del
sistema operativo, una suposición rota por la presencia de
subinterpretes. Se recomienda encarecidamente que no cambie los
subinterpretes entre un par de llamadas coincidentes
"PyGILState_Ensure()" y "PyGILState_Release()". Además, las
extensiones (como "ctypes") que usan estas APIs para permitir la
llamada de código Python desde hilos no creados por Python
probablemente se rompan cuando se usan subinterpretes.


Notificaciones asincrónicas
===========================

Se proporciona un mecanismo para hacer notificaciones asincrónicas al
hilo principal del intérprete. Estas notificaciones toman la forma de
un puntero de función y un argumento de puntero nulo.

int Py_AddPendingCall(int (*func)(void*), void *arg)
    * Part of the Stable ABI.*

   Programa una función para que se llame desde el hilo principal del
   intérprete. En caso de éxito, se retorna "0" y se pone en cola
   *func* para ser llamado en el hilo principal. En caso de fallo, se
   retorna "-1" sin establecer ninguna excepción.

   Cuando se puso en cola con éxito, *func* será *eventualmente*
   invocado desde el hilo principal del intérprete con el argumento
   *arg*. Se llamará de forma asincrónica con respecto al código
   Python que se ejecuta normalmente, pero con ambas condiciones
   cumplidas:

   * en un límite *bytecode*;

   * con el hilo principal que contiene el *global interpreter lock*
     (*func*, por lo tanto, puede usar la API C completa).

   *func* debe retornar "0" en caso de éxito o "-1" en caso de error
   con una excepción establecida. *func* no se interrumpirá para
   realizar otra notificación asíncrona de forma recursiva, pero aún
   se puede interrumpir para cambiar hilos si se libera el bloqueo
   global del intérprete.

   Esta función no necesita un estado de hilo actual para ejecutarse y
   no necesita el bloqueo global del intérprete.

   Para llamar a esta función en un subinterprete, quien llama debe
   mantener el GIL. De lo contrario, la función *func* se puede
   programar para que se llame desde el intérprete incorrecto.

   Advertencia:

     Esta es una función de bajo nivel, solo útil para casos muy
     especiales. No hay garantía de que *func* se llame lo más rápido
     posible. Si el hilo principal está ocupado ejecutando una llamada
     al sistema, no se llamará *func* antes de que vuelva la llamada
     del sistema. Esta función generalmente **no** es adecuada para
     llamar a código Python desde hilos C arbitrarios. En su lugar,
     use PyGILState API.

   Added in version 3.1.

   Distinto en la versión 3.9: Si esta función se llama en un
   subinterprete, la función *func* ahora está programada para ser
   llamada desde el subinterprete, en lugar de ser llamada desde el
   intérprete principal. Cada subinterprete ahora tiene su propia
   lista de llamadas programadas.


Perfilado y Rastreo
===================

El intérprete de Python proporciona soporte de bajo nivel para
adjuntar funciones de creación de perfiles y seguimiento de ejecución.
Estos se utilizan para herramientas de análisis de perfiles,
depuración y cobertura.

Esta interfaz C permite que el código de perfilado o rastreo evite la
sobrecarga de llamar a través de objetos invocables a nivel de Python,
haciendo una llamada directa a la función C en su lugar. Los atributos
esenciales de la instalación no han cambiado; la interfaz permite
instalar funciones de rastreo por hilos, y los eventos básicos
informados a la función de rastreo son los mismos que se informaron a
las funciones de rastreo a nivel de Python en versiones anteriores.

typedef int (*Py_tracefunc)(PyObject *obj, PyFrameObject *frame, int what, PyObject *arg)

   The type of the trace function registered using
   "PyEval_SetProfile()" and "PyEval_SetTrace()". The first parameter
   is the object passed to the registration function as *obj*, *frame*
   is the frame object to which the event pertains, *what* is one of
   the constants "PyTrace_CALL", "PyTrace_EXCEPTION", "PyTrace_LINE",
   "PyTrace_RETURN", "PyTrace_C_CALL", "PyTrace_C_EXCEPTION",
   "PyTrace_C_RETURN", or "PyTrace_OPCODE", and *arg* depends on the
   value of *what*:

   +---------------------------------+------------------------------------------+
   | Valor de *what*                 | Significado de *arg*                     |
   |=================================|==========================================|
   | "PyTrace_CALL"                  | Siempre "Py_None".                       |
   +---------------------------------+------------------------------------------+
   | "PyTrace_EXCEPTION"             | Información de excepción retornada por   |
   |                                 | "sys.exc_info()".                        |
   +---------------------------------+------------------------------------------+
   | "PyTrace_LINE"                  | Siempre "Py_None".                       |
   +---------------------------------+------------------------------------------+
   | "PyTrace_RETURN"                | Valor retornado al que llama, o "NULL"   |
   |                                 | si es causado por una excepción.         |
   +---------------------------------+------------------------------------------+
   | "PyTrace_C_CALL"                | Objeto función que se llaman.            |
   +---------------------------------+------------------------------------------+
   | "PyTrace_C_EXCEPTION"           | Objeto función que se llaman.            |
   +---------------------------------+------------------------------------------+
   | "PyTrace_C_RETURN"              | Objeto función que se llaman.            |
   +---------------------------------+------------------------------------------+
   | "PyTrace_OPCODE"                | Siempre "Py_None".                       |
   +---------------------------------+------------------------------------------+

int PyTrace_CALL

   El valor del parámetro *what* para una función "Py_tracefunc"
   cuando se informa una nueva llamada a una función o método, o una
   nueva entrada en un generador. Tenga en cuenta que la creación del
   iterador para una función de generador no se informa ya que no hay
   transferencia de control al código de bytes de Python en la marco
   correspondiente.

int PyTrace_EXCEPTION

   El valor del parámetro *what* para una función "Py_tracefunc"
   cuando se ha producido una excepción. La función de devolución de
   llamada se llama con este valor para *what* cuando después de que
   se procese cualquier bytecode, después de lo cual la excepción se
   establece dentro del marco que se está ejecutando. El efecto de
   esto es que a medida que la propagación de la excepción hace que la
   pila de Python se desenrolle, el retorno de llamada se llama al
   retornar a cada marco a medida que se propaga la excepción. Solo
   las funciones de rastreo reciben estos eventos; el perfilador
   (*profiler*) no los necesita.

int PyTrace_LINE

   The value passed as the *what* parameter to a "Py_tracefunc"
   function (but not a profiling function) when a line-number event is
   being reported. It may be disabled for a frame by setting
   "f_trace_lines" to *0* on that frame.

int PyTrace_RETURN

   El valor para el parámetro *what* para "Py_tracefunc" funciona
   cuando una llamada está por regresar.

int PyTrace_C_CALL

   El valor del parámetro *what* para "Py_tracefunc" funciona cuando
   una función C está a punto de ser invocada.

int PyTrace_C_EXCEPTION

   El valor del parámetro *what* para funciones "Py_tracefunc" cuando
   una función C ha lanzado una excepción.

int PyTrace_C_RETURN

   El valor del parámetro *what* para "Py_tracefunc" funciona cuando
   una función C ha retornado.

int PyTrace_OPCODE

   The value for the *what* parameter to "Py_tracefunc" functions (but
   not profiling functions) when a new opcode is about to be executed.
   This event is not emitted by default: it must be explicitly
   requested by setting "f_trace_opcodes" to *1* on the frame.

void PyEval_SetProfile(Py_tracefunc func, PyObject *obj)

   Set the profiler function to *func*.  The *obj* parameter is passed
   to the function as its first parameter, and may be any Python
   object, or "NULL".  If the profile function needs to maintain
   state, using a different value for *obj* for each thread provides a
   convenient and thread-safe place to store it.  The profile function
   is called for all monitored events except "PyTrace_LINE"
   "PyTrace_OPCODE" and "PyTrace_EXCEPTION".

   Consulte también la función "sys.setprofile()".

   La persona que llama debe mantener el *GIL*.

void PyEval_SetProfileAllThreads(Py_tracefunc func, PyObject *obj)

   Like "PyEval_SetProfile()" but sets the profile function in all
   running threads belonging to the current interpreter instead of the
   setting it only on the current thread.

   La persona que llama debe mantener el *GIL*.

   As "PyEval_SetProfile()", this function ignores any exceptions
   raised while setting the profile functions in all threads.

Added in version 3.12.

void PyEval_SetTrace(Py_tracefunc func, PyObject *obj)

   Set the tracing function to *func*.  This is similar to
   "PyEval_SetProfile()", except the tracing function does receive
   line-number events and per-opcode events, but does not receive any
   event related to C function objects being called.  Any trace
   function registered using "PyEval_SetTrace()" will not receive
   "PyTrace_C_CALL", "PyTrace_C_EXCEPTION" or "PyTrace_C_RETURN" as a
   value for the *what* parameter.

   Consulte también la función "sys.settrace()".

   La persona que llama debe mantener el *GIL*.

void PyEval_SetTraceAllThreads(Py_tracefunc func, PyObject *obj)

   Like "PyEval_SetTrace()" but sets the tracing function in all
   running threads belonging to the current interpreter instead of the
   setting it only on the current thread.

   La persona que llama debe mantener el *GIL*.

   As "PyEval_SetTrace()", this function ignores any exceptions raised
   while setting the trace functions in all threads.

Added in version 3.12.


Soporte avanzado del depurador
==============================

Estas funciones solo están destinadas a ser utilizadas por
herramientas de depuración avanzadas.

PyInterpreterState *PyInterpreterState_Head()

   Retorna el objeto de estado del intérprete al principio de la lista
   de todos esos objetos.

PyInterpreterState *PyInterpreterState_Main()

   Retorna el objeto de estado del intérprete principal.

PyInterpreterState *PyInterpreterState_Next(PyInterpreterState *interp)

   Retorna el siguiente objeto de estado de intérprete después de
   *interp* de la lista de todos esos objetos.

PyThreadState *PyInterpreterState_ThreadHead(PyInterpreterState *interp)

   Retorna el puntero al primer objeto "PyThreadState" en la lista de
   hilos asociados con el intérprete *interp*.

PyThreadState *PyThreadState_Next(PyThreadState *tstate)

   Retorna el siguiente objeto de estado del hilo después de *tstate*
   de la lista de todos los objetos que pertenecen al mismo objeto
   "PyInterpreterState".


Soporte de almacenamiento local de hilo
=======================================

El intérprete de Python proporciona soporte de bajo nivel para el
almacenamiento local de hilos (TLS) que envuelve la implementación de
TLS nativa subyacente para admitir la API de almacenamiento local de
hilos de nivel Python ("threading.local"). Las APIs de nivel CPython C
son similares a las ofrecidas por pthreads y Windows: use una clave de
hilo y funciones para asociar un valor de void* por hilo.

El GIL *no* necesita ser retenido al llamar a estas funciones;
proporcionan su propio bloqueo.

Tenga en cuenta que "Python.h" no incluye la declaración de las API de
TLS, debe incluir "pythread.h" para usar el almacenamiento local de
hilos.

Nota:

  Ninguna de estas funciones API maneja la administración de memoria
  en nombre de los valores void*. Debe asignarlos y desasignarlos
  usted mismo. Si los valores void* son PyObject*, estas funciones
  tampoco realizan operaciones de conteo de referencias en ellos.


API de almacenamiento específico de hilo (TSS, *Thread Specific Storage*)
-------------------------------------------------------------------------

La API de TSS se introduce para reemplazar el uso de la API TLS
existente dentro del intérprete de CPython. Esta API utiliza un nuevo
tipo "Py_tss_t" en lugar de int para representar las claves del hilo.

Added in version 3.7.

Ver también:

  "Una nueva C-API para *Thread-Local Storage* en CPython" (**PEP
  539**)

type Py_tss_t

   Esta estructura de datos representa el estado de una clave del
   hilo, cuya definición puede depender de la implementación de TLS
   subyacente, y tiene un campo interno que representa el estado de
   inicialización de la clave. No hay miembros públicos en esta
   estructura.

   Cuando Py_LIMITED_API no está definido, la asignación estática de
   este tipo por "Py_tss_NEEDS_INIT" está permitida.

Py_tss_NEEDS_INIT

   Esta macro se expande al inicializador para variables "Py_tss_t".
   Tenga en cuenta que esta macro no se definirá con Py_LIMITED_API.


Asignación dinámica
~~~~~~~~~~~~~~~~~~~

Asignación dinámica de "Py_tss_t", requerida en los módulos de
extensión construidos con Py_LIMITED_API, donde la asignación estática
de este tipo no es posible debido a que su implementación es opaca en
el momento de la compilación.

Py_tss_t *PyThread_tss_alloc()
    * Part of the Stable ABI since version 3.7.*

   Retorna un valor que es el mismo estado que un valor inicializado
   con "Py_tss_NEEDS_INIT", o "NULL" en caso de falla de asignación
   dinámica.

void PyThread_tss_free(Py_tss_t *key)
    * Part of the Stable ABI since version 3.7.*

   Libera la *clave* asignada por "PyThread_tss_alloc()", después de
   llamar por primera vez "PyThread_tss_delete()" para asegurarse de
   que los hilos locales asociados no hayan sido asignados. Esto es un
   no-op si el argumento *clave* es "NULL".

   Nota:

     Una clave liberada se convierte en un puntero colgante. Debería
     restablecer la clave a "NULL".


Métodos
~~~~~~~

El parámetro *key* de estas funciones no debe ser "NULL". Además, los
comportamientos de "PyThread_tss_set()" y "PyThread_tss_get()" no
están definidos si el "Py_tss_t" dado no ha sido inicializado por
"PyThread_tss_create()".

int PyThread_tss_is_created(Py_tss_t *key)
    * Part of the Stable ABI since version 3.7.*

   Retorna un valor distinto de cero si "Py_tss_t" ha sido
   inicializado por "PyThread_tss_create()".

int PyThread_tss_create(Py_tss_t *key)
    * Part of the Stable ABI since version 3.7.*

   Retorna un valor cero en la inicialización exitosa de una clave
   TSS. El comportamiento no está definido si el valor señalado por el
   argumento *key* no se inicializa con "Py_tss_NEEDS_INIT". Esta
   función se puede invocar repetidamente en la misma tecla: llamarla
   a una tecla ya inicializada es un *no-op* e inmediatamente retorna
   el éxito.

void PyThread_tss_delete(Py_tss_t *key)
    * Part of the Stable ABI since version 3.7.*

   Destruye una clave TSS para olvidar los valores asociados con la
   clave en todos los hilos y cambie el estado de inicialización de la
   clave a no inicializado. Una clave destruida se puede inicializar
   nuevamente mediante "PyThread_tss_create()". Esta función se puede
   invocar repetidamente en la misma llave; llamarla en una llave ya
   destruida es un *no-op*.

int PyThread_tss_set(Py_tss_t *key, void *value)
    * Part of the Stable ABI since version 3.7.*

   Retorna un valor cero para indicar la asociación exitosa de un
   valor a void* con una clave TSS en el hilo actual. Cada hilo tiene
   un mapeo distinto de la clave a un valor void*.

void *PyThread_tss_get(Py_tss_t *key)
    * Part of the Stable ABI since version 3.7.*

   Retorna el valor void* asociado con una clave TSS en el hilo
   actual. Esto retorna "NULL" si no hay ningún valor asociado con la
   clave en el hilo actual.


API de almacenamiento local de hilos (TLS, *Thread Local Storage*)
------------------------------------------------------------------

Obsoleto desde la versión 3.7: Esta API es reemplazada por API de
Almacenamiento Específico de Hilos (TSS, por sus significado en inglés
*Thread Specific Storage*).

Nota:

  Esta versión de la API no es compatible con plataformas donde la
  clave TLS nativa se define de una manera que no se puede transmitir
  de forma segura a "int". En tales plataformas,
  "PyThread_create_key()" regresará inmediatamente con un estado de
  falla, y las otras funciones TLS serán no operativas en tales
  plataformas.

Debido al problema de compatibilidad mencionado anteriormente, esta
versión de la API no debe usarse en código nuevo.

int PyThread_create_key()
    * Part of the Stable ABI.*

void PyThread_delete_key(int key)
    * Part of the Stable ABI.*

int PyThread_set_key_value(int key, void *value)
    * Part of the Stable ABI.*

void *PyThread_get_key_value(int key)
    * Part of the Stable ABI.*

void PyThread_delete_key_value(int key)
    * Part of the Stable ABI.*

void PyThread_ReInitTLS()
    * Part of the Stable ABI.*
