बस पाइथन के बिल्टिन यूयूड का उपयोग करें:

यदि आपके उद्देश्यों के लिए यूयूआईडी ठीक है, तो अंतर्निहित uuid पैकेज का उपयोग करें।

एक रेखा समाधान:

import uuid; str(uuid.uuid4().get_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

(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  

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

आप कोड का उपयोग कर सकते हैं

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;

यह यादृच्छिक 7 अल्फान्यूमेरिक पैटर्न को यादृच्छिक रूप से थूक देगा, बस अपनी इच्छानुसार किसी भी संख्या में 7 को बदलें और यह कई संख्याओं और / या अक्षरों का उत्पादन करेगा।

इसे लिखने का एक और तरीका इस प्रकार है ...

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

मैं इस बात को लेकर अनिश्चित हूं कि इसे बनाने के लिए प्रतिबंधों को कैसे जोड़ना है, जहां यह कुछ संख्याओं और / या अक्षरों को एक-दूसरे के बगल में रहने की अनुमति नहीं देता है या अगर कोई जानता है कि परिणाम को कैसे सीमित करना है, कृपया टिप्पणी करें

इग्नासिओ से जवाब लेते हुए, यह पायथन 2.6 के साथ काम करता है:

import random
import string

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

उदाहरण आउटपुट:

JQUBT2

एक और स्टैक ओवरफ़्लो उत्तर के आधार पर, यादृच्छिक स्ट्रिंग और यादृच्छिक हेक्साडेसिमल संख्या बनाने के लिए सबसे हल्का तरीका स्वीकार्य उत्तर से बेहतर संस्करण होगा:

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

काफी तेज।

एक साधारण एक:

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

ऐसा करने के लिए एक तेज़, आसान और अधिक लचीला तरीका 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'

एक यादृच्छिक एचटीएमएल रंग:

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

आदि।

हमें यह पता होना चाहिए कि यह:

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

इसमें एक अंक (या अपरकेस वर्ण) नहीं हो सकता है।

उपर्युक्त समाधानों में से किसी एक की तुलना में डेवलपर-समय में strgen तेज है। इग्नासिओ का समाधान सबसे तेज़ रन-टाइम प्रदर्शन है और पाइथन मानक लाइब्रेरी का उपयोग करके सही जवाब है। लेकिन आप शायद ही कभी उस रूप में इसका इस्तेमाल करेंगे। आप SystemRandom (या उपलब्ध नहीं होने पर फ़ॉलबैक) का उपयोग करना चाहेंगे, सुनिश्चित करें कि आवश्यक वर्ण सेट का प्रतिनिधित्व किया गया है, यूनिकोड (या नहीं) का उपयोग करें, सुनिश्चित करें कि लगातार चालान एक अद्वितीय स्ट्रिंग उत्पन्न करते हैं, स्ट्रिंग मॉड्यूल वर्ण वर्गों में से किसी एक का सबसेट का उपयोग करें, इत्यादि। सभी को प्रदान किए गए उत्तरों की तुलना में बहुत अधिक कोड की आवश्यकता है। एक समाधान को सामान्यीकृत करने के विभिन्न प्रयासों में सभी की सीमाएं होती हैं जो एक सरल टेम्पलेट भाषा का उपयोग करके अधिक ब्रेवटी और अभिव्यक्तिपूर्ण शक्ति के साथ स्ट्रोजेन हल करती हैं।

यह पीईपीआई पर है:

pip install StringGenerator

प्रकटीकरण: मैं strgen मॉड्यूल के लेखक हूँ।

मैं आपको अगला विकल्प सुझाऊंगा:

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

मैंने सोचा कि किसी ने अभी तक इसका जवाब नहीं दिया था! लेकिन हे, यह मेरा स्वयं का है:

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

यदि आपको छद्म यादृच्छिक एक की बजाय यादृच्छिक स्ट्रिंग की आवश्यकता है, तो आपको स्रोत के रूप में 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))

यह स्टैक ओवरफ़्लो क्विज़न "यादृच्छिक स्ट्रिंग पायथन" के लिए वर्तमान शीर्ष 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))

विंडोज़ में * निक्स मशीनों और CryptGenRandom() पर यादृच्छिक उपयोग / dev / urandom के बजाय CryptGenRandom() का उपयोग करना। ये क्रिप्टोग्राफिक रूप से सुरक्षित पीआरएनजी हैं। random.SystemRandom().choice बजाय random.choice का उपयोग करना। random.choice random.SystemRandom().choice एक ऐसे एप्लिकेशन में random.SystemRandom().choice जो एक सुरक्षित पीआरएनजी की आवश्यकता है, संभावित रूप से विनाशकारी हो सकता है, और इस सवाल की लोकप्रियता को देखते हुए, मुझे लगता है कि गलती पहले से ही कई बार बनाई गई है।

यदि आप python3.6 या ऊपर का उपयोग कर रहे हैं, तो आप नए secrets मॉड्यूल का उपयोग कर सकते हैं।

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

मॉड्यूल दस्तावेज़ सुरक्षित टोकन और सर्वोत्तम प्रथाओं को उत्पन्न करने के सुविधाजनक तरीकों पर भी चर्चा करते हैं ।

एक पंक्ति में जवाब:

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

या random.choices() : का उपयोग कर पाइथन 3.6 के साथ भी छोटा शुरू

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

एक क्रिप्टोग्राफिक रूप से अधिक सुरक्षित संस्करण; https://.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 + string.digits :

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

फिर हम 'एन' तत्वों की सूची बनाने के लिए सूची समझ का उपयोग करते हैं:

>>> 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 फ़ंक्शन में नहीं हैं, इसलिए पाइथन मेमोरी में सूची नहीं बनाता है, लेकिन फ्लाई पर तत्व उत्पन्न करता है, एक-एक करके ( here इसके बारे में अधिक) ।

स्ट्रिंग elem 'n' बनाने के लिए पूछने के बजाय, हम पाइथन से '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'

>>> 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 फ़ंक्शन किसी सूची में यादृच्छिक प्रविष्टि चुनता है। आप एक सूची भी बनाते हैं ताकि आप चरित्र को कथन में जोड़ सकें। अंत में str ['t', 'm', '2', 'J', 'U', 'Q', '0', '4', 'C', 'K'] है, लेकिन str = "".join(str) उस पर ख्याल रखता है, आपको 'tm2JUQ04CK' साथ छोड़ देता है।

उम्मीद है की यह मदद करेगा!

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

import uuid
lowercase_str = uuid.uuid4().hex  

lowercase_str एक यादृच्छिक मान है जैसे 'cea8b32e00934aaea8c005a35d85a5c0'

uppercase_str = lowercase_str.upper()

uppercase_str 'CEA8B32E00934AAEA8C005A35D85A5C0'