Build a Personal Budget Tracker with Tkinter and SQLite in Python

A personal budget tracker helps you manage and monitor your finances. In this tutorial, we will create a simple budget tracker app using Python, Tkinter, and SQLite. We’ll also add features like categorizing transactions, visualizing spending, and setting a custom window icon for a more polished look.

Prerequisites

Before we begin, make sure you have Python installed on your system. You’ll also need the following libraries:

• Matplotlib: For visualizing spending in the form of pie charts.
• Tkinter: For the graphical user interface (GUI).
• SQLite: For storing transaction data in a local database.

To install Matplotlib, run:

pip install matplotlib

Step 1: Set Up the Database

First, we need to set up an SQLite database to store the transactions. The database will include a table where we will store the transaction details like date, category, description, amount, and type (income or expense).

Here’s the code to create the database and table:

import sqlite3
from datetime import datetime
def initialize_database():
    conn = sqlite3.connect('budget_tracker.db')
    cursor = conn.cursor()
    
    # Create a table for transactions
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS transactions (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            date TEXT,
            category TEXT,
            description TEXT,
            amount REAL,
            type TEXT
        )
    ''')
    conn.commit()
    conn.close()
initialize_database()

Step 2: Create the Add Transaction Form – Personal Budget Tracker

We need a form where users can input transaction details such as category, description, amount, and type (income or expense). We will build this form using Tkinter’s widgets like Entry, Label, and Button.

Here is the code for the form and how it will add transactions to the database:

import tkinter as tk
from tkinter import ttk, messagebox

def add_transaction_gui():
    def submit():
        category = category_entry.get()
        description = description_entry.get()
        amount = float(amount_entry.get())
        trans_type = trans_type_var.get()

        if not category or not description or not amount or not trans_type:
            messagebox.showerror("Error", "All fields are required.")
            return

        add_transaction(category, description, amount, trans_type)
        messagebox.showinfo("Success", f"{trans_type.capitalize()} added successfully!")
        window.destroy()

    window = tk.Toplevel()
    window.title("Add Transaction")
    window.geometry("400x300")

    tk.Label(window, text="Category").grid(row=0, column=0, padx=10, pady=10)
    category_entry = tk.Entry(window)
    category_entry.grid(row=0, column=1, padx=10, pady=10)

    tk.Label(window, text="Description").grid(row=1, column=0, padx=10, pady=10)
    description_entry = tk.Entry(window)
    description_entry.grid(row=1, column=1, padx=10, pady=10)

    tk.Label(window, text="Amount").grid(row=2, column=0, padx=10, pady=10)
    amount_entry = tk.Entry(window)
    amount_entry.grid(row=2, column=1, padx=10, pady=10)

    tk.Label(window, text="Type").grid(row=3, column=0, padx=10, pady=10)
    trans_type_var = tk.StringVar(value="income")
    trans_type_menu = ttk.Combobox(window, textvariable=trans_type_var, values=["income", "expense"])
    trans_type_menu.grid(row=3, column=1, padx=10, pady=10)

    submit_btn = tk.Button(window, text="Submit", command=submit)
    submit_btn.grid(row=4, column=0, columnspan=2, pady=20)

Step 3: View Transactions

To track our spending, we need to view all transactions in a list. Tkinter’s Treeview widget is perfect for this purpose. It allows us to display transaction details in a structured, scrollable table.

Here’s how you can display transactions from the database:

def view_transactions():
    conn = sqlite3.connect('budget_tracker.db')
    cursor = conn.cursor()
    cursor.execute('SELECT * FROM transactions')
    transactions = cursor.fetchall()
    conn.close()

    window = tk.Toplevel()
    window.title("Transaction History")
    window.geometry("600x400")

    tree = ttk.Treeview(window, columns=("Date", "Category", "Description", "Amount", "Type"), show="headings")
    tree.heading("Date", text="Date")
    tree.heading("Category", text="Category")
    tree.heading("Description", text="Description")
    tree.heading("Amount", text="Amount")
    tree.heading("Type", text="Type")

    for trans in transactions:
        tree.insert("", tk.END, values=trans[1:])
    
    tree.pack(fill=tk.BOTH, expand=True)

Step 4: Visualize Spending

To help users understand their spending habits, we can visualize their expenses by category using a pie chart. Matplotlib will be used to generate the pie chart, which will show a breakdown of spending across different categories.

import matplotlib.pyplot as plt

def visualize_spending_by_category():
    conn = sqlite3.connect('budget_tracker.db')
    cursor = conn.cursor()
    cursor.execute('''
        SELECT category, SUM(amount) FROM transactions
        WHERE type = 'expense'
        GROUP BY category
    ''')
    spending = cursor.fetchall()
    conn.close()

    if not spending:
        messagebox.showinfo("Info", "No expenses to display.")
        return

    categories = [row[0] for row in spending]
    amounts = [row[1] for row in spending]

    plt.figure(figsize=(8, 6))
    plt.pie(amounts, labels=categories, autopct='%1.1f%%', startangle=140)
    plt.title("Spending by Category")
    plt.show()

Step 5: Customize the Window Icon (Favicon)

To give your app a more professional look, you can set a custom window icon (favicon). Tkinter allows us to easily set a .ico file as the window icon.

Here’s how you can change the default icon:

def main_gui():
    root = tk.Tk()
    root.title("Personal Budget Tracker")
    root.geometry("400x300")

    # Set the window icon (Favicon)
    root.iconbitmap('favicon.ico')  # Provide the path to your icon file

    tk.Label(root, text="Personal Budget Tracker", font=("Helvetica", 16)).pack(pady=20)

    tk.Button(root, text="Add Transaction", width=20, command=add_transaction_gui).pack(pady=10)
    tk.Button(root, text="View Transactions", width=20, command=view_transactions).pack(pady=10)
    tk.Button(root, text="Visualize Spending", width=20, command=visualize_spending_by_category).pack(pady=10)
    tk.Button(root, text="Exit", width=20, command=root.quit).pack(pady=10)

    root.mainloop()

Tip: You can convert any PNG or JPEG image into an .ico file using online converters.

Step 6: Putting Everything Together

Now, let’s integrate everything into one cohesive app. The following is the complete code for the Personal Budget Tracker.

import sqlite3
import tkinter as tk
from tkinter import ttk, messagebox
from datetime import datetime
import matplotlib.pyplot as plt

# Code for database setup, adding transactions, viewing transactions, and visualizing spending
# (Refer to the code sections above)

if __name__ == "__main__":
    main_gui()

Step 7: Running Personal Budget Tracker Application

Once you’ve written the code, save it as budget_tracker.py. To run the app, simply execute the script in your terminal:

python budget_tracker.py

You should now see the Personal Budget Tracker GUI with a custom window icon. You can add income and expense transactions, view them, and visualize your spending by category.

Step 8: Application Screenshot

Execute Application – Personal Budget Tracker

Insert a Sample Income

Now Insert a Sample Expenses

View Transactions History

Visualize Spending using Tkinter App – Matplotlib

GitHub Repository Link: https://github.com/data-coach/personal-budget-tracker-python.git

About Author: Connect with Me on LinkedIn

Conclusion – Personal Budget Tracker using Python

This simple Python app demonstrates how to build a personal budget tracker with Tkinter for the GUI and SQLite for data storage. You also learned how to visualize your expenses using Matplotlib and customize your app with a custom icon.

To dive deeper into building a sentiment analysis model using Transformers (BERT) and deploying it as an API, check out this detailed guide: How to Build a Sentiment Analysis API with Transformers in 2024.

Feel free to contact us or expand the app by adding features like editing transactions, setting a budget limit, or generating monthly reports!

• Share on LinkedIn
• Share on Telegram

Learn how to build a personal budget tracker using Python, Tkinter, and SQLite in this step-by-step guide. We cover how to create a user-friendly interface, store transactions in a database, visualize spending with charts, and even set a custom window icon for a polished look.