"platform" ---  Access to underlying platform's identifying data
****************************************************************

**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.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. "'i386'". An empty string is
   returned if the value cannot be determined.

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=0, terse=0)

   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.

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.

platform.uname()

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

   Note that this adds a sixth attribute ("processor") not present in
   the "os.uname()" result.  Also, the attribute names are different
   for the first two attributes; "os.uname()" names them "sysname" and
   "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()".


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


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

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

   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'".

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

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


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.
