Construiți această aplicație simplă pentru a vă exersa programarea matematică și pentru a afla puțin despre codarea GUI pe parcurs.

Un instrument de urmărire a cheltuielilor este un instrument esențial care ajută persoanele și companiile să își gestioneze tranzacțiile financiare. Cu un instrument de urmărire a cheltuielilor, puteți crea bugete, puteți clasifica cheltuielile și puteți analiza tiparele de cheltuieli.

Aflați cum să creați o aplicație de urmărire a cheltuielilor, cu o interfață grafică multiplatformă, în Python.

Modulele Tkinter, CSV și Matplotlib

Pentru a construi acest instrument de urmărire a cheltuielilor, veți avea nevoie de modulele Tkinter, CSV și Matplotlib.

Tkinter vă permite creați aplicații desktop. Oferă o varietate de widget-uri, cum ar fi butoane, etichete și casete de text, care facilitează dezvoltarea aplicațiilor.

Modulul CSV este o bibliotecă Python încorporată care oferă funcționalități pentru citire și scriere fișiere CSV (valori separate prin virgulă)..

Cu Matplotlib, puteți crea vizualizări interactive, cum ar fi grafice, diagrame și diagrame. Folosirea lui cu module precum OpenCV vă poate ajuta

instagram viewer
stăpânește tehnici de îmbunătățire a imaginii de asemenea.

Pentru a instala aceste module, rulați:

pip install tk matplotlib

Definiți structura aplicației Expense Tracker

Puteți găsi codul sursă al acestui proiect în documentul său Depozitul GitHub.

Începeți prin a importa modulele necesare. Definiți o clasă, ExpenseTrackerApp. Setați titlul și dimensiunile. Definiți o listă pentru stocarea cheltuielilor și alta pentru categorii. Inițializați a StringVar numit categorie_var și setați valoarea inițială la prima categorie din lista de categorii. Terminați sunând la create_widgets metodă.

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()

The create_widgets metoda este responsabilă pentru adăugarea componentelor UI la aplicația dvs. Creați un cadru pentru etichetele și înregistrările înregistrării cheltuielilor. Creați șase etichete: câte una pentru titlu, suma cheltuielilor, descrierea articolului, categorie, dată și cheltuieli totale. Setați elementul părinte al fiecăruia, textul pe care ar trebui să-l afișeze și stilul de font.

Creați trei widget-uri de intrare și a Combobox pentru a obține intrarea corespunzătoare. Pentru widget-urile de intrare, setați elementul părinte, stilul fontului și lățimea. Definiți elementul părinte, lista de valori, stilul fontului și lățimea pentru Combobox. Lega categorie_var la acesta, astfel încât valoarea selectată este actualizată automat.

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)

Definiți cinci butoane: Adăugați cheltuieli, Editați Cheltuieli, Șterge cheltuieli, Economisiți Cheltuieli, și Arată graficul cheltuielilor. Setați elementul părinte al fiecăruia, textul pe care ar trebui să-l afișeze și comanda pe care o va rula când faceți clic pe el. Creați un cadru pentru caseta cu listă. Setați elementul părinte, stilul fontului și lățimea.

Creați o bară de defilare verticală și plasați-o în partea dreaptă a cadrului. Folosiți-l pentru a parcurge conținutul casetei cu listă. Organizați toate elementele cu umplutura și apelul necesare 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()

Definiți funcționalitatea instrumentului de urmărire a cheltuielilor

Definiți o metodă, add_expense. Preluați valoarea cheltuielii, articolului, categoriei și datei. Dacă valoarea cheltuielii și data sunt valide, adăugați cheltuiala la cheltuieli listă. Introduceți această înregistrare în caseta cu listă și formatați-o corespunzător. Odată introdus, ștergeți introducerea utilizatorului în casetele de introducere pentru introducerea nouă.

În caz contrar, afișați un avertisment că valorile cheltuielilor și datei nu pot fi goale. Apel update_total_label.

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()

Definiți o metodă, edit_cheltuieli. Preluați indexul înregistrării selectate și obțineți cheltuiala. Deschideți o casetă de dialog care vă cere să introduceți cheltuiala. Dacă utilizatorul a furnizat o nouă cheltuială, modificați lista de cheltuieli în consecință. Suna reîmprospătare_listă și update_total_label.

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()

Definiți o metodă, şterge_cheltuieli. Preluați indexul înregistrării selectate și obțineți cheltuiala. Treceți indexul intrării pe care doriți să o ștergeți. Ștergeți acea intrare din listbox și apelați update_total_label.

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()

Definiți o metodă, reîmprospătare_listă. Ștergeți înregistrarea existentă și adăugați o nouă înregistrare cu valorile actualizate.

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})"
 )

Definiți o metodă, update_total_label. Calculați suma tuturor cheltuielilor din listă și actualizați-o pe etichetă. Definiți o altă metodă, economisiți_cheltuieli. Creați și deschideți un CSV fişier numit cheltuieli.csv în modul de scriere. Adăugați antete de coloană în fișierul CSV ca primul rând. Repetați fiecare înregistrare de cheltuieli și scrieți-o ca un rând.

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))

Definiți o metodă, arată graficul_cheltuielilor. Definiți un dicționar, categorie_totaluri. Iterați prin cheltuieli enumerați și convertiți suma cheltuielilor în float. Stocați suma totală a cheltuielilor pentru fiecare categorie. Dacă categoria există deja în dicționar, creșteți totalul cu suma curentă a cheltuielilor. În caz contrar, creați o nouă intrare cu suma curentă a cheltuielilor.

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

Extrageți categoriile și cheltuielile în două liste diferite. Creați o nouă figură pentru parcelă cu dimensiunea specificată. Generați o diagramă circulară, folosind lista de cheltuieli ca date și lista de categorii ca etichetă. The autopct parametrul specifică formatul de afișare a valorilor procentuale pe secțiunile diagramei. Trece egal la plt.axa pentru a vă asigura că desenați diagrama circulară ca un cerc. Setați titlul diagramei circulare și afișați-l.

 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ți o instanță a ExpenseTrackerApp clasă. The mainloop() funcția îi spune lui Python să ruleze bucla de evenimente Tkinter și să asculte evenimente până când închideți fereastra.

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

Testați diferite caracteristici ale Python Expense Tracker

Când rulați programul, acesta va lansa o fereastră de aplicație. Acesta are câmpuri de introducere pentru a înregistra cheltuielile, descrierea articolului, categoria și data. Introduceți câteva date și faceți clic pe Adăugați cheltuieli buton; veți vedea că înregistrarea este adăugată în caseta de listă. Programul actualizează și cheltuielile totale.

Selectați o înregistrare și faceți clic pe Editați Cheltuieli buton. Apare o casetă de dialog care vă permite să actualizați înregistrarea individuală.

Făcând clic pe Ștergeți cheltuielile butonul pentru a elimina înregistrarea selectată.

La lovirea Arată graficul cheltuielilor butonul, programul afișează o diagramă circulară. Graficul circular afișează cheltuielile pentru fiecare categorie împreună cu numele și procentul acesteia.

Îmbunătățirea monitorizării cheltuielilor

Puteți adăuga funcționalitate de căutare pentru a le permite utilizatorilor să găsească anumite cheltuieli în funcție de descriere, sumă, categorie sau dată. Puteți adăuga o opțiune pentru sortarea și filtrarea înregistrărilor. Localizați aplicația pentru a accepta diferite limbi și formate de monedă.

De asemenea, puteți extinde aplicația cu suport pentru notificări. Permiteți utilizatorului să configureze alerte pentru a preveni depășirea limitelor bugetare sau pentru a evidenția orice cheltuieli neobișnuite.