Eu quero gerar uma sequência de tamanho N.

Deve ser composto por números e letras maiúsculas em inglês, como:

• 6U1S75
• 4Z4UKK
• U911K4

Como posso conseguir isso de maneira pitônica ?

Responda em uma linha:

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

ou ainda mais curto a partir do Python 3.6 usando random.choices():

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

Uma versão criptograficamente mais segura; consulte https://stackoverflow.com/a/23728630/2213647 :

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

Em detalhes, com uma função limpa para reutilização adicional:

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

Como funciona ?

Importamos stringum módulo que contém sequências de caracteres ASCII comuns e randomum módulo que trata de geração aleatória.

string.ascii_uppercase + string.digits concatena apenas a lista de caracteres que representam caracteres e dígitos ASCII maiúsculos:

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

Em seguida, usamos uma compreensão de lista para criar uma lista de elementos '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']

No exemplo acima, usamos [para criar a lista, mas não na id_generatorfunção, para que o Python não crie a lista na memória, mas gera os elementos rapidamente, um por um (mais sobre isso aqui ).

Em vez de pedir para criar 'n' vezes a string elem, pediremos ao Python para criar 'n' vezes um caractere aleatório, escolhido a partir de uma sequência de caracteres:

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

Portanto, random.choice(chars) for _ in range(size)realmente está criando uma sequência de sizecaracteres. Caracteres escolhidos aleatoriamente 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']

Depois, juntamos-os a uma string vazia para que a sequência se torne uma string:

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

Esta questão do Stack Overflow é o principal resultado atual do Google para "string aleatória Python". A principal resposta atual é:

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

Este é um método excelente, mas o PRNG aleatoriamente não é criptograficamente seguro. Suponho que muitas pessoas pesquisando essa questão desejem gerar seqüências aleatórias para criptografia ou senhas. Você pode fazer isso com segurança, fazendo uma pequena alteração no código acima:

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

Usar em random.SystemRandom()vez de apenas aleatoriamente usa / dev / urandom em máquinas * nix e CryptGenRandom()no Windows. Estes são PRNGs criptograficamente seguros. Usar em random.choicevez de random.SystemRandom().choiceem um aplicativo que requer um PRNG seguro pode ser potencialmente devastador e, dada a popularidade dessa pergunta, aposto que esse erro já foi cometido muitas vezes.

Se você estiver usando python3.6 ou superior, poderá usar o novo módulo de segredos , conforme mencionado na resposta do MSeifert :

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

Os documentos do módulo também discutem maneiras convenientes de gerar tokens seguros e práticas recomendadas .

Basta usar o uuid interno do Python:

Se os UUIDs forem bons para seus propósitos, use o pacote uuid interno .

Solução de uma linha:

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

Versão detalhada:

Exemplo:

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

Se você precisar exatamente do seu formato (por exemplo, "6U1S75"), poderá fazer o seguinte:

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

Uma maneira mais simples, mais rápida, mas um pouco menos aleatória, é usar em random.samplevez de escolher cada letra separadamente. Se n-repetições forem permitidas, amplie sua base aleatória em n vezes.

import random
import string

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

Nota: random.sample impede a reutilização de caracteres, multiplicar o tamanho do conjunto de caracteres possibilita várias repetições, mas elas ainda são menos prováveis ​​do que elas são uma escolha aleatória pura. Se optarmos por uma sequência de comprimento 6 e escolhermos 'X' como o primeiro caractere, no exemplo escolhido, as chances de obter 'X' para o segundo caractere serão as mesmas que as de obter 'X' como o primeiro caractere. Na implementação random.sample, as chances de obter 'X' como qualquer caractere subseqüente têm apenas 6/7 de chance de obtê-lo como o primeiro caractere

import uuid
lowercase_str = uuid.uuid4().hex  

lowercase_str é um valor aleatório como 'cea8b32e00934aaea8c005a35d85a5c0'

uppercase_str = lowercase_str.upper()

uppercase_str é 'CEA8B32E00934AAEA8C005A35D85A5C0'

Uma maneira mais rápida, fácil e flexível de fazer isso é usar o strgenmódulo ( pip install StringGenerator).

Gere uma sequência aleatória de 6 caracteres com letras maiúsculas e dígitos:

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

Obtenha uma lista exclusiva:

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

Garanta um caractere "especial" na string:

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

Uma cor HTML aleatória:

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

etc.

Precisamos estar cientes de que isso:

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

pode não ter um dígito (ou caractere maiúsculo).

strgené mais rápido no tempo do desenvolvedor do que qualquer uma das soluções acima. A solução da Ignacio é o desempenho mais rápido em tempo de execução e é a resposta certa usando a Biblioteca Padrão do Python. Mas você quase nunca o utilizará dessa forma. Você deseja usar SystemRandom (ou fallback, se não estiver disponível), garantir que os conjuntos de caracteres necessários sejam representados, usar unicode (ou não), garantir que sucessivas invocações produzam uma cadeia exclusiva, usar um subconjunto de uma das classes de caracteres do módulo de cadeia, etc. Isso tudo requer muito mais código do que nas respostas fornecidas. As várias tentativas de generalizar uma solução têm limitações que o strgen resolve com maior brevidade e poder expressivo usando uma linguagem de modelo simples.

Está no PyPI:

pip install StringGenerator

Divulgação: sou o autor do módulo strgen.

No Python 3.6 em diante, você deve usar o secretsmódulo se precisar que ele seja criptograficamente seguro em vez do randommódulo (caso contrário, essa resposta é idêntica à de @Ignacio Vazquez-Abrams):

from secrets import choice
import string

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

Uma observação adicional: uma compreensão de lista é mais rápida no caso do str.joinque usar uma expressão geradora!

Com base em outra resposta do Stack Overflow, a maneira mais leve de criar uma sequência aleatória e um número hexadecimal aleatório , uma versão melhor que a resposta aceita seria:

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

muito mais rapido.

Se você precisar de uma sequência aleatória em vez de uma pseudoaleatória , use os.urandomcomo fonte

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

Eu pensei que ninguém tinha respondido isso ainda lol! Mas ei, aqui está o meu próprio exemplo:

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

Esse método é um pouco mais rápido e um pouco mais irritante do que o método random.choice () que Ignacio postou.

Ele tira proveito da natureza dos algoritmos pseudoaleatórios, e os bancos em bit a bit e and shift são mais rápidos do que gerar um novo número aleatório para cada caractere.

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

... crie um gerador que retire números de 5 bits de cada vez 0..31 até que nenhum seja deixado

... join () os resultados do gerador em um número aleatório com os bits certos

Com Timeit, para cadeias de caracteres de 32 caracteres, o tempo era:

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

... mas para 64 cadeias de caracteres, randbits perde;)

Eu provavelmente nunca usaria essa abordagem no código de produção, a menos que realmente não gostasse dos meus colegas de trabalho.

edit: atualizado para se adequar à pergunta (somente maiúsculas e dígitos) e use operadores bit a bit & e >> em vez de% e //

Eu faria assim:

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

Ou apenas:

def rand_string(length, char_set=legals):

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

Use a função random.choice () de Numpy

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

A documentação está aqui http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.random.choice.html

Às vezes 0 (zero) e O (letra O) podem ser confusos. Então eu uso

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

>>> import string 
>>> import random

a lógica a seguir ainda gera amostra aleatória de 6 caracteres

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

Não há necessidade de multiplicar por 6

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

TK82HK

Para aqueles que gostam de python funcional:

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

Ele gera um iterador [infinito] indefinido, de seqüências aleatórias unidas, primeiro gerando uma sequência indefinida de símbolo selecionado aleatoriamente a partir do pool de distribuição e, em seguida, dividindo essa sequência em partes de comprimento que são então unidas, deve funcionar com qualquer sequência que suporte getitem , por padrão, ele simplesmente gera uma sequência aleatória de letras alfanuméricas, embora você possa modificar facilmente para gerar outras coisas:

por exemplo, para gerar tuplas aleatórias de dígitos:

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

se você não quiser usar a próxima geração, poderá simplesmente torná-lo acessível:

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

se você deseja gerar a sequência em tempo real, basta definir junção à identidade.

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

Como já mencionado, se você precisar de mais segurança, defina a função de seleção apropriada:

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

o seletor padrão é o choiceque pode selecionar o mesmo símbolo várias vezes para cada bloco, se você preferir o mesmo membro selecionado no máximo uma vez para cada bloco, um possível uso:

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

nós usamos sample como nosso seletor para fazer a seleção completa, de modo que os pedaços são na verdade o comprimento 1, e para juntar, simplesmente chamamos nextque busca o próximo pedaço completamente gerado, desde que este exemplo pareça um pouco complicado e seja ...

(1) Isso fornecerá todos os limites e números:

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) Se você desejar incluir posteriormente letras minúsculas em sua chave, isso também funcionará:

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  

esta é uma opinião sobre a resposta de Anurag Uniyal e algo que eu estava trabalhando comigo mesmo.

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'

A random.choicefunção seleciona uma entrada aleatória em uma lista. Você também cria uma lista para poder acrescentar o caractere na fordeclaração. No final, str é ['t', 'm', '2', 'J', 'U', 'Q', '0', '4', 'C', 'K'], mas as str = "".join(str)tomadas cuide disso, deixando você com 'tm2JUQ04CK'.

Espero que isto ajude!

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

Aqui, o comprimento da string pode ser alterado no loop for, ou seja, no intervalo i (1, length). É um algoritmo simples e fácil de entender. ele usa a lista para que você possa descartar caracteres desnecessários.

Um simples:

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

Gostaria de sugerir a próxima opção:

import crypt
n = 10
crypt.crypt("any sring").replace('/', '').replace('.', '').upper()[-n:-1]

Modo paranóico:

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

Dois métodos:

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

Referência:

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

Resultado :

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

O desempenho do primeiro método é melhor.

Eu fui embora quase todas as respostas, mas nenhuma delas parece mais fácil. Eu sugiro que você tente o passgen biblioteca , que geralmente é usada para criar senhas aleatórias.

Você pode gerar seqüências aleatórias de sua escolha , como comprimento, pontuação, dígitos, letras e maiúsculas.

Aqui está o código para o seu caso:

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

Gere uma ID aleatória de 16 bytes contendo letras, dígitos, '_' e '-'

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

Eu estava olhando as diferentes respostas e tirei um tempo para ler a documentação dos segredos

O módulo secrets é usado para gerar números aleatórios criptograficamente fortes, adequados para gerenciar dados como senhas, autenticação de conta, tokens de segurança e segredos relacionados.

Em particular, os segredos devem ser usados ​​de preferência ao gerador de números pseudo-aleatórios padrão no módulo aleatório, projetado para modelagem e simulação, não para segurança ou criptografia.

Analisando mais o que ele tem a oferecer, achei uma função muito útil se você deseja imitar um ID como os do Google Drive:

secrets.token_urlsafe ([nbytes = Nenhum])
Retorna uma cadeia de texto aleatória segura para URL, contendo nbytes de bytes aleatórios. O texto é codificado em Base64, portanto, em média, cada byte resulta em aproximadamente 1,3 caracteres . Se nbytes for Nenhum ou não for fornecido, um padrão razoável será usado.

Use da seguinte maneira:

import secrets
import math

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

print(id_generator())

Crie um ID de comprimento de 32 caracteres:

joXR8dYbBDAHpVs5ci6iD-oIgPhkeQFk

Sei que isso é um pouco diferente da pergunta do OP, mas espero que ainda seja útil para muitos que estavam procurando o mesmo caso de uso que eu estava procurando.

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

Eu achei isso mais simples e limpo.

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 

Basta alterar o 64 para variar o comprimento, variar o CharacterPool para fazer apenas alfa caracteres numéricos alfa ou numéricos apenas ou estranhos ou o que você quiser.