To pytanie o przepełnienie stosu jest aktualnym najlepszym wynikiem Google dla "random string Python". Aktualna odpowiedź brzmi:

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

Jest to doskonała metoda, ale PRNG W random nie jest kryptograficznie Bezpieczny. Zakładam, że wiele osób badających to pytanie będzie chciało wygenerować losowe ciągi do szyfrowania lub haseł. Możesz to zrobić bezpiecznie, wprowadzając niewielką zmianę w powyższym kodzie:

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

Używanie random.SystemRandom() zamiast przypadkowych zastosowań / dev / urandom na * nix maszyn i CryptGenRandom() W Windows. Są to kryptograficznie bezpieczne PRNG. Użycie random.choice zamiast random.SystemRandom().choice w aplikacji, która wymaga bezpiecznego PRNG, może być potencjalnie katastrofalne, a biorąc pod uwagę popularność tego pytania, założę się, że błąd został już popełniony wiele razy.

Jeśli używasz python3. 6 lub nowszego, możesz użyć nowego modułu secrets.

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

Dokumentacja modułu omawia również dogodne sposoby generowania bezpiecznych tokenów i najlepszych praktyki .

Po prostu użyj wbudowanego uuid Pythona:

Jeśli uuid jest odpowiedni do Twoich celów, użyj wbudowanego pakietu uuid .

Rozwiązanie Jednej Linii:

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

Wersja Dogłębna:

Przykład:

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

Jeśli potrzebujesz dokładnie swojego formatu (na przykład "6U1S75"), możesz to zrobić w następujący sposób:

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

Prostszym, szybszym, ale nieco mniej losowym sposobem jest użycie random.sample zamiast wyboru każdej litery osobno, jeśli dozwolone są n-powtórzenia, powiększ swoją losową podstawę O n razy np.

import random
import string

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

Uwaga: przypadkowe.próbka zapobiega ponownemu użyciu znaków, pomnożenie rozmiaru zestawu znaków umożliwia wielokrotne powtórzenia, ale są one jeszcze mniej prawdopodobne, niż są w czystym losowym wyborze. Jeśli wybieramy ciąg o długości 6 i wybieramy 'X' jako pierwszy znak, w przykładzie wyboru, szanse na zdobycie 'X' dla drugiego znaku są takie same jak szanse na zdobycie 'X' jako pierwszego znaku. W przypadkowym.przykładowa implementacja, szanse na uzyskanie 'X' jak każdy kolejny znak są tylko 6/7 szansa na uzyskanie go jako pierwszy znak

import uuid
lowercase_str = uuid.uuid4().hex  

lowercase_str jest wartością losową jak 'cea8b32e00934aaea8c005a35d85a5c0'

uppercase_str = lowercase_str.upper()

uppercase_str is 'CEA8B32E00934AAEA8C005A35D85A5C0'

Biorąc odpowiedź od Ignacio, działa to z Pythonem 2.6:

import random
import string

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

Przykładowe wyjście:

JQUBT2

Szybszym, łatwiejszym i bardziej elastycznym sposobem jest użycie modułu strgen (pip install StringGenerator).

Wygeneruj 6-znakowy losowy ciąg znaków z dużymi literami i cyframi:

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

Uzyskaj unikalną listę:

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

gwarancja jeden "specjalny" znak w łańcuchu:

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

Losowy kolor HTML:

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

Itd.

Musimy mieć świadomość, że to:

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

Może nie mieć w sobie cyfry (lub wielkich liter).

strgen na szybsze w czasie deweloperskim niż jakiekolwiek z powyższych rozwiązań. Rozwiązanie z Ignacio jest najszybszym wykonaniem w czasie i jest właściwą odpowiedzią przy użyciu standardowej biblioteki Pythona. Ale prawie nigdy nie użyjesz go w tej formie. Będziesz chciał użyć SystemRandom (lub fallback, jeśli nie jest dostępny), upewnij się, że wymagane zestawy znaków są reprezentowane, użyj unicode( lub nie), upewnij się, że kolejne wywołania wytwarzają unikalny ciąg znaków, użyj podzbioru jednej z klas znaków modułu string, itp. To wszystko wymaga dużo więcej kodu niż w udzielonych odpowiedziach. Różne próby uogólnienia rozwiązania mają ograniczenia, które strgen rozwiązuje z większą zwięzłością i siłą ekspresji za pomocą prostego języka szablonów.

Jest na PyPI:

pip install StringGenerator

Ujawnienie: jestem autorem modułu strgen.

Jeśli potrzebujesz losowego ciągu zamiast pseudo losowego , powinieneś użyć os.urandom jako źródło

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

Myślałem, że nikt jeszcze na to nie odpowiedział lol! Ale hej, oto mój własny pomysł:

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))], "")

Na podstawie innej odpowiedzi przepełnienia stosu, najlżejszy sposób na stworzenie losowego ciągu i losowej liczby szesnastkowej, lepsza wersja od zaakceptowanej odpowiedzi brzmiałaby:

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

Ta metoda jest nieco szybsza i nieco bardziej irytująca niż losowa.metoda choice ()

Wykorzystuje naturę pseudolosowych algorytmów, a banki na bitowe i i przesunięcie są szybsze niż generowanie nowej liczby losowej dla każdego znaku.

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

...Utwórz generator, który pobiera 5 liczb bitowych na raz 0..31 until none left

...join () wyniki generatora na liczbie losowej z odpowiednimi bitami

Z Timeit, dla 32-znakowych łańcuchów czas wynosił:

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

...ale na 64 ciągi znaków randbits przegrywa;)

Prawdopodobnie nigdy nie użyłbym tego podejścia w kodzie produkcyjnym, chyba że naprawdę nie lubiłem moich współpracowników.

Edit: zaktualizowano, aby odpowiadało pytaniu (tylko wielkie litery i cyfry) i używaj operatorów bitowych & and > > zamiast % i //

Od Pythona 3.6 powinieneś użyć secrets module jeśli potrzebujesz, aby był kryptograficznie Bezpieczny zamiast random module (w przeciwnym razie ta odpowiedź jest identyczna z tą z @Ignacio Vazquez-Abrams):

from secrets import choice
import string

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

Jedna uwaga dodatkowa: zrozumienie listy jest szybsze w przypadku str.join niż użycie wyrażenia generatora!

Zrobiłbym to w ten sposób:

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

Lub po prostu:

def rand_string(length, char_set=legals):

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

Użyj Numpy ' s random.funkcja choice ()

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

Dokumentacja jest tutaj http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.random.choice.html

Dla tych z Was, którzy lubią funkcjonalny python:

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

Generuje nieokreślony [nieskończony] iterator połączonych losowych sekwencji, najpierw generując nieokreśloną sekwencję losowo wybranego symbolu z puli dającej, a następnie dzieląc tę sekwencję na części długości, które są następnie łączone, powinien działać z dowolną sekwencją, która obsługuje getitem, domyślnie po prostu generuje losową sekwencję liter alfanumerycznych, choć można łatwo modyfikować, aby wygenerować inne sekwencje. rzeczy:

Na przykład do generowania losowych krotek cyfr:

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

Jeśli nie chcesz używać next dla generacji, możesz po prostu zrobić go nazywalnym:

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

Jeśli chcesz wygenerować sekwencję w locie, po prostu ustaw join na identity.

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

Jak już inni wspominali, jeśli potrzebujesz większego bezpieczeństwa, ustaw odpowiednią funkcję select:

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

Domyślnym selektorem jest choice, który może wybrać ten sam symbol wiele razy dla każdego fragmentu, jeśli zamiast tego jeśli chcesz, aby ten sam członek był wybierany co najwyżej raz dla każdego kawałka, możliwe użycie:

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

Używamy sample jako naszego selektora, aby wykonać pełną selekcję, więc kawałki mają faktycznie długość 1, A aby dołączyć, po prostu wywołujemy next, który pobiera następny całkowicie wygenerowany fragment, ponieważ ten przykład wydaje się nieco kłopotliwy i jest ...

(1) to da Ci wszystkie caps and numbers:

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) jeśli później chcesz umieścić małe litery w swoim kluczu, będzie to również działać:

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  

To jest spojrzenie na odpowiedź Anurag Uniyal i coś, nad czym pracowałem sam.

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

Następująca logika nadal generuje 6-znakową próbkę losową

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

Nie trzeba mnożyć przez 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'

Funkcja random.choice wybiera losowy wpis na liście. Tworzysz również listę, dzięki czemu możesz dodać znak w instrukcji for. Na końcu str to ['t', 'm', '2', 'J', 'U', 'Q', '0', '4', 'C', 'K'], ale str = "".join(str) zajmuje się tym, zostawiając cię z 'tm2JUQ04CK'.

Prosty:

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

Tutaj Długość łańcucha może być zmieniona w pętli for tzn. dla i w zakresie (1, length) Jest to prosty algorytm, który jest łatwy do zrozumienia. używa listy, więc możesz odrzucić znaki, których nie potrzebujesz.

Chciałbym zaproponować Ci następną opcję:

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

Tryb paranoiczny:

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

Dwie metody:

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

Benchmark:

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

Wyjście:

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

Wydajność pierwszej metody jest lepsza.

Dla Pythona 3 import string, random

''.join(random.choice (string.ascii_lowercase + string.ascii_uppercase + string.cyfry) for _ in range(15))

Uznałem to za prostsze i czystsze.

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 

Wystarczy zmienić 64, aby zmienić długość, zmienić znak, aby zrobić tylko Alfę Alfę lub tylko cyfrę lub dziwne znaki lub cokolwiek chcesz.

Możesz użyć kodu

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;

To losowo wypluwa losowy wzór alfanumeryczny 7, po prostu zmień 7 na dowolną liczbę, a to wytworzy tyle cyfr i / lub liter.

Inny sposób zapisu jest następujący...

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;`

Nie jestem pewien, jak dodać ograniczenia, takie jak robienie go tam, gdzie nie pozwala pewne cyfry i / lub litery być obok siebie lub powtórzyć, takie jak uzyskanie "AAA123", jeśli ktoś wie, jak ograniczyć wynik do masz coś takiego proszę o komentarz