Como criar um GUID / UUID em Python

Como crio um GUID no Python que é independente da plataforma? Ouvi dizer que existe um método usando o ActivePython no Windows, mas é o Windows apenas porque ele usa COM. Existe um método usando Python simples?

O módulo uuid, no Python 2.5 e superior, fornece geração UUID compatível com RFC. Consulte a documentação do módulo e a RFC para obter detalhes. [ fonte ]

Documentos:

• Python 2: http://docs.python.org/2/library/uuid.html
• Python 3: https://docs.python.org/3/library/uuid.html

Exemplo (trabalhando em 2 e 3):

>>> import uuid
>>> uuid.uuid4()
UUID('bd65600d-8669-4903-8a14-af88203add38')
>>> str(uuid.uuid4())
'f50ec0b7-f960-400d-91f0-c42a6d44e3d0'
>>> uuid.uuid4().hex
'9fe2c4e93f654fdbb24c02b15259716c'

Se você estiver usando o Python 2.5 ou posterior, o módulo uuid já está incluído na distribuição padrão do Python.

Ex:

>>> import uuid
>>> uuid.uuid4()
UUID('5361a11b-615c-42bf-9bdb-e2c3790ada14')

Copiado de: https://docs.python.org/2/library/uuid.html (Como os links publicados não estavam ativos e continuam atualizando)

>>> 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
'\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')

Eu uso GUIDs como chaves aleatórias para operações do tipo banco de dados.

A forma hexadecimal, com traços e caracteres extras, parece desnecessariamente longa para mim. Mas também gosto que cadeias de caracteres que representam números hexadecimais sejam muito seguras, pois não contêm caracteres que podem causar problemas em algumas situações, como '+', '=', etc.

Em vez de hexadecimal, eu uso uma string base64 segura para URL. O seguinte não está de acordo com nenhuma especificação UUID / GUID (exceto a quantidade necessária de aleatoriedade).

import base64
import uuid

# get a UUID - URL safe, Base64
def get_a_uuid():
    r_uuid = base64.urlsafe_b64encode(uuid.uuid4().bytes)
    return r_uuid.replace('=', '')

Se você precisar passar o UUID para uma chave primária para o seu modelo ou campo exclusivo, o código abaixo retornará o objeto UUID -

 import uuid
 uuid.uuid4()

Se você precisar passar o UUID como parâmetro para o URL, faça o seguinte abaixo do código -

import uuid
str(uuid.uuid4())

Se você quiser o valor hexadecimal para um UUID, faça o seguinte:

import uuid    
uuid.uuid4().hex

Esta função é totalmente configurável e gera um uid exclusivo com base no formato especificado

por exemplo: - [8, 4, 4, 4, 12], este é o formato mencionado e irá gerar o seguinte uuid

LxoYNyXe-7hbQ-caJt-DSdU-PDAht56cMEWi

 import random as r

 def generate_uuid():
        random_string = ''
        random_str_seq = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
        uuid_format = [8, 4, 4, 4, 12]
        for n in uuid_format:
            for i in range(0,n):
                random_string += str(random_str_seq[r.randint(0, len(random_str_seq) - 1)])
            if n != 12:
                random_string += '-'
        return random_string

Resposta 2019 (para Windows):

Se você deseja um UUID permanente que identifique uma máquina exclusivamente no Windows, use este truque: (Copiado da minha resposta em https://stackoverflow.com/a/58416992/8874388 ).

from typing import Optional
import re
import subprocess
import uuid

def get_windows_uuid() -> Optional[uuid.UUID]:
    try:
        # Ask Windows for the device's permanent UUID. Throws if command missing/fails.
        txt = subprocess.check_output("wmic csproduct get uuid").decode()

        # Attempt to extract the UUID from the command's result.
        match = re.search(r"\bUUID\b[\s\r\n]+([^\s\r\n]+)", txt)
        if match is not None:
            txt = match.group(1)
            if txt is not None:
                # Remove the surrounding whitespace (newlines, space, etc)
                # and useless dashes etc, by only keeping hex (0-9 A-F) chars.
                txt = re.sub(r"[^0-9A-Fa-f]+", "", txt)

                # Ensure we have exactly 32 characters (16 bytes).
                if len(txt) == 32:
                    return uuid.UUID(txt)
    except:
        pass # Silence subprocess exception.

    return None

print(get_windows_uuid())

Usa a API do Windows para obter o UUID permanente do computador, depois processa a cadeia de caracteres para garantir que seja um UUID válido e, por fim, retorna um objeto Python ( https://docs.python.org/3/library/uuid.html ), que oferece uma conveniência maneiras de usar os dados (como número inteiro de 128 bits, sequência hexadecimal etc.).

Boa sorte!

PS: A chamada de subprocesso provavelmente poderia ser substituída por ctypes chamando diretamente o kernel / DLLs do Windows. Mas, para meus propósitos, essa função é tudo que preciso. Faz validação forte e produz resultados corretos.

Confira este post, me ajudou muito. Em suma, a melhor opção para mim foi:

import random 
import string 

# defining function for random 
# string id with parameter 
def ran_gen(size, chars=string.ascii_uppercase + string.digits): 
    return ''.join(random.choice(chars) for x in range(size)) 

# function call for random string 
# generation with size 8 and string  
print (ran_gen(8, "AEIOSUMA23")) 

Porque eu precisava de apenas 4-6 caracteres aleatórios em vez de GUID volumoso.