cette question de débordement de pile est le résultat Google top actuel pour"random string Python". La meilleure réponse actuelle est:

''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(N))

c'est une excellente méthode, mais le PRNG au hasard n'est pas cryptographiquement sûr. Je suppose que beaucoup de gens qui font des recherches sur cette question voudront générer des chaînes aléatoires pour le cryptage ou les mots de passe. Vous pouvez le faire en toute sécurité par un petit changement dans le code ci-dessus:

''.join(random.SystemRandom().choice(string.ascii_uppercase + string.digits) for _ in range(N))

utilisant random.SystemRandom() au lieu de n'utiliser que des utilisations aléatoires /dev/urandom sur les machines *nix et CryptGenRandom() sous Windows. Ils sont cryptographiquement sécurisés PRNGs. L'utilisation de random.choice au lieu de random.SystemRandom().choice dans une application qui exige un PRNG sûr pourrait être potentiellement dévastatrice, et compte tenu de la popularité de cette question, je parie que l'erreur a été faite de nombreuses fois déjà.

si vous utilisez python3.6 ou plus, vous pouvez utiliser le nouveau secrets Module .

''.join(secrets.choice(string.ascii_uppercase + string.digits) for _ in range(N))

le module docs examine également des moyens pratiques pour générer des jetons sécurisés et meilleures pratiques .

utilisez simplement l'uuid de construction de Python:

si les UUIDs conviennent à vos besoins, utilisez le paquet intégré uuid .

Une Solution En Ligne:

import uuid; uuid.uuid4().hex.upper()[0:6]

En Profondeur Version:

exemple:

import uuid
uuid.uuid4() #uuid4 => full random uuid
# Outputs something like: UUID('0172fc9a-1dac-4414-b88d-6b9a6feb91ea')

si vous avez besoin de exactement votre format( par exemple, "6U1S75"), vous pouvez le faire comme ceci:

import uuid

def my_random_string(string_length=10):
    """Returns a random string of length string_length."""
    random = str(uuid.uuid4()) # Convert UUID format to a Python string.
    random = random.upper() # Make all characters uppercase.
    random = random.replace("-","") # Remove the UUID '-'.
    return random[0:string_length] # Return the random string.

print(my_random_string(6)) # For example, D9E50C

un moyen plus simple, plus rapide mais légèrement moins aléatoire est d'utiliser random.sample au lieu de choisir chaque lettre séparément, si n-Les répétitions sont permises, agrandir votre base aléatoire par n fois par exemple

import random
import string

char_set = string.ascii_uppercase + string.digits
print ''.join(random.sample(char_set*6, 6))

Note: aléatoire.échantillon empêche la réutilisation de caractères, la multiplication de la taille de l'ensemble de caractères rend les répétitions multiples possibles, mais ils sont encore moins probables qu'ils sont dans un choix purement aléatoire. Si nous optons pour une chaîne de longueur 6, et nous choisissons " X " comme l' premier caractère, le choix, par exemple, les chances d'obtenir " X "pour le second caractère sont les mêmes que les chances d'obtenir des" X " comme premier caractère. Dans l'aléatoire.la mise en œuvre de l'échantillon, les chances d'Obtenir 'X' comme n'importe quel caractère subséquent sont seulement 6/7 la chance de l'obtenir comme le premier caractère

import uuid
lowercase_str = uuid.uuid4().hex  

lowercase_str est une valeur aléatoire comme 'cea8b32e00934aaea8c005a35d85a5c0'

uppercase_str = lowercase_str.upper()

uppercase_str est 'CEA8B32E00934AAEA8C005A35D85A5C0'

prenant la réponse D'Ignacio, cela fonctionne avec Python 2.6:

import random
import string

N=6
print ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(N))

exemple de sortie:

JQUBT2

une façon plus rapide, plus facile et plus flexible de le faire est d'utiliser le module strgen ( pip install StringGenerator ).

génère une chaîne de caractères aléatoire de 6 caractères avec des lettres majuscules et des chiffres:

>>> from strgen import StringGenerator as SG
>>> SG("[\u\d]{6}").render()
u'YZI2CI'

obtenir une liste unique:

>>> SG("[\l\d]{10}").render_list(5,unique=True)
[u'xqqtmi1pOk', u'zmkWdUr63O', u'PGaGcPHrX2', u'6RZiUbkk2i', u'j9eIeeWgEF']

garantie un caractère" spécial" dans la chaîne:

>>> SG("[\l\d]{10}&[\p]").render()
u'jaYI0bcPG*0'

une couleur html aléatoire:

>>> SG("#[\h]{6}").render()
u'#CEdFCa'

etc.

nous devons être conscients que cela:

''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(N))

ne pourrait pas avoir un chiffre ou un caractère en majuscule).

strgen est plus rapide, le développeur de temps qu'aucune des solutions ci-dessus. La solution D'Ignacio est la plus rapide et est la bonne réponse en utilisant la bibliothèque standard de Python. Mais vous ne l'utiliserez jamais sous cette forme. Vous voudrez utiliser SystemRandom (ou repli si non disponible), assurez-vous que les jeux de caractères requis sont représentés, utilisez unicode (ou non), assurez-vous que les invocations successives produisent une chaîne unique, utilisez un sous-ensemble de l'une des classes de caractères du module de chaîne, etc. Tout cela nécessite beaucoup plus de code que dans les réponses fournies. Les différentes tentatives de généralisation d'une solution ont toutes des limites que strgen résout avec plus de brièveté et de puissance expressive en utilisant un langage de modèle simple.

C'est sur PyPI:

pip install StringGenerator

Divulgation: je suis l'auteur de la strgen module.

si vous avez besoin d'une chaîne aléatoire plutôt que d'une pseudo aléatoire , vous devez utiliser os.urandom comme source

from os import urandom
from itertools import islice, imap, repeat
import string

def rand_string(length=5):
    chars = set(string.ascii_uppercase + string.digits)
    char_gen = (c for c in imap(urandom, repeat(1)) if c in chars)
    return ''.join(islice(char_gen, None, length))

je pensais que personne n'avait encore répondu à cela lol! Mais bon, j'ai mon propre go:

import random

def random_alphanumeric(limit):
    #ascii alphabet of all alphanumerals
    r = (range(48, 58) + range(65, 91) + range(97, 123))
    random.shuffle(r)
    return reduce(lambda i, s: i + chr(s), r[:random.randint(0, len(r))], "")

basé sur une autre réponse de dépassement de pile, la façon la plus légère de créer une chaîne aléatoire et un nombre hexadécimal aléatoire , une meilleure version que la réponse acceptée serait:

('%06x' % random.randrange(16**6)).upper()

beaucoup plus rapide.

Cette méthode est légèrement plus rapide, et un peu plus ennuyeux, que l'aléatoire.choix () méthode Ignacio affiché.

Il tire avantage de la nature des algorithmes pseudo-aléatoires, et les banques sur bitwise et et shift étant plus rapide que la génération d'un nouveau nombre aléatoire pour chaque caractère.

# must be length 32 -- 5 bits -- the question didn't specify using the full set
# of uppercase letters ;)
_ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789'

def generate_with_randbits(size=32):
    def chop(x):
        while x:
            yield x & 31
            x = x >> 5
    return  ''.join(_ALPHABET[x] for x in chop(random.getrandbits(size * 5))).ljust(size, 'A')

...créer un générateur qui prend 5 bits effectifs à la date 0..31 jusqu'à ce qu'il n'en reste plus

...join() les résultats de l' générateur sur un nombre aléatoire avec les bits de droite

avec Timeit, pour des chaînes de 32 caractères, le timing était:

[('generate_with_random_choice', 28.92901611328125),
 ('generate_with_randbits', 20.0293550491333)]

...mais pour 64 chaînes de caractères, randbits perd;)

Je n'utiliserais probablement jamais cette approche dans le code de production à moins que je n'aime vraiment pas mes collègues.

modifier: mis à jour pour répondre à la question (majuscule et chiffres seulement), et utiliser les opérateurs bitwise & et > > au lieu de % et //

de Python 3.6 sur vous devez utiliser le secrets module si vous avez besoin qu'il soit cryptographiquement sécurisé au lieu du random module (sinon cette réponse est identique à celle de @Ignacio Vazquez-Abrams):

from secrets import choice
import string

''.join([choice(string.ascii_uppercase + string.digits) for _ in range(N)])

une note supplémentaire: une compréhension de liste est plus rapide dans le cas de str.join que d'utiliser une expression de générateur!

je le ferais de cette façon:

import random
from string import digits, ascii_uppercase

legals = digits + ascii_uppercase

def rand_string(length, char_set=legals):

    output = ''
    for _ in range(length): output += random.choice(char_set)
    return output

ou juste:

def rand_string(length, char_set=legals):

    return ''.join( random.choice(char_set) for _ in range(length) )

utilisez le hasard de Numpy.choix () fonction

import numpy as np
import string        

if __name__ == '__main__':
    length = 16
    a = np.random.choice(list(string.ascii_uppercase + string.digits), length)                
    print(''.join(a))

la Documentation est ici http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.random.choice.html

pour ceux d'entre vous qui aiment Python fonctionnel:

from itertools import imap, starmap, islice, repeat
from functools import partial
from string import letters, digits, join
from random import choice

join_chars = partial(join, sep='')
identity = lambda o: o

def irand_seqs(symbols=join_chars((letters, digits)), length=6, join=join_chars, select=choice, breakup=islice):
    """ Generates an indefinite sequence of joined random symbols each of a specific length
    :param symbols: symbols to select,
        [defaults to string.letters + string.digits, digits 0 - 9, lower and upper case English letters.]
    :param length: the length of each sequence,
        [defaults to 6]
    :param join: method used to join selected symbol, 
        [defaults to ''.join generating a string.]
    :param select: method used to select a random element from the giving population. 
        [defaults to random.choice, which selects a single element randomly]
    :return: indefinite iterator generating random sequences of giving [:param length]
    >>> from tools import irand_seqs
    >>> strings = irand_seqs()
    >>> a = next(strings)
    >>> assert isinstance(a, (str, unicode))
    >>> assert len(a) == 6
    >>> assert next(strings) != next(strings)
    """
    return imap(join, starmap(breakup, repeat((imap(select, repeat(symbols)), None, length))))

il génère un itérateur indéfini [infini], de séquences aléatoires jointes, en générant d'abord une séquence indéfinie de symbole choisi au hasard à partir de la piscine donnant, puis en cassant cette séquence en parties de longueur qui est ensuite joint, il devrait fonctionner avec toute séquence qui soutient getitem, par défaut il génère simplement une séquence aléatoire de lettres alphanumériques, bien que vous pouvez facilement Modifier pour générer d'autres choses:

par exemple pour générer des tuples aléatoires de chiffres:

>>> irand_tuples = irand_seqs(xrange(10), join=tuple)
>>> next(irand_tuples)
(0, 5, 5, 7, 2, 8)
>>> next(irand_tuples)
(3, 2, 2, 0, 3, 1)

si vous ne voulez pas utiliser next pour la génération, vous pouvez simplement le rendre appelable:

>>> irand_tuples = irand_seqs(xrange(10), join=tuple)
>>> make_rand_tuples = partial(next, irand_tuples) 
>>> make_rand_tuples()
(1, 6, 2, 8, 1, 9)

si vous voulez générer la séquence à la volée, définissez join to identity.

>>> irand_tuples = irand_seqs(xrange(10), join=identity)
>>> selections = next(irand_tuples)
>>> next(selections)
8
>>> list(selections)
[6, 3, 8, 2, 2]

comme d'autres l'ont mentionné si vous avez besoin de plus de sécurité, définissez la fonction select appropriée.:

>>> from random import SystemRandom
>>> rand_strs = irand_seqs(select=SystemRandom().choice)
'QsaDxQ'

le sélecteur par défaut est choice qui peut sélectionner le même symbole plusieurs fois pour chaque morceau, si au lieu de cela vous voulez que le même membre soit sélectionné au plus une fois pour chaque morceau alors, une utilisation possible:

>>> from random import sample
>>> irand_samples = irand_seqs(xrange(10), length=1, join=next, select=lambda pool: sample(pool, 6))
>>> next(irand_samples)
[0, 9, 2, 3, 1, 6]

nous utilisons sample comme notre sélecteur, pour faire la sélection complète, donc les morceaux sont en fait Longueur 1, et pour rejoindre nous appelons simplement next qui va chercher le prochain morceau complètement généré, accordé ce exemple semble un peu lourd et de il est ...

(1) cela vous donnera tous les capuchons et les numéros:

import string, random
passkey=''
for x in range(8):
    if random.choice([1,2]) == 1:
        passkey += passkey.join(random.choice(string.ascii_uppercase))
    else:
        passkey += passkey.join(random.choice(string.digits))
print passkey 

(2) Si vous voulez plus tard inclure des lettres minuscules dans votre clé, alors cela fonctionnera aussi:

import string, random
passkey=''
for x in range(8):
    if random.choice([1,2]) == 1:
        passkey += passkey.join(random.choice(string.ascii_letters))
    else:
        passkey += passkey.join(random.choice(string.digits))
print passkey  

il s'agit d'une prise sur la réponse D'Anurag Uniyal et quelque chose que je travaillais sur moi-même.

import random
import string

oneFile = open('‪Numbers.txt', 'w')
userInput = 0
key_count = 0
value_count = 0
chars = string.ascii_uppercase + string.digits + string.punctuation

for userInput in range(int(input('How many 12 digit keys do you want?'))):
    while key_count <= userInput:
        key_count += 1
        number = random.randint(1, 999)
        key = number

        text = str(key) + ": " + str(''.join(random.sample(chars*6, 12)))
        oneFile.write(text + "\n")
oneFile.close()

>>> import string 
>>> import random

la logique suivante génère encore un échantillon aléatoire de 6 caractères

>>> print ''.join(random.sample((string.ascii_uppercase+string.digits),6))
JT7K3Q

pas besoin de multiplier par 6

>>> print ''.join(random.sample((string.ascii_uppercase+string.digits)*6,6))

TK82HK

>>> import random
>>> str = []
>>> chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'
>>> num = int(raw_input('How long do you want the string to be?  '))
How long do you want the string to be?  10
>>> for k in range(1, num+1):
...    str.append(random.choice(chars))
...
>>> str = "".join(str)
>>> str
'tm2JUQ04CK'

la fonction random.choice sélectionne une entrée aléatoire dans une liste. Vous créez également une liste de sorte que vous pouvez ajouter le caractère dans la déclaration for . À la fin str ['t', 'm', '2', 'J', 'U', 'Q', '0', '4', 'C", "K"], "mais le str = "".join(str) prend soin de cela, vous laissant avec 'tm2JUQ04CK' .

Espérons que cette aide!

un simple:

import string
import random
character = string.lowercase + string.uppercase + string.digits + string.punctuation
char_len = len(character)
# you can specify your password length here
pass_len = random.randint(10,20)
password = ''
for x in range(pass_len):
    password = password + character[random.randint(0,char_len-1)]
print password

import string
from random import *
characters = string.ascii_letters + string.punctuation  + string.digits
password =  "".join(choice(characters) for x in range(randint(8, 16)))
print password

import random
q=2
o=1
list  =[r'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','s','0','1','2','3','4','5','6','7','8','9','0']
while(q>o):
    print("")

    for i in range(1,128):
        x=random.choice(list)
        print(x,end="")

ici la longueur de chaîne peut être changée pour boucle I. e pour i dans la gamme (1, Longueur) C'est un algorithme simple qui est facile à comprendre. il utilise la liste de sorte que vous pouvez jeter des caractères dont vous n'avez pas besoin.

je voudrais vous suggérer la prochaine option:

import crypt
n = 10
crypt.crypt("any sring").replace('/', '').replace('.', '').upper()[-n:-1]

mode Paranoïque:

import uuid
import crypt
n = 10
crypt.crypt(str(uuid.uuid4())).replace('/', '').replace('.', '').upper()[-n:-1]

deux méthodes:

import random, math

def randStr_1(chars:str, length:int) -> str:
    chars *= math.ceil(length / len(chars))
    chars = letters[0:length]
    chars = list(chars)
    random.shuffle(characters)

    return ''.join(chars)

def randStr_2(chars:str, length:int) -> str:
    return ''.join(random.choice(chars) for i in range(chars))

la Référence :

from timeit import timeit

setup = """
import os, subprocess, time, string, random, math

def randStr_1(letters:str, length:int) -> str:
    letters *= math.ceil(length / len(letters))
    letters = letters[0:length]
    letters = list(letters)
    random.shuffle(letters)
    return ''.join(letters)

def randStr_2(letters:str, length:int) -> str:
    return ''.join(random.choice(letters) for i in range(length))
"""

print('Method 1 vs Method 2', ', run 10 times each.')

for length in [100,1000,10000,50000,100000,500000,1000000]:
    print(length, 'characters:')

    eff1 = timeit("randStr_1(string.ascii_letters, {})".format(length), setup=setup, number=10)
    eff2 = timeit("randStr_2(string.ascii_letters, {})".format(length), setup=setup, number=10)
    print('\t{}s : {}s'.format(round(eff1, 6), round(eff2, 6)))
    print('\tratio = {} : {}\n'.format(eff1/eff1, round(eff2/eff1, 2)))

sortie:

Method 1 vs Method 2 , run 10 times each.

100 characters:
    0.001411s : 0.00179s
    ratio = 1.0 : 1.27

1000 characters:
    0.013857s : 0.017603s
    ratio = 1.0 : 1.27

10000 characters:
    0.13426s : 0.151169s
    ratio = 1.0 : 1.13

50000 characters:
    0.709403s : 0.855136s
    ratio = 1.0 : 1.21

100000 characters:
    1.360735s : 1.674584s
    ratio = 1.0 : 1.23

500000 characters:
    6.754923s : 7.160508s
    ratio = 1.0 : 1.06

1000000 characters:
    11.232965s : 14.223914s
    ratio = 1.0 : 1.27

la performance de la première méthode est meilleure.

pour python 3 chaîne d'importation, aléatoire

".join(aléatoire.choix(chaîne de caractères.ascii_lowercase + chaîne.ascii_uppercase + chaîne.chiffres) pour _ dans la gamme(15))

j'ai trouvé cela plus simple et plus propre.

str_Key           = ""
str_FullKey       = "" 
str_CharacterPool = "01234ABCDEFfghij~>()"
for int_I in range(64): 
    str_Key = random.choice(str_CharacterPool) 
    str_FullKey = str_FullKey + str_Key 

il suffit de changer le 64 pour varier la longueur, faire varier le CharacterPool alpha seulement alphanumérique ou numérique seulement ou des caractères étranges ou ce que vous voulez.

vous pouvez utiliser le code

var chars = "ABC123";
        var random = new Random();
        var result = new string(
            Enumerable.Repeat(chars, 7) //Change 7 to any number of characters you want in your outcome
                      .Select(s => s[random.Next(s.Length)])
                      .ToArray());

        textBox1.Text = result;

cela va cracher au hasard un 7 motif alphanumérique aléatoire, il suffit de changer le 7 à n'importe quel nombre que vous souhaitez et il produira que beaucoup de nombres et/ou de lettres.

une autre façon d'écrire ceci est la suivante...

var chars = "ABC123";
var stringChars = new char[7]; //Change 7 to any number of characters you want in your outcome
var random = new Random();

for (int i = 0; i < stringChars.Length; i++)
{

stringChars[i] = chars[random.Next(chars.Length)];

}

var finalString = new String(stringChars);

textBox1.Text = finalstring;`

Je ne sais pas comment ajouter des restrictions telles que le fait de le faire à l'endroit où il ne permet pas à certains nombres et / ou lettres d'être à côté de l'autre ou de répéter comme obtenir "AAA123" si quelqu'un sait comment restreindre le résultat pour avoir quelque chose comme ça s'il vous plaît commenter retour