Crie este aplicativo simples para praticar sua programação matemática e aprender um pouco sobre codificação GUI ao longo do caminho.

Um rastreador de despesas é uma ferramenta essencial que ajuda indivíduos e empresas a gerenciar suas transações financeiras. Com um rastreador de despesas, você pode criar orçamentos, categorizar despesas e analisar padrões de gastos.

Descubra como construir um aplicativo rastreador de despesas, com uma GUI multiplataforma, em Python.

Os módulos Tkinter, CSV e Matplotlib

Para construir este rastreador de despesas, você precisará dos módulos Tkinter, CSV e Matplotlib.

Tkinter permite que você criar aplicativos de desktop. Ele oferece uma variedade de widgets como botões, rótulos e caixas de texto que facilitam o desenvolvimento de aplicativos.

O módulo CSV é uma biblioteca Python integrada que fornece funcionalidade para leitura e escrita Arquivos CSV (valores separados por vírgula).

Com Matplotlib, você pode construir visualizações interativas, como gráficos, plotagens e tabelas. Usá-lo com módulos como OpenCV pode ajudá-lo

instagram viewer
dominar técnicas de aprimoramento de imagem também.

Para instalar esses módulos, execute:

pip install tk matplotlib

Defina a estrutura do aplicativo Expense Tracker

Você pode encontrar o código fonte deste projeto em seu Repositório GitHub.

Comece importando os módulos necessários. Defina uma classe, Aplicativo ExpenseTracker. Defina o título e as dimensões. Defina uma lista para armazenar as despesas e outra para as categorias. Inicialize um StringVar nomeado categoria_var e defina seu valor inicial para a primeira categoria na lista de categorias. Termine ligando para o criar_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()

O criar_widgets O método é responsável por adicionar componentes de UI ao seu aplicativo. Crie um quadro para os rótulos e entradas do registro de despesas. Crie seis rótulos: um para cada título, valor da despesa, descrição do item, categoria, data e despesa total. Defina o elemento pai de cada um, o texto que ele deve exibir e seu estilo de fonte.

Crie três widgets de entrada e um Caixa combo para obter a entrada correspondente. Para os widgets de entrada, defina o elemento pai, o estilo da fonte e a largura. Defina o elemento pai, a lista de valores, o estilo da fonte e a largura do Caixa combo. Vincular categoria_var a ele, para que o valor selecionado seja atualizado 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)

Defina cinco botões: Adicionar despesa, Editar despesa, Excluir despesa, Economize despesas, e Mostrar gráfico de despesas. Defina o elemento pai de cada um, o texto que ele deve exibir e o comando que será executado quando você clicar nele. Crie um quadro para a caixa de listagem. Defina o elemento pai, o estilo da fonte e a largura.

Crie uma barra de rolagem vertical e coloque-a no lado direito do quadro. Use-o para percorrer o conteúdo da caixa de listagem. Organize todos os elementos com preenchimento e chamada necessários 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()

Defina a funcionalidade do Expense Tracker

Defina um método, add_expense. Recupere o valor da despesa, item, categoria e data. Se o valor da despesa e a data forem válidos, adicione a despesa ao despesas lista. Insira este registro na caixa de listagem e formate-o adequadamente. Uma vez inserido, exclua a entrada do usuário nas caixas de entrada para nova entrada.

Caso contrário, exibe um aviso de que os valores de despesa e data não podem ficar vazios. Chamar 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()

Defina um método, editar_despesa. Recupere o índice do registro selecionado e obtenha a despesa. Abra uma caixa de diálogo solicitando a inserção da despesa. Se o usuário forneceu uma nova despesa, altere a lista de despesas de acordo. Ligar para atualizar lista e 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()

Defina um método, excluir_despesa. Recupere o índice do registro selecionado e obtenha a despesa. Passe o índice da entrada que deseja excluir. Exclua essa entrada da caixa de listagem e chame o 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()

Defina um método, atualizar lista. Exclua o registro existente e adicione um novo registro com os valores atualizados.

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

Defina um método, update_total_label. Calcule a soma de todas as despesas da lista e atualize na etiqueta. Defina outro método, economizar_despesas. Crie e abra um CSV arquivo nomeado despesas.csv no modo de gravação. Adicione cabeçalhos de coluna ao arquivo CSV como a primeira linha. Itere cada registro de despesas e escreva-o como uma linha.

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

Defina um método, mostrar_despesas_gráfico. Defina um dicionário, categoria_totais. Iterar através do despesas liste e converta o valor da despesa em flutuante. Armazene o valor total das despesas para cada categoria. Se a categoria já existir no dicionário, aumente o total pelo valor da despesa atual. Caso contrário, crie uma nova entrada com o valor da despesa atual.

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

Extraia as categorias e as despesas em duas listas diferentes. Crie uma nova figura para o gráfico com o tamanho especificado. Gere um gráfico de pizza, usando a lista de despesas como dados e a lista de categorias como rótulo. O autopct parâmetro especifica o formato para exibição dos valores percentuais nas fatias do gráfico. Passar igual para eixo plt para garantir que você desenhe o gráfico de pizza como um círculo. Defina o título do gráfico de pizza e exiba-o.

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

Crie uma instância do Aplicativo ExpenseTracker aula. O loop principal() função diz ao Python para executar o loop de eventos Tkinter e ouvir eventos até você fechar a janela.

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

Teste diferentes recursos do Python Expense Tracker

Ao executar o programa, ele abrirá uma janela do aplicativo. Possui campos de entrada para registrar a despesa, a descrição do item, a categoria e a data. Insira alguns dados e clique no botão Adicionar despesa botão; você verá que o registro é adicionado à caixa de listagem. O programa também atualiza as despesas totais.

Selecione um registro e clique no botão Editar despesas botão. Uma caixa de diálogo é exibida, permitindo atualizar o registro individual.

Clicando no Excluir despesas botão para remover o registro selecionado.

Ao acertar o Mostrar gráfico de despesas botão, o programa exibe um gráfico de pizza. O gráfico de pizza exibe as despesas de cada categoria junto com seu nome e porcentagem.

Melhorando o rastreador de despesas

Você pode adicionar funcionalidade de pesquisa para permitir que os usuários encontrem despesas específicas com base em sua descrição, valor, categoria ou data. Você pode adicionar uma opção para classificar e filtrar registros. Localize o aplicativo para oferecer suporte a diferentes idiomas e formatos de moeda.

Você também pode estender o aplicativo com suporte para notificações. Deixe o usuário configurar alertas para evitar que ultrapasse os limites orçamentários ou destaque quaisquer gastos incomuns.