# `platform` — Acesso aos dados de identificação da plataforma subjacente

Código-fonte: Lib/platform.py

Nota

Plataformas específicas listadas em ordem alfabética, com Linux incluído na seção Unix.

## Multiplataforma

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

  Consulta o executável fornecido (o padrão é o binário do interpretador Python) para obter várias informações de arquitetura.

  Retorna uma tupla `(bits, linkage)` que contém informações sobre a arquitetura de bits e o formato de linkage usado para o executável. Ambos os valores são retornados como strings.

  Valores que não podem ser determinados são retornados como fornecidos pelas predefinições de parâmetros. Se bits for fornecido como `''`, o `sizeof(pointer)` (ou `sizeof(long)` na versão Python < 1.5.2) é usado como indicador para o tamanho de ponteiro suportado.

  A função depende do comando `file` do sistema para fazer o trabalho real. Isso está disponível na maioria, se não em todas as plataformas Unix e algumas plataformas não Unix e somente se o executável apontar para o interpretador Python. Padrões razoáveis são usados quando as necessidades acima não são atendidas.

  Nota

  No macOS (e talvez em outras plataformas), arquivos executáveis podem ser arquivos universais contendo diversas arquiteturas.

  Para obter a “característica de 64 bits” do interpretador atual, é mais confiável consultar o atributo `sys.maxsize`:

      is_64bits = sys.maxsize > 2**32

platform.machine()

  Retorna o tipo de máquina, por exemplo, `'AMD64'`. Uma string vazia é retornada se o valor não puder ser determinado.

  A saída depende da plataforma e pode diferir nas convenções de nomenclatura e uso de maiúsculas e minúsculas.

platform.node()

  Retorna o nome de rede do computador (pode não ser totalmente qualificado!). Uma string vazia é retornada se o valor não puder ser determinado.

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

  Retorna uma única string identificando a plataforma subjacente com o máximo de informações úteis possível.

  A saída é pretendida para ser legível por humanos em vez de analisável por máquinas. Pode parecer diferente em diferentes plataformas e isso é intencional.

  Se aliased for true, a função usará apelidos para várias plataformas que relatam nomes de sistemas que diferem de seus nomes comuns, por exemplo, SunOS será relatado como Solaris. A função `system_alias()` é usada para implementar isso.

  Definir terse como true faz com que a função retorne apenas o mínimo absoluto de informações necessárias para identificar a plataforma.

  Alterado na versão 3.8: No macOS, a função agora usa `mac_ver()`, se retornar uma string de versão não vazia, para obter a versão do macOS em vez da versão do darwin.

platform.processor()

  Retorna o nome (real) do processador, por exemplo `'amdk6'`.

  Uma string vazia é retornada se o valor não puder ser determinado. Note que muitas plataformas não fornecem essas informações ou simplesmente retornam o mesmo valor que para `machine()`. O NetBSD faz isso.

platform.python_build()

  Retorna uma tupla `(buildno, builddate)` informando o número e a data da construção do Python como strings.

platform.python_compiler()

  Retorna uma string identificando o compilador usado para compilar Python.

platform.python_branch()

  Retorna uma string identificando a branch SCM da implementação do Python.

platform.python_implementation()

  Retorna uma string identificando a implementação do Python. Os valores de retorno possíveis são: ‘CPython’, ‘IronPython’, ‘Jython’, ‘PyPy’.

platform.python_revision()

  Retorna uma string que identifica a revisão do SCM da implementação Python.

platform.python_version()

  Retorna a versão do Python como string `'major.minor.patchlevel'`.

  Observe que, diferentemente do `sys.version` do Python, o valor retornado sempre incluirá o patchlevel (o padrão é 0).

platform.python_version_tuple()

  Retorna a versão do Python como tupla `(major, minor, patchlevel)` de strings.

  Observe que, diferentemente do `sys.version` do Python, o valor retornado sempre incluirá o patchlevel (o padrão é `'0'`).

platform.release()

  Retorna a versão do sistema, por exemplo, `'2.2.0'` ou `'NT'`. Uma string vazia é retornada se o valor não puder ser determinado.

platform.system()

  Retorna o nome do sistema/SO, como `'Linux'`, `'Darwin'`, `'Java'`, `'Windows'`. Uma string vazia é retornada se o valor não puder ser determinado.

  No iOS e Android, isso retorna o nome do SO voltado para o usuário (por exemplo, `'iOS`, `'iPadOS'` ou `'Android'`). Para obter o nome do kernel (`'Darwin'` ou `'Linux'`), use `os.uname()`.

platform.system_alias(system, release, version)

  Retorna `(sistema, release, versão)` com apelido para nomes comuns de marketing usados para alguns sistemas. Ele também faz alguma reordenação das informações em alguns casos em que, de outra forma, causaria confusão.

platform.version()

  Retorna a versão de lançamento do sistema, por exemplo, `'#3 on degas'`. Uma string vazia é retornada se o valor não puder ser determinado.

  No iOS e Android, esta é a versão do SO voltada para o usuário. Para obter a versão do kernel Darwin ou Linux, use `os.uname()`.

platform.uname()

  Interface para uname razoavelmente portátil. Retorna um `namedtuple()` contendo seis atributos: `system`, `node`, `release`, `version`, `machine` e `processor`.

  `processor` é resolvido tardiamente, sob demanda.

  Nota: os dois primeiros nomes de atributos diferem dos nomes apresentados por `os.uname()`, onde são chamados `sysname` e `nodename`.

  As entradas que não podem ser determinadas são definidas como `''`.

  Alterado na versão 3.3: O resultado mudou de uma tupla para `namedtuple()`.

  Alterado na versão 3.9: `processor` é resolvido tarde em vez de imediatamente.

## Plataforma Java

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

  Interface de versão para Jython.

  Retorna uma tupla `(release, vendor, vminfo, osinfo)` com vminfo sendo uma tupla `(vm_name, vm_release, vm_vendor)` e osinfo sendo uma tupla `(os_name, os_version, os_arch)`. Valores que não podem ser determinados são definidos para os padrões fornecidos como parâmetros (que são todos padrão para `''`).

  Descontinuado desde a versão 3.13, será removido na versão 3.15: Ele não foi testado em grande parte, tinha uma API confusa e só era útil para suporte ao Jython.

## Plataforma Windows

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

  Obtém informações adicionais sobre a versão do Registro do Windows e retorna uma tupla `(release, version, csd, ptype)` referente à versão do SO, número da versão, nível do CSD (service pack) e tipo de sistema operacional (processador múltiplo/único). Os valores que não podem ser determinados são definidos para os padrões fornecidos como parâmetros (que são todos padrão para uma string vazia).

  Como dica: ptype é `'Uniprocessor Free'` em máquinas NT de processador único e `'Multiprocessor Free'` em máquinas de multiprocessador. O `'Free'` se refere à versão do sistema operacional que está livre de código de depuração. Ele também pode declarar `'Checked'`, o que significa que a versão do sistema operacional usa código de depuração, ou seja, código que verifica argumentos, intervalos, etc.

platform.win32_edition()

  Retorna uma string representando a edição atual do Windows, ou `None` se o valor não puder ser determinado. Os valores possíveis incluem, mas não estão limitados a `'Enterprise'`, `'IoTUAP'`, `'ServerStandard'` e `'nanoserver'`.

  Adicionado na versão 3.8.

platform.win32_is_iot()

  Retorna `True` se a edição do Windows retornada por `win32_edition()` for reconhecida como uma edição IoT.

  Adicionado na versão 3.8.

## Plataforma macOS

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

  Obtém informações sobre a versão do macOS e retorna-as como tupla `(release, versioninfo, machine)`, sendo versioninfo uma tupla `(version, dev_stage, non_release_version)`.

  Entradas que não podem ser determinadas são definidas como `''`. Todas as entradas de tupla são strings.

## Plataforma iOS

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

  Obtém informações sobre a versão do iOS e retorna-as como `namedtuple()` com os seguintes atributos:

  - `system` é o nome do sistema operacional; `'iOS'` ou `'iPadOS'`.

  - `release` é o número da versão do iOS como uma string (por exemplo, `'17.2'`).

  - `model` é o identificador do modelo do dispositivo; será uma string como `'iPhone13,2'` para um dispositivo físico ou `'iPhone'` em um simulador.

  - `is_simulator` é um booleano que descreve se o aplicativo está sendo executado em um simulador ou em um dispositivo físico.

  As entradas que não podem ser determinadas são definidas para os padrões fornecidos como parâmetros.

## Plataformas Unix

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

  Tenta determinar a versão libc contra a qual o executável do arquivo (padrão para o interpretador Python) está vinculado. Retorna uma tupla de strings `(lib, version)` que tem como padrão os parâmetros fornecidos caso a pesquisa falhe.

  Observe que esta função tem conhecimento profundo de como diferentes versões da libc adicionam símbolos ao executável e provavelmente só pode ser usada para executáveis compilados usando gcc.

  O arquivo é lido e escaneado em blocos de chunksize bytes.

## Plataformas Linux

platform.freedesktop_os_release()

  Obtém a identificação do sistema operacional do arquivo `os-release` e retorna-a como um dict. O arquivo `os-release` é um padrão freedesktop.org e está disponível na maioria das distribuições Linux. Uma exceção notável é o Android e as distribuições baseadas em Android.

  Levanta `OSError` ou subclasse quando nem `/etc/os-release` nem `/usr/lib/os-release` podem ser lidos.

  Em caso de sucesso, a função retorna um dicionário onde chaves e valores são strings. Valores têm seus caracteres especiais como `"` e `$` sem aspas. Os campos `NAME`, `ID` e `PRETTY_NAME` são sempre definidos de acordo com o padrão. Todos os outros campos são opcionais. Os fornecedores podem incluir campos adicionais.

  Note que campos como `NAME`, `VERSION` e `VARIANT` são strings adequadas para apresentação aos usuários. Os programas devem usar campos como `ID`, `ID_LIKE`, `VERSION_ID` ou `VARIANT_ID` para identificar distribuições Linux.

  Exemplo:

      def get_like_distro():
          info = platform.freedesktop_os_release()
          ids = [info["ID"]]
          if "ID_LIKE" in info:
              # ids são separados por espaço e ordenado por precedência
              ids.extend(info["ID_LIKE"].split())
          return ids

  Adicionado na versão 3.10.

## Plataforma Android

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

  Obtém informações do dispositivo Android. Retorna um `namedtuple()` com os seguintes atributos. Valores que não podem ser determinados são definidos para os padrões fornecidos como parâmetros.

  - `release` - Versão do Android, como uma string (por exemplo, `"14"`).

  - `api_level` - Nível de API do dispositivo em execução, como um inteiro (por exemplo, `34` para Android 14). Para obter o nível de API contra o qual o Python foi criado, consulte `sys.getandroidapilevel()`.

  - `manufacturer` - Nome do fabricante.

  - `model` - Nome do modelo – normalmente o nome de marketing ou o número do modelo.

  - `device` - Nome do dispositivo – normalmente o número do modelo ou um codinome.

  - `is_emulator` - `True` se o dispositivo for um emulador; `False` se for um dispositivo físico.

  O Google mantém uma lista de nomes de modelos e dispositivos conhecidos.

  Adicionado na versão 3.13.

## Uso na linha de comando

`platform` também pode ser invocado diretamente usando a opção `-m` do interpretador:

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

As seguintes opções são aceitas:

--terse

  Exibe informações concisas sobre a plataforma. Isso equivale a chamar `platform.platform()` com o argumento terse definido como `True`.

--nonaliased

  Exibe informações da plataforma sem alias de nome do sistema/SO. Isso equivale a chamar `platform.platform()` com o argumento aliased definido como `True`.

Você também pode passar um ou mais argumentos posicionais (`terse`, `nonaliased`) para controlar explicitamente o formato de saída. Eles se comportam de forma semelhante às suas opções correspondentes.