Python Projects

An open-source GitHub repository containing Python project ideas, steps, tips, and code solutions.

This repository is designed to help Python learners at all levels, starting with beginner-friendly projects and gradually progressing to more advanced ones. Each project includes clear instructions and a working code implementation.

Total Projects: 36 Total Beginner Projects: 27 Total Intermediate Projects: 9

Setup

Ensure have at least Python 3.6 or later (we recommend 3.12 or later) installed on your computer. You can do a quick search and download it from a trusted provider for your platform.
Ensure you have an IDE or a place where you can code and run the Python interpreter.

Tip

We use Visual Studio Code. It's fast, efficient, and has many extensions and customizability options.

Project Difficulty Ratings

Project	Category	Difficulty
Calculator	Beginner	1.5/10
Number Guessing Game	Beginner	2.0/10
Password Generator	Beginner	2.5/10
Tip Calculator	Beginner	1.5/10
Temperature Converter	Beginner	1.5/10
Palindrome Checker	Beginner	1.5/10
Word Counter	Beginner	2.0/10
Text Encryption	Beginner	2.5/10
Countdown Timer	Beginner	2.5/10
Rock Paper Scissors	Beginner	2.5/10
Mad Libs Generator	Beginner	2.0/10
Dice Rolling Simulator	Beginner	1.5/10
Hangman Game	Beginner	3.5/10
Address Book	Beginner	4.0/10
Pomodoro Timer	Beginner	3.0/10
Budget Tracker	Beginner	4.5/10
File Sorter	Beginner	3.5/10
Text Reverser	Beginner	1.0/10
Simple Quiz Game	Beginner	2.5/10
Prime Number Generator	Beginner	2.5/10
Fibonacci Sequence	Beginner	2.0/10
Email Slicer	Beginner	1.5/10
BMI Calculator	Beginner	1.5/10
Currency Converter	Beginner	2.5/10
Task Tracker	Beginner	3.0/10
Unit Converter	Beginner	2.5/10
Leap Year Checker	Beginner	1.5/10
Tic Tac Toe	Intermediate	6.0/10
Text-based Adventure Game	Intermediate	5.5/10
Sudoku Solver	Intermediate	8.5/10
Basic Sorting Algorithms	Intermediate	6.5/10
Prime Number Sieve	Intermediate	5.0/10
Basic Caesar Cipher	Intermediate	4.5/10
Bank Account Simulator (OOP)	Intermediate	5.5/10
File Metadata Extractor	Intermediate	5.0/10
CSV to JSON Converter	Intermediate	4.5/10

Beginner Projects

These projects are ideal for those new to Python. Each project includes a description, steps to follow, and tips for completing it.

1. Calculator

Difficulty: 1.5/10
Description: Build a simple calculator that performs basic arithmetic operations (+, -, *, /).
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/1_calculator.py
Steps:
1. Prompt the user for two numbers and an operator.
2. Perform the chosen operation.
3. Display the result.
Tips:

Tip 1:

Use input() to get the user's input. Learn more from here: https://docs.python.org/3/library/functions.html#input

Tip 2:

Use variables to store the user's input.

Tip 3:

Use conditional statements to check for valid values, and perform certain operations. Learn more from here: https://www.w3schools.com/python/python_conditions.asp

Tip 4:

Print out the result using print(). Learn more from here: https://docs.python.org/3/library/functions.html#print

2. Number Guessing Game

Difficulty: 2.0/10
Description: Build a simple random number generator, where users have to submit their guesses as to what the number is. Accept a range within 10 of the random number. [0 - 100]
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/2_random_guesser.py
Steps:
1. Generate a random number within the range 0 - 100.
2. Prompt the user for a number input.
3. Compare the input to a valid range within 10 of the random number.
4. Display the result.
Tips:

Tip 1:

Use the random module to generate a random number within the range.

Tip 2:

Use input() to prompt the user for input.

Tip 3:

Use conditional statements to check for valid values within the range of 10. Learn more from here: https://www.w3schools.com/python/python_conditions.asp

Tip 4:

Print out the result using print(). Learn more from here: https://docs.python.org/3/library/functions.html#print

3. Password Generator

Difficulty: 2.5/10
Description: Build a simple password generator than can generate custom length passwords, from 8 up to 128 characters. Use uppercase, lowercase, symbols, and numbers.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/3_password_generator.py
Steps:
1. Define your password generator's maps or strings.
2. Prompt the user for a number [8 - 128] input.
3. Generate the password.
4. Display the result.
Tips:

Tip 1:

Use the string module for character sets like punctuation, letters or special characters.

Tip 2:

Use input() to prompt the user for input.

Tip 3:

Use a loop to generate the password up until the given length.

Tip 4:

Print out the result using print().

4. Tip Calculator

Difficulty: 1.5/10
Description: Build a simple tip calculator, that calculates the tip based on the total and the desired percentage with splits.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/4_tip_calculator.py
Steps:
1. Get the total from the user.
2. Get the tip percentage from the user.
3. Get the amount of people who should split the bill.
4. Calculate the tip.
5. Display the result.
Tips:

Tip 1:

Get all inputs using input().

Tip 2:

Calculate the tip_amount, new_total and splits_per_person using basic arithmetic and math.

Tip 3:

Print out the result using print().

5. Temperature Converter

Difficulty: 1.5/10
Description: Build a simple temperature converter that converts between Celsius and Fahrenheit.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/5_temperature_converter.py
Steps:
1. Define conversion values for each conversion.
2. Prompt the user for the unit to convert to, and from.
3. Prompt the user for a temperature value.
4. Convert.
5. Display the result.
Tips:

Tip 1:

Use predefined formulas for accurate conversion between units.

Tip 2:

Use input() to prompt the user for input.

Tip 3:

Print out the result using print().

6. Palindrome Checker

Difficulty: 1.5/10
Description: Build a simple palindrome checker.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/6_palindrome_checker.py
Steps:
1. Prompt the user for a word.
2. Reverse the string.
3. Check if it is equal to the original.
4. Display the result.
Tips:

Tip 1:

Use input() for input.

Tip 2:

You can easily reverse the string using array manipulation techniques. [::-1]

Tip 3:

Print out the result using print().

7. Word Counter

Difficulty: 2.0/10
Description: Build a simple word counter.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/7_word_counter.py
Steps:
1. Prompt the user for a file path (TXT).
2. Read the file path.
3. Count the words in the read data.
4. Display the result.
Tips:

Tip 1:

Use input() for input.

Tip 2:

Read the file using read operations (https://www.geeksforgeeks.org/how-to-read-from-a-file-in-python/) in Python.

Tip 3:

Count the number of words using split() and len().

Tip 4:

Print out the result using print().

8. Text Encryption

Difficulty: 2.5/10
Description: Create a text encryption function with decryption as well.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/8_text_encryption.py
Steps:
1. Prompt the user for text and a password (to be used for encryption).
2. Encrypt the text.
3. Decrypt the text.
4. Display the results.
Tips:

Tip 1:

Use input() for input.

Tip 2:

Use simple encryption methods like Caesar cipher.

Tip 3:

Store the password in a variable to use it later during decryption.

Tip 4:

Print out the results using print().

9. Countdown Timer

Difficulty: 2.5/10
Description: Create a countdown timer for seconds and minutes.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/9_countdown_timer.py
Steps:
1. Prompt the user for a time, in a specific format.
2. Extract information from the provided time.
3. Countdown.
4. Display the results.
Tips:

Tip 1:

Use input() for input.

Tip 2:

Use simple string manipulation techniques to get the minutes and seconds from the provided time.

Tip 3:

Use time.sleep(1) to count down in seconds.

Tip 4:

Print out the results using print().

10. Rock Paper Scissors

Difficulty: 2.5/10
Description: Create a rock paper scissors game.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/10_rock_paper_scissors.py
Steps:
1. Prompt the user for a choice.
2. Generate a random choice for the computer.
3. Compare the choices.
4. Display the results.
Tips:

Tip 1:

Use input() for input.

Tip 2:

Use random.choice() to generate a random choice for the computer.

Tip 3:

Use conditional statements to compare the choices and determine the winner.

Tip 4:

Print out the results using print().

11. Mad Libs Generator

Difficulty: 2.0/10
Description: Create a Mad Libs generator.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/11_mad_libs_generator.py
Steps:
1. Define a template for the Mad Libs story.
2. Prompt the user for different types of words (noun, verb, adjective, etc.).
3. Replace the placeholders in the template with the user's words.
4. Display the completed Mad Libs story.
Tips:

Tip 1:

Use input() for input.

Tip 2:

Use string formatting to replace the placeholders in the template.

Tip 3:

Create multiple templates for different stories.

Tip 4:

Print out the results using print().

12. Dice Rolling Simulator

Difficulty: 1.5/10
Description: Create a dice rolling simulator.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/12_dice_rolling_simulator.py
Steps:
1. Prompt the user for the number of dice to roll.
2. Roll the dice.
3. Display the results.
Tips:

Tip 1:

Use input() for input.

Tip 2:

Use random.randint() to generate a random number between 1 and 6.

Tip 3:

Use a loop to roll multiple dice.

Tip 4:

Print out the results using print().

13. Hangman Game

Difficulty: 3.5/10
Description: Implement the classic Hangman game where the player guesses letters to reveal a hidden word.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/13_hangman_game.py
Steps:
1. Create a list of words for the game.
2. Randomly select a word.
3. Display the word with blanks for hidden letters.
4. Allow the user to guess letters.
5. Keep track of guessed letters and remaining attempts.
6. Reveal letters in the word as they are guessed correctly.
7. End the game when the word is guessed or attempts run out.
Tips:

Tip 1:

Use random.choice() to select a random word from a list.

Tip 2:

Use a while loop for the main game interactions.

Tip 3:

Store guessed letters in a list to avoid repeat guesses and display them to the user.

Tip 4:

Represent the hidden word as a list of characters or underscores, updating it as letters are guessed.

Tip 5:

Keep a counter for incorrect guesses (attempts remaining).

14. Address Book

Difficulty: 4.0/10
Description: A simple command-line contact manager.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/14_address_book.py
Steps:
1. Create functions to add, view, and delete contacts.
2. Store contacts in a file (e.g., JSON).
3. Create a main loop to interact with the user.
Tips:

Tip 1:

Use a dictionary to store contact information.

Tip 2:

Use the json module to save and load contacts from a file.

15. Pomodoro Timer

Difficulty: 3.0/10
Description: A time management tool to help you stay focused.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/15_pomodoro_timer.py
Steps:
1. Create a function to run a countdown timer.
2. Prompt the user for work and break durations.
3. Alternate between work and break sessions.
Tips:

Tip 1:

Use the time module to pause execution.

Tip 2:

Use a loop to alternate between work and break sessions.

16. Budget Tracker

Difficulty: 4.5/10
Description: A tool to track your income and expenses.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/16_budget_tracker.py
Steps:
1. Create functions to add income and expenses.
2. Store transactions in a file (e.g., JSON).
3. Calculate and display the current balance.
Tips:

Tip 1:

Use lists of dictionaries to store income and expense transactions.

Tip 2:

Use the json module to save and load transaction data.

17. File Sorter

Difficulty: 3.5/10
Description: Create a script that organizes files in a directory into subfolders based on their file type (e.g., .txt files go into a "Text" folder, .jpg files go into an "Images" folder).
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/17_file_sorter.py
Steps:
1. Prompt the user for the directory path to organize.
2. Scan the directory for all files.
3. For each file, get its extension (e.g., .txt, .jpg).
4. Create a subfolder corresponding to the file type if it doesn't already exist.
5. Move the file into the appropriate subfolder.
6. Display a summary of the actions taken.
Tips:

Tip 1:

Use the os module to interact with the file system, such as listing files (os.listdir()), creating directories (os.mkdir()), and moving files (os.rename()).

Tip 2:

The pathlib module is a modern and more object-oriented alternative to os.path for handling filesystem paths.

Tip 3:

Use a dictionary to map file extensions to folder names (e.g., {".txt": "Text", ".jpg": "Images"}).

Tip 4:

Remember to handle cases where a file has no extension or you want to ignore certain files/directories.

18. Text Reverser

Difficulty: 1.0/10
Description: Create a function that takes a string and returns it in reverse order.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/18_text_reverser.py
Steps:
1. Prompt the user to enter a string.
2. Create a function that takes the string as an argument.
3. Inside the function, reverse the string.
4. Return and display the reversed string.
Tips:

Tip 1:

Python's string slicing is a very concise way to reverse a string: my_string[::-1].

Tip 2:

You could also use a loop to iterate through the string from end to start and build the new string.

Tip 3:

Wrap your logic in a function to make it reusable.

19. Simple Quiz Game

Difficulty: 2.5/10
Description: Create a small program that asks multiple-choice questions from a predefined list and keeps score.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/19_simple_quiz_game.py
Steps:
1. Create a list of questions, with options and the correct answer for each.
2. Initialize a score variable to zero.
3. Loop through the questions, displaying each one to the user.
4. Prompt the user for their answer and check if it's correct.
5. Update the score if the answer is correct.
6. At the end of the quiz, display the final score.
Tips:

Tip 1:

Use a list of dictionaries to store your questions, where each dictionary contains the question, options, and the correct answer.

Tip 2:

Use a for loop to iterate through your list of questions.

Tip 3:

Keep track of the player's score in a variable that you increment for each correct answer.

20. Prime Number Generator

Difficulty: 2.5/10
Description: Create a small program that finds and prints all prime numbers up to a user-specified limit.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/20_prime_number_generator.py
Steps:
1. Prompt the user for an upper limit (a number).
2. Create a function to check if a number is prime.
3. Loop from 2 up to the user-specified limit.
4. For each number, use your function to check if it's prime.
5. Print all the numbers that are identified as prime.
Tips:

Tip 1:

A prime number is a number greater than 1 that has no positive divisors other than 1 and itself.

Tip 2:

To check if a number n is prime, you only need to check for divisors up to the square root of n.

Tip 3:

Consider edge cases like 0, 1, and 2.

21. Fibonacci Sequence

Difficulty: 2.0/10
Description: Create a function that generates the Fibonacci sequence up to a certain number of terms.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/21_fibonacci_sequence.py
Steps:
1. Prompt the user for the number of terms to generate.
2. Create a function that takes the number of terms as an argument.
3. Generate the Fibonacci sequence up to that number.
4. Return and display the sequence.
Tips:

Tip 1:

The Fibonacci sequence starts with 0 and 1. Each subsequent number is the sum of the two preceding ones (e.g., 0, 1, 1, 2, 3, 5, 8...).

Tip 2:

Use a loop and two variables to keep track of the last two numbers in the sequence to calculate the next one.

Tip 3:

Handle edge cases, such as a user requesting 0 or 1 term.

22. Email Slicer

Difficulty: 1.5/10
Description: A simple tool that takes an email address and extracts the username and domain name.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/22_email_slicer.py
Steps:
1. Prompt the user for an email address.
2. Use string slicing to find the "@" symbol.
3. Separate the string into a username and a domain.
4. Display the results.
Tips:

Tip 1:

Use input() to get user input. The .strip() method is useful for removing leading/trailing whitespace.

Tip 2:

String indexing (e.g., email.index("@")) can find the position of a specific character.

Tip 3:

Slicing (e.g., my_string[:5]) is a great way to extract parts of a string.

23. BMI Calculator

Difficulty: 1.5/10
Description: A program that calculates a person's Body Mass Index (BMI) based on their height and weight.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/23_bmi_calculator.py
Steps:
1. Prompt the user for their weight (in kg) and height (in meters).
2. Calculate the BMI using the formula: weight / (height ** 2).
3. Display the calculated BMI.
4. Provide a basic interpretation of the result (e.g., underweight, normal, overweight).
Tips:

Tip 1:

Use float(input()) to convert user input into a number that can have decimal points.

Tip 2:

The power operator in Python is **.

Tip 3:

Use if/elif/else statements to check the BMI range and provide the correct interpretation.

24. Currency Converter

Difficulty: 2.5/10
Description: A simple tool to convert between a few currencies using fixed exchange rates.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/24_currency_converter.py
Steps:
1. Define a dictionary with fixed exchange rates (e.g., relative to a base currency like USD).
2. Prompt the user for the amount, the source currency, and the target currency.
3. Perform the conversion calculation.
4. Display the final converted amount.
Tips:

Tip 1:

A dictionary is a great way to store the currency exchange rates.

Tip 2:

To make the logic simpler, first convert the input amount to a common base currency (like USD), and then convert that base amount to the final target currency.

Tip 3:

Use the .upper() method on the currency input from the user to make the dictionary lookup case-insensitive.

25. Task Tracker

Difficulty: 3.0/10
Description: A simple command-line interface to add, view, and remove tasks from a list.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/25_task_tracker.py
Steps:
1. Create functions to add, view, and delete tasks.
2. Use a loop to keep the program running until the user exits.
3. Display a menu of options to the user.
Tips:

Tip 1:

Use a list to store the tasks.

Tip 2:

Use enumerate() to display the indices of the tasks for easier deletion.

26. Unit Converter

Difficulty: 2.5/10
Description: A tool to convert between different units of length (meters to feet) and weight (kilograms to pounds).
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/26_unit_converter.py
Steps:
1. Define conversion factors for different units.
2. Prompt the user for the value and units to convert.
3. Perform the conversion and display the result.
Tips:

Tip 1:

Use a dictionary to store conversion factors relative to a base unit.

Tip 2:

Use float(input()) to handle decimal values.

27. Leap Year Checker

Difficulty: 1.5/10
Description: A program that determines if a given year is a leap year based on calendar rules.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Beginner/27_leap_year_checker.py
Steps:
1. Prompt the user for a year.
2. Apply the leap year logic (divisible by 4, but not by 100 unless divisible by 400).
3. Display the result.
Tips:

Tip 1:

Use nested if statements or logical operators to check the conditions.

Tip 2:

Remember that years like 1900 were not leap years, but 2000 was.

Note

Working code solutions are in the /Beginner folder.

Intermediate Projects

These projects are ideal for those with experience in Python. Each project includes a description, steps to follow, and tips for completing it.

1. Tic Tac Toe

Difficulty: 6.0/10
Description: Build a tic tac toe board, with it's own algorithm for winning and countering player moves.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Intermediate/1_tic_tac_toe.py
Steps:
1. Create the board (3x3 grid) and other logic (handling invalid moves, etc.)
2. Handle player and computer moves, including ties, wins and losses.
3. Display the board and start the game.
Tips:

Tip 1:

Use functions for repetitive tasks.

Tip 2:

Create an algorithm that not only chooses certain priority positions on the board, but also counters player moves.

Tip 3:

Add error handling and retries if a player chooses a place on the board that is already occupied.

2. Text-based Adventure Game

Difficulty: 5.5/10
Description: An interactive fiction game where you can explore and make choices.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Intermediate/2_adventure_game.py
Steps:
1. Create a story with different rooms and choices.
2. Use functions to represent different parts of the story.
3. Get user input to navigate through the story.
Tips:

Tip 1:

Use a dictionary to define the game world, with rooms, descriptions, and choices.

Tip 2:

Use a loop to keep the game running until the player reaches an end state.

3. Sudoku Solver

Difficulty: 8.5/10
Description: A program that can solve a partially completed Sudoku puzzle using a backtracking algorithm.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Intermediate/3_sudoku_solver.py
Steps:
1. Represent the Sudoku board (e.g., a 9x9 2D list, with 0 for empty cells).
2. Create a function to find the next empty cell on the board.
3. Create a function to check if placing a number in a cell is valid (obeys row, column, and 3x3 box rules).
4. Implement the backtracking algorithm to recursively try numbers and solve the puzzle.
5. Display the initial and solved boards.
Tips:

Tip 1:

Backtracking involves trying a possibility, seeing if it leads to a solution, and if not, undoing it (backtracking) to try another.

Tip 2:

A helper function like is_valid(board, number, position) is essential for checking the rules of Sudoku.

Tip 3:

Recursion is a natural fit for this problem. The base case for the recursion is when the board has no empty cells left.

4. Basic Sorting Algorithms

Difficulty: 6.5/10
Description: Write your own functions to implement sorting algorithms like Bubble Sort, Selection Sort, or Insertion Sort.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Intermediate/4_sorting_algorithms.py
Steps:
1. Create a list of unsorted numbers.
2. Implement a function for Bubble Sort.
3. Implement a function for Selection Sort.
4. Implement a function for Insertion Sort.
5. For each algorithm, pass a copy of the unsorted list to the function and display the sorted result.
Tips:

Tip 1:

Bubble Sort: Repeatedly step through the list, compare adjacent elements, and swap them if they are in the wrong order.

Tip 2:

Selection Sort: Repeatedly find the minimum element from the unsorted part and put it at the beginning.

Tip 3:

Insertion Sort: Build the final sorted array one item at a time, inserting each new item into its proper place.

5. Prime Number Sieve

Difficulty: 5.0/10
Description: A program that uses the Sieve of Eratosthenes algorithm to efficiently find all prime numbers up to a given limit.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Intermediate/5_prime_sieve.py
Steps:
1. Prompt the user for an upper limit.
2. Create a boolean list (a "sieve") of size limit + 1, initially setting all entries to True.
3. Mark 0 and 1 as not prime (False).
4. Iterate from 2 up to the square root of the limit. If a number is prime (still True), mark all of its multiples as not prime (False).
5. Extract all numbers that are still marked as True and display them.
Tips:

Tip 1:

The Sieve of Eratosthenes is much more efficient for finding all primes up to a limit than checking each number individually.

Tip 2:

You only need to iterate your main loop up to sqrt(limit) because any composite number n will have a prime factor less than or equal to sqrt(n).

6. Basic Caesar Cipher

Difficulty: 4.5/10
Description: A program that can encrypt and decrypt a message using a simple shifting algorithm.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Intermediate/6_caesar_cipher.py
Steps:
1. Prompt the user for a message, a shift key (an integer), and whether to encrypt or decrypt.
2. Create a function that takes the message, key, and mode as input.
3. Inside the function, iterate through each character of the message.
4. If the character is a letter, shift it by the key amount, wrapping around the alphabet if necessary (e.g., 'Z' shifted by 2 becomes 'B').
5. Preserve the case (uppercase/lowercase) and leave non-alphabetic characters unchanged.
6. Return and display the resulting message.
Tips:

Tip 1:

The modulo operator (%) is perfect for handling the "wrap-around" logic for the alphabet. (char_position + shift) % 26.

Tip 2:

The string module (string.ascii_lowercase, string.ascii_uppercase) can provide you with the alphabet, so you don't have to type it out yourself.

Tip 3:

To decrypt, you can simply use the same function but with a negative shift key.

7. Bank Account Simulator (OOP)

Difficulty: 5.5/10
Description: An object-oriented project using classes to simulate basic banking operations like deposits, withdrawals, and balance checks.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Intermediate/7_bank_account.py
Steps:
1. Define an Account class with attributes for owner and balance.
2. Implement methods for deposit, withdraw, and displaying account information.
3. Create a main loop to interact with the account.
Tips:

Tip 1:

Use the __init__ method to initialize account attributes.

Tip 2:

The __str__ method is useful for defining how the object should be printed.

8. File Metadata Extractor

Difficulty: 5.0/10
Description: A script that recursively walks through a directory and lists file names, sizes, and modification dates.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Intermediate/8_file_metadata.py
Steps:
1. Use the os.walk() function to traverse the directory tree.
2. Use os.stat() to retrieve metadata for each file.
3. Use the time module to format the modification date.
Tips:

Tip 1:

os.path.join() is the safest way to construct file paths across different operating systems.

Tip 2:

time.ctime() is a quick way to convert a timestamp into a human-readable string.

9. CSV to JSON Converter

Difficulty: 4.5/10
Description: A utility that reads data from a CSV file and converts it into a formatted JSON file.
Solution: https://github.com/Infinitode/Python-Projects/blob/main/Intermediate/9_csv_to_json.py
Steps:
1. Use the csv module to read data from a CSV file.
2. Store the data in a list of dictionaries.
3. Use the json module to write the list to a JSON file with indentation.
Tips:

Tip 1:

csv.DictReader is perfect for automatically using the CSV header as keys for your dictionaries.

Tip 2:

Setting indent=4 in json.dump() makes the resulting JSON file much easier to read.

Note

Working code solutions are in the /Intermediate folder.

Contributing

Contributions are welcome! If you have project ideas or improvements, feel free to fork the repository and open a pull request.

License

This project is licensed under the MIT License. See the LICENSE file for details.

Name		Name	Last commit message	Last commit date
Latest commit History 29 Commits
.github/ISSUE_TEMPLATE		.github/ISSUE_TEMPLATE
Beginner		Beginner
Intermediate		Intermediate
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md

Folders and files

Latest commit

History

Repository files navigation

Python Projects

Table of Contents

Setup

Project Difficulty Ratings

Beginner Projects

1. Calculator

2. Number Guessing Game

3. Password Generator

4. Tip Calculator

5. Temperature Converter

6. Palindrome Checker

7. Word Counter

8. Text Encryption

9. Countdown Timer

10. Rock Paper Scissors

11. Mad Libs Generator

12. Dice Rolling Simulator

13. Hangman Game

14. Address Book

15. Pomodoro Timer

16. Budget Tracker

17. File Sorter

18. Text Reverser

19. Simple Quiz Game

20. Prime Number Generator

21. Fibonacci Sequence

22. Email Slicer

23. BMI Calculator

24. Currency Converter

25. Task Tracker

26. Unit Converter

27. Leap Year Checker

Intermediate Projects

1. Tic Tac Toe

2. Text-based Adventure Game

3. Sudoku Solver

4. Basic Sorting Algorithms

5. Prime Number Sieve

6. Basic Caesar Cipher

7. Bank Account Simulator (OOP)

8. File Metadata Extractor

9. CSV to JSON Converter

Contributing

License

About

Topics

Resources

License

Contributing

Uh oh!

Stars

Watchers

Forks

Contributors

Uh oh!

Languages