So I need to generate a 10-digit password (needs to use the random module) that must contain 2 lower ase letters, 2 uppercase letters, 3 special symbols and 3 numbers all in a random order every time. I've got the random password generator part done but I'm not sure how to restrict it to 2 lower case letters, 2 upper case letters, 3 special symbols and 3 numbers.
This is what I have so far:
import random
import string
lc_letter = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
uc_letter = ["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"]
symbols = ["!","#","#","$","%","^","&","*","(",")","_","+","=","-","/",">","<",",",".","?","\\"]
numbers = ["0","1","2","3","4","5","6","7","8","9"]
options = [lc_letter,uc_letter,symbols,numbers]
for i in range(10):
choice = random.choice(options)
digit = random.choice(choice)
print(digit, end = '')
You can use constants from string:
import random
import string
s = ""
for i in range(2):
s = s + random.choice(string.ascii_lowercase)
for i in range(2):
s = s + random.choice(string.ascii_uppercase)
for i in range(3):
s = s + random.choice(string.punctuation)
for i in range(3):
s = s + random.choice(string.digits)
s = ''.join(random.sample(s, 10))
print(s)
An alternative approach that I will suggest is, Take 2 letters from uppercase, lowercase etc. and then shuffle resulting password using random.shuffle method.
Pick every needed characters first, then shuffle them:
from random import choice as rd
from random import shuffle
import string
lc_letter = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
uc_letter = ["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"]
symbols = ["!","#","#","$","%","^","&","*","(",")","_","+","=","-","/",">","<",",",".","?","\\"]
numbers = ["0","1","2","3","4","5","6","7","8","9"]
options = [
rd(lc_letter),
rd(lc_letter),
rd(uc_letter),
rd(uc_letter),
rd(symbols),
rd(symbols),
rd(symbols),
rd(numbers),
rd(numbers),
rd(numbers),
]
shuffle(options)
print(''.join(options))
You can use random.choice, random.sample, and constants from the string module to obtain randomly generated passwords.
import random
import string
lc_letter = string.ascii_lowercase
uc_letter = string.ascii_uppercase
# Could use string.punctuation here, but it would be different
# as your list doesn't contain semicolons or colons,
# while string.punctuation does.
symbols = ["!","#","#","$","%","^","&","*","(",")","_","+","=","-","/",">","<",",",".","?","\\"]
numbers = string.digits
lc_selection = [random.choice(lc_letter) for _ in range(2)]
uc_selection = [random.choice(uc_letter) for _ in range(2)]
symbol_selection = [random.choice(symbols) for _ in range(3)]
number_selection = [random.choice(numbers) for _ in range(3)]
print(''.join(random.sample(lc_selection + uc_selection + symbol_selection + number_selection, 10)))
What you can actually do is make a list of length 10 like this:
dist = [0, 0, 1, 1, 2, 2, 2, 3, 3, 3]
This list represents the distribution of each index out of your options list.
For example, you put lowercase letters first in the option, and you have to pick 2 lowercase values, therefore there are 2 zeroes in the distribution list.
Now you can pick an index in the list:
idx = random.randint(0, len(dist))
Then, pick your choice from the list at: options[dist[idx]].
Lastly pop the value at idx from dist.
dist.pop(idx)
This will generate all the valid passwords with the same probability.
An in my opinion better version of Yevgeniy Kosmak's solution (the stand-alone config is clearer to see, the loop avoids code duplication, and using choices instead of choice avoids a loop).
import random
import string
config = [
(2, string.ascii_lowercase),
(2, string.ascii_uppercase),
(3, string.punctuation), # or use your '!##$%^&*()_+=-/><,.?\\'
(3, string.digits),
]
picked = []
for k, options in config:
picked += random.choices(options, k=k)
random.shuffle(picked)
password = ''.join(picked)
print(password)
Try it online!
Related
I am a noob and was wondering how to combine multiple outputs into one string that outputs
Here is my code
print ("password size (use numbers)")
passwordsize = int(input(""))
passwordsize = passwordsize -1
papers = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','?','!','1','2','3','4','5','6','7','8','9','0',]
q_list = [random.choice(papers) for i in range(passwordsize)]
' '.join(q_list)
poopers = q_list[0].replace("'", '')
print("/")
print(q_list)
for word in q_list:
result = word.replace("'", '')
print(result)
lets say that the random stuff picked was 3 a b c
it outputs...
3
a
b
c
I want it to output...
3abc
Any help is very much appreciated
Along the same lines as what #Chuck and #Ash proposed, but streamlining things a bit by taking fuller advantage of Python's standard library as well as the handy join string method:
import random
import string
passwordsize = 4 # int(input()) - 1
a = [*string.ascii_uppercase, *string.digits, "?", "!"]
print("".join(random.sample(a, passwordsize)))
Output:
W16H
import random
passwordsize = 4 # int(input("")) - 1
papers = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T',
'U','V','W','X','Y','Z','?','!','1','2','3','4','5','6','7','8','9','0',]
q_list = [random.choice(papers) for i in range(passwordsize)]
result = ""
for word in q_list:
result += word
print(result)
String object in python can use add "+" operation to do concatenation.
For example, if you want to create s = "ABC", you can create it by s = 'A' + 'B' + 'C'.
The += operation can iteratively do the + operation.
Thus, you can create "ABC" by a for loop:
s = ""
for w in ['A', 'B', 'C']:
s += w
If you want every generated char is unique, use random.sample. But if you want every char can occur more than one, use random.choices instead:
from random import choices; from string import ascii_uppercase as caps, digits as nums
result = ''.join(choices(caps+'?!'+nums,k=int(input('password size (use numbers)\n'))))
print(result)
# password size (use numbers)
# 15
# DK6V1DZOFKA?3HG
This is my string:
keyword = "qatarworldcup"
I mean my string should be qqatarworldcup, qatarworldcupp or qatarrworlddcup
This should be pretty easy to do if you break it up into parts.
Select a random letter from the word.
import random
letter_index = random.randint(0, len(keyword)-1)
Split the word into two parts at the letter you picked.
before, after = keyword[:letter_index], keyword[letter_index:]
Join the two parts, adding an extra instance of the selected letter
result = before + keyword[letter_index] + after
If your strings are big enough, or you're doing this multiple times, you could see a speedup from reducing the number of string concatenations, because that's an O(N) operation on account of the immutability of strings. Since the selected letter already exists in the word, you can split it such that the selected letter is the last character of before and the first character of after. Then, you only need a single concatenationThanks to #Mechanic Pig for your comment:
before, after = keyword[:letter_index+1], keyword[letter_index:]
result = before + after
from random import randint
keyword = "qatarwordcup"
idx = randint(0, len(keyword) - 1)
keyword = keyword[:idx] + keyword[idx] + keyword[idx:]
I'd do it like this
import random
#Find random position in string
r = random.randint(0, len(keyword) - 1)
#Create new string with added character at random position
newStr = keyword[:r] + keyword[r] + keyword[r:]
Iteration through index-character pairs, apply the condition on each "term" with the ternary operator and join everything together.
import random
# fix random number generator (for testing only!)
random.seed(190)
keyword = "qatarworldcup"
# random index
r = random.randint(0, len(keyword)-1)
out = ''.join(char * 2 if i == r else char for i, char in enumerate(keyword))
print(out)
#qaatarworldcup
I would like to generate a 16 character code
The code has 5 known characters
The code has 3 digits
The code must be random
What I did :
result1 = "NAA3U" + ''.join((random.choice(string.ascii_uppercase + string.digits) for codenum in range(11)))
One approach:
import random
import string
# select 2 digits at random
digits = random.choices(string.digits, k=2)
# select 9 uppercase letters at random
letters = random.choices(string.ascii_uppercase, k=9)
# shuffle both letters + digits
sample = random.sample(digits + letters, 11)
result = "NAA3U" + ''.join(sample)
print(result)
Output from a sample run
NAA3U6MUGYRZ3DEX
If the code needs to contain at least 3 digits, but is not limited to this threshold, just change to this line:
# select 11 uppercase letters and digits at random
letters = random.choices(string.ascii_uppercase + string.digits, k=11)
this will pick at random from uppercase letters and digits.
You can add the remaining 2 digits at the end if it is fine for you like this
import random
import string
result1 = "NAA3U" + ''.join((random.choice(string.ascii_uppercase) for codenum in range(8))) + str(random.randint(10,99))
print(result1)
NAA3URYWMGIHG45
You can use random.choices and random.shuffle then use ''.join like below:
>>> import random
>>> import string
>>> def generate_rndm():
... digit_char = random.choices(string.ascii_uppercase, k=9) + random.choices(string.digits, k=2)
... random.shuffle(digit_char)
... return "NAA3U" + ''.join(digit_char)
Output:
>>> generate_rndm()
'NAA3UTVQG8DT8NRM'
>>> generate_rndm()
'NAA3UCYBWCNQ45HR'
>>> generate_rndm()
'NAA3UIJP7W7DLOCQ'
I want to build a strong password generator with Python and strong password would be 2 lowercase chars, 2 uppercase chars, 2 numbers, 2 symbols. The strong part gives me error. Too many positional arguments for method call on random in the while
# Password generator
import random
import string
def create_waek_pass():
password = random.randint(10000000, 99999999)
print(f"password : {password}")
def create_strong_pass():
password = []
for i in range(2):
lower = [string.ascii_lowercase] # i wanted to create a list with 2 lower case chars
upper = [string.ascii_uppercase]
number = [random.randint(0, 9)]
exclimations = [string.punctuation]
while len(password) <= 8:
password = random.choice(lower, upper, number, exclimations)
print(password)
As i said in my comment its never a good idea to role your own security functions as security is a complex space and should be left to professionals. however you said this is just for your own training / learning so below is an example of your code but modified to work. This is by no means a well thought design, i have simply taken your code and made it work.
# Password generator
from random import shuffle, choice
import string
def create_strong_pass():
lower = string.ascii_lowercase
upper = string.ascii_uppercase
number = string.digits
punctuation = string.punctuation
password = []
for _ in range(2):
password.append(choice(lower))
password.append(choice(upper))
password.append(choice(number))
password.append(choice(punctuation))
shuffle(password)
return "".join(password)
for _ in range(10):
print(create_strong_pass())
OUTPUT
b7B#eR?7
)V2be7!Y
3Hng7_;V
q\/mDU74
Ii03/tW:
0Md6i;K#
<:LHw0b6
2eoM&V`6
c09N)Za(
t:34T'Bo
Need to generate random string as follows
first 5 strings should be alphabet in caps
Next 4 should be integers and
one alphabet at last
output i need examples:
ACCE1664Z
BCED1782V
FBCR9126N
it is generating random string.
from string import ascii_uppercase, digits
import random
def generatestr():
str0= random.sample(ascii_uppercase,4)+random.sample(digits,4)+random.sample(ascii_uppercase,1)
return ''.join(str0)
print(generatestr())
Improvement from #ComplicatedPhenomenon's Answer
Visit here for more string constants (e.g. ascii_uppercase).
Suppose the last alphabet is also in caps.
import random
def generatestr():
alphabet = []
for letter in range(65, 91):
alphabet.append(chr(letter))
num = [str(i) for i in range(10)]
str0= random.sample(alphabet,4)+random.sample(num,4)+random.sample(alphabet,1)
return ''.join(str0)
generatestr()
import random
import string
def randomString(charLength, intLength):
letters = string.ascii_uppercase
numbers = list(range(0,9))
charArray = ""
numArray= ""
for i in range(max(charLength,intLength)):
if i < charLength:
charArray = charArray + random.choice(letters)
if i < intLength:
numArray = numArray + str(random.choice(numbers))
return (charArray + numArray + random.choice(letters))
print(randomString(5,4))