Dans le développement d’interfaces graphiques, afficher des données complexes de manière claire peut être un défi.
Une mauvaise gestion des données peut rendre l’application confuse, nuisant à l’expérience utilisateur.
Le widget Treeview de Tkinter offre une solution efficace pour structurer et présenter des données hiérarchiques de manière intuitive. Découvrez comment l’utiliser dans cet article.
Créez des interfaces graphiques interactives avec Python et TKinter !
Maîtriser Tkinter Treeview efficacement
Présentation générale du Treeview
Le widget Treeview de Tkinter est un outil puissant qui vous permet de gérer des données hiérarchisées en affichant des éléments sous forme d’arborescence. Chaque nœud peut avoir des enfants, ce qui rend ce widget particulièrement adapté pour représenter des relations parent-enfant comme dans un système de fichiers ou une hiérarchie organisationnelle. En utilisant ce widget, vous pouvez facilement structurer les informations complexes et les présenter d’une manière claire et organisée.
Création et initialisation d'un Treeview
La première étape pour intégrer un Treeview dans une application Tkinter consiste à créer une instance de ce widget et à spécifier les colonnes que vous souhaitez afficher. Vous devez d’abord définir la fenêtre principale (souvent appelée root ), puis ajouter le Treeview. Par exemple :
import tkinter as tk
from tkinter import ttk
# Initialisation de la fenêtre principale
root = tk.Tk()
root.title("Gestion des données avec Treeview")
# Création du Treeview avec des colonnes spécifiques
tree = ttk.Treeview(root,columns=("nom", "prenom", "age"))
# Placement du Treeview dans la fenêtre
tree.pack(fill=tk.BOTH,expand=True)
Ici, vous initialisez une fenêtre principale à laquelle vous ajoutez un Treeview avec trois colonnes : nom , prenom et age . Le placement de ce widget dans la fenêtre est assuré par la méthode pack() avec les paramètres fill=tk.BOTH et expand=True , qui garantissent que le Treeview occupe tout l’espace disponible dans la fenêtre. Voici le résultat d’exécution de ce code :
Configuration des en-têtes de colonnes
Une fois le Treeview créé, vous devez configurer les en-têtes pour que chaque colonne ait un titre approprié et compréhensible pour l’utilisateur. Cette étape permet de rendre vos données lisibles et organisées. Voici comment configurer les en-têtes :
import tkinter as tk
from tkinter import ttk
# Initialisation de la fenêtre principale
root = tk.Tk()
root.title("Gestion des données avec Treeview")
# Création du Treeview avec des colonnes spécifiques
tree = ttk.Treeview(root,columns=("nom", "prenom", "age"))
# Configuration des en-têtes des colonnes
tree.heading("nom",text="Nom")
tree.heading("prenom",text="Prénom")
tree.heading("age",text="Âge")
# Définition de la largeur des colonnes
tree.column("nom",width=100)
tree.column("prenom",width=100)
tree.column("age",width=50,anchor="center")
# Placement du Treeview dans la fenêtre
tree.pack(fill=tk.BOTH,expand=True)
root.mainloop()
Dans cet exemple, la méthode heading() associe chaque colonne à un titre. Ainsi, nom , prenom , et age auront respectivement « Nom », « Prénom » et « Âge » comme titre d’en-tête. De plus, la méthode column() permet de définir la largeur des colonnes pour garantir une bonne présentation des données. En fixant une largeur spécifique, vous vous assurez que chaque colonne est correctement proportionnée pour améliorer la lisibilité. Voici le résultat d’exécution de ce programme :
Insertion et gestion des données hiérarchiques
Insertion de données dans le Treeview
Maintenant que votre Treeview est configuré, vous pouvez y insérer des données. Le processus d’insertion de données dans le Treeview est simple et s’effectue à l’aide de la méthode insert() . Voici un exemple d’utilisation de cet méthode :
import tkinter as tk
from tkinter import ttk
root = tk.Tk()
root.title("Gestion des données avec Treeview")
tree = ttk.Treeview(root,columns=("nom", "prenom", "age"))
tree.heading("nom",text="Nom")
tree.heading("prenom",text="Prénom")
tree.heading("age",text="Âge")
tree.column("nom",width=100)
tree.column("prenom",width=100)
tree.column("age",width=50,anchor="center")
# Insertion de données dans le Treeview
tree.insert("", "end",text="1",values=("Dupont", "Jean", 25))
tree.insert("", "end",text="2",values=("Martin", "Claire", 30))
tree.insert("", "end",text="3",values=("Durand", "Pierre", 22))
# Placement du Treeview dans la fenêtre
tree.pack(fill=tk.BOTH,expand=True)
root.mainloop()
Dans cet extrait de code, on a insérez trois lignes représentant des individus avec un nom, un prénom et un âge. Voici le détail des arguments de la méthode insert() :
- Premier argument » » :Cela indique que ces éléments sont ajoutés à la racine de l’arbre, c’est-à-dire sans parent. Si vous souhaitez ajouter ces items sous un autre élément, vous passeriez l’ID de cet élément parent ici.
- Deuxième argument »end » :Ce paramètre indique que chaque nouvelle ligne sera ajoutée à la fin de la liste des éléments dans le Treeview.
- Paramètretext= »1″ :Ce texte représente l’étiquette principale de l’item dans la hiérarchie de l’arbre. Par défaut, il s’affiche dans la première colonne si aucun autre contenu n’est défini dans cette colonne. Il est surtout utile dans les cas où vous gérez une hiérarchie (avec des éléments parents et enfants).
- Paramètrevalues=(« Dupont », « Jean », 25) :Ce tuple contient les valeurs des autres colonnes définies dans le Treeview. Dans ce cas, les données »Dupont », »Jean »et25sont respectivement placées dans les colonnes « Nom », « Prénom », et « Âge ».
Ainsi, chaque appel à insert() ajoute une nouvelle ligne avec les données spécifiées, Comme il est montré dans la figure suivante :
Ajout de branches (nœuds parents et enfants)
Le Treeview ne se limite pas à une liste simple. Vous pouvez créer des nœuds parents et ajouter des enfants pour former une véritable structure arborescente. Cela est particulièrement utile pour afficher des informations qui nécessitent plusieurs niveaux d’organisation.
import tkinter as tk
from tkinter import ttk
# Création de la fenêtre principale
root = tk.Tk()
root.title("Gestion des données avec Treeview")
# Configuration du Treeview avec des colonnes
tree = ttk.Treeview(root,columns=("nom", "prenom", "age"))
tree.heading("nom",text="Nom")
tree.heading("prenom",text="Prénom")
tree.heading("age",text="Âge")
tree.column("nom",width=150)
tree.column("prenom",width=150)
tree.column("age",width=50,anchor="center")
# Insertion d'un nœud parent
parent_id = tree.insert("", "end",text="4",values=("Collègues de bureau", "", ""))
# Insertion d'enfants sous le nœud parent
tree.insert(parent_id, "end",text="5",values=("Lefèvre", "Sophie", 28))
tree.insert(parent_id, "end",text="6",values=("Bernard", "Luc", 35))
# Placement du Treeview dans la fenêtre
tree.pack(fill=tk.BOTH,expand=True)
# Boucle principale de l'interface graphique
root.mainloop()
Dans cet exemple, vous créez un nœud parent avec la valeur « Collègues de bureau » , puis vous ajoutez deux enfants sous ce nœud représentant des collègues individuels. Le Treeview offre ainsi une manière intuitive de représenter des groupes et sous-groupes de données. Voici le résultat d’exécution de ce code :
Interagir avec l'arborescence Tkinter
Lecture des données sélectionnées dans le Treeview
Une des fonctionnalités interactives essentielles dans l’utilisation d’un Treeview est la possibilité de lire les données sélectionnées par l’utilisateur. Cela peut se faire à l’aide de la méthode selection() , qui permet de récupérer les éléments actuellement sélectionnés. Voici un exemple de fonction qui affiche les données des lignes sélectionnées :
tree.pack(fill=tk.BOTH,expand=True)
deflire_selection():
selection = tree.selection()
if selection:
for item_id in selection:
item = tree.item(item_id)
valeurs = item["values"]
print(f"Nom: {valeurs[0]}, Prénom: {valeurs[1]}, Âge: {valeurs[2]}")
else:
print("Aucun élément sélectionné."
Dans cet exemple, la méthode selection() retourne une liste des identifiants des éléments sélectionnés. Chaque identifiant est ensuite utilisé avec la méthode item() pour accéder aux valeurs de la ligne correspondante. Ces valeurs sont ensuite affichées dans la console.
Suppression d'éléments dans le Treeview
Pour supprimer un ou plusieurs éléments dans un Treeview, vous pouvez utiliser la méthode delete() . Elle prend en paramètre l’identifiant de l’élément à supprimer. Voici un exemple :
# Suppression d'un élément sélectionné
def supprimer_element():
selection = tree.selection()
if selection:
for item_id in selection:
tree.delete(item_id)
else:
print("Aucun élément sélectionné.")
Cette fonction récupère les éléments sélectionnés avec selection() et les supprime ensuite un par un avec delete() . Cela permet à l’utilisateur de supprimer les éléments choisis de manière interactive.
Modification des données dans le Treeview
Vous pouvez également modifier les données des éléments existants dans le Treeview à l’aide de la méthode item() . Voici un exemple de modification des valeurs d’un élément sélectionné :
defmodifier_selection():
selection = tree.selection()
if selection:
for item_id in selection:
tree.item(item_id,values=("Modifié", "Nouvelle Valeur", 99))
else:
print("Aucun élément sélectionné.")
Dans cet exemple, la méthode item() est utilisée pour changer les valeurs des colonnes d’un item sélectionné. Les nouvelles valeurs remplacent celles existantes.
Récupération d'informations sur les colonnes du Treeview
La méthode heading() vous permet de configurer ou de récupérer les propriétés des en-têtes de colonnes. Vous pouvez par exemple changer le texte d’une colonne ou en obtenir les détails. Voici un exemple :
# Modifier l'en-tête d'une colonne
tree.heading("nom",text="Nom de Famille")
# Récupérer l'en-tête d'une colonne
nom_heading = tree.heading("nom")['text']
print(f"L'en-tête de la colonne 'nom' est : {nom_heading}")
Dans cet exemple, la première ligne change le texte affiché dans l’en-tête de la colonne « nom ». La deuxième ligne récupère et affiche le texte actuel de cet en-tête.
Exemple complet
Pour mieux comprendre ces différentes méthodes, voici un exemple qui récapitule les méthodes vues précédemment. Il intègre toutes les fonctionnalités abordées, à savoir : la lecture des données sélectionnées, la suppression, la modification et la gestion des en-têtes dans un Treeview.
import tkinter as tk
from tkinter import ttk
deflire_selection():
for item in tree.selection():
print("Item sélectionné:", tree.item(item, "values"))
defsupprimer_selection():
for item in tree.selection():
tree.delete(item)
defmodifier_selection():
for item in tree.selection():
tree.item(item,values=("Modifié", "Donnée modifiée", "Exemple"))
defafficher_en_tete():
print("Texte de l'en-tête de la colonne 'nom':", tree.heading('nom', 'text'))
tree.heading('nom',text="Nouveau Nom")
# Création de la fenêtre principale
root = tk.Tk()
root.title("Exemple Treeview")
# Création du Treeview avec des colonnes
tree = ttk.Treeview(root,columns=("nom", "description", "exemple"),show="headings")
tree.heading("nom",text="Nom")
tree.heading("description",text="Description")
tree.heading("exemple",text="Exemple")
# Ajout d'éléments au Treeview
tree.insert("", "end",values=("Élément 1", "Ceci est le premier élément", "Exemple 1"))
tree.insert("", "end",values=("Élément 2", "Ceci est le deuxième élément", "Exemple 2"))
tree.pack()
# Boutons pour les actions
btn_lire = tk.Button(root,text="Lire sélection",command=lire_selection)
btn_lire.pack()
btn_supprimer = tk.Button(root,text="Supprimer sélection",command=supprimer_selection)
btn_supprimer.pack()
btn_modifier = tk.Button(root,text="Modifier sélection",command=modifier_selection)
btn_modifier.pack()
btn_en_tete = tk.Button(root,text="Afficher/modifier en-tête",command=afficher_en_tete)
btn_en_tete.pack()
root.mainloop()
Dans cet exemple, une interface graphique est créée avec un Treeview affichant trois colonnes. Vous pouvez ajouter des éléments, les sélectionner, et exécuter des actions via des boutons pour lire, modifier, ou supprimer les éléments sélectionnés, ainsi que pour afficher ou modifier les en-têtes des colonnes. Voici un exemple d’utilisation de ce programme :
Dans cet exemple, on a explorer plusieurs actions possibles sur un widget Treeview, telles que la sélection, la suppression, la modification d’une ligne, ainsi que la modification de l’en-tête. Voici les étapes effectuées.
- Sélection de la première ligne :on a d’abord cliqué sur la première ligne du tableau, ce qui a permis d’afficher dans le terminal les détails de l’élément sélectionné, incluant son nom et ses valeurs. La sélection est confirmée par l’affichage dans le terminal de : Item sélectionné : (‘Élément 1’, ‘Ceci est le premier élément’, ‘Exemple 1’).
- Suppression de la ligne :Ensuite, en cliquant sur le bouton « Supprimer sélection », la ligne sélectionnée a été retirée du tableau, et le Treeview s’est actualisé pour ne plus afficher cet élément.
- Modification de la ligne :Puis, en cliquant sur « Modifier sélection », on a modifié les données de la ligne sélectionnée. Dans ce cas, le contenu de la ligne a été remplacé par les nouvelles informations, comme le montre l’interface où la colonne « Nouveau Nom » est passée à « Modifié ».
- Modification de l’en-tête :Enfin, en cliquant sur la dernière option « Afficher/modifier en-tête », vous avez modifié l’en-tête du tableau. Le texte de l’en-tête de la colonne « Nouveau Nom » a été modifié pour devenir « Nom », comme indiqué dans le terminal : Texte de l’en-tête de la colonne ‘nom’ : Nom.
Cette séquence d’actions démontre les différentes fonctionnalités de gestion de données dans un Treeview, avec des opérations comme la lecture, suppression, modification d’éléments, et la gestion des en-têtes.
Avantages du widget Treeview Tkinter
L’utilisation du widget Treeview dans Tkinter présente de nombreux avantages, surtout lorsque vous devez manipuler et afficher des données complexes de manière claire et intuitive. Voici quelques-uns des principaux avantages de ce widget :
Gestion des données hiérarchiques
Le Treeview est particulièrement efficace pour représenter des données hiérarchiques, telles que des systèmes de fichiers, des organigrammes ou des relations parent-enfant. Sa structure arborescente permet de visualiser ces relations de manière claire et ordonnée, ce qui facilite la navigation à travers plusieurs niveaux de données.
Personnalisation flexible
Le widget Treeview permet une grande flexibilité en termes de personnalisation. Vous pouvez définir plusieurs colonnes, ajouter des en-têtes personnalisés et ajuster la taille des colonnes pour améliorer la lisibilité. Cela vous permet d’adapter l’apparence du Treeview en fonction de vos besoins spécifiques et des données à afficher.
Interaction avec l'utilisateur
Le Treeview offre des fonctionnalités interactives puissantes, telles que la sélection d’éléments, la possibilité de modifier des données en temps réel, et la suppression ou l’ajout d’éléments dynamiquement. Ces interactions permettent à l’utilisateur de manipuler facilement les données, améliorant ainsi l’expérience utilisateur.
Représentation visuelle efficace
Le Treeview combine la puissance de la gestion des données tabulaires et hiérarchiques avec une présentation visuelle claire. Chaque nœud peut être développé ou réduit, ce qui permet d’afficher les informations importantes tout en maintenant une interface utilisateur concise et non surchargée. Cela réduit la complexité pour l’utilisateur final.
Polyvalence dans l'affichage des données
Le Treeview n’est pas seulement limité aux données arborescentes ; il peut également être utilisé pour afficher des données tabulaires simples. Avec la possibilité d’ajouter des colonnes multiples et de gérer des valeurs dans chaque cellule, le Treeview peut s’adapter à divers types de données, qu’il s’agisse d’une liste plate ou d’une structure plus complexe.
Facilité d'intégration dans des applications Tkinter
Le Treeview s’intègre de manière fluide dans les interfaces Tkinter, ce qui en fait un choix idéal pour les développeurs qui souhaitent une solution rapide et simple pour afficher des données structurées. Sa compatibilité avec les autres widgets Tkinter permet de l’utiliser dans des interfaces graphiques complètes et bien intégrées.
Support des grandes quantités de données
Le Treeview est capable de gérer efficacement de grandes quantités de données sans sacrifier la performance. Que vous ayez à afficher des centaines de lignes ou des structures hiérarchiques profondes, le Treeview offre une interface fluide et performante.
Formez-vous gratuitement avec Alphorm !
Maîtrisez les compétences clés en IT grâce à nos formations gratuites et accélérez votre carrière dès aujourd'hui.
FAQ
Comment créer un Treeview dans Tkinter?
Comment insérer des données dans le Treeview?
Comment configurer les en-têtes des colonnes dans un Treeview?
Comment gérer les interactions de sélection dans un Treeview?
Quels sont les avantages du widget Treeview?
Conclusion
Le widget Treeview de Tkinter est un outil puissant pour gérer des données hiérarchiques et tabulaires. En exploitant ses fonctionnalités, vous pouvez créer des interfaces utilisateur intuitives et performantes. Quelle autre fonctionnalité de Tkinter aimeriez-vous explorer pour améliorer vos applications?
