Génération aléatoire de chaînes de caractères avec des lettres majuscules et des chiffres en Python

je veux générer une chaîne de taille N.

, Il devrait être composé de chiffres et de lettres majuscules lettres anglaises telles que:

  • 6U1S75
  • 4Z4UKK
  • U911K4

Comment puis-je réaliser cela de manière pythonique ?

1033
demandé sur Peter Mortensen 2010-02-13 15:23:58
la source

27 ответов

Réponse en une seule ligne:

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

ou même plus court à partir de Python 3.6 en utilisant random.choices() :

''.join(random.choices(string.ascii_uppercase + string.digits, k=N))

d'Un point de vue cryptographique version plus sécurisée; voir https://stackoverflow.com/a/23728630/2213647 :

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

en détail, avec une fonction propre pour une réutilisation ultérieure:

>>> import string
>>> import random
>>> def id_generator(size=6, chars=string.ascii_uppercase + string.digits):
...    return ''.join(random.choice(chars) for _ in range(size))
...
>>> id_generator()
'G5G74W'
>>> id_generator(3, "6793YUIO")
'Y3U'

comment ça marche ?

nous importons string , un module qui contient des séquences de caractères ASCII communs , et random , un module qui traite de la génération aléatoire.

string.ascii_uppercase + string.digits concaténate simplement la liste des caractères représentant les caractères ASCII en majuscules et les chiffres:

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.digits
'0123456789'
>>> string.ascii_uppercase + string.digits
'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'

alors nous utilisons une liste de compréhension pour créez une liste d'éléments 'n':

>>> range(4) # range create a list of 'n' numbers
[0, 1, 2, 3]
>>> ['elem' for _ in range(4)] # we use range to create 4 times 'elem'
['elem', 'elem', 'elem', 'elem']

dans l'exemple ci-dessus, nous utilisons [ pour créer la liste, mais nous ne le faisons pas dans la fonction id_generator donc Python ne crée pas la liste en mémoire, mais génère les éléments à la volée, un par un (plus sur ce ici ).

au lieu de demander de créer 'N' times la chaîne de caractères elem , nous allons demander à Python de créer ' N ' times un caractère aléatoire, choisi à partir d'un séquence de caractères:

>>> random.choice("abcde")
'a'
>>> random.choice("abcde")
'd'
>>> random.choice("abcde")
'b'

donc random.choice(chars) for _ in range(size) crée vraiment une séquence de caractères size . Caractères choisis au hasard dans chars :

>>> [random.choice('abcde') for _ in range(3)]
['a', 'b', 'b']
>>> [random.choice('abcde') for _ in range(3)]
['e', 'b', 'e']
>>> [random.choice('abcde') for _ in range(3)]
['d', 'a', 'c']

ensuite nous les joignons avec une chaîne vide de sorte que la séquence devient une chaîne:

>>> ''.join(['a', 'b', 'b'])
'abb'
>>> [random.choice('abcde') for _ in range(3)]
['d', 'c', 'b']
>>> ''.join(random.choice('abcde') for _ in range(3))
'dac'
2105
répondu Ignacio Vazquez-Abrams 2018-08-04 10:28:53
la source

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 .

468
répondu Randy Marsh 2017-12-11 01:33:25
la source

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
135
répondu Bijan 2018-07-31 21:13:36
la source

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

41
répondu Anurag Uniyal 2016-02-13 10:44:39
la source
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'

24
répondu Savad KP 2018-01-25 12:03:28
la source

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

18
répondu quamrana 2014-05-31 15:19:33
la source

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.

16
répondu Paul Wolf 2014-08-26 15:47:33
la source

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))
8
répondu John La Rooy 2012-12-09 23:01:56
la source

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))], "")
8
répondu nemesisfixx 2014-03-01 02:31:19
la source

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.

8
répondu Gubbi 2017-05-23 15:02:59
la source

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 //

6
répondu Rob 2013-01-08 19:40:14
la source

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!

6
répondu MSeifert 2017-01-04 16:12:55
la source

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) )
4
répondu Carl Smith 2013-10-12 23:42:53
la source

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

3
répondu Mudit Jain 2017-09-04 10:18:37
la source

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 ...

2
répondu Samy Vilar 2015-02-02 21:02:12
la source

(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  
2
répondu Jacob 2016-04-22 06:50:49
la source

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()
2
répondu Stopit Donk 2017-07-01 07:28:02
la source
>>> 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
2
répondu user128956 2017-12-17 19:47:07
la source
>>> 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!

1
répondu A.J. Uppal 2014-01-30 08:13:41
la source

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
1
répondu Hackaholic 2014-10-24 02:03:18
la source
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
1
répondu Natasha 2016-05-11 14:22:02
la source
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.

1
répondu lawlie8 2018-08-22 14:25:58
la source

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]
0
répondu mrvol 2017-10-05 19:58:21
la source

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.

0
répondu Bi Ao 2018-04-22 11:17:56
la source

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

0
répondu Foki 2018-05-04 07:37:16
la source

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.

-1
répondu M T Head 2017-07-21 02:54:33
la source

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

-5
répondu Rage 2015-07-09 03:06:39
la source

Autres questions sur python string random