Esta documentação é de uma versão antiga do Python que não é mais atualizada. Você deveria atualizar e ler a Documentação do Python para versão estável atual.

# `uuid` — UUID objects according to RFC 4122

Código-fonte: Lib/uuid.py

Este módulo fornece objetos `UUID` imutáveis (a classe `UUID`) e as funções `uuid1()`, `uuid3()`, `uuid4()`, `uuid5()` para gerar UUIDs de versão 1, 3, 4 e 5, conforme especificado em RFC 4122.

Se tudo o que você quer é um ID único, você provavelmente deve chamar `uuid1()` ou `uuid4()`. Note que `uuid1()` pode comprometer a privacidade, pois cria um UUID contendo o endereço de rede do computador. `uuid4()` cria um UUID aleatório.

Depending on support from the underlying platform, `uuid1()` may or may not return a “safe” UUID. A safe UUID is one which is generated using synchronization methods that ensure no two processes can obtain the same UUID. All instances of `UUID` have an `is_safe` attribute which relays any information about the UUID’s safety, using this enumeration:

class `uuid.``SafeUUID`

  Novo na versão 3.7.

  `safe`

    O UUID foi gerado pela plataforma de forma segura para multiprocessamento.

  `unsafe`

    O UUID não foi gerado de forma segura para multiprocessamento.

  `unknown`

    A plataforma não fornece informações sobre se o UUID foi gerado com segurança ou não.

class `uuid.``UUID`(hex=None, bytes=None, bytes_le=None, fields=None, int=None, version=None, *, is_safe=SafeUUID.unknown)

  Cria um UUID a partir de uma sequência de 32 dígitos hexadecimais, uma sequência de 16 bytes em ordem big-endian como o argumento bytes, uma sequência de 16 bytes em ordem little-endian como o argumento bytes_le, uma tupla de seis inteiros (time_low de 32 bits, time_mid de 16 bits, time_hi_version de 16 bits, clock_seq_hi_variant de 8 bits, clock_seq_low de 8 bits, node de 48 bits) como o argumento fields ou um único inteiro de 128 bits como o argumento int. Quando uma sequência de dígitos hexadecimais é fornecida, chaves, hifens e um prefixo URN são todos opcionais. Por exemplo, todas essas expressões produzem o mesmo UUID:

      UUID('{12345678-1234-5678-1234-567812345678}')
      UUID('12345678123456781234567812345678')
      UUID('urn:uuid:12345678-1234-5678-1234-567812345678')
      UUID(bytes=b'\x12\x34\x56\x78'*4)
      UUID(bytes_le=b'\x78\x56\x34\x12\x34\x12\x78\x56' +
                    b'\x12\x34\x56\x78\x12\x34\x56\x78')
      UUID(fields=(0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x567812345678))
      UUID(int=0x12345678123456781234567812345678)

  Exatamente um de hex, bytes, bytes_le, fields ou int deve ser fornecido. O argumento version é opcional; se fornecido, o UUID resultante terá sua variante e número de versão definidos de acordo com RFC 4122, substituindo bits no hex, bytes, bytes_le, fields ou int fornecido.

  A comparação de objetos UUID é feita por meio da comparação de seus atributos `UUID.int`. A comparação com um objeto não UUID levanta uma `TypeError`.

  `str(uuid)` retorna uma string no formato `12345678-1234-5678-1234-567812345678` onde os 32 dígitos hexadecimais representam o UUID.

As instâncias `UUID` têm estes atributos de somente leitura:

`UUID.``bytes`

  O UUID como uma string de 16 bytes (contendo os seis campos inteiros em ordem de bytes big-endian).

`UUID.``bytes_le`

  O UUID como uma string de 16 bytes (com time_low, time_mid e time_hi_version em ordem de bytes little-endian).

`UUID.``fields`

  Uma tupla dos seis campos de inteiros do UUID, que também estão disponíveis como seis atributos individuais e dois atributos derivados:

  Campo | Significado
  --- | ---
  `time_low` | os primeiros 32 bits do UUID
  `time_mid` | os próximos 16 bits do UUID
  `time_hi_version` | os próximos 16 bits do UUID
  `clock_seq_hi_variant` | os próximos 8 bits do UUID
  `clock_seq_low` | os próximos 8 bits do UUID
  `node` | the last 48 bits of the UUID
  `time` | the 60-bit timestamp
  `clock_seq` | the 14-bit sequence number

`UUID.``hex`

  O UUID como uma sequência hexadecimal de 32 caracteres minúsculos.

`UUID.``int`

  O UUID como um inteiro de 128 bits.

`UUID.``urn`

  O UUID como um URN conforme especificado no RFC 4122.

`UUID.``variant`

  A variante UUID, que determina o layout interno do UUID. Esta será uma das constantes `RESERVED_NCS`, `RFC_4122`, `RESERVED_MICROSOFT` ou `RESERVED_FUTURE`.

`UUID.``version`

  O número da versão do UUID (1 a 5, significativo somente quando a variante é `RFC_4122`).

`UUID.``is_safe`

  Uma enumeração de `SafeUUID` que indica se a plataforma gerou o UUID de forma segura para multiprocessamento.

  Novo na versão 3.7.

O módulo `uuid` define as seguintes funções:

`uuid.``getnode`()

  Obtém o endereço de hardware como um inteiro positivo de 48 bits. Na primeira vez que isso for executado, ele pode iniciar um programa separado, o que pode ser bem lento. Se todas as tentativas de obter o endereço de hardware falharem, escolhemos um número aleatório de 48 bits com o bit multicast (bit menos significativo do primeiro octeto) definido como 1, conforme recomendado no RFC 4122. “Endereço de hardware” significa o endereço MAC de uma interface de rede. Em uma máquina com várias interfaces de rede, endereços MAC administrados universalmente (ou seja, onde o segundo bit menos significativo do primeiro octeto é não definido) serão preferidos em relação a endereços MAC administrados localmente, mas sem nenhuma outra garantia de ordenação.

  Alterado na versão 3.7: Endereços MAC administrados universalmente são preferidos em vez de endereços MAC administrados localmente, pois os primeiros têm garantia de serem globalmente exclusivos, enquanto os últimos não.

`uuid.``uuid1`(node=None, clock_seq=None)

  Gera um UUID a partir de um ID de host, número de sequência e hora atual. Se node não for fornecido, `getnode()` é usado para obter o endereço de hardware. Se clock_seq for fornecido, ele é usado como o número de sequência; caso contrário, um número de sequência aleatório de 14 bits é escolhido.

`uuid.``uuid3`(namespace, name)

  Generate a UUID based on the MD5 hash of a namespace identifier (which is a UUID) and a name (which is a string).

`uuid.``uuid4`()

  Gera um UUID aleatório.

`uuid.``uuid5`(namespace, name)

  Generate a UUID based on the SHA-1 hash of a namespace identifier (which is a UUID) and a name (which is a string).

O módulo `uuid` define os seguintes identificadores de espaço de nomes para uso com `uuid3()` ou `uuid5()`.

`uuid.``NAMESPACE_DNS`

  When this namespace is specified, the name string is a fully-qualified domain name.

`uuid.``NAMESPACE_URL`

  Quando esse espaço de nomes é especificado, a string name é uma URL.

`uuid.``NAMESPACE_OID`

  Quando esse espaço de nomes é especificado, a string name é um OID ISO.

`uuid.``NAMESPACE_X500`

  Quando esse espaço de nomes é especificado, a string name é um DN X.500 em DER ou um formato de saída de texto.

The `uuid` module defines the following constants for the possible values of the `variant` attribute:

`uuid.``RESERVED_NCS`

  Reservado para compatibilidade com NCS.

`uuid.``RFC_4122`

  Especifica o layout do UUID fornecido no RFC 4122.

`uuid.``RESERVED_MICROSOFT`

  Reservado para compatibilidade com Microsoft.

`uuid.``RESERVED_FUTURE`

  Reservado para definição futura.

Ver também

RFC 4122 - Um espaço de nomes de URN de identificador universalmente exclusivo (UUID)

  Esta especificação define um espaço de nomes de Uniform Resource Name para UUIDs, o formato interno de UUIDs e métodos de geração de UUIDs.

## Exemplo

Aqui estão alguns exemplos de uso típico do módulo `uuid`:

    >>> import uuid

    >>> # make a UUID based on the host ID and current time
    >>> uuid.uuid1()
    UUID('a8098c1a-f86e-11da-bd1a-00112444be1e')

    >>> # make a UUID using an MD5 hash of a namespace UUID and a name
    >>> uuid.uuid3(uuid.NAMESPACE_DNS, 'python.org')
    UUID('6fa459ea-ee8a-3ca4-894e-db77e160355e')

    >>> # make a random UUID
    >>> uuid.uuid4()
    UUID('16fd2706-8baf-433b-82eb-8c7fada847da')

    >>> # make a UUID using a SHA-1 hash of a namespace UUID and a name
    >>> uuid.uuid5(uuid.NAMESPACE_DNS, 'python.org')
    UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')

    >>> # make a UUID from a string of hex digits (braces and hyphens ignored)
    >>> x = uuid.UUID('{00010203-0405-0607-0809-0a0b0c0d0e0f}')

    >>> # convert a UUID to a string of hex digits in standard form
    >>> str(x)
    '00010203-0405-0607-0809-0a0b0c0d0e0f'

    >>> # get the raw 16 bytes of the UUID
    >>> x.bytes
    b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f'

    >>> # make a UUID from a 16-byte string
    >>> uuid.UUID(bytes=x.bytes)
    UUID('00010203-0405-0607-0809-0a0b0c0d0e0f')