Come creare un tracker delle spese utilizzando Python

Un tracker delle spese è uno strumento essenziale che aiuta gli individui e le aziende a gestire le proprie transazioni finanziarie. Con un tracker delle spese puoi creare budget, classificare le spese e analizzare i modelli di spesa.

Scopri come creare un'app per il monitoraggio delle spese, con una GUI multipiattaforma, in Python.

I moduli Tkinter, CSV e Matplotlib

Per creare questo tracker delle spese, avrai bisogno dei moduli Tkinter, CSV e Matplotlib.

Tkinter te lo permette creare applicazioni desktop. Offre una varietà di widget come pulsanti, etichette e caselle di testo che semplificano lo sviluppo di app.

Il modulo CSV è una libreria Python integrata che fornisce funzionalità per la lettura e la scrittura File CSV (valori separati da virgole)..

Con Matplotlib puoi creare visualizzazioni interattive come grafici, diagrammi e diagrammi. Usarlo con moduli come OpenCV può aiutarti padroneggiare le tecniche di miglioramento delle immagini pure.

Per installare questi moduli, eseguire:

pip install tk matplotlib 

Definire la struttura dell'app di monitoraggio delle spese

Puoi trovare il codice sorgente di questo progetto nel suo file Repositorio GitHub.

Inizia importando i moduli necessari. Definire una classe, ExpenseTrackerApp. Imposta il titolo e le dimensioni. Definire una lista per memorizzare le spese ed un'altra per le categorie. Inizializzare a StringVar di nome categoria_var e imposta il suo valore iniziale sulla prima categoria nell'elenco delle categorie. Concludi chiamando il create_widgets metodo.

import tkinter as tk
from tkinter import ttk, messagebox, simpledialog
import csv
import matplotlib.pyplot as plt
classExpenseTrackerApp(tk.Tk):
def__init__(self):
 super().__init__()
 self.title("Expense Tracker")
 self.geometry("1300x600")
 self.expenses = []
 self.categories = [
"Food",
"Transportation",
"Utilities",
"Entertainment",
"Other",
 ]
 self.category_var = tk.StringVar(self)
 self.category_var.set(self.categories[0])
 self.create_widgets()

IL create_widgets Il metodo è responsabile dell'aggiunta di componenti dell'interfaccia utente alla tua app. Crea una cornice per le etichette e le voci del record di spesa. Crea sei etichette: una per intestazione, importo di spesa, descrizione dell'articolo, categoria, data e spesa totale. Imposta l'elemento genitore di ciascuno, il testo che dovrebbe visualizzare e il suo stile di carattere.

Crea tre widget di ingresso e a Casella combinata per ottenere l'input corrispondente. Per i widget di ingresso, imposta l'elemento principale, lo stile del carattere e la larghezza. Definisci l'elemento genitore, l'elenco dei valori, lo stile del carattere e la larghezza per il file Casella combinata. Legamento categoria_var ad esso, quindi il valore selezionato viene aggiornato automaticamente.

defcreate_widgets(self):
 self.label = tk.Label(
 self, text="Expense Tracker", font=("Helvetica", 20, "bold")
 )
 self.label.pack(pady=10)
 self.frame_input = tk.Frame(self)
 self.frame_input.pack(pady=10)
 self.expense_label = tk.Label(
 self.frame_input, text="Expense Amount:", font=("Helvetica", 12)
 )
 self.expense_label.grid(row=0, column=0, padx=5)
 self.expense_entry = tk.Entry(
 self.frame_input, font=("Helvetica", 12), width=15
 )
 self.expense_entry.grid(row=0, column=1, padx=5)
 self.item_label = tk.Label(
 self.frame_input, text="Item Description:", font=("Helvetica", 12)
 )
 self.item_label.grid(row=0, column=2, padx=5)
 self.item_entry = tk.Entry(self.frame_input, font=("Helvetica", 12), width=20)
 self.item_entry.grid(row=0, column=3, padx=5)
 self.category_label = tk.Label(
 self.frame_input, text="Category:", font=("Helvetica", 12)
 )
 self.category_label.grid(row=0, column=4, padx=5)
 self.category_dropdown = ttk.Combobox(
 self.frame_input,
 textvariable=self.category_var,
 values=self.categories,
 font=("Helvetica", 12),
 width=15,
 )
 self.category_dropdown.grid(row=0, column=5, padx=5)
 self.date_label = tk.Label(
 self.frame_input, text="Date (YYYY-MM-DD):", font=("Helvetica", 12)
 )
 self.date_label.grid(row=0, column=6, padx=5)
 self.date_entry = tk.Entry(self.frame_input, font=("Helvetica", 12), width=15)
 self.date_entry.grid(row=0, column=7, padx=5)

Definire cinque pulsanti: Aggiungi spesa, Modifica spesa, Elimina spesa, Risparmia sulle spese, E Mostra grafico delle spese. Imposta l'elemento genitore di ciascuno, il testo che dovrebbe visualizzare e il comando che verrà eseguito quando fai clic su di esso. Crea una cornice per la casella di riepilogo. Imposta l'elemento principale, lo stile del carattere e la larghezza.

Crea una barra di scorrimento verticale e posizionala sul lato destro della cornice. Usalo per scorrere il contenuto della casella di riepilogo. Organizza tutti gli elementi con il riempimento necessario e chiama update_total_label().

 self.add_button = tk.Button(self, text="Add Expense", command=self.add_expense)
 self.add_button.pack(pady=5)
 self.frame_list = tk.Frame(self)
 self.frame_list.pack(pady=10)
 self.scrollbar = tk.Scrollbar(self.frame_list)
 self.scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
 self.expense_listbox = tk.Listbox(
 self.frame_list,
 font=("Helvetica", 12),
 width=70,
 yscrollcommand=self.scrollbar.set,
 )
 self.expense_listbox.pack(pady=5)
 self.scrollbar.config(command=self.expense_listbox.yview)
 self.edit_button = tk.Button(
 self, text="Edit Expense", command=self.edit_expense
 )
 self.edit_button.pack(pady=5)
 self.delete_button = tk.Button(
 self, text="Delete Expense", command=self.delete_expense
 )
 self.delete_button.pack(pady=5)
 self.save_button = tk.Button(
 self, text="Save Expenses", command=self.save_expenses
 )
 self.save_button.pack(pady=5)
 self.total_label = tk.Label(
 self, text="Total Expenses:", font=("Helvetica", 12)
 )
 self.total_label.pack(pady=5)
 self.show_chart_button = tk.Button(
 self, text="Show Expenses Chart", command=self.show_expenses_chart
 )
 self.show_chart_button.pack(pady=5)
 self.update_total_label()

Definire la funzionalità del tracciatore delle spese

Definire un metodo, aggiungi_spesa. Recupera il valore della spesa, dell'articolo, della categoria e della data. Se il valore della spesa e la data sono validi, aggiungere la spesa al spese elenco. Inserisci questo record nella casella di riepilogo e formattalo in modo appropriato. Una volta inserito, eliminare l'input dell'utente nelle caselle di immissione per il nuovo input.

Altrimenti, visualizza un avviso che i valori di spesa e data non possono essere vuoti. Chiamata aggiornamento_totale_etichetta.

defadd_expense(self):
 expense = self.expense_entry.get()
 item = self.item_entry.get()
 category = self.category_var.get()
 date = self.date_entry.get()
if expense and date:
 self.expenses.append((expense, item, category, date))
 self.expense_listbox.insert(
 tk.END, f"{expense} - {item} - {category} ({date})"
 )
 self.expense_entry.delete(0, tk.END)
 self.item_entry.delete(0, tk.END)
 self.date_entry.delete(0, tk.END)
else:
 messagebox.showwarning("Warning", "Expense and Date cannot be empty.")
 self.update_total_label()

Definire un metodo, modifica_spesa. Recupera l'indice del record selezionato e ottieni la spesa. Aprire una finestra di dialogo che chiede di inserire la spesa. Se l'utente ha fornito una nuova spesa, modificare di conseguenza l'elenco delle spese. Chiama il aggiorna la lista E aggiornamento_totale_etichetta.

defedit_expense(self):
 selected_index = self.expense_listbox.curselection()
if selected_index:
 selected_index = selected_index[0]
 selected_expense = self.expenses[selected_index]
 new_expense = simpledialog.askstring(
"Edit Expense", "Enter new expense:", initialvalue=selected_expense[0]
 )
if new_expense:
 self.expenses[selected_index] = (
 new_expense,
 selected_expense[1],
 selected_expense[2],
 selected_expense[3],
 )
 self.refresh_list()
 self.update_total_label()

Definire un metodo, elimina_spesa. Recupera l'indice del record selezionato e ottieni la spesa. Passa l'indice della voce che desideri eliminare. Elimina quella voce dalla casella di riepilogo e chiama il aggiornamento_totale_etichetta.

defdelete_expense(self):
 selected_index = self.expense_listbox.curselection()
if selected_index:
 selected_index = selected_index[0]
del self.expenses[selected_index]
 self.expense_listbox.delete(selected_index)
 self.update_total_label()

Definire un metodo, aggiorna la lista. Elimina il record esistente e aggiungi invece un nuovo record con i valori aggiornati.

defrefresh_list(self):
 self.expense_listbox.delete(0, tk.END)
for expense, item, category, date in self.expenses:
 self.expense_listbox.insert(
 tk.END, f"{expense} - {item} - {category} ({date})"
 )

Definire un metodo, aggiornamento_totale_etichetta. Calcola la somma di tutte le spese nell'elenco e aggiornala sull'etichetta. Definire un altro metodo, risparmia_spese. Crea e apri un file CSV file denominato spese.csv in modalità scrittura. Aggiungi intestazioni di colonna al file CSV come prima riga. Ripeti ogni record di spesa e scrivilo come una riga.

defupdate_total_label(self):
 total_expenses = sum(float(expense[0]) for expense in self.expenses)
 self.total_label.config(text=f"Total Expenses: USD {total_expenses:.2f}")
defsave_expenses(self):
with open("expenses.csv", "w", newline="") as csvfile:
 writer = csv.writer(csvfile)
 column_headers = ["Expense Amount", "Item Description", "Category", "Date"]
 writer.writerow(column_headers)
for expense in self.expenses:
 writer.writerow(expense))

Definire un metodo, mostra_tabella_spese. Definire un dizionario, categoria_totali. Scorrere il file spese elencare e convertire l'importo della spesa in flottante. Memorizzare l'importo totale della spesa per ciascuna categoria. Se la categoria esiste già nel dizionario, incrementare il totale dell'importo della spesa corrente. Altrimenti, crea una nuova voce con l'importo della spesa corrente.

defshow_expenses_chart(self):
 category_totals = {}
for expense, _, category, _ in self.expenses:
try:
 amount = float(expense)
except ValueError:
continue
 category_totals[category] = category_totals.get(category, 0) + amount

Estrarre le categorie e le spese in due elenchi diversi. Crea una nuova figura per la trama con la dimensione specificata. Genera un grafico a torta, utilizzando l'elenco delle spese come dati e l'elenco delle categorie come etichetta. IL autopct Il parametro specifica il formato per la visualizzazione dei valori percentuali sulle sezioni del grafico. Passaggio pari A asse plt per assicurarti di disegnare il grafico a torta come un cerchio. Imposta il titolo del grafico a torta e visualizzalo.

 categories = list(category_totals.keys())
 expenses = list(category_totals.values())
 plt.figure(figsize=(8, 6))
 plt.pie(
 expenses, labels=categories, autopct="%1.1f%%", startangle=140, shadow=True
 )
 plt.axis("equal")
 plt.title(f"Expense Categories Distribution (USD)")
 plt.show()

Crea un'istanza di ExpenseTrackerApp classe. IL ciclo principale() La funzione dice a Python di eseguire il ciclo di eventi di Tkinter e di ascoltare gli eventi finché non chiudi la finestra.

if __name__ == "__main__":
 app = ExpenseTrackerApp()
 app.mainloop()

Prova diverse funzionalità del tracker delle spese Python

Quando esegui il programma, verrà avviata una finestra dell'applicazione. Dispone di campi di input per registrare la spesa, la descrizione dell'articolo, la categoria e la data. Immettere alcuni dati e fare clic su Aggiungi spesa pulsante; vedrai che il record viene aggiunto alla casella di riepilogo. Il programma aggiorna anche il totale delle spese.

Selezionare un record e fare clic su Modifica spese pulsante. Viene visualizzata una finestra di dialogo che consente di aggiornare il singolo record.

Facendo clic su Elimina le spese pulsante per rimuovere il record selezionato.

Colpendo il Mostra grafico delle spese pulsante, il programma visualizza un grafico a torta. Il grafico a torta mostra la spesa per ciascuna categoria insieme al nome e alla percentuale.

Miglioramento del tracker delle spese

Puoi aggiungere funzionalità di ricerca per consentire agli utenti di trovare spese specifiche in base alla descrizione, all'importo, alla categoria o alla data. Puoi aggiungere un'opzione per ordinare e filtrare i record. Localizza l'app per supportare diverse lingue e formati di valuta.

Potresti anche estendere l'app con il supporto per le notifiche. Consenti all'utente di impostare avvisi per evitare che superi i limiti di budget o evidenzia eventuali spese insolite.