A collection of small Python projects built to strengthen programming logic and problem-solving skills. Currently includes:
- Password Manager
- Password Generator
- Tic-Tac-Toe
- Hangman
- Rock-Paper-Scissor
- Guess the Number
- Basic Calculator
- Dice Simulator
- Quiz
- Date and Time Display
- Countdown Timer
- Mad Libs
- Email Slicer
- Word Replacer
This repository is part of my foundational learning in Python programming, supporting my journey as an IT Engineering student focused on Full Stack Development and CyberSecurity.
Each mini project is designed to reinforce programming concepts like variables, conditionals, loops, and input handling.
A command-line password manager that allows users to securely store, view, update, and remove account credentials. The application is structured into modular components for handling operations, validating user input, and managing password-related functionality. The program ensures controlled input flow, persistent looping for menu navigation, and organized function handling for each operation.
Concepts used:
- Modular project structure with multiple Python files
- Input validation using custom validation functions
- Loop-based menu system for continuous user interaction
- CRUD operations (Create, Read, Update, Delete) for managing entries
- Separation of concerns through dedicated modules
- Error handling using try/except blocks
Example Output
A customizable command-line password generator that creates secure passwords based on user-selected criteria. The program allows the user to choose the length of the password and specify whether to include numbers, lowercase letters, uppercase letters, and special symbols. It validates all inputs, constructs an allowed character set, and generates a random password of the desired length.
Concepts used:
- User input validation for security and correctness
- String module for character sets (digits, letters, punctuation)
- Random module for generating unpredictable passwords
- Conditional logic for building a customizable character pool
- Looping and string manipulation for assembling the final password
Example Output
Accomplished a fully playable CLI Tic-Tac-Toe game, as measured by correct win and tie detection across all winning conditions, by evaluating board state using a 2D NumPy array. Smooth human vs computer turn-based gameplay, as measured by consistent game flow until completion. Robust user input handling, as measured by prevention of invalid moves, by validating inputs against dynamically updated available slots.
Concepts Used:
- Python modular programming for separating game logic
- Command-line interface (CLI) for user interaction
- Random module for computer move selection
- NumPy 2D arrays for board representation
- List manipulation to track available and selected slots
- Input validation to prevent invalid moves
- Conditional logic for win and tie detection
Example Output
A console-based Hangman game where the computer selects a random word from a predefined list, and the player attempts to guess it one letter at a time. The program tracks correct guesses, incorrect guesses, and previously attempted letters. The game continues until the player either completes the word or exits manually.
Concepts used:
- Random module for selecting a hidden word
- List manipulation to track revealed and unrevealed letters
- Sets for storing previously guessed characters
- Loop control for repeated guessing
- Conditional branching for correct and incorrect guesses
- String and input handling for player interaction
Example Output
A command-line version of the classic Rock-Paper-Scissor game where the user competes against the computer. The program randomly selects its choice and compares it with the user's input to determine the winner. It continues running until the user decides to exit.
Concepts used:
- Random module for generating computer choices
- Conditional logic for win/loss evaluation
- Loop control and user input handling
- Program termination using exit conditions
Example Output
Includes two variations:
- User Guess: The user tries to guess a number randomly chosen by the computer.
- Computer Guess: The computer attempts to guess the number the user is thinking of.
Concepts used:
- Loops
- Conditional statements
- Random number generation
- Logic design
Example Output
A simple, command-line calculator that performs basic arithmetic operations (addition, subtraction, multiplication, and division) on two user-provided numbers. It includes basic input validation to handle non-numeric input and invalid operation choices.
Concepts used:
- Functions for modularizing arithmetic operations
- Loop control (
while True) for continuous operation - Conditional branching (
if/elif/else) to execute the chosen operation - Error handling (
try...except ValueError) for invalid number input - Input handling (
input()) for numbers and operation choice
Example Output
A program that simulates rolling two six-sided dice. Each roll randomly selects values from predefined ASCII art representations and displays the visual output of both dice to the user.
Concepts used:
- Random number generation
- Dictionaries for structured data storage
- Loops and conditional logic
- User input handling
Example Output
A basic terminal-based quiz that iterates through a predefined set of questions, accepts user input, compares answers, and tracks the total score.
Concepts used:
- Dictionaries for structured data storage
- Loops for sequential question processing
- User input handling
- String normalization using
.lower() - Conditional checks for answer validation
- Basic scoring logic
Example Output
A basic program that retrieves the system’s current date and time using Python’s time module and prints it in a human-readable format. It extracts day, month, and year values, as well as hour, minute, and second values, and outputs them separately.
Concepts used:
- Using the
timemodule - Accessing system time structures
- Formatted string output
Example Output
A basic timer that accepts a number of seconds from the user and performs a countdown, printing each remaining second until it reaches zero.
Concepts used:
- User input handling
- Loop control
- Time delay using
time.sleep()
Example Output
A simple word game where the program takes user inputs (nouns, verbs, adjectives, etc.) and inserts them into a story template to create a fun or random narrative.
Concepts used:
- Input/output handling
- String concatenation and formatting
Example Output
This is a simple console-based program that parses an email address provided by the user. It uses string manipulation, specifically the split() method, to separate the email into its three core components: the username, the email provider, and the domain extension.
Concepts used:
- String manipulation using the
split()method to break the string at specified delimiters (@and.) - Tuple unpacking
(a, b) = valuefor concise assignment of the split components - Input handling (
input()) for taking the email address from the user - String formatting (f-strings) for displaying the results
Example Output
This program demonstrates the basic concept of string manipulation by allowing the user to dynamically replace a specific word within a predefined message. It uses the built-in Python .replace() method to perform the substitution and prints the modified string to the console.
- String declaration and basic output (
print()) - Input handling (
input()) to accept words from the user - String formatting (f-strings) for interactive prompting
- The core String Method
.replace(old, new)for substitution
Example Output
- Strengthen understanding of Python basics
- Practice problem decomposition and logic flow
- Build a foundation for scripting and automation in Python
- Python 3.x
Aarya Sarfare
IT Engineering student | Learning Full Stack Development
Projects inspired by Kylie Ying and Code with Tomi’s tutorial on YouTube.