Differences between revisions 5 and 6
Revision 5 as of 2014-05-14 06:13:59
Size: 3827
Editor: 178
Comment:
Revision 6 as of 2014-05-14 06:34:29
Size: 6321
Editor: 178
Comment:
Deletions are marked like this. Additions are marked like this.
Line 64: Line 64:

=== Exercice ===

Adapter ce programme pour que le texte affiché indique combien de fois le bouton a été cliqué depuis le début.

== Utilisation de classes ==

L'exemple du bouton qui modifie le message, et plus encore l'exercice qui compte le nombre de clics, montrent qu'il est nécessaire de maintenir un ''état'' et utilise pour cela des variables globales. Cela fonctionne, mais ce n'est pas très modulaire et cela peut être source d'erreurs. Pour améliorer la situation, la bonne méthode est d'utiliser la programmation par objets en définissant une classe pour notre boîte de dialogue. On peut procéder comme ceci:

{{{#!highlight python
from tkinter import *

class Dialogue (Frame):
    def __init__(self):
        Frame.__init__(self)

        self.texte = Label(self, text="Salut!")
        self.texte.pack()

        bouton = Button(self, text="Hop", command=self.action)
        bouton.pack()

    def action(self):
        self.texte['text'] = "Message reçu!"

dialogue = Dialogue()
dialogue.pack()
dialogue.mainloop()
}}}

La classe de notre boîte de dialogue ''dérive'' de la classe `Frame` de tkinter: une boîte de dialogue est uen fenêtre principale (`Frame`) avec des propriétés supplémentaires. La méthode `__init__` sert à effectuer les opérations nécessaires à la ''construction'' du dialogue:

 * On initialise l'objet comme un `Frame` avec la première instruction.

 * On crée l'élément pour le message et le bouton et on les inclut dans le dialogue. Le nom `self` désigne par convention l'objet que l'on est en train de créer.

 * Le message est stocké dans `self.texte`: c'est une variable propre à l'objet, on pourra y faire référence depuis les autres méthodes.

La fonction qui correspond à l'action à effectuer est maintenant `self.action`: c'est la méthode `action` de l'objet qui correspond au dialogue. C'est ici que l'on a gagné quelque chose: `self.action` connaît l'objet (c'est son premier argument, `self`) et elle peut donc accéder au champ `texte`, sans avoir besoin d'une variable globale.

Les trois dernières lignes de cette version illustrent que notre classe `Dialogue` peut être utilisée à peu près comme une classe standard de `tkinter`: on crée un objet, on le place avec `pack()` et on lui passe la main avec `mainloop`. Ces méthodes existent parce que `Dialogue` dérive de `Frame`.

=== Exercice ===

Refaire l'exemple du compteur en style objet.

Interfaces graphiques en Python et Tkinter

Ceci correspond à la séance 1B4 de la formation 2013-2014.

Il y a de nombreuses bibliothèques pour créer des interfaces graphiques: Gtk+, Qt, wxWidgets, qui sont utilisables en Python. Cela fonctionne toujours un peu pareil, même si chacune a ses spécificités. Ici, on utilisera la bibliothèque tkinter, qui est la présentation en Python de la bibliothèque Tcl/Tk. La raison principale est qu'elle fait partie des bibliothèques standard de Python et qu'à ce titre elle est installée d'office et interagit bien avec les environnements de développement comme Idle.

/!\ La documentation standard de tkinter est assez succinte: elle se limite à une introduction et ne donne pas une liste exhaustive de toutes les classes et de toutes les options. Il faut se reporter aux documentations portant sur Tk pour en savoir plus.

Démarrage

L'incontournable premier programme avec tkinter ressemble à ceci:

   1 from tkinter import *
   2 fenetre = Frame()
   3 fenetre.pack()
   4 texte = Label(fenetre, text="Salut!")
   5 texte.pack()
   6 fenetre.mainloop()

Tapez ce programme et lancez-le, vous verrez apparaître une fenêtre qui dit juste "Salut". Le programme se terminera quand vous fermerez la fenêtre.

Quelques explications:

  • La bibliothèque s'appelle simplement tkinter. On l'inclut avec cette forme pour simplifier l'écriture des programmes.

    • /!\ Les exemples sont en Python 3. En Python 2, tout est pareil sauf qu'on écrit Tkinter avec une majuscule!

  • Les éléments d'interface sont créés par les appels à Frame et Label qui construisent des objets des classes portant ce nom. Le premier désigne la fenêtre principale (celle qui contient l'interface) et le deuxième désigne l'élément de texte qui y est affiché. Chaque élément est contenu dans un autre élément (l'agument du constructeur), sauf la fenêtre principale. Le deuxième argument (nommé) du constructeur Label sert à configurer l'élément que l'on crée: text précise le texte, d'autres options précisent d'autres aspects.

  • La méthode pack() sert à positionner un élément dans son conteneur. Tant qu'on ne l'appelle pas, l'élément n'est pas affiché.

  • La méthode mainloop() passe la main à l'interface graphique: elle affiche ce qui doit être affiché et attend des actions de l'utilisateur. Elle rend la main quand toutes les fenêtres ouverts ont été fermées.

Actions et réactions

Ajoutons un bouton à la fenêtre: avant l'appel à mainloop, on ajoute

   1 bouton = Button(fenetre, text="Hop")
   2 bouton.pack()

Et on a un bouton en dessous du message, mais ce bouton ne fait rien.

Pour ajouter une action, on utilise le paramètre command qui attend comme valeur une fonction. On remplace alors les deux lignes précédentes par:

   1 def action():
   2     print("Clic.")
   3 
   4 bouton = Button(fenetre, text="Hop", command=action)
   5 bouton.pack()

Cette fonction est l'action à exécuter lorsque le bouton est cliqué. Ici elle se contente d'afficher un message dans le terminal où a été lancé le programme, ce qui n'est pas très utile pour une interface graphique. On peut modifier la définition de la fonction action pour qu'elle change le texte affiché dans le Label:

   1 def action():
   2     texte['text'] = "Message reçu!"

L'affectation qui a lieu dans cette fonction modifie les propriétés de l'object texte, en changeant le texte affiché. On parle de configuration d'un objet, dans le jargon de Tk.

Exercice

Adapter ce programme pour que le texte affiché indique combien de fois le bouton a été cliqué depuis le début.

Utilisation de classes

L'exemple du bouton qui modifie le message, et plus encore l'exercice qui compte le nombre de clics, montrent qu'il est nécessaire de maintenir un état et utilise pour cela des variables globales. Cela fonctionne, mais ce n'est pas très modulaire et cela peut être source d'erreurs. Pour améliorer la situation, la bonne méthode est d'utiliser la programmation par objets en définissant une classe pour notre boîte de dialogue. On peut procéder comme ceci:

   1 from tkinter import *
   2 
   3 class Dialogue (Frame):
   4     def __init__(self):
   5         Frame.__init__(self)
   6 
   7         self.texte = Label(self, text="Salut!")
   8         self.texte.pack()
   9 
  10         bouton = Button(self, text="Hop", command=self.action)
  11         bouton.pack()
  12 
  13     def action(self):
  14         self.texte['text'] = "Message reçu!"
  15 
  16 dialogue = Dialogue()
  17 dialogue.pack()
  18 dialogue.mainloop()

La classe de notre boîte de dialogue dérive de la classe Frame de tkinter: une boîte de dialogue est uen fenêtre principale (Frame) avec des propriétés supplémentaires. La méthode __init__ sert à effectuer les opérations nécessaires à la construction du dialogue:

  • On initialise l'objet comme un Frame avec la première instruction.

  • On crée l'élément pour le message et le bouton et on les inclut dans le dialogue. Le nom self désigne par convention l'objet que l'on est en train de créer.

  • Le message est stocké dans self.texte: c'est une variable propre à l'objet, on pourra y faire référence depuis les autres méthodes.

La fonction qui correspond à l'action à effectuer est maintenant self.action: c'est la méthode action de l'objet qui correspond au dialogue. C'est ici que l'on a gagné quelque chose: self.action connaît l'objet (c'est son premier argument, self) et elle peut donc accéder au champ texte, sans avoir besoin d'une variable globale.

Les trois dernières lignes de cette version illustrent que notre classe Dialogue peut être utilisée à peu près comme une classe standard de tkinter: on crée un objet, on le place avec pack() et on lui passe la main avec mainloop. Ces méthodes existent parce que Dialogue dérive de Frame.

Exercice

Refaire l'exemple du compteur en style objet.

WikISN: 1B4 (last edited 2014-05-14 14:15:15 by 178)