1. Création d'une interface pour travailler avec des rapports
Alors, chers étudiants, il est temps de plonger dans la conception et le développement d'une interface qui nous permettra non seulement de collecter des données, mais aussi de les présenter de manière digeste et, surtout, jolie. Aujourd'hui, nous créons une application qui rend la génération et la visualisation de rapports aussi facile que de coder en Python après une tasse de café bien fort !
Construction d'une interface pour la sélection et l'affichage des rapports
Commençons par créer une interface à partir de laquelle l'utilisateur pourra choisir les rapports à afficher. L'interface inclura des boutons pour charger des données, des listes déroulantes pour choisir différents rapports et une zone pour afficher les graphiques.
import tkinter as tk
from tkinter import ttk
# Création de la fenêtre principale
root = tk.Tk()
root.title("Rapports et données")
# Ajout d'une liste déroulante pour sélectionner un rapport
report_label = ttk.Label(root, text="Choisissez un rapport :")
report_label.pack(pady=10)
report_options = ["Rapport n°1", "Rapport n°2", "Rapport n°3"]
selected_report = tk.StringVar(value=report_options[0])
report_menu = ttk.Combobox(root, textvariable=selected_report, values=report_options)
report_menu.pack(pady=10)
# Lancement de la boucle principale de l'application
root.mainloop()
En exécutant le code ci-dessus, vous verrez une fenêtre simple dans laquelle vous pouvez choisir un des rapports proposés. Bien qu'aucun graphique ne soit encore visible, ceci est la base sur laquelle nous allons construire la fonctionnalité de l'application.
2. Intégration avec des bibliothèques graphiques
Utilisation de Matplotlib pour afficher des graphiques dans l'application
Passons aux graphiques. Pour leur visualisation, nous allons utiliser la bibliothèque populaire Matplotlib. Cette bibliothèque est parfaite pour afficher des données et peut être intégrée à une application Tkinter. Tout d'abord, assurez-vous que la bibliothèque est installée :
pip install matplotlib
Ajoutons maintenant un graphique à notre interface, en utilisant FigureCanvasTkAgg pour l'intégration avec Tkinter.
from matplotlib.figure import Figure
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
# Création d'une zone pour les graphiques
def plot_report():
# Création d'un graphique de test
fig = Figure(figsize=(5, 4), dpi=100)
plot = fig.add_subplot(111)
plot.plot([1, 2, 3, 4, 5], [2, 3, 5, 7, 11]) # Exemple de données
# Intégration du graphique dans l'application Tkinter
canvas = FigureCanvasTkAgg(fig, master=root)
canvas.draw()
canvas.get_tk_widget().pack()
# Ajout d'un bouton pour construire le graphique
plot_button = ttk.Button(root, text="Construire le rapport", command=plot_report)
plot_button.pack(pady=20)
En utilisant l'exemple ci-dessus, vous pouvez afficher un graphique simple en cliquant sur le bouton "Construire le rapport". Bien sûr, ce n'est qu'un début. En pratique, vous remplacerez ce simple graphique par des données provenant de vrais rapports.
3. Application pratique
Création d'une application pour générer et visualiser des rapports avec intégration de graphiques et de données
Maintenant que nous avons une base pour notre interface avec des graphiques, nous pouvons explorer comment présenter des données de manière plus complexe et fonctionnelle. Pour cela, vous pouvez intégrer des données provenant de vos fichiers Excel ou CSV traités, et afficher toutes les formes de visualisations adaptées à votre application.
import pandas as pd
import random
def load_data():
# Exemple de génération de données aléatoires
data = pd.DataFrame({
"x": list(range(1, 11)),
"y": [random.randint(1, 10) for _ in range(10)]
})
return data
def plot_data_report():
data = load_data()
fig = Figure(figsize=(5, 4), dpi=100)
plot = fig.add_subplot(111)
plot.plot(data['x'], data['y'])
canvas = FigureCanvasTkAgg(fig, master=root)
canvas.draw()
canvas.get_tk_widget().pack()
plot_button.config(command=plot_data_report)
Exportation de rapports et données depuis l'interface vers divers formats pour une utilisation future
Pour que l'application ne soit pas seulement démonstrative mais aussi utile, il est important d'implémenter la possibilité d'exporter des données. Par exemple, dans un fichier PDF ou Excel, ce qui permettra de partager les rapports avec des collègues ou des supérieurs :
from tkinter import filedialog
import matplotlib.pyplot as plt
def export_report():
# Génération des données et création du graphique
data = load_data()
fig, ax = plt.subplots()
ax.plot(data['x'], data['y'])
# Choix du chemin de sauvegarde
file_path = filedialog.asksaveasfilename(defaultextension=".pdf",
filetypes=[("Fichiers PDF", "*.pdf"), ("Tous les fichiers", "*.*")])
if file_path:
fig.savefig(file_path)
print(f"Rapport enregistré dans {file_path}")
# Ajout d'un bouton pour l'exportation
export_button = ttk.Button(root, text="Exporter le rapport", command=export_report)
export_button.pack(pady=10)
La fonction export_report permet de choisir dans quel fichier enregistrer le graphique, et de l'enregistrer dans le format spécifié. Maintenant, votre application ne se limite pas seulement à visualiser les données, mais offre également la possibilité de les stocker de manière pratique.
Ainsi, vous avez appris à construire une interface pour travailler avec des rapports, à y intégrer des graphiques à l'aide de Matplotlib, et à ajouter des fonctionnalités d'exportation. En pratique, ces compétences sont extrêmement utiles pour développer des outils d'automatisation des rapports, d'analyse des données et de leur présentation sous une forme facile à comprendre. J'espère que ça vous a plu ! Et rappelez-vous que la vraie magie de la programmation se produit lorsque le code prend vie sous la forme d'un outil utile.
GO TO FULL VERSION