대문자와 숫자를 사용한 무작위 문자열 생성

질문자 :Hellnar

크기가 N인 문자열을 생성하고 싶습니다.

다음과 같이 숫자와 영문 대문자로 구성되어야 합니다.

• 6U1S75
• 4Z4UKK
• U911K4

파이썬 방식으로 어떻게 이것을 달성 할 수 있습니까?

한 줄로 대답:

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

random.choices() 사용하여 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))

세부적으로, 추가 재사용을 위한 clean 기능으로:

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

어떻게 작동합니까?

우리는 공통 ASCII 문자 시퀀스를 포함하는 모듈 string 과 임의 생성을 처리하는 모듈 random 가져옵니다.

string.ascii_uppercase + string.digits 는 대문자 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 함수에서는 사용하지 않으므로 Python은 메모리에 목록을 생성하지 않고 요소를 하나씩 즉석에서 생성합니다(자세한 내용은 여기 ) .

elem 'n'배 생성하도록 요청하는 대신 Python에 일련의 문자에서 선택한 임의의 문자를 'n'배 생성하도록 요청할 것입니다.

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

Ignacio Vazquez-Abrams

이 스택 오버플로 질문은 "임의 문자열 Python"에 대한 현재 상위 Google 결과입니다. 현재 최고 답변은 다음과 같습니다.

 ''.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() 을 사용합니다. 이들은 암호화로 안전한 PRNG입니다. random.SystemRandom().choice 대신 random.choice 를 사용하는 것은 잠재적으로 파괴적일 수 있으며 이 질문의 인기를 감안할 때 이미 여러 번 실수를 저질렀습니다.

python3.6 이상을 사용하는 경우 MSeifert의 답변에 언급된 대로 새로운 secrets 모듈을 사용할 수 있습니다.

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

모듈 문서에서는 보안 토큰 을 생성하는 편리한 방법과 모범 사례도 설명 합니다.

Randy Marsh

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

Bijan

더 간단하고 빠르지 만 약간 덜 무작위적인 방법은 random.sample 을 사용하는 것입니다. n-반복이 허용되는 경우 무작위 기반을 n배 확대합니다.

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

참고: random.sample은 문자 재사용을 방지하고 문자 집합의 크기를 곱하면 여러 번 반복할 수 있지만 순수한 임의 선택에 있을 때보다 가능성은 여전히 적습니다. 길이가 6인 문자열로 이동하고 첫 번째 문자로 'X'를 선택하는 경우 선택 예에서 두 번째 문자에 대해 'X'를 얻을 확률은 'X'를 첫 번째 캐릭터. random.sample 구현에서 후속 문자로 'X'를 얻을 확률은 첫 번째 문자로 얻을 확률이 6/7에 불과합니다.

Anurag Uniyal

import uuid lowercase_str = uuid.uuid4().hex

lowercase_str 'cea8b32e00934aaea8c005a35d85a5c0' 과 같은 임의의 값입니다.

 uppercase_str = lowercase_str.upper()

uppercase_str 은 'CEA8B32E00934AAEA8C005A35D85A5C0'

Savad KP

Python 3.6부터는 random 모듈 대신 암호학적으로 안전해야 하는 경우 secrets 모듈을 사용해야 합니다(그렇지 않으면 이 답변은 @Ignacio Vazquez-Abrams의 답변과 동일합니다).

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

한 가지 추가 사항: 목록 이해는 생성기 표현식을 사용하는 것보다 str.join

MSeifert

이를 수행하는 더 빠르고 쉽고 유연한 방법은 strgen 모듈( pip install StringGenerator 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 은 위의 솔루션보다 개발자 시간이 더 빠릅니다. Ignacio의 솔루션은 가장 빠른 런타임 성능을 제공하며 Python 표준 라이브러리를 사용하는 정답입니다. 그러나 당신은 거의 그 형태로 그것을 사용하지 않을 것입니다. SystemRandom(또는 사용할 수 없는 경우 대체)을 사용하고, 필요한 문자 집합이 표시되는지 확인하고, 유니코드를 사용하고(또는 사용하지 않고), 연속 호출이 고유한 문자열을 생성하는지 확인하고, 문자열 모듈 문자 클래스 중 하나의 하위 집합을 사용하고, 등. 이 모든 것은 제공된 답변보다 훨씬 더 많은 코드가 필요합니다. 솔루션을 일반화하려는 다양한 시도는 모두 strgen이 간단한 템플릿 언어를 사용하여 더 간결하고 표현력 있게 해결하는 한계가 있습니다.

PyPI에 있습니다.

 pip install StringGenerator

공개: 저는 strgen 모듈의 작성자입니다.

Paul Wolf

다른 스택 오버플로 답변을 기반으로 임의의 문자열과 임의의 16진수를 만드는 가장 간단한 방법 은 허용되는 답변보다 더 나은 버전입니다.

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

훨씬 더 빨리.

Gubbi

아직 아무도 대답하지 않았다고 생각합니다 lol! 하지만 여기 내 나름대로의 방법이 있습니다.

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

JWL

의사 임의 문자열이 아닌 임의 문자열이 필요한 경우 os.urandom 을 소스로 사용해야 합니다.

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

John La Rooy

이 방법은 Ignacio가 게시한 random.choice() 방법보다 약간 더 빠르고 약간 더 짜증납니다.

의사 난수 알고리즘의 특성을 활용하고 각 문자에 대해 새 난수를 생성하는 것보다 비트 단위 및 시프트를 더 빠르게 뱅크합니다.

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

...아무것도 남지 않을 때까지 0..31번에 5비트 숫자를 가져오는 생성기를 만듭니다.

...join() 올바른 비트가 있는 난수에 대한 생성기의 결과

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

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

...하지만 64자 문자열의 경우 randbits가 손실됩니다 ;)

동료를 정말 싫어하지 않는 한 프로덕션 코드에서 이 접근 방식을 사용하지 않을 것입니다.

편집: 질문에 맞게 업데이트되고(대문자 및 숫자만), % 및 // 대신 비트 연산자 & 및 >>를 사용합니다.

sea-rob

나는 이렇게 할 것이다:

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

Carl Smith

Numpy의 random.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에 있습니다.

Mudit Jain

때로는 0(영) 및 O(문자 O)가 혼동될 수 있습니다. 그래서 나는 사용

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

Aseem

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

user128956

>>> 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 문에 문자를 추가할 수 있도록 목록을 만듭니다. 끝에서 str은 ['t', 'm', '2', 'J', 'U', 'Q', '0', '4', 'C', 'K']이지만 str = "".join(str) 이 처리하여 'tm2JUQ04CK' .

도움이 되었기를 바랍니다!

A.J. Uppal

기능적인 파이썬을 즐기는 사람들을 위해:

 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)

다음 세대를 사용하지 않으려면 간단히 호출 가능하게 만들 수 있습니다.

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

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

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

우리는 sample 을 선택기로 사용하여 전체 선택을 수행하므로 청크는 실제로 길이가 1이고 결합하기 위해 다음으로 완전히 생성된 청크를 가져오는 next

Samy Vilar

(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

Jacob

이것은 Anurag Uniyal의 답변과 제가 직접 작업한 내용입니다.

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

Stopit Donk

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

Natasha

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

여기서 문자열의 길이는 for 루프에서 변경할 수 있습니다. 즉 for i in range(1,length) 이것은 이해하기 쉬운 간단한 알고리즘입니다. 필요하지 않은 문자를 버릴 수 있도록 목록을 사용합니다.

lawlie8

다양한 답변을 보며 시간을 내어 비밀문서를 읽어보았습니다.

secrets 모듈은 암호, 계정 인증, 보안 토큰 및 관련 비밀과 같은 데이터를 관리하는 데 적합한 암호학적으로 강력한 난수를 생성하는 데 사용됩니다.

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

제공해야 하는 기능을 자세히 살펴보면 Google 드라이브 ID와 같은 ID를 모방하려는 경우 매우 편리한 기능을 찾았습니다.

secrets.token_urlsafe([nbytes=없음])
nbytes의 임의 바이트를 포함하는 임의의 URL 안전 텍스트 문자열을 반환합니다. 텍스트는 Base64로 인코딩되므로 평균적으로 각 바이트는 약 1.3자 입니다. nbytes가 None이거나 제공되지 않으면 합리적인 기본값이 사용됩니다.

다음과 같은 방법으로 사용하십시오.

 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의 질문과 약간 다르다는 것을 알고 있지만 내가 찾고 있던 것과 동일한 사용 사례를 찾고 있던 많은 사람들에게 여전히 도움이 될 것으로 기대합니다.

Antonin GAVREL

간단한 것:

 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

Hackaholic

다음 옵션을 제안하고 싶습니다.

 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]

mrvol

두 가지 방법:

 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

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

Bi Ao

문자, 숫자, '_' 및 '-'를 포함하는 임의의 16바이트 ID 생성

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

socketpair

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

Pedro Lobito

사용하기 쉽지만 사용자 정의가 가능한 키 생성기를 원한다면 key-generator pypi 패키지를 사용하십시오.

다음 은 전체 문서를 찾을 수 있는 GitHub 리포지토리입니다.

더 많은 옵션을 사용하여 원하는 문자열 jist를 제공하도록 사용자 정의할 수 있습니다. 다음은 예입니다.

 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

Sahith Kurapati

지금까지 어떤 답변도 위, 아래, 숫자 등과 같은 특정 범주의 문자가 있음을 보장하지 않습니다. 그래서 다른 답변은 숫자가 없는 비밀번호가 될 수 있습니다. 그런 기능이 표준 라이브러리의 일부가 아니라는 사실에 놀랐습니다. 내가 사용하는 것은 다음과 같습니다.

 def random_password(*, nchars = 7, min_nupper = 3, ndigits = 3, nspecial = 3, special=string.punctuation): letters = random.choices(string.ascii_lowercase, k=nchars) letters_upper = random.choices(string.ascii_uppercase, k=min_nupper) digits = random.choices(string.digits, k=ndigits) specials = random.choices(special, k=nspecial) password_chars = letters + letters_upper + digits + specials random.shuffle(password_chars) return ''.join(password_chars)

Oliver

이 방법을 사용하여 a -> z에서 길이가 n인 임의의 문자열을 생성했습니다.

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

Nishan

출처 : http:www.stackoverflow.com/questions/2257441/random-string-generation-with-upper-case-letters-and-digits