Random Username Generator – Build a Python Tool from Scratch

A program that creates unique, random usernames by combining adjectives, nouns, and numbers. You will learn how to work with lists, pick random elements, build strings, and write clean, reusable functions. This tool is useful for generating placeholder accounts, test data, or gamertags for games.

Table of Contents

• Project Overview
• Features
• Prerequisites
• Folder Structure
• Step 1 – Create the Project Folder
• Step 2 – Import and Prepare Word Lists
• Step 3 – Write the Adjective Picker Function
• Step 4 – Write the Noun Picker Function
• Step 5 – Add Random Numbers
• Step 6 – Build a Complete Username
• Step 7 – Let the User Choose How Many Usernames
• Step 8 – Add Customization Options
• Step 9 – Add Input Validation
• Step 10 – Full Source Code
• Testing
• Common Errors
• Improvements
• Challenge Exercises

Project Overview

The Username Generator takes two word lists — adjectives and nouns — picks one word from each at random, optionally appends a number, and produces a string like HappyTiger42. The user can request multiple usernames at once and control whether numbers or separators are added.

Where this is used in the real world: Every web app with user accounts needs a username generator. Social media sites use them for suggested handles. Game platforms use them for default gamertags. Testing teams use them to create hundreds of fake accounts for load testing.

Features

• Random adjective + noun combination
• Optional random number suffix (2 digits)
• Optional separator (underscore, hyphen, dot)
• Generate multiple usernames at once
• Easy-to-modify word lists
• No external libraries required
• Input validation for count

Prerequisites

Knowledge needed

• Variables and strings
• Lists
• Functions
• for loops
• import statement

Software needed

• Python 3.x
• Any text editor

Folder Structure

UsernameGenerator/
│
├── main.py      # The generator program
└── README.md    # This tutorial

Step 1 – Create the Project Folder

mkdir UsernameGenerator
cd UsernameGenerator

Create a new file called main.py.

Step 2 – Import and Prepare Word Lists

We need lists of adjectives and nouns. Instead of asking the user to type them (which would be tedious), we define them inside the program.

import random

adjectives = [
    "Happy", "Brave", "Clever", "Cool", "Crazy",
    "Fast", "Fierce", "Gentle", "Jolly", "Lucky",
    "Quiet", "Shiny", "Silly", "Smart", "Wild"
]

nouns = [
    "Tiger", "Panda", "Eagle", "Dolphin", "Falcon",
    "Lion", "Wolf", "Bear", "Fox", "Hawk",
    "Otter", "Raven", "Shark", "Whale", "Zebra"
]

Why two lists: A good username combines two unrelated words. Adjectives describe (Happy, Brave) and nouns name an animal or thing (Tiger, Panda). Keeping them separate means we get 15 × 15 = 225 combinations before adding numbers. 15 adjectives × 15 nouns × 90 possible numbers = 202,500 unique usernames.

Why capital letters: Starting each word with a capital letter makes the final username look like a proper name (HappyTiger) instead of two lowercase words run together (happytiger). The capital letters act as visual separators — this is called "PascalCase" or "UpperCamelCase".

How the list + random combination works:

adjectives = ["Happy", "Brave", "Clever", ...]    (15 words)
nouns      = ["Tiger", "Panda", "Eagle", ...]      (15 words)

random.choice(adjectives) → "Happy"
random.choice(nouns)      → "Tiger"
        ↓          ↓
    "Happy" + "Tiger" + random number (10-99)
        ↓
    "HappyTiger42"

Step 3 – Write the Adjective Picker Function

A function is a reusable block of code. Instead of writing random.choice(adjectives) every time, we wrap it in a function with a clear name.

def get_random_adjective():
    return random.choice(adjectives)

def get_random_adjective(): — The def keyword defines a function. The name get_random_adjective describes exactly what it does. The empty parentheses () mean this function takes no arguments — it needs no input, it just returns a result.

return sends a value back to the caller. When you call adj = get_random_adjective(), the variable adj receives whatever return sent.

Why write a function for one line: Functions isolate behaviour. If you later decide to change how an adjective is picked (e.g., read from a file instead of a list), you only change one place in the code, not every place that needs an adjective.

Step 4 – Write the Noun Picker Function

Same pattern for nouns.

def get_random_noun():
    return random.choice(nouns)

Testing these functions: After writing them, you can test by adding:

print(get_random_adjective())  # e.g., "Happy"
print(get_random_noun())       # e.g., "Tiger"

Each run prints a different pair.

Step 5 – Add Random Numbers

A number suffix makes the username more unique. Two digits gives us 90 possible numbers (10-99).

def get_random_number():
    return random.randint(10, 99)

random.randint(10, 99) — randint stands for "random integer". It returns an integer between the two arguments, inclusive. So 10 and 99 are both possible results. The range is 10, 11, 12, ..., 98, 99 — that is 90 distinct numbers.

Why not start at 0 or 1? Two-digit numbers (10-99) look more intentional in a username than single digits. HappyTiger4 looks odd. HappyTiger42 looks deliberate.

Step 6 – Build a Complete Username

Now combine the adjective, noun, and number into a single string. Write one function that assembles all the pieces.

def generate_username(include_number=True, separator=""):
    adj = get_random_adjective()
    noun = get_random_noun()
    
    if include_number:
        num = get_random_number()
        return f"{adj}{separator}{noun}{separator}{num}"
    else:
        return f"{adj}{separator}{noun}"

Parameters with defaults: include_number=True and separator="" are default parameter values. If the caller does not pass these arguments, the defaults are used. This means generate_username() works with zero arguments, but generate_username(False, "_") also works.

String assembly walkthrough:

Case 1: include_number=True, separator=""
  adj = "Happy", noun = "Tiger", num = 42
  f"{Happy}{}{Tiger}{}{42}"   →   "HappyTiger42"

Case 2: include_number=False, separator=""
  adj = "Brave", noun = "Falcon"
  f"{Brave}{}{Falcon}"        →   "BraveFalcon"

Case 3: include_number=True, separator="_"
  adj = "Lucky", noun = "Panda", num = 78
  f"{Lucky}{_}{Panda}{_}{78}"  →   "Lucky_Panda_78"

f"{adj}{separator}{noun}{separator}{num}" — The f-string evaluates each {} expression and inserts the value. If separator is an empty string "", it inserts nothing — the words are glued directly.

Intermediate Checkpoint

Before adding user interaction, here is the complete generator logic:

import random

adjectives = [
    "Happy", "Brave", "Clever", "Cool", "Crazy",
    "Fast", "Fierce", "Gentle", "Jolly", "Lucky",
    "Quiet", "Shiny", "Silly", "Smart", "Wild"
]

nouns = [
    "Tiger", "Panda", "Eagle", "Dolphin", "Falcon",
    "Lion", "Wolf", "Bear", "Fox", "Hawk",
    "Otter", "Raven", "Shark", "Whale", "Zebra"
]

def get_random_adjective():
    return random.choice(adjectives)

def get_random_noun():
    return random.choice(nouns)

def get_random_number():
    return random.randint(10, 99)

def generate_username(include_number=True, separator=""):
    adj = get_random_adjective()
    noun = get_random_noun()
    if include_number:
        num = get_random_number()
        return f"{adj}{separator}{noun}{separator}{num}"
    else:
        return f"{adj}{separator}{noun}"

# Quick test — generate 5 usernames
for i in range(5):
    print(generate_username())

Run this. You should see 5 random usernames like:

HappyTiger42
BraveFalcon78
LuckyPanda13
WildEagle55
QuietShark89

Step 7 – Let the User Choose How Many Usernames

Now add user interaction. Ask the user how many usernames they want and run the generator in a loop.

print("=== Username Generator ===\n")

count = int(input("How many usernames do you want? "))

for i in range(count):
    username = generate_username(include_number=True)
    print(f"{i+1}. {username}")

int(input(...)) — input() always returns a string. If the user types "5", int("5") converts it to the integer 5. If the user types "five", int("five") crashes with a ValueError. We handle that later.

range(count) — range(5) produces the sequence 0, 1, 2, 3, 4. The loop body runs 5 times.

i+1 — The loop counter starts at 0, but humans count from 1. Adding 1 converts: 0→1, 1→2, 2→3, etc.

Output when run:

=== Username Generator ===

How many usernames do you want? 3
1. BraveFalcon47
2. LuckyPanda82
3. WildTiger13

Screenshot Suggestion: Terminal showing the user entering "5" and the program printing five random usernames.

Step 8 – Add Customization Options

Let the user choose whether to include numbers, what separator to use, and whether to add a prefix.

print("=== Username Generator ===\n")

count = int(input("How many usernames? "))
use_numbers = input("Include numbers? (yes/no): ").lower() == "yes"
sep_input = input("Separator (leave blank for none, or use _ - .): ")

for i in range(count):
    username = generate_username(include_number=use_numbers, separator=sep_input)
    print(f"{i+1}. {username}")

How use_numbers becomes a boolean:

input("Include numbers? (yes/no): ")      # User types: "yes"
    ↓
    "yes".lower()                          # → "yes"
    ↓
    "yes" == "yes"                         # → True
    ↓
use_numbers = True

If the user types anything other than "yes" — "no", "n", "sure", "maybe", or just presses Enter — the comparison fails and use_numbers becomes False. This is a common pattern for converting yes/no input to a boolean flag.

sep_input can be any string. Common values are "" (blank), "_", "-", ".". The user could even type "+++" to get Happy+++Tiger+++42.

Step 9 – Add Input Validation

Protect against bad numeric input. If the user types something that is not a number, ask again instead of crashing.

def get_positive_int(prompt):
    while True:
        value = input(prompt)
        if value.isdigit():
            num = int(value)
            if num > 0:
                return num
            else:
                print("Number must be greater than zero.")
        else:
            print("Please enter a valid number.")

count = get_positive_int("How many usernames? ")

value.isdigit() — Returns True if every character in the string is a digit (0-9). "5".isdigit() → True. "five".isdigit() → False. "".isdigit() → False.

The while True validation loop: Keeps asking until the user provides valid input. This is called a "validation loop" and is a standard pattern for getting reliable user input.

Full flow:

User types: "five"
isdigit("five") → False → "Please enter a valid number." → ask again

User types: "0"
isdigit("0") → True → int("0") → 0 → 0 > 0 → False → "Number must be > 0" → ask again

User types: "5"
isdigit("5") → True → int("5") → 5 → 5 > 0 → True → return 5

Step 10 – Full Source Code

import random

adjectives = [
    "Happy", "Brave", "Clever", "Cool", "Crazy",
    "Fast", "Fierce", "Gentle", "Jolly", "Lucky",
    "Quiet", "Shiny", "Silly", "Smart", "Wild"
]

nouns = [
    "Tiger", "Panda", "Eagle", "Dolphin", "Falcon",
    "Lion", "Wolf", "Bear", "Fox", "Hawk",
    "Otter", "Raven", "Shark", "Whale", "Zebra"
]

def get_random_adjective():
    return random.choice(adjectives)

def get_random_noun():
    return random.choice(nouns)

def get_random_number():
    return random.randint(10, 99)

def generate_username(include_number=True, separator=""):
    adj = get_random_adjective()
    noun = get_random_noun()
    if include_number:
        num = get_random_number()
        return f"{adj}{separator}{noun}{separator}{num}"
    else:
        return f"{adj}{separator}{noun}"

def get_positive_int(prompt):
    while True:
        value = input(prompt)
        if value.isdigit():
            num = int(value)
            if num > 0:
                return num
            else:
                print("Number must be greater than zero.")
        else:
            print("Please enter a valid number.")

print("=== Username Generator ===\n")

count = get_positive_int("How many usernames? ")
use_numbers = input("Include numbers? (yes/no): ").lower() == "yes"
sep_input = input("Separator (leave blank for none, or use _ - .): ")

print()
for i in range(count):
    username = generate_username(include_number=use_numbers, separator=sep_input)
    print(f"{i+1}. {username}")

Testing

Run the file:

python main.py

Test 1 – Default generation

Input: How many usernames? 3
Input: Include numbers? yes
Input: Separator: (press Enter — blank)
Expected: Three usernames like BraveFalcon47, LuckyPanda82, WildTiger13 (no separators)

Test 2 – With underscore separator

Input: How many usernames? 2
Input: Include numbers? yes
Input: Separator: _
Expected: Brave_Falcon_47, Lucky_Panda_82

Test 3 – No numbers

Input: Include numbers? no
Expected: BraveFalcon, LuckyPanda, WildTiger (no digits appended)

Test 4 – Zero usernames (edge case)

Input: How many usernames? 0
Expected: "Number must be greater than zero." Prompt repeats.

Test 5 – Invalid number (text input)

Input: How many usernames? five
Expected: "Please enter a valid number." Prompt repeats.

Common Errors

ValueError: invalid literal for int()

Trigger: User typed something that is not a number, like "five" or left it blank.
Why: `int("five")` cannot convert "five" to an integer.
Solution: Use `.isdigit()` to validate before converting, as shown in Step 9.

AttributeError: module 'random' has no attribute 'choice'

Trigger: You named your file random.py.
Why: Python looks for modules in the current folder first. Your file "random.py" shadows the built-in random module. So `import random` imports your file, not Python's random.
Solution: Rename your file to main.py or generator.py, and delete any random.pyc file in the __pycache__ folder.

Output looks like HAPPYTIGER42 (all caps)

Trigger: The word lists accidentally use uppercase.
Why: No `.lower()` or `.title()` conversion is applied.
Solution: Either use title case in the lists ("Happy" not "HAPPY") or call `.title()` on the final username.

Username always the same (seems not random)

Trigger: Running multiple times and seeing the same combination.
Why: With only 15 adjectives and 15 nouns, repeats happen. Each specific combo has a 1/225 chance.
Solution: Add more words to the lists. Or observe over 20+ generations — you will see variety.

Improvements

• Load adjectives and nouns from an external text file instead of hardcoding
• Add a "leet speak" mode (replace letters with numbers: Tiger → T1g3r)
• Generate pronounceable usernames using random syllables (consonant + vowel pairs)
• Check against a "taken" list to avoid duplicates
• Copy the generated username to the clipboard with pyperclip
• Add a GUI version with Tkinter
• Add themed word sets: animals, space, fantasy, food — let the user pick

Challenge Exercises

1. Custom Word Lists – Let the user add their own adjectives and nouns at the start of the program using a loop that collects words until they type "done".

2. Mixed Case – Randomly capitalize some letters inside the username (e.g., HaPpYtIgEr42). Use random.choice() on each letter to decide case.

3. Save to File – Write all generated usernames to a text file called usernames.txt using with open("usernames.txt", "w") as f:.

4. Minimum Length – Keep generating until you produce a username at least 12 characters long. Loop inside generate_username() and regenerate if too short.

5. Theme Mode – Create themed word sets (animals, space, fantasy, food) in separate lists and let the user pick which theme to use before generating.