This repository contains a collection of console-based Python projects developed as part of an internship learning track.
Each task is designed to strengthen core Python fundamentals through practical, real-world problem solving.
The projects are implemented incrementally, following a clear and structured development flow.
A console-based task management application that allows users to manage daily tasks efficiently.
The program provides options to add new tasks, view existing tasks, update task details, and remove completed tasks through a menu-driven interface.
The project focuses on organizing logic in a clean and readable manner while simulating a basic real-world application workflow.
- Conditional statements
- Loops
- Lists and dictionaries
- User input handling
- Function-based modular design
- Basic object-oriented concepts
- Separation of data, logic, and user interaction
A console-based number guessing game designed to reinforce Python fundamentals through an interactive experience.
The program randomly generates a number within a defined range, and the user attempts to guess it.
Based on the user's input, the game provides feedback indicating whether the guess is too high or too low.
The application tracks the number of attempts, enforces a maximum guess limit, and allows the user to replay the game.
Special attention is given to handling real-world user input scenarios where input may contain non-numeric characters.
- Random number generation
- Loops (
while) - Conditional statements (
if / elif / else) - User input validation
- String processing
- Function-based program structure
- Program entry point using
main()and__name__ == "__main__"
A Python-based program that demonstrates basic file handling operations by reading data from a text file, performing word search and replacement, and saving the updated content back to the file. The application includes proper exception handling to manage file-related errors gracefully while ensuring reliable and consistent text processing.
The task emphasizes practical usage of file I/O, string manipulation, and error handling in a clean and readable implementation.git
- File input and output operations
- Reading from and writing to text files
- String manipulation and text replacement
- Case-insensitive text processing
- Exception handling for file-related errors
- Dynamic file path handling
- Modular function-based program structure
A console-based Python application that scrapes and displays news headlines from a predefined website.
The program sends an HTTP request to fetch webpage content, parses the HTML structure, extracts relevant data, and presents it in a readable format. This task focuses on understanding web scraping fundamentals and working with real-world HTML data.
-
Install required dependencies:
-
Run the scraper script from the terminal
- Send an HTTP request to the target website
- Receive and validate the response
- Parse the HTML content using Beautiful Soup
- Locate relevant HTML elements containing headlines
- Extract and store the text data
- Display the extracted information in a formatted console output
- Python
- Requests
- Beautiful Soup (bs4)
- Web scraping fundamentals
- HTTP request handling
- HTML parsing basics
- Data extraction techniques
- Error handling
- Function-based modular design
This task demonstrates how Python can be used to scrape and process data from web pages while maintaining clean structure, readability, and safe scraping practices.
A console-based Python application that converts an amount from one currency to another using exchange rate data.
The program focuses on understanding how real-world API-based systems are structured by separating user interaction, data sourcing, and core conversion logic. Exchange rates are mocked to simulate an external API, keeping the task cost-free while preserving realistic architecture and data flow.
- No external APIs or API keys required
- No third-party libraries needed
- Run the script directly using Python
- Accept currency codes and amount from the user via CLI
- Validate user input for correctness and safety
- Retrieve exchange rate data from a data provider layer (mocked API)
- Convert the amount using a common base currency (USD)
- Calculate the final converted value using core mathematical logic
- Display the result in a clear, readable format
- Python (standard library only)
- API-style data consumption (mocked external service)
- Request–response style data flow
- Input validation and error handling
- JSON-like structured data usage (dictionary-based)
- Currency conversion mathematics
- Separation of concerns within a single-file program
- Clean, testable core logic design
This task demonstrates how a simple utility can be designed using real-world architectural thinking. By isolating core logic from data sources and user interaction, the program remains easy to understand, test, and extend—laying a strong foundation for integrating real APIs or scaling into larger systems later.
A console-based Python application that reads a .txt file and analyzes its content.
The program calculates the total number of lines, words, and characters in the file. It also performs word frequency analysis to identify the most commonly used words.
The architecture separates file handling, text processing, and result presentation to maintain clean structure and clarity.
- No third-party libraries required
- Uses only Python standard library
- Place
.txtfiles in the same directory as the script - Run directly using Python
- Detect available
.txtfiles in the directory - Allow user to select a file via CLI
- Read file safely using context manager
- Count lines, words, and characters
- Normalize text (lowercase + remove punctuation)
- Generate word frequency distribution
- Sort and display top frequent words
- Present results in a structured report format
- Python (standard library only)
osfor file detectionstringfor text cleaningcollections.Counterfor frequency analysis
- File Input/Output handling
- String manipulation and tokenization
- Dictionary-based data aggregation
- Sorting and structured output formatting
- Modular function design (separation of concerns)
The tool produces a clear analytical summary of the text file, demonstrating practical file handling, text preprocessing, and basic data analysis using core Python concepts.
- All projects are intentionally console-based to emphasize core logic over user interface design.
- The code prioritizes clarity, readability, and maintainable structure.
- Each task builds progressively on concepts introduced in previous tasks.