¿Cuál es la mejor manera de generar cadenas aleatorias de una longitud específica en Python?

Para un proyecto, necesito un método para crear miles de cadenas aleatorias mientras mantengo bajas las colisiones. Estoy buscando que tengan solo 12 caracteres de longitud y solo en mayúsculas. ¿Alguna sugerencia?

CÓDIGO:

from random import choice from string import ascii_uppercase print(''.join(choice(ascii_uppercase) for i in range(12))) 

SALIDA:

5 ejemplos:

 QPUPZVVHUNSN EFJACZEBYQEB QBQJJEEOYTZY EOJUSUEAJEEK QWRWLIWDTDBD 

EDITAR:

Si solo necesita dígitos, use la constante de digits lugar de la ascii_uppercase del módulo de string .

3 ejemplos:

 229945986931 867348810313 618228923380 

Por Django , puede usar la función django.utils.crypto en el módulo django.utils.crypto .

 get_random_string(length=12, allowed_chars=u'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789') Returns a securely generated random string. The default length of 12 with the az, AZ, 0-9 character set returns a 71-bit value. log_2((26+26+10)^12) =~ 71 bits 

Ejemplo:

 get_random_string() u'ngccjtxvvmr9' get_random_string(4, allowed_chars='bqDE56') u'DDD6' 

Pero si no quieres tener Django , aquí tienes un código independiente:

Código:

 import random import hashlib import time SECRET_KEY = 'PUT A RANDOM KEY WITH 50 CHARACTERS LENGTH HERE !!' try: random = random.SystemRandom() using_sysrandom = True except NotImplementedError: import warnings warnings.warn('A secure pseudo-random number generator is not available ' 'on your system. Falling back to Mersenne Twister.') using_sysrandom = False def get_random_string(length=12, allowed_chars='abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'): """ Returns a securely generated random string. The default length of 12 with the az, AZ, 0-9 character set returns a 71-bit value. log_2((26+26+10)^12) =~ 71 bits """ if not using_sysrandom: # This is ugly, and a hack, but it makes things better than # the alternative of predictability. This re-seeds the PRNG # using a value that is hard for an attacker to predict, every # time a random string is required. This may change the # properties of the chosen random sequence slightly, but this # is better than absolute predictability. random.seed( hashlib.sha256( ("%s%s%s" % ( random.getstate(), time.time(), SECRET_KEY)).encode('utf-8') ).digest()) return ''.join(random.choice(allowed_chars) for i in range(length)) 

Podría hacer un generador:

 from string import ascii_uppercase import random from itertools import islice def random_chars(size, chars=ascii_uppercase): selection = iter(lambda: random.choice(chars), object()) while True: yield ''.join(islice(selection, size)) random_gen = random_chars(12) print next(random_gen) # LEQIITOSJZOQ print next(random_gen) # PXUYJTOTHWPJ 

Luego, simplemente extraiga del generador cuando sea necesario … next(random_gen) cuando los necesite o use random_200 = list(islice(random_gen, 200)) por ejemplo …

Esta función genera una cadena aleatoria de letras MAYÚSCULAS con la longitud especificada,

por ejemplo: longitud = 6, generará el siguiente patrón de secuencia aleatoria

YLNYVQ

  import random as r def generate_random_string(length): random_string = '' random_str_seq = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" for i in range(0,length): if i % length == 0 and i != 0: random_string += '-' random_string += str(random_str_seq[r.randint(0, len(random_str_seq) - 1)]) return random_string 

Para los bytes pseudo-aleatorios criptográficamente fuertes, puede usar el ajuste pyOpenSSL alrededor de OpenSSL.

Proporciona la función de bytes para reunir una secuencia pseudoaleatoria de bytes .

 from OpenSSL import rand b = rand.bytes(7) 

Por cierto, 12 letras mayúsculas es un poco más que 56 bits de entropía. Solo tendrás que leer 7 bytes.