# `platform` — Acceso a los datos identificativos de la plataforma subyacente

código fuente: Lib/platform.py

Nota

Plataformas específicas listadas alfabéticamente, con Linux incluido en la sección de Unix.

## Plataforma cruzada

`platform.``architecture`(executable=sys.executable, bits='', linkage='')

  Consulta el ejecutable provisto (por defecto el archivo binario del intérprete de Python) para obtener información de diversas arquitecturas.

  Retorna una tupla `(bits, linkage)`, siendo bits la información sobre la arquitectura del procesador y linkage el formato de conexión usado por el ejecutable. Ambos valores se retornan como cadenas.

  Los valores que no se pueden determinar se retornan según lo indicado por los ajustes por defecto de los parámetros. Si bits se da como `''`, el `sizeof(pointer)` (o `sizeof(long)` en la versión de Python < 1.5.2) se utiliza como indicador para el tamaño del puntero admitido.

  La función se basa en el comando `file` del sistema para realizar la tarea. Está disponible en la mayoría de las plataformas Unix, si no en todas, y en algunas plataformas que no son de Unix y solo si el ejecutable apunta al intérprete de Python. Unos valores por defecto se utilizan cuando no se satisfacen las necesidades anteriores.

  Nota

  En macOS (y quizás en otras plataformas), los archivos ejecutables pueden ser archivos universales que contienen múltiples arquitecturas.

  Para llegar a los «64-bits» del intérprete actual, es más seguro consultar el atributo `sys.maxsize`:

      is_64bits = sys.maxsize > 2**32

`platform.``machine`()

  Returns the machine type, e.g. `'AMD64'`. An empty string is returned if the value cannot be determined.

`platform.``node`()

  Retorna el nombre de la red del ordenador (¡tal vez no sea el nombre completo!). Si no se puede determinar el valor, se retorna una cadena vacía.

`platform.``platform`(aliased=0, terse=0)

  Retorna una sola cadena identificando la plataforma subyacente con la mayor información útil posible.

  La salida se intenta que sea humanamente legible más que tratable por una máquina. Tal vez la salida sea diferente en diversas plataformas y eso mismo es lo que se pretende.

  Si aliased es verdadero, la función usará aliases para varias plataformas que informen de nombres de sistema que sean diferentes a sus nombres comunes. Por ejemplo, SunOS se reportará como Solaris. La función `system_alias()` ha sido usada para implementar esto.

  Estableciendo terse a verdadero provoca que la función retorne el mínimo de información necesaria para identificar la plataforma.

  Distinto en la versión 3.8: En macOS, la función ahora usa `mac_ver()`, si retorna una cadena no vacía para obtener la versión de macOS más que la versión de darwin.

`platform.``processor`()

  Retorna el nombre (real) del procesador. E.j. `'amdk6'`.

  Una cadena vacía se retorna si el valor no se puede determinar. Destacar que muchas plataformas no proveen esta información o simplemente retorna los mismos valores que para `machine()`, como hace NetBSD.

`platform.``python_build`()

  Retorna una tupla `(buildno, builddate)` con buildno indicando el número de la build de Python y builddate su fecha de publicación como cadenas.

`platform.``python_compiler`()

  Retorna la string con la identificación del compilador usado para compilar Python.

`platform.``python_branch`()

  Retorna la string identificando la implementación de la rama SCM de Python.

`platform.``python_implementation`()

  Retorna la string identificando la implementación de Python. Algunos valores posibles son: “CPython”, “IronPython”, “Jython”, “PyPy”.

`platform.``python_revision`()

  Retorna la string identificando la implementación de la revisión SCM de Python.

`platform.``python_version`()

  Retorna la versión de Python en formato de cadena de caracteres con la forma `'major.minor.patchlevel'` siendo major la versión principal, minor la versión menor y patchlevel el último parche aplicado.

  Destacar que a diferencia del `sys.version` de Python, el valor retornado siempre incluirá el último parche aplicado (siendo 0 por defecto).

`platform.``python_version_tuple`()

  Retorna la versión de Python como una tupla `(major, minor, patchlevel)` de cadena, siendo major la versión principal, minor la versión menor y patchlevel último parche aplicado.

  Destacar que a diferencia del `sys.version` de Python, el valor retornado siempre incluirá el último parche aplicado (siendo `'0'` por defecto).

`platform.``release`()

  Returns the system’s release, e.g. `'2.2.0'` or `'NT'`. An empty string is returned if the value cannot be determined.

`platform.``system`()

  Retorna el nombre del sistema/SO, como `'Linux'`, `'Darwin'`, `'Java'`, `'Windows'`. Si no se puede determinar el valor, se retorna una cadena vacía.

`platform.``system_alias`(system, release, version)

  Retorna la tupla `(system, release, version)` con los aliases de los nombres comerciales usados por algunos sistemas siendo system el nombre comercial del sistema, release como la versión principal de publicación y version como el número de la versión del sistema. También hace cierta reordenación de la información en algunos casos donde se produjera algún tipo de confusión.

`platform.``version`()

  Retorna la versión de la publicación del sistema. Por ejemplo: `'#3 n degas'`. Una cadena vacía se retorna en el caso de que el valor no pueda ser determinado.

`platform.``uname`()

  Interfaz uname relativamente portable. Retorna una `namedtuple()` con seis atributos: `system`, `node`, `release`, `version`, `machine`, and `processor`.

  Destacar que añade un sexto atributo (`processor`) que no está presente en el resultado de la función `os.uname()`. Los dos primeros atributos tienen nombres diferentes a los que tiene `os.uname()`, que los llama `sysname` y `nodename`.

  Cualquier entrada que no pueda ser determinada se establece como `''`.

  Distinto en la versión 3.3: Result changed from a tuple to a `namedtuple()`.

## Plataforma Java

`platform.``java_ver`(release='', vendor='', vminfo=('', '', ''), osinfo=('', '', ''))

  Versión de la interfaz de Jython.

  Retorna una tupla `(release, vendor, vminfo, osinfo)` con vminfo siendo una tupla `(vm_name, vm_release, vm_vendor)` y osinfo siendo una tupla `(os_name, os_version, os_arch)`. Los valores que no se pueden determinar se establecen por defecto de los parámetros (que todos los valores predeterminados son `''`).

## Plataforma windows

`platform.``win32_ver`(release='', version='', csd='', ptype='')

  Get additional version information from the Windows Registry and return a tuple `(release, version, csd, ptype)` referring to OS release, version number, CSD level (service pack) and OS type (multi/single processor). Values which cannot be determined are set to the defaults given as parameters (which all default to an empty string).

  Como sugerencia: ptype es `'Uniprocessor Free'` en máquinas NT de procesador único y `'Multiprocessor Free'` en máquinas multiprocesador. El “Free” se refiere a que la versión del sistema operativo está libre de código de depuración. También podría indicar “Checked” lo que significa que la versión del sistema operativo utiliza código de depuración, es decir, código que comprueba argumentos, rangos, etc.

`platform.``win32_edition`()

  Returns a string representing the current Windows edition, or `None` if the value cannot be determined. Possible values include but are not limited to `'Enterprise'`, `'IoTUAP'`, `'ServerStandard'`, and `'nanoserver'`.

  Nuevo en la versión 3.8.

`platform.``win32_is_iot`()

  Retorna `True` si la edición de Windows retornada por `win32_edition()` se reconoce como una edición IoT.

  Nuevo en la versión 3.8.

## Plataforma macOS

`platform.``mac_ver`(release='', versioninfo=('', '', ''), machine='')

  Obtenga información de la versión de macOS y devuélvala como tupla `(release, versioninfo, machine)` con versioninfo como tupla `(version, dev_stage, non_release_version)`.

  Cualquier registro que no puede ser determinado se establece como `''`. Todas los registros de la tupla son cadenas.

## Plataformas Unix

`platform.``libc_ver`(executable=sys.executable, lib='', version='', chunksize=16384)

  Intenta determinar la versión libc al que está enlazado el fichero ejecutable (por defecto el intérprete de Python). Retorna una tupla de cadenas `(lib, version)` que tiene por defecto los parámetros que han sido introducidos en caso de que la búsqueda fallase.

  Destacar que esta función tiene un conocimiento íntimo de cómo las diferentes versiones de libc agregan símbolos al ejecutable. Probablemente sólo se puede utilizar para los ejecutables compilados mediante gcc.

  El archivo se lee y se analiza en fragmentos de bytes chunksize.

## Plataformas Linux

`platform.``freedesktop_os_release`()

  Obtiene la identificación del sistema operativo del archivo `os-release` y la retorna como dict. El archivo `os-release` es un freedesktop.org standard y está disponible en la mayoría de las distribuciones de Linux. Una excepción notable son las distribuciones de Android y basadas en Android.

  Lanza `OSError` o subclase cuando no se pueden leer ni `/etc/os-release` ni `/usr/lib/os-release`.

  En caso de éxito, la función retorna un diccionario donde las claves y los valores son cadenas de caracteres. Los valores tienen sus caracteres especiales como `"` y `$` sin comillas. Los campos `NAME`, `ID` y `PRETTY_NAME` siempre se definen de acuerdo con el estándar. Todos los demás campos son opcionales. Los proveedores pueden incluir campos adicionales.

  Tenga en cuenta que campos como `NAME`, `VERSION` y `VARIANT` son cadenas de caracteres adecuadas para la presentación a los usuarios. Los programas deben usar campos como `ID`, `ID_LIKE`, `VERSION_ID` o `VARIANT_ID` para identificar distribuciones de Linux.

  Ejemplo:

      def get_like_distro():
          info = platform.freedesktop_os_release()
          ids = [info["ID"]]
          if "ID_LIKE" in info:
              # ids are space separated and ordered by precedence
              ids.extend(info["ID_LIKE"].split())
          return ids

  Nuevo en la versión 3.10.