# 21.20. `uuid` — Objets UUID d’après la RFC 4122

Code source : Lib/uuid.py

Ce module exporte des objets `UUID` immuables (de la classe `UUID`) et les fonctions `uuid1()`, `uuid3()`, `uuid4()`, `uuid5()` permettant de générer des UUID de version 1, 3, 4 et 5 tels que définis dans la RFC 4122.

Utilisez `uuid1()` ou `uuid4()` si votre but est de produire un identifiant unique. Notez que `uuid1()` peut dévoiler des informations personnelles car l’UUID produit contient l’adresse réseau de l’ordinateur. En revanche, `uuid4()` génère un UUID aléatoire.

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

  Produit un UUID à partir soit d’une chaîne de 32 chiffres hexadécimaux, soit une chaîne de 16 octets gros-boutiste (argument bytes), soit une chaîne de 16 octets petit-boutiste (argument bytes_le), soit un sextuplet d’entiers (32-bit time_low, 16-bit time_mid, 16-bit time_hi_version, 8-bit clock_seq_hi_variant, 8-bit clock_seq_low, 48-bit node) (argument fields), soit un unique entier sur 128 bits (argument int). Lorsque la fonction reçoit une chaîne de chiffres hexadécimaux, les accolades, les tirets et le préfixe URN sont facultatifs. Par exemple, toutes les expressions ci-dessous génèrent le même 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)

  Un seul des arguments hex, bytes, bytes_le, fields ou int doit être spécifié. L’argument version est optionnel : s’il est spécifié, l’UUID généré aura pour numéro de version et de variante la valeur indiquée dans la RFC 4122, remplaçant les bits idoines de hex, bytes, bytes_le, fields ou int.

  La comparaison de deux objets UUID se fait en comparant leurs attributs `UUID.int`. La comparaison avec un objet autre qu’un UUID lève une exception `TypeError`.

  `str(uuid)` renvoie une chaîne de caractères de la forme `12345678-1234-5678-1234-567812345678` représentant l’UUID par une chaîne de 32 chiffres hexadécimaux.

Les instances de `UUID` possèdent les attributs suivants en lecture seule :

`UUID.``bytes`

  L’UUID représenté comme une chaîne de 16 octets (contenant les six champs entiers dans l’ordre gros-boutiste).

`UUID.``bytes_le`

  L’UUID représenté comme une chaîne de 16 octets (avec time_low, time_mid et time_hi_version dans l’ordre petit-boutiste).

`UUID.``fields`

  Un sextuplet contenant les champs entiers de l’UUID, également accessibles en tant que six attributs individuels et deux attributs dérivés :

  Champ | Signification
  --- | ---
  `time_low` | les 32 premiers bits de l’UUID
  `time_mid` | les 16 bits suivants de l’UUID
  `time_hi_version` | les 16 bits suivants de l’UUID
  `clock_seq_hi_variant` | les 8 bits suivants de l’UUID
  `clock_seq_low` | les 8 bits suivants de l’UUID
  `node` | les derniers 48 bits de l’UUID
  `time` | l’horodatage sur 60 bits
  `clock_seq` | le numéro de séquence sur 14 bits

`UUID.``hex`

  Représentation de l’UUID sous forme d’une chaîne de 32 chiffres hexadécimaux.

`UUID.``int`

  Représentation de l’UUId sous forme d’un entier de 128 bits.

`UUID.``urn`

  Représentation de l’UUID sous forme d’URN tel que spécifié dans la RFC 4122.

`UUID.``variant`

  Variante de l’UUID. Celle-ci détermine l’agencement interne de l’UUID. Les valeurs possibles sont les constantes suivantes : `RESERVED_NCS`, `RFC_4122`, `RESERVED_MICROSOFT` ou `RESERVED_FUTURE`.

`UUID.``version`

  Numéro de version de l’UUID (de 1 à 5). Cette valeur n’a de sens que dans le cas de la variante `RFC_4122`.

Le module `uu` définit les fonctions suivantes :

`uuid.``getnode`()

  Get the hardware address as a 48-bit positive integer. The first time this runs, it may launch a separate program, which could be quite slow. If all attempts to obtain the hardware address fail, we choose a random 48-bit number with its eighth bit set to 1 as recommended in RFC 4122. « Hardware address » means the MAC address of a network interface, and on a machine with multiple network interfaces the MAC address of any one of them may be returned.

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

  Génère un UUID à partir d’un identifiant hôte, d’un numéro de séquence et de l’heure actuelle. Si node n’est pas spécifié, la fonction `getnode()` est appelée pour obtenir l’adresse matérielle. clock_seq est utilisé comme numéro de séquence s’il est spécifié, sinon un numéro aléatoire sur 14 bits est utilisé à la place.

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

  Génère un UUID à partir de l’empreinte MD5 de l’identifiant d’un espace de nom (un UUID) et d’un nom (une chaîne de caractères).

`uuid.``uuid4`()

  Génère un UUID aléatoire.

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

  Génère un UUID à partir de l’empreinte SHA-1 de l’identifiant d’un espace de nom (un UUID) et d’un nom (une chaîne de caractères).

Le module `uuid` définit les identifiants d’espaces de noms suivants (pour `uuid3()` et `uuid5()`).

`uuid.``NAMESPACE_DNS`

  Lorsque cet espace de nom est spécifié, la chaîne name doit être un nom de domaine pleinement qualifié (souvent indiqué en anglais par FQDN).

`uuid.``NAMESPACE_URL`

  Lorsque cet espace de nom est spécifié, la chaîne name doit être une URL.

`uuid.``NAMESPACE_OID`

  Lorsque cet espace de nom est spécifié, la chaîne name doit être un OID ISO.

`uuid.``NAMESPACE_X500`

  Lorsque cet espace de nom est spécifié, la chaîne name doit être un DN X.500 au format texte ou DER.

Le module `uuid` définit les constantes suivantes correspondant aux valeurs autorisées pour l’attribut `variant` :

`uuid.``RESERVED_NCS`

  Réservé pour la compatibilité NCS.

`uuid.``RFC_4122`

  Utilise l’agencement des UUID de la RFC 4122.

`uuid.``RESERVED_MICROSOFT`

  Réservé pour la compatibilité Microsoft.

`uuid.``RESERVED_FUTURE`

  Réservé pour un usage futur.

Voir aussi

RFC 4122 – A Universally Unique IDentifier (UUID) URN Namespace

  Cette spécification (en anglais) définit un espace de noms Uniform Resource Name pour les UUID, leur format interne et les méthodes permettant de les générer.

## 21.20.1. Exemple

Voici quelques exemples classiques d’utilisation du module `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')