Cree esta sencilla aplicación para practicar su programación matemática y aprender un poco sobre la codificación GUI a lo largo del camino.
Un rastreador de gastos es una herramienta esencial que ayuda a personas y empresas a gestionar sus transacciones financieras. Con un rastreador de gastos, puede crear presupuestos, categorizar gastos y analizar patrones de gastos.
Descubra cómo crear una aplicación de seguimiento de gastos, con una GUI multiplataforma, en Python.
Los módulos Tkinter, CSV y Matplotlib
Para crear este rastreador de gastos, necesitará los módulos Tkinter, CSV y Matplotlib.
Tkinter te permite crear aplicaciones de escritorio. Ofrece una variedad de widgets como botones, etiquetas y cuadros de texto que facilitan el desarrollo de aplicaciones.
El módulo CSV es una biblioteca Python incorporada que proporciona funcionalidad para lectura y escritura. Archivos CSV (valores separados por comas).
Con Matplotlib, puede crear visualizaciones interactivas como gráficos, diagramas y tablas. Usarlo con módulos como OpenCV puede ayudarte
dominar las técnicas de mejora de imágenes también.Para instalar estos módulos, ejecute:
pip install tk matplotlib
Definir la estructura de la aplicación Expense Tracker
Puedes encontrar el código fuente de este proyecto en su repositorio de GitHub.
Comience importando los módulos necesarios. Definir una clase, Aplicación ExpenseTracker. Establece el título y las dimensiones. Defina una lista para almacenar los gastos y otra para las categorías. Inicializar un CadenaVar llamado categoría_var y establezca su valor inicial en la primera categoría en la lista de categorías. Termine llamando al crear_widgets método.
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()
El crear_widgets El método es responsable de agregar componentes de interfaz de usuario a su aplicación. Cree un marco para las etiquetas y entradas del registro de gastos. Cree seis etiquetas: una para el encabezado, el monto del gasto, la descripción del artículo, la categoría, la fecha y el gasto total. Establezca el elemento principal de cada uno, el texto que debe mostrar y su estilo de fuente.
Cree tres widgets de entrada y un Caja combo para obtener la entrada correspondiente. Para los widgets de entrada, establezca el elemento principal, el estilo de fuente y el ancho. Defina el elemento principal, la lista de valores, el estilo de fuente y el ancho del Caja combo. Unir categoría_var a él, por lo que el valor seleccionado se actualiza automáticamente.
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)Defina cinco botones: Agregar gastos, Editar gasto, Eliminar Gasto, Ahorrar gastos, y Mostrar tabla de gastos. Establezca el elemento principal de cada uno, el texto que debe mostrar y el comando que ejecutará cuando haga clic en él. Crea un marco para el cuadro de lista. Establezca el elemento principal, el estilo de fuente y el ancho.
Cree una barra de desplazamiento vertical y colóquela en el lado derecho del marco. Úselo para desplazarse por el contenido del cuadro de lista. Organiza todos los elementos con el relleno necesario y llama. actualización_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()Definir la funcionalidad del rastreador de gastos
Definir un método, agregar_gasto. Recupera el valor del gasto, artículo, categoría y fecha. Si el valor del gasto y la fecha son válidos, agregue el gasto al gastos lista. Inserte este registro en el cuadro de lista y formatéelo adecuadamente. Una vez insertado, elimine la entrada del usuario en los cuadros de entrada para una nueva entrada.
De lo contrario, mostrará una advertencia de que los valores de gasto y fecha no pueden estar vacíos. Llamar etiqueta_actualización_total.
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()Definir un método, editar_gasto. Recupera el índice del registro seleccionado y obtén el gasto. Abra un cuadro de diálogo solicitando ingresar el gasto. Si el usuario proporcionó un nuevo gasto, modifique la lista de gastos en consecuencia. Llama a actualizar lista y etiqueta_actualización_total.
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()Definir un método, eliminar_gasto. Recupera el índice del registro seleccionado y obtén el gasto. Pase el índice de la entrada que desea eliminar. Elimine esa entrada del cuadro de lista y llame al etiqueta_actualización_total.
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()Definir un método, actualizar lista. Elimine el registro existente y agregue un nuevo registro con los valores actualizados.
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})"
)Definir un método, etiqueta_actualización_total. Calcula la suma de todos los gastos de la lista y actualízala en la etiqueta. Definir otro método, guardar_gastos. Crear y abrir un CSV archivo llamado gastos.csv en modo escritura. Agregue encabezados de columna al archivo CSV como primera fila. Repita cada registro de gastos y escríbalo como una fila.
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))
Definir un método, mostrar_gráfico_gastos. Definir un diccionario, categoría_totales. Iterar a través del gastos enumere y convierta el monto del gasto a flotante. Almacene el monto total del gasto para cada categoría. Si la categoría ya existe en el diccionario, incremente el total por el monto del gasto actual. De lo contrario, cree una nueva entrada con el monto del gasto actual.
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) + amountExtraiga las categorías y los gastos en dos listas diferentes. Crea una nueva figura para el gráfico con el tamaño especificado. Genere un gráfico circular, utilizando la lista de gastos como datos y la lista de categorías como etiqueta. El autopct El parámetro especifica el formato para mostrar los valores porcentuales en los sectores del gráfico. Aprobar igual a plt.eje para asegurarse de dibujar el gráfico circular como un círculo. Establezca el título del gráfico circular y muéstrelo.
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()Crear una instancia del Aplicación ExpenseTracker clase. El bucle principal() La función le dice a Python que ejecute el bucle de eventos de Tkinter y escuche los eventos hasta que cierre la ventana.
if __name__ == "__main__":
app = ExpenseTrackerApp()
app.mainloop()Pruebe diferentes funciones del rastreador de gastos de Python
Cuando ejecute el programa, abrirá una ventana de aplicación. Tiene campos de entrada para registrar el gasto, la descripción del artículo, la categoría y la fecha. Introduce algunos datos y haz clic en Agregar gastos botón; Verá que el registro se agrega al cuadro de lista. El programa también actualiza los gastos totales.
Seleccione un registro y haga clic en Editar gastos botón. Aparece un cuadro de diálogo que le permite actualizar el registro individual.
Al hacer clic en Eliminar gastos para eliminar el registro seleccionado.
Al golpear el Mostrar tabla de gastos, el programa muestra un gráfico circular. El gráfico circular muestra el gasto de cada categoría junto con su nombre y porcentaje.
Mejora del rastreador de gastos
Puede agregar una función de búsqueda para permitir a los usuarios encontrar gastos específicos según su descripción, monto, categoría o fecha. Puede agregar una opción para ordenar y filtrar registros. Localice la aplicación para que admita diferentes idiomas y formatos de moneda.
También puedes ampliar la aplicación con soporte para notificaciones. Permita que el usuario configure alertas para evitar que exceda los límites de presupuesto o destaque cualquier gasto inusual.