Răspunde într-o singură linie:

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

sau chiar mai scurte începând cu Python 3.6 folosind aleatoare.alegeri():

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

O criptografice versiune mai sigură; a se vedea https://stackoverflow.com/a/23728630/2213647:

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

În detalii, cu o funcție pentru reutilizare ulterioară:

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

Cum funcționează ?

Noi de import string, un modul care conține secvențe de comun caractere ASCII, și "aleatorie", un modul care se ocupa cu generarea aleatoare.

`string.ascii_uppercase + string.cifre doar concateneaza lista de caractere reprezentând majuscule ASCII caractere și cifre:

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

Apoi vom folosi o listă de înțelegere pentru a crea o listă de 'n' elemente:

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

În exemplul de mai sus, vom folosi [ pentru a crea lista, dar nu ne't în `id_generator funcția Python nu't crea lista din memorie, dar generează elementele pe zbor, unul câte unul (mai multe despre acest aici).

În loc de a cere pentru a crea 'n' ori șirul elem, vom cere Python pentru a crea 'n' ori un caracter aleatoriu, ales dintr-o secvență de caractere:

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

Prin urmare aleatorie.alegerea(caractere) pentru _ în intervalul(dimensiune)într-adevăr este de a crea o secvență de "dimensiune" de caractere. Personaje care sunt culese la întâmplare dinchars`:

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

Atunci ne vom alătura lor cu un șir gol astfel încât secvența devine un șir de caractere:

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

Acest Stack Overflow quesion este actualul top Google rezultat pentru "șir aleator Python". Actualul top răspunsul este:

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

Aceasta este o metodă excelentă, dar PRNG în mod aleatoriu nu este criptografice sigure. Presupun că mulți oameni cercetarea la această întrebare va dori pentru a genera aleatoriu siruri de caractere pentru criptare sau parole. Puteți face acest lucru în siguranță, de a face o mică schimbare în codul de mai sus:

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

Folosind aleatorie.SystemRandom()în loc de doar o întâmplare foloseste /dev/urandom pe *nix mașini șiCryptGenRandom()` din Windows. Acestea sunt criptografice sigure PRNGs. Folosind aleatorie.alegerea "în loc de" aleatoare.SystemRandom().alegerea într-o aplicație care necesită o secure PRNG ar putea fi devastatoare, și având în vedere popularitatea de această întrebare, pun pariu că greșeala a fost făcută de mai multe ori deja.

Daca're folosind python3.6 sau mai sus, puteți folosi noua secrete modul cum se menționează în MSeifert's a răspunde:

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

Modulul docs discuta, de asemenea, convenabil moduri de a a genera jetoane sigure și cele mai bune practici.

Pur și simplu utilizați Python's built-uuid:

Dacă Uuid-urile sunt ok pentru scopurile tale, utilizați built-in uuid pachet.

O Soluție Linie:

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

În Profunzime Versiune:

Exemplu:

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

Dacă aveți nevoie de exact formatul (de exemplu, "6U1S75"), o poti face astfel:

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

Mai simplu, mai rapid, dar mai puțin aleatoare mod este de a utiliza aleatorie.proba` în loc de a alege fiecare literă separat, Dacă n-repetiții sunt permise, extindeți dvs. și aleatoriu de n ori, de exemplu

import random
import string

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

Notă: aleatoare.proba previne caracter reutilizare, înmulțirea dimensiunea setului de caractere face mai multe repetari posibile, dar ele sunt mai puțin probabil, atunci ele sunt într-o pură întâmplare alegere. Dacă mergem pentru un șir de lungime 6, și vom alege 'X' ca primul caracter, în alegerea exemplu, șansele de a obține 'X' pentru cel de-al doilea personaj sunt aceleași ca și șansele de a obține 'X' ca primul caracter. În mod aleatoriu.exemplu de implementare, șansele de a obține 'X' ca orice caracter ulterioară sunt doar 6/7 șansa de a obține-l ca primul caracter

import uuid
lowercase_str = uuid.uuid4().hex  

lowercase_str este o valoare aleatoare ca 'cea8b32e00934aaea8c005a35d85a5c0'

uppercase_str = lowercase_str.upper()

uppercase_str "este" 'CEA8B32E00934AAEA8C005A35D85A5C0'

Un mod mai rapid, mai ușor și mai flexibil mod de a face acest lucru este de a utiliza strgen modulul (pip instala StringGenerator).

Genera un 6 caractere aleatoare șir cu litere majuscule și cifre:

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

Obține o listă unică:

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

Guarantee unul "speciale" caracter din șir:

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

O întâmplare de culoare HTML:

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

etc.

Trebuie să fim conștienți de faptul că acest lucru:

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

s-ar putea să nu aibă o cifră (sau majusculă) în ea.

strgen este mai rapid în producător-time, decât oricare dintre soluțiile de mai sus. Soluția de Ignacio este cel mai rapid run-time performante și este răspunsul corect utilizând Biblioteca Standard Python. Dar, niciodata nu se va folosi în această formă. Veți dori să utilizați SystemRandom (sau de rezervă, dacă nu sunt disponibile), asigurați-vă că este necesar seturi de caractere sunt reprezentate, utilizarea unicode (sau nu), asigurați-vă că succesive invocații produce un șir unic, utilizați un subset de un șir de module clase de caractere, etc. Toate acestea necesită o mulțime mai mult cod decât în răspunsurile oferite. Diferitele încercări de a generaliza o soluție de avea limitări care strgen rezolvă cu o mai mare concizie și putere expresivă, folosind un model simplu limba.

L's pe PyPI:

pip install StringGenerator

Dezvăluire: am'm autorul strgen module.

De Python 3.6 pe tine ar trebui să utilizeze "secrete" modul if ai nevoie de ea pentru a fi criptografice secure în loc de "aleator" module (în caz contrar, acest răspuns este identică cu cea de @Ignacio Vazquez-Abrams):

from secrets import choice
import string

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

O notă suplimentară: o listă de înțelegere este mai rapid în cazul din str.alătură-te decât cu ajutorul unui generator de exprimare!

Bazat pe un alt Teanc de Preaplin răspuns, cel Mai ușor mod de a crea un șir aleator și aleatoriu un număr hexazecimal, o versiune mai bună decât a acceptat răspunsul ar fi:

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

mult mai rapid.

Am crezut că nimeni nu a răspuns încă lol! Dar hei, aici's propria mea du-te la ea:

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

Dacă aveți nevoie de un șir aleator mai degrabă decât un pseudo-aleatoare o, ar trebui să utilizați os.urandom ca sursă

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

Această metodă este ușor mai rapid, și ușor mai enervant, decât întâmplător.alegerea() metoda Ignacio postat.

Profită de natura pseudo-aleatoare algoritmi, și băncile la nivel de bit și și schimbare fiind mai rapidă decât a genera un nou număr aleator pentru fiecare personaj.

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

...de a crea un generator care are 5 biți numere la un moment dat 0..31 până când nimeni nu a plecat

...join() rezultatele generator pe un număr aleator cu dreptul de biți

Cu Datănu, pentru 32 de caractere, siruri de caractere, momentul a fost:

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

...dar pentru 64 de șiruri de caractere, randbits pierde ;)

Probabil că m-aș folosi niciodată această abordare în codul de producție dacă nu-mi plăcea să-mi co-lucrătorilor.

edit: actualizat pentru a se potrivi întrebare (majuscule și cifre numai), și de a folosi operatori la nivel de bit & și >> în loc de a % și //

Am'd face în acest fel:

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

Sau doar:

def rand_string(length, char_set=legals):

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

Utilizarea Numpy's întâmplare.alegerea() funcția

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

Documentația este aici http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.random.choice.html

>>> import string 
>>> import random

următoarele logica generează încă 6 caractere eșantion aleatoriu

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

Nu este nevoie pentru a se multiplica de 6

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

TK82HK

Uneori 0 (zero) & O (litera O) poate fi confuz. Asa ca am folosi

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

Pentru cei dintre voi care se bucura funcționale 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))))

Acesta generează o durată nedeterminată [infinit] iterator, de s-au alăturat secvențe aleatoare, de prima genera o durată nedeterminată secvență de selectate aleatoriu simbol din oferindu-exterioară, apoi de rupere această secvență în părți, care este apoi s-au alăturat, ar trebui să funcționeze cu orice secvență care acceptă getitem, implicit, pur și simplu generează o secvență aleatoare de alfa numerice litere, deși puteți modifica cu ușurință pentru a genera alte lucruri:

de exemplu, pentru a genera aleatoriu tupluri de cifre:

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

dacă tu nu't doriți să utilizați în continuare pentru generarea puteți face pur și simplu nevărsat:

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

dacă doriți pentru a genera secvența de pe zbor, pur și simplu setați adere la identitate.

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

Cum alții au menționat dacă aveți nevoie de mai multă securitate, apoi setați corespunzător selectați funcția:

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

implicit selector este alegere, care poate selecta același simbol de mai multe ori pentru fiecare parte, dacă în loc să te'd vrem același membru selectat cel mult o dată pentru fiecare bucată apoi, într-o posibilă utilizare:

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

vom folosi sample nostru selector, pentru a face o selecție completă, astfel încât bucăți sunt, de fapt, lungime 1, și să se alăture pur și simplu apel "next" care preia următorul complet generat bucată, acordat acest exemplu pare un pic greoaie și este ...

(1) Acest lucru vă va oferi toate capacele și numere:

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) Dacă doriți mai târziu să includă litere mici în cheia ta, atunci acest lucru va lucra, de asemenea,:

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  

aceasta este o ia pe Anurag Uniyal 's de răspuns și ceva ce am fost de lucru pe mine însumi.

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 

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

Aici lungime de șir poate fi schimbat în buclă pentru am.e pentru că în intervalul(1,lungime) Este algoritm simplu, care este ușor de înțeles. folosește listă astfel încât vă puteți debarasa de caractere care nu aveți nevoie.

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

La aleatorie.alegerea funcția alege o intrare aleatoare într-o listă. Ai, de asemenea, de a crea o listă, astfel încât să puteți adăuga personajul din "pentru" declarație. La sfârșitul str ['t', 'm', '2', 'J', 'U', 'Q', '0', '4', 'C', 'K'], dar str = "".alăturați-vă(str) are grijă de faptul că, lăsându-vă cu 'tm2JUQ04CK'.

Sper că acest lucru vă ajută!