Tutoriel de prise en main de Tkinter pour Python

Tkinter est l’abréviation de « Tk interface » : le paquet du même nom sur de nombreuses distributions Linux fournit les liaisons Python pour la boîte à outils Tcl/Tk GUI. Bien que d’autres boîtes à outils graphiques puissent être utilisées à partir de Python, comme Qt ou GTK, Tkinter est la norme (l’éditeur Python IDLE et l’environnement de développement sont écrits à l’aide de cette boîte à outils, par exemple) et probablement le plus facile à utiliser. Dans ce tutoriel, nous voyons les concepts de base derrière l’utilisation de Tkinter et comment créer et interagir avec certains des widgets les plus utilisés.

Dans ce tutoriel, vous allez apprendre :

Comment installer Tkinter sur les distributions Linux les plus utilisées
Comment créer la fenêtre racine
Comment ajouter un widget à la fenêtre racine
Comment spécifier une action de bouton
Comment utiliser les variables de contrôle
Comment créer des widgets de saisie, d’étiquette, de case à cocher et de radio
Les méthodes du gestionnaire d’agencement de paquets, de grilles et de lieux

Configuration logicielle requise et conventions utilisées

Installation de Tkinter

Bien que Python soit installé par défaut dans le cadre des systèmes Linux les plus minimaux, Tkinter n’est pas fourni avec lui ; cependant, il est inclus dans les dépôts officiels de pratiquement toutes les distributions Linux les plus utilisées, il est donc très facile à installer. Voyons comment. Supposons que nous utilisions Fedora comme pilote quotidien, pour installer Tkinter, nous exécuterions :

sudo dnf install python3-tkinter

Si au lieu de cela, nous fonctionnons sur Debian, Ubuntu ou l’un de leurs dérivés, le paquet s’appelle python3-tk, et peut être installé en exécutant :

sudo apt-get update && sudo apt-get install python3-tk

Sur Archlinux, pour installer Tkinter, il suffit d’extraire le paquet tk. Pour accomplir la tâche, nous utilisons le gestionnaire de paquets pacman, et exécutons :

sudo pacman -Sy tk

Une fois l’installation effectuée sans problème, nous ouvrons un terminal et exécutons la commande suivante :

python3 -m tkinter

La fenêtre de démonstration suivante doit apparaître :

Si nous cliquons sur le bouton avec le texte « QUITTER », la fenêtre sera fermée ; si nous cliquons sur le bouton "Cliquez sur moi ! ", au lieu de cela, nous pouvons voir comment le texte du bouton lui-même va changer.

La fenêtre Racine

Commençons par les bases. Pour créer une interface utilisateur graphique avec Tkinter et python, la première chose que nous devons faire, comme vous pouvez l’imaginer, est d’importer le module tkinter. Une fois le module importé, nous devons créer la fenêtre racine. Tous les widgets que nous utiliserons auront finalement cette fenêtre comme parent. Une fenêtre racine est obtenue en créant une instance de la classe Tk :

import tkinter

if __name__ == '__main__':
  root = tkinter.Tk()

Nous avons maintenant notre fenêtre racine, cependant, si nous essayons d’exécuter le script, rien ne s’affiche. En effet, nous devons démarrer ce que l’on appelle la boucle d’événements. La boucle d’événements est une boucle qui s’exécute tant que la fenêtre racine n’est pas détruite, afin que l’application puisse gérer tous les événements tels que le clic d’un bouton. Pour démarrer la boucle d’événements, tout ce que nous avons à faire est d’appeler la méthode mainloop sur l’objet racine :

import tkinter

if __name__ == '__main__':
  rootwindow = tkinter.Tk()
  rootwindow.mainloop()

Si nous essayons de relancer le script à ce stade, nous devrions visualiser la fenêtre suivante :

L’apparence actuelle de notre interface graphique est assez inutile, admettons-le. Ce que nous pouvons faire pour le rendre plus utile, c’est d’y ajouter un bouton. Voyons comment faire.

Ajout d’un bouton à la fenêtre racine

D’abord le code, puis les explications :

import tkinter

if __name__ == '__main__':
  rootwindow = tkinter.Tk()
  button = tkinter.Button(rootwindow, text="Click me!")
  button.pack()

  rootwindow.mainloop()

Analysons le code que nous avons ajouté ci-dessus. Nous avons généré le bouton en créant une instance du tkinter. Classe de bouton. Le premier argument que nous passons au constructeur d’une classe widget est une référence à son parent, qui dans ce cas est la fenêtre racine elle-même. Nous avons également utilisé l’argument text pour spécifier le texte qui doit être visualisé sur le bouton.

Après avoir créé l’instance de la classe Button, nous avons appelé la méthode pack sur celle-ci ; Ceci est essentiel pour que le widget s’affiche. Cette méthode est l’une des trois que nous pouvons utiliser pour gérer la géométrie et la disposition d’un widget. Nous en reparlerons dans un instant. Pour l’instant, essayons de relancer notre script, et voyons ce que nous obtenons :

Comme prévu, le widget de bouton est visualisé avec le texte que nous avons spécifié dans notre code. Si nous cliquons dessus, cependant, rien ne se passe et un bouton qui n’effectue aucune action n’a aucun sens.

Spécification de l’action du bouton

Comment spécifier l’action ou la commande qui doit être exécutée lorsque l’utilisateur clique sur un bouton ? Tout ce que nous avons à faire est d’utiliser l’argument command du constructeur de la classe Button. À titre d’exemple, disons que nous voulons changer la couleur d’arrière-plan de la fenêtre racine lorsque le bouton est cliqué. Modifions notre code :

import tkinter

def change_root_background_color():
    rootwindow.config(background="red")

if __name__ == '__main__':
    rootwindow = tkinter.Tk()
    button = tkinter.Button(rootwindow,text='Click me!',command=change_root_background_color)
    button.pack(pady=10)
    rootwindow.mainloop()

Voyons quels changements nous avons apportés. Tout d’abord, nous avons ajouté l’argument command au constructeur de la classe Button. En tant que valeur du paramètre de commande, nous avons passé une fonction, qui est exécutée lorsque l’événement click est reçu. Un autre changement que nous avons fait, a été d’utiliser le paramètre pady de la méthode pack : ce changement est purement esthétique, et est nécessaire pour ajouter un remplissage vertical (axe y) exprimé en pixels, au widget. Nous l’avons fait pour pouvoir visualiser l’arrière-plan de la fenêtre racine.

À l’intérieur du change_root_background_color, nous avons écrit le code nécessaire pour changer la couleur d’arrière-plan de la fenêtre racine. L’apparence d’une fenêtre ou d’un widget peut être spécifiée à l’aide de nombreux paramètres lors de l’initialisation de la classe appropriée, ou plus tard à l’aide de la méthode config. Pour spécifier la couleur d’arrière-plan, nous utilisons le paramètre background (il peut être abrégé en bg), et passons la couleur que nous voulons utiliser comme valeur. Dans ce cas, nous avons utilisé le rouge, le nom de la couleur, cependant, nous aurions également pu utiliser sa représentation hexadécimale (« #FF0000 »).

Si nous lançons maintenant notre script, et que nous cliquons sur le bouton, nous obtenons le résultat suivant :

Dans l’exemple précédent, en tant que valeur du paramètre de commande, nous avons passé le nom de la fonction à exécuter lors de la réception de l’événement click. Cette fonction n’accepte aucun argument, car la couleur « rouge » y est codée en dur. Et s’il acceptait la couleur à utiliser comme argument ? Comment pourrions-nous le passer lors de la spécification de la commande ? Dans de tels cas, nous voulons utiliser une fonction en ligne lambda, ou anonyme :

import tkinter

def change_root_background_color(color):
    rootwindow.config(background=color)

if __name__ == '__main__':
    rootwindow = tkinter.Tk()
    button = tkinter.Button(rootwindow,text='Click me!',command=lambda: change_root_background_color("red"))
    button.pack(pady=10)
    rootwindow.mainloop()

Comme la commande à exécuter est très simple et ne contient aucune logique complexe, en utilisant la fonction lambda, nous pourrions simplifier notre code et supprimer complètement la fonction change_root_background_color :

import tkinter

if __name__ == '__main__':
    rootwindow = tkinter.Tk()
    button = tkinter.Button(rootwindow, text='Click me!', command=lambda: rootwindow.config(background="red"))
    button.pack(pady=10)
    rootwindow.mainloop()

Variables de contrôle

Dans les exemples précédents, nous avons vu l’utilisation de base d’un widget de bouton. Le bouton que nous avons créé ne répond qu’à l’événement de clic ; D’autres, comme le widget d’entrée, permettent à l’utilisateur d’entrer une valeur. On peut créer un widget « entry " en instanciant le tkinter. Classe d’entrée. Supposons que nous voulions créer un champ pour permettre à l’utilisateur d’entrer son nom ; Nous écririons :

  username_entry_widget = tkinter.Entry(rootwindow)

Le widget créé se présente comme suit :

À ce stade, une question devrait se poser. Dans notre code, comment pouvons-nous obtenir le texte que l’utilisateur saisit dans le widget ? Nous pouvons le faire en utilisant des variables de contrôle. Les variables de contrôle sont créées à l’aide des classes suivantes :

StrinVar
IntVar
DoubleVar
BooleanVar

Le nom des classes est assez explicite. Ce qu’il faut utiliser dépend du type de données dont nous avons besoin. La valeur associée à une variable de contrôle peut être récupérée à l’aide de la méthode get. Le type de variable renvoyé par la méthode dépend de la classe utilisée. Comme vous pouvez vous y attendre, StringVar.get renvoie une chaîne de caractères, IntVar.get renvoie un entier, DoubleVar.get renvoie un nombre flottant et BooleanVar.get renvoie une valeur booléenne.

Lorsqu’une variable de contrôle est associée à un widget, elles sont synchronisées avec celui-ci, donc si la valeur de la variable change (nous pouvons utiliser la méthode set pour changer sa valeur dans notre code), le contenu du widget est mis à jour, et vice-versa :

  username_var = tkinter.StringVar()
  username_entry_widget = tkinter.Entry(rootwindow, textvariable=username_var)

Nous avons associé la variable de contrôle au widget via le paramètre constructeur textvariable (dans d’autres widgets, comme les cases à cocher ou la radio, nous utiliserions le paramètre variable à la place). Pour récupérer le nom que l’utilisateur a saisi dans le widget, il suffit d’appeler :

username_var.get()

Une variable de contrôle peut également être créée avec une valeur par défaut : tout ce que nous avons à faire est de la spécifier dans le constructeur. Bien que cela n’ait pas beaucoup de sens, pour utiliser un nom par défaut pour notre variable, nous écririons :

username_var = tkinter.StringVar(value="Egidio")

Les widgets étiquette, case à cocher et radio

Nous avons brièvement vu comment créer un widget « bouton » et un widget « entrée ». D’autres widgets très souvent utilisés sont : étiquette, case à cocher et radio. Voyons comment les créer.

Pour créer un widget d’étiquette, nous devons instancier le tkinter. Classe d’étiquette. Ce type de widget est utilisé uniquement pour afficher du texte, qui peut être spécifié via l’argument text. Pour ajouter un widget d’étiquette à notre fenêtre racine, nous écririons :

label = tkinter.Label(rootwindow, text="Our first label")

Le widget de case à cocher peut être utilisé pour permettre à l’utilisateur d’effectuer un choix comme la sélection d’une certaine fonctionnalité. Nous pouvons en créer un en instanciant le tkinter. Checkbutton. Pour demander la confirmation de l’utilisateur, par exemple, on pourrait l’associer à un BooleanVar :

confirmation = tkinter.BooleanVar(value=True)
checkbox = tkinter.Checkbutton(rootwindow, text="Confirm" variable=confirmation)

La variable de confirmation associée au widget étant définie sur True, le widget apparaît comme « coché » par défaut :

Le widget du bouton radio permet à l’utilisateur d’effectuer une sélection parmi un ensemble d’options. Si plusieurs cases d’option sont associées à la même variable, une seule peut être vérifiée à la fois. Pour créer un widget de bouton radio, nous utilisons la classe Radiobutton. Supposons que nous souhaitions que l’utilisateur choisisse une couleur entre le blanc et le noir, en définissant ce dernier par défaut. Voici ce que nous pourrions écrire :

color_variable = tkinter.StringVar(value="black")
white_radio = tkinter.Radiobutton(rootwindow, text="White", variable=color_variable, value="white")
black_radio = tkinter.Radiobutton(rootwindow, text="Black", variable=color_variable, value="black")

Les méthodes du gestionnaire d’agencement de paquets, de grilles et de lieux

Nous avons vu précédemment que lorsque nous initialisons un widget via la classe appropriée, et que nous n’appelons pas la méthode pack, il n’est pas visualisé. Comme nous l’avons dit, pack est l’une des trois méthodes de gestion de mise en page disponibles. Les deux autres sont : la grille et le lieu. Voyons brièvement quelles sont les principales différences entre eux.

La méthode pack est la plus simple : elle ne doit être utilisée que dans les cas les plus simples, où une mise en page complexe n’est pas demandée, car elle empile simplement les widgets dans l’un des quatre côtés de la fenêtre. Nous avons déjà vu un exemple de son utilisation.

La méthode grid est plus moderne et nous permet de placer des widgets dans la fenêtre en utilisant une grille de lignes/colonnes comme référence. C’est le choix recommandé dans tous les cas, sauf les plus simples. Lorsque vous utilisez la méthode de la grille, nous pouvons spécifier dans quelle ligne et colonne le widget doit être placé. Par exemple, pour placer le bouton dans la deuxième colonne de la première ligne (le nombre de lignes et de colonnes est indexé par zéro), nous écririons :

button.grid(row=0, column=1)

Pour qu’un widget s’étende sur plus d’une colonne ou d’une ligne, nous utiliserons respectivement les arguments columnspan ou rowspan. Par exemple, pour que le bouton soit placé sur la première ligne et utilise deux colonnes commençant pour la première, on écrirait :

button.grid(row=0, column=0, columnspan=2)

Enfin, avec la méthode place, nous pouvons positionner explicitement un widget dans la fenêtre parente en utilisant des coordonnées statiques. Lorsque l’utilisation de cette méthode, comme vous pouvez l’imaginer, il est assez difficile de gérer des événements tels que les changements de dimension de la fenêtre parente. En utilisant la terminologie du développement web, on pourrait dire que notre mise en page ne serait pas très « responsive ».

Les méthodes du gestionnaire de mise en page ne peuvent pas être mélangées : la même doit être utilisée pour tous les widgets ayant la même fenêtre parente.

Conclusions

Dans ce tutoriel, nous avons fait nos tout premiers pas dans le monde de Tkinter, et nous avons vu comment créer des éléments d’interface graphique de base en utilisant ladite bibliothèque. Nous avons vu comment installer Tkinter sur les distributions Linux les plus utilisées, comment créer une fenêtre racine et y ajouter des widgets, comment utiliser les widgets button, entry, label, checkbox et radio et gérer les entrées utilisateur via des variables de contrôle. Enfin, nous avons vu quelles sont les méthodes de gestion de l’agencement et de la géométrie, et la différence entre elles.