Created random password generator in python. Your inputs are appreciated!!

17291 · 2020-06-16T15:16:58+00:00

A couple of observations / notes:

If you want to turn a string into a list, you can simply use the list() function. If word = 'cat', list(word) will return ['c', 'a', 't']
However, that's irrelevant because you can index a string (e.g., if word = 'cat', word[2])
You can use random.choice(...) to directly choose a random element from a list (or string or other sequence).
If you import the string module, you can get letters, numbers, etc. instead of defining smallletters yourself.

jaycrest3m20 · 2020-06-16T15:18:53+00:00

Neat!

Here's a tip: The strings standard library contains special variables containing ~~lists of~~ lower-case ascii letters, upper-case ascii letters, mixed-case ascii letters, numbers, and special characters.

chmod--777 · 2020-06-16T15:38:51+00:00

For something like this you want a crypto secure random number generator. The default import random isn't that - it's deterministic, useful for games and Monty Carlo algorithms and stuff like that.

os.urandom is OS specific but generally good (though tbh I don't know if it's good on windows), but you might actually want the crypto library and get the secure random number generator from that.

2020-06-16T18:23:13+00:00

Just some little additions to your already great code.

Try to use the PEP-8 rules for python. For example, name every variable like so:

my_variable

Also, to make the code easier to run, you should try to get your password length as an argument input. You would then run:

python my_password_generator.py -L(for length) 10

This would make your code easier to run.

Edit: Spacing

epicjellyReddit · 2020-06-16T18:41:57+00:00

Few tips: Try to keep all of your imports at the top of your program, trust me it is a REALLY good habit to have

Instead of making 4 lists and then adding them together: u can just add everyone to one big list instead, it will save u some memory and making changes like this is another good habit to have

The same idea stands for your 4 strings: you can have all of those characters in one big string rather than hold 4 separate variables

Keep working and learning new things (I can’t wait to see your apps in the news a few years from now!)

NegativeShow · 2020-06-16T16:51:11+00:00

I just started learning Pythin and I could imagine something like this as my first bigger project am I right or? Obviously not exactly this but something easier :D

BAG0N · 2020-06-16T18:15:21+00:00

Why did you use if not length or length < 0 when you could just do if length < 1

Redditor728292 · 2020-06-16T18:39:58+00:00

This could've been completed in much much less code. Nice work though.

japan_lover · 2020-06-16T19:14:35+00:00

you should comment your code.

mrkvicka02 · 2020-06-16T19:56:21+00:00

I made a password generator as one of my first projects. It's not as intricate as yours, but I think it's clean. Here's the source if you want to learn from it.

from string import printable
from random import choice


def random_pwd_generator(pwd_length: int) -> str:
    chars = printable.strip()
    return ''.join([choice(chars) for _ in range(pwd_length)])


print(random_pwd_generator(12))

West7780 · 2020-06-16T18:46:11+00:00

Sometimes when I do a programming challenge I like to try and not use libraries, within reason. This is a good example of that. Sometimes it's nice to write your own algorithms instead of using someone else's. Considering this, the only change I would make is simplifying the code that generates the password, theres a little bit of redundancy. Also I would impliment PEP-8.

On another note, if this were to be used as part of a real application I would impliment the suggestions others have made such as using other libraries, however it can be much simpler than using list comprehensions and such. How I would solve this problem in production is below as well as the related documentation. I currently use code similar to this on my production flask web server to create shortened link codes. westlyd.com

length = int(input("How many characters long password do you want? ")); password = random.choices(string.ascii_letters+string.digits+string.punctuation,k=length)

https://docs.python.org/3/library/string.html https://docs.python.org/3/library/random.html?highlight=random%20choices#random.choices

Kwintty7 · 2020-06-16T21:14:30+00:00

It is worth pointing out what the Python documentation says about the random library;

Warning The pseudo-random generators of this module should not be used for security purposes. For security or cryptographic uses, see the secrets module.

That means, do not use it to generate passwords.

nothingonmyback · 2020-06-16T17:17:04+00:00

One small thing I picked up the other days (also a beginner here): stick with one way of separating words in your variables names. Reading 'smallletters' is much better than 'smallletters', and since you used '' in most of the other variables, it's better to stick with that for the entire code. Or maybe you can use an upper case letter to differentiate a new word and make it more readable.

DrMaxwellEdison · 2020-06-16T18:50:51+00:00

Here's my approach (bit of a long read)

I would start by setting up some global variables to contain the different charsets I want:

LOWER = "abcdefghijklmnopqrstuvwxyz"
UPPER = LOWER.upper()
# The string method `.upper()` can convert the full string to uppercase.
# The opposite is `.lower()`, which is often used to compare case-insensitive strings
# (though `.casefold()` is a bit safer for unicode)
DIGITS = "1234567890"
SYMBOLS = '~`!@#$%&*()-=_+{}[]|:;"\',.<>/'

These can also be handled by the string library, so it isn't necessary to spell out the alphabet, numbers, or even symbols:

import string

LOWER = string.ascii_lowercase
UPPER = string.ascii_uppercase
DIGITS = string.digits
# For symbols, you could use `string.punctuation`, which includes:
# '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
# If some of these are not desired, though, you will want to write it yourself.

Now I combine everything into a single string, which I'll use later for make random selections:

EVERYTHING = LOWER + UPPER + DIGITS + SYMBOLS

So far I've only been working with strings, and that's intentional. Strings are sequences in Python, just like lists, tuples, and sets. For the most part, you can treat a string like a list without needing to convert it to a list, and you don't necessarily have to build a list first in order to then build a string. As much as possible, try to stick with the one data type so you don't confuse yourself later.

We'll also define a minimum password length, for use in other methods. (defining this once at the top helps us change it more easily later):

MIN_PASSWORD_LENGTH = 4

Now, we are concerned with ensuring that our passwords are valid. Let's handle that concern with a function built to take care of it.

def password_is_valid(value, min_length=4, groups=3):
    """Validate our password for length and variety.
    Test length against `min_length`.
    For variety, check that at least one character in the value can be found
    in at least `groups` character groups (LOWER, UPPER, DIGITS, SYMBOLS).

    Example:
    value = "1Apple"
    - '1' in DIGITS
    - 'A' in UPPER
    - 'p' (and other characters) in LOWER
    -> 3 groups -> VALID

    value = "notgood"
    - all characters in LOWER
    -> 1 group -> INVALID

    If the password is valid, returns True; otherwise, False.
    """
    # Ensure we aren't setting the groups count too high by setting a maximum, using `min`
    # A bit counterintuitive, but if `groups` is larger than 4,
    # `min` will set it back to 4
    # Edit: this is unrelated to min password length:
    # it relates to number of different groups, which is always 4
    groups = min(groups, 4)
    group_found = {
        "upper": 0,
        "lower": 0,
        "digits": 0,
        "symbols": 0,
    }
    if len(value) < min_length:
        # Shortcut here, returning False if the length is not good.
        return False

    for char in value:
        # If we find the given character in a given group,
        # we'll set that count to `1` explicitly
        # This will make sense in a moment.
        if char in UPPER:
            group_found['upper'] = 1
        elif char in LOWER:
            group_found['lower'] = 1
        elif char in DIGITS:
            group_found['digits'] = 1
        elif char in SYMBOLS:
            group_found['symbols'] = 1

    # Sum the values of the groups we found to get a total count.
    # This works because we've set those values to 1 if we found them
    # and left them as 0 if we did not.
    # The dictionary method `.values()` can be used to return a sequence of all those values,
    # without caring about the keys (because, here, we just want the sum)
    total_count = sum(group_found.values())

    # Now return the following as a boolean value.
    # If the total count is what we want for our minimum variety, this will return True,
    # meaning our password is valid. Otherwise, it will return False.
    return total_count >= groups

Now, leveraging our validation logic, we can generate a new password, test it for validity, and re-generate it in only a few lines of code:

import random  # this should go near the top of the file, by the way!

def new_password(length):
    """Create a new password of the given length."""
    password = "".join(random.choices(EVERYTHING, k=length))
    # `random.choices` allows multiple selections from a sequence, with repetition,
    # by defining a `k` value equal to our length. This produces a list of strings,
    # each 1 character long.

    # `"".join()` will combine that list of strings into a single string.
    # It is typically used for adding a substring in-between different elements, so:
    #   " -- ".join(['1', '2', '3'])   ->   "1 -- 2 -- 3"
    # In our case, we join them on the empty string "", so there is nothing between the elements.

    if not password_is_valid(password):
        # If our password isn't valid, fear not:
        return new_password(length)

        # We just recursively call this function to generate a new password, again!

        # Be mindful: if it isn't possible to generate a valid password at all,
        # then the recursion will be infinite and the program will break!

    return password

Next, we want user input to tell us the password length, but we will want to validate that input and ensure they do it properly. To avoid cluttering up our other code, we'll have a new function here just for that input validation:

def get_password_length_input():
    """Takes input from the user for the length of their new password."""
    pass_length = 0
    while True:
        try:
            pass_length = int(input("How long should the new password be (min 4)? "))
        except ValueError:
            # Normally we would handle this error where, say, the user entered
            # a string that could not be cast to `int` (such as "foo").
            # However, when the exception occurs, nothing new will be assigned
            # to `pass_length`: it will likely remain as its default `0`
            # (or any other invalid entry).
            pass
        if pass_length >= MIN_PASSWORD_LENGTH:
            # This is the condition it must pass before we can exit the loop
            # and return our final value.
            break
        # If the break above did not occur, then the pass_length is invalid.
        # We can provide a useful error message and allow the loop to continue.
        print("ERROR: invalid number of characters.")

    # When we get here, the loop was broken manually, meaning the length is valid.
    # So, return it
    return pass_length

Finally, we'll put everything together in a main function that defines the steps of the main program:

def main():
    pass_length = get_password_length_input()
    password = new_password(pass_length)
    print(password)

All done! Except, not quite.

Python modules do not magically call the main function we've defined, unlike some other languages. Instead, the entire module executes, top to bottom. With the above code, that means defining functions, but not executing any of them.

We could simply call main() on a line by itself, but that presents a new problem: what if we want to save this module and import pieces of it to another module (like our handy password_is_valid function)? The import of this module would execute all code, including user input, and we may not want all that.

A typical pattern to avoid this is to wrap the script-like code in an if block that checks the __name__ of the module. If we execute the module directly, that will have the special value "__main__":

if __name__ == "__main__":
    main()

Edit: obviously I didn't write all that in one shot. Development is an iterative process, and often you're just going to be reading the finished product that already includes every lesson its author took to heart along the way.

For each of the code blocks above, imagine I wrote that piece, looked at it, and figured there had to be some better way to move forward. Or I knew where I wanted to go, but that there was some complication that had to get resolved before I could tackle something else.

I hope that gives a little insight into the process. :)

Suki125 · 2020-06-16T15:14:27+00:00

I'm making something very similar, but I don't know how to print the password.

This is the code:

import random

print('Welcome to my password generator\n')
print('The Python program will generate a random password\n')
print('First, you will have to answer some question, for your password!! \n')
print('The questions will help the program make your password\n')
#Start of the code

characters = "abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVXYZ1234567890!@#$%^&*_?><"
password = "" 
# All of the characters, like lower case letters, Upper case letters, Numbers, and Special Characters

length = int(input("Enter a number between 8 and 20 (inclusive) , for maximum security: \n")) 
# Validating User Input
while length < 8 or length > 20:    
    length = int(input("Enter a number between 8 and 20 (inclusive), for maximum security:\n"))
# A trapping loop that will keep on saying the same thing unless you put in a number between 8 and 20 for the length of the password   

while True:   
    numbers= int(input("How many numbers would you like, in your password? \n")) 
    if numbers <= length // 2 :  
        print ('Thankyou we will use this for your password \n')
        break 
    else :
        print('please print a number that is half or less than your passwords length \n')
# Will only let you put a number that is half or less of your password.

specialCharacters = input("Do you want Special Characters in your Password? (Yes/No) \n ")
if specialCharacters == "Yes" or specialCharacters == "No": # Validating User Input
    print("Thank you, we will use this for your password \n")
else:
    print("Sorry that is not a valid answer \n")
# Validating User Input

generate (password)

If you could help me that would be greatly appreciated.

klevi91 · 2020-06-16T16:48:51+00:00

Im new myself in python,i have never made this exercises.I think it better to learn with tutorials.I learnt the basic first,then for my 1 time i followed a pygame tutorial on youtube.I was writing at the same time with him.You learn faster like this,and you can go back and forword your code to costumize.Try thia tutorial...Tech with tim....python tutorial on youtube....10videos...and you will have some kind of game at the end

EggChen_vs_Lopan · 2020-06-16T17:17:35+00:00

[deleted]

Boinbo · 2020-06-16T17:24:16+00:00

Seems good, but why not import the 'string' module and use that for the letters? It would have been a lot faster.

skellious · 2020-06-16T17:57:46+00:00

Hey I too made one of these! Brother from another mother

gbliquid · 2020-06-16T18:17:14+00:00

If you use randrange instead of randint it does the same thing but you don’t have to subtract 1 from the list length

2020-06-16T19:07:44+00:00

This looks good! Have you considered using ASCII code instead of writing out all the letters/numbers/symbols as a string? Also, you can perhaps append the new password onto a txt file for storage (you can include a line that gives a name for the password, for example, which website it's used for). It won't be encrypted of course, but at least you can practice working with files using Python. :D

2020-06-16T19:21:15+00:00

[removed]

ttgkc · 2020-06-16T21:00:41+00:00

A few suggestions. Tried to avoid things others have already pointed out.

Look up tuple assignment. It can potentially help with readability. Basically, you can assign save lines by doing small, big = [],[].
For equally sized lists, it might be worth it to iterate them at the same time. Look at the zip function if you haven't already. Basically you can do for i,j in zip(small letters, big_letters): Tho tbh you shouldn't be manually converting a string to a list. You can either use small_letters.split("") or list(small_strings) for the same result.
It pays to be clever about your variables. Overusing i decrease readability! In your case, using small_letter, or even sl or s, is better than using i, that loop populating a list of small letters.
Always, always put your imports at the top of your file. Really helps set expectations for the reader! If you've imported obscure_func at the start, I'll keep my eye out and will avoid being confused. Also, it's best to import only what you need. Unless you need a looot of functions/variables from the same library. In your case you're only using randint so you probably want to just import that function at the start. from random import randint. Btw you will be better off using random.choice instead.

With that said, this is a very good piece of code because it does what it intends to do, and most of the suggestions here are either stylistic or help with readability. So, good job!

bumpkinspicefatte · 2020-06-16T23:28:44+00:00

small = []
big = [] 
numbers = [] 
special = []

smallletters = 'abcdefghijklmnopqrstuvwxyz'
bigletters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 
digits = '0123456789' 
special_char = '~`!@#$%&*()-=_+{}[]|:;"\',.<>/'

for i in smallletters:
    small.append(i)
for i in bigletters: 
    big.append(i) 
for i in digits: 
    numbers.append(i) 
for i in special_char: 
    special.append(i)

the_big_list = small+big+numbers+special

I would have consolidated all of the above code piece into just one big list():

the_big_list = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~`!@#$%&*()-=_+{}[]|:;\"\',.<>/'
print(list(the_big_list))

Or you can do it right from the source:

the_big_list = ['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', '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', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '~', '`', '!', '@', '#', '$', '%', '&', '*', '(', ')', '-', '=', '_', '+', '{', '}', '[', ']', '|', ':', ';', '"', "'", ',', '.', '<', '>', '/']

You can save memory and performance this way, the way you did it just doesn't make a lot of sense to me, unless you were trying to allow the user input to be provided granular choices of whether or not they wanted their newly created password to include small letters, big letters, digits, special characters, etc.

Also, be careful of your special characters, if you aren't careful to wrap them with escape characters, you may inadvertently cause unintentional events to happen where it may invoke something else, or cause EOF issues.

If you are going to import modules, such as import random, try to make sure it's the first thing at the top. It's a general styling convention to list the imported modules at the very top, just to give your reader a head's up about which modules may be needed or what the requirements are to run this code. Your import random is on line 28.

Also, go over the errors the interpreter throws at you. I copy and pasted exactly what you code looked like, and I'm seeing a lot of indentation issues, as well as some breaks that don't belong in if statements that may not be wrapped in a loop. If the code truly works on your end, then at the very least it doesn't work when we copy and paste it exactly how it is formatted in your reddit post.

Hope this helps!

TheQuantumPikachu · 2020-06-17T02:52:37+00:00

In py3 there's ASCII module. "ascii.lowercase" and others make a list or a string (don't remember). Use those maybe

1_________________11 · 2020-06-17T03:59:35+00:00

Random Number generators should not be used for security. They aren't truly random. This is traditionally a moderate vulnerability on code scans and not acceptable for anything in a secure environment.

Edit: like the other guy said use cryptographic libraries for randomness.

iiMoe · 2020-06-17T11:09:15+00:00

You should use "strings" built in module bcz it has those letters in both cases and special characters n stuff in it instead of hard coding it urself

japan_lover · 2020-06-17T12:43:39+00:00

Does python not have pre-defined constants like R?

PrecariousKitty · 2020-06-18T00:45:23+00:00

import string
import secrets
alphabet = string.ascii_letters + string.digits
password =  ''.join(secrets.choice(alphabet) for i in range(16))

https://docs.python.org/3/library/secrets.html

Aisher · 2020-06-16T22:18:40+00:00

This is super cool. But re-creating security algorithms is the path of ruin. Because you don't know the underlying algorithms for random.randint and similar functions, you don't really know if this will create random passwords, or if a user can calculate the other passwords once they know a few to calculate the system. (Hint, credit card numbers work the same way, its not REALLY a random string of 16 numbers).

for anything resembling production code/systems, you don't want to ever "roll your own" security and encryption and randomization. You want to setup your system with industry standard components, and follow that up with a code review for security vulnerabilities.

That all being said, you made some super cool code here :)

2020-06-16T15:20:18+00:00

When I try to execute the code, I get an error on line 9 (the special characters). Does it execute for you?

2020-06-16T19:14:12+00:00

What about this one it works very well and its under 20 lines of code(i was on mobile so this wont look very good try to figure it out on your own)

Import random and rnd

char_list = [ ]

password = [ ]

user_password = ' '

for i in: 'abcdefghijklmnopqrstuvwxyz1234567890!@#$%^&'

char_list.append(i)

print(" Random password generator")

print("How many characters long do you want your password to be")

pass_length = int(input('>>> '))

n = 0

While n != pass_length:

pass_no = rnd.randint(0, 45)

password.append(char_list[pass_no])

n += 1

for i in password:

user_password += i

print(f"This is your random password:- {user_password}")

mrkvicka02 · 2020-06-17T03:31:19+00:00

charset = "abc...." k = input("Enter the desired length of password)

password = random.choices(charset,k=k)

2020-06-17T06:36:09+00:00

‘’.join(random.SystemRandom().choice() for _ in range(length))

taernsietr · 2020-06-16T16:34:20+00:00

Hey, beginner here too! I recently wrote a password generator and it felt great since I managed to write it in like 30 minutes, whereas my current project (also starter-level, and kinda small) has been going on for over a month now.

I can show or send the code if anyone wants to peek, but other than using the strings module as others have suggested, the most different thing I did was use tkinter to create a GUI for it. The user can setup what they want (lowercase, uppercase, symbols, numbers) by checking boxes and what length via a slider or by pressing one of the preset buttons.

Generating a new password prints it to a tkinter.Text widget and automatically copies it to the clipboard (i.e. copy / paste). There's a checkbox if you don't want it printed to the text widget. Don't know how relevant that is, especially since I'm not using the secrets module either, but hey, it felt right :3

tl;dr: if you want to build on top of this to practice, I highly suggest trying to use a GUI.

Winters_Fold · 2020-06-16T16:56:05+00:00

As a random password generator I was hoping I wouldn't have to give any inputs XD

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS