Tkinter Interface graphique Python

Tkinter (Tool kit interface) est un module présent par défaut dans python et permet de créer
des interfaces graphiques.

Présentation de Tkinter
Notez qu'il existe d'autres bibliothèques pour créer des interfaces graphiques. Tkinter a
l'avantage d'être disponible par défaut, sans nécessiter une installation supplémentaire.

Pour savoir si vous pouvez utiliser le module Tkinter via la version de Python installée sur
votre système, tapez dans l'interpréteur en ligne de commande Python :

from tkinter import *

Aucune erreur ne doit apparaitre !

Votre première interface graphique

Premier exemple avec Tkinter.
On crée une fenêtre simple avec le message « BTS SNIR ».

# On importe Tkinter, attention à la casse

from tkinter import * #tkinder en miniscule

# On crée une fenêtre, racine de notre interface

fenetre = Tk()

# On crée un label (ligne de texte) souhaitant la bienvenue

# Note : le premier paramètre passé au constructeur de Label est notre
# interface racine
champ_label = Label(fenetre, text="BTS SNIR")

# On affiche le label dans la fenêtre

champ_label.pack()

# On démarre la boucle Tkinter qui s'interrompt quand on ferme la fenêtre

[Link]()

TKINDER PAGE 1 SUR 6

Vous pouvez voir le résultat à la figure suivante.

Détails du premier exemple :

1. On commence par importer Tkinter.

2. On crée ensuite un objet de la classe Tk. La plupart du temps, cet objet sera la
fenêtre principale de notre interface.
3. On crée un Label, c'est-à-dire un objet graphique affichant du texte
4. On appelle la méthode pack de notre Label. Cette méthode permet de positionner
l'objet dans notre fenêtre (et, par conséquent, de l'afficher).
5. Enfin, on appelle la méthode mainloop de notre fenêtre racine. Cette méthode ne
retourne que lorsqu'on ferme la fenêtre.

Quelques petites précisions :

• Nos objets graphiques (boutons, champs de texte, cases à cocher, barres de

progression…) sont appelés des widgets.
• On peut préciser plusieurs options lors de la construction de nos widgets. Ici, on
définit l'option text de notre Label à "BTS SNIR".

Il existe d'autres options communes à la plupart des widgets (la couleur de fond bg, la couleur
du widget fg, etc.) et d'autres plus spécifiques à un certain type de widget. Le Label par
exemple possède l'option text représentant le texte affiché par le Label.

Les options d’un widget peuvent être définie lors de sa création.

champ_label = Label(fenetre, text="BTS SNIR")

Et/ou dans un second temps :

champ_label["text"] = "Python etc"

Il faut mettre entre crochets le nom de l'option. C'est le même principe pour accéder à la
valeur actuelle de l'option ou pour la modifier.

TKINDER PAGE 2 SUR 6

Les widgets les plus communs
Les labels
On s'en sert pour afficher du texte dans notre fenêtre, du texte qui ne sera pas modifié par
l'utilisateur.

champ_label = Label(fenetre, text="contenu de notre champ label")

champ_label.pack()

Pour qu'un widget apparaisse, il faut :

• qu'il prenne, en premier paramètre du constructeur, la fenêtre principale ;

• qu'il fasse appel à la méthode pack.

La méthode pack permet de positionner un objet dans une fenêtre ou dans un cadre.

Les boutons
Les boutons sont des widgets sur lesquels on peut cliquer et qui peuvent déclencher des
actions ou commandes.

bouton_quitter = Button(fenetre, text="Quitter", command=[Link])

bouton_quitter.pack()

Ici, c'est la méthode quit de notre fenêtre racine qui est appelée lors de l’appuie sur le
bouton.

Si vous faites des tests depuis l'interpréteur Python en ligne de commande, la fenêtre Tk reste
ouverte tant que la console reste ouverte. Le bouton Quitter interrompt la boucle main
loop mais ne ferme pas l'interface (contrairement à la méthode destroy)

Une ligne de saisie

C’est une zone de texte (une ligne) dans lequel l'utilisateur peut écrire.

Entree = Entry(Fenetre) # On définit l'objet Entry qui a le nom Entree

[Link]() # On place "Entree"

Pour récupérer le contenu d’Entry :

reponse = Entry(Fenetre)
affichage['text'] = [Link]() # contenu du widget "reponse"
[Link]()

Il existe également le widget Text qui représente un champ de texte à plusieurs lignes.

TKINDER PAGE 3 SUR 6

Les cases à cocher
Les cases à cocher sont définies dans la classe Checkbutton. On utilise une variable pour
surveiller la sélection de la case.

Pour surveiller l'état d'une case à cocher (qui peut être soit active soit inactive), on crée une
variable de type IntVar .

var_case = IntVar()
case = Checkbutton(fenetre, text="Accepter", variable=var_case)
[Link]()

Vous pouvez ensuite contrôler l'état de la case à cocher en interrogeant la variable :

var_case.get()

Si la case est cochée, la valeur renvoyée par la variable sera 1.

Si elle n'est pas cochée, ce sera 0.

Comme pour un bouton, vous pouvez lier la case à cocher à une commande qui sera appelée
quand son état change.

Les boutons radio

Les boutons radio (radio buttons en anglais) sont des boutons généralement présentés en
groupes. C'est un ensemble de cases à cocher mutuellement exclusives : quand vous cliquez
sur l'un des boutons, celui-ci se sélectionne et tous les autres boutons du même groupe se
désélectionnent.

Pour créer un groupe de boutons, il faut simplement qu'ils soient tous associés à la même
variable (une variable Tkinter).

Quand l'utilisateur change le bouton sélectionné, la valeur de la variable change en fonction

de l'option value associée au bouton :

var_ch = StringVar()

choix_noir = Radiobutton(fen, text="Noir", variable=var_ch, value="noir")

choix_vert = Radiobutton(fen, text="Vert", variable=var_ch, value="vert")
choix_bleu = Radiobutton(fen, text="Bleu", variable=var_ch, value="bleu")

choix_noir.pack()
choix_vert.pack()
choix_bleu.pack()

Pour récupérer la valeur associée au bouton sélectionné :

var_ch.get()

TKINDER PAGE 4 SUR 6

Les listes déroulantes
Ce widget permet de construire une liste dans laquelle on peut sélectionner un ou plusieurs
éléments. Le fonctionnement n'est pas tout à fait identique aux boutons radio. Ici, la liste
comprend plusieurs lignes et non un groupe de boutons.

Créer une liste :

liste = Listbox(fenetre)
[Link]()

On insère ensuite des éléments. La méthode insert prend deux paramètres :

1. La position à laquelle insérer l'élément ;

2. L’élément même, sous la forme d'une chaîne de caractères.

Pour insérer des éléments à la fin de la liste, utilisez la constante END définie par Tkinter :

[Link](END, "Pierre")
[Link](END, "Feuille")
[Link](END, "Ciseau")

Pour accéder à la sélection, utilisez la méthode curselection de la liste. Elle renvoie la

position de l'élément sélectionné.

Par exemple, si [Link]() renvoie('2'), c'est le troisième élément de la liste qui

est sélectionné (Ciseau dans notre cas).

Organiser ses widgets dans la fenêtre

Il existe plusieurs widgets qui peuvent contenir d'autres widgets comme Frame.

C'est un cadre rectangulaire dans lequel on peut placer des widgets et d’autres Frame si
besoin.

Pour avoir un cadre, il faut utiliser le Frame comme parent à la création du widget :

fenetre = Tk()
[Link]("700x500") #la fenêtre doit être plus grande que le frame
cadre = Frame(fenetre, width=500, height=300, borderwidth=10, bg=’red’)
[Link](fill=BOTH)

message = Label(cadre, text="Notre fenêtre")

[Link](side="top", fill=X)
[Link]()

TKINDER PAGE 5 SUR 6

Dans notre cas, il y a plusieurs arguments utilisés dans la méthode pack.

side="top", le widget est placé en haut de son parent (ici, notre cadre).

Il existe aussi l'argument nommé fill qui permet au widget de remplir le widget parent, soit
en largeur si la valeur est X(majuscule), soit en hauteur si la valeur est Y, soit en largeur et
hauteur si la valeur est BOTH.

Il existe aussi le widget Labelframe, un cadre avec un titre, ce qui évite d'avoir à placer un
label en haut du cadre. Il se construit comme un Frame mais peut prendre en argument, à
la construction, le texte représentant le titre :

cadre = Labelframe(..., text="Titre du cadre")

D'autres widgets
Il existe de nombreux autres widgets de Tkinter et de nombreuses autres options des widgets
vus précédemment.

Il est notamment possible de créer une barre de menus avec ses menus imbriqués, d'afficher
des images, des canvas dans lesquels on peut dessiner pour personnaliser une fenêtre.

Les commandes
bouton_quitter = Button(fenetre, text="Quitter", command=[Link])

L’argument a pour nom command et a pour valeur la méthode quit de notre fenêtre.

Sur ce modèle, on peut créer des commandes personnalisées, en écrivant des méthodes.

La méthode que nous devons créer ne prend aucun paramètre.

Si nous voulons qu'un clic sur le bouton modifie le bouton lui-même ou un autre objet, nous
devons placer nos widgets dans un corps de classe. Hormis des phases de tests, il est
préférable de mettre le code dans une classe.

On peut la faire hériter de Frame, ce qui signifie que notre classe sera un widget elle aussi.

TKINDER PAGE 6 SUR 6