Python Small Projects for Beginners

In this tutorial, we’ll explore a variety of Python beginner projects that cover different aspects of programming. As you know programming is best learned by doing, and Python is an excellent language for beginners due to its simplicity and readability. Each project here will give you new concepts and test your coding skills. Let’s dive into the world of Python projects for beginners.

10 Simple Projects for Practice in Python

Python Beginner Projects are like little adventures that make learning to code easy and enjoyable. Whether you are making a calculator, a to-do list, or a game, these projects teach you the basics of programming in a simple and fun way. So, if you’re new to coding, Python Beginner Projects are the perfect way to start.

Python Habit Tracker Project

Create a dynamic habit tracker that allows users to input their daily habits and track their progress over time. Utilize a simple SQLite database to store habit data and provide insights through visualizations, fostering a habit-building journey.

Prereq

• Ensure you have Python is up and running on your system.
• Install the required libraries using the following commands:

  pip install matplotlib

Value Addition

• Encourages positive habits through daily tracking.
• Provides visual insights into habit trends.

Solution

# Habit Tracker
import sqlite3
import matplotlib.pyplot as plt
from datetime import datetime

def track_habit(habit):
    today = datetime.today().strftime('%Y-%m-%d')

    # Connect to SQLite db
    conn = sqlite3.connect('habit_tracker.db')
    cursor = conn.cursor()

    # Create the habit tracking table if not exists
    cursor.execute('''CREATE TABLE IF NOT EXISTS habits
                      (date TEXT, habit TEXT)''')

    # Insert habit data into the table
    cursor.execute("INSERT INTO habits VALUES (?, ?)", (today, habit))
    conn.commit()

    # Close the connection
    conn.close()

def show_habit_data():
    # Connect to SQLite db
    conn = sqlite3.connect('habit_tracker.db')
    cursor = conn.cursor()

    # Retrieve habit data from the table
    cursor.execute("SELECT date, COUNT(habit) FROM habits GROUP BY date")
    data = cursor.fetchall()

    # Extract dates and habit counts for plotting
    dates, habit_counts = zip(*data)

    # Plot the habit data
    plt.figure(figsize=(10, 5))
    plt.plot(dates, habit_counts, marker='o', linestyle='-', color='b')
    plt.title('Habit Tracker')
    plt.xlabel('Date')
    plt.ylabel('Habit Count')
    plt.xticks(rotation=45)
    plt.tight_layout()
    plt.show()

# Example usage
track_habit("Read for 30 minutes")
show_habit_data()

Vocab Builder with Flashcards

Build an interactive vocabulary builder using flashcards. Fetch a random word and its definition from a public API, allowing users to quiz themselves on new words and reinforce language skills.

Prereq

• Ensure that you have installed the latest version of Python on your system.
• Also, install the required library using the following command:

  pip install requests

Value Addition

• Enhances vocabulary through interactive learning.
• Incorporates API usage for dynamic content.

Solution

# Vocab Builder with Flashcards
import requests

def rand_word():
    api_url = "https://random-word-api.herokuapp.com/word"
    res = requests.get(api_url)

    if res.status_code == 200:
        return res.json()[0]
    else:
        return "Error getting a word at the moment."

def display_flashcard(word, def):
    print(f"Word: {word}")
    input("Press Enter to reveal the definition...")
    print(f"Definition: {def}")

# Example usage
rword = rand_word()
display_flashcard(rword, "A brief explanation of a word's meaning.")

Python Code Snippet Organizer

Develop a code snippet organizer that enables users to store and categorize their frequently used code snippets. Utilize a SQLite database to manage and retrieve code snippets based on categories.

Prereq

• Make sure Python is available on your system.
• Install the required library using the following command:

  pip install sqlite3

Value Addition

• Organizes and stores frequently used code snippets.
• Facilitates easy retrieval based on categories.

Solution

# Code Snippet Organizer
import sqlite3

def save_codes(category, code):
    # Connect to SQLite db
    conn = sqlite3.connect('codes.db')
    cursor = conn.cursor()

    # Create the code snippets table if not exists
    cursor.execute('''CREATE TABLE IF NOT EXISTS code_snippets
                      (category TEXT, code TEXT)''')

    # Insert code snippet data into the table
    cursor.execute("INSERT INTO code_snippets VALUES (?, ?)", (category, code))
    conn.commit()

    # Close the connection
    conn.close()

def retrieve_codes(category):
    # Connect to SQLite db
    conn = sqlite3.connect('codes.db')
    cursor = conn.cursor()

    # Retrieve code snippets from the table based on category
    cursor.execute("SELECT code FROM code_snippets WHERE category=?", (category,))
    snippets = cursor.fetchall()

    # Close the connection
    conn.close()

    return snippets

# Let's get our code snippet organizer up to work.
save_codes("Python", "print('Hello, World!')")
py_codes = retrieve_codes("Python")
print("Python Code Snippets:", py_codes)

Here are some more unique Python beginner project ideas with distinct concepts and added prerequisites:

Personal Finance Tracker

Below, we are going to build a simple personal finance tracker. It allows users to input their daily expenses and income. Utilize the matplotlib library to create a visual representation of their spending habits over time.

Prereq

• Python should be installed on your system.
• Install the required libraries using the following commands:

  pip install matplotlib pandas

Value Addition

• Encourages financial awareness through expense tracking.
• Provides visual insights into spending patterns.

Solution

# Personal Finance Tracker
import matplotlib.pyplot as plt
import pandas as pd
from datetime import datetime

def track_expense(category, amount):
    today = datetime.today().strftime('%Y-%m-%d')

    # Create or load a CSV file to store expense data
    try:
        df = pd.read_csv('expense_tracker.csv')
    except FileNotFoundError:
        df = pd.DataFrame(columns=['Date', 'Category', 'Amount'])

    # Append new expense to the DataFrame
    new_expense = pd.DataFrame({'Date': [today], 'Category': [category], 'Amount': [amount]})
    df = pd.concat([df, new_expense], ignore_index=True)

    # Save the updated DataFrame to the CSV file
    df.to_csv('expense_tracker.csv', index=False)

def show_spending():
    # Load expense data from the CSV file
    try:
        df = pd.read_csv('expense_tracker.csv')
    except FileNotFoundError:
        print("No expense data found.")
        return

    # Plotting the expense data
    plt.figure(figsize=(10, 5))
    df['Date'] = pd.to_datetime(df['Date'])
    df = df.sort_values(by='Date')
    plt.plot(df['Date'], df['Amount'], marker='o', linestyle='-', color='r')
    plt.title('Personal Finance Tracker')
    plt.xlabel('Date')
    plt.ylabel('Expense Amount ($)')
    plt.xticks(rotation=45)
    plt.tight_layout()
    plt.show()

# Let's track the spend and print the info
track_expense("Groceries", 50)
show_spending()

Book Recommendation Engine

Let’s create a book recommendation engine that suggests reading based on users’ preferences. We’ll utilize a simple database or file system to store book data and implement a basic algorithm for recommendations.

Prereq

• You require Python on your system to run the above project.

Value Addition

• Introduces basic recommendation algorithms.
• Encourages exploration of different book genres.

Solution

# Book Recommendation Engine
import random

def get_book(genre):
    # Create or load a db with book data
    books = {
        'Mystery': ['The Da Vinci Code', 'Gone Girl', 'Sherlock Holmes'],
        'Science Fiction': ['Dune', 'Ender\'s Game', 'The Hitchhiker\'s Guide to the Galaxy'],
        'Fantasy': ['The Lord of the Rings', 'Harry Potter', 'Game of Thrones'],
    }

    # Generate a random book recommendation based on genre
    if genre in books:
        return random.choice(books[genre])
    else:
        return "Genre not found. Please choose from Mystery, Science Fiction, or Fantasy."

# Example usage
genre_pref = input("Enter your preferred genre (Mystery, Science Fiction, Fantasy): ")
rec = get_book(genre_pref)
print(f"We recommend: {rec}")

Language Flashcard Quiz

Develop a language flashcard quiz that helps users practice vocabulary in a foreign language. Utilize a file to store flashcards, and implement a scoring system to track user progress.

Prereq

• Ensure Python is installed on your system.

Value Addition

• Enhances language skills through interactive learning.
• Customizable flashcard content for various languages.

Solution

# Language Flashcard Quiz
import random

def load_fc(file_path):
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            fc = [line.strip().split(',') for line in f.readlines()]
        return fc
    except FileNotFoundError:
        print("Flashcard file not found.")
        return []

def quiz_user(fc):
    score = 0
    random.shuffle(fc)

    for w, t in fc:
        guess = input(f"What is the English translation of '{w}'? ")
        if guess.lower() == t.lower():
            print("Correct!\n")
            score += 1
        else:
            print(f"Wrong! The correct translation is '{t}'.\n")

    print(f"Quiz completed! Your score: {score}/{len(fc)}")

# Example usage
file_path = "your_flashcards.txt"  # Replace with the actual file path

# Sample flashcard data in the file:
# Bonjour,Hello
# Maison,House
# Ami,Friend
# ...

flashcards_data = load_fc(file_path)
quiz_user(flashcards_data)

Weather Forecast Dashboard

Create a weather forecast dashboard that fetches current weather data from a public API and presents it in a user-friendly interface. Utilize the requests library for API calls.

Prereq

• Check whether Python is available on your system. If not, you need to install it.
• Obtain a free API key from the OpenWeatherMap site.

Value Addition

• Provides real-time weather information for a specified city.
• Introduces making API calls for dynamic data retrieval.

Solution

# Weather Forecast Dashboard
import requests as req

def wet_info(city):
    api_key = 'your_api_key'
    api_url = f'http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric'

    try:
        res = req.get(api_url)
        wet_data = res.json()

        if res.status_code == 200:
            temp = wet_data['main']['temp']
            desc = wet_data['weather'][0]['description']
            return f"The current weather in {city} is {temp}°C with {desc}."
        else:
            return "Error getting weather info at the moment."

    except req.exceptions.RequestException as e:
        return f"Failure: {e}"

# Let's collect input and print weather info
city_name = input("Enter the city for weather forecast: ")
print(wet_info(city_name))

Fitness Challenge Tracker

Let’s develop a fitness challenge tracker that allows users to set fitness goals, log their daily activities, and track their progress over time. Utilize a SQLite database to store fitness data.

Prereq

• Python is the first thing you need to run the above code.
• Install the required library using the following command:

  pip install sqlite3

Value Addition

• Encourages a healthy lifestyle through fitness tracking.
• Provides a historical overview of fitness goals.

Solution

# Fitness Challenge Tracker
import sqlite3
from datetime import datetime

def set_fitness_goal(goal):
    # Connect to SQLite db
    conn = sqlite3.connect('fitness_tracker.db')
    cursor = conn.cursor()

    # Create the fitness tracking table if not exists
    cursor.execute('''CREATE TABLE IF NOT EXISTS fitness_log
                      (date TEXT, goal TEXT)''')

    # Insert fitness goal data into the table
    cursor.execute("INSERT INTO fitness_log VALUES (?, ?)", (datetime.today().strftime('%Y-%m-%d'), goal))
    conn.commit()

    # Close the connection
    conn.close()

def view_progress():
    # Connect to SQLite db
    conn = sqlite3.connect('fitness_tracker.db')
    cursor = conn.cursor()

    # Retrieve fitness log data from the table
    cursor.execute("SELECT date, goal FROM fitness_log")
    data = cursor.fetchall()

    # Displaying fitness log data
    for entry in data:
        print(f"{entry[0]} - {entry[1]}")

    # Close the connection
    conn.close()

# Example usage
set_fitness_goal("Run 5 miles")
view_progress()

Interactive Storytelling Game

You will make a fun game where people can choose what happens in the story. Use special commands to change the story as people decide what to do. Add surprises to make the game different each time someone plays it.

Special Things This helps you learn basic computer ideas like special commands, choices, and repeating actions. Inspires you to be creative in writing and telling stories. It gives you a lively and exciting experience when you use it.

Solution

import random

def get_choice():
    return input("Choose A or B: ").upper()

def play_story():
    print("You're in a mysterious forest...")
    choice = get_choice()

    if choice == 'A':
        print("You find hidden treasure!")
    elif choice == 'B':
        print("You meet a friendly dragon and discover a magical portal.")
    else:
        print("Invalid choice. The story takes a surprising turn.")

if __name__ == "__main__":
    play_story()

Password Manager Project in Python

Let’s make a safe tool to keep and get your passwords for different accounts. Use secret codes to keep your information private. Save these secret codes in files, and add a main password for extra safety.

Special Things:

• Teaches how to keep information safe using secret codes and safety in computer programs.
• Improve your ability to manage files and store information.
• Confirms how to ensure that it’s truly you accessing and safeguarding your data.

Solution

from cryptography.fernet import Fernet

def gen_key():
    return Fernet.generate_key()

def enc(key, data):
    cipher = Fernet(key)
    return cipher.encrypt(data.encode())

def dec(key, data):
    cipher = Fernet(key)
    return cipher.decrypt(data).decode()

def save_pwd(file, user, enc_pwd):
    with open(file, 'a') as f:
        f.write(f"{user},{enc_pwd}\n")

def get_creds():
    user = input("Enter username: ")
    pwd = input("Enter password: ")
    return user, pwd

if __name__ == "__main__":
    key = gen_key()
    file = "passwords.txt"  # Change to your file name

    # Sample data
    user, pwd = get_creds()
    enc_pwd = enc(key, pwd)
    save_pwd(file, user, enc_pwd)

    # Retrieve and decrypt password
    target_user = input("Enter username to retrieve password: ")
    with open(file, 'r') as f:
        for line in f:
            stored_user, stored_enc_pwd = line.strip().split(',')
            if stored_user == target_user:
                dec_pwd = dec(key, stored_enc_pwd)
                print(f"Decrypted password for {target_user}: {dec_pwd}")
                break
        else:
            print(f"Password not found for {target_user}.")

Summary- Python Beginner Projects

Getting started with Python is a lot of fun with Python Beginner Projects. These projects are like friendly challenges that help you learn how to code in Python. From simple programs to more interactive ones, each project introduces new challenges and opportunities for learning.

As you work through these projects, don’t hesitate to explore additional resources, seek help from the Python community, and, most importantly, have fun! Programming is a skill that improves with practice, so keep coding, building, and expanding your knowledge.

Lastly, our site needs your support to remain free. Share this post on social media (Linkedin/Twitter) if you gained some knowledge from this tutorial.

Happy coding,
TechBeamers.