Chaînes aléatoires en Python

Comment créer une chaîne aléatoire en Python?

J'avais besoin que ce soit un nombre puis un caractère répété jusqu'à ce que vous ayez terminé

def random_id(length):
    number = '0123456789'
    alpha = 'abcdefghijklmnopqrstuvwxyz'
    id = ''
    for i in range(0,length,2):
        id += random.choice(number)
        id += random.choice(alpha)
    return id

Génération de chaînes à partir (par exemple) de caractères minuscules:

import random, string

def randomword(length):
   letters = string.ascii_lowercase
   return ''.join(random.choice(letters) for i in range(length))

Résultats:

>>> randomword(10)
'vxnxikmhdc'
>>> randomword(10)
'ytqhdohksy'

Puisque cette question est assez, euh, aléatoire, cela peut fonctionner pour vous:

>>> import uuid
>>> print uuid.uuid4()
58fe9784-f60a-42bc-aa94-eb8f1a7e5c17

>>> import random
>>> import string
>>> s=string.lowercase+string.digits
>>> ''.join(random.sample(s,10))
'jw72qidagk

Réponse à la question initiale:

os.urandom(n)

Citation de: http://docs.python.org/2/library/os.html

Renvoie une chaîne de n octets aléatoires adaptée à une utilisation cryptographique.

Cette fonction renvoie des octets aléatoires à partir d'une source aléatoire spécifique au système d'exploitation. Les données renvoyées doivent être suffisamment imprévisibles pour les applications cryptographiques, bien que leur qualité exacte dépende de l'implémentation du système d'exploitation. Sur un système de type UNIX, cela interrogera / dev / urandom, et sous Windows, il utilisera CryptGenRandom. Si une source aléatoire n'est pas trouvée, NotImplementedError sera déclenché.

Pour une interface facile à utiliser avec le générateur de nombres aléatoires fourni par votre plate-forme, veuillez consulter random.SystemRandom.

Vous pouvez créer des personnages ascii aléatoires comme:

import random
print chr(random.randint(0,255))

Et puis construisez une chaîne plus longue comme:

len = 50
print ''.join( [chr(random.randint(0,255)) for i in xrange(0,len)] )

Vous n'avez pas vraiment dit grand-chose sur le type de chaîne aléatoire dont vous avez besoin. Mais dans tous les cas, vous devriez regarder dans le randommodule.

Une solution très simple est collée ci-dessous.

import random

def randstring(length=10):
    valid_letters='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    return ''.join((random.choice(valid_letters) for i in xrange(length)))

print randstring()
print randstring(20)

Parfois, j'ai voulu des chaînes aléatoires semi-prononcables, semi-mémorables.

import random

def randomWord(length=5):
    consonants="bcdfghjklmnpqrstvwxyz"
    vowels="aeiou"

    return "".join(random.choice((consonants,vowels)[i%2]) for i in range(length))

Ensuite,

>>> randomWord()
nibit
>>> randomWord()
piber
>>> randomWord(10)
rubirikiro

Pour éviter les mots de 4 lettres, ne définissez pas lengthsur 4.

Jim

random_name = lambda length: ''.join(random.sample(string.letters, length))

la longueur doit être <= len (string.letters) = 53. exemple de résultat

   >>> [random_name(x) for x in range(1,20)]
['V', 'Rq', 'YtL', 'AmUF', 'loFdS', 'eNpRFy', 'iWFGtDz', 'ZTNgCvLA', 'fjUDXJvMP', 'EBrPcYKUvZ', 'GmxPKCnbfih', 'nSiNmCRktdWZ', 'VWKSsGwlBeXUr', 'i
stIFGTUlZqnav', 'bqfwgBhyTJMUEzF', 'VLXlPiQnhptZyoHq', 'BXWATvwLCUcVesFfk', 'jLngHmTBtoOSsQlezV', 'JOUhklIwDBMFzrTCPub']
>>> 

Prendre plaisir. ;)

Installez ce package:

pip3 install py_essentials

Et utilisez ce code:

from py_essentials import simpleRandom as sr
print(sr.randomString(4))

Plus d'informations sur la méthode, d'autres paramètres sont disponibles ici.

Dans python3.6+vous pouvez utiliser le secretsmodule :

Le module secrets est utilisé pour générer des nombres aléatoires cryptographiquement forts adaptés à la gestion de données telles que les mots de passe, l'authentification de compte, les jetons de sécurité et les secrets associés.

En particulier, les secrets doivent être utilisés de préférence au générateur de nombres pseudo-aléatoires par défaut dans le module aléatoire, qui est conçu pour la modélisation et la simulation, et non pour la sécurité ou la cryptographie.

En testant la génération de 768bitjetons de sécurité, j'ai trouvé:

• random.choices()- 0.000246secondes
• secrets.choice()- 0.003529secondes

Les secretsmodules sont plus lents, mais en dehors des tests, c'est ce que vous devriez utiliser à des fins cryptographiques:

import string, secrets

def random_string(size):        
        letters = string.ascii_lowercase+string.ascii_uppercase+string.digits            
        return ''.join(secrets.choice(letters) for i in range(size))

print(random_string(768))

Cette fonction génère une chaîne aléatoire composée de lettres majuscules, minuscules, de chiffres, passez le séparateur de longueur, no_of_blocks pour spécifier votre format de chaîne

par exemple: len_sep = 4, no_of_blocks = 4 générera le motif suivant,

F4nQ-Vh5z-JKEC-WhuS

Où, le séparateur de longueur ajoutera "-" après 4 caractères

XXXX-

no of blocks générera le motif suivant de caractères sous forme de chaîne

XXXX - XXXX - XXXX - XXXX

si une seule chaîne aléatoire est nécessaire, gardez simplement la variable no_of_blocks égale à 1 et len_sep pour spécifier la longueur de la chaîne aléatoire.

par exemple: len_sep = 10, no_of_blocks = 1, générera le modèle suivant ie. chaîne aléatoire de longueur 10 ,

F01xgCdoDU

import random as r

def generate_random_string(len_sep, no_of_blocks):
    random_string = ''
    random_str_seq = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    for i in range(0,len_sep*no_of_blocks):
        if i % len_sep == 0 and i != 0:
            random_string += '-'
        random_string += str(random_str_seq[r.randint(0, len(random_str_seq) - 1)])
    return random_string

import random 
import string

def get_random_string(size):
    chars = string.ascii_lowercase+string.ascii_uppercase+string.digits
    ''.join(random.choice(chars) for _ in range(size))

print(get_random_string(20)

sortie: FfxjmkyyLG5HvLeRudDS

essayez d'importer le package ci-dessous à partir d'une importation aléatoire *