web-dev-qa-db-fra.com

Quelle est la meilleure façon de générer des chaînes aléatoires d'une longueur spécifique en Python?

Pour un projet, j'ai besoin d'une méthode pour créer des milliers de chaînes aléatoires tout en limitant les collisions. Je recherche qu'ils ne contiennent que 12 caractères et qu'ils soient en majuscules uniquement. Aucune suggestion?

pythonrandom
36
Brandon

CODE:

from random import choice
from string import ascii_uppercase

print(''.join(choice(ascii_uppercase) for i in range(12)))

SORTIE:

5 exemples: 

QPUPZVVHUNSN
EFJACZEBYQEB
QBQJJEEOYTZY
EOJUSUEAJEEK
QWRWLIWDTDBD

MODIFIER:

Si vous n'avez besoin que de chiffres, utilisez la constante digits au lieu de ascii_uppercase un du module string.

3 exemples: 

229945986931
867348810313
618228923380
96
Peter Varo

Par Django, vous pouvez utiliser get_random_string fonction dans Django.utils.crypto module.

get_random_string(length=12,
    allowed_chars=u'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789')
    Returns a securely generated random string.

    The default length of 12 with the a-z, A-Z, 0-9 character set returns
    a 71-bit value. log_2((26+26+10)^12) =~ 71 bits

Exemple:

get_random_string()
u'ngccjtxvvmr9'

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

Mais si vous ne voulez pas avoir Django, ici en est un code indépendant:

Code:

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 a-z, A-Z, 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))
15
Omid Raha

Pourrait faire un générateur:

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

Tirez ensuite du générateur quand vous en avez besoin ... Soit en utilisant next(random_gen) quand vous en avez besoin, soit en utilisant random_200 = list(islice(random_gen, 200)) par exemple ...

3
Jon Clements
#!/bin/python3
import random
import string
def f(n: int) -> str:
        bytes(random.choices(string.ascii_uppercase.encode('ascii'),k=n)).decode('ascii')

courir plus vite pour très grand n. éviter de concaténer str.

0
把友情留在无盐

Pour les octets pseudo-aléatoires cryptographiquement puissants, vous pouvez utiliser le wrapper pyOpenSSL autour d'OpenSSL.

Il fournit la fonction bytes pour rassembler des séquences pseudo-aléatoires de octets .

from OpenSSL import Rand

b = Rand.bytes(7)

BTW, 12 lettres majuscules est un peu plus que 56 bits d'entropie. Vous n'aurez qu'à lire 7 octets.

0
Sylvain Leroux

Cette fonction génère une chaîne aléatoire de lettres MAJUSCULE de la longueur spécifiée,

par exemple: longueur = 6, générera le modèle de séquence aléatoire suivant

[~ # ~] 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
0
Manoj Selvin