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

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

int Py_DebugFlag

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

int Py_DontWriteBytecodeFlag

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

int Py_FrozenFlag

   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_importlib" y
   "frozenmain".

int Py_HashRandomizationFlag

   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.

int Py_IgnoreEnvironmentFlag

   Ignorar todas las variables de entorno "PYTHON*", por ejemplo
   "PYTHONPATH" y "PYTHONHOME", eso podría establecerse.

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

int Py_InspectFlag

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

int Py_InteractiveFlag

   Establecido por la opción "-i".

int Py_IsolatedFlag

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

   Nuevo en la versión 3.4.

int Py_LegacyWindowsFSEncodingFlag

   Si el indicador no es cero, use la codificación "mbcs" en lugar de
   la codificación UTF-8 para la codificación del sistema de archivos.

   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.

   Disponibilidad: Windows.

int Py_LegacyWindowsStdioFlag

   Si el indicador no es cero, use "io.FileIO" en lugar de
   "WindowsConsoleIO" para secuencias estándar "sys".

   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.

   Disponibilidad: Windows.

int Py_NoSiteFlag

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

int Py_NoUserSiteDirectory

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

int Py_OptimizeFlag

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

int Py_QuietFlag

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

   Establecido por la opción "-q".

   Nuevo en la versión 3.2.

int Py_UnbufferedStdioFlag

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

int Py_VerboseFlag

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


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

void Py_Initialize()

   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.

   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)

   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.

int Py_IsInitialized()

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

   Deshace todas las inicializaciones realizadas por "Py_Initialize()"
   y el uso posterior de las funciones de Python/C API, y destruye
   todos los sub-intérpretes (ver "Py_NewInterpreter()" a
   continuación) que se crearon y aún no se destruyeron desde el
   última llamada a "Py_Initialize()". Idealmente, esto libera toda la
   memoria asignada por el intérprete de Python. Este es un *no-op*
   cuando se llama por segunda vez (sin llamar a "Py_Initialize()"
   nuevamente primero). Normalmente el valor de retorno es "0". Si
   hubo errores durante la finalización (lavado de datos almacenados
   en el búfer), se retorna "-1".

   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.

   **Errores y advertencias:** La destrucción de módulos y objetos en
   módulos se realiza en orden aleatorio; esto puede causar que los
   destructores (métodos "__del__()") fallen cuando dependen de otros
   objetos (incluso funciones) o módulos. Los módulos de extensión
   cargados dinámicamente cargados por Python no se descargan. Es
   posible que no se liberen pequeñas cantidades de memoria asignadas
   por el intérprete de Python (si encuentra una fuga, informe por
   favor). La memoria atada en referencias circulares entre objetos no
   se libera. Es posible que parte de la memoria asignada por los
   módulos de extensión no se libere. Algunas extensiones pueden no
   funcionar correctamente si su rutina de inicialización se llama más
   de una vez; Esto puede suceder si una aplicación llama a
   "Py_Initialize()" y "Py_FinalizeEx()" más de una vez.

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

   Nuevo en la versión 3.6.

void Py_Finalize()

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

   Nuevo en la versión 3.4.

void Py_SetProgramName(const wchar_t *name)

   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()" para decodificar una cadena de bytes para
   obtener una cadena "wchar_ *".

wchar* Py_GetProgramName()

   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.

wchar_t* Py_GetPrefix()

   Retorna el prefijo *prefix* para los archivos instalados
   independientes 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
   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 **prefix** en el archivo de
   nivel superior "Makefile" y el argumento "--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.prefix".
   Solo es útil en Unix. Ver también la siguiente función.

wchar_t* Py_GetExecPrefix()

   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.

wchar_t* Py_GetProgramFullPath()

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

wchar_t* Py_GetPath()

   Return the default module search path; this is computed from the
   program name (set by "Py_SetProgramName()" above) and some
   environment variables. The returned string consists of a series of
   directory names separated by a platform dependent delimiter
   character.  The delimiter character is "':'" on Unix and macOS,
   "';'" on Windows.  The returned string points into static storage;
   the caller should not modify its value.  The list "sys.path" is
   initialized with this value on interpreter startup; it can be (and
   usually is) modified later to change the search path for loading
   modules.

void Py_SetPath(const wchar_t *)

   Set the default module search path.  If this function is called
   before "Py_Initialize()", then "Py_GetPath()" won't attempt to
   compute a default search path but uses the one provided instead.
   This is useful if Python is embedded by an application that has
   full knowledge of the location of all modules.  The path components
   should be separated by the platform dependent delimiter character,
   which is "':'" on Unix and macOS, "';'" on 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()".

   Use "Py_DecodeLocale()" para decodificar una cadena de bytes para
   obtener una cadena "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.

const char* Py_GetVersion()

   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]"

   The first word (up to the first space character) is the current
   Python version; the first characters are the major and minor
   version separated by a period.  The returned string points into
   static storage; the caller should not modify its value.  The value
   is available to Python code as "sys.version".

const char* Py_GetPlatform()

   Return the platform identifier for the current platform.  On Unix,
   this is formed from the "official" name of the operating system,
   converted to lower case, followed by the major revision number;
   e.g., for Solaris 2.x, which is also known as SunOS 5.x, the value
   is "'sunos5'".  On macOS, it is "'darwin'".  On Windows, it is
   "'win'".  The returned string points into static storage; the
   caller should not modify its value.  The value is available to
   Python code as "sys.platform".

const char* Py_GetCopyright()

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

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

   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)

   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()" para decodificar una cadena de bytes para
   obtener una cadena "wchar_ *".

   Nota:

     Se recomienda que las aplicaciones que incorporan el intérprete
     de Python para otros fines que no sean ejecutar una sola
     secuencia de comandos (*script*) pasen "0" como *updatepath* y
     actualicen "sys.path" si lo desean. Ver *CVE-2008-5983
     <https://cve.mitre.org/cgi-bin/cvename.cgi?name=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");

   Nuevo en la versión 3.1.3.

void PySys_SetArgv(int argc, wchar_t **argv)

   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()" para decodificar una cadena de bytes para
   obtener una cadena "wchar_ *".

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

void Py_SetPythonHome(const wchar_t *home)

   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()" para decodificar una cadena de bytes para
   obtener una cadena "wchar_ *".

w_char* Py_GetPythonHome()

   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.


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_*()" suponen 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
múltiples intérpretes y la API "PyGILState_*()" no son compatibles.


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.

El hecho de que solo permanezca al hilo "actual" significa que ningún
bloqueo retenido por otros hilos nunca se liberará. Python resuelve
esto para "os.fork()" adquiriendo los bloqueos que usa internamente
antes de la bifurcación (*fork*) y soltándolos después. Además,
restablece cualquier Objetos tipo lock en el elemento secundario. Al
extender o incrustar Python, no hay forma de informar a Python de
bloqueos adicionales (que no sean Python) que deben adquirirse antes o
restablecerse después de una bifurcación. Las instalaciones del
sistema operativo como "pthread_atfork()" tendrían que usarse para
lograr lo mismo. Además, al extender o incrustar Python, llamando
"fork()" directamente en lugar de a través de "os.fork()" (y retornar
o llamar a Python) puede resultar en un punto muerto (*deadlock*) por
uno de los bloqueos internos de Python. sostenido por un hilo que no
funciona después del *fork*. "PyOS_AfterFork_Child()" intenta
restablecer los bloqueos necesarios, pero no siempre puede hacerlo.

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:

PyInterpreterState

   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.

PyThreadState

   Esta estructura de datos representa el estado de un solo hilo. El
   único miembro de datos públicos es "interp" ("PyInterpreterState
   *"), que apunta al estado del intérprete de este hilo.

void PyEval_InitThreads()

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

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

int PyEval_ThreadsInitialized()

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

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

PyThreadState* PyEval_SaveThread()

   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)

   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:

     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.

PyThreadState* PyThreadState_Get()

   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)

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

   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:

     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.

void PyGILState_Release(PyGILState_STATE)

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

   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.

   Nuevo en la versión 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

   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

   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

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

Py_UNBLOCK_THREADS

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

   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)

   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)

   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)

   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)

   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)

   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)

   Destruye un objeto de estado de hilo y suelta el bloqueo del
   intérprete global. Como "PyThreadState_Delete()", no es necesario
   mantener el bloqueo del intérprete global. El estado del hilo debe
   haberse restablecido con una llamada anterior a
   "PyThreadState_Clear()".

PyFrameObject* PyThreadState_GetFrame(PyThreadState *tstate)

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

   Retorna una referencia sólida. Retorna "NULL" si no se está
   ejecutando ningún marco.

   Vea también "PyEval_GetFrame()".

   *tstate* no debe ser "NULL".

   Nuevo en la versión 3.9.

uint64_t PyThreadState_GetID(PyThreadState *tstate)

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

   *tstate* no debe ser "NULL".

   Nuevo en la versión 3.9.

PyInterpreterState* PyThreadState_GetInterpreter(PyThreadState *tstate)

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

   *tstate* no debe ser "NULL".

   Nuevo en la versión 3.9.

PyInterpreterState* PyInterpreterState_Get(void)

   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.

   Nuevo en la versión 3.9.

int64_t PyInterpreterState_GetID(PyInterpreterState *interp)

   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.

   Nuevo en la versión 3.7.

PyObject* PyInterpreterState_GetDict(PyInterpreterState *interp)

   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.

   Nuevo en la versión 3.8.

PyObject* (*_PyFrameEvalFunction)(PyThreadState *tstate, PyFrameObject *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*.

_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".

   Nuevo en la versión 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".

   Nuevo en la versión 3.9.

PyObject* PyThreadState_GetDict()
    *Return value: Borrowed reference.*

   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)

   Asincrónicamente lanza una excepción en un hilo. El argumento *id*
   es el id del hilo del hilo de destino; *exc* es el objeto de
   excepción que se debe generar. Esta función no roba ninguna
   referencia a *exc*. Para evitar el uso indebido ingenuo, debe
   escribir su propia extensión C para llamar a esto. Debe llamarse
   con el GIL retenido. Retorna el número de estados de hilo
   modificados; normalmente es uno, pero será cero si no se encuentra
   la identificación del hilo. Si *exc* es "NULL", se borra la
   excepción pendiente (si existe) para el hilo. Esto no lanza
   excepciones.

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

void PyEval_AcquireThread(PyThreadState *tstate)

   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:

     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.

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

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

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

   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:

PyThreadState* Py_NewInterpreter()

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

   El valor de retorno apunta al primer estado del hilo creado en el
   nuevo subinterprete. Este estado de hilo se realiza en el estado de
   hilo actual. Tenga en cuenta que no se crea ningún hilo real; vea
   la discusión de los estados del hilo a continuación. Si la creación
   del nuevo intérprete no tiene éxito, se retorna "NULL"; no se
   establece ninguna excepción, ya que el estado de excepción se
   almacena en el estado actual del hilo y es posible que no haya un
   estado actual del hilo. (Al igual que todas las otras funciones de
   Python/C API, el bloqueo global del intérprete debe mantenerse
   antes de llamar a esta función y aún se mantiene cuando regresa;
   sin embargo, a diferencia de la mayoría de las otras funciones de
   Python/C API, no es necesario que haya un estado del hilo actual en
   entrada.)

   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.

void Py_EndInterpreter(PyThreadState *tstate)

   Destruye el (sub) intérprete representado por el estado del hilo
   dado. El estado del hilo dado debe ser el estado del hilo actual.
   Vea la discusión de los estados del hilo a continuación. Cuando la
   llamada regresa, el estado actual del hilo es "NULL". Todos los
   estados de hilo asociados con este intérprete se destruyen. (El
   bloqueo global del intérprete debe mantenerse antes de llamar a
   esta función y aún se mantiene cuando vuelve). "Py_FinalizeEx()"
   destruirá todos los subinterpretes que no se hayan destruido
   explícitamente en ese punto.


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_*()" API es delicada, porque estas API 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 API 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)

   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.

   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.

   Nuevo en la versión 3.1.


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.

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

   El tipo de la función de rastreo registrada usando
   "PyEval_SetProfile()" y "PyEval_SetTrace()". El primer parámetro es
   el objeto pasado a la función de registro como *obj*, *frame* es el
   objeto de marco al que pertenece el evento, *what* es una de las
   constantes "PyTrace_CALL", "PyTrace_EXCEPTION" , "PyTrace_LINE",
   "PyTrace_RETURN", "PyTrace_C_CALL", "PyTrace_C_EXCEPTION",
   "PyTrace_C_RETURN", o "PyTrace_OPCODE", y *arg* depende de el valor
   de *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

   El valor pasado como parámetro *what* a una función "Py_tracefunc"
   (pero no una función de creación de perfiles) cuando se informa un
   evento de número de línea. Puede deshabilitarse para un marco
   configurando "f_trace_lines" en *0* en ese marco.

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

   El valor del parámetro *what* para funciones "Py_tracefunc" (pero
   no funciones de creación de perfiles) cuando un nuevo código de
   operación está a punto de ejecutarse. Este evento no se emite de
   forma predeterminada: debe solicitarse explícitamente estableciendo
   "f_trace_opcodes" en *1* en el marco.

void PyEval_SetProfile(Py_tracefunc func, PyObject *obj)

   Establece la función del generador de perfiles en *func*. El
   parámetro *obj* se pasa a la función como su primer parámetro, y
   puede ser cualquier objeto de Python o "NULL". Si la función de
   perfilado necesita mantener el estado, el uso de un valor diferente
   para *obj* para cada hilo proporciona un lugar conveniente y seguro
   para guardarlo. Se llama a la función de perfilado para todos los
   eventos supervisados, excepto "PyTrace_LINE" "PyTrace_OPCODE" y
   "PyTrace_EXCEPTION".

   La persona que llama debe mantener el *GIL*.

void PyEval_SetTrace(Py_tracefunc func, PyObject *obj)

   Establece la función de rastreo en *func*. Esto es similar a
   "PyEval_SetProfile()", excepto que la función de rastreo recibe
   eventos de número de línea y eventos por código de operación, pero
   no recibe ningún evento relacionado con los objetos de la función
   C. Cualquier función de rastreo registrada con "PyEval_SetTrace()"
   no recibirá "PyTrace_C_CALL", "PyTrace_C_EXCEPTION" o
   "PyTrace_C_RETURN" como valor para el parámetro *what*.

   La persona que llama debe mantener el *GIL*.


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

Nuevo en la versión 3.7.

Ver también:

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

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

   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)

   Libera la clave *key* 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 *key* es *NULL*.

   Nota:

     A freed key becomes a dangling pointer. You should reset the key
     to *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)

   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)

   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)

   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)

   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)

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

void PyThread_delete_key(int key)

int PyThread_set_key_value(int key, void *value)

void* PyThread_get_key_value(int key)

void PyThread_delete_key_value(int key)

void PyThread_ReInitTLS()
