대문자 및 숫자를 사용한 랜덤 문자열 생성

대문자 및 숫자를 사용한 랜덤 문자열 생성

다음과 같은 숫자와 대문자 영문자로 구성된 N 크기의 문자열을 생성하려면 어떻게 해야 합니까?

• 6U1S75
• 4Z4UKK
• U911K4

한 줄의 답변:

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

또는 Python 3.6부터는 다음을 사용하여 더 짧습니다.

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

암호화적으로 더 안전한 버전: 이 투고를 참조해 주세요.

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

세부사항: 더 이상 재사용할 수 있는 깨끗한 기능 포함:

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

어떻게 작동합니까?

포트를 Import .string ASCII와 ASCII의 시퀀스를 포함하는random랜덤 생성을 처리하는 모듈입니다.

string.ascii_uppercase + string.digits의 ASCII 및합니다.ASCII 문자 목록입니다.

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

그런 다음 목록 이해를 사용하여 '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']

에서는 '어울리지 않다', '어울리지 않다'를 하고 있습니다.[은 할 수 에는 할 수 .id_generator기능 그래서 파이선 메모리의 목록을 만드는 것이 아니라, 비행 중에 요소를 하나씩(더 이 문제에 관해 여기서)에 의해 생성합니다.

' 'n을 생성하도록 'n'을 생성하십시오.elem에 대해 중에서 문자의 'Python ★★★★★★★★★★★★★★★.

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

따라서 '''는random.choice(chars) for _ in range(size) '대로'를 .size성격.무작위로 끼어드는에서 따진다는 캐릭터.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']

어차피 우린 빈 문자열과 시퀀스가 되는 문자열입니다. 그들 참가한다.

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

"파이선 문자열 무작위"이것은 StackOverflowquesion은 현재 위 구글 결과이다.현재 위 답: 있다.

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

이것은 아주 훌륭한 메서드이지만 그 PRNG 무작위에 암호로 안전치 않다.많은 사람들이 이 질문에 대한 연구가 암호화나 비밀 번호를 무작위적인 문자열을 생성하기를 원할 것이라고 전망한다.당신은 안전하게 위의 코드에서 작은 변화를 만드는 것에 의해:이 할 수 있다.

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

「」를 사용합니다.random.SystemRandom()*및 *nix 머신에서 을 사용하는 /dev/urandom을 CryptGenRandom()Windows(윈도우)PRNG.「」를 사용합니다.random.choicerandom.SystemRandom().choice안전한 PRNG를 필요로 하는 어플리케이션에서는 잠재적으로 파괴적일 수 있으며, 이 질문의 인기를 감안할 때, 저는 그 실수가 이미 여러 번 일어났을 것이라고 확신합니다.

python3.6 이상을 사용하는 경우 MSeifert의 답변에 나와 있는 새로운 비밀 모듈을 사용할 수 있습니다.

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

모듈 문서에서는 안전한 토큰을 생성하는 편리한 방법과 베스트프랙티스에 대해서도 설명합니다.

Python의 내장 UUID를 사용하면 됩니다.

UUID가 목적에 적합할 경우 내장된 UUID 패키지를 사용합니다.

단일 라인 솔루션:

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

상세 버전:

예:

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

포맷이 정확하게 필요한 경우(예: "6U1S75") 다음과 같이 할 수 있습니다.

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

덜은 '하다'를 사용하는 것입니다.random.sample하는 것이 되는 경우 "n" "n" "n" "n" "n" ).

import random
import string

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

주의: random.sample은 문자 집합의 크기를 곱하면 여러 번 반복할 수 있지만 순수한 랜덤 선택일 때보다 반복 가능성이 낮습니다.첫 번째 문자로 X를 선택하면 두 번째 문자로 X를 받을 확률은 첫 번째 문자로 X를 받을 확률과 같습니다.random.sample 구현에서는 후속 문자로 "X"를 받을 확률은 첫 번째 문자로 받을 확률의 6/7에 불과합니다.

import uuid
lowercase_str = uuid.uuid4().hex  

lowercase_str입니다.'cea8b32e00934aaea8c005a35d85a5c0'

uppercase_str = lowercase_str.upper()

uppercase_str'CEA8B32E00934AAEA8C005A35D85A5C0'

Python 3.6부터 암호화로 보안 보호가 필요한 경우 보안 모듈을 사용해야 합니다.random 않으면 이 은 @): module (@Ignacio Vazquez-Abrams)

from secrets import choice
import string

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

더 주의:는 is한 one of of of in one one음음음음음음음음음음음음음음음음 one one one one one one one one one one one one one one one one one one one one one one one one one one one 。str.join발전기를 표현을 사용해 온!발전기 식을 사용하는 것보다더 낫습니다!

이를 위한 보다 빠르고 쉽고 유연한 방법은 모듈을 사용하는 것입니다(pip install StringGenerator).

대문자 및 숫자를 사용하여 6자 랜덤 문자열을 생성합니다.

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

원하는 목록 가져오기:

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

문자열에서 "특수" 문자를 하나 보장합니다.

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

임의의 HTML 색상:

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

기타.

다음 사항에 유의해야 합니다.

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

에는 숫자(또는 대문자)가 포함되지 않을 수 있습니다.

strgen있나 더 빨리developer-time은 그 위의 솔루션보다.위의 어떤 솔루션보다 개발 시간이 빠릅니다.이그나시오에서 해결책은 가장 빠른 런타임을 수행하고 옳은 답은 파이썬 표준 라이브러리를 사용하여.Ignacio의 솔루션은 실행 시간이 가장빠르며 파이썬 표준 Library를 사용하는것이 정답입니다.하지만 거의 그 형태에서 사용할 것이다.하지만 그런 형태로는 거의 사용하지 않을 겁니다.당신은 SystemRandom(또는 대체 만약 가용하지 않음)사용할, 필요한 문자 집합을 나타내는 있는지 확인한unicode( 아니)을 사용하도록 연속적인 바라는 기원을 독특한 문자열을 생산하게 한 문자열 모듈 성격의 수업 등의 하위 집합을 사용한다 하고 싶을 것이다SystemRandom(또는 사용할 수 없는 경우 폴백), 필요한문자집합이 표현되어 있는지, Unicode(또는 사용할 수 없는 경우)를 사용하고, 연속 호출을 통해 고유한 문자열이 생성되는지, 문자열 모듈 문자열 클래스의 서브셋을 사용하는 등의 작업을 수행할 수 있습니다.이것은 모든 대답에보다 더 많은 코드 제공이 필요하다.이 모든 것은 제공된 답변보다 훨씬 더 많은 코드를 필요로 합니다.그 다양한 시도 해결책을 일반화하는 것 모두 더욱 큰 간결하고 표현한 파워는 단순한 템플릿 언어를 이용하여 해결 strgen 제한을 두고 있다.솔루션을 일반화하기 위한 다양한 시도에는 모두 단순한 템플릿 언어를 사용하여 보다 간결하고 표현력 있게 해결할 수 있는 한계가 있습니다.

파이에 있어요.PI:

pip install StringGenerator

공개:저는 스트겐 모듈의 저자입니다.

다른 스택 오버플로 응답인 랜덤 문자열과 랜덤16 진수를 작성하는 Most Lightweight 방법에 따르면 허용되는 응답보다 좋은 버전은 다음과 같습니다.

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

훨씬 더 빨리.

아직 아무도 대답하지 않은 줄 알았어. 하하!하지만 나 혼자 할 수 있는 일이 있어

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

의사 랜덤 문자열이 아닌 랜덤 문자열이 필요한 경우 를 소스로 사용해야 합니다.

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

이 방법은 랜덤보다 약간 빠르고 약간 더 귀찮습니다.choice() 메서드 Ignacio가 게시했습니다.

이는 의사 랜덤 알고리즘의 특성을 이용하여 각 문자에 대해 새로운 난수를 생성하는 것보다 비트 및 시프트를 뱅킹합니다.

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

...한 번에 5비트 번호를 추출하는 제너레이터를 만듭니다.남아있지 않을 때까지 31번

...generator()는 올바른 비트를 가진 랜덤 번호의 생성기 결과입니다.

Timeit에서는 32글자 문자열의 타이밍은 다음과 같습니다.

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

...단, 64글자 문자열에서는 랜디비트가 손실됩니다.

동료들이 정말 싫지 않다면 생산 코드에 이 방식을 사용하지 않을 것입니다.

edit: 질문에 맞게 업데이트(숫자 및 숫자만), % 및 // 대신 비트 연산자 & > 및 >

Numpy의 랜덤을 사용합니다.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))

매뉴얼은 http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.random.choice.html 에서 입수 가능합니다.

난 이렇게 할 거야:

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

아니면 그냥:

def rand_string(length, char_set=legals):

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

0(제로)과 O(문자 O)가 혼동될 수 있습니다.그래서 저는

import uuid
uuid.uuid4().hex[:6].upper().replace('0','X').replace('O','Y')

>>> import string 
>>> import random

다음 논리는 여전히 6자 랜덤 샘플을 생성합니다.

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

6을 곱할 필요가 없다

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

TK82HK

이 메서드를 사용하여 -> z에서 길이 n의 임의의 문자열을 생성했습니다.

import random
s = ''.join(random.choice([chr(i) for i in range(ord('a'),ord('z'))]) for _ in range(10))

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

random.choice함수는 목록에서 임의의 항목을 선택합니다. 좋다 라는 할 수 있습니다.for에는 [' ' 'K'가 스트링 에는 [t', 'm', '2', 'J', 'U', '0', '0', '0', '0', '4'가 있습니다str = "".join(str)해, 「」를 남깁니다.'tm2JUQ04CK'.

이게 도움이 됐으면 좋겠네요!

기능적인 비단뱀을 즐겨 찾는 분들을 위해:

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

그것은 우선 주어진 풀에서 무작위로 선택된 기호의 무한 시퀀스를 생성한 다음 이 시퀀스를 결합되는 길이 부분으로 분할함으로써 결합 랜덤 시퀀스의 무한 [무한] 반복자를 생성하며, 기본적으로 getitem을 지원하는 모든 시퀀스와 함께 작동해야 하며, 기본적으로 단순히 알파의 랜덤 시퀀스를 생성합니다.숫자 문자(단, 다른 것을 생성하도록 쉽게 수정할 수 있습니다)

예를 들어, 자릿수의 랜덤 튜플을 생성합니다.

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

세대를 위해 next를 사용하고 싶지 않은 경우는, 간단하게 콜 가능 상태로 할 수 있습니다.

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

즉석에서 시퀀스를 생성하려면 join을 identity로 설정하기만 하면 됩니다.

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

다른 사용자가 언급했듯이 보안이 더 필요한 경우 적절한 선택 기능을 설정하십시오.

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

는 " " " 입니다.choice 같은 번 할 수 각 를 한 할 수 한 사용법이 있습니다. 대신 각 청크에 대해 동일한 멤버를 한 번만 선택하려는 경우 한 가지 사용 방법이 있습니다.

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

는 용하고다 we를 사용한다sample이고, '1로, 1로, '1'이라고 합니다.또한 단순히 결합하기 위해서next하다이 예에서는 조금 번거로운 것 같습니다.

(1) 다음과 같은 모든 대문자와 숫자가 표시됩니다.

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) 나중에 키에 소문자를 포함할 경우 다음과 같이 동작합니다.

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  

이것은 아누락 유니얄의 응답에 대한 견해이며, 저 스스로 노력하고 있던 것입니다.

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

나는 다른 답을 보다가 비밀 문서를 읽는 시간을 가졌다.

비밀 모듈은 암호, 계정 인증, 보안 토큰 및 관련 비밀 등의 데이터 관리에 적합한 암호로 강력한 난수를 생성하기 위해 사용됩니다.

특히 비밀은 보안이나 암호화가 아닌 모델링과 시뮬레이션을 위해 설계된 랜덤 모듈의 기본 의사 난수 발생기보다 우선적으로 사용해야 한다.

Google 드라이브 ID와 같은 ID를 모방하고 싶을 때 매우 편리한 기능을 찾았습니다.

=Nonetoken_urlsafe([nbytes=None])
nbytes 랜덤바이트를 포함한 임의의 URL 안전 텍스트 문자열을 반환합니다.텍스트는 Base64로 인코딩되어 있기 때문에 각 바이트는 평균 약 1.3글자가 됩니다.nbytes 가 [None] 또는 [not supped]인 경우 적절한 기본값이 사용됩니다.

다음과 같이 사용합니다.

import secrets
import math

def id_generator():
    id = secrets.token_urlsafe(math.floor(32 / 1.3))
    return id

print(id_generator())

32 문자 길이의 ID 를 출력합니다.

joXR8dYbBDAHpVs5ci6iD-oIgPhkeQFk

OP의 질문과는 조금 다른 내용인 것은 알지만, 제가 찾고 있던 것과 같은 사용 사례를 찾고 있는 많은 분들에게 도움이 될 것으로 기대하고 있습니다.

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

여기서 문자열의 길이는 루프에 대해 변경할 수 있습니다. 즉, i의 경우 범위(1, length)는 이해하기 쉬운 단순한 알고리즘입니다.목록을 사용하기 때문에 불필요한 문자를 삭제할 수 있습니다.

보안 지향 접근법

보안과 관련된 모든 권장 사항은 "자신의 소유로 롤링"하지 않고 보안에 대해 특별히 검사된 비밀 모듈을 사용하는 것입니다.

이것은 문서의 베스트프랙티스 섹션에 기재되어 있습니다.

import string
import secrets
alphabet = string.ascii_letters + string.digits
password = ''.join(secrets.choice(alphabet) for i in range(8))

대문자만 하면 .ascii_uppercase★★★★★★에ascii_letters를 대문자로

password = password.upper()

보안을 목적으로 하지 않는 표준 접근법

이 문제에 대한 표준 접근법(지정된 대로)에서는 랜덤모듈의 선택() 함수를 사용합니다.

>>> from random import choices
>>> from string import ascii_uppercase, digits

>>> population = ascii_uppercase + digits
>>> str.join('', choices(population, k=6))
'6JWF1H'

간단한 질문:

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 crypt
n = 10
crypt.crypt("any sring").replace('/', '').replace('.', '').upper()[-n:-1]

편집 모드:

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

import string, random
lower = string.ascii_lowercase
upper = string.ascii_uppercase
digits = string.digits
special = '!"£$%^&*.,@#/?'

def rand_pass(l=4, u=4, d=4, s=4):
    p = []
    [p.append(random.choice(lower)) for x in range(l)]
    [p.append(random.choice(upper)) for x in range(u)]
    [p.append(random.choice(digits)) for x in range(d)]
    [p.append(random.choice(special)) for x in range(s)]
    random.shuffle(p)
    return "".join(p)

print(rand_pass())
# @5U,@A4yIZvnp%51

두 가지 방법:

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

벤치마크:

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

출력:

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

첫 번째 방법은 성능이 더 좋습니다.

임의 16바이트 ID 생성 문자, 숫자, '_' 및 '-'

os.urandom(16).translate((f'{string.ascii_letters}{string.digits}-_'*4).encode('ascii'))

가 필요한 를 합니다.key-generator피피

여기 완전한 문서를 찾을 수 있는 GitHub repo가 있습니다.

원하는 문자열 목록을 더 많은 옵션과 함께 제공하도록 커스터마이즈할 수 있습니다.다음은 예를 제시하겠습니다.

from key_generator.key_generator import generate

custom_key = generate(2, ['-', ':'], 3, 10, type_of_value = 'char', capital = 'mix', seed = 17).get_key()
print(custom_key)  # ZLFdHXIUe-ekwJCu

이것이 도움이 되기를 바랍니다:)

「 」: 「 」를 사용합니다.key-generator내가 만든 도서관

언급URL : https://stackoverflow.com/questions/2257441/random-string-generation-with-upper-case-letters-and-digits