Pythone sukurkite atsitiktines eilutes su didžiosiomis raidėmis ir skaičiais

Noriu sukurti N. dydžio eilutę.

Ją turėtų sudaryti skaičiai ir didžiosios anglų kalbos raidės, pavyzdžiui:

  • 6U1S75
  • 4Z4UKK
  • U911K4

Kaip tai pasiekti pythoniniame ?

875
13 февр. Hellnar rinkinys vasario 13 dieną 2010-02-13 15:23 '10, 15:23, 2010-02-13 15:23
@ 24 atsakymai

Atsakymas vienoje eilutėje:

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

arba net trumpesnis, pradedant nuo 3.6 „Python“, naudojant random.choices() :

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

Kriptografiškai saugesnė versija; žr. ngn-wiki.ru.site/questions/11498 / ... :

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

Išsamiai, su švaria funkcija tolesniam pakartotiniam naudojimui:

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

Kaip tai veikia?

Mes importuojame string , modulį, kuriame yra įprastų ASCII ženklų sekų ir random , modulį, kuriame aptariamas atsitiktinis generavimas.

string.ascii_uppercase + string.digits tiesiog sujungia simbolių, žyminčių didžiųjų ASCII simbolių ir skaičių, sąrašą:

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

Tada mes naudojame sąrašo supratimą, kad sukurtume „n“ elementų sąrašą:

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

Pirmiau pateiktame pavyzdyje mes naudojame [ sukurti sąrašą, bet neatliekame id_generator funkcijos, todėl „Python“ nesukuria atmintyje sąrašo, bet vienas po kito generuoja elementus (daugiau apie tai čia ).

Užuot elem sukurti eilutę „ elem “ n, „Python“ paprašysime sukurti atsitiktinį simbolį „n“, pasirinktą iš simbolių sekos:

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

Todėl „ random.choice(chars) for _ in range(size) iš tikrųjų sukuria size simbolių seką. Simboliai, atrinkti atsitiktinai iš 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'] 

Tada mes tiesiog pridedame juos prie tuščios eilutės, todėl seka tampa eilute:

 >>> ''.join(['a', 'b', 'b']) 'abb' >>> [random.choice('abcde') for _ in range(3)] ['d', 'c', 'b'] >>> ''.join(random.choice('abcde') for _ in range(3)) 'dac' 
1806
13 февр. Ignacio Vazquez-Abrams atsakymas, pateiktas vasario 13 d. 2010-02-13 15:26 '10, 15:26, 2010-02-13 15:26

Ši užklausa yra „Google“ aukščiausio lygio „atsitiktinės„ Python “eilutės rezultatas. Dabartinis aukščiausias atsakymas:

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

Tai puikus metodas, bet

383
19 мая '14 в 4:41 2014-05-19 04:41 atsakymą pateikė Randy Marsh 19 d. 14 d. 4:41 2014-05-19 04:41

Tiesiog naudokite Python builtin uuid:

Jei UUID yra tinkamas jūsų tikslams, naudokite integruotą „ uuid“ paketą.

Vienos eilutės sprendimas:

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

Išsamios versijos:

Pavyzdys:

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

Jei jums reikia jūsų konkretaus formato (pvz., „6U1S75“), galite tai padaryti taip:

 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 
115
26 июня '13 в 18:11 2013-06-26 18:11 atsakymas suteikiamas Bijanui birželio 26 d. 13 d. 6:11 2013-06-26 18:11

Paprastesnis, greitesnis, bet šiek tiek mažiau atsitiktinis būdas yra naudoti atsitiktinį random.sample o ne pasirinkti kiekvieną laišką atskirai. Jei leidžiami n-pakartojimai, pvz., Padidinkite savo atsitiktinį skaičių n kartus.

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

Pastaba: atsitiktinis pavyzdys neleidžia pakartotinai naudoti simbolių, padauginant simbolių rinkinio dydį, galima pakartoti kelis kartus, tačiau jie vis dar yra mažiau tikėtini, tada jie yra tik atsitiktine atranka. Jei einame į 6 ilgio eilutę, o kaip pirmąjį simbolį pasirenkame „X“, pasirinkimo pavyzdyje tikimybė gauti „X“ antrajam simboliui yra tokia pati, kaip tikimybė gauti „X“ kaip pirmąjį simbolį. Įgyvendinant atsitiktinį pavyzdį, tikimybė gauti „X“ kaip bet kokį vėlesnį simbolį yra tik 6/7 tikimybė gauti jį kaip pirmąjį simbolį.

36
13 февр. Atsakymą pateikė Anurag Uniyal , vasario 13 d. 2010-02-13 15:44 '10, 15:44, 2010-02-13 15:44
 import uuid str = uuid.uuid4().hex 

str yra atsitiktinė vertė, pvz., 'cea8b32e00934aaea8c005a35d85a5c0'

 uppercase_str = str.upper() 

'cea8b32e00934aaea8c005a35d85a5c0'

15
01 дек. Atsakymas duotas Savad KP 01 Dec. 2015-12-01 13:04 '15, 13:04 2015-12-01 13:04

Greitesnis, paprastesnis ir lankstesnis būdas tai padaryti yra naudoti strgen modulį („ pip install StringGenerator ).

Sukurkite 6 skaitmenų atsitiktinę eilutę su didžiosiomis raidėmis ir skaičiais:

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

Gaukite unikalų sąrašą:

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

Užtikrinkite vieną „specialų“ simbolį eilutėje:

 >>> SG("[\l\d]{10} u'jaYI0bcPG*0' 

HTML spalva atsitiktinai:

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

ir kt.

Turime žinoti, kas tai yra:

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

gali neturėti numerių (arba didžiųjų raidžių).

strgen greitesnis vystymosi metu nei bet kuris iš pirmiau minėtų sprendimų. Ignacio sprendimas yra greičiausias darbo laikas, ir tai yra teisingas atsakymas naudojant standartinę Python biblioteką. Tačiau vargu ar kada nors naudosite šią formą. Norite naudoti „SystemRandom“ (arba atsarginę kopiją, jei ji nepasiekiama), įsitikinkite, kad pateikiami reikalingi simbolių rinkiniai, naudokite unikodą (ar ne), įsitikinkite, kad nuoseklūs skambučiai sukuria unikalią eilutę, naudokite vienos iš eilutės modulio simbolių modulių klasių pogrupį ir tt . Tam reikia daug daugiau kodų nei pateikti atsakymai. Įvairūs bandymai apibendrinti sprendimus turi apribojimų, kuriuos strgen išsprendžia, naudodama paprastą šablonų kalbą, naudodama daugybę ir išraiškingą galią.

Tai yra „PyPI“:

 pip install StringGenerator 

Atskleidimas: esu strgen modulio autorius.

15
26 авг. Paul Wolf Wolf atsakymas 26 rug. 2014-08-26 14:47 '14 at 14:47 2014-08-26 14:47

Atsakydamas iš Ignacio, jis veikia su „Python 2.6“:

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

Išvesties pavyzdys:

Jqubt2

14
13 февр. Atsakymas duotas quamrana vasario 13 d. 2010-02-13 15:35 '10, 15:35, 2010-02-13 15:35

Jei jums reikia atsitiktinės eilutės, o ne pseudo- atsitiktinės eilutės, kaip šaltinį turėtumėte naudoti 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)) 
8
13 сент. John La Rooy atsakymas rugsėjo 13 d 2012-09-13 07:32 '12, 07:32 2012-09-13 07:32

Maniau, kad niekas neatsakė į tai, bet lol! Bet Ei, čia aš pats einu už jį:

 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))], "") 
8
11 февр. atsakymas pateikiamas nemesisfixx 11 vasario mėn. 2012-02-11 02:27 '12 at 2:27 2012-02-11 02:27

Remiantis kitu atsakymo perpildymu, paprasčiausias būdas sukurti atsitiktinę eilutę ir atsitiktinį šešiakampį skaičių , geresnė versija nei priimtas atsakymas, būtų:

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

daug greičiau.

7
19 дек. Atsakymą pateikė Gubbi gruodžio 19 d. 2013-12-19 20:51 '13, 20:51, 2013-12-19 20:51

Iš „Python 3.6“ turėtumėte naudoti secrets modulį, jei norite, kad jis būtų saugomas kriptografiškai, o ne random modulis (kitaip šis atsakymas yra toks pat, kaip ir @Ignacio Vazquez-Abrams):

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

Dar viena pastaba: str.join atveju sąrašo supratimas yra greitesnis nei naudojant generatoriaus išraišką!

6
04 янв. Atsakymą pateikė MSeifert 04 sausis 2017-01-04 16:12 '17 at 4:12 2017-01-04 16:12

Šis metodas yra šiek tiek greitesnis ir truputį erzina, nei Ignacio atsiųstas atsitiktinis.

Jis naudoja pseudo-atsitiktinių algoritmų pobūdį, o bankai yra bitai ir perkeliami greičiau, nei kuriant kiekvieną atsitiktinį skaičių kiekvienam simboliui.

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

... sukurkite generatorių, kuris pasirenka 5 bitų skaičių 0..31 metu, kol jis lieka

... prisijungti () atsitiktinių skaičių generatoriaus rezultatus su teisingais bitais

Su 32 simbolių eilutėmis su „Timeit“, laikas buvo:

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

... bet 64 simbolių eilutėms randbits praranda;)

Tikriausiai niekada nenaudosiu tokio požiūrio gamybos kode, jei tikrai nenorėčiau savo darbuotojų.

pakeisti: atnaujinkite pagal klausimą (tik didžiosiomis ir tik skaičiais) ir naudokite bitų operatorius ir → vietoj% ir //

6
08 янв. atsakymą pateikė Robas nuo 08 sausio. 2013-01-08 11:51 '13, 11:51, 2013-01-08 11:51

Norėčiau tai padaryti taip:

 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 

Arba tiesiog:

 def rand_string(length, char_set=legals): return ''.join( random.choice(char_set) for _ in range(length) ) 
3
10 марта '12 в 22:07 2012-03-10 22:07 atsakymą pateikė Carl Smith , kovo 10 d. 12 val. 10:07 2012-03-10 22:07

(1) Tai suteiks jums visas kepurės ir numerius:

 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) Jei vėliau savo rakte norite įtraukti mažąsias raides, tai taip pat veiks:

 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 
2
22 апр. atsakymą pateikė Jokūbas balandžio 22 d 2016-04-22 06:50 '16 at 6:50 2016-04-22 06:50

tai yra anurag unikalus atsakas ir kažkas, ką dirbau sau.

 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() 
2
01 июля '17 в 7:28 2017-07-01 07:28 atsakymą pateikė „ Stopit Donk“ liepos 1 d. 17, 07:28 2017-07-01 07:28

Tiems, kurie mėgsta funkcinį 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)))) 

Jis sukuria neapibrėžtą [begalinį] kombinuotų atsitiktinių sekų iteratorių, pirmiausia sukurdamas neribotą atsitiktinai pasirinkto simbolio seką iš atkūrimo fondo, tada suskirstydamas šią seką į ilgio dalis, kurios yra tada prijungtos, ji turėtų veikti su bet kokia seka, kuri palaiko getitem, pagal nutylėjimą ji tiesiog generuoja atsitiktinę raidės seka, nors galite lengvai keisti, kad sukurtumėte kitus dalykus:

Pavyzdžiui, jei norite sukurti atsitiktinius skaičių rinkinius:

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

Jei nenorite naudoti šių kartų kartoms, galite paprasčiausiai jį naudoti:

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

jei norite generuoti seką skristi, tiesiog užmegzkite ryšį su identifikatoriumi.

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

Kaip jau minėta, jei jums reikia papildomo saugumo, nustatykite tinkamą pasirinkimo funkciją:

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

numatytąjį pasirinkimo choice , kuris gali pasirinkti tą patį simbolį kelis kartus kiekvienam fragmentui, jei norite, kad tas pats narys būtų pasirinktas ne daugiau kaip vieną kartą kiekvienam fragmentui, tada vienas iš galimų naudojimo būdų:

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

mes naudojame sample kaip mūsų selektorių, kad galėtume atlikti išsamų pasirinkimą, todėl gabalai iš tikrųjų yra 1 ilgio, o prisijungti, mes tiesiog paskambinę next , kuris nuskaito kitą visiškai sukurtą fragmentą, pateiktą šiam pavyzdžiui, atrodo šiek tiek sudėtinga ir kad ...

2
02 февр. Atsakymą pateikė Samy Vilar 02 vasaris 2015-02-02 21:02 '15 at 21:02 2015-02-02 21:02

Naudokite funkciją 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)) 

Dokumentacija čia http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.random.choice.html

2
18 июня '16 в 4:22 2016-06-18 04:22 atsakymą pateikė Mudit Jain birželio 18 d. 16 val. 22:22 2016-06-18 04:22

importuoti importuoti atsitiktinę eilutę

ši logika vis dar generuoja atsitiktinį 6 simbolių modelį

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

Nereikia dauginti iš 6

 >>> print ''.join(random.sample((string.ascii_uppercase+string.digits)*6,6)) TK82HK 
1
04 мая '15 в 22:19 2015-05-04 22:19 atsakymą pateikė vartotojo128956 gegužės 4 d., „15, 10:19 pm 2015-05-04 22:19
 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 
1
11 мая '16 в 14:22 2016-05-11 14:22 atsakymas duotas Natasha gegužės 11, 16, 14:22 2016-05-11 14:22
 >>> 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 funkcijos funkcija pasirenka atsitiktinį įrašą sąraše. Taip pat sukuriate sąrašą, skirtą simboliui pridėti prie pareiškimo. Str pabaigoje yra ['t', 'm', '2', 'J', 'U', 'Q', '0', '4', 'C', 'K'), bet str = "".join(str) tai pasirūpins, paliekant 'tm2JUQ04CK' .

Tikiuosi, kad tai padės!

1
30 янв. atsakymą pateikė AJ Uppal, sausio 30 d 2014-01-30 07:13 '14, 7:13 2014-01-30 07:13

Paprasta:

 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 
1
27 сент. atsakymas duodamas Hackaholic 27 sep . 2014-09-27 22:12 '14, 10:12 pm 2014-09-27 22:12

Norėčiau pasiūlyti jums šią parinktį:

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

Paranoinis režimas:

 import uuid import crypt n = 10 crypt.crypt(str(uuid.uuid4())).replace('/', '').replace('.', '').upper()[-n:-1] 
0
05 окт. atsakymas pateikiamas mrvol 05 okt. 2017-10-05 19:58 '17, 19:58 pm 2017-10-05 19:58

Radau paprastesnį ir švaresnį.

 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 

Tiesiog pakeiskite vertę 64, kad pakeistumėte ilgį, pakeiskite CharacterPool, kad padarytumėte tik raidinius ar skaitmeninius ar keistus simbolius ar bet kokius.

-1
21 июля '17 в 2:54 2017-07-21 02:54 atsakymą įteikė MT vadovas liepos 21 d. 17:24 2:54 2017-07-21 02:54

Galite naudoti kodą

 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; 

Jis atsitiktinai išspjaus atsitiktinį 7 raidžių ir skaitmenų raštą, tiesiog pakeiskite 7 į bet kurį norimą skaičių, ir jis pagamins daug skaičių ir (arba) raidžių.

Kitas būdas rašyti tai yra:

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

Nežinau, kaip pridėti apribojimų, pvz., Tai padaryti, kai neleidžiama, kad tam tikri numeriai ir (arba) raidės būtų vienas šalia kito, arba pakartoti, pvz., Gauti „AAA123“, jei kas žino, kaip apriboti rezultatą. Kažkas panašaus, prašome komentuoti

-4
09 июля '15 в 3:06 2015-07-09 03:06 atsakymas duotas Rage liepos 09, 15 d. 3:06 2015-07-09 03:06

Kiti klausimai apie žymes arba Ask a question