Random String Generation mit Großbuchstaben und Ziffern in Python

Ich möchte einen String der Größe N erzeugen.

Es sollte aus Zahlen und Großbuchstaben bestehen, wie zB:

  • 6U1S75
  • 4Z4UKK
  • U911K4

Wie kann ich das pythonisch erreichen ?

21 Solutions collect form web for “Random String Generation mit Großbuchstaben und Ziffern in Python”

Antwort in einer Zeile:

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

Oder sogar kürzer beginnend mit Python 3.6 mit random.choices() :

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

Eine kryptographisch sicherere Version; Siehe https://stackoverflow.com/a/23728630/2213647 :

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

Im Einzelnen mit einer sauberen Funktion zur weiteren Wiederverwendung:

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

Wie funktioniert es ?

Wir importieren string , ein Modul, das Sequenzen von gängigen ASCII-Zeichen enthält, und random , ein Modul, das sich mit der zufälligen Generierung beschäftigt.

string.ascii_uppercase + string.digits verkettet nur die Liste der Zeichen, die Großbuchstaben ASCII-Zeichen und Ziffern darstellen:

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

Dann verwenden wir ein Listenverständnis, um eine Liste von 'n' Elementen zu erstellen:

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

Im obigen Beispiel verwenden wir [ um die Liste zu erstellen, aber wir nicht in der id_generator Funktion, so dass Python nicht die Liste im Speicher erstellt, sondern die Elemente auf der Fliege erzeugt, eins nach dem anderen (mehr dazu hier ) .

Anstatt zu fragen, 'n' mal die Zeichenfolge elem zu erstellen, werden wir bitten, Python zu erstellen 'n' mal ein zufälliges Zeichen, ausgewählt aus einer Folge von Zeichen:

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

Daher random.choice(chars) for _ in range(size) wirklich eine random.choice(chars) for _ in range(size) . Charaktere, die zufällig aus 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'] 

Dann kommen wir einfach mit einem leeren String zusammen, damit die Sequenz zu einem String wird:

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

Diese Stack Overflow quesion ist das aktuelle Top-Google-Ergebnis für "random string Python". Die aktuelle Top-Antwort ist:

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

Dies ist eine hervorragende Methode, aber das PRNG ist zufällig nicht kryptographisch sicher. Ich gehe davon aus, dass viele Leute, die diese Frage erforschen, zufällige Zeichenfolgen für Verschlüsselung oder Passwörter generieren möchten. Sie können dies sicher tun, indem Sie eine kleine Änderung in der oben genannten Code:

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

Verwenden von random.SystemRandom() anstelle von nur zufälligen Verwendungen / dev / urandom auf * nix-Maschinen und CryptGenRandom() in Windows. Das sind kryptographisch sichere PRNGs. Mit random.choice anstelle von random.SystemRandom().choice in einer Anwendung, die eine sichere PRNG erfordert könnte potenziell verheerend sein, und angesichts der Popularität dieser Frage, ich wette, dass Fehler schon viele Male schon gemacht wurde.

Verwenden Sie einfach Python's builtin uuid:

Wenn UUIDs für Ihre Zwecke in Ordnung sind, verwenden Sie das eingebaute uuid Paket.

One Line Lösung:

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

In der Tiefe Version:

Beispiel:

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

Wenn Sie genau Ihr Format benötigen (zB "6U1S75"), können Sie es so machen:

 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 

Ein einfacher, schneller, aber etwas weniger zufälliger Weg ist, random.sample zu verwenden, anstatt jeden Buchstaben separat zu wählen, wenn n-Wiederholungen erlaubt sind, vergrößern Sie Ihre zufällige Basis um n mal zB

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

Anmerkung: random.sample verhindert Zeichenwiederverwendung, Multiplikation der Größe des Zeichensatzes macht mehrere Wiederholungen möglich, aber sie sind immer noch weniger wahrscheinlich, dann sind sie in einer reinen zufälligen Wahl. Wenn wir für einen String von Länge 6 gehen, und wir wählen 'X' als das erste Zeichen, in der Wahl Beispiel, die Chancen zu bekommen 'X' für das zweite Zeichen sind die gleichen wie die Chancen zu bekommen 'X' als die Erster Charakter. In der zufälligen Beispiel-Implementierung sind die Chancen, 'X' als jeden nachfolgenden Charakter zu bekommen, nur 6/7 die Chance, es als das erste Zeichen zu bekommen

Eine schnellere, einfachere und flexiblere Möglichkeit, dies zu tun, ist das strgen Modul ( pip install StringGenerator ) zu verwenden.

Generiere einen 6-stelligen zufälligen String mit Großbuchstaben und Ziffern:

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

Holen Sie sich eine einzigartige Liste:

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

Gewährleistung eines "besonderen" Charakters in der Zeichenfolge:

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

Eine zufällige HTML-Farbe:

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

etc.

Wir müssen uns bewusst sein, dass dies:

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

Möglicherweise keine Ziffer (oder Großbuchstaben) darin.

strgen ist schneller in der Entwickler-Zeit als jede der oben genannten Lösungen. Die Lösung von Ignacio ist die schnellste Laufzeit und ist die richtige Antwort mit der Python Standard Library. Aber du wirst es in dieser Form kaum benutzen. Sie möchten SystemRandom (oder Fallback, wenn nicht verfügbar) verwenden, stellen Sie sicher, dass erforderliche Zeichensätze vertreten sind, verwenden Sie Unicode (oder nicht), stellen Sie sicher, dass aufeinanderfolgende Aufrufe eine eindeutige Zeichenfolge erzeugen, eine Teilmenge einer der Zeichenfolgenmodulzeichenklassen verwenden, Etc. Dies alles erfordert viel mehr Code als in den Antworten zur Verfügung gestellt. Die verschiedenen Versuche, eine Lösung zu verallgemeinern, haben alle Einschränkungen, die strgen mit größerer Kürze und Ausdruckskraft mit einer einfachen Vorlagensprache löst.

Es ist auf PyPI:

 pip install StringGenerator 

Disclosure: Ich bin der Autor des Strgen-Moduls.

Die Antwort von Ignacio, das funktioniert mit Python 2.6:

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

Beispielausgabe:

JQUBT2

 import uuid str = uuid.uuid4().hex 

str ist ein zufälliger Wert wie 'cea8b32e00934aaea8c005a35d85a5c0'

 uppercase_str = str.upper() 

'CEA8B32E00934AAEA8C005A35D85A5C0' ist 'CEA8B32E00934AAEA8C005A35D85A5C0'

Wenn Sie eine zufällige Zeichenfolge anstatt ein Pseudo zufälliges benötigen, sollten Sie os.urandom als Quelle verwenden

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

Ich dachte, niemand hatte das noch gelohnt! Aber hey, hier ist meine eigene gehen auf sie:

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

Diese Methode ist etwas schneller und etwas ärgerlicher als die random.choice () Methode Ignacio posted.

Es nutzt die Art der pseudozufälligen Algorithmen und die Bänke auf bitweise und und die Verschiebung ist schneller als die Erzeugung einer neuen Zufallszahl für jedes Zeichen.

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

… einen Generator erstellen, der 5 Bit Zahlen zu einem Zeitpunkt 0..31 aufnimmt, bis keiner übrig ist

… join () die Ergebnisse des Generators auf einer zufälligen Zahl mit den rechten Bits

Mit Timeit, für 32-Zeichen-Strings, war das Timing:

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

… aber für 64 Zeichenfolgen verliert man Randbits;)

Ich würde wahrscheinlich nie diesen Ansatz in Produktionscode verwenden, wenn ich meine Kollegen nicht wirklich mochte.

Edit: aktualisiert auf die Frage (Groß- und Ziffern nur), und verwenden Sie bitweise Operatoren & und >> anstelle von% und //

Basierend auf einem anderen Stack Overflow Antwort, die meisten leichten Weg, um eine zufällige Zeichenfolge und eine zufällige hexadezimale Zahl , eine bessere Version als die akzeptierte Antwort wäre:

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

viel schneller.

Von Python 3.6 auf sollten Sie das secrets wenn Sie es benötigen, um anstelle des random Moduls kryptographisch sicher zu sein (andernfalls ist diese Antwort identisch mit dem von @Ignacio Vazquez-Abrams):

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

Eine weitere Anmerkung: ein Listenverständnis ist im Fall von str.join schneller als mit einem Generatorausdruck!

Ich würde es so machen:

 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 

Oder nur:

 def rand_string(length, char_set=legals): return ''.join( random.choice(char_set) for _ in range(length) ) 

Für diejenigen unter Ihnen, die funktionelle Python genießen:

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

Es erzeugt einen unbestimmten [unendlichen] Iterator, von verbundenen zufälligen Sequenzen, indem er zuerst eine unbestimmte Folge von zufällig ausgewählten Symbol aus dem gebenden Pool erzeugt und dann diese Sequenz in Längenteile zerbricht, die dann verbunden sind, sie sollte mit einer beliebigen Sequenz arbeiten, die getitem unterstützt , Standardmäßig erzeugt es einfach eine zufällige Folge von alphanumerischen Buchstaben, obwohl man leicht ändern kann, um andere Dinge zu erzeugen:

Zum Beispiel um zufällige Tupel von Ziffern zu erzeugen:

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

Wenn du nicht als nächstes für die Generation benutest, kannst du es einfach kündbar machen:

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

Wenn du die Sequenz auf der Fliege erzeugen willst, kannst du einfach zur Identität beitragen.

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

Wie andere erwähnt haben, wenn Sie mehr Sicherheit benötigen, dann stellen Sie die entsprechende Auswahlfunktion ein:

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

Die Standard-Selektor ist die choice die das gleiche Symbol mehrmals für jedes Stück auswählen kann, wenn Sie stattdessen das gleiche Mitglied am meisten einmal für jedes Stück dann wählen möchten, eine mögliche Verwendung:

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

Wir verwenden die sample als unser Selektor, um die komplette Auswahl zu machen, also sind die Chunks eigentlich Länge 1, und um uns zu kommen, rufen wir einfach weiter an, was das nächste komplett generierte Chunk holt, was dieses Beispiel scheint, ist ein bisschen umständlich und es ist …

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

Die random.choice Funktion wählt einen zufälligen Eintrag in einer Liste. Sie erstellen auch eine Liste, so dass Sie das Zeichen in der for Anweisung anfügen können. Am Ende ist Str. ['T', 'm', '2', 'J', 'U', 'Q', '0', '4', 'C', 'K'], aber die str = "".join(str) kümmert sich darum, so dass du dich mit 'tm2JUQ04CK' .

Hoffe das hilft!

Ein einfacher:

 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 String Import zufällig

Die folgende Logik erzeugt immer noch 6 Zeichen zufällige Stichprobe

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

Keine Notwendigkeit, mit 6 zu multiplizieren

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

(1) Das gibt euch alle Mützen und Zahlen:

 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) Wenn Sie später Kleinbuchstaben in Ihren Schlüssel einfügen möchten, dann funktioniert das auch:

 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 

Verwenden Sie Numpys random.choice () – Funktion

 import numpy as np import string if __name__ == '__main__': a = np.random.choice(list(string.ascii_uppercase + string.digits), length) print(''.join(a)) 

Dokumentation ist hier http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.random.choice.html

Dies ist eine Annahme von Anurag Uniyals Antwort und etwas, das ich an mir selbst gearbeitet habe.

 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 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 
  • Empfehlungen für niedrige Diskrepanz (zB Sobol) quasi-zufällige Sequenzen in Python / SciPy?
  • Gewichtete Stichprobe in Python
  • Warum dieses python-programm funktioniert nicht
  • Wie man ein zufälliges englisches Wort aus einer Liste auswählt
  • Zufällig aus der Liste mit random.randint in python wählen
  • Schnellste Weg, um 1.000.000 + Zufallszahlen in Python zu generieren
  • Vergleich von Matlab und Numpy Code, der die Zufallsgenerierung verwendet
  • Konsequent erstellen gleiche zufällige numpy Array
  • Was ist der beste Weg, um zufällige Strings einer bestimmten Länge in Python zu generieren?
  • Generieren Sie Zufallszahlen mit einer gegebenen (numerischen) Verteilung
  • Implementierung eines Pseudozufallsgenerators in Python
  • Python ist die beste Programmiersprache der Welt.