Comment créer un suivi des dépenses à l'aide de Python

Un outil de suivi des dépenses est un outil essentiel qui aide les particuliers et les entreprises à gérer leurs transactions financières. Avec un outil de suivi des dépenses, vous pouvez créer des budgets, catégoriser les dépenses et analyser les modèles de dépenses.

Découvrez comment créer une application de suivi des dépenses, avec une interface graphique multiplateforme, en Python.

Les modules Tkinter, CSV et Matplotlib

Pour créer ce suivi des dépenses, vous aurez besoin des modules Tkinter, CSV et Matplotlib.

Tkinter vous permet créer des applications de bureau. Il propose une variété de widgets tels que des boutons, des étiquettes et des zones de texte qui facilitent le développement d'applications.

Le module CSV est une bibliothèque Python intégrée qui fournit des fonctionnalités de lecture et d'écriture. Fichiers CSV (valeurs séparées par des virgules).

Avec Matplotlib, vous pouvez créer des visualisations interactives telles que des graphiques, des tracés et des diagrammes. L'utiliser avec des modules comme OpenCV peut vous aider maîtriser les techniques d'amélioration de l'image aussi.

Pour installer ces modules, exécutez :

pip install tk matplotlib 

Définir la structure de l'application Expense Tracker

Vous pouvez trouver le code source de ce projet dans son Dépôt GitHub.

Commencez par importer les modules nécessaires. Définir une classe, ExpenseTrackerApp. Définissez le titre et les dimensions. Définissez une liste pour stocker les dépenses et une autre pour les catégories. Initialiser un VarChaîne nommé catégorie_var et définissez sa valeur initiale sur la première catégorie de la liste des catégories. Terminez en appelant le créer_widgets méthode.

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

Le créer_widgets La méthode est responsable de l’ajout de composants d’interface utilisateur à votre application. Créez un cadre pour les étiquettes et les entrées du dossier de dépenses. Créez six étiquettes: une pour le titre, le montant de la dépense, la description de l'article, la catégorie, la date et la dépense totale. Définissez l'élément parent de chacun, le texte qu'il doit afficher et son style de police.

Créez trois widgets d'entrée et un Boîte combo pour obtenir l'entrée correspondante. Pour les widgets d'entrée, définissez l'élément parent, le style de police et la largeur. Définissez l'élément parent, la liste de valeurs, le style de police et la largeur du Boîte combo. Lier catégorie_var à celui-ci, de sorte que la valeur sélectionnée est automatiquement mise à jour.

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)

Définissez cinq boutons: Ajouter une dépense, Modifier les dépenses, Supprimer une dépense, Économisez des dépenses, et Afficher le tableau des dépenses. Définissez l'élément parent de chacun, le texte qu'il doit afficher et la commande qu'il exécutera lorsque vous cliquerez dessus. Créez un cadre pour la listbox. Définissez l'élément parent, le style de police et la largeur.

Créez une barre de défilement verticale et placez-la sur le côté droit du cadre. Utilisez-le pour faire défiler le contenu de la liste. Organisez tous les éléments avec le rembourrage et l'appel nécessaires 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()

Définir la fonctionnalité du suivi des dépenses

Définir une méthode, add_expense. Récupérez la valeur de la dépense, de l'article, de la catégorie et de la date. Si la valeur de la dépense et la date sont valides, ajoutez la dépense au dépenses liste. Insérez cet enregistrement dans la liste et formatez-le de manière appropriée. Une fois inséré, supprimez la saisie utilisateur dans les zones de saisie pour une nouvelle saisie.

Sinon, affichez un avertissement indiquant que les valeurs de dépense et de date ne peuvent pas être vides. Appel 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()

Définir une méthode, edit_expense. Récupérez l'index de l'enregistrement sélectionné et obtenez la dépense. Ouvrez une boîte de dialogue vous demandant de saisir la dépense. Si l'utilisateur a fourni une nouvelle dépense, modifiez la liste des dépenses en conséquence. Appeler le Rafraîchir la liste et 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()

Définir une méthode, delete_expense. Récupérez l'index de l'enregistrement sélectionné et obtenez la dépense. Passez l'index de l'entrée que vous souhaitez supprimer. Supprimez cette entrée de la liste et appelez le 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()

Définir une méthode, Rafraîchir la liste. Supprimez l'enregistrement existant et ajoutez plutôt un nouvel enregistrement avec les valeurs mises à jour.

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

Définir une méthode, update_total_label. Calculez la somme de toutes les dépenses de la liste et mettez-la à jour sur l'étiquette. Définir une autre méthode, save_expenses. Créer et ouvrir un CSV fichier nommé dépenses.csv en mode écriture. Ajoutez des en-têtes de colonne au fichier CSV comme première ligne. Parcourez chaque enregistrement de dépenses et écrivez-le sous forme de ligne.

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

Définir une méthode, show_expenses_chart. Définir un dictionnaire, catégorie_totaux. Parcourez le dépenses lister et convertir le montant de la dépense en flottant. Stockez le montant total des dépenses pour chaque catégorie. Si la catégorie existe déjà dans le dictionnaire, incrémentez le total du montant actuel de la dépense. Sinon, créez une nouvelle entrée avec le montant de la dépense actuelle.

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

Extrayez les catégories et les dépenses dans deux listes différentes. Créez une nouvelle figure pour le tracé avec la taille spécifiée. Générez un diagramme circulaire en utilisant la liste des dépenses comme données et la liste des catégories comme étiquette. Le automatique Le paramètre spécifie le format d'affichage des valeurs en pourcentage sur les tranches du graphique. Passer égal à plt.axis pour vous assurer que vous dessinez le diagramme circulaire sous forme de cercle. Définissez le titre du diagramme circulaire et affichez-le.

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

Créez une instance du ExpenseTrackerApp classe. Le boucle principale() La fonction indique à Python d'exécuter la boucle d'événements Tkinter et d'écouter les événements jusqu'à ce que vous fermiez la fenêtre.

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

Testez différentes fonctionnalités du Python Expense Tracker

Lorsque vous exécutez le programme, il lancera une fenêtre d'application. Celui-ci comporte des champs de saisie pour enregistrer la dépense, la description de l'article, la catégorie et la date. Entrez quelques données et cliquez sur le Ajouter une dépense bouton; vous verrez que l’enregistrement est ajouté à la zone de liste. Le programme met également à jour les dépenses totales.

Sélectionnez un enregistrement et cliquez sur le Modifier les dépenses bouton. Une boîte de dialogue apparaît, vous permettant de mettre à jour l'enregistrement individuel.

En cliquant sur le Supprimer les dépenses pour supprimer l'enregistrement sélectionné.

En frappant le Afficher le tableau des dépenses bouton, le programme affiche un diagramme circulaire. Le diagramme circulaire affiche les dépenses pour chaque catégorie ainsi que son nom et son pourcentage.

Améliorer le suivi des dépenses

Vous pouvez ajouter une fonctionnalité de recherche pour permettre aux utilisateurs de trouver des dépenses spécifiques en fonction de leur description, montant, catégorie ou date. Vous pouvez ajouter une option pour trier et filtrer les enregistrements. Localisez l'application pour prendre en charge différentes langues et formats de devises.

Vous pouvez également étendre l'application avec la prise en charge des notifications. Laissez l'utilisateur configurer des alertes pour l'empêcher de dépasser les limites budgétaires ou mettre en évidence toute dépense inhabituelle.