Python Project: Password Generator

What you are building

You build a generator that picks characters from letters, digits, and symbols. The length is a number you choose. The program prints three sample passwords and checks that each one is exactly that long.

Run the code at /try. That is the Python editor, not HTML, C, or C++. The examples callrandom.seed(1) so the three samples stay the same every time you click Run. That makes the output easy to check.

Skills used

• random.choice to pick one character from a pool
• random.seed so a tutorial run is repeatable
• string.ascii_letters and string.digits
• "".join(...) to glue characters into one password
• A length rule: reject or rebuild if len(password) != n

Build the character pool

A password is a string. The generator does not invent letters from nowhere. It chooses from a pool you define. Keep letters, digits, and symbols in named pieces so you can require one of each later.

import string

letters = string.ascii_letters
digits = string.digits
symbols = "!@#$%^&*?"
pool = letters + digits + symbols

print("Letters:", letters)
print("Digits:", digits)
print("Symbols:", symbols)
print("Pool size:", len(pool))

Pick N characters with a seed

random.choice(pool) returns one character. Repeat that N times and join. Setting the seed first freezes the sequence. Change the seed and you get a different trio of samples.

import random
import string

random.seed(1)
pool = string.ascii_letters + string.digits + "!@#$%^&*?"
length = 12

password = "".join(random.choice(pool) for _ in range(length))
print(password)
print("Length ok:", len(password) == length)

Complete program

Each password starts with one letter, one digit, and one symbol so the mix is not all letters by chance. The rest of the slots fill from the full pool. random.shuffle hides those first three picks. Three samples print, each checked against length N.

import random
import string

random.seed(1)

LETTERS = string.ascii_letters
DIGITS = string.digits
SYMBOLS = "!@#$%^&*?"
POOL = LETTERS + DIGITS + SYMBOLS
N = 12

def make_password(length):
    if length < 4:
        return None
    chars = [
        random.choice(LETTERS),
        random.choice(DIGITS),
        random.choice(SYMBOLS),
    ]
    while len(chars) < length:
        chars.append(random.choice(POOL))
    random.shuffle(chars)
    return "".join(chars)

print("Password generator")
print("Required length:", N)
print()

ok = 0
for i in range(3):
    pwd = make_password(N)
    if pwd is None:
        print("Sample", i + 1, "-> length too small")
        continue
    passed = len(pwd) == N
    if passed:
        ok += 1
    print("Sample", i + 1, ":", pwd)
    print("  chars:", len(pwd), " rule:", "pass" if passed else "fail")

print()
print("Passed", ok, "of 3")

Because the seed is 1, a second Run prints the same three strings. If you need a one-off secret on your own machine, drop the seed line and, if you like, swap random.choice forsecrets.choice.

Common mistakes

• Forgetting "".join. A generator expression of characters is not a password until you join it.
• Using random.randint on character codes and hoping the result is printable. A pool of characters is simpler and safer.
• Seeding in production. A fixed seed means anyone can replay the same passwords.
• Checking length with print only. Store a boolean and count passes, as the complete program does, so a failed sample cannot hide in the log.
• Putting a quote inside the symbol string and breaking the Python string. Keep the symbol set short, or use a triple-quoted string.

How to extend / Practice tasks

Change N, the pool, or the number of samples. Keep the seed until you like the new output.

1. Set N = 16 and generate three samples. Confirm every printed length is 16.
2. Remove digits from POOL but still require one digit in the first three picks. Check that each sample still contains at least one character from string.digits using a loop orany(ch.isdigit() for ch in pwd).
3. Print a fourth sample using secrets if the import works, otherwise fall back torandom. Do not seed that fourth sample.