# `platform` --- Access to underlying platform's identifying data

Code source : Lib/platform.py

Note

Les spécificités des plateformes sont regroupées dans des sections triées par ordre alphabétique. Linux est inclus dans la section Unix.

## Cross platform

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

  Interroge l'exécutable fourni (par défaut l'interpréteur Python) sur les informations de l'architecture.

  Renvoie un n-uplet de `(bits, linkage)` qui contient de l'information sur l'architecture binaire et le format de lien. Les deux valeurs sont des chaînes de caractères.

  Lorsqu'une valeur ne peut être déterminée, la valeur passée en paramètre est utilisée. Si la valeur passée à bits est `''`, la valeur de `sizeof(pointer)` (ou `sizeof(long)` sur les versions Python antérieures à 1.5.2) est utilisée comme indicateur de la taille de pointeur prise en charge.

  La fonction dépend de la commande `file` du système pour accomplir la tâche. `file` est disponible sur quasiment toutes les plateformes Unix ainsi que sur certaines plateformes hors de la famille Unix et l'exécutable doit pointer vers l'interpréteur Python. Des valeurs par défaut raisonnables sont utilisées lorsque les conditions précédentes ne sont pas atteintes.

  Note

  On macOS (and perhaps other platforms), executable files may be universal files containing multiple architectures.

  To get at the "64-bitness" of the current interpreter, it is more reliable to query the `sys.maxsize` attribute:

      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()

  Renvoie le nom de l'ordinateur sur le réseau (pas forcément pleinement qualifié). Une chaîne de caractères vide est renvoyée s'il ne peut pas être déterminé.

platform.platform(aliased=False, terse=False)

  Renvoie une chaîne de caractère identifiant la plateforme avec le plus d'informations possible.

  La valeur renvoyée est destinée à la lecture humaine plutôt que l'interprétation machine. Il est possible qu'elle soit différente selon la plateforme et c'est voulu.

  Si aliased est vrai, la fonction utilisera des alias pour certaines plateformes qui utilisent des noms de système qui diffèrent de leurs noms communs. Par exemple, SunOS sera reconnu comme Solaris. La fonction `system_alias()` est utilisée pour l'implémentation.

  Si terse est vrai, la fonction ne renverra que l'information nécessaire à l'identification de la plateforme.

  Modifié dans la version 3.8: Sur MacOS, la fonction essaie maintenant d'utiliser la fonction `mac_ver()` pour obtenir la version de MacOS plutôt que la version de Darwin : le résultat de `mac_ver` est utilisé si ce n'est pas une chaîne vide.

platform.processor()

  Renvoie le (vrai) nom du processeur. Par exemple : `'amdk6'`.

  Une chaîne de caractères vide est renvoyée si la valeur ne peut être déterminée. Prenez note que plusieurs plateformes ne fournissent pas cette information ou renvoient la même valeur que la fonction `machine()`. NetBSD agit ainsi.

platform.python_build()

  Renvoie une paire `(buildno, builddate)` de chaîne de caractères identifiant la version et la date de compilation de Python.

platform.python_compiler()

  Renvoie une chaîne de caractères identifiant le compilateur utilisé pour compiler Python.

platform.python_branch()

  Renvoie la chaîne de caractères identifiant la branche du gestionnaire de versions de l'implémentation Python.

platform.python_implementation()

  Renvoie une chaîne de caractères identifiant l'implémentation de Python. Des valeurs possibles sont : `CPython`, `IronPython`, `Jython`, `Pypy`.

platform.python_revision()

  Renvoie la chaîne de caractères identifiant la révision du gestionnaire de versions de l'implémentation Python.

platform.python_version()

  Renvoie la version de Python comme une chaîne de caractères `'major.minor.patchlevel'`.

  Prenez note que la valeur renvoyée inclut toujours le patchlevel (valeur par défaut de 0) à la différence de `sys.version`.

platform.python_version_tuple()

  Renvoie la version de Python comme un triplet de chaînes de caractères `(major, minor, patchlevel)`.

  Prenez note que la valeur renvoyée inclut toujours le patchlevel (valeur par défaut de `'0'`) à la différence de `sys.version`.

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()

  Renvoie le nom du système d'exploitation, tel que `'Linux'`, `'Darwin'`, `'Java'`, `'Windows'`. Une chaîne de caractères vide est renvoyée si le nom ne peut être déterminé.

  On iOS and Android, this returns the user-facing OS name (i.e, `'iOS`, `'iPadOS'` or `'Android'`). To obtain the kernel name (`'Darwin'` or `'Linux'`), use `os.uname()`.

platform.system_alias(system, release, version)

  Renvoie `(system, release, version)` avec des alias pour les noms communs de certains systèmes. Modifie aussi l'ordre de l'information pour éviter la confusion.

platform.version()

  Renvoie la version de déploiement du système. Par exemple, `'#3 on degas'`. Une chaîne de caractères vide est renvoyée si aucune valeur ne peut être déterminée.

  On iOS and Android, this is the user-facing OS version. To obtain the Darwin or Linux kernel version, use `os.uname()`.

platform.uname()

  Interface de uname relativement portable. Renvoie un `namedtuple()` contenant six attributs : `system`, `node`, `release`, `version`, `machine` et `processor`.

  `processor` is resolved late, on demand.

  Note: the first two attribute names differ from the names presented by `os.uname()`, where they are named `sysname` and `nodename`.

  Les entrées qui ne peuvent pas être identifiées ont la valeur `''`.

  Modifié dans la version 3.3: Result changed from a tuple to a `namedtuple()`.

  Modifié dans la version 3.9: `processor` is resolved late instead of immediately.

## Java platform

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

  Version de l'interface pour Jython.

  Renvoie un n-uplet `(release, vendor, vminfo, osinfo)`. vminfo est un triplet de valeur `(vm_name, vm_release, vm_vendor)` et osinfo est un triplet de valeur `(os_name, os_version, os_arch)`. Les valeurs indéterminables ont la valeur des paramètres par défaut (valeur de `''` par défaut).

  Deprecated since version 3.13, will be removed in version 3.15: It was largely untested, had a confusing API, and was only useful for Jython support.

## Windows platform

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).

  As a hint: ptype is `'Uniprocessor Free'` on single processor NT machines and `'Multiprocessor Free'` on multi processor machines. The `'Free'` refers to the OS version being free of debugging code. It could also state `'Checked'` which means the OS version uses debugging code, i.e. code that checks arguments, ranges, 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'`.

  Ajouté dans la version 3.8.

platform.win32_is_iot()

  Renvoie `True` si l'édition de Windows renvoyée par la fonction `win32_edition()` est reconnue comme une édition IoT.

  Ajouté dans la version 3.8.

## macOS platform

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

  Get macOS version information and return it as tuple `(release, versioninfo, machine)` with versioninfo being a tuple `(version, dev_stage, non_release_version)`.

  Les entrées qui ne peuvent pas être identifiées auront la valeur `''`. Les membres du n-uplet sont tous des chaînes de caractères.

## iOS platform

platform.ios_ver(system='', release='', model='', is_simulator=False)

  Get iOS version information and return it as a `namedtuple()` with the following attributes:

  - `system` is the OS name; either `'iOS'` or `'iPadOS'`.

  - `release` is the iOS version number as a string (e.g., `'17.2'`).

  - `model` is the device model identifier; this will be a string like `'iPhone13,2'` for a physical device, or `'iPhone'` on a simulator.

  - `is_simulator` is a boolean describing if the app is running on a simulator or a physical device.

  Entries which cannot be determined are set to the defaults given as parameters.

## Unix platforms

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

  Tente d'identifier la version de la bibliothèque standard C à laquelle le fichier exécutable (par défaut l'interpréteur Python) est lié. Renvoie une paire de chaînes de caractères `(lib, version)`. Les valeurs passées en paramètre seront retournées si la recherche échoue.

  Prenez note que cette fonction a une connaissance profonde des méthodes utilisées par les versions de la bibliothèque standard C pour ajouter des symboles au fichier exécutable. Elle n'est probablement utilisable qu'avec des exécutables compilés avec gcc.

  Le fichier est lu en blocs de chunksize octets.

## Linux platforms

platform.freedesktop_os_release()

  Get operating system identification from `os-release` file and return it as a dict. The `os-release` file is a freedesktop.org standard and is available in most Linux distributions. A noticeable exception is Android and Android-based distributions.

  Raises `OSError` or subclass when neither `/etc/os-release` nor `/usr/lib/os-release` can be read.

  On success, the function returns a dictionary where keys and values are strings. Values have their special characters like `"` and `$` unquoted. The fields `NAME`, `ID`, and `PRETTY_NAME` are always defined according to the standard. All other fields are optional. Vendors may include additional fields.

  Note that fields like `NAME`, `VERSION`, and `VARIANT` are strings suitable for presentation to users. Programs should use fields like `ID`, `ID_LIKE`, `VERSION_ID`, or `VARIANT_ID` to identify Linux distributions.

  Exemple :

      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

  Ajouté dans la version 3.10.

## Android platform

platform.android_ver(release='', api_level=0, manufacturer='', model='', device='', is_emulator=False)

  Get Android device information. Returns a `namedtuple()` with the following attributes. Values which cannot be determined are set to the defaults given as parameters.

  - `release` - Android version, as a string (e.g. `"14"`).

  - `api_level` - API level of the running device, as an integer (e.g. `34` for Android 14). To get the API level which Python was built against, see `sys.getandroidapilevel()`.

  - `manufacturer` - Manufacturer name.

  - `model` - Model name – typically the marketing name or model number.

  - `device` - Device name – typically the model number or a codename.

  - `is_emulator` - `True` if the device is an emulator; `False` if it's a physical device.

  Google maintains a list of known model and device names.

  Ajouté dans la version 3.13.

## Command-line usage

`platform` can also be invoked directly using the `-m` switch of the interpreter:

    python -m platform [--terse] [--nonaliased] [{nonaliased,terse} ...]

The following options are accepted:

--terse

  Print terse information about the platform. This is equivalent to calling `platform.platform()` with the terse argument set to `True`.

--nonaliased

  Print platform information without system/OS name aliasing. This is equivalent to calling `platform.platform()` with the aliased argument set to `True`.

You can also pass one or more positional arguments (`terse`, `nonaliased`) to explicitly control the output format. These behave similarly to their corresponding options.