මට N ප්‍රමාණයේ නූලක් ජනනය කිරීමට අවශ්‍යයි.

එය අංක සහ ලොකු අකුරු වලින් සෑදිය යුතුය:

• 6U1S75
• 4Z4UKK
• U911K4

පයිතොනික් ආකාරයකින් මෙය සාක්ෂාත් කරගන්නේ කෙසේද ?

එක් පේළියකින් පිළිතුරු දෙන්න:

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

හෝ ඊටත් වඩා කෙටි පයිතන් 3.6 භාවිතා කරමින් random.choices():

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

ගුප්ත විද්‍යාත්මකව වඩා ආරක්ෂිත අනුවාදයක්; https://stackoverflow.com/a/23728630/2213647 බලන්න :

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

එය ක්‍රියාත්මක වන්නේ කෙසේද?

අපි ආනයනය කරන්නේ string, පොදු ASCII අක්ෂර අනුපිළිවෙල අඩංගු 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ශ්‍රිතයේ නොසිටින බැවින් පයිතන් මතකයේ ලැයිස්තුව නිර්මාණය නොකරයි, නමුත් මැස්සන්ගේ මූලද්‍රව්‍ය එකින් එක ජනනය කරයි (මේ ගැන වැඩි විස්තර මෙහි ).

'N' වාරයක් නිර්මාණය කිරීමට ඉල්ලා සිටීම වෙනුවට elem, අපි අනුපිළිවෙලින් තෝරාගත් අහඹු අක්ෂරයක් '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'

මෙම අහඹු පිටාර ගැලීමේ ප්‍රශ්නය "අහඹු නූල් පයිතන්" සඳහා ගූගල් ඉහළම ප්‍රති result ලය වේ. වර්තමාන ඉහළම පිළිතුර:

''.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()වෙනුවට හුදෙක් අහඹු භාවිතය / dev / urandom * nix යන්ත්ර හා CryptGenRandom()Windows හි. මේවා ගුප්ත විද්‍යාත්මකව ආරක්ෂිත PRNGs වේ. ආරක්ෂිත PRNG අවශ්‍ය වන යෙදුමක් random.choiceවෙනුවට භාවිතා කිරීම random.SystemRandom().choiceවිනාශකාරී විය හැකි අතර, මෙම ප්‍රශ්නයේ ජනප්‍රියතාවය සැලකිල්ලට ගෙන, එම වැරැද්ද දැනටමත් බොහෝ වාර ගණනක් සිදුවී ඇති බව මම විශ්වාස කරමි.

ඔබ python3.6 හෝ ඊට වැඩි භාවිතා කරන්නේ නම්, MSeifert හි පිළිතුරෙහි සඳහන් පරිදි ඔබට නව රහස් මොඩියුලය භාවිතා කළ හැකිය :

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

ආරක්ෂිත ටෝකන සහ හොඳම භාවිතයන් ජනනය කිරීමට පහසු ක්‍රම ද මොඩියුල ලේඛනය සාකච්ඡා කරයි.

පයිතන්ගේ බිල්ඩින් uuid භාවිතා කරන්න:

ඔබගේ අරමුණු සඳහා UUIDs හරි නම්, සාදන ලද 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 ගුණයකින් විශාල කරන්න.

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' ලබා ගැනීමේ අවාසියට සමාන වේ. පළමු චරිතය. සසම්භාවී නියැදි ක්‍රියාවට නැංවීමේදී, ඕනෑම පසු අක්ෂරයක් ලෙස 'X' ලබා ගැනීමේ අවාසිය එය පළමු අක්‍ෂරය ලෙස ලබා ගැනීමේ අවස්ථාව 6/7 ක් පමණි

import uuid
lowercase_str = uuid.uuid4().hex  

lowercase_str වැනි අහඹු අගයකි 'cea8b32e00934aaea8c005a35d85a5c0'

uppercase_str = lowercase_str.upper()

uppercase_str වේ 'CEA8B32E00934AAEA8C005A35D85A5C0'

මෙය කිරීමට වේගවත්, පහසු සහ නම්‍යශීලී ක්‍රමයක් වන්නේ strgenමොඩියුලය ( 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ඉහත ඕනෑම විසඳුමකට වඩා සංවර්ධක කාලය තුළ වේගවත් වේ. ඉග්නේෂියෝ වෙතින් විසඳුම වේගවත්ම ධාවන කාලය වන අතර එය පයිතන් සම්මත පුස්තකාලය භාවිතා කර නිවැරදි පිළිතුර වේ. නමුත් ඔබ එය කිසි විටෙකත් එම ස්වරූපයෙන් භාවිතා නොකරනු ඇත. ඔබට SystemRandom භාවිතා කිරීමට අවශ්‍ය වනු ඇත (හෝ ආපසු ලබා ගත නොහැකි නම්), අවශ්‍ය අක්ෂර කට්ටල නිරූපණය කර ඇති බවට වග බලා ගන්න, යුනිකෝඩ් භාවිතා කරන්න (හෝ නැත), අනුප්‍රාප්තික ආයාචනා අද්විතීය නූලක් නිපදවන බවට වග බලා ගන්න, නූල් මොඩියුල අක්ෂර පන්ති වලින් එකක උප කුලකයක් භාවිතා කරන්න, ආදිය. මේ සියල්ලටම ලබා දී ඇති පිළිතුරු වලට වඩා වැඩි කේතයක් අවශ්‍ය වේ. විසඳුමක් සාමාන්‍යකරණය කිරීමේ විවිධ උත්සාහයන් සියල්ලටම සරල අච්චු භාෂාවක් භාවිතා කරමින් ස්ට්‍රජන් වැඩි සංක්ෂිප්තතාවයකින් සහ ප්‍රකාශන ශක්තියකින් විසඳන සීමාවන් ඇත.

එය PyPI හි ඇත:

pip install StringGenerator

අනාවරණය: මම strgen මොඩියුලයේ කතුවරයා වෙමි.

පයිතන් 3.6 සිට ඔබට secretsමොඩියුලය වෙනුවට ගුප්ත විද්‍යාත්මකව ආරක්‍ෂිත වීමට අවශ්‍ය නම් මොඩියුලය භාවිතා කළ යුතුය random(එසේ නොමැතිනම් මෙම පිළිතුර @ ඉග්නේෂියෝ වාස්කේස්-ඒබ්‍රම්ස්ගේ පිළිතුරට සමාන වේ):

from secrets import choice
import string

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

එක් අමතර සටහනක්: str.joinඋත්පාදක ප්‍රකාශනයක් භාවිතා කිරීමට වඩා ලැයිස්තු-අවබෝධය වේගවත් වේ !

තවත් Stack පමාණය පිළිතුර මත පදනම්ව, බොහෝ සැහැල්ලු අහඹු string නිර්මාණය කිරීමට මග හා අහඹු ෂඩ් දශම සංඛ්යාව , ලොව පිළිගත් පිළිතුර වනු ඇත වඩා හොඳ අනුවාදය:

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

වඩා වේගවත්.

ව්‍යාජ අහඹු එකක් වෙනුවට ඔබට අහඹු නූලක් අවශ්‍ය නම් , ඔබ 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))

මම හිතුවේ කවුරුත් මේකට උත්තර දීලා නෑ ලොල්! නමුත් හේයි, මෙන්න මගේම ගමන එයයි:

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

මෙම ක්‍රමය ඉග්නේෂියෝ විසින් පළ කරන ලද 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 ක් ගන්නා ජනක යන්ත්‍රයක් සාදන්න

... සම්බන්ධ වන්න () නිවැරදි බිටු සමඟ අහඹු අංකයක උත්පාදක යන්ත්රයේ ප්රති results ල

ටයිමිට් සමඟ, අක්ෂර 32 ක් සඳහා, වේලාව වූයේ:

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

... නමුත් අක්ෂර නූල් 64 ක් සඳහා, අහඹු ලෙස නැති වී යයි;)

මගේ සම සේවකයින්ට මා අකමැති නම් මිස මම කිසි විටෙකත් නිෂ්පාදන කේතය තුළ මෙම ප්‍රවේශය භාවිතා නොකරමි.

සංස්කරණය කරන්න: ප්‍රශ්නයට සරිලන පරිදි යාවත්කාලීන කර ඇත (ලොකු අකුරු සහ ඉලක්කම් පමණි), සහ% සහ // වෙනුවට බිට්වේස් ක්‍රියාකරුවන් සහ >> භාවිතා කරන්න

මම එය මේ ආකාරයෙන් කරන්නෙමි:

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

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

සමහර විට 0 (බිංදුව) සහ ඕ (අක්ෂරය 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

ක්‍රියාකාරී පයිතන් භුක්ති විඳින ඔබ සඳහා:

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)

ඔබට මැස්සේ අනුක්‍රමය ජනනය කිරීමට අවශ්‍ය නම් හුදෙක් අනන්‍යතාවයට සම්බන්ධ වන්න.

>>> 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අමතන්නේ ඊළඟට සම්පුර්ණයෙන්ම ජනනය කරන ලද කැබැල්ල ලබා ගන්නේ කුමන උදාහරණයකටද යන්න මෙම උදාහරණය තරමක් අවුල් සහගත බවක් පෙනේ නම් එය ...

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

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

මෙය උපකාරී වේ යැයි සිතමු!

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, දිග) එය තේරුම් ගැනීමට පහසු සරල ඇල්ගොරිතමයකි. එය ලැයිස්තුවක් භාවිතා කරන බැවින් ඔබට අවශ්‍ය නොවන අක්‍ෂර ඉවත දැමිය හැකිය.

සරල එකක්:

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

පළමු ක්‍රමයේ ක්‍රියාකාරිත්වය වඩා හොඳය.

මම පිළිතුරු සියල්ලම පාහේ ගොස් ඇති නමුත් ඒවා කිසිවක් පහසු නැත. පාස්ජන් අත්හදා බැලීමට මම ඔබට යෝජනා කරමිඅහඹු මුරපද සෑදීම සඳහා සාමාන්‍යයෙන් භාවිතා වන පුස්තකාලය .

ඔබ තෝරාගත් දිග, විරාම ලකුණු, ඉලක්කම්, අකුරු සහ නඩුව අහඹු ලෙස උත්පාදනය කළ හැකිය .

ඔබේ නඩුව සඳහා කේතය මෙන්න:

from passgen import passgen
string_length = int(input())
random_string = passgen(length=string_length, punctuation=False, digits=True, letters=True, case='upper')

අහඹු ලෙස 16-බයිට් හැඳුනුම්පත අඩංගු අකුරු, ඉලක්කම්, '_' සහ '-'

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

මම විවිධ පිළිතුරු දෙස බලා රහස් ලේඛන කියවීමට කාලය ගත්තා

මුරපද, ගිණුම් සත්‍යාපනය, ආරක්ෂක ටෝකන සහ අදාළ රහස් වැනි දත්ත කළමනාකරණය කිරීම සඳහා සුදුසු ගුප්ත විද්‍යාත්මකව ශක්තිමත් අහඹු සංඛ්‍යා ජනනය කිරීම සඳහා රහස් මොඩියුලය භාවිතා කරයි.

විශේෂයෙන්, සසම්භාවී මොඩියුලයේ සුපුරුදු ව්‍යාජ-සසම්භාවී සංඛ්‍යා උත්පාදක යන්ත්‍රයට වඩා රහස් භාවිතා කළ යුතු අතර එය නිර්මාණය කර ඇත්තේ ආකෘති නිර්මාණය හා අනුකරණය කිරීම සඳහා මිස ආරක්ෂාව හෝ ගුප්ත ලේඛනකරණය නොවේ.

ගූගල් ඩ්‍රයිව් හැඳුනුම්පත් වැනි හැඳුනුම්පතක් අනුකරණය කිරීමට ඔබට අවශ්‍ය නම් එය ලබා දිය යුතු දේ පිළිබඳව වැඩිදුර සොයා බැලීමේදී මට ඉතා පහසු කාර්යයක් හමු විය:

secrets.token_urlsafe ([nbytes = None])
nbytes අහඹු බයිට් අඩංගු අහඹු URL- ආරක්ෂිත පෙළ පෙළක් ආපසු එවන්න. පා Base ය Base64 කේතනය කර ඇත, එබැවින් සාමාන්‍යයෙන් සෑම බයිටයකම අක්ෂර 1.3 ක් පමණ වේ. Nbytes කිසිවක් නොමැති නම් හෝ සපයා නොමැති නම්, සාධාරණ පෙරනිමියක් භාවිතා වේ.

එය පහත පරිදි භාවිතා කරන්න:

import secrets
import math

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

print(id_generator())

අක්ෂර 32 ක දිග හැඳුනුම්පතක් ප්‍රතිදානය කරන්න:

joXR8dYbBDAHpVs5ci6iD-oIgPhkeQFk

මෙය OP හි ප්‍රශ්නයට වඩා තරමක් වෙනස් බව මම දනිමි, නමුත් මා සොයන එකම භාවිත අවස්ථාව සොයන බොහෝ දෙනෙකුට එය තවමත් ප්‍රයෝජනවත් වනු ඇතැයි මම අපේක්ෂා කරමි.

ඔබට භාවිතයට පහසු නමුත් අතිශයින්ම රිසිකරණය කළ හැකි යතුරු උත්පාදකයක් අවශ්‍ය නම්, key-generatorpypi පැකේජය භාවිතා කරන්න.

මෙන්න ඔබට සම්පූර්ණ ලියකියවිලි සොයාගත හැකි 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මා විසින් සාදන ලද පුස්තකාලය භාවිතා කරයි .

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

මෙය වඩාත් සරල හා පිරිසිදු බව මට පෙනී ගියේය.

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 

දිග වෙනස් කිරීමට 64 වෙනස් කරන්න, ඇල්ෆා පමණක් ඇල්ෆා සංඛ්‍යාත්මක හෝ සංඛ්‍යාත්මක හෝ අමුතු අක්ෂර හෝ ඔබට අවශ්‍ය ඕනෑම දෙයක් කිරීමට අක්ෂර පූල් වෙනස් කරන්න.