# `sysconfig` — Proporciona acceso a la información de configuración de Python

Nuevo en la versión 3.2.

Código fuente: Lib/sysconfig.py

El módulo `sysconfig` proporcionado acceso a la información de configuración de Python, como la lista de rutas de instalación y las variables de configuración relevantes para la plataforma actual.

## Variables de configuración

Una distribución de Python contiene un `Makefile` y un archivo de cabecera `pyconfig.h` que son necesarios para construir tanto el propio binario de Python como las extensiones C de terceros compiladas usando `distutils`.

`sysconfig` coloca todas las variables que se encuentran en estos archivos un diccionario al que se puede acceder usando `get_config_vars()` o `get_config_var()`.

Tenga en cuenta que en Windows, es un conjunto mucho más pequeño.

sysconfig.get_config_vars(*args)

  Sin argumentos, retorna un diccionario de todas las variables de configuración relevantes para la plataforma actual.

  Con argumentos, retorna un lista de valores que resultan de buscar cada argumento en el diccionario de variables de configuración.

  Por cada argumento, si no se encuentra el valor, retorna `None`.

sysconfig.get_config_var(name)

  Retorna el valor de un solo nombre de variable (name). Equivalente a `get_config_vars().get(name)`.

  Si no se encuentra name, retorna `None`.

Ejemplos de uso:

    >>> import sysconfig
    >>> sysconfig.get_config_var('Py_ENABLE_SHARED')
    0
    >>> sysconfig.get_config_var('LIBDIR')
    '/usr/local/lib'
    >>> sysconfig.get_config_vars('AR', 'CXX')
    ['ar', 'g++']

## Rutas de instalación

Python uses an installation scheme that differs depending on the platform and on the installation options. These schemes are stored in `sysconfig` under unique identifiers based on the value returned by `os.name`. The schemes are used by package installers to determine where to copy files to.

Python actualmente admite nueve esquemas:

- posix_prefix: esquema para plataformas POSIX como Linux o macOS. Este es el esquema predeterminado que se usa cuando se instala Python o un componente.

- posix_home: scheme for POSIX platforms, when the home option is used. This scheme defines paths located under a specific home prefix.

- posix_user: scheme for POSIX platforms, when the user option is used. This scheme defines paths located under the user’s home directory (`site.USER_BASE`).

- posix_venv: scheme for `Python virtual environments` on POSIX platforms; by default it is the same as posix_prefix.

- nt: scheme for Windows. This is the default scheme used when Python or a component is installed.

- nt_user: scheme for Windows, when the user option is used.

- nt_venv: scheme for `Python virtual environments` on Windows; by default it is the same as nt.

- venv: a scheme with values from either posix_venv or nt_venv depending on the platform Python runs on.

- nt_user: esquema para macOS, cuando se usa la opción user.

Cada esquema está compuesto por una serie de rutas y cada ruta tiene un identificador único. Python actualmente usa ocho rutas:

- stdlib: directorio que contiene los archivos de la biblioteca estándar de Python que no son específicos de la plataforma.

- platstdlib: directorio que contiene los archivos de la biblioteca estándar de Python que son específicos de la plataforma.

- platlib: directorio para archivos específicos del sitio, específicos de la plataforma.

- purelib: directory for site-specific, non-platform-specific files (“pure” Python).

- include: directorio para plataformas no especificadas para archivos de encabezado de Python C-API.

- include: directorio para plataformas especificadas para archivos de encabezado de Python C-API.

- scripts: directorio para archivos de script.

- data: directorio para archivos de datos.

## User scheme

This scheme is designed to be the most convenient solution for users that don’t have write permission to the global site-packages directory or don’t want to install into it.

Files will be installed into subdirectories of `site.USER_BASE` (written as `userbase` hereafter). This scheme installs pure Python modules and extension modules in the same location (also known as `site.USER_SITE`).

### `posix_user`

Path | Installation directory
--- | ---
stdlib | `userbase/lib/pythonX.Y`
platstdlib | `userbase/lib/pythonX.Y`
platlib | `userbase/lib/pythonX.Y/site-packages`
purelib | `userbase/lib/pythonX.Y/site-packages`
include | `userbase/include/pythonX.Y`
scripts | `userbase/bin`
data | `userbase`

### `nt_user`

Path | Installation directory
--- | ---
stdlib | `userbase\PythonXY`
platstdlib | `userbase\PythonXY`
platlib | `userbase\PythonXY\site-packages`
purelib | `userbase\PythonXY\site-packages`
include | `userbase\PythonXY\Include`
scripts | `userbase\PythonXY\Scripts`
data | `userbase`

### `osx_framework_user`

Path | Installation directory
--- | ---
stdlib | `userbase/lib/python`
platstdlib | `userbase/lib/python`
platlib | `userbase/lib/python/site-packages`
purelib | `userbase/lib/python/site-packages`
include | `userbase/include/pythonX.Y`
scripts | `userbase/bin`
data | `userbase`

## Home scheme

The idea behind the «home scheme» is that you build and maintain a personal stash of Python modules. This scheme’s name is derived from the idea of a «home» directory on Unix, since it’s not unusual for a Unix user to make their home directory have a layout similar to `/usr/` or `/usr/local/`. This scheme can be used by anyone, regardless of the operating system they are installing for.

### `posix_home`

Path | Installation directory
--- | ---
stdlib | `home/lib/python`
platstdlib | `home/lib/python`
platlib | `home/lib/python`
purelib | `home/lib/python`
include | `home/include/python`
platinclude | `home/include/python`
scripts | `home/bin`
data | `home`

## Prefix scheme

The «prefix scheme» is useful when you wish to use one Python installation to perform the build/install (i.e., to run the setup script), but install modules into the third-party module directory of a different Python installation (or something that looks like a different Python installation). If this sounds a trifle unusual, it is—that’s why the user and home schemes come before. However, there are at least two known cases where the prefix scheme will be useful.

First, consider that many Linux distributions put Python in `/usr`, rather than the more traditional `/usr/local`. This is entirely appropriate, since in those cases Python is part of «the system» rather than a local add-on. However, if you are installing Python modules from source, you probably want them to go in `/usr/local/lib/python2.X` rather than `/usr/lib/python2.X`.

Another possibility is a network filesystem where the name used to write to a remote directory is different from the name used to read it: for example, the Python interpreter accessed as `/usr/local/bin/python` might search for modules in `/usr/local/lib/python2.X`, but those modules would have to be installed to, say, `/mnt/@server/export/lib/python2.X`.

### `posix_prefix`

Path | Installation directory
--- | ---
stdlib | `prefix/lib/pythonX.Y`
platstdlib | `prefix/lib/pythonX.Y`
platlib | `prefix/lib/pythonX.Y/site-packages`
purelib | `prefix/lib/pythonX.Y/site-packages`
include | `prefix/include/pythonX.Y`
platinclude | `prefix/include/pythonX.Y`
scripts | `prefix/bin`
data | `prefix`

### `nt`

Path | Installation directory
--- | ---
stdlib | `prefix\Lib`
platstdlib | `prefix\Lib`
platlib | `prefix\Lib\site-packages`
purelib | `prefix\Lib\site-packages`
include | `prefix\Include`
platinclude | `prefix\Include`
scripts | `prefix\Scripts`
data | `prefix`

## Installation path functions

`sysconfig` provides some functions to determine these installation paths.

sysconfig.get_scheme_names()

  Retorna una tupla que contiene todos los esquemas admitidos actualmente en `sysconfig`.

sysconfig.get_default_scheme()

  Retorna el nombre del esquema predeterminado para la plataforma actual.

  Nuevo en la versión 3.10: Esta función se llamaba anteriormente `_get_default_scheme()` y se consideraba un detalle de implementación.

  Distinto en la versión 3.11: Cuando Python se ejecuta desde un entorno virtual, este retorna el esquema venv.

sysconfig.get_preferred_scheme(key)

  Retorna un nombre de esquema preferido para un diseño de instalación especificado por key.

  key debe ser `"prefix"`, `"home"` o `"user"`.

  El valor de retorno es un nombre de esquema que aparece en `get_scheme_names()`. Se puede pasar a funciones `sysconfig` que toman un argumento scheme, como `get_paths()`.

  Nuevo en la versión 3.10.

  Distinto en la versión 3.11: Cuando Python se ejecuta desde un entorno virtual con `key="prefix"`, este retorna el esquema venv.

sysconfig._get_preferred_schemes()

  Retorna un diccionario que contiene los nombres de los esquemas preferidos en la plataforma actual. Los implementadores y redistribuidores de Python pueden agregar sus esquemas preferidos al valor global de nivel de módulo `_INSTALL_SCHEMES` y modificar esta función para devolver esos nombres de esquema, p. Ej. proporcionan diferentes esquemas para que los utilicen los administradores de paquetes de idioma y sistema, de modo que los paquetes instalados por uno no se mezclen con los del otro.

  Los usuarios finales no deben utilizar esta función, sino `get_default_scheme()` y `get_preferred_scheme()` en su lugar.

  Nuevo en la versión 3.10.

sysconfig.get_path_names()

  Retorna una tupla que contiene todo los nombres de rutas admitidos actualmente en `sysconfig`.

sysconfig.get_path(name[, scheme[, vars[, expand]]])

  Retorna una ruta de instalación correspondiente a la ruta name, del esquema de instalación denominado scheme.

  name tiene que ser un valor de la lista retornado por `get_path_names()`.

  `sysconfig` almacena las rutas de instalación correspondientes a cada nombre de ruta, para cada plataforma, con variables que se expandirán. Por ejemplo, la ruta stdlib para el esquema nt es: `{base}/Lib`.

  `get_path()` utilizará las variables retornadas por `get_config_vars()` para expandir la ruta. Todas las variables tienen valores predeterminados para cada plataforma, por lo que se puede llamar a esta función y obtener el valor predeterminado.

  Si se proporciona el esquema (scheme), debe ser un valor de la lista retornada por `get_scheme_names()`. De lo contrario, se utiliza el esquema predeterminado para la plataforma actual.

  If vars is provided, it must be a dictionary of variables that will update the dictionary returned by `get_config_vars()`.

  Si expand se establece en `False`, la ruta no se expandirá usando las variables.

  Si no se encuentra name, lanza un `KeyError`.

sysconfig.get_paths([scheme[, vars[, expand]]])

  Retorna un diccionario de contiene todas las rutas de instalación correspondientes a un esquema de instalación. Consulte `get_path()` para obtener más información.

  Si no se proporciona el esquema (scheme), utilizará el esquema predeterminado para la plataforma actual.

  Si se proporciona vars, debe ser un diccionario de variables que actualizará el diccionario utilizado para expandir las rutas.

  Si expand se establece en falso, las rutas no se expandirán.

  Si scheme no es un esquema existente, `get_paths()` lanzará un `KeyError`.

## Otras funciones

sysconfig.get_python_version()

  Retorna el número de versión versión `MAJOR.MINOR` de Python como una cadena. Similar a `'%d.%d' % sys.version_info[:2]`.

sysconfig.get_platform()

  Retorna una cadena que identifica la plataforma actual.

  Se utiliza principalmente para distinguir los directorios de compilación específicos de la plataforma y las distribuciones compiladas específicas de la plataforma. Por lo general se incluye el nombre y la versión del sistema operativo y la arquitectura (como lo proporciona “os.uname()”), aunque la información exacta incluida depende del sistema operativo: por ejemplo, en Linux, la versión del kernel no es particularmente importante.

  Ejemplo de valores retornados:

  - linux-i586

  - linux-alpha (?)

  - solaris-2.6-sun4u

  Windows retornará uno de:

  - win-amd64 (Windows de 64 bits en AMD64, también conocido como x86_64, Intel64 y EM64T)

  - win32 (todos los demás - específicamente se retorna sys.platform)

  macOS puede retornar:

  - macosx-10.6-ppc

  - macosx-10.4-ppc64

  - macosx-10.3-i386

  - macosx-10.4-fat

  Para otras plataformas que no son POSIX, actualmente solo retorna `sys.platform`.

sysconfig.is_python_build()

  Retorna `True` si el intérprete de Python en ejecución se compiló a partir de la fuente y se está ejecutando desde su ubicación compilada, y no desde una ubicación resultante de por ejemplo ejecutando `make install` o instalando a través de un instalador binario.

sysconfig.parse_config_h(fp[, vars])

  Analiza un archivo de estilo `config.h`.

  fp es un objeto similar a un archivo que apunta al archivo similar a `config.h`.

  Se retorna un diccionario que contiene pares de nombre/valor. Si se pasa un diccionario opcional como un segundo argumento, se utiliza en lugar de un nuevo diccionario y se actualiza con los valores leídos en el archivo.

sysconfig.get_config_h_filename()

  Retorna la ruta de `pyconfig.h`.

sysconfig.get_makefile_filename()

  Retorna la ruta de `Makefile`.

## Usando `sysconfig` como un script

Puedes usar `sysconfig` como un script con la opción -m de Python:

    $ python -m sysconfig
    Platform: "macosx-10.4-i386"
    Python version: "3.2"
    Current installation scheme: "posix_prefix"

    Paths:
            data = "/usr/local"
            include = "/Users/tarek/Dev/svn.python.org/py3k/Include"
            platinclude = "."
            platlib = "/usr/local/lib/python3.2/site-packages"
            platstdlib = "/usr/local/lib/python3.2"
            purelib = "/usr/local/lib/python3.2/site-packages"
            scripts = "/usr/local/bin"
            stdlib = "/usr/local/lib/python3.2"

    Variables:
            AC_APPLE_UNIVERSAL_BUILD = "0"
            AIX_GENUINE_CPLUSPLUS = "0"
            AR = "ar"
            ARFLAGS = "rc"
            ...

Esta llamada imprimirá en la salida estándar la información retornada por `get_platform()`, `get_python_version()`, `get_path()` y `get_config_vars()`.