1. import random What it does: Imports Python's built-in random module Why: This module provides functions to generate random numbers and select random items from sequences Used for: The random.sample() function later in the code 2. import string What it does: Imports Python's built-in string module Why: This module contains pre-defined string constants for different character types Used for: Accessing character sets like ascii_letters, digits, and punctuation 4. total = string.ascii_letters + string.digits + string.punctuation Breaking it down: ->string.ascii_letters: Contains all alphabetic characters (a-z, A-Z) = 52 characters ->string.digits: Contains all numeric digits (0-9) = 10 characters ->string.punctuation: Contains all special characters (!@#$%^&*(), etc.) = 32 characters ->+ operator: Concatenates these three strings together Result: A single string with 94+ different characters Purpose: Creates the character pool from which the password will be randomly selected 4. length = 18 What it does: Defines a variable storing the desired password length Value: 18 characters Purpose: Specifies how long the generated password should be 5. password = "".join(random.sample(total, length)) This is the core line. Let me break it down: -> random.sample(total, length): Takes the total string (all possible characters) and the length value (16) Randomly selects 16 unique characters from the pool without replacement (no duplicates) Returns a list of 16 randomly selected characters Example result: ['P', 'a', '#', '9', 'x', '!', ...] (16 items) ->"".join(...): Takes the list of characters returned by random.sample() Joins them together into a single string with no separator between them Example: ['P', 'a', '#', '9'] becomes "Pa#9" The empty string "" means no character is inserted between items password =: Stores the final generated password in the password variable 6. print(password) What it does: Displays the generated password to the console Output: A random 18-character password like: 7kL#mN9@xQ2$pRvWut
A powerful Python application that generates secure random passwords with customizable length and composition. This program creates passwords containing a mix of uppercase letters, lowercase letters, numbers, and special characters to ensure strong security.
- Customizable Password Length: Generate passwords of any desired length
- Mixed Character Sets: Automatically includes:
- Uppercase letters (A-Z)
- Lowercase letters (a-z)
- Numbers (0-9)
- Special characters (!@#$%^&*, etc.)
- Smart Distribution: Intelligently distributes different character types for optimal password strength
- Interactive Loop: Generate multiple passwords without restarting the program
- User-Friendly Interface: Simple yes/no prompts for easy navigation
The program distributes characters in the following way:
-
50% Alphabetic Characters (50% of password length)
- Randomly chosen to be uppercase or lowercase
-
30% Numeric Characters (30% of password length)
- Random digits from 0-9
-
Remaining % Special Characters (the rest of password length)
- Random punctuation marks and special symbols
Example: For a 10-character password:
- 5 alphabetic characters (random case)
- 3 numeric characters
- 2 special characters
- Run the script - The program will ask if you want to generate a password
- Enter 'y' for yes - You'll be prompted to enter the desired password length
- Input the length - Type a number (e.g., 12) for password length
- Get your password - The generated password will be displayed
- Generate again? - The program will ask if you want to generate another password
- Enter 'n' for no - The program will exit gracefully
Do you want to generate more passwords (y/n) ? : y
Enter the length of the password: 12
K#9m@XdL2!pT
Do you want to generate more passwords (y/n) ? : y
Enter the length of the password: 15
aB#3cD$4eF%5gH^6
Do you want to generate more passwords (y/n) ? : n
Exiting the program.....
- Python Version: Python 3.x or higher
- Required Libraries:
random(built-in)math(built-in)string(built-in)
All dependencies are part of Python's standard library - no additional installation needed!
- Letters:
string.ascii_letterscontains all 52 letters (a-z, A-Z) - Digits:
string.digitscontains all 10 digits (0-9) - Special Characters:
string.punctuationcontains symbols (!@#$%^&*, etc.)
- Alpha length: Password length ÷ 2 (integer division)
- Number length: Password length × 0.3 (rounded up using
math.ceil()) - Special char length: Remaining characters to fill the password
This password generator creates reasonably secure passwords suitable for most purposes. The random selection and character mixing provide good entropy.
Recommendations:
- Use passwords of at least 12 characters for better security
- Use the generated passwords for important accounts
- Don't reuse passwords across different services
- Store passwords securely in a password manager
Pythonpracticeproject2/
├── randompasswordgenerator_A.py # Simple version
├── randompasswordgenerator_B.py # Advanced version (this file)
└── README.md # Documentation
This is an excellent learning project that covers:
- ✅ Python
whileloops - ✅ String manipulation
- ✅ The
randommodule - ✅ The
stringmodule - ✅ User input handling
- ✅ Conditional logic (if/elif/else)
- ✅ List operations
- ✅ Mathematical operations
After studying this code, you'll understand:
- How to work with Python's built-in libraries
- How to create interactive programs
- How to manipulate strings and characters
- How to use loops for repetitive tasks
- How randomization works in Python
import random import math import string Explanation: import random: ->The word import means "bring in" or "load" ->random is a built-in Python module (a collection of pre-written code) ->This allows us to use functions that generate random values ->We'll use random.choice() to pick random characters import math: ->math is another built-in module for mathematical operations ->We'll specifically use math.ceil() which rounds numbers UP to the nearest whole number ->For example: math.ceil(3.2) becomes 4 import string: ->string is a module that contains pre-defined character groups ->This is more efficient than typing out all letters, numbers, and symbols ourselves
alpha = string.ascii_letters num = string.digits special = string.punctuation Explanation: alpha = string.ascii_letters: ->We create a variable called alpha (short for alphabetic) ->string.ascii_letters is a string containing all 52 letters: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' ->Now we can refer to all letters simply by using alpha ->Think of it as a container holding all the letters num = string.digits: ->We create a variable called num (short for numbers/numerals) ->string.digits contains all 10 digits: '0123456789' ->This is a shortcut instead of typing '0123456789' every time special = string.punctuation: ->We create a variable called special ->string.punctuation contains all special symbols: '!"#$%&\'()*+,-./:;<=>?@[\\]^_{|}~'` ->These are the fancy characters used for security in passwords ->Visual Example: -> alpha = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' -> num = '0123456789' -> special = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
while True: more = input("\n Do you want to generate more passwords (y/n) ? : ").lower() if more == 'y': Explanation: while True: ->while means "keep doing this block of code as long as the condition is true" ->True is always true, so this loop runs forever (until we break out of it) ->This keeps asking for passwords indefinitely ->more = input(...).lower() input(): ->displays a message and waits for the user to type something and press Enter ->The message shown to the user is: " Do you want to generate more passwords (y/n) ? : " .lower(): ->converts whatever the user typed to lowercase ->So if they type 'Y', it becomes 'y' (makes it easier to check) ->We store their answer in the variable more ->\n means "new line" - creates space before the question if more == 'y': ->if checks if a condition is true ->== means "is equal to" (used for checking, not assigning) ->This checks: "Did the user type 'y'?" ->If yes, run the code block below
pass_len = int(input("Enter the length of the password: ")) alpha_len = pass_len // 2 num_len = math.ceil(pass_len * 0.3) special_len = pass_len - (alpha_len + num_len) Explanation: pass_len = int(input("Enter the length of the password: ")): ->input() gets what the user types ->int() converts the text to a whole number (integer) ->So if user types "12", it becomes the number 12 ->We store this in variable pass_len (password length) ->Example: user types "12" → becomes 12 (number) alpha_len = pass_len // 2: ->This calculates how many LETTERS we'll have in our password ->// means "divide and round DOWN" (integer division) ->If password is 12 characters: 12 ÷ 2 = 6 letters ->If password is 15 characters: 15 ÷ 2 = 7.5 → rounds down to 7 letters num_len = math.ceil(pass_len * 0.3): ->This calculates how many NUMBERS we'll have ->* 0.3 means "multiply by 0.3" (which is 30%) ->math.ceil() rounds UP to the nearest whole number ->If password is 12: 12 × 0.3 = 3.6 → rounds up to 4 numbers ->If password is 15: 15 × 0.3 = 4.5 → rounds up to 5 numbers special_len = pass_len - (alpha_len + num_len): ->This calculates how many SPECIAL CHARACTERS we'll have ->We take the total length and subtract the letters and numbers ->If password is 12: 12 - (6 + 4) = 2 special characters ->This ensures all character positions are filled Visual Example for 12-character password: ->Code: Total length: 12 Letters: 6 (50%) Numbers: 4 (30%) Special: 2 (remaining) Total: 6 + 4 + 2 = 12 ✓
password = [] for _ in range(alpha_len): Explanation: password = []: ->We create an empty list called password ->[] represents an empty list (like an empty shopping basket) ->A list can hold multiple items ->We'll add characters to this list one by one for _ in range(alpha_len): ->for means "repeat this block of code multiple times" ->_ is a variable name (the underscore means "we don't need the value") ->range(alpha_len) creates numbers from 0 up to (but not including) alpha_len ->If alpha_len is 6, this repeats 6 times (0, 1, 2, 3, 4, 5) ->This loop adds 6 random letters to our password
char = random.choice(alpha) if random.choice([True, False]): char = char.upper() password.append(char) Explanation: char = random.choice(alpha): ->random.choice() picks ONE random item from a group ->Here it picks one random letter from alpha ->So char becomes something like 'a' or 'Z' or 'm' ->Each time this line runs, it picks a DIFFERENT random letter if random.choice([True, False]): ->We randomly choose between True and False (50/50 chance) ->[True, False] is a list with two options ->This randomly decides whether to make the letter uppercase char = char.upper(): ->.upper() converts a letter to uppercase ->So 'a' becomes 'A', 'm' becomes 'M' ->This only runs if the random choice was True password.append(char): ->append() means "add to the end" ->We add our character (letter) to the password list ->After 6 iterations, our password list has 6 random letters ->Example of what happens: ->Code: Iteration 1: char = 'g' → True → char = 'G' → password = ['G'] Iteration 2: char = 'x' → False → password = ['G', 'x'] Iteration 3: char = 'h' → True → char = 'H' → password = ['G', 'x', 'H'] ... and so on for 6 iterations
for _ in range(num_len): password.append(random.choice(num)) Explanation: for _ in range(num_len): ->Similar to before, but now repeating num_len times ->If num_len is 4, this repeats 4 times ->password.append(random.choice(num)) random.choice(num): ->picks one random digit from 0-9 ->We add it directly to the password list ->No need to check uppercase/lowercase (numbers stay the same!) ->Result: ->Code: After letters: password = ['G', 'x', 'H', 'w', 'B', 'z'] After numbers: password = ['G', 'x', 'H', 'w', 'B', 'z', '4', '7', '2', '9']
for _ in range(special_len): password.append(random.choice(special)) Explanation: for _ in range(special_len): ->Repeats special_len times ->If special_len is 2, this repeats 2 times ->password.append(random.choice(special)) random.choice(special): ->picks one random special character ->We add it to the password list ->Result: ->Code: After special: password = ['G', 'x', 'H', 'w', 'B', 'z', '4', '7', '2', '9', '#', '@']
generated_pwd = ''.join(password) print(generated_pwd) Explanation: generated_pwd = ''.join(password): ->''.join() combines all items in a list into ONE text string ->'' is empty text (with nothing between the quotes) So all list items are joined with nothing between them ['G', 'x', 'H'] becomes 'GxH' ->We store the final password in generated_pwd print(generated_pwd): ->print() displays something on the screen ->This shows the generated password to the user ->Example output: Gx#H7w@Bz429
elif more == 'n': print("Exiting the program.....") break Explanation: elif more == 'n': ->elif means "else if" - another condition to check ->This checks: "Did the user type 'n'?" ->This runs only if the first if was false print("Exiting the program....."): ->Displays a goodbye message to the user break: ->break stops the loop immediately ->It exits the while True loop, ending the program ->Without this, the loop would run forever!
else: print("Invalid choice try again.....") Explanation: else: ->This runs if NONE of the previous conditions were true ->Meaning: the user didn't type 'y' and didn't type 'n' ->Maybe they typed 'maybe' or 'x' or something else print("Invalid choice try again....."): ->Tells the user they made a mistake ->The loop continues (back to the top of while True) ->The user gets asked again
🎯 Program Flow Diagram:-
START ↓ Ask: "Want more passwords?" ↓ ┌─────────────────────────────────────┐ │ │ ├─ User types 'y' ──→ Get length ──→ Generate password ──→ Display ──→ Loop back │ │ ├─ User types 'n' ──→ Exit program │ │ │ └─ User types anything else → Show error → Loop back ↓ END
📚 Key Concepts Summary Table:-
Concept What It Does Example
import Brings in libraries import random
= Assigns value to variable alpha = string.ascii_letters
// Integer division (rounds down) 12 // 2 = 6
math.ceil() Rounds up math.ceil(3.2) = 4
while True: Infinite loop Loop until break
for ... in range(): Repeats set number of times for x in range(5) = 5 times
random.choice() Picks random item Pick random letter
.append() Adds to list list.append('a')
''.join() Combines list into string ['a','b'] = 'ab'
break Exits loop Stop while loop
if/elif/else Conditional logic Check user input
🎓 Learning Checkpoints:
After understanding this code, you should be able to:
✅ Explain what import does and why we need it ✅ Describe the three character sets used ✅ Calculate character distribution for any password length ✅ Explain how while True creates an infinite loop ✅ Understand how random.choice() works ✅ Explain why we use .lower() on user input ✅ Describe what .append() and .join() do ✅ Trace through an example password generation ✅ Explain the if/elif/else logic flow ✅ Know when to use break to exit a loop
This comprehensive guide covers every line of code with beginner-friendly explanations! 🎉