Configuraciones de intérprete

sys contiene atributos y funciones para acceder a la configuración de tiempo de compilación o tiempo de ejecución para el intérprete.

Información de versión de tiempo de compilación

La versión utilizada para construir el intérprete de C está disponible en algunas formas. sys.version es una cadena legible por humanos que generalmente incluye el número de versión completo, así como información sobre la fecha de compilación, el compilador y la plataforma. sys.hexversion es más fácil de usar para verificar la versión del intérprete, ya que es un entero simple. Cuando se formatea usando hex(), está claro que partes de sys.hexversion provienen de la información de la versión también visible en el más legible sys.version_info (una tupla llamada de cinco partes que representa solo el número de versión). La versión separada de C API utilizada por el intérprete actual se guarda en sys.api_version.

sys_version_values.py
import sys

print('Version info:')
print()
print('sys.version      =', repr(sys.version))
print('sys.version_info =', sys.version_info)
print('sys.hexversion   =', hex(sys.hexversion))
print('sys.api_version  =', sys.api_version)

Todos los valores dependen del intérprete real utilizado para ejecutar el programa de muestra.

$ python3 sys_version_values.py

Version info:

sys.version      = '3.6.4 (v3.6.4:d48ecebad5, Dec 18 2017,
21:07:28) \n[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)]'
sys.version_info = sys.version_info(major=3, minor=6, micro=4,
releaselevel='final', serial=0)
sys.hexversion   = 0x30604f0
sys.api_version  = 1013

La plataforma del sistema operativo utilizada para construir el intérprete se guarda como sys.platform.

sys_platform.py
import sys

print('This interpreter was built for:', sys.platform)

Para la mayoría de los sistemas Unix, el valor proviene de combinar la salida de uname -s con la primera parte de la versión en uname -r. Para otros sistemas operativos hay una tabla de valores codificados.

$ python3 sys_platform.py

This interpreter was built for: darwin

Ver también

Implementaciones del intérprete

El intérprete de CPython es una de varias implementaciones del lenguaje Python. sys.implementation se proporciona para detectar la implementación actual de las bibliotecas que necesitan solucionar cualquier diferencia en los intérpretes.

sys_implementation.py
import sys


print('Name:', sys.implementation.name)
print('Version:', sys.implementation.version)
print('Cache tag:', sys.implementation.cache_tag)

sys.implementation.version es lo mismo que sys.version_info para CPython, pero será diferente para otros intérpretes.

$ python3 sys_implementation.py

Name: cpython
Version: sys.version_info(major=3, minor=6, micro=4, releaseleve
l='final', serial=0)
Cache tag: cpython-36

Ver también

  • PEP 421 – Agregar sys.implementation

Opciones de línea de comando

El intérprete de CPython acepta varias opciones de línea de comandos para controlar su comportamiento, que se enumeran en the table below.

Indicadores de opciones de línea de comandos de CPython
Opción Sentido
-B no escribir archivos .py[co] en la importación
-b emitir advertencias sobre la conversión de bytes a cadena sin decodificar adecuadamente y comparar bytes con cadenas
-bb convertir bytes de advertencia a errores
-d salida de depuración del analizador
-E ignorar las variables de entorno PYTHON* (como PYTHONPATH)
-i inspeccionar interactivamente después de ejecutar la secuencia de comandos
-O optimizar el bytecode generado ligeramente
-OO eliminar cadenas de documentos además de las optimizaciones -O
-s no agregar el directorio del sitio del usuario a sys.path
-S no ejecutar “import site” en la inicialización
-t emitir advertencias sobre el uso inconsistente de pestañas
-tt emitir errores por uso inconsistente de tabuladores
-v verbosa

Algunos de estos están disponibles para que los programas los verifiquen a través de sys.flags.

sys_flags.py
import sys

if sys.flags.bytes_warning:
    print('Warning on bytes/str errors')
if sys.flags.debug:
    print('Debuging')
if sys.flags.inspect:
    print('Will enter interactive mode after running')
if sys.flags.optimize:
    print('Optimizing byte-code')
if sys.flags.dont_write_bytecode:
    print('Not writing byte-code files')
if sys.flags.no_site:
    print('Not importing "site"')
if sys.flags.ignore_environment:
    print('Ignoring environment')
if sys.flags.verbose:
    print('Verbose mode')

Experimenta con sys_flags.py para aprender cómo las opciones de línea de comando se asignan a la configuración de las banderas.

$ python3 -S -E -b sys_flags.py

Warning on bytes/str errors
Not importing "site"
Ignoring environment

Valores predeterminados de Unicode

Para obtener el nombre de la codificación Unicode predeterminada que utiliza el intérprete, llama a getdefaultencoding(). El valor se establece durante el inicio y no se puede cambiar.

La codificación interna predeterminada y la codificación del sistema de archivos pueden ser diferentes para algunos sistemas operativos, por lo que hay una forma separada de recuperar la configuración del sistema de archivos. getfilesystemencoding() devuelve un valor específico del sistema operativo (no específico del sistema de archivos).

sys_unicode.py
import sys

print('Default encoding     :', sys.getdefaultencoding())
print('File system encoding :', sys.getfilesystemencoding())

En lugar de confiar en la codificación predeterminada global, la mayoría de los expertos de Unicode recomiendan hacer una aplicación explícitamente compatible con Unicode. Esto proporciona dos beneficios: las diferentes codificaciones Unicode para diferentes fuentes de datos se pueden manejar de manera más limpia, y se reduce el número de suposiciones sobre codificaciones en el código de la aplicación.

$ python3 sys_unicode.py

Default encoding     : utf-8
File system encoding : utf-8

Símbolo del sistema interactivo

El intérprete interactivo utiliza dos mensajes separados para indicar el nivel de entrada predeterminado (ps1) y la «continuación» de una instrucción de varias líneas (ps2). Los valores solo los usa el intérprete interactivo.

>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>>

Cualquiera de los dos o ambos pueden cambiarse a una cadena diferente.

>>> sys.ps1 = '::: '
::: sys.ps2 = '~~~ '
::: for i in range(3):
~~~   print i
~~~
0
1
2
:::

Alternativamente, cualquier objeto que se pueda convertir en una cadena (a través de __str__) se puede usar para el indicador.

sys_ps1.py
import sys


class LineCounter:

    def __init__(self):
        self.count = 0

    def __str__(self):
        self.count += 1
        return '({:3d})> '.format(self.count)

El LineCounter realiza un seguimiento de cuántas veces se ha utilizado, por lo que el número en el indicador aumenta cada vez.

$ python
Python 3.4.2 (v3.4.2:ab2c023a9432, Oct  5 2014, 20:42:22)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more
information.
>>> from sys_ps1 import LineCounter
>>> import sys
>>> sys.ps1 = LineCounter()
(  1)>
(  2)>
(  3)>

Gancho de Muestra

El intérprete interactivo invoca sys.displayhook cada vez que el usuario ingresa una expresión. El resultado de evaluar la expresión se pasa como el único argumento para la función.

sys_displayhook.py
import sys


class ExpressionCounter:

    def __init__(self):
        self.count = 0
        self.previous_value = self

    def __call__(self, value):
        print()
        print('  Previous:', self.previous_value)
        print('  New     :', value)
        print()
        if value != self.previous_value:
            self.count += 1
            sys.ps1 = '({:3d})> '.format(self.count)
        self.previous_value = value
        sys.__displayhook__(value)


print('installing')
sys.displayhook = ExpressionCounter()

El valor predeterminado (guardado en sys.__displayhook__) imprime el resultado en stdout y lo guarda en _ para una fácil referencia posterior.

$ python3
Python 3.4.2 (v3.4.2:ab2c023a9432, Oct  5 2014, 20:42:22)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more
information.
>>> import sys_displayhook
installing
>>> 1 + 2

  Previous: <sys_displayhook.ExpressionCounter
  object at 0x1021035f8>
  New     : 3

3
(  1)> 'abc'

  Previous: 3
  New     : abc

'abc'
(  2)> 'abc'

  Previous: abc
  New     : abc

'abc'
(  2)> 'abc' * 3

  Previous: abc
  New     : abcabcabc

'abcabcabc'
(  3)>

Ubicación de instalación

La ruta al programa de intérprete real está disponible en sys.executable en todos los sistemas para los que tiene sentido tener una ruta al intérprete. Esto puede ser útil para garantizar que se esté utilizando el intérprete correcto, y también proporciona pistas sobre las rutas que pueden establecerse en función de la ubicación del intérprete.

sys.prefix se refiere al directorio principal de la instalación del intérprete. Por lo general, incluye directorios bin y lib para ejecutables y módulos instalados, respectivamente.

sys_locations.py
import sys

print('Interpreter executable:')
print(sys.executable)
print('\nInstallation prefix:')
print(sys.prefix)

Este resultado de ejemplo se produjo en una Mac que ejecuta una compilación de marco instalada desde python.org.

$ python3 sys_locations.py

Interpreter executable:
/Library/Frameworks/Python.framework/Versions/3.5/bin/python3

Installation prefix:
/Library/Frameworks/Python.framework/Versions/3.5