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

# `sys` — Parámetros y funciones específicos del sistema

Este módulo provee acceso a algunas variables usadas o mantenidas por el intérprete y a funciones que interactúan fuertemente con el intérprete. Siempre está disponible.

`sys.``abiflags`

  En los sistemas POSIX donde Python se construyó con el script estándar `configure`, este contiene los indicadores ABI según lo especificado por PEP 3149.

  Distinto en la versión 3.8: Los flags por defecto se convirtieron en una cadena de caracteres vacía (el flag `m` para pymalloc ha sido eliminado).

  Nuevo en la versión 3.2.

`sys.``addaudithook`(hook)

  Append the callable hook to the list of active auditing hooks for the current (sub)interpreter.

  When an auditing event is raised through the `sys.audit()` function, each hook will be called in the order it was added with the event name and the tuple of arguments. Native hooks added by `PySys_AddAuditHook()` are called first, followed by hooks added in the current (sub)interpreter. Hooks can then log the event, raise an exception to abort the operation, or terminate the process entirely.

  Calling `sys.addaudithook()` will itself raise an auditing event named `sys.addaudithook` with no arguments. If any existing hooks raise an exception derived from `RuntimeError`, the new hook will not be added and the exception suppressed. As a result, callers cannot assume that their hook has been added unless they control all existing hooks.

  See the audit events table for all events raised by CPython, and PEP 578 for the original design discussion.

  Nuevo en la versión 3.8.

  Distinto en la versión 3.8.1: Las excepciones derivadas de `Exception` pero no `RuntimeError` ya no se suprimen.

  CPython implementation detail: Cuando el rastreo está habilitado (ver `settrace()`), los ganchos de Python solo se rastrean si el invocable tiene un miembro `__cantrace__` que se establece en un valor verdadero. De lo contrario, las funciones de seguimiento omitirán el enlace.

`sys.``argv`

  La lista de argumentos de la línea de comandos pasados a un script de Python. `argv[0]` es el nombre del script (depende del sistema operativo si se trata de una ruta completa o no). Si el comando se ejecutó usando la opción `-c` de la línea de comandos del intérprete, `argv[0]` se establece en la cadena de caracteres `'-c'`. Si no se pasó ningún nombre de secuencia de comandos al intérprete de Python, `argv[0]` es la cadena de caracteres vacía.

  Para recorrer la entrada estándar, o la lista de archivos dada en la línea de comando, vea el módulo `fileinput`.

  Nota

  En Unix, los argumentos de la línea de comandos se pasan por bytes desde el sistema operativo. Python los decodifica con la codificación del sistema de archivos y el controlador de errores «surrogateescape». Cuando necesite bytes originales, puede obtenerlos mediante `[os.fsencode (arg) for arg in sys.argv]`.

`sys.``audit`(event, *args)

  Activar un evento de auditoría y activar cualquier hook de auditoría activo. event es una cadena que identifica el evento, y args puede contener argumentos opcionales con más información sobre el evento. El número y los tipos de argumentos para un evento determinado se consideran una API pública y estable y no deberían modificarse entre versiones.

  Por ejemplo, un evento de auditoría se llama `os.chdir`. Este evento tiene un argumento llamado path que contendrá el nuevo directorio de trabajo solicitado.

  `sys.audit()` llamará a los ganchos de auditoría existentes, pasando el nombre del evento y los argumentos, y volverá a lanzar la primera excepción de cualquier hook. En general, si se lanza una excepción, no debería ser manejada y el proceso debería terminar lo más rápidamente posible. Esto permite que las implementaciones de los hook decidan cómo responder a determinados eventos: pueden limitarse a registrar el evento o abortar la operación lanzando una excepción.

  Los ganchos se agregan usando las funciones `sys.addaudithook()` o `PySys_AddAuditHook()`.

  El equivalente nativo de esta función es `PySys_Audit()`. Se prefiere usar la función nativa cuando sea posible.

  Consulte la tabla de eventos de auditoría para todos los eventos lanzados por CPython.

  Nuevo en la versión 3.8.

`sys.``base_exec_prefix`

  Se establece durante el inicio de Python, antes de que se ejecute `site.py`, en el mismo valor que `exec_prefix`. Si no se ejecuta en un entorno virtual, los valores permanecerán iguales; Si `site.py` encuentra que se está utilizando un entorno virtual, los valores de `prefix` y `exec_prefix` se cambiarán para apuntar al entorno virtual, mientras que `base_prefix` y `base_exec_prefix` seguirá apuntando a la instalación base de Python (aquella desde la que se creó el entorno virtual).

  Nuevo en la versión 3.3.

`sys.``base_prefix`

  Se establece durante el inicio de Python, antes de que se ejecute `site.py`, al mismo valor que `prefix`. Si no se ejecuta en un entorno virtual, los valores permanecerán iguales; si `site.py` encuentra que se está utilizando un entorno virtual, los valores de `prefix` y `exec_prefix` se cambiarán para apuntar al entorno virtual, mientras que `base_prefix` y `base_exec_prefix` seguirá apuntando a la instalación base de Python (aquella desde la que se creó el entorno virtual).

  Nuevo en la versión 3.3.

`sys.``byteorder`

  Un indicador del orden de bytes nativo. Esto tendrá el valor `'big'` en las plataformas big-endian (el byte más significativo primero) y `'little'` en las plataformas little-endian (el byte menos significativo primero).

`sys.``builtin_module_names`

  Una tupla de cadenas de caracteres que proporciona los nombres de todos los módulos que se compilan en este intérprete de Python. (Esta información no está disponible de ninguna otra manera — `modules.keys()` solo enumera los módulos importados.)

`sys.``call_tracing`(func, args)

  Llame a `func(*args)`, mientras el rastreo está habilitado. El estado de seguimiento se guarda y se restaura posteriormente. Esto está destinado a ser llamado desde un depurador desde un punto de control, para depurar recursivamente algún otro código.

`sys.``copyright`

  Una cadena de caracteres que contiene los derechos de autor pertenecientes al intérprete de Python.

`sys.``_clear_type_cache`()

  Borre la caché de tipo interno. La caché de tipos se utiliza para acelerar las búsquedas de métodos y atributos. Utilice la función solo para eliminar referencias innecesarias durante la depuración de fugas de referencia.

  Esta función debe usarse solo para fines internos y especializados.

`sys.``_current_frames`()

  Retorna un diccionario que asigna el identificador de cada subproceso al marco de pila superior actualmente activo en ese subproceso en el momento en que se llama a la función. Tenga en cuenta que las funciones en el módulo `traceback` pueden construir la pila de llamadas dado tal marco.

  Esto es más útil para depurar deadlock: esta función no requiere la cooperación de los subprocesos con deadlock, y las pilas de llamadas de dichos subprocesos se congelan mientras permanezcan en deadlock. El marco retornado para un subproceso no en deadlock puede no tener relación con la actividad actual de ese subproceso en el momento en que el código de llamada examina el marco.

  Esta función debe usarse solo para fines internos y especializados.

  Lanza un auditing event `sys._current_frames` sin argumentos.

`sys.``breakpointhook`()

  Esta función de gancho es llamada por built-in `breakpoint()`. De forma predeterminada, lo coloca en el depurador `pdb`, pero se puede configurar en cualquier otra función para que pueda elegir qué depurador se utiliza.

  La firma de esta función depende de lo que llame. Por ejemplo, el enlace predeterminado (por ejemplo, `pdb.set_trace()`) no espera argumentos, pero puede vincularlo a una función que espera argumentos adicionales (posicional o palabra clave). La función incorporada `breakpoint()` pasa sus `*args` y `**kws` directamente. Lo que sea que retorne `breakpointhooks()` se retorna desde `breakpoint()`.

  La implementación predeterminada consulta primero la variable de entorno `PYTHONBREAKPOINT`. Si se establece en `"0"`, esta función vuelve inmediatamente; es decir, no es una operación. Si la variable de entorno no se establece, o se establece en la cadena vacía, se llama a `pdb.set_trace()`. De lo contrario, esta variable debería nombrar una función para ejecutar, utilizando la nomenclatura de importación con puntos de Python, por ejemplo `package.subpackage.module.function`. En este caso, se importaría `package.subpackage.module` y el módulo resultante debe tener un invocable llamado `function()`. Esto se ejecuta, pasando `*args` y `**kws`, y lo que sea que `function()` retorna, `sys.breakpointhook()` retorna a la función `breakpoint()`.

  Tenga en cuenta que si algo sale mal al importar el invocable nombrado por `PYTHONBREAKPOINT`, se informa un `RuntimeWarning` y se ignora el punto de interrupción (breakpoint).

  También tenga en cuenta que si `sys.breakpointhook()` se anula mediante programación, `PYTHONBREAKPOINT` no se consulta.

  Nuevo en la versión 3.7.

`sys.``_debugmallocstats`()

  Imprime información de bajo nivel para stderr sobre el estado del asignador de memoria de CPython.

  Si Python está configurado –with-pydebug, también realiza algunas comprobaciones de consistencia internas costosas.

  Nuevo en la versión 3.3.

  CPython implementation detail: Esta función es específica de CPython. El formato exacto de salida no se define aquí y puede cambiar.

`sys.``dllhandle`

  Número entero que especifica el identificador de la DLL de Python.

  Disponibilidad: Windows.

`sys.``displayhook`(value)

  Si value no es `None`, esta función imprime `repr(value)` en `sys.stdout` y guarda value en `builtins._`. Si `repr(value)` no se puede codificar en `sys.stdout.encoding` con el controlador de errores `sys.stdout.errors` (que probablemente sea `'strict'`), codifíquelo para `sys.stdout.encoding` con el controlador de errores `'backslashreplace'`.

  Se llama a `sys.displayhook` como resultado de evaluar un expression ingresado en una sesión interactiva de Python. La visualización de estos valores se puede personalizar asignando otra función de un argumento a `sys.displayhook`.

  Pseudo-código:

      def displayhook(value):
          if value is None:
              return
          # Set '_' to None to avoid recursion
          builtins._ = None
          text = repr(value)
          try:
              sys.stdout.write(text)
          except UnicodeEncodeError:
              bytes = text.encode(sys.stdout.encoding, 'backslashreplace')
              if hasattr(sys.stdout, 'buffer'):
                  sys.stdout.buffer.write(bytes)
              else:
                  text = bytes.decode(sys.stdout.encoding, 'strict')
                  sys.stdout.write(text)
          sys.stdout.write("\n")
          builtins._ = value

  Distinto en la versión 3.2: Usa el manejador de error `'backslashreplace'` en `UnicodeEncodeError`.

`sys.``dont_write_bytecode`

  Si esto es cierto, Python no intentará escribir archivos `.pyc` en la importación de módulos fuente. Este valor se establece inicialmente en `True` o `False` según la opción `-B` de la línea de comando y la variable de entorno `PYTHONDONTWRITEBYTECODE`, pero puede configurarlo usted mismo para controlar el código de bytes generación de archivos.

`sys.``pycache_prefix`

  Si esto está configurado (no `None`), Python escribirá archivos de bytecode-cache `.pyc` en (y los leerá desde) un árbol de directorios paralelo enraizado en este directorio, en lugar de `__pycache__` directorios en el árbol de código fuente. Cualquier directorio `__pycache__` en el árbol de código fuente será ignorado y los nuevos archivos .pyc se escribirán dentro del prefijo pycache. Por lo tanto, si usa `compileall` como paso previo a la compilación, debe asegurarse de ejecutarlo con el mismo prefijo de pycache (si lo hay) que usará en tiempo de ejecución.

  Una ruta relativa se interpreta en relación con el directorio de directorio actual.

  Este valor se establece inicialmente en función del valor de la opción de línea de comandos `-X` `pycache_prefix=PATH` o la variable de entorno `PYTHONPYCACHEPREFIX` (la línea de comandos tiene prioridad). Si no se establece ninguno, es `None`.

  Nuevo en la versión 3.8.

`sys.``excepthook`(type, value, traceback)

  Esta función imprime un rastreo y una excepción dados a `sys.stderr`.

  Cuando se genera una excepción y no se detecta, el intérprete llama a `sys.excepthook` con tres argumentos, la clase de excepción, la instancia de excepción y un objeto de rastreo. En una sesión interactiva, esto sucede justo antes de que se retorna el control al indicador; en un programa de Python esto sucede justo antes de que el programa salga. El manejo de tales excepciones de nivel superior se puede personalizar asignando otra función de tres argumentos a `sys.excepthook`.

  Lanza un auditing event `sys.excepthook` con argumentos `hook`, `type`, `value`, `traceback`.

  Ver también

  La función `sys.unraisablehook()` maneja las excepciones que no se pueden evaluar y la función `threading.excepthook()` maneja la excepción lanzada por `threading.Thread.run()`.

`sys.``__breakpointhook__`
`sys.``__displayhook__`
`sys.``__excepthook__`
`sys.``__unraisablehook__`

  Estos objetos contienen los valores originales de `breakpointhook`, `displayhook`, `excepthook` y `unraisablehook` al inicio del programa. Se guardan para que `breakpointhook`, `displayhook` y `excepthook`, `unraisablehook` se puedan restaurar en caso de que sean reemplazados por objetos rotos o alternativos.

  Nuevo en la versión 3.7: __breakpointhook__

  Nuevo en la versión 3.8: __unraisablehook__

`sys.``exc_info`()

  Esta función retorna una tupla de tres valores que proporcionan información sobre la excepción que se está manejando actualmente. La información retornada es específica tanto del hilo actual como del marco de pila actual. Si el marco de pila actual no está manejando una excepción, la información se toma del marco de pila que llama, o de quien la llama, y así sucesivamente hasta que se encuentra un marco de pila que está manejando una excepción. Aquí, «manejar una excepción» se define como «ejecutar una cláusula except». Para cualquier marco de pila, solo se puede acceder a la información sobre la excepción que se maneja actualmente.

  Si no se maneja ninguna excepción en ninguna parte de la pila, se retorna una tupla que contiene tres valores `None`. De lo contrario, los valores retornados son `(type, value, traceback)`. Su significado es: type obtiene el tipo de excepción que se está manejando (una subclase de `BaseException`); value obtiene la instancia de excepción (una instancia del tipo de excepción); traceback obtiene un objeto traceback que encapsula la pila de llamadas en el punto donde ocurrió originalmente la excepción.

`sys.``exec_prefix`

  Una cadena de caracteres que proporciona el prefijo de directorio específico del sitio donde están instalados los archivos Python dependientes de la plataforma; de forma predeterminada, también es `'/usr/local'`. Esto se puede configurar en el momento de la compilación con el argumento `--exec-prefix` del script configure. Específicamente, todos los archivos de configuración (por ejemplo, el archivo de encabezado `pyconfig.h`) se instalan en el directorio `exec_prefix/lib/pythonXY/config`, y los módulos de la biblioteca compartida se instalan en `exec_prefix/lib/pythonXY/lib-dynload`, donde XY es el número de versión de Python, por ejemplo,``3.2``.

  Nota

  Si un virtual environment está en efecto, este valor se cambiará en `site.py` para apuntar al entorno virtual. El valor para la instalación de Python seguirá estando disponible a través de `base_exec_prefix`.

`sys.``executable`

  Una cadena de caracteres que proporciona la ruta absoluta del binario ejecutable para el intérprete de Python, en sistemas donde esto tiene sentido. Si Python no puede recuperar la ruta real a su ejecutable, `sys.executable` será una cadena de caracteres vacía o `None`.

`sys.``exit`([arg])

  Raise a `SystemExit` exception, signaling an intention to exit the interpreter.

  El argumento opcional arg puede ser un número entero que dé el estado de salida (por defecto es cero) u otro tipo de objeto. Si es un número entero, cero se considera «terminación exitosa» y cualquier valor distinto de cero se considera «terminación anormal» por los shells y similares. La mayoría de los sistemas requieren que esté en el rango 0-127 y, de lo contrario, producen resultados indefinidos. Algunos sistemas tienen una convención para asignar significados específicos a códigos de salida específicos, pero estos generalmente están subdesarrollados; Los programas Unix generalmente usan 2 para errores de sintaxis de línea de comandos y 1 para todos los demás tipos de errores. Si se pasa otro tipo de objeto, `None` equivale a pasar cero, y cualquier otro objeto se imprime en `stderr` y da como resultado un código de salida de 1. En particular, `sys.exit("algún mensaje de error")` es una forma rápida de salir de un programa cuando ocurre un error.

  Since `exit()` ultimately «only» raises an exception, it will only exit the process when called from the main thread, and the exception is not intercepted. Cleanup actions specified by finally clauses of `try` statements are honored, and it is possible to intercept the exit attempt at an outer level.

  Distinto en la versión 3.6: Si se produce un error en la limpieza después de que el intérprete de Python haya detectado `SystemSalir` (como un error al vaciar los datos almacenados en el búfer en los flujos estándar), el estado de salida cambia a 120.

`sys.``flags`

  El named tuple flags expone el estado de los indicadores de la línea de comando. Los atributos son de solo lectura.

  atributo | flag
  --- | ---
  `debug` | `-d`
  `inspect` | `-i`
  `interactive` | `-i`
  `isolated` | `-I`
  `optimize` | `-O` o `-OO`
  `dont_write_bytecode` | `-B`
  `no_user_site` | `-s`
  `no_site` | `-S`
  `ignore_environment` | `-E`
  `verbose` | `-v`
  `bytes_warning` | `-b`
  `quiet` | `-q`
  `hash_randomization` | `-R`
  `dev_mode` | `-X dev` (Modo de desarrollo de Python)
  `utf8_mode` | `-X utf8`
  `int_max_str_digits` | `-X int_max_str_digits` (integer string conversion length limitation)

  Distinto en la versión 3.2: Agregado el atributo `quiet` para el nuevo flag `-q`.

  Nuevo en la versión 3.2.3: El atributo `hash_randomization`.

  Distinto en la versión 3.3: Eliminado el atributo obsoleto `division_warning`.

  Distinto en la versión 3.4: Agregado el atributo `isolated` para el flag `-I` `isolated`.

  Distinto en la versión 3.7: Added the `dev_mode` attribute for the new Python Development Mode and the `utf8_mode` attribute for the new `-X` `utf8` flag.

  Distinto en la versión 3.9.14: Added the `int_max_str_digits` attribute.

`sys.``float_info`

  Un named tuple que contiene información sobre el tipo de flotante. Contiene información de bajo nivel sobre la precisión y la representación interna. Los valores corresponden a las diversas constantes de coma flotante definidas en el archivo de encabezado estándar `float.h` para el lenguaje de programación “C”; consulte la sección 5.2.4.2.2 de la norma ISO/IEC C de 1999 [C99], “Características de los tipos flotantes”, para obtener más detalles.

  atributo | macro float.h | explicación
  --- | --- | ---
  `epsilon` | DBL_EPSILON | diferencia entre 1.0 y el menor valor mayor que 1.0 que es representable como flotante Vea también `math.ulp()`.
  `dig` | DBL_DIG | número máximo de dígitos decimales que se pueden representar fielmente en un flotante; véase a continuación
  `mant_dig` | DBL_MANT_DIG | precisión de flotantes: el número de dígitos base-`radix` en el significando de un flotante
  `max` | DBL_MAX | máximo punto flotante positivo representable
  `max_exp` | DBL_MAX_EXP | entero máximo e tal que `radix**(e-1)` es un flotante finito representable
  `max_10_exp` | DBL_MAX_10_EXP | entero máximo e tal que `10**e` está en el rango de flotantes finitos representables
  `min` | DBL_MIN | flotante normalizado mínimo representable positivo Usa `math.ulp(0.0)` para obtener el menor flotante positivo denormalizado representable.
  `min_exp` | DBL_MIN_EXP | entero mínimo e tal que `radix**(e-1)` es un flotante normalizado
  `min_10_exp` | DBL_MIN_10_EXP | entero mínimo e tal que `10**e` es un valor flotante normalizado
  `radix` | FLT_RADIX | base de representación de exponente
  `rounds` | FLT_ROUNDS | constante entera que representa el modo de redondeo utilizado para operaciones aritméticas. Esto refleja el valor de la macro FLT_ROUNDS del sistema en el momento de inicio del intérprete. Consulte la sección 5.2.4.2.2 del estándar C99 para obtener una explicación de los posibles valores y sus significados.

  El atributo `sys.float_info.dig` necesita más explicación. Si `s` es cualquier cadena que represente un número decimal con como máximo `sys.float_info.dig` dígitos significativos, entonces la conversión de `s` a un flotante y viceversa recuperará una cadena que representa el mismo decimal valor:

      >>> import sys
      >>> sys.float_info.dig
      15
      >>> s = '3.14159265358979'    # decimal string with 15 significant digits
      >>> format(float(s), '.15g')  # convert to float and back -> same value
      '3.14159265358979'

  Pero para cadenas con más de `sys.float_info.dig` dígitos significativos, esto no siempre es cierto:

      >>> s = '9876543211234567'    # 16 significant digits is too many!
      >>> format(float(s), '.16g')  # conversion changes value
      '9876543211234568'

`sys.``float_repr_style`

  Una cadena que indica cómo se comporta la función `repr()` para los flotantes. Si la cadena tiene el valor `'short'`, entonces para un flotante finito `x`, `repr(x)` tiene como objetivo producir una cadena corta con la propiedad de que `float(repr(x)) == x`. Este es el comportamiento habitual en Python 3.1 y posteriores. De lo contrario, `float_repr_style` tiene el valor `'legacy'` y `repr(x)` se comporta de la misma manera que en las versiones de Python anteriores a la 3.1.

  Nuevo en la versión 3.1.

`sys.``getallocatedblocks`()

  Retorna el número de bloques de memoria asignados actualmente por el intérprete, independientemente de su tamaño. Esta función es principalmente útil para rastrear y depurar pérdidas de memoria. Debido a los cachés internos del intérprete, el resultado puede variar de una llamada a otra; puede que tenga que llamar a `_clear_type_cache()` y `gc.collect()` para obtener resultados más predecibles.

  Si una construcción o implementación de Python no puede calcular razonablemente esta información, `getallocatedblocks()` puede retornar 0 en su lugar.

  Nuevo en la versión 3.4.

`sys.``getandroidapilevel`()

  Retorna la versión de la API de tiempo de compilación de Android como un número entero.

  Disponibilidad: Android.

  Nuevo en la versión 3.7.

`sys.``getdefaultencoding`()

  Retorna el nombre de la codificación de cadena predeterminada actual utilizada por la implementación de Unicode.

`sys.``getdlopenflags`()

  Retorna el valor actual de las flags que se utilizan para llamadas `dlopen()`. Los nombres simbólicos para los valores de las flags se pueden encontrar en el módulo `os` (constantes `RTLD_xxx`, por ejemplo `os.RTLD_LAZY`).

  Disponibilidad: Unix.

`sys.``getfilesystemencoding`()

  Retorna el nombre de la codificación utilizada para convertir entre nombres de archivo Unicode y nombres de archivo en bytes. Para una mejor compatibilidad, se debe utilizar str para los nombres de archivo en todos los casos, aunque también se admite la representación de nombres de archivo como bytes. Las funciones que aceptan o retornan nombres de archivo deben admitir str o bytes y se deben convertir internamente a la representación preferida del sistema.

  Esta codificación es siempre compatible con ASCII.

  `os.fsencode()` y `os.fsdecode()` deben usarse para garantizar que se utilizan la codificación correcta y el modo de errores.

  - En el modo UTF-8, la codificación es `utf-8` en cualquier plataforma.

  - En macOS, la codificación es `'utf-8'`.

  - En Unix, la codificación es la codificación local.

  - En Windows, la codificación puede ser `'utf-8'` o `'mbcs'`, según la configuración del usuario.

  - En Android, la codificación es `'utf-8'`.

  - En VxWorks, la codificación es `'utf-8'`.

  Distinto en la versión 3.2: el resultado de `getfilesystemencoding()` ya no puede ser `None`.

  Distinto en la versión 3.6: Ya no se garantiza que Windows retorne `'mbcs'`. Consulte PEP 529 y `_enablelegacywindowsfsencoding()` para obtener más información.

  Distinto en la versión 3.7: Retorna “utf-8” en el modo UTF-8.

`sys.``getfilesystemencodeerrors`()

  Retorna el nombre del modo de error utilizado para convertir entre nombres de archivo Unicode y nombres de archivo en bytes. El nombre de la codificación se retorna desde `getfilesystemencoding()`.

  `os.fsencode()` y `os.fsdecode()` deben usarse para garantizar que se utilizan la codificación correcta y el modo de errores.

  Nuevo en la versión 3.6.

`sys.``get_int_max_str_digits`()

  Returns the current value for the integer string conversion length limitation. See also `set_int_max_str_digits()`.

  Nuevo en la versión 3.9.14.

`sys.``getrefcount`(object)

  Retorna el recuento de referencias del object. El recuento retornado es generalmente uno más alto de lo que cabría esperar, porque incluye la referencia (temporal) como argumento para `getrefcount()`.

`sys.``getrecursionlimit`()

  Retorna el valor actual del límite de recursividad, la profundidad máxima de la pila de intérpretes de Python. Este límite evita que la recursividad infinita cause un desbordamiento de la pila C y bloquee Python. Se puede configurar mediante `setrecursionlimit()`.

`sys.``getsizeof`(object[, default])

  Retorna el tamaño de un objeto en bytes. El objeto puede ser cualquier tipo de objeto. Todos los objetos integrados retornarán resultados correctos, pero esto no tiene por qué ser cierto para las extensiones de terceros, ya que es una implementación específica.

  Solo se tiene en cuenta el consumo de memoria atribuido directamente al objeto, no el consumo de memoria de los objetos a los que se refiere.

  Si se proporciona, se retornará predeterminado si el objeto no proporciona los medios para recuperar el tamaño. De lo contrario, se generará un `TypeError`.

  `getsizeof()` llama al método `__sizeof__` del objeto y agrega una sobrecarga adicional del recolector de basura si el objeto es administrado por el recolector de basura.

  Consulte receta de sizeof recursivo para ver un ejemplo del uso de `getsizeof()` de forma recursiva para encontrar el tamaño de los contenedores y todo su contenido.

`sys.``getswitchinterval`()

  Retorna el «intervalo de cambio de hilo» del intérprete; ver `setswitchinterval()`.

  Nuevo en la versión 3.2.

`sys.``_getframe`([depth])

  Retorna un objeto de marco de la pila de llamadas. Si se proporciona un entero opcional depth, retorna el objeto de marco que muchas llamadas debajo de la parte superior de la pila. Si eso es más profundo que la pila de llamadas, se lanza `ValueError`. El valor predeterminado de depth es cero, lo que retorna el marco en la parte superior de la pila de llamadas.

  Lanza un auditing event `sys._getframe` sin argumentos.

  CPython implementation detail: Esta función debe utilizarse únicamente para fines internos y especializados. No se garantiza que exista en todas las implementaciones de Python.

`sys.``getprofile`()

  Obtiene la función de generador de perfiles establecida por `setprofile()`.

`sys.``gettrace`()

  Obtiene la función de seguimiento (trace) establecida por `settrace()`.

  CPython implementation detail: La función `gettrace()` está pensada solo para implementar depuradores, perfiladores, herramientas de cobertura y similares. Su comportamiento es parte de la plataforma de implementación, en lugar de parte de la definición del lenguaje y, por lo tanto, es posible que no esté disponible en todas las implementaciones de Python.

`sys.``getwindowsversion`()

  Retorna una tupla con nombre que describe la versión de Windows que se está ejecutando actualmente. Los elementos nombrados son major, minor, build, platform, service_pack, service_pack_minor, service_pack_major, suite_mask, product_type y platform_version. service_pack contiene una cadena de caracteres, platform_version una tupla de 3 y todos los demás valores son números enteros. También se puede acceder a los componentes por su nombre, por lo que `sys.getwindowsversion()[0]` es equivalente a `sys.getwindowsversion().major`. Para compatibilidad con versiones anteriores, solo los primeros 5 elementos se pueden recuperar mediante la indexación.

  platform será `2 (VER_PLATFORM_WIN32_NT)`.

  product_type puede ser uno de los siguientes valores:

  Constante | Significado
  --- | ---
  `1 (VER_NT_WORKSTATION)` | El sistema es una estación de trabajo.
  `2 (VER_NT_DOMAIN_CONTROLLER)` | El sistema es un controlador de dominio.
  `3 (VER_NT_SERVER)` | El sistema es un servidor, pero no un controlador de dominio.

  Esta función envuelve la función Win32 `GetVersionEx()`; consulte la documentación de Microsoft en `OSVERSIONINFOEX()` para obtener más información sobre estos campos.

  platform_version returns the major version, minor version and build number of the current operating system, rather than the version that is being emulated for the process. It is intended for use in logging rather than for feature detection.

  Nota

  platform_version derives the version from kernel32.dll which can be of a different version than the OS version. Please use `platform` module for achieving accurate OS version.

  Disponibilidad: Windows.

  Distinto en la versión 3.2: Cambiada a una tupla con nombre y agregado service_pack_minor, service_pack_major, suite_mask, y product_type.

  Distinto en la versión 3.6: Agregado platform_version

`sys.``get_asyncgen_hooks`()

  Retorna un objeto asyncgen_hooks, que es similar a `namedtuple` de la forma (firstiter, finalizer), donde se espera que firstiter y finalizer sean `None` o funciones que toman un asynchronous generator iterator como argumento, y se utilizan para programar la finalización de un generador asíncrono mediante un bucle de eventos.

  Nuevo en la versión 3.6: Ver PEP 525 para más detalles.

  Nota

  Esta función se ha añadido de forma provisional (consulte PEP 411 para obtener más detalles).

`sys.``get_coroutine_origin_tracking_depth`()

  Obtiene la profundidad de seguimiento del origen de la corrutina actual, según lo establecido por `set_coroutine_origin_tracking_depth()`.

  Nuevo en la versión 3.7.

  Nota

  Esta función se ha añadido de forma provisional (consulte PEP 411 para obtener más detalles). Úsela sólo para fines de depuración.

`sys.``hash_info`

  A named tuple dando parámetros de la implementación de hash numérico. Para obtener más detalles sobre el hash de tipos numéricos, consulte Calculo del hash de tipos numéricos.

  atributo | explicación
  --- | ---
  `width` | ancho en bits usado para valores hash
  `modulus` | primer módulo P utilizado para el esquema de hash numérico
  `inf` | valor hash retornado para un infinito positivo
  `nan` | valor hash retornado para un nan
  `imag` | multiplicador utilizado para la parte imaginaria de un número complejo
  `algorithm` | nombre del algoritmo para el hash de str, bytes y memoryview
  `hash_bits` | tamaño de salida interno del algoritmo hash
  `seed_bits` | tamaño de la clave semilla del algoritmo hash

  Nuevo en la versión 3.2.

  Distinto en la versión 3.4: Agregado algoritmo, hash_bits y seed_bits

`sys.``hexversion`

  El número de versión codificado como un solo entero. Se garantiza que esto aumentará con cada versión, incluido el soporte adecuado para versiones que no son de producción. Por ejemplo, para probar que el intérprete de Python es al menos la versión 1.5.2, use:

      if sys.hexversion >= 0x010502F0:
          # use some advanced feature
          ...
      else:
          # use an alternative implementation or warn the user
          ...

  Esto se llama `hexversion` ya que solo parece realmente significativo cuando se ve como el resultado de pasarlo a la función incorporada `hex()`. El named tuple `sys.version_info` puede usarse para una codificación más amigable para los humanos de la misma información.

  Se pueden encontrar más detalles de `hexversion` en Versiones de API y ABI.

`sys.``implementation`

  Un objeto que contiene información sobre la implementación del intérprete de Python en ejecución. Los siguientes atributos deben existir en todas las implementaciones de Python.

  name es el identificador de la implementación, por ejemplo `'cpython'`. La cadena de caracteres real está definida por la implementación de Python, pero se garantiza que estará en minúsculas.

  version es una tupla con nombre, en el mismo formato que `sys.version_info`. Representa la versión de la implementación de Python. Esto tiene un significado distinto de la versión específica del lenguaje de Python al que se ajusta el intérprete que se está ejecutando actualmente, que representa `sys.version_info`. Por ejemplo, para PyPy 1.8 `sys.implementation.version` podría ser `sys.version_info(1, 8, 0, 'final', 0)`, mientras que `sys.version_info` sería `sys.version_info(2, 7, 2, 'final', 0)`. Para CPython tienen el mismo valor, ya que es la implementación de referencia.

  hexversion es la versión de implementación en formato hexadecimal, como `sys.hexversion`.

  cache_tag es la etiqueta utilizada por la maquinaria de importación en los nombres de archivo de los módulos almacenados en caché. Por convención, sería una combinación del nombre y la versión de la implementación, como `'cpython-33'`. Sin embargo, una implementación de Python puede usar algún otro valor si corresponde. Si `cache_tag` está configurado como `None`, indica que el almacenamiento en caché del módulo debe estar deshabilitado.

  `sys.implementation` puede contener atributos adicionales específicos de la implementación de Python. Estos atributos no estándar deben comenzar con un guion bajo y no se describen aquí. Independientemente de su contenido, `sys.implementation` no cambiará durante la ejecución del intérprete, ni entre las versiones de implementación. (Sin embargo, puede cambiar entre las versiones del lenguaje Python). Consulte PEP 421 para obtener más información.

  Nuevo en la versión 3.3.

  Nota

  La adición de nuevos atributos obligatorios debe pasar por el proceso normal de PEP. Consulte PEP 421 para obtener más información.

`sys.``int_info`

  Un named tuple que contiene información sobre la representación interna de Python de los enteros. Los atributos son de solo lectura.

  Atributo | Explicación
  --- | ---
  `bits_per_digit` | número de bits retenidos en cada dígito. Los enteros de Python se almacenan internamente en la base `2**int_info.bits_per_digit`
  `sizeof_digit` | tamaño en bytes del tipo C utilizado para representar un dígito
  `default_max_str_digits` | default value for `sys.get_int_max_str_digits()` when it is not otherwise explicitly configured.
  `str_digits_check_threshold` | minimum non-zero value for `sys.set_int_max_str_digits()`, `PYTHONINTMAXSTRDIGITS`, or `-X int_max_str_digits`.

  Nuevo en la versión 3.1.

  Distinto en la versión 3.9.14: Added `default_max_str_digits` and `str_digits_check_threshold`.

`sys.``__interactivehook__`

  Cuando existe este atributo, su valor se llama automáticamente (sin argumentos) cuando se lanza el intérprete en modo interactivo. Esto se hace después de leer el archivo `PYTHONSTARTUP`, para que pueda establecer este enlace allí. El módulo `site` establece este.

  Lanza un auditing event `cpython.run_interactivehook` con el argumento `hook`.

  Nuevo en la versión 3.4.

`sys.``intern`(string)

  Ingresa string en la tabla de cadenas de caracteres «internadas» y retorna la cadena de caracteres interna, que es string en sí misma o una copia. Internar cadenas de caracteres es útil para obtener un poco de rendimiento en la búsqueda de diccionario: si las claves en un diccionario están internadas y la clave de búsqueda está interna, las comparaciones de claves (después del hash) se pueden realizar mediante una comparación de punteros en lugar de una comparación de cadenas. Normalmente, los nombres utilizados en los programas de Python se internan automáticamente, y los diccionarios utilizados para contener los atributos de módulo, clase o instancia tienen claves internas.

  Las cadenas de caracteres internas no son inmortales; debe mantener una referencia al valor de retorno de `intern()` para beneficiarse de él.

`sys.``is_finalizing`()

  Retorna `True` si el intérprete de Python es shutting down, `False` en caso contrario.

  Nuevo en la versión 3.5.

`sys.``last_type`
`sys.``last_value`
`sys.``last_traceback`

  Estas tres variables no siempre están definidas; se establecen cuando no se maneja una excepción y el intérprete imprime un mensaje de error y un seguimiento de la pila. Su uso previsto es permitir que un usuario interactivo importe un módulo depurador y realice una depuración post-mortem sin tener que volver a ejecutar el comando que provocó el error. (El uso típico es `import pdb; pdb.pm()` para ingresar al depurador post-mortem; consulte módulo `pdb` para obtener más información).

  El significado de las variables es el mismo que el de los valores retornados de `exc_info()` arriba.

`sys.``maxsize`

  Un entero que da el valor máximo que puede tomar una variable de tipo `Py_ssize_t`. Suele ser `2**31 - 1` en una plataforma de 32 bits y `2** 63 - 1` en una plataforma de 64 bits.

`sys.``maxunicode`

  Un número entero que da el valor del punto de código Unicode más grande, es decir, `1114111` (`0x10FFFF` en hexadecimal).

  Distinto en la versión 3.3: Antes PEP 393, `sys.maxunicode` solía ser `0xFFFF` o `0x10FFFF`, dependiendo de la opción de configuración que especificaba si los caracteres Unicode se almacenaban como UCS-2 o UCS-4.

`sys.``meta_path`

  Una lista de objetos meta path finder que tienen sus métodos `find_spec()` llamados para ver si uno de los objetos puede encontrar el módulo que se va a importar. Se llama al método `find_spec()` con al menos el nombre absoluto del módulo que se está importando. Si el módulo que se va a importar está contenido en un paquete, el atributo del paquete principal `__path__` se pasa como segundo argumento. El método retorna module spec, o `None` si no se puede encontrar el módulo.

  Ver también

  `importlib.abc.MetaPathFinder`

    La clase base abstracta que define la interfaz de los objetos del buscador en `meta_path`.

  `importlib.machinery.ModuleSpec`

    La clase concreta que `find_spec()` debería retornar instancias de.

  Distinto en la versión 3.4: Especificaciones del módulo se introdujeron en Python 3.4, por PEP 451. Las versiones anteriores de Python buscaban un método llamado `find_module()`. Esto todavía se llama como una alternativa si una entrada `meta_path` no tiene un método `find_spec()`.

`sys.``modules`

  Este es un diccionario que asigna los nombres de los módulos a los módulos que ya se han cargado. Esto se puede manipular para forzar la recarga de módulos y otros trucos. Sin embargo, reemplazar el diccionario no necesariamente funcionará como se esperaba y eliminar elementos esenciales del diccionario puede hacer que Python falle.

`sys.``path`

  Una lista de cadenas de caracteres que especifica la ruta de búsqueda de módulos. Inicializado desde la variable de entorno `PYTHONPATH`, más un valor predeterminado que depende de la instalación.

  Como se inicializó al iniciar el programa, el primer elemento de esta lista, `path[0]`, es el directorio que contiene el script que se utilizó para invocar al intérprete de Python. Si el directorio de la secuencia de comandos no está disponible (por ejemplo, si el intérprete se invoca de forma interactiva o si la secuencia de comandos se lee desde la entrada estándar), `path[0]` es la cadena de caracteres vacía, que dirige a Python a buscar módulos en el directorio actual primero. Observe que el directorio del script se inserta antes de las entradas insertadas como resultado de `PYTHONPATH`.

  Un programa es libre de modificar esta lista para sus propios fines. Solo se deben agregar cadenas de caracteres y bytes a `sys.path`; todos los demás tipos de datos se ignoran durante la importación.

  Ver también

  Módulo `site` Esto describe cómo usar archivos .pth para extender `sys.path`.

`sys.``path_hooks`

  Una lista de invocables que toman un argumento de ruta para intentar crear un finder para la ruta. Si se puede crear un buscador, el invocable debe retornar; de lo contrario, lanza `ImportError`.

  Especificado originalmente en PEP 302.

`sys.``path_importer_cache`

  Un diccionario que actúa como caché para objetos finder. Las claves son rutas que se han pasado a `sys.path_hooks` y los valores son los buscadores que se encuentran. Si una ruta es una ruta de sistema de archivos válida pero no se encuentra ningún buscador en `sys.path_hooks`, entonces se almacena `None`.

  Especificado originalmente en PEP 302.

  Distinto en la versión 3.3: `None` se almacena en lugar de `imp.NullImporter` cuando no se encuentra ningún buscador.

`sys.``platform`

  Esta cadena de caracteres contiene un identificador de plataforma que se puede usar para agregar componentes específicos de la plataforma a `sys.path`, por ejemplo.

  Para los sistemas Unix, excepto en Linux y AIX, este es el nombre del sistema operativo en minúsculas como lo retorna `uname -s` con la primera parte de la versión retornada por `uname -r` adjunta, por ejemplo `'sunos5'` o `'freebsd8'`, en el momento en que se construyó Python. A menos que desee probar una versión específica del sistema, se recomienda utilizar el siguiente idioma:

      if sys.platform.startswith('freebsd'):
          # FreeBSD-specific code here...
      elif sys.platform.startswith('linux'):
          # Linux-specific code here...
      elif sys.platform.startswith('aix'):
          # AIX-specific code here...

  Para otros sistemas, los valores son:

  Sistema | valor `platform`
  --- | ---
  AIX | `'aix'`
  Linux | `'linux'`
  Windows | `'win32'`
  Windows/Cygwin | `'cygwin'`
  macOS | `'darwin'`

  Distinto en la versión 3.3: En Linux, `sys.platform` ya no contiene la versión principal. Siempre es `'linux'`, en lugar de `'linux2'` o `'linux3'`. Dado que las versiones anteriores de Python incluyen el número de versión, se recomienda utilizar siempre el idioma `startswith` presentado anteriormente.

  Distinto en la versión 3.8: En AIX, `sys.platform` ya no contiene la versión principal. Siempre es `'aix'`, en lugar de `'aix5'` o `'aix7'`. Dado que las versiones anteriores de Python incluyen el número de versión, se recomienda utilizar siempre el idioma `startswith` presentado anteriormente.

  Ver también

  `os.name` tiene una granularidad más gruesa. `os.uname()` proporciona información de versión dependiente del sistema.

  El módulo `platform` proporciona comprobaciones detalladas de la identidad del sistema.

`sys.``platlibdir`

  Nombre del directorio de la biblioteca específica de la plataforma. Se utiliza para construir la ruta de la biblioteca estándar y las rutas de los módulos de extensión instalados.

  Es igual a `"lib"` en la mayoría de las plataformas. En Fedora y SuSE, es igual a `"lib64"` en plataformas de 64 bits, lo que da las siguientes rutas `sys.path` (donde `X.Y` es la versión `mayor.menor` de Python):

  - `/usr/lib64/pythonX.Y/`: Biblioteca estándar (como `os.py` del módulo `os`)

  - `/usr/lib64/pythonX.Y/lib-dynload/`: Módulos de extensión C de la biblioteca estándar (como el módulo `errno`, el nombre exacto del archivo es específico de la plataforma)

  - `/usr/lib/pythonX.Y/site-packages/` (utilice siempre `lib`, no `sys.platlibdir`): Módulos de terceros

  - `/usr/lib64/pythonX.Y/site-packages/`: Módulos de extensión C de paquetes de terceros

  Nuevo en la versión 3.9.

`sys.``prefix`

  A string giving the site-specific directory prefix where the platform independent Python files are installed; on Unix, the default is `'/usr/local'`. This can be set at build time with the `--prefix` argument to the configure script. See Rutas de instalación for derived paths.

  Nota

  Si un virtual environment está en efecto, este valor se cambiará en `site.py` para apuntar al entorno virtual. El valor para la instalación de Python seguirá estando disponible a través de `base_prefix`.

`sys.``ps1`
`sys.``ps2`

  Cadenas de caracteres que especifican el indicador principal y secundario del intérprete. Estos solo se definen si el intérprete está en modo interactivo. Sus valores iniciales en este caso son `'>>>'` y `'...'`. Si se asigna un objeto que no es una cadena a cualquiera de las variables, su `str()` se vuelve a evaluar cada vez que el intérprete se prepara para leer un nuevo comando interactivo; esto se puede utilizar para implementar un mensaje dinámico.

`sys.``setdlopenflags`(n)

  Establece los indicadores utilizados por el intérprete para llamadas `dlopen()`, como cuando el intérprete carga módulos de extensión. Entre otras cosas, esto permitirá una resolución diferida de símbolos al importar un módulo, si se llama como `sys.setdlopenflags(0)`. Para compartir símbolos entre módulos de extensión, llame como `sys.setdlopenflags(os.RTLD_GLOBAL)`. Los nombres simbólicos para los valores de las banderas se pueden encontrar en el módulo `os` (constantes `RTLD_xxx`, por ejemplo `os.RTLD_LAZY`).

  Disponibilidad: Unix.

`sys.``set_int_max_str_digits`(n)

  Set the integer string conversion length limitation used by this interpreter. See also `get_int_max_str_digits()`.

  Nuevo en la versión 3.9.14.

`sys.``setprofile`(profilefunc)

  Configura la función de perfil del sistema, que le permite implementar un generador de perfiles de código fuente de Python en Python. Consulte el capítulo Los perfiladores de Python para obtener más información sobre el generador de perfiles de Python. La función de perfil del sistema se llama de manera similar a la función de seguimiento del sistema (ver `settrace()`), pero se llama con diferentes eventos, por ejemplo, no se llama para cada línea de código ejecutada (solo al llamar y regresar, pero el evento de retorno se informa incluso cuando se ha establecido una excepción). La función es específica de subprocesos, pero el generador de perfiles no tiene forma de conocer los cambios de contexto entre subprocesos, por lo que no tiene sentido usar esto en presencia de varios subprocesos. Además, su valor de retorno no se usa, por lo que simplemente puede retornar `None`. Un error en la función del perfil provocará su desarmado.

  Las funciones de perfil deben tener tres argumentos: frame, event y arg. frame es el marco de pila actual. event es una cadena de caracteres: `'call'`, `'return'`, `'c_call'`, `'c_return'`, o `'c_exception'`. arg depende del tipo de evento.

  Lanza un auditing event `sys.setprofile` sin argumentos.

  Los eventos tienen el siguiente significado:

  `'call'`

    Se llama a una función (o se ingresa algún otro bloque de código). Se llama a la función de perfil; arg es `None`.

  `'return'`

    Una función (u otro bloque de código) está a punto de regresar. Se llama a la función de perfil; arg es el valor que se retornará, o `None` si el evento es causado por una excepción.

  `'c_call'`

    Una función C está a punto de ser llamada. Esta puede ser una función de extensión o una incorporada. arg es el objeto de función de C.

  `'c_return'`

    Ha vuelto una función C. arg es el objeto de función de C.

  `'c_exception'`

    Una función C ha generado una excepción. arg es el objeto de función de C.

`sys.``setrecursionlimit`(limit)

  Establece la profundidad máxima de la pila de intérpretes de Python en limit. Este límite evita que la recursividad infinita cause un desbordamiento de la pila C y bloquee Python.

  El límite más alto posible depende de la plataforma. Un usuario puede necesitar establecer un límite más alto cuando tiene un programa que requiere una recursividad profunda y una plataforma que admite un límite más alto. Esto debe hacerse con cuidado, ya que un límite demasiado alto puede provocar un accidente.

  Si el nuevo límite es demasiado bajo en la profundidad de recursividad actual, se genera una excepción `RecursionError`.

  Distinto en la versión 3.5.1: A la excepción `RecursionError` ahora se lanza si el nuevo límite es demasiado bajo en la profundidad de recursión actual.

`sys.``setswitchinterval`(interval)

  Establece el intervalo de cambio de hilo del intérprete (en segundos). Este valor de punto flotante determina la duración ideal de los «segmentos de tiempo» asignados a los subprocesos de Python que se ejecutan simultáneamente. Tenga en cuenta que el valor real puede ser mayor, especialmente si se utilizan funciones o métodos internos de larga duración. Además, qué hilo se programa al final del intervalo es decisión del sistema operativo. El intérprete no tiene su propio programador.

  Nuevo en la versión 3.2.

`sys.``settrace`(tracefunc)

  Configura la función de seguimiento del sistema, que le permite implementar un depurador de código fuente de Python en Python. La función es específica del hilo; para que un depurador admita múltiples subprocesos, debe registrar una función de seguimiento usando `settrace()` para cada subproceso que se depura o use `threading.settrace()`.

  Las funciones de seguimiento deben tener tres argumentos: frame, event y arg. frame es el marco de pila actual. event es una cadena de caracteres: `'call'`, `'line'`, `'return'`, `'exception'` or `'opcode'`. arg depende del tipo de evento.

  La función de rastreo se invoca (con event establecido en `'call'`) cada vez que se ingresa un nuevo ámbito local; debe retornar una referencia a una función de rastreo local que se usará para el nuevo alcance, o `None` si no se debe rastrear el alcance.

  La función de seguimiento local debe retornar una referencia a sí misma (o a otra función para realizar un seguimiento adicional en ese ámbito), o `None` para desactivar el seguimiento en ese ámbito.

  Si se produce algún error en la función de seguimiento, se desarmará, al igual que se llama a `settrace(None)`.

  Los eventos tienen el siguiente significado:

  `'call'`

    Se llama a una función (o se ingresa algún otro bloque de código). Se llama a la función de rastreo global; arg es `None`; el valor de retorno especifica la función de rastreo local.

  `'line'`

    El intérprete está a punto de ejecutar una nueva línea de código o volver a ejecutar la condición de un bucle. Se llama a la función de rastreo local; arg es `None`; el valor de retorno especifica la nueva función de rastreo local. Consulte `Objects/lnotab_notes.txt` para obtener una explicación detallada de cómo funciona. Los eventos por línea se pueden deshabilitar para un marco estableciendo `f_trace_lines` to `False` en ese marco.

  `'return'`

    Una función (u otro bloque de código) está a punto de regresar. Se llama a la función de rastreo local; arg es el valor que se retornará, o `None` si el evento es causado por una excepción. Se ignora el valor de retorno de la función de seguimiento.

  `'exception'`

    Ha ocurrido una excepción. Se llama a la función de rastreo local; arg es una tupla `(exception, value, traceback)`; el valor de retorno especifica la nueva función de rastreo local.

  `'opcode'`

    El intérprete está a punto de ejecutar un nuevo código de operación (ver `dis` para detalles del código de operación). Se llama a la función de rastreo local; arg es `None`; el valor de retorno especifica la nueva función de rastreo local. Los eventos por código de operación no se emiten de forma predeterminada: deben solicitarse explícitamente configurando `f_trace_opcodes` en `True` en el marco.

  Tenga en cuenta que como una excepción se propaga a lo largo de la cadena de llamadas de funciones, se lanza un evento de `'excepción'` en cada nivel.

  Para un uso más detallado, es posible establecer una función de seguimiento asignando `frame.f_trace = tracefunc` explícitamente, en lugar de confiar en que se establezca indirectamente a través del valor de retorno de una función de seguimiento ya instalada. Esto también es necesario para activar la función de seguimiento en el marco actual, lo cual `settrace()` no funciona. Tenga en cuenta que para que esto funcione, se debe haber instalado una función de rastreo global con `settrace()` para habilitar la maquinaria de rastreo en tiempo de ejecución, pero no necesita ser la misma función de rastreo (por ejemplo, podría ser una función de rastreo de sobrecarga baja que simplemente retorna `None` para deshabilitarse inmediatamente en cada cuadro).

  Para obtener más información sobre los objetos de código y marco, consulte Jerarquía de tipos estándar.

  Lanza un auditing event `sys.settrace` sin argumentos.

  CPython implementation detail: La función `settrace()` está pensada únicamente para implementar depuradores, perfiladores, herramientas de cobertura y similares. Su comportamiento es parte de la plataforma de implementación, en lugar de parte de la definición del lenguaje y, por lo tanto, es posible que no esté disponible en todas las implementaciones de Python.

  Distinto en la versión 3.7: Se agregó el tipo de evento `'opcode'`; atributos `f_trace_lines` y `f_trace_opcodes` agregados a los marcos (frames)

`sys.``set_asyncgen_hooks`(firstiter, finalizer)

  Acepta dos argumentos de palabras clave opcionales que son invocables que aceptan un asynchronous generator iterator como argumento. Se llamará al firstiter invocable cuando se repita un generador asincrónico por primera vez. Se llamará al finalizer cuando un generador asincrónico esté a punto de ser recolectado como basura.

  Lanza un auditing event `sys.set_asyncgen_hooks_firstiter` sin argumentos.

  Lanza un auditing event `sys.set_asyncgen_hooks_finalizer` sin argumentos.

  Se lanzan dos eventos de auditoría porque la API subyacente consta de dos llamadas, cada una de las cuales debe generar su propio evento.

  Nuevo en la versión 3.6: Ver PEP 525 para más detalles, y para un ejemplo de referencia de un método finalizer ver la implementación de `asyncio.Loop.shutdown_asyncgens` en Lib/asyncio/base_events.py

  Nota

  Esta función se ha añadido de forma provisional (consulte PEP 411 para obtener más detalles).

`sys.``set_coroutine_origin_tracking_depth`(depth)

  Permite habilitar o deshabilitar el seguimiento de origen de rutina. Cuando está habilitado, el atributo `cr_origin` en los objetos de corrutina contendrá una tupla de (nombre de archivo, número de línea, nombre de función) tuplas que describen el rastreo donde se creó el objeto de corrutina, con la llamada más reciente primero. Cuando esté deshabilitado, `cr_origin` será None.

  Para habilitarlo, pase un valor de depth mayor que cero; esto establece el número de fotogramas cuya información será capturada. Para deshabilitar, pase set depth a cero.

  Esta configuración es específica de cada hilo.

  Nuevo en la versión 3.7.

  Nota

  Esta función se ha añadido de forma provisional (consulte PEP 411 para obtener más detalles). Úsela sólo para fines de depuración.

`sys.``_enablelegacywindowsfsencoding`()

  Cambia la codificación predeterminada del sistema de archivos y el modo de errores a “mbcs” y “replace” respectivamente, para mantener la coherencia con las versiones de Python anteriores a la 3.6.

  Esto es equivalente a definir la variable de entorno `PYTHONLEGACYWINDOWSFSENCODING` antes de iniciar Python.

  Disponibilidad: Windows.

  Nuevo en la versión 3.6: Consulte PEP 529 para obtener más detalles.

`sys.``stdin`
`sys.``stdout`
`sys.``stderr`

  Objetos de archivo utilizado por el intérprete para entradas, salidas y errores estándar:

  - `stdin` se usa para todas las entradas interactivas (incluidas las llamadas a `input()`);

  - `stdout` se usa para la salida de `print()` y expression y para las solicitudes de `input()`;

  - Las propias indicaciones del intérprete y sus mensajes de error van a `stderr`.

  Estos flujos son regulares archivos de texto como los retornados por la función `open()`. Sus parámetros se eligen de la siguiente manera:

  - La codificación de caracteres depende de la plataforma. Las plataformas que no son de Windows utilizan la codificación local (consulte `locale.getpreferredencoding()`).

    En Windows, se usa UTF-8 para el dispositivo de consola. Los dispositivos que no son caracteres, como archivos de disco y tuberías, utilizan la codificación de la configuración regional del sistema (es decir, la página de códigos ANSI). Los dispositivos de caracteres que no son de consola, como NUL (es decir, donde `isatty()` retorna `True`) utilizan el valor de las páginas de códigos de entrada y salida de la consola al inicio, respectivamente para stdin y stdout/stderr. Este valor predeterminado es la codificación de la configuración regional del sistema si el proceso no se adjunta inicialmente a una consola.

    El comportamiento especial de la consola se puede anular configurando la variable de entorno PYTHONLEGACYWINDOWSSTDIO antes de iniciar Python. En ese caso, las páginas de códigos de la consola se utilizan como para cualquier otro dispositivo de caracteres.

    En todas las plataformas, puede anular la codificación de caracteres configurando la variable de entorno `PYTHONIOENCODING` antes de iniciar Python o usando la nueva `-X` `utf8` opción de línea de comando y `PYTHONUTF8` variable de entorno. Sin embargo, para la consola de Windows, esto solo se aplica cuando `PYTHONLEGACYWINDOWSSTDIO` también está configurado.

  - Cuando es interactivo, el flujo de `stdout` se almacena en búfer de línea. En caso contrario, se almacena en búfer de bloque como los archivos de texto normales. El flujo `stderr` tiene un búfer de línea en ambos casos. Puede hacer que ambos flujos no tengan búfer pasando la opción de línea de comandos `-u` o estableciendo la variable de entorno `PYTHONUNBUFFERED`.

  Distinto en la versión 3.9: Ahora, `stderr` no interactivo tiene búfer de línea en lugar de búfer completo.

  Nota

  Para escribir o leer datos binarios desde/hacia los flujos estándar, use el objeto binario subyacente `buffer`. Por ejemplo, para escribir bytes en `stdout`, use `sys.stdout.buffer.write(b'abc')`.

  Sin embargo, si está escribiendo una biblioteca (y no controla en qué contexto se ejecutará su código), tenga en cuenta que las transmisiones estándar pueden reemplazarse con objetos similares a archivos como `io.StringIO` que no admiten el atributo `buffer`.

`sys.``__stdin__`
`sys.``__stdout__`
`sys.``__stderr__`

  Estos objetos contienen los valores originales de `stdin`, `stderr` y `stdout` al inicio del programa. Se utilizan durante la finalización y podrían ser útiles para imprimir en el flujo estándar real sin importar si el objeto `sys.std*` ha sido redirigido.

  También se puede utilizar para restaurar los archivos reales a objetos de archivo de trabajo conocidos en caso de que se hayan sobrescrito con un objeto roto. Sin embargo, la forma preferida de hacer esto es guardar explícitamente la secuencia anterior antes de reemplazarla y restaurar el objeto guardado.

  Nota

  En algunas condiciones, `stdin`, `stdout` y `stderr`, así como los valores originales `__stdin__`, `__stdout__` y `__stderr__` pueden ser `None` . Suele ser el caso de las aplicaciones GUI de Windows que no están conectadas a una consola y las aplicaciones Python que comienzan con pythonw.

`sys.``thread_info`

  Un named tuple que contiene información sobre la implementación del hilo.

  Atributo | Explicación
  --- | ---
  `name` | Nombre de la implementación de hilos (thread implementation): `'nt'`: hilos de Windows `'pthread'`: hilos de POSIX `'solaris'`: hilos de Solaris
  `lock` | Nombre de la implementación de bloqueo (lock implementation): `'semaphore'`: un bloqueo que utiliza un semáforo `'mutex+cond'`: un bloqueo que utiliza un mutex y una variable de condición `None` si esta información es desconocida
  `version` | Nombre y versión de la biblioteca de subprocesos. Es una cadena de caracteres, o `None` si se desconoce esta información.

  Nuevo en la versión 3.3.

`sys.``tracebacklimit`

  Cuando esta variable se establece en un valor entero, determina el número máximo de niveles de información de rastreo que se imprime cuando ocurre una excepción no controlada. El valor predeterminado es `1000`. Cuando se establece en `0` o menos, toda la información de rastreo se suprime y solo se imprimen el tipo y el valor de excepción.

`sys.``unraisablehook`(unraisable, /)

  Maneja una excepción que no se puede lanzar.

  Se llama cuando se ha producido una excepción pero no hay forma de que Python la maneje. Por ejemplo, cuando un destructor lanza una excepción o durante la recolección de basura (`gc.collect()`).

  El argumento unraisable tiene los siguientes atributos:

  - exc_type: Tipo de excepción.

  - exc_value: Valor de excepción, puede ser `None`.

  - exc_traceback: Rastreo de excepción, puede ser `None`.

  - err_msg: Mensaje de error, puede ser `None`.

  - objeto: Objeto que causa la excepción, puede ser `None`.

  Los formatos de gancho predeterminados err_msg y object como: `f'{err_msg}:{object!R}'`; use el mensaje de error «Excepción ignorada en» si err_msg es `None`.

  `sys.unraisablehook()` se puede anular para controlar cómo se manejan las excepciones que no se pueden evaluar.

  Almacenar exc_value usando un gancho personalizado puede crear un ciclo de referencia. Debe borrarse explícitamente para romper el ciclo de referencia cuando la excepción ya no sea necesaria.

  Almacenar object usando un gancho personalizado puede resucitarlo si se establece en un objeto que se está finalizando. Evite almacenar object después de que se complete el gancho personalizado para evitar resucitar objetos.

  Véase también `excepthook()` que maneja excepciones no capturadas.

  Lanza un evento de auditoría `sys.unraisablehook` con argumentos `hook`, `unraisable` cuando ocurre una excepción que no se puede manejar. El objeto `no lanzable` es el mismo que se pasará al gancho. Si no se ha colocado ningún gancho, `hook` puede ser `None`.

  Nuevo en la versión 3.8.

`sys.``version`

  Una cadena de caracteres que contiene el número de versión del intérprete de Python más información adicional sobre el número de compilación y el compilador utilizado. Esta cadena se muestra cuando se inicia el intérprete interactivo. No extraiga información de la versión de él, en su lugar, use `version_info` y las funciones proporcionadas por el módulo `platform`.

`sys.``api_version`

  La versión de API C para este intérprete. Los programadores pueden encontrar esto útil al depurar conflictos de versiones entre Python y módulos de extensión.

`sys.``version_info`

  Una tupla que contiene los cinco componentes del número de versión: major, minor, micro, releaselevel, y serial. Todos los valores excepto releaselevel son números enteros; el nivel de lanzamiento es `'alpha'`, `'beta'`, `'candidate'`, o `'final'`. El valor de `version_info` correspondiente a la versión 2.0 de Python es `(2, 0, 0, 'final', 0)`. También se puede acceder a los componentes por su nombre, por lo que `sys.version_info[0]` es equivalente a `sys.version_info.major` y así sucesivamente.

  Distinto en la versión 3.1: Se agregaron atributos de componentes con nombre.

`sys.``warnoptions`

  Este es un detalle de implementación del marco de advertencias; No modifique este valor. Consulte el módulo `warnings` para obtener más información sobre el marco de advertencias.

`sys.``winver`

  El número de versión utilizado para formar claves de registro en plataformas Windows. Esto se almacena como recurso de cadena 1000 en la DLL de Python. El valor son normalmente los primeros tres caracteres de `version`. Se proporciona en el módulo `sys` con fines informativos; la modificación de este valor no tiene ningún efecto sobre las claves de registro que utiliza Python.

  Disponibilidad: Windows.

`sys.``_xoptions`

  Un diccionario de las diversas flags específicas de la implementación pasa a través de la opción de línea de comandos `-X`. Los nombres de las opciones se asignan a sus valores, si se dan explícitamente, o a `True`. Ejemplo:

      $ ./python -Xa=b -Xc
      Python 3.2a3+ (py3k, Oct 16 2010, 20:14:50)
      [GCC 4.4.3] on linux2
      Type "help", "copyright", "credits" or "license" for more information.
      >>> import sys
      >>> sys._xoptions
      {'a': 'b', 'c': True}

  CPython implementation detail: Esta es una forma específica de CPython de acceder a las opciones que se pasan a través de `-X`. Otras implementaciones pueden exportarlos a través de otros medios, o no exportarlos.

  Nuevo en la versión 3.2.

Citas

C99

  ISO/IEC 9899:1999. «Programming languages – C.» A public draft of this standard is available at http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf.