# 1. Línea de comandos y entorno

El intérprete de CPython analiza la línea de comandos y el entorno en busca de varias configuraciones.

CPython implementation detail: Los esquemas de línea de comandos de otras implementaciones pueden diferir. Véase Implementaciones alternativas para obtener más recursos.

## 1.1. Línea de comando

Al invocar Python, puede especificar cualquiera de estas opciones:

    python [-bBdEhiIOqsSuvVWx?] [-c command | -m module-name | script | - ] [args]

El caso de uso más común es, por supuesto, una simple invocación de un script:

    python myscript.py

### 1.1.1. Opciones de interfaz

La interfaz del intérprete es similar a la del shell UNIX, pero proporciona algunos métodos adicionales de invocación:

- Cuando se llama con entrada estándar conectada a un dispositivo tty, solicita comandos y los ejecuta hasta que se lea un EOF (un carácter de fin de archivo, puede producirlo con `Ctrl-D` en UNIX o `Ctrl-Z, Enter` en Windows).

- Cuando se llama con un argumento de nombre de archivo o con un archivo como entrada estándar, lee y ejecuta un script de ese archivo.

- Cuando se llama con un argumento de nombre de directorio, lee y ejecuta un script con el nombre adecuado desde ese directorio.

- Cuando se llama con `-c comando`, ejecuta las instrucciones de Python dadas como command. Aquí comando puede contener varias instrucciones separadas por nuevas líneas. ¡El espacio en blanco principal es significativo en las instrucciones de Python!

- Cuando se llama con `-m module-name`, el módulo dado se encuentra en la ruta del módulo Python y se ejecuta como un script.

En el modo no interactivo, toda la entrada se analiza antes de ejecutarse.

Una opción de interfaz termina la lista de opciones consumidas por el intérprete, todos los argumentos consecutivos terminarán en `sys.argv` – tenga en cuenta que el primer elemento, subíndice cero (`sys.argv[0]`), es una cadena que refleja el origen del programa.

`-c``<command>`

  Ejecute el código de Python en comando. comando puede ser una o más sentencias separadas por nuevas líneas, con espacio en blanco inicial significativo como en el código normal del módulo.

  Si se proporciona esta opción, el primer elemento de `sys.argv` será `"-c"` y el directorio actual se agregará al inicio de `sys.path` (permitiendo que los módulos de ese directorio se importen como módulos de nivel superior).

  Lanza un auditing event `cpython.run_command` con el argumento `command`.

`-m``<module-name>`

  Busque `sys.path` para el módulo con nombre y ejecute su contenido como el módulo `__main__`.

  Dado que el argumento es un nombre módulo, no debe dar una extensión de archivo (`.py`). El nombre del módulo debe ser un nombre de módulo Python absoluto válido, pero es posible que la implementación no siempre lo aplique (por ejemplo, puede permitirle usar un nombre que incluya un guión).

  También se permiten los nombres de paquetes (incluidos los paquetes de espacio de nombres). Cuando se proporciona un nombre de paquete en lugar de un módulo normal, el intérprete ejecutará `<pkg>.__main__` como módulo principal. Este comportamiento es deliberadamente similar al manejo de directorios y archivos zip que se pasan al intérprete como argumento del script.

  Nota

  Esta opción no se puede utilizar con módulos integrados y módulos de extensión escritos en C, ya que no tienen archivos de módulo Python. Sin embargo, todavía se puede utilizar para módulos precompilados, incluso si el archivo de origen original no está disponible.

  Si se da esta opción, el primer elemento de `sys.argv` será la ruta de acceso completa al archivo de módulo (mientras se encuentra el archivo de módulo, el primer elemento se establecerá en `"-m"`). Al igual que con la opción `-c`, el directorio actual se agregará al inicio de `sys.path`.

  `-I` se puede utilizar para ejecutar el script en modo aislado donde `sys.path` no contiene ni el directorio actual ni el directorio site-packages del usuario. También se omiten todas las variables de entorno `PYTHON*`.

  Muchos módulos de biblioteca estándar contienen código que se invoca en su ejecución como script. Un ejemplo es el módulo `timeit`:

      python -m timeit -s 'setup here' 'benchmarked code here'
      python -m timeit -h # for details

  Retorna un auditing event `cpython.run_module` con el argumento `nombre-módulo`.

  Ver también

  `runpy.run_module()`

    Funcionalidad equivalente directamente disponible para el código Python

  PEP 338 – Ejecución de módulos como scripts

  Distinto en la versión 3.1: Proporcione el nombre del paquete para ejecutar un submódulo `__main__`.

  Distinto en la versión 3.4: paquetes de espacio de nombres también son compatibles

`-`

  Leer comandos de entrada estándar (`sys.stdin`). Si la entrada estándar es un terminal, `-i` está implícita.

  Si se da esta opción, el primer elemento de `sys.argv` será `"-"` y el directorio actual se agregará al inicio de `sys.path`.

  Genera un evento auditing event `cpython.run_stdin` sin argumentos.

`<script>`

  Ejecute el código Python contenido en script, que debe ser una ruta de acceso del sistema de archivos (absoluta o relativa) que haga referencia a un archivo Python, un directorio que contenga un archivo `__main__.py` o un archivo zip que contenga un archivo `__main__.py`.

  Si se proporciona esta opción, el primer elemento de `sys.argv` será el nombre del script como se indica en la línea de comandos.

  Si el nombre del script hace referencia directamente a un archivo Python, el directorio que contiene ese archivo se agrega al inicio de `sys.path`, y el archivo se ejecuta como el módulo `__main__`.

  Si el nombre del script hace referencia a un directorio o zipfile, el nombre del script se agrega al inicio de `sys.path` y el archivo `__main__.py` en esa ubicación se ejecuta como el módulo `__main__`.

  `-I` se puede utilizar para ejecutar el script en modo aislado donde `sys.path` no contiene ni el directorio del script ni el directorio site-packages del usuario. También se omiten todas las variables de entorno `PYTHON*`.

  Lanza un auditing event `cpython.run_file` con el argumento `filename`.

  Ver también

  `runpy.run_path()`

    Funcionalidad equivalente directamente disponible para el código Python

Si no se da ninguna opción de interfaz, `-i` está implícita, `sys.argv[0]` es una cadena vacía (`"`) y el directorio actual se agregará al inicio de `sys.path`. Además, la finalización de tabulación y la edición del historial se habilitan automáticamente, si están disponibles en su plataforma (consulte Configuración de Readline).

Ver también

Invocando al intérprete

Distinto en la versión 3.4: Habilitación automática de la finalización de pestañas y edición del historial.

### 1.1.2. Opciones genéricas

`-?```
`-h```
`--help```

  Imprima una breve descripción de todas las opciones de la línea de comandos.

`-V```
`--version```

  Imprima el número de versión de Python y salga. Ejemplo de salida podría ser:

      Python 3.8.0b2+

  Cuando se le dé dos veces, imprima más información sobre la compilación, como:

      Python 3.8.0b2+ (3.8:0c076caaa8, Apr 20 2019, 21:55:00)
      [GCC 6.2.0 20161005]

  Nuevo en la versión 3.6: La opción `-VV`.

### 1.1.3. Opciones diversas

`-b```

  Emitir una advertencia al comparar `bytes` o `bytearray` con `str` o `bytes` con `int`. Emitir un error cuando la opción se da dos veces (`-bb`).

  Distinto en la versión 3.5: Afecta a las comparaciones de `bytes` con `int`.

`-B```

  Si se da, Python no intentará escribir archivos `.pyc` en la importación de módulos de origen. Véase también `PYTHONDONTWRITEBYTECODE`.

`--check-hash-based-pycs` `default|always|never`

  Controle el comportamiento de validación de los archivos `.pyc` basados en hash. Véase Invalidación del código de bytes en caché. Cuando se establece en `default`, los archivos de caché de código de bytes basados en hash marcados y desmarcados se validan según su semántica predeterminada. Cuando se establece en `always`, todos los archivos basados en hash `.pyc`, ya estén marcados o desmarcados, se validan con su archivo de origen correspondiente. Cuando se establece en `never`, los archivos basados en hash `.pyc` no se validan con sus archivos de origen correspondientes.

  Esta opción no afecta a la semántica de los archivos `.pyc` basados en la marca de tiempo.

`-d```

  Active la salida de depuración del analizador (solo para expertos, dependiendo de las opciones de compilación). Véase también `PYTHONDEBUG`.

`-E```

  Ignore todas las variables de entorno `PYTHON*`, por ejemplo `PYTHONPATH` y `PYTHONHOME`, que podrían establecerse.

`-i```

  Cuando se pasa un script como primer argumento o se utiliza la opción `-c`, entre en modo interactivo después de ejecutar el script o el comando, incluso cuando `sys.stdin` no parece ser un terminal. El archivo `PYTHONSTARTUP` no se lee.

  Esto puede ser útil para inspeccionar variables globales o un seguimiento de pila cuando un script genera una excepción. Véase también `PYTHONINSPECT`.

`-I```

  Ejecute Python en modo aislado. Esto también implica -E y -s. En modo aislado `sys.path` no contiene ni el directorio del script ni el directorio site-packages del usuario. También se omiten todas las variables de entorno `PYTHON*`. Se pueden imponer restricciones adicionales para evitar que el usuario inyecte código malicioso.

  Nuevo en la versión 3.4.

`-O```

  Quite las instrucciones assert y cualquier código condicionado al valor de `__debug__`. Aumente el nombre de archivo para los archivos compilados (bytecode) agregando `.opt-1` antes de la extensión `.pyc` (consulte PEP 488). Véase también `PYTHONOPTIMIZE`.

  Distinto en la versión 3.5: Modifique los nombres de archivo `.pyc` según PEP 488.

`-OO```

  Haga `-O` y también deseche las docstrings. Aumente el nombre de archivo para los archivos compilados (bytecode) agregando `.opt-2` antes de la extensión `.pyc` (consulte PEP 488).

  Distinto en la versión 3.5: Modifique los nombres de archivo `.pyc` según PEP 488.

`-q```

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

  Nuevo en la versión 3.2.

`-R```

  Active la aleatorización de hash. Esta opción solo tiene efecto si la variable de entorno `PYTHONHASHSEED` está establecida en `0`, ya que la aleatorización de hash está habilitada de forma predeterminada.

  En versiones anteriores de Python, esta opción activa la aleatorización de hash, de modo que los valores `__hash__()` de los objetos str y bytes son «saladas» con un valor aleatorio impredecible. Aunque permanecen constantes dentro de un proceso de Python individual, no son predecibles entre invocaciones repetidas de Python.

  La aleatorización de hash está diseñada para proporcionar protección contra una denegación de servicio causada por entradas cuidadosamente elegidas que aprovechan el peor rendimiento de una construcción de dictado, la complejidad de O(n-2). Consulte http://www.ocert.org/advisories/ocert-2011-003.html para obtener más información.

  `PYTHONHASHSEED` le permite establecer un valor fijo para el secreto de inicialización hash.

  Distinto en la versión 3.7: La opción ya no se omite.

  Nuevo en la versión 3.2.3.

`-s```

  No agregue el `user site-packages directory` a `sys.path`.

  Ver también

  PEP 370 – Directorio de paquetes de sitio por usuario

`-S```

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

`-u```

  Forzar que las corrientes stdout y stderr no estén en búfer. Esta opción no tiene ningún efecto en la secuencia stdin.

  Véase también `PYTHONUNBUFFERED`.

  Distinto en la versión 3.7: La capa de texto de las secuencias stdout y stderr ahora no está en búfer.

`-v```

  Imprima un mensaje cada vez que se inicialice un módulo, mostrando el lugar (nombre de archivo o módulo integrado) desde el que se carga. Cuando se le da dos veces (`-vv`), imprima un mensaje para cada archivo que se comprueba al buscar un módulo. También proporciona información sobre la limpieza del módulo en la salida. Véase también `PYTHONVERBOSE`.

`-W` `arg`

  Control de advertencia. La maquinaria de advertencia de Python por defecto imprime mensajes de advertencia en `sys.stderr`. Un mensaje de advertencia típico tiene el siguiente formulario:

      file:line: category: message

  De forma predeterminada, cada advertencia se imprime una vez para cada línea de origen donde se produce. Esta opción controla la frecuencia con la que se imprimen las advertencias.

  Se pueden dar varias opciones `-W`; cuando una advertencia coincide con más de una opción, se realiza la acción para la última opción de coincidencia. No se omiten las opciones `-W` (aunque se imprime un mensaje de advertencia sobre opciones no válidas cuando se emite la primera advertencia).

  Las advertencias también se pueden controlar utilizando la variable de entorno `PYTHONWARNINGS` y desde un programa Python utilizando el módulo `warnings`.

  La configuración más sencilla aplica una acción determinada incondicionalmente a todas las advertencias emitidas por un proceso (incluso aquellas que de otro modo se ignoran de forma predeterminada):

      -Wdefault  # Warn once per call location
      -Werror    # Convert to exceptions
      -Walways   # Warn every time
      -Wmodule   # Warn once per calling module
      -Wonce     # Warn once per Python process
      -Wignore   # Never warn

  Los nombres de acción se pueden abreviar como se desee (por ejemplo, `-Wi`, `-Wd`, `-Wa`, `-We`) y el intérprete los resolverá con el nombre de acción adecuado.

  Consulte El filtro de advertencias y Descripción de los filtros de advertencia para obtener más detalles.

`-x```

  Omita la primera línea de la fuente, permitiendo el uso de formas que no sean de Unix de `#!cmd`. Esto está destinado a un hackeo específico de DOS solamente.

`-X```

  Reservado para varias opciones específicas de la implementación. CPython define actualmente los siguientes valores posibles:

  - `-X faulthandler` para habilitar `faulthandler`;

  - `-X showrefcount` para generar el recuento total de referencias y el número de bloques de memoria utilizados cuando finalice el programa o después de cada instrucción en el intérprete interactivo. Esto sólo funciona en compilaciones de depuración.

  - `-X tracemalloc` para iniciar el seguimiento de las asignaciones de memoria de Python mediante el módulo `tracemalloc`. De forma predeterminada, solo el marco más reciente se almacena en un seguimiento de un seguimiento. Utilice `-X tracemalloc-NFRAME` para iniciar el seguimiento con un límite de rastreo de marcos NFRAME. Consulte el `tracemalloc.start()` para obtener más información.

  - `-X showalloccount` para generar el recuento total de objetos asignados para cada tipo cuando finalice el programa. Esto sólo funciona cuando Python se creó con `COUNT_ALLOCS` definido.

  - `-X importtime` para mostrar cuánto tiempo tarda cada importación. Muestra el nombre del módulo, el tiempo acumulado (incluidas las importaciones anidadas) y el tiempo de autoestima (excluyendo las importaciones anidadas). Tenga en cuenta que su salida puede romperse en aplicaciones multiproceso. El uso típico es `python3 -X importtime -c 'import asyncio'`. Véase también `PYTHONPROFILEIMPORTTIME`.

  - `-X dev`: habilite el «modo de desarrollo» de CPython, introduciendo comprobaciones de tiempo de ejecución adicionales que son demasiado costosas para habilitarse de forma predeterminada. No debe ser más detallado que el valor predeterminado si el código es correcto: las nuevas advertencias solo se emiten cuando se detecta un problema. Efecto del modo de desarrollador:

    - Agregue el filtro de advertencia `default`, como `-W` `default`.

    - Instale los enlaces de depuración en los asignadores de memoria: vea la función `PyMem_SetupDebugHooks()` C.

    - Habilite el módulo `faulthandler` para volcar el rastreo de Python en un bloqueo.

    - Habilite asyncio debug mode.

    - Establezca el atributo `sys.flags.dev_mode` de `sys.flags` en `True`.

    - `io.IOBase` destructor registra las excepciones `close()`.

  - `-X utf8` habilita el modo UTF-8 para las interfaces del sistema operativo, reemplazando el modo predeterminado compatible con la configuración regional. `-X utf8-0` desactiva explícitamente el modo UTF-8 (incluso cuando de lo contrario se activaría automáticamente). Consulte `PYTHONUTF8` para obtener más detalles.

  - `-X pycache_prefix=PATH` permite escribir archivos `.pyc` en un árbol paralelo enraizado en el directorio dado en lugar de en el árbol de código. Véase también `PYTHONPYCACHEPREFIX`.

  También permite pasar valores arbitrarios y recuperarlos a través del diccionario `sys._xoptions`.

  Distinto en la versión 3.2: Se ha añadido la opción `-X`.

  Nuevo en la versión 3.3: La opción `-X faulhandler`.

  Nuevo en la versión 3.4: Las opciones `-X showrefcount` y `-X tracemalloc`.

  Nuevo en la versión 3.6: La opción `-X showalloccount`.

  Nuevo en la versión 3.7: Las opciones `-X importtime`, `-X dev` y `-X utf8`.

  Nuevo en la versión 3.8: La opción `-X pycache_prefix`. La opción `-X dev` ahora registra las excepciones `close()` en el destructor `io.IOBase`.

### 1.1.4. Opciones que no debe usar

`-J```

  Reservado para su uso por Jython.

## 1.2. Variables de entorno

Estas variables de entorno influyen en el comportamiento de Python, se procesan antes de que los modificadores de línea de comandos distintos de -E o -I. Es habitual que los modificadores de línea de comandos anulen variables de entorno donde hay un conflicto.

`PYTHONHOME`

  Cambie la ubicación de las bibliotecas estándar de Python. De forma predeterminada, las bibliotecas se buscan en `prefix/lib/pythonversion` y `exec_prefix/lib/pythonversion`, donde `prefix` y `exec_prefix` son directorios dependientes de la instalación, ambos predeterminados: file:/usr/local.

  Cuando `PYTHONHOME` se establece en un único directorio, su valor reemplaza tanto al `prefix` como a `exec_prefix`. Para especificar valores diferentes para estos, establezca `PYTHONHOME` en `prefix:exec_prefix`.

`PYTHONPATH`

  Aumente la ruta de búsqueda predeterminada para los archivos de módulo. El formato es el mismo que el de shell `PATH`: uno o más nombres de ruta de directorio separados por `os.pathsep` (por ejemplo, dos puntos en Unix o punto y coma en Windows). Los directorios inexistentes se omiten silenciosamente.

  Además de los directorios normales, las entradas individuales `PYTHONPATH` pueden referirse a archivos zip que contienen módulos Python puros (ya sea en forma de origen o compilado). Los módulos de extensión no se pueden importar desde zipfiles.

  La ruta de búsqueda predeterminada depende de la instalación, pero generalmente comienza con `prefix/lib/pythonversion` (consulte `PYTHONHOME` arriba). Es always anexado a `PYTHONPATH`.

  Se insertará un directorio adicional en la ruta de búsqueda delante de `PYTHONPATH` como se describió anteriormente en Opciones de interfaz. La ruta de búsqueda se puede manipular desde un programa Python como la variable `sys.path`.

`PYTHONSTARTUP`

  Si este es el nombre de un archivo legible, los comandos de Python de ese archivo se ejecutan antes de que el primer mensaje se muestre en modo interactivo. El archivo se ejecuta en el mismo espacio de nombres donde se ejecutan comandos interactivos para que los objetos definidos o importados en él se puedan usar sin calificación en la sesión interactiva. También puede cambiar las solicitudes `sys.ps1` y `sys.ps2` y el enlace `sys.__interactivehook__` en este archivo.

  Lanza auditing event `cpython.run_startup` con el argumento `filename`.

`PYTHONOPTIMIZE`

  Si se establece en una cadena no vacía, equivale a especificar la opción `-O`. Si se establece en un entero, es equivalente a especificar `-O` varias veces.

`PYTHONBREAKPOINT`

  Si se establece, nombra un nombre que se puede llamar mediante la notación de trayecto de puntos. El módulo que contiene el invocable se importará y, a continuación, el invocable se ejecutará por la implementación predeterminada de `sys.breakpointhook()` que a su vez se llama por incorporado `breakpoint()`. Si no se establece o se establece en la cadena vacía, es equivalente al valor «pdb.set_trace». Establecer esto en la cadena «0» hace que la implementación predeterminada de `sys.breakpointhook()` no haga nada más que retornar inmediatamente.

  Nuevo en la versión 3.7.

`PYTHONDEBUG`

  Si se establece en una cadena no vacía, equivale a especificar la opción `-d`. Si se establece en un entero, equivale a especificar `-d` varias veces.

`PYTHONINSPECT`

  Si se establece en una cadena no vacía, equivale a especificar la opción `-i`.

  Esta variable también se puede modificar mediante código Python mediante `os.environ` para forzar el modo de inspección en la terminación del programa.

`PYTHONUNBUFFERED`

  Si se establece en una cadena no vacía, equivale a especificar la opción `-u`.

`PYTHONVERBOSE`

  Si se establece en una cadena no vacía, equivale a especificar la opción `-v`. Si se establece en un entero, equivale a especificar `-v` varias veces.

`PYTHONCASEOK`

  Si se establece, Python omite mayúsculas y minúsculas en las instrucciones `import`. Esto sólo funciona en Windows y OS X.

`PYTHONDONTWRITEBYTECODE`

  Si se establece en una cadena no vacía, Python no intentará escribir archivos `.pyc` en la importación de módulos de origen. Esto equivale a especificar la opción `-B`.

`PYTHONPYCACHEPREFIX`

  Si se establece, Python escribirá archivos `.pyc` en un árbol de directorios reflejado en esta ruta de acceso, en lugar de en directorios `__pycache__` dentro del árbol de origen. Esto equivale a especificar la opción `-X` `pycache_prefix=PATH`.

  Nuevo en la versión 3.8.

`PYTHONHASHSEED`

  Si esta variable no se establece o se establece en `random`, se utiliza un valor aleatorio para sembrar los hashes de los objetos str y bytes.

  Si `PYTHONHASHSEED` se establece en un valor entero, se utiliza como una semilla fija para generar el hash() de los tipos cubiertos por la aleatorización hash.

  Su propósito es permitir el hash repetible, como para las autocomprobaciónes para el propio intérprete, o permitir que un grupo de procesos python comparta valores hash.

  El entero debe ser un número decimal en el intervalo [0,4294967295]. Especificar el valor 0 deshabilitará la aleatorización de hash.

  Nuevo en la versión 3.2.3.

`PYTHONIOENCODING`

  Si se establece antes de ejecutar el intérprete, invalida la codificación utilizada para stdin/stdout/stderr, en la sintaxis `encodingname:errorhandler`. Tanto las partes `encodingname` como `:errorhandler` son opcionales y tienen el mismo significado que en `str.encode()`.

  Para stderr, se omite la parte `:errorhandler`; el manejador siempre será `'backslashreplace'`.

  Distinto en la versión 3.4: La parte `encodingname` ahora es opcional.

  Distinto en la versión 3.6: En Windows, la codificación especificada por esta variable se omite para los búferes de consola interactivos a menos que también se especifique `PYTHONLEGACYWINDOWSSTDIO`. Los archivos y canalizaciones redirigidos a través de las corrientes estándar no se ven afectados.

`PYTHONNOUSERSITE`

  Si se establece, Python no agregará `user site-packages directory` a `sys.path`.

  Ver también

  PEP 370 – Directorio de paquetes de sitio por usuario

`PYTHONUSERBASE`

  Define el `user base directory`, que se utiliza para calcular la ruta de acceso de `user site-packages directory` y Distutils installation paths para `python setup.py install --user`.

  Ver también

  PEP 370 – Directorio de paquetes de sitio por usuario

`PYTHONEXECUTABLE`

  Si se establece esta variable de entorno, `sys.argv[0]` se establecerá en su valor en lugar del valor conseguido a través del tiempo de ejecución de C. Sólo funciona en Mac OS X.

`PYTHONWARNINGS`

  Esto es equivalente a la opción `-W`. Si se establece en una cadena separada por comas, es equivalente a especificar `-W` varias veces, con filtros más adelante en la lista que tienen prioridad sobre los anteriores de la lista.

  La configuración más sencilla aplica una acción determinada incondicionalmente a todas las advertencias emitidas por un proceso (incluso aquellas que de otro modo se ignoran de forma predeterminada):

      PYTHONWARNINGS=default  # Warn once per call location
      PYTHONWARNINGS=error    # Convert to exceptions
      PYTHONWARNINGS=always   # Warn every time
      PYTHONWARNINGS=module   # Warn once per calling module
      PYTHONWARNINGS=once     # Warn once per Python process
      PYTHONWARNINGS=ignore   # Never warn

  Consulte El filtro de advertencias y Descripción de los filtros de advertencia para obtener más detalles.

`PYTHONFAULTHANDLER`

  Si esta variable de entorno se establece en una cadena no vacía, se llama a `faulthandler.enable()` al inicio: instale un controlador para `SIGSEGV`, `SIGFPE`, `SIGABRT`, `SIGBUS` y `SIGILL` para volcar el seguimiento de Python. Esto es equivalente a la opción `-X` `faulthandler`.

  Nuevo en la versión 3.3.

`PYTHONTRACEMALLOC`

  Si esta variable de entorno se establece en una cadena no vacía, comience a trazar las asignaciones de memoria de Python mediante el módulo `tracemalloc`. El valor de la variable es el número máximo de marcos almacenados en un rastreo de un seguimiento. Por ejemplo, `PYTHONTRACEMALLOC=1` almacena sólo el marco más reciente. Consulte el `tracemalloc.start()` para obtener más información.

  Nuevo en la versión 3.4.

`PYTHONPROFILEIMPORTTIME`

  Si esta variable de entorno se establece en una cadena no vacía, Python mostrará cuánto tiempo tarda cada importación. Esto equivale exactamente a establecer `-X importtime` en la línea de comandos.

  Nuevo en la versión 3.7.

`PYTHONASYNCIODEBUG`

  Si esta variable de entorno se establece en una cadena no vacía, habilite el modo debug mode del módulo `asyncio`.

  Nuevo en la versión 3.4.

`PYTHONMALLOC`

  Establezca los asignadores de memoria de Python y/o instale enlaces de depuración.

  Establezca la familia de asignadores de memoria utilizados por Python:

  - `default`: utilice default memory allocators.

  - `malloc`: utilice la función `malloc()` de la biblioteca C para todos los dominios (`PYMEM_DOMAIN_RAW`, `PYMEM_DOMAIN_MEM`, `PYMEM_DOMAIN_OBJ`).

  - `pymalloc`: utilice los dominios pymalloc allocator para `PYMEM_DOMAIN_MEM` y `PYMEM_DOMAIN_OBJ` y utilice la función `malloc()` para el dominio `PYMEM_DOMAIN_RAW`.

  Instale los ganchos del debug:

  - `debug`: instale los enlaces de depuración encima de default memory allocators.

  - `malloc_debug`: igual que `malloc` pero también instalar ganchos de depuración.

  - `pymalloc_debug`: igual que `pymalloc` pero también instalar enlaces de depuración.

  Consulte default memory allocators y la función `PyMem_SetupDebugHooks()` (instalar enlaces de depuración en los asignadores de memoria de Python).

  Distinto en la versión 3.7: Se ha añadido el asignador `"predeterminado"`.

  Nuevo en la versión 3.6.

`PYTHONMALLOCSTATS`

  Si se establece en una cadena no vacía, Python imprimirá estadísticas de pymalloc memory allocator cada vez que se crea una nueva arena de objetos pymalloc y al apagarse.

  Esta variable se omite si la variable de entorno `PYTHONMALLOC` se utiliza para forzar el asignador `malloc()` de la biblioteca C, o si Python está configurado sin compatibilidad con `pymalloc`.

  Distinto en la versión 3.6: Esta variable ahora también se puede utilizar en Python compilado en modo de versión. Ahora no tiene ningún efecto si se establece en una cadena vacía.

`PYTHONLEGACYWINDOWSFSENCODING`

  Si se establece en una cadena no vacía, el modo de codificación y errores del sistema de archivos predeterminado volverá a sus valores pre-3.6 de mbcs y replace, respectivamente. De lo contrario, se utilizan los nuevos valores predeterminados utf-8 y surrogatepass.

  Esto también se puede habilitar en tiempo de ejecución con `sys._enablelegacywindowsfsencoding()`.

  Availability: Windows.

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

`PYTHONLEGACYWINDOWSSTDIO`

  Si se establece en una cadena no vacía, no utiliza el nuevo lector y escritor de consola. Esto significa que los caracteres Unicode se codificarán de acuerdo con la página de códigos de la consola activa, en lugar de usar utf-8.

  Esta variable se omite si se redirigen las secuencias estándar (a archivos o canalizaciones) en lugar de hacer referencia a búferes de consola.

  Availability: Windows.

  Nuevo en la versión 3.6.

`PYTHONCOERCECLOCALE`

  Si se establece en el valor `0`, hace que la aplicación principal de línea de comandos de Python omita la coerción de las configuraciones regionales C y POSIX basadas en ASCII heredadas a una alternativa basada en UTF-8 más capaz.

  Si esta variable es no establecida (o se establece en un valor distinto de `0`), tampoco se establece la variable de entorno de invalidación local `LC_ALL`, y la configuración local actual notificada para la categoría `LC_CTYPE` es la configuración local `C` predeterminada, o bien la configuración local basada explícitamente en ASCII `POSIX`, entonces la CLI de Python intentará configurar las siguientes configuraciones locales para la categoría `LC_CTYPE` en el orden indicado antes de cargar el tiempo de ejecución del intérprete:

  - `C.UTF-8`

  - `C.utf8`

  - `UTF-8`

  Si la configuración de una de estas categorías de configuración local se realiza correctamente, la variable de entorno `LC_CTYPE` también se establecerá en consecuencia en el entorno de proceso actual antes de que se inicialice el tiempo de ejecución de Python. Esto garantiza que, además de ser visto tanto por el propio intérprete como por otros componentes compatibles con la configuración local que se ejecutan en el mismo proceso (como la biblioteca GNU `readline`), la configuración actualizada también se ve en los subprocesos (independientemente de si esos procesos están ejecutando o no un intérprete de Python), así como en las operaciones que consultan el entorno en lugar de la configuración regional de C actual (como la propia de Python `locale.getdefaultlocale()`).

  La configuración de una de estas configuraciones regionales (ya sea explícitamente o a través de la coerción de configuración regional implícita anterior) habilita automáticamente el `surrogateescape` error handler para `sys.stdin` y `sys.stdout` (`sys.stderr` continúa utilizando `backslashreplace` como lo hace en cualquier otra configuración local). Este comportamiento de control de secuencias se puede invalidar mediante `PYTHONIOENCODING` como de costumbre.

  Para fines de depuración, establecer `PYTHONCOERCECLOCALE-warn` hará que Python emita mensajes de advertencia en `stderr` si se activa la coerción de configuración regional, o si una configuración regional que would ha activado la coerción sigue activa cuando se inicializa el tiempo de ejecución de Python.

  Also note that even when locale coercion is disabled, or when it fails to find a suitable target locale, `PYTHONUTF8` will still activate by default in legacy ASCII-based locales. Both features must be disabled in order to force the interpreter to use `ASCII` instead of `UTF-8` for system interfaces.

  Availability: *nix.

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

`PYTHONDEVMODE`

  Si esta variable de entorno se establece en una cadena no vacía, habilite el «modo de desarrollo» de CPython. Consulte la opción `-X` `dev`.

  Nuevo en la versión 3.7.

`PYTHONUTF8`

  Si se establece en `1`, habilita el modo UTF-8 del intérprete, donde `UTF-8` se utiliza como codificación de texto para las interfaces del sistema, independientemente de la configuración regional actual.

  Esto significa que:

  > - `sys.getfilesystemencoding()` devuelve `'UTF-8'` (se omite la codificación de configuración local).

  > - `locale.getpreferredencoding()` devuelve `'UTF-8'` (se omite la codificación de configuración regional y el parámetro `do_setlocale` de la función no tiene ningún efecto).

  > - `sys.stdin`, `sys.stdout`, y `sys.stderr` todos usan UTF-8 como su codificación de texto, con el `surrogateescape` error handler que se habilita para `sys.stdin` y `sys.stdout` (`sys.stderr` continúa utilizando `backslashreplace` como lo hace en el modo predeterminado de configuración local)

  Como consecuencia de los cambios en esas API de nivel inferior, otras API de nivel superior también presentan diferentes comportamientos predeterminados:

  > - Los argumentos de línea de comandos, las variables de entorno y los nombres de archivo se descodifican en texto mediante la codificación UTF-8.

  > - `os.fsdecode()` y `os.fsencode()` utilizan la codificación UTF-8.

  > - `open()`, `io.open()`, y `codecs.open()` utilizan la codificación UTF-8 de forma predeterminada. Sin embargo, siguen usando el controlador de errores estricto de forma predeterminada para que intentar abrir un archivo binario en modo de texto sea probable que genere una excepción en lugar de producir datos sin sentido.

  Tenga en cuenta que la configuración de secuencia estándar en modo UTF-8 se puede invalidar por `PYTHONIOENCODING` (igual que pueden estar en el modo predeterminado de configuración local).

  Si se establece en `0`, el intérprete se ejecuta en su modo predeterminado compatible con la configuración local.

  Establecer cualquier otra cadena no vacía produce un error durante la inicialización del intérprete.

  Si esta variable de entorno no se establece en absoluto, el intérprete utiliza de forma predeterminada la configuración regional actual, a menos que la configuración regional actual se identifique como una configuración regional basada en ASCII heredada (como se describe para `PYTHONCOERCECLOCALE`) y la coerción de configuración regional está deshabilitada o se produce un error. En estas configuraciones regionales heredadas, el intérprete habilitará de forma predeterminada el modo UTF-8 a menos que se indique explícitamente que no lo haga.

  También disponible como la opción `-X` `utf8`.

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

### 1.2.1. Variables de modo de depuración

Establecer estas variables solo tiene un efecto en una compilación de depuración de Python.

`PYTHONTHREADDEBUG`

  Si se establece, Python imprimirá información de depuración de subprocesos.

  Necesita configurar Python con la opción de compilación `--with-pydebug`.

`PYTHONDUMPREFS`

  Si se establece, Python volcará objetos y recuentos de referencias aún vivos después de apagar el intérprete.

  Necesita Python configurado con la opción de compilación `--with-trace-refs`.