Projets Python Tkinter [explication étape par étape]

L'apprentissage de l'interface graphique en Python peut être assez difficile. Ne vous inquiétez pas car nous sommes là pour vous ! Dans cet article, nous avons partagé un tutoriel Tkinter afin que vous puissiez travailler efficacement sur des projets d'interface graphique Python. Après avoir terminé ce didacticiel, vous serez familiarisé avec les blocs de construction pour créer des projets Python Tkinter. Si vous souhaitez acquérir plus d'expertise en python, consultez nos programmes de science des données.

Nous avons également partagé le code pour chaque étape. Cependant, nous vous recommandons de ne le copier et le coller que lorsque vous comprenez son fonctionnement. Sinon, ça ne servirait pas à grand chose.

Qu'est-ce que Tkinter ?

Tkinter est un package permettant à Python d'utiliser la boîte à outils Tk GUI. Vous pouvez utiliser Tkinter pour créer des programmes GUI via Python. Bien que Tkinter soit capable de produire de nombreux programmes, vous devrez peut-être utiliser des modules pour des implémentations avancées. Vous devez être familiarisé avec les bases de Tkinter avant de travailler sur des projets Python Tkinter :

Un programme Hello World dans Tkinter

Voici un exemple de programme hello world dans Tkinter :

importer tkinter en tant que tk

application de classe (tk.Frame):

def __init__(self, master=None):

super().__init__(maître)

self.master = maître

self.pack()

self.create_widgets()

def create_widgets(self):

self.hi_there = tk.Button(soi)

self.hi_there["text"] = "Hello World\n(click me)"

self.hi_there["commande"] = self.say_hi

self.hi_there.pack(side="top")

self.quit = tk.Button(self, text=”QUIT”, fg=”red”,

commande=self.master.destroy)

self.quit.pack(side="bottom")

def say_hi(self):

imprimer ("salut tout le monde !")

racine = tk.Tk()

app = Application (maître = racine)

app.mainloop()

Gestionnaires de géométrie dans Tkinter

Un autre concept principal que vous devez connaître lorsque vous travaillez sur des projets Python Tkinter est celui des gestionnaires de géométrie. Sans utiliser un gestionnaire de géométrie, vos widgets n'apparaîtraient pas à l'écran. Il existe principalement trois façons d'ajouter un gestionnaire de géométrie :

Grille

Il ajoute une grille au parent et lui permet d'afficher les widgets en conséquence. La grille comporte des lignes et des colonnes pour mesurer la longueur et la hauteur de ses widgets.

Pack

Cette méthode indique au widget de se regrouper dans le parent. Il ajoute uniquement le widget à une liste de widgets enfants pour le parent. En termes simples, il les ajoute à un bloc avant de les placer dans un widget parent.

Lieu

Cette méthode place les widgets à un emplacement spécifique en fonction du widget parent.

Dans notre tutoriel ci-dessous, nous avons utilisé le gestionnaire de packs pour gérer la position de nos widgets. C'est pourquoi il serait préférable que vous connaissiez ces concepts. Cela vous aiderait à mieux comprendre le fonctionnement de notre projet.

Checkout : 42 idées et sujets de projets Python passionnants pour les débutants

Construire une interface graphique en Python (tutoriel Tkinter)

Étape 1 : Importation du module

Pour commencer à travailler sur l'application, nous devons d'abord importer le module nécessaire. Vous pouvez le faire en important le module dans votre espace de noms. Cela vous permettrait d'utiliser les constantes et les classes par leurs noms au lieu de les qualifier. Cela signifie que vous pouvez utiliser "Label" en utilisant son nom au lieu de le qualifier de "TkinterLabel". Cela rendrait les choses relativement faciles et vous permettrait de gagner beaucoup de temps car la qualification de chaque classe et constante peut être très fastidieuse. Utilisez le code suivant pour importer le module :

>>> depuis l'import Tkinter *

Si Python n'est pas lié à Tk (ou Tcl) dans votre système ou si Tk (ou Tcl) n'est pas installé sur votre système, vous verrez un message d'erreur dans cette section. Pour résoudre ce problème, vous auriez besoin de l'administrateur de votre système pour l'accès. Assurez-vous de résoudre ce problème en faisant de même.

En revanche, si vous ne voyez aucun message d'erreur dans ces sections, vous pouvez passer à l'étape suivante pour créer une fenêtre :

>>> gagner = Tk()

Nous avons attribué à notre fenêtre la variable "gagner". Après avoir implémenté le code ci-dessus, vous verriez une petite fenêtre à l'écran. Sa barre de titre doit afficher "tk" écrit dedans.

Cela signifie que vous avez terminé cette étape avec succès et que vous pouvez maintenant commencer à créer une interface graphique en Python.

Étape 2 : Ajouter des boutons

Maintenant que notre Tkinter fonctionne, nous pouvons ajouter des boutons à notre programme. Les boutons sont la section la plus simple de tout programme GUI, nous allons donc commencer par eux :

>>> b1 = Bouton(gagner, texte=”Un”)

>>> b2 = Bouton(gagner, text=”Deux”)

La fenêtre que nous avons créée dans la dernière section est le parent des boutons que nous avons créés maintenant. Au fur et à mesure que vous travaillerez sur d'autres projets Python Tkinter, vous constaterez que les cadres peuvent également servir de parents pour d'autres classes. Maintenant, lorsque vous implémentez ce code, vous remarquerez une occurrence étrange - Les boutons n'apparaissent pas dans la fenêtre !

C'est parce que nous devons ajouter une grille et un pack à notre programme. Ils sont appelés gestionnaires de géométrie, et nous en avons parlé plus tôt dans cet article. Nous ajouterons le gestionnaire de packs dans notre prochaine section :

Étape #3 : Implémenter le gestionnaire de packs

Nous allons utiliser la méthode pack pour ajouter nos boutons au widget parent. Avec le gestionnaire de pack, vous pouvez indiquer de quel côté du widget parent vous souhaitez que votre widget enfant soit compressé. Vous pouvez utiliser TOP, RIGHT, BOTTOM, LEFT comme fonctions. Le programme sélectionne TOP par défaut si vous ne spécifiez pas de côté. Ajoutons d'abord le gestionnaire de pack :

>>> b1.pack()

>>> b2.pack()

Lorsque vous ajoutez le premier bouton (première ligne du code), vous remarquerez que votre fenêtre se rétrécit à la taille du bouton. De même, lorsque vous ajoutez le deuxième bouton (deuxième ligne du code), la fenêtre s'agrandit en fonction de la taille de ce bouton. La fenêtre a placé les boutons dans l'ordre vertical car nous n'avons pas spécifié de quel côté ils doivent être placés. Emballons-les sur la gauche en utilisant le code ci-dessous :

>>> b2.pack(côté=GAUCHE)

>>> b1.pack(côté=GAUCHE)

Notez que nous utilisons le gestionnaire de packs principalement lorsque nous devons placer nos widgets dans ces deux ordres (horizontal et vertical) uniquement. Pour les autres types de placements de widgets, nous utilisons la méthode de la grille ou la méthode de la place. Vous pouvez ajouter de l'espace entre les boutons et la fenêtre en utilisant les fonctions 'padx' ou 'pady'. La fonction 'padx' ajoute un rembourrage à l'axe X (gauche et droite) du widget, et la fonction 'pady' ajoute un rembourrage à l'axe Y (haut et bas) de l'appareil.

>>> b1.pack(côté=GAUCHE, padx=10)

>>> b2.pack(côté=GAUCHE, padx=10)

Nous vous recommandons d'expérimenter le rembourrage des widgets. Cela vous aiderait à comprendre les différentes manières dont vous pouvez modifier le placement des widgets. Le rembourrage est un concept difficile à maîtriser, il serait donc préférable de l'essayer avant de passer à la section suivante.

Étape #4 : Le gestionnaire de grille

Un autre gestionnaire de géométrie populaire dans Tkinter est le gestionnaire de grille. Comme nous l'avons vu précédemment dans notre article, le gestionnaire de grille vous permet de diviser le parent en lignes et en colonnes. Vous pouvez placer les widgets enfants dans les cellules de la grille du parent. Vous pouvez modifier la largeur et la longueur de chaque colonne et ligne en fonction de vos besoins. Toutes les colonnes ne doivent pas nécessairement avoir la même largeur. De même, chaque ligne n'a pas besoin d'avoir la même hauteur. Ainsi, le gestionnaire de grille vous donne plus de liberté créative en termes de modification de l'apparence et du placement de vos widgets.

Nous allons créer une nouvelle fenêtre avec les mêmes boutons que nous avons créés auparavant pour tester le gestionnaire de grille. Cependant, nous ajouterons les boutons dans une grille 2×2 :

>>> gagner = Tk()

>>> b1 = Bouton(gagner, texte=”Un”)

>>> b2 = Bouton (gagner, texte = "Deux")

>>> b1.grid(ligne=0, colonne=0)

>>> b2.grid(ligne=1, colonne=1)

Vous remarquerez que notre programme a laissé des cellules vides. C'est parce que nous n'avons rien ajouté à la ligne 0, à la colonne 1 (ou à la ligne 1 et à la colonne 0). Nous allons essayer un nouveau widget pour voir quelque chose d'intéressant :

>>> l = Label(win, text="Ceci est un label")

>>> l.grid(ligne=1, colonne=0)

Une fois que vous avez ajouté le code ci-dessus, vous remarquez que le deuxième bouton se déplace vers la droite pour s'adapter au texte. Il serait préférable d'essayer le gestionnaire de grille avec plusieurs widgets pour voir comment il fonctionne.

Doit lire: Django Developer Salaire en Inde

Étape #5 : Amélioration de la mise en page

Dans cette section, nous allons essayer un nouveau widget appelé frame. Un cadre ne sert qu'à contenir d'autres widgets. Vous pouvez regrouper plusieurs widgets dans un cadre ou utiliser une grille pour les placer dans le même. Vous pouvez également regrouper différents cadres dans un seul cadre. Cette fonctionnalité vous permet de créer des mises en page avancées pour votre programme GUI. Par exemple, nous allons ajouter trois boutons à un cadre à la suite. Ajoutez les boutons horizontalement puis emballez l'étiquette verticalement avec le cadre :

>>> gagner = Tk()

>>> f = Cadre (gagner)

>>> b1 = Bouton(f, "Un")

>>> b2 = Bouton(f, "Deux")

>>> b3 = Bouton(f, "Trois")

>>> b1.pack(côté=GAUCHE)

>>> b2.pack(côté=GAUCHE)

>>> b3.pack(côté=GAUCHE)

>>> l = Label(win,"Cette étiquette est sur tous les boutons")

>>> l.pack()

>>> f.pack()

Comme nous l'avons vu précédemment dans l'article, vous pouvez également utiliser la méthode place comme gestionnaire de géométrie. La méthode de placement vous permet de placer des widgets à un emplacement spécifique dans une fenêtre ou un cadre. Cependant, nous vous déconseillons d'utiliser fréquemment la méthode de localisation car elle limite la réactivité du programme.

Avec la fonction de grille, vous pouvez utiliser le paramètre 'sticky' qui vous permet d'utiliser les coordonnées de la carte (S, N, W, SW, NE, etc.) pour spécifier les emplacements des widgets. Avant de passer à la section suivante, assurez-vous que vous comprenez les fonctions dont nous avons déjà parlé. Testez la grille et le cadre fonctionne ensemble pour voir comment vous pouvez l'utiliser dans d'autres projets d'interface graphique Python.

Étape 6 : Rendre les boutons utiles

Si vous cliquez sur les boutons que nous avons créés jusqu'à présent, vous devez avoir remarqué qu'ils ne répondent pas (ils ne font rien). Ils s'abaissent lorsque vous cliquez et mettez en surbrillance lorsque vous les survolez, mais ils n'exécutent aucune fonction. Pour que nos boutons exécutent des fonctions spécifiques, nous devrons utiliser la fonction 'configurer'.

Nous pouvons passer n'importe quel argument de mot-clé à la méthode 'configure' d'un widget pour le passer lors de sa création. Voici un exemple :

>>> b1.configure(text=”Uno”)

Le paramètre 'command' lie les boutons aux fonctions de rappel lorsque vous les créez ou leur ajoutez 'configure'. Pour comprendre comment cela fonctionne, nous allons créer une fonction qui imprime un message :

>>> def but1() :

… print("Le bouton un a été appuyé")

…

>>> b1.configure(commande=but1)

Ainsi, lorsque vous cliqueriez sur le bouton correspondant, un message serait imprimé.

Étape n ° 7 : Ajouter des widgets d'entrée

Les widgets d'entrée permettent aux utilisateurs de saisir du texte dans le programme. Cependant, nous devions rendre le widget d'entrée fonctionnel comme nous l'avons fait avec les boutons. Un widget d'entrée doit récupérer (et définir) du texte. Pour que le widget d'entrée exécute cette fonction, vous devez utiliser l'objet Tkinter "StringVar". L'objet 'StringVar' contient le texte sous la forme d'une chaîne et le rend lisible via get.

Nous allons créer une nouvelle fenêtre pour tester nos widgets d'entrée :

>>> gagner = Tk()

>>> v = StringVar()

>>> e = Entrée(gagner, textevariable=v)

>>> e.pack()

Ajoutons maintenant "ceci est un test" comme entrée et récupérons la même chose via StringVar :

>>> v.get()

"c'est un test"

Vous pouvez maintenant définir le texte dans StringVar et le faire apparaître dans le widget :

>>> v.set("ceci est défini à partir du programme")

Widget supplémentaire : le widget Listbox

Outre le widget d'entrée, nous pouvons ajouter un widget listbox. Un widget de liste déroulante permet à l'utilisateur de choisir un élément dans un menu. Nous allons créer une nouvelle fenêtre pour essayer le widget listbox :

>>> gagner = Tk()

>>> lb = Listbox(gagner, hauteur=3)

>>> lb.pack()

>>> lb.insert(END, "première entrée")

>>> lb.insert(END, "deuxième entrée")

>>> lb.insert(FIN, "troisième entrée")

>>> lb.insert(END, "quatrième entrée")

Vous pouvez insérer des éléments au début, au milieu et à la fin de la liste. Vous pouvez également les supprimer. S'il y a trop d'éléments dans la liste, vous pouvez ajouter une barre de défilement :

>>> sb = Barre de défilement(gagner, orient=VERTICAL)

>>> sb.pack(côté=GAUCHE, remplissage=Y)

Pour rendre notre barre de défilement fonctionnelle, nous devrons utiliser des fonctions de rappel :

>>> sb.configure(commande=lb.yview)

>>> lb.configure(yscrollcommand=sb.set)

La méthode curselection vous renvoie un élément lorsque vous le sélectionnez dans la zone de liste. Il renverra un tuple vide si vous ne choisissez aucun élément.

Étape # 8 : Étapes finales

Nous utiliserons tout ce que nous avons appris dans notre tutoriel Tkinter pour créer un éditeur de liste téléphonique :

Code total

#!/usr/bin/env python3

de l'importation tkinter *

depuis l'importation de téléphones *

def which_selected() :

print("À {0}".format(select.curselection()))

return int(select.curselection()[0])

def add_entry() :

phonelist.append([fnamevar.get(), lnamevar.get(), phonevar.get()])

set_select()

def update_entry() :

phonelist[which_selected()] = [fnamevar.get(),

lnamevar.get(),

phonevar.get()]

def delete_entry() :

del phonelist[which_selected()]

set_select()

def load_entry() :

fname, lname, phone = phonelist[which_selected()]

fnamevar.set(fname)

lnamevar.set(lname)

phonevar.set(téléphone)

def make_window() :

global fnamevar, lnamevar, phonevar, sélectionnez

gagner = Tk()

frame1 = Frame(gagnant)

frame1.pack()

Label(frame1, text=”First Name”).grid(row=0, column=0, sticky=W)

fnamevar = StringVar()

fname = Entrée(frame1, textvariable=fnamevar)

fname.grid (ligne = 0, colonne = 1, collant = W)

Label(frame1, text=”Last Name”).grid(row=1, column=0, sticky=W)

lnamevar = StringVar()

lname = Entry(frame1, textvariable=lnamevar)

lname.grid(ligne=1, colonne=1, collant=W)

Label(frame1, text=”Téléphone”).grid(row=2, column=0, sticky=W)

phonevar = StringVar()

phone = Entry(frame1, textvariable=phonevar)

phone.grid(ligne=2, colonne=1, collant=W)

frame2 = Frame(win) # Rangée de boutons

frame2.pack()

b1 = Bouton(frame2, text="Add", command=add_entry)

b2 = Bouton(frame2, text=”Mettre à jour”, command=update_entry)

b3 = Button(frame2, text=”Delete”, command=delete_entry)

b4 = Button(frame2, text=”Load “, command=load_entry)

b5 = Bouton(frame2, text=”Refresh”, command=set_select)

b1.pack(côté=GAUCHE)

b2.pack(côté=GAUCHE)

b3.pack(côté=GAUCHE)

b4.pack(côté=GAUCHE)

b5.pack(côté=GAUCHE)

frame3 = Frame(win) # sélection de noms

frame3.pack()

scroll = Barre de défilement(frame3, orient=VERTICAL)

select = Listbox(frame3, yscrollcommand=scroll.set, height=6)

scroll.config(command=select.yview)

scroll.pack(côté=DROITE, remplissage=Y)

select.pack(side=LEFT, fill=BOTH, expand=1)

retour victoire

def set_select() :

phonelist.sort(clé=enregistrement lambda : enregistrement[1])

select.delete(0, FIN)

pour fname, lname, phone dans la liste téléphonique :

select.insert(END, "{0}, {1}".format(lname, fname))

gagner = make_window()

set_select()

win.mainloop()

Voici la liste téléphonique :

phonelist = [['Chris', 'Meyers', '241-343-4349'],

['Robert', 'Smith', '202-689-1234'],

['Janet', 'Jones', '609-483-5432'],

['Ralph', 'Barnhart', '215-683-2341'],

['Éric', 'Nelson', '571-485-2689'],

['Ford', 'Préfet', '703-987-6543'],

['Marie', 'Zigler', '812-567-8901'],

['Bob', 'Smith', '856-689-1234']]

Le programme que nous avons partagé ici en est un exemple. Vous pouvez créer votre programme avec les fonctions dont nous avons parlé dans ce tutoriel Tkinter. Le programme ci-dessus manque de plusieurs fonctionnalités, telles qu'il n'a pas la possibilité d'enregistrer les modifications. Vous pouvez ajouter la fonction de sauvegarde par vous-même en créant un bouton qui peut effectuer cette tâche.

Doit lire: chaîne de Markov dans le didacticiel Python

En savoir plus sur les projets Python et Python GUI

Travailler sur des projets Python Tkinter peut être assez amusant si vous savez ce que vous faites. Ils sont également un excellent moyen de comprendre vos points forts (et vos points faibles). Vous pouvez en savoir plus sur Python ; nous vous recommandons de vous rendre sur notre blog. Voici quelques ressources pour aller plus loin :

• 10 projets d'interface graphique Python
• Comment faire un chatbot en Python
• 42 idées de projets Python

Que pensez-vous de ce projet ? Avez-vous travaillé sur d'autres projets Python Tkinter ? Faites le nous savoir.

Si vous êtes curieux d'en savoir plus sur la science des données, consultez le programme Executive PG en science des données de IIIT-B & upGrad qui est créé pour les professionnels en activité et propose plus de 10 études de cas et projets, des ateliers pratiques, un mentorat avec des experts de l'industrie, 1 -on-1 avec des mentors de l'industrie, plus de 400 heures d'apprentissage et d'aide à l'emploi avec les meilleures entreprises.