Formation Python pour apprendre à créer des interfaces graphiques avec Tkinter

Table des matières

Manuel des références de tkinter ..8

1. notion d'application graphique 8

1.1. les origines ..8 1.2. les principes .8

1.3. programmation ..9

1.4. le cas de Python 9

1.5. l'interfaçage de tkinter .9

2. la librairie dans l'arborescence Python .10
3. la documentation 12
4. une documentation illustrée, en français .13

4.1. notre objectif .13

4.2. en français .13

5. première approche .14

5.1. étape 1 .14 5.2. étape 2 .15

5.3 étape 3 ..16

6. les widgets de tkinter 18

6.1. liste des widgets .18

6.2. les fonctions des widgets 18

6.3. les constructeurs 19 6.4. le problème du nom d'une instance ..19

tk01 : valeurs d'attributs standards .20

1. couleurs ..20

1.1. couleurs nommées 20

1.2. couleur codées hex ..20

1.3. méthodes de widget .20

2. bordures .21

2.1. six reliefs .21

2.2. codage .21

3. unités 21
4. l'attribut bitmap 22
5. l'attribut cursor .22
6. justification des textes ..23
7. complément sur les types de données .23 tk02 : BitmapImage et PhotoImage .24
8. questions de formats .24

1.1. l'attribut image .24

1.2. modes d'une image bitmap 24

1.3. question de fichier .24

1.4. un exemple 25

2. la classe BitmapImage .26

3.1. syntaxe 26

3.2. les options .26

3.3. les méthodes 26

3. la classe PhotoImage 26

3.1. syntaxe 26

3.2. les options .26

3.3. les méthodes 27

4. Un problème avec l'attribut «image» 27

4.1. on considère le script suivant : 27 4.2. traiter le bug ..28

tk03 : les fontes 30

1. descripteur de fonte ..30

1.1. caractéristiques d'une fonte ..30

1.2. valeur de fonte : les descripteurs de fonte .30

1.3. familles prédéfinies 31

2. Le module Font 31

2.1. le constructeur Font ..31 2.2. les options de Font ..31

2.3. les méthodes d'instance de Font 31 2.4. fonctions du module font .32

tk04 : géométries .34

1. géométrie des fenêtres 34

1.1. geometry .34

1.2. fixer la géométrie d'une fenêtre ..34

1.3. retrouver la géométrie d'une fenêtre .34

2. Les gestionnaires de placement .35

2.1. les trois gestionnaires ..35

2.2. règles d'usage .35

3. Le gestionnaire Pack 35

3.1. fonctionnement du gestionnaire Pack ..35

3.2. les méthodes de widget ..37 3.3. les valeurs d'attribut : 38

3.4. les options .38

4. le gestionnaire Grid 38

4.1. principe du gestionnaire Grid 38

4.2. les méthodes de Grid ..39

4.3. les options de configuration de grille 39

4.4. les options de cellule 39

5. Le gestionnaire Place ..40

5.1. principe du gestionnaire Place .40

5.2. les méthode du gestionnaire Place 40

5.3. le valeurs d'options 40

5.4. les options .40

6. la troisième dimension .41

6.1. empilement des «calques» 41 6.2. Les méthodes ..41

tk05 : attributs partagés ..42

1. méthodes d'attributs ..42

1.1. attributs donnés à un widget .42

1.2.modification d'un ou plusieurs attributs .42

1.3. accès aux attributs .42

2. attributs système .43
3. attributs de bordure et de marge .44
4. attributs de couleur 44
5. attributs pour les gestionnaires de géométrie (rappel) .44
6. les attributs default et state 45
7. l'attribut command ..45
8. attributs de désaffection (disable) ..45 tk06: les méthodes partagées .46
9. méthodes portant sur les attributs ..46

1.1. méthodes de configuration 46

1.2. méthodes d'options de classes 46

2. méthodes concernant les événements 47 3. méthodes de presse-papier ..47
3. méthodes relatives aux placements ..47

4.1. gestionnaires de placement ..47

4.2. empilement des widgets .47

5. mesures relatives au widget .48
6. méthodes portant sur la console .48
7. méthodes de souris ..49
8. les boucles .49
9. méthodes de gestion du déroulement de programme ..51
10. méthodes d'identification ..52
11. méthodes de focus ..53
12. méthodes d'accaparement ..54 tk07 : Événements ..56
13. les événements reconnus ..56

1.1.  événements clavier 56

1.2.  événements souris 56

1.3.  événements fenêtre ..56

2. la notion de séquence ..57

2.1.  écrire une séquence .57

2.2.  exemples : .57

2.3.  événements virtuels ..58

2.4.  le cas de la molette 58

3. gestionnaire d'événement ..58

3.1.  fonction gestionnaire 58

3.2.  l'objet Event ..59

3.3.  cas mixtes ..60

4. la liaison ..60

4.1.  les bindtags ..60

4.2.  les niveaux de liaison ..60

4.3.  le retour de bind() ..63

4.4.  méthodes de suppression de liaisons ..63

4.5.  génération d'événement :  event_generate() 63

5. Les protocoles .64

5.1.  les trois modes de liaison ..64 5.2. la syntaxe ..64 pour s'y retrouver dans la gestion des événements 64 annexe : les keysym ..65 clavier de base .65 pavé numérique ..66

tk08 : Tk et Toplevel ..68

1. les constructeurs .68
2. les attributs 68

2.1. liste des attributs 68

2.2. les attributs spécifiques ..68

3. les méthodes spécifiques 69

3.1. relations avec le gestionnaire de fenêtres .69 3.2. Icone et visibilité .69

3.3. Style .70

3.4. géométrie et position 70

4. Un exemple de fenêtre Toplevel ..70 tk09 : Menu ..73
5. le constructeur .73
6. les attributs 73

2.1. liste des attributs 73

2.2. les attributs spécifiques ..73

3. un exemple de barres de menu ..74
4. exemple de menu popup 75
5. les méthodes spécifiques 76

6.1. les options d'items .76

6.2. les méthodes d'ajouts d'items à un menu ..77

6.3. méthodes de configuration 78

6.4. méthodes de popup ..78 6.5. Divers ..78

tk10 : Frame et LabelFrame ..79

1. le constructeur .79
2. options .79

2.1. liste des options de Frame .79

2.2. liste des options de LabelFrame .79

2.3. attributs spécifiques ..80

3. méthodes ..80 tk11 : PanedWindow ..81
4. le constructeur .81
5. options .82

2.1. liste des options de PanedWindows .82

2.2. options spécifiques : .82

3. configuration de panneaux 83
4. méthodes du widget PanedWindow ..84 tk12 : Scrollbar ..86
5. le constructeur .86
6. options .86

2.1. liste des options ..86

2.2. attributs spécifiques ..86

3. la fonction commmand .87

3.1. cas où le curseur de la barre de scroll est déplacée .87

3.2. cas où un mouvement unitaire est requis .87

4. méthodes 87
5. un script pour montrer le fonctionnement des connexions .88

5.1. la double connexion ..88

5.2. le script commenté 89

tk13 : Label ..92

1. le constructeur .92
2. les attributs 92

2.1. liste des attributs 92

2.2. les attributs spécifiques ..92

3. les méthodes spécifiques 93 tk14 : Button 94
4. le constructeur .94
5. les attributs 94

2.1. liste des attributs .94

2.2. attributs spécifiques ..94

2. méthodes ..95 tk15 : Checkbutton .96
3. le constructeur .96
4. les attributs 96

2.1. liste des attributs .96

2.2. attributs spécifiques ..96

3. méthodes ..97 tk16 : Radiobutton ..98
4. le constructeur .98
5. les attributs 98

2.1. liste des attributs .98

2.2. attributs spécifiques ..98

3. méthodes 100 tk17 : Listbox ..101
4. le constructeur ..101
5. les attributs .101

2.1. liste des attributs .101

2.2. les attributs spécifiques 101

3. les méthodes spécifiques .102
4. un exemple de widget Listbox avec ascenseur .103 tk18 : OptionMenu 106
5. le constructeur ..106
6. les attributs .106

2.1. liste des attributs ..106

2.2. les attributs spécifiques 106

3. un exemple de widget OptionMenu .107
4. les méthodes .109 tk19 : Entry 110
5. le constructeur 110
6. les attributs ..110

2.1. liste des attributs ..110

2.2. les attributs spécifiques .110

3. les méthodes ..112 4. scroller le widget Entry ..114
4. problème de validation : un exemple ..115 tk20 : Text ..117
5. le constructeur ..117
6. les attributs ..117

2.1. liste des attributs ..117

2.2. les attributs spécifiques .117

3. se repérer dans un texte ..119

3.1. les index de position ..119

3.2. les marqueurs 120

4. les balises (tags) ..120

4.1. fonctionnalités et aspect de blocs 120

4.2. la pile des tags ..121

4.3. les option de tag ..121

5. les méthodes .121

5.1. utilitataires ..121

5.2. méthodes générales d'édition 122

5.3. méthodes pour les marqueurs ..122

5.4. méthodes pour les éléments fenêtrés inclus ..123

5.5. méthodes pour les images incluses 123

5.6. méthodes pour les balises ..124

5.7. méthode de rendu ..124

5.8. méthodes de recherche 125

5.9. méthodes pour les ascenseurs .125

6. quelques exemples .126

6.1. méthodes de sélection ..126

6.2. un exemple simple ..126

tk21 : Canvas ..130

1. le constructeur ..130
2. les attributs .130

2.1. liste des attributs ..130

2.2. les attributs spécifiques 130

3. fonctionnement du widget 131

3.1. dimensions .131

3.2. les coordonnées ..132

3.3. identification et taguage des items .134

4. méthodes générales du widget Canvas 135

4.1. méthodes générales ..135

4.2. méthodes de manipulation de tags .135

4.3. méthodes relatives aux dimensions et aux transformations ..136

4.4. méthodes relatives aux événements .136

4.5. méthodes de texte ..136

4.5. méthodes de recherche d'item ..137

4.6. méthodes de scroll .137

5. les méthodes create 138

5.1. création à partir d'un Bitmap ou d'une Image 138

5.2. création de ligne et polygone .139 5.3. création de rectangle, d'ellipse .141

5.4. création d'un arc ..141 5.5. création de texte ..141 5.6. création de fenêtre ..142

tk22 : Scale 143

1. le constructeur ..143
2. les attributs .144

2.1. liste des attributs ..144

2.2. les attributs spécifiques 144

3. les méthodes du widget Scale ..146 tk23 : Spinbox .147
4. le constructeur ..147
5. les options 148

2.1. la liste des options ..148

2.2. les options spécifiques .148

3. les méthodes du widget Spinbox .150

tk00 : manuel des références de tkinter

À l'origine, il y a le langage Tcl, langage de programmation simple, compilé à la volée, implanté sur toutes les plate-formes (Apple, Windows, Linux). Tcl dispose d'une librairie graphique Tk, assez riche, extensible et bien maintenue. L'appellation usuelle est Tcl/Tk. Cette librairie est facile à interfacer, et c'est ainsi que Python l'a adopté comme librairie graphique par défaut.

(voir )

version : tout le travail a été réalisé avec Python3.2. sous Linux (et vérifié sous Windows) et la version (8.5) de tkinter qui l'accompagne.

1. notion d'application graphique

1.1. les origines

Une application graphique est une application qui est exécutée dans une unité d'interface graphique

(GUI, pour Graphic User Interface). Les GUI les plus connus sur le PC sont Windows (système Microsoft) et X11 (système Linux). Le premier matériel qui a disposé d'un GUI sur ordinateur personnel a été Lisa (1982), d'Apple, ancêtre du Macintosh, et qui a été repris sur les plates formes Next (qui ont engendré l'actuel Mac OS X d'Apple en 2001). Les principes de l'élaboration d'interface graphique et des logiciels graphiques ont été définis entre 1970 et 1981 au Palo Alto Research Center.

L'interface graphique utilise la métaphore du bureau : des pages empilées ou se chevauchant ; des piles de documents (pages) distribuées sur un bureau ; le dessus d'une des piles est la page active, page sur laquelle on travaille ; les pages peuvent être réunies en dossier ou en systèmes à onglets (notebook) ; des systèmes de classement par listes, répertoires etc. Ce type de métaphore qui paraît si naturelle aujourd'hui n'est cependant pas si évident qu'il y paraît. Les tablettes filent une autre métaphore, plus proche de celle de livres issus d'une bibliothèque : on tourne les pages, on glisse d'une partie du document à une autre, on choisit son application dans une bibliothèque d'applications indépendantes

1.2. les principes

- Un logiciel graphique se présente sous forme de composants graphiques fenêtrés, et il dispose d'un outil de pointage (la souris) qui permet assez souvent de ne pas utiliser la commande par le clavier.

- Par ailleurs, la gestion du logiciel se fait par événements, et non selon un déroulement séquentiel impératif comme dans les logiciels classiques.

les composants fenêtrés

- Les composants fenêtrés peuvent être de divers aspects et fonctions : cadres,  menus, boutons, images, étiquettes, tableaux etc. Chaque élément fenêtré, est un objet au sens de la POO, avec ses paramètres, ses attributs et ses méthodes.

- es éléments fenêtrés affichés sont hiérarchisés et forment un arbre ; à la racine, on trouve la fenêtre principale (root window). Les divers éléments entretiennent un rapport de dépendance du type maître (master) à enfant (child). La dépendance se traduit graphiquement par l'inclusion de l'enfant dans sont  maître, sauf pour les fenêtres de haut niveau. Attention, ce rapport de dépendance ne doit pas être confondu, malgré la proximité de vocabulaire avec la hiérarchie des objets (rapport hiérarchique qu'il vaut mieux exprimer en français par les mots ascendant et descendant). Ce rapport de dépendance est identifiable à un rapports de contenant à contenu sauf pour les éléments de haut niveau (les fenêtres Toplevel) : tout élément fenêtré a un conteneur unique, Si le maître est modifié ou s'il disparaît, toute sa progéniture est modifiée (ou disparaît).Supprimer la fenêtre principale revient à supprimer la présence à l'écran du logiciel, et en pratique sa fin.

- La gestion est événementielle : cela implique qu'un dispositif de surveillance scrute en permanence toutes les sources d'événements possibles : frappe d'une touche au clavier, action d'un timer, actions liées à la souris, au programme, à des éléments d'interface (comme la modification d'une dimension de fenêtre) L'élément racine dispose d'une boucle qui surveille tout ce qui relève de l'application.

Sortir de cette boucle s'accompagne immédiatement de la suppression de la réactivité aux événements. Dans les logiciels de «console», il existe au mieux un élément qui est en attente d'un événement (en général, la frappe dite de «validation» venant du clavier). Dans les logiciels graphique, ce sont tous les éléments qui peuvent être en «en attente» d'un événement.

- Liée à cette notion de gestion événementielle on trouve celle de focus :  une seule fenêtre de haut niveau à la fois peut être en fonctionnement ; on dit qu'elle est active. Parmi ses contenus , un élément (ou lui-même) peut attendre un événement venant du clavier : on dit qu'il a le focus. Le système d'exploitation et l'interface graphique gèrent les fenêtres de haut niveau et n'accordent l'activité qu'à l'une d'entre elles : c'est la fenêtre active, qui se repère par une teinte différente donnée à la barre de titre de la fenêtre.

1.3. programmation

La notion d'interface graphique fenêtrée et celle de programmation objet naissent en même temps. Comme ce mode de modélisation se prête bien à la programmation de l'interface graphique, l'essentiel des langages de la programmation graphique relève de la POO. Pour mémoire, Smalltalk, C++, Delphi (Pascal), Visual Basic, Java. Les systèmes qui implémentent l'interface graphique fenêtrée comportent deux parties, le système d'exploitation proprement dit, et une surcouche graphique capable de commander la carte graphique. C'est cette surcouche, Windows (Microsoft), X11 (système Linux) que le programme commande. Depuis les années 1990, on voit apparaître des modules complémentaires (frameworks) que l'on peut interfacer aussi bien avec les langages compilés que les langages interprétés et indépendants des langages destination

1.4. le cas de Python.

Python comporte plusieurs version : CPython, le Python classique, Jython, écrit en Java, IronPython etc. Jython qui fonctionne sous Java peut utiliser les capacités graphiques de Java (awt, swing).

L'activité foisonnante des programmeurs Python a permis de proposer au moins quatre bibliothèques graphiques d'origine externe, dont voici une évocation rapide :

librairie	wrapper	commentaire
tk	tkinter	Écrit en Tcl. Comporte tous les essentiels. Inclus le système Python. Utilisé aussi par Perl, Ruby. Existe en version Python 3. Exploite peu le système hôte.
wxWidget	wxPython	Bibliothèque plus riche que tkinter. Exploite au maximum le système hôte (Windows, Linux ). Les applications on le look du système hôte.
Qt	PyQt, Pyside	Développé en C++. À la base de KDE sous Linux. C'est la cour de grands ! Programmation assez spécifique.
Gtk	PyGtk	Comparable à tk ou wxWidget. Peut être programmé avec le logiciel Glade (dont il existe une version pour wxPython).

tkinter n'est pas le plus puissant ni me plus beau. Mais il a l'avantage d'être présent dans le système Python, ce qui aide à la diffusion des programmes. Il est aussi le plus simple, et son intérêt pédagogique est évident.

1.5. l'interfaçage de tkinter.

Pour aider à comprendre comment se situe la librairie tkinter dans le complexe logiciel, on propose le schéma qui suit.

Parmi les choses importantes, il faut signaler la structure tripartite de tkinter :

-  le cœur de tkinter comprend l'essentiel des routines ; ces routines ont un fonctionnement très classique puisque une fois appelées, elles effectuent leur tâche jusqu'au bout avant de rendre la main.

-  le superviseur des événements : cette partie comporte une surveillance des événements, et

les empile. Le traitement des événements est donc différé et certains événements sont simplement oubliés. Il faut  penser aussi que dans les système à un seul thread, si une boucle logicielle est engagée, le système de surveillance est interrompu. Au cours d'un dessin d'animation dans un canevas, pas question d'activer un bouton ; on y parvient cependant en multithread pour lequel Python est bien équipé.

 le gestionnaire de fenêtre est chargé du calcul des éléments d'affichage et de la commande de l'interface graphique du système. Ce gestionnaire fonctionne sur le mode paresseux (idle). Il n'effectue les calculs demandés que lorsqu'il n'y a rien de plus urgent à faire.

Le cas d'espèce consiste à demander à ce gestionnaire d'effectuer une tâche complexe, utilisant d'autres éléments graphiques déjà programmé. Pour que cela fonctionne, il faut être sûr qu'il n'y a pas de tâches en attente dont on désire exploiter le résultat : par exemple, si on demande à une fenêtre d'être modale sur une fenêtre hôte, il faut être sûr que celle-ci soit calculée complètement -peu importe qu'elle soit effectivement affichée- On peut sinon avoir un comportement partiellement modal !  bonne réaction à l'iconisation, mauvais affichage-.

2. la librairie dans l'arborescence Python

tkinter est un wrapper qui se situe dans la librairie de Python. C'est un module répertoire.

Sur notre machine, le chemin est : /usr/lib64/python3.2/tkinter

La librairie python peut se situer dans une autre arborescence ; cela dépend de l'implémentation de Python dans le système d'exploitation. Le répertoire se présente ainsi :

-rw-r--r-- 1 root root  77690 2011-09-05 23:30

-rw-r--r-- 1 root root  56250 2011-09-05 23:30

-rw-r--r-- 1 root root  14552 2011-09-05 23:30

-rw-r--r-- 1 root root  11488 2011-09-05 23:30

-rw-r--r-- 1 root root  11395 2011-09-05 23:30

-rw-r--r-- 1 root root  6135 2011-09-05 23:30 drwxr-xr-x 2 root root  4096 2012-12-26 17:25 __pycache__ -rw-r--r-- 1 root root  3701 2011-09-05 23:30

-rw-r--r-- 1 root root  2887 2011-09-05 23:30

-rw-r--r-- 1 root root  1814 2011-09-05 23:30

-rw-r--r-- 1 root root  1793 2011-09-05 23:30

-rw-r--r-- 1 root root  1568 2011-09-05 23:30

-rw-r--r-- 1 root root  1493 2011-09-05 23:30

-rw-r--r-- 1 root root  1412 2011-09-05 23:30

-rw-r--r-- 1 root root  148 2011-09-05 23:30

*

Le répertoire est un module car il possède le présent fichier. Lors de l'importation du module, le fichier est exécuté, et les classes, fonctions et constantes qu'il définit sont importées.

On rappelle qu'il y a deux grandes façons pour importer un module :

-  from tkinter import <données à importer>

-  import tkinter

Dans le premier cas, les données à importer sont citées sous forme d'un liste de noms séparés par des virgules :

from tkinter import Tk, Toplevel, Label, Button

ou si l'on veut tout importer :

from tkinter import *

Dans ce cas, les données à importer sont utilisée sans préfixe et seules les données importées sont connues du script d'importation :

monBouton = Button(monParent, text="QUITTER") fenetrePrincipale = Tk()

Dans la seconde approche, import tkinter, seule la référence du module est connue ; pour disposer des éléments qu'il connaît, c'ey-à-dire ceux définis dans la fonction __init__(), il suffit de les utiliser comme qualificatifs :

monBouton = tkinter.Button(monParent, text="QUITTER") fenetrePrincipale = ()

Attention : si on fait from tkinter import *, on ne connaît que les éléments de __init__, pas ceux des fichiers du répertoire.

On peut cependant importer un module inclus par les deux méthodes :

from tkinter import messagebox from tkinter.messagebox import askyesno import tkinter.messagebox as popMsg import tkinter.messagebox

TixTk Interface eXtension est une extension de tkinter qui offre des composants de plus haut niveau (plus de 40) comme ComboBox,NoteBook (onglets), DirTree,FileSelectBox.

Il est en principe inclus dans toutes les éditions de Python.

Redéfinit des composants de tkinter : Button,Checkbutton,Entry,Frame,Label,LabelFrame,Menubutton,PanedWindow,Radiobutton,Scale et Scrollbar en améliorant leur aspects Il en ajoute 6 qui sont : Combobox,Notebook,Progressbar,Separator,Sizegrip etTreeview.

Cette librairie n'existe que sur les versions récentes.

• Librairie intéressante puisqu'elle permet de disposer d'un composant graphique pour choisir des fichiers. On rappelle que si l'on veut utiliser les éléments de cette librairie (comme les autres du répertoire), il faut les importer explicitement : from tkinter.filedialog import *
• Librairie qui fournit des fonctions qui permet la saisie clavier à travers une interface graphique : askinteger, askfloat, askstring
• Librairie de drag & drop
• Une librairie importante si l'on veut travailler finement sur les fontes (rechercher les fontes disponibles par exemple). Elle complète des dispositions existant dans le cœur de tkinter, et n'est pas utile si on se contente de définir des attributs de fonte pour les composants Label, Button etc.
• La librairie la plus communément utilisée pour les petits travaux d'interrogation par popup à travers les fonctions comme askyesno, askokcancel, askquestion
• Actuellement non utilisable
• Affichage et saisie de texte avec un ascenseur latéral
• Permet de choisir une couleur sur une palette.
• Cette librairie est à usage interne : comme elle est importée dans __init__ ses données sont disponibles depuis le module tkinter.
• ,

À usage interne.

3. la documentation.

La documentation en français est restreinte. Les tutoriels traitent tous plus ou moins des mêmes sujets et avec un bonheur à relativiser. La documentation de référence n'existe en pratique qu'en anglais. On peut pour des cas d'espèce consulter la documentation Tcl/Tk, partiellement traduite en français ()

Le passage obligé pour Python est "An Introduction to Tkinter" de Frederik Lundth. Cette documentation date de 1999, et nécessite quelques adaptations ; une mise à jour est annoncée depuis 2006 ! On trouve en la version la plus récente, qui reste incomplète. Cette documentation reste la plus sérieuse malgré de nombreuses inexactitudes et obsolescences. Elle est disponible sur le web aux formats html (version récente) et pdf (vieille version).

Il existe une documentation de John W. Shipman pour les étudiants de l'Université du Nouveau

Mexique. Elle répond bien à son objet -une référence pour des étudiants-, elle est fiable mais reste lacunaire. S'en tenir à la version originale, en anglais.

Bien entendu, il reste la possibilité d'utiliser la documentation interne, engendrée par pydoc3. Le plus simple est de lancer dans une console : pydoc3 -w tkinter pydoc3 -w

Pydoc crée alors la doc au format HTML dans le répertoire courant. C'est lourd, assez indigeste, mais précieux pour disposer de références de première main. On peut toujours faire du copier/coller de certaine parties dans Open Office. En veillant toutefois à éviter de trop grosses transpositions qui sont fort longues et hasardeuses.

On peut évidemment faire la même opération avec les modules additionnels évoqués dans la section qui précède. C'est même en pratique la seule documentation qui existe pour plusieurs modules. Pour le paramétrage de pydoc3, ouvrir une console (sous Linux) et faire : man pydoc3

Une doc Python/tkinter est elle aussi disponible dans la doc Python, mais elle s'avère assez peu pratique.