Le Langage
Introduction
Pseudo-code sauvegardé dans fichiers .pyc/pyo pour éviter de refaire l'analyse et la génération à chaque fois.
Lancement
Options CLI (cf man python)
Code Python en CLI : -c commande | script Passage en mode interactif à la fin : -i
Optimisation simple : -O
Suivi des chargements de modules : -v Variables d'environnement (cf man python)
PYTHONPATH PYTHONSTARTUP
Syntaxe
Insister sur réglage tab ==> 4 espaces.
Modèle, Espace de Noms
Espaces de noms => dir(x) pour lister les noms dans un espace x. Par défaut espace des
'globales'. ==> Fonction vars(x) pour accéder aux noms définis dans un domaine sous forme de dictionnaire (doit avoir un __dict__), donc avec les objets correspondants.
globals() et locals().
Espace builtins, fonctions, types, classes courament utilisés (exemples).
Ramasse miettes. Comptage de références en C-Python, a priori ramasse miettes Java en Jython.
Possibilité de détection de cycles.
Objets => id. ex. id(1), id("toto")
Objet => attributs => setattr, getattr, delattr, hasattr, dir.
Tous les objets sont typés. Fct type pour connaître le type d'un objet, module types.
Mots clés réservés
None: 'rien', 'pas encore connu'... un genre de NULL.
pass: instruction nulle.
Instructions / Fonctions
Python 2.3 avec print >>fichier,...
eval, execfile.
Types de Base
Valeurs Numériques
Opérations Numériques
Citer les module cmath (nombres comlpexes), random.
Citer module fpectl (floating point exception control).
Valeurs Chaînes
Chaînes unicode et spécification de l'encodage en entrée.
Méthodes d'encodage/décodage (module codecs).
Stockage unicode en 16 bits ou 32 bits suivant la compilation.
Opérations sur les Chaînes
Fonctions chr et ord. Préférer unichr pour les chaînes unicode.
Coût concaténation de nombreuses chaînes (création nouvel objet à chaque +). Préférer utilisation de liste puis "".join(liste).
Indexation Chaînes
Index caractères de 0 à n-1.
Conteneurs Séquences
Index éléments de zéro à n-1.
range, fonction builtin.
Autres Séquences
buffer, xrange: types builtin avec constructeur.
Opérations Séquences
Opérations Séquences Mutables Fonctions Pratiques Séquences Conteneur Mapping
Opérations Dictionnaires (1)
Opérations Dictionnaires (2)
Citer le module set (Python 2.3), entre mapping et sequences, qui stocke des séquences non ordonnées.
Formatage de Chaînes (1)
Formatage de Chaînes (2)
Différence str / repr (possibilité d'évaluation).
Test If
Boucle While
Boucle For (1) Boucle For (2)
Alternances dans les boucles
Attention avec continue avant l'expression du variant.
List comprehension
Idem map et filter... en plus lisible.
Itérateurs (1)
Itérateurs (2)
Noter fonction builtin iter() pour créer un itérateur (par exemple pour d'anciens types de données qui ne fournissent pas __iter__).
Fonctions - Définition
Fonctions définissables en interractif, dans des modules, dans d'autres fonctions...
Fonctions - Variables
Possibilité d'imbriquer les définitions de fonctions, accès aux variables des fonctions englobantes.
Fonctions - Paramètres (1)
Fonctions - Paramètres (2)
Fonctions - Appel
Paramètres nommés: exemple on omet le mode d'ouverture.
Ce sont les () qui déclenchent l'appel. Sans cela on a une simple référence vers un objet fonction, que l'on peut manipuler (stocker dans des listes/dicos...).
Ces () peuvent être appliquées à d'autres objets (cf classes et méthode __call__).
Fonction - Documentation
Lambda Fonctions
Introduire fct builtin cmp qui retourne -1, 0 ou 1 suivant la comparaison des arguments.
Indiquer getsize dans os.path.
Module - Définition
Code à la racine (cadré à gauche) exécuté lors de l'import.
Code des fonctions exécuté lorsqu'elles sont appelées.
Attention: espace de noms du module = globales, passe avant les builtin... donc susceptible de masquer des noms s'ils sont identiques.
Module - Recherche
Import d'un module
Danger du import * (tableau s'il y a).
Syntaxe d'import, donner les noms définis.
Utilisation de __import__ pour du chargement dynamique. Module imp.
Export de symboles d'un module
Au sens symboles importables par * ou par leur nom.
Module Modèle
Re-indiquer l'url docutils. http://docutils.sourceforge.net/index.html
Spécifier le if __name__=="__main__" (ils ne l'ont pas sur leurs transparents).
Outil utilisable de façon autonome ou dans un cadre plus large.
Code de test.
Package
__init__.py peut être vide, sa présence suffit.
Ce que __init__.py exporte est ce qui est disponible par from package import xxx/* (hors des modules du package)
Possibilité (version de Python?) d'avoir des packages zippés (dézippés à la volée).
Utilisation d'un Package
Programmation Orientée Objet
Demander s'ils connaissent déjà, passer si oui.
Données moins versatiles dans le temps que les traitements.
Classes - Principes
Objet ou Instance: existence dans l'ordinateur d'un exemplaire de la famille.
Héritage, exemple Moteur => Moteur Pas à Pas => Moteur modèle X.
Classes - Définition (1)
Documentation sur les classes.
Variable de classe cptmoteurs, partagée par tous les objets (1 seul exemplaire).
Variables d'instance (membres) nom et modele existent pour chaque à chaque objet moteur.
Accès à la varianle de classe par la classe.
Premier paramètre représente l'objet, l'instance, à laquelle s'applique la méthode. Par convention self. Pour le reste, méthode == fonction (documentation...).
Utilisation de self pour accéder aux données stockées dans l'objet.
Constructeur (Initialiseur) __init__, avec des paramètres de construction. A priori jamais rappelé - si code d'initialisation et réinitialisation, le mettre dans une méthode spécifique. On peut s'en passer.
Bien de définir des méthodes "virtuelles", dont on donne le sens, mais dont le code effectif sera dans une sous-classe. MAIS PAS OBLIGATOIRE.
Classes - Définition (2)
Héritage (entre parenthèses) - possibilité d'héritage multiple (importance de l'ordre, nouveaux
algorithmes, possibilité/conseil fort d'hériter de object).
Utilisation de self pour les appels des méthodes sur l'objet.
Appel explicite du constructeur de la (des) classe parente.
Possibilité d'utiliser super pour appeler la méthode héritée de la classe parent (ou d'une classe au dessus): super(maclasse,monobjet).methode(arguments).
Redéfinition de la méthode "virtuellle" (spécialisation).
Définition d'un destructeur - appelé lorsque l'objet est détruit par le ramasse miettes. Pour être sûr du moment, définit une méthode explicite et l'appeler lorsqu'on le veut (jamais à l'abri d'une référence conservée qq part).
Appel d'une méthode spécifique writeserial.
Appel d'une méthode héritée ModNom.
Fonctions isinstance issubclass.
Classes - Utilisation
Instanciation par le nom de la classe.
Accès direct aux membres toujours possible en passant par l'objet.
Appel des méthodes en passant par l'objet (équivalent classe.methode(objet,...)).
Pas de sécurité contre l'instanciation de classes "virtuelles pures".
Variables membres "privées" en utilisant le __. Sécurité contre fausses manips/réutilisation même nom dans une sous classe. Contre un accès involontaire à la variable membre. Mais n'empêche pas d'y accéder (_NomClasse__nommembre).
Possibilité d'accès aux membres via setattr/getattr. A priori possibilité de définition de noms de membres non exprimable en tant qu'identificateurs Python.
Stockage des membres des objets dans dictionnaire o.__dict__.
Les classes sont des objets.
Attributs spéciaux: __dict__, __class__ ( et __bases__ pour les classes).
Classes - Opérateurs
__cmp__ pour les tris.
__str__ / __repr__ pour les print.
autres pour simuler des types (noter la possibilité d'héritage des types de base depuis l'unification type/classe - Python 2.2 sauf erreur).
fonction callable retourne vrai si __call__ est défini pour un objet.
Classes - Avancé
Méthodes statiques: liées à la classe, appelables indifférement via la classe ou via une instance.
Méthodes de classe: reçoit la classe comme premier argument (comme une méthode reçoit l'objet). Idem def cm(cls,arg1,arg2):.... puis cm=classmethod(cm)
Property (getter, setter, deleter, documentation). Uniquement avec classes héritant de object.
Permet d'effectuer des contrôle d'accès, de mettre en place des déclencheurs, d'avoir des variables calculées, d'avoir des variables rw ou ro ou wo...
Exceptions
Déroulement avec/sans exception.
Levée d'exceptions par le langage (div/zéro), par une fonction.
Syntaxe du raise
raise Classe,params
raise instance raise Classe(params)
raise pour remonter une exception en cours de traitement.
Traitements possibles
Transmission de l'exception.
Levée d'une autre exception.
Continuation à la suite.
Ne pas passer complètement sous silence une exception! Log d'erreurs - signaler le module logging, standard dans Python 2.3, téléchargeable sinon.
Exceptions - Handlers
Indiquer que les exceptions chaines sont dépréciées et seront abandonnées.
Donner quelques exemples d'exceptions: Exception, LookupError (parent IndexError et KeyError), ZeroDivisionError, SyntaxError.
Indiquer sys.exc_info() permet d'accéder plus complètement à l'erreur.
indiquer module traceback.
Exceptions - Finally
On ne peut pas avoir try/except/finally au meme niveau. Imbriquer le traitement d'exception dans le bloc d'instructions normales.
Les Outils
Les Fichiers
Objet standard (directement accessible dans les builtin).
Modes d'ouverture du langage C. Si non spécifié ouverture en lecture texte.
Avec Python 2.3, mode d'ouverture supplémentaire: U (pour Universel, où il se débrouille avec les fins de ligne). Et support transparent des conversions entre chaînes internes Unicode et encodage fichier.
Mode binaire=contenu tel quel. Mode t-texte (défaut, spécifiable)=adaptation des fins de ligne à la plateforme (CR, LF, CR+LF).
Paramètre supplémentaire optionnel, mode de bufferisation: 0=aucune (défaut), 1=bufferisation ligne, n>1=bufferisation n octets.
open() est équivalent à l'appel de file() (construction d'un objet file).
xreadlines est déprécié à partir de Python 2.3
Fichiers Itérables
Remplace méthode xreadlines
Module linecache pour accéder à des lignes dans un fichier avec gestion de cache.
Fichiers Ailleurs
Premier point, ce sont des fct/meth qui retournent des objets file.
Module sys contient aussi __stdin__, __stdout__, __stderr__ qui sont les 'originaux'.
Utilisation normale: on prend un fichier en paramètre, on utilise read/write... on peut définir une classe qui supporte ces méthodes et l'utiliser comme un fichier... StringIO.
Existe aussi cStringIO.
Les fichiers mappés peuvent être utilisés pour des communications inter-process.
La fonction codecs.open permet d'avoir un décodage/encodage transparent d'un fichier.
Pour permettre cette facilité, découpler la fonction de traitement de celle qui ouvre les flux d'entrée/sortie.
Le module sys
L'environnement d'exécution.
Pour sys.argv, indiquer le module fileinput qui permet de traiter de façon transparente stdin - si
aucun argument n'est donné - ou une liste de fichiers indiquée en arguments du script.
En plus du module getopt, Python 2.3 fournit optparse, plus souple et plus puissant.
Pour sys.exc_info, excepthook appelé pour les exceptions qui n'ont pas été interceptées. Re- indiquer module traceback avec fonctions pour manipuler la pile d'appels.
Gestion du mode interactif (prompts, fonction d'affichage des résultats).
Encodage par défaut, entier maximum (maxint), fonction à appeler lors de la sortie de Python (préférer l'utilisation du module atexit), plateforme, version, big/little endian.
Manipulation de certains éléments du fonctionnement interne (_getframe..., get/set limites
récursion), getrefcount (indiquer module weakref, utilisation principale: cache d'objets, limitation des références circulaires). Indiquer module inspect qui fournit des méthodes pour cela.
Modules gc, imp, code, codeop... fonctionnement interne.
Module site: automatiquement importé lors de l'initialisation. Pour standardiser un environnement sur une machine.
Module user et fichier .pythonrc.py. Son import doit être explicite.
Cf doc Python chap. 18 et 19 (Python langage service, Python compiler package).
Faire tourner l'exemple exsys.py - en l'appelant en ligne de commande avec des arguments !!!, et en l'appelant à partir d'IDLE.
Manipulations d'Objets
Sens de copie en profondeur.
Existe cPickle, qui peut être jusqu'à 1000 fois plus rapide!.
Faire tourner et commenter l'exemple expickle.py.
Manipulation de Textes
Avec Python 2.3, module csv (Comma Separated Value) pour manipuler des fichiers textes avec séparateurs.
Outil de test d'expressions régulières Python: Recon, sur:
http://webpages.charter.net/erburley/recon.html
Manipulation de flots binaires
Rappeler qu'une chaine est comme un bloc mémoire (peut contenir flots binaires).
Pour xstruct: http://www.sis.nl/python/xstruct/xstruct.shtml.
En plus de zlib, module gzip pour manipuler directement (lire/écrire) des fichiers .gz, et module zipfile pour manipuler des archives .zip.
Le module array permet d'accéder aux données binaires (sous forme de chaîne).
Faire tourner et commenter l'exemple exbin.py.
Manipulation du Temps
Pour mxDateTime: http://www.egenix.com/files/python/mxDateTime.html.
Accès au Système
Les fonctions dans os.path permettent d'écrire du code indépendant de la plateforme (gestion des : / \... en fonction de la plateforme). Utilise des constantes définies dans os.
Attention, os définit aussi un open... qui retourne un entier (descripteur de fichier bas niveau) ainsi que les fonctions pour le manipuler. Un exemple du danger de import *.
Fonction os.path.walk pour parcourir une arborescence de fichiers et appliquer des traitements.
Module dircache (os.listdir).
Avec Python 2.3, le module tempfile est plus complet et plus sécurisé.
Avec Python 2.3, il y a une fonction os.walk pour parcourir toute une arborescence (plus simplement que os.path.walk).
shutil, fcts de copie, copie récursive, renomage...
Module errno pour les codes d'erreurs standards.
Services spécifiques Unix: pwd, crypt, nis, syslog, fcntl, pipes...
Sous Windows en standard msvcrt, _winreg, winsound. Ajouter win32all.
Faire tourner et commenter l'exemple exos.py.
Pour gnuplot, signaler le gnuplot-py, sur http://gnuplot-py.sourceforge.net/
Console
Si la librairie readline est disponible, l'édition en ligne de commande (correction, historique...) est automatiquement supporté.
Sous windows, voir le module tiers console (?consolelib) http://effbot.org/zone/console- index.htm.
Pour les programmes qui veulent absolument avoir une console, problèmes avec les popen. Il existe un module tiers qui règle ce problème (mais je ne sais plus son nom).
Module tiers ipython (http://ipython.scipy.org/) pour avoir un mode interactif encore plus puissant (accès direct au shell, introspection...).
Multitache
Si utilisation, prévoir les synchronisations pour les accès aux données.
Thread principal (main thread).
Thread démons.
Fonction sys.setcheckinterval. Prise en compte switchs de tache et signaux.
Global lock: libéré lors des opérations asynchrones courantes (I/O, sleep...). Penser à le libérer lors de l'écriture de modules d'extension autant que possible (pas d'interraction avec
l'interpréteur).
Module thread, bas niveau (préférer threading), fonction start_new_thread & Co.
Module threading, fct currentThread, fct enumerate.
Timer = tache avec attente avant son démarrage.
Aussi BoundedSemaphore.
Faire tourner l'exemple exthread.py.
Communications Inter-process
Attention aux signaux avec le multithread.
Possibilité de connexions via ssl sur une socket.
Select fonctionne aussi avec les pipes sous Unix.
XML-RPC, module SimpleXMLRPCServer.
CORBA: OmniORBpy, pyORBIT, Fnorb.
Attention mapping CORBA, les séquences sont mappées vers des listes, particulièrement inefficace pour les données volumineuses. Préférer si possible des séquences d'octets, mappés vers des chaînes, et manipuler ensuite avec array/Numeric/Numarray.
COM/DCOM: Partie de l'extension Win32all. Permet de piloter des applications sous Windows (ex. Word, Excel...).
Module administration Windows Win32-WMI: http://tgolden.sc.sabren.com/python/wmi.html Module tiers Pyro (Python Remote Object), comme les RMI (Remote Method Invocation) de Java.
Internet
Pour telnet, sauf erreur il y a des modules tiers plus avancés.
Serveurs SimpleHTTPServer, CGIHTTPServer...
XML: il existe des modules tiers souvent plus simple d'accès.
Bases de données
Python Database API V2: http://www.python.org/peps/pep-0249.html
Rappeler le module shelve qui s'occupe de la persistence en utilisant une BD clé->valeur.
Autres: MetaKit...
mxODBC - en partie commercial.
Base Gadfly - base SQL tout en Python, permet de tester facilement du code sans avoir à installer/manipuler une grosse SGBDR: http://gadfly.sourceforge.net/.
Génie logiciel
Pychecker sur http://pychecker.sourceforge.net/.
Pyreverse sur http://www.logilab.org/projects/pyreverse, pour générer analyse de dépendances, documentation et diagramme de classes à partir de source Python.
Le "Thinking in Python" de Bruce Eckel, sur http://mindview.net/Books/TIPython.
Faire tourner l'exemple expychecker.py.
Calcul
Pour Numeric/Numarray, http://www.stsci.edu/resources/software_hardware/numarray.
«numarray currently has ports of Numeric packages for linear algebra, random numbers, and fourier transforms. numarray has native packages for convolution and multi-dimensional image processing»
Pour Scientific (Konrad Hinsen) http://starship.python.net/~hinsen/ScientificPython/
Scipy, calcul numérique scientifique («special functions, integration, ordinary differential equation (ODE) solvers, gradient optimization, genetic algorithms, parallel programming tools, an expression-to-C++ compiler for fast execution, and others. SciPy also has plotting functions for quickly visualizing data.»), sur http://www.scipy.org/.
Pour StatPy: http://astrosun.tn.cornell.edu/staff/loredo/statpy/
Pour MatPy: http://matpy.sourceforge.net/
Pour PIL: http://www.pythonware.com/products/pil/, il y a un support commercial.
La page de Konrad Hinsen: http://starship.python.net/crew/hinsen/, son cours Python pour les scientifiques: http://dirac.cnrs-orleans.fr/~hinsen/courses.html.
CUPS -Club Utilisateurs Python Scientifique - http://lists.logilab.org/mailman/listinfo/cups.
Numeric
Classe array, données toutes du même type, possibilité de plusieurs dimensions.
Nombre de données => size.
Dimensions = application d'une forme. Attribut shape, modifiable dynamiquement.
Création à partir de séquences.
Lecture/écriture données binaires.
Attribut flat contient les données en shape (n,). cf fonction ravel.
Fonctions 'universelles' (ou ufunc), opérations +-*/, fcts math, mini/maxi, manipulations de bits, comparaisons... appliquées aux tableaux Numeric.array dans leur ensemble (applicables aux séquences Python aussi). Retournent des array / possible d'indiquer de stocker le résultat dans un array existant.
Fonctions de diagonalisation, recherche, tri, multiplication matricielle, bornage (limitation des valeurs)...
Tkinter
Interfaces Graphiques
Programmation d'interfaces graphiques, un peu comme un démon: se prépare puis attends des requêtes à traiter.
Séparer le code fonctionnel du code GUI. Le code fonctionnel doit pouvoir être utilisé, testé, sans la GUI (ex. en CLI). La GUI doit pouvoir être modifiée sans que cela n'influence le code fonctionnel.
Eventuellement, prévoir des mécanismes permettant au code fonctionnel d'envoyer des signaux / évènements vers la GUI. Par exemples :
Passage au code fonctionnel d'une référence à une fonction d'information d'avancement des opérations qu'il appellera régulièrement.
Utilisation d'une globale dans le code fonctionnel pour indiquer un état d'avancement, le code GUI pool régulièrement cette globale.
Boucle Evènementielle
La séparation entre les catégories d'évènements n'est pas hyper normalisée (les évènements graphiques sont souvent liés à des évènements utilisateurs précédents).
Pour les évènements utilisateur et graphiques, il faut identifier l'élément graphique concerné.
Si API bas niveau, tout gérer... rapidement lourd. Si API haut niveau... association entre signature d'évènement et fonction à appeler - c'est l'API qui se charge de la boucle évènementielle et du dispatch des évènements vers le code approprié.
Eléments Graphiques
SDI: le document est dans une fenêtre principale (de premier niveau). Typiquement un éditeur simple.
MDI: la fenêtre principale contient des sous-fenêtres documents. Typiquement un environnement de développement intégré (IDE).
Dialogue modal: il doit être refermé pour retourner au document. Non modal: il peut rester ouvert durant les autres manipulations du document.
Hiérarchie d'éléments graphiques
A tout moment, un des éléments a le 'focus', les actions au clavier lui sont destinées (un champs en cours d'édition, d'autres widgets sélectionnés par une navigation au clavier).
Deux façons de décrire l'interface. La mauvaise, en la décrivant dans du code. La bonne en utilisant des "ressources" séparées du code. Avec Tkinter... la mauvaise en général.
Dans certains modèles "MVC" (Model View Controler), il est possible de connecter des variables du programme au contenu des widgets (un changement dans l'un est répercuté dans l'autre). s
Définition d'une interface
Règle des 7 éléments +-2 dans une zone - ne pas surcharger.
Menus, regrouper les éléments les plus utilisés au début. Pas plus de un niveau de sous-menus.
Menus contextuels: avoir les opérations listées ailleurs (au niveau de la barre des menus, dans une palette d'outils...).
Rester cohérent avec le reste de l'application, avec les applications sur la même plateforme.
Placer les boutons de validation toujours au même endroit.
Utiliser des étiquettes claires (plutôt que Ok, utiliser le verbe de l'action liée au clic sur un bouton de validation).
Mettre l'option la plus sécurisée comme option par défaut (appui sur Entrée dans un dlog).
Ne pas abuser du mélange de styles de caractères différents (font, taille, graisse, italique).
Utiliser des graphiques/icônes là où ils apportent clairement un plus; éviter les effets gratuits (clignottement & Co), qui dérangent l'attention s'ils n'ajoutent rien.
Utiliser les couleurs à bon escient (pour faire ressortir qq chose, pour regrouper certains éléments).
Cf Inside Macintosh vol I, livre de la fondation Gnome sur la création d'interfaces graphiques,
Librairies
VTK: produit gratuit, livre et support commerciaux.
Qt: voir license vs utilisation (vs Windows).
Liste de liens plot-resource: http://starship.python.net/crew/jhauser/plot-res.html Et aussi sur http://www.physik.tu-dresden.de/~baecker/python/plot.html
Tkinter
Pour la suite, construction d'une petite application.
Widgets Tkinter
Premier paramètre de construction d'un widget: son conteneur ('parent').
Widgets Tkinter (2)
Pour Démarrer
L'appel à Tk crée un interpréteur Tcl pour manipuler la librairie Tk. Et il crée une fenêtre 'Toplevel' liée, pour contenir les autres éléments.
Noter l'association directe de l'activation du bouton (sa commande) avec le quit de la fenêtre toplevel.
L'appel à mainloop permet à Tkinter de boucler sur les traitements des évènements.
Il est possible de créer d'autres fenêtres Toplevel (documents, dialogues), mais il y a toujours la 'principale' liée à l'interpréteur Tcl, qui déroule la boucle évènementielle et dont la fermeture termine l'application.
La mise en place des widgets se fait en deux étape:
1) création de l'objet, avec ses attributs.
2) placement de l'objet dans son conteneur avec le pack ou le grid ou le placer.
L'appel à root.quit() provoque la sortie de la boucle d'évènements (donc normalement la fermeture de l'application).
Attributs Généraux
Cf p426.
Les atributs par défaut peuvent être lus dans un fichier afin d'être appliqués automatiquement lors de la création des widgets (il faut les charger AVANT de créer les widgets) :
root.option_readfile("nomdufichier") Avec dans le fichier:
*font: Helvetica 12 bold
*label*font: Helvetica 12 bold italic
*background: white
*foreground: blue
*Button*background: yellow
Exemples de couleurs: 'gray25', 'black', 'royalblue', '#00FF55'.
Ce sont les noms originaux des serveurs X...
Exemples de font: (''Arial',12,'italic'), ('Helvetica',10), ('Verdana',8,'medium'), 'Verdana 8 bold italic'
Exemple de curseurs (p622): 'arrow', 'bottom_side', 'plus', 'clock', 'crosshair', 'watch'...
Exemples de reliefs: RAISED, SUNKEN, FLAT, RIDGE, SOLIF, GROOVE.
Largeur encadrement: entier.
Prise de focus: YES (1) ou NO (0).
Attributs supplémentaires liés au focus: highlightbackground (couleur pourtour quand pas de focus), highlightcolor (couleur pourtour quand focus), highlightthickness (largeur pourtour quand focus).
Attributs Courants
Text pour les boutons, label, message.
Exemple de state: NORMAL, ACTIVE, DISABLED. Pour les boutons, entry, scale, text.
Pour les command, fonction ou méthode liée à un objet (bounded method), utilisation courante des lambda-fonctions. Pour les différents boutons, les ascenceurs et thermomètres.
With pour beaucoup, exceptés les menus.
Height pour les boutons, canvas, frame, label, text, toplevel, listbox.
Exemples de justify: LEFT, CENTER, RIGHT. Pour les différents boutons, entry, labels, message.
Warplength pour boutons, label.
Exemple de anchor : N, NE, E, SE, S, SW, W, NW, CENTER. Pour les différents boutons, label, message.
Underline pour boutons, label.
Pour padx et pady. Pour les boutons, label, text, message.
Pour les bitmap, fct Tk_GetBitmap. Bitmap touchée par anchor et justify.
Pour image et bitmap, remettre à chaîne vide pour retirer l'image (et revenir au texte).
Image et bitmap pour les différents boutons, les labels.
x/y scrollcommand pour canvas, entry, listbox, text. Pour permettre aux widgets de mettre à jours les ascenceurs lorsque leur contenu change.
Méthodes Générales Widgets
Méthodes Générales Widgets (2)
wait... fait entrer dans une boucle locale de traitement des évènements jusqu'à ce que la condition (ex. chgt d'état d'un composant graphique) soit effective.
Variables Tkinter
trace_variable permet d'installer un callback, activé lorsque la variable est lue/écrite/indéfinie.
Tkinter et threads
Pour avoir du code exécuté de façon délayée: widget.after (millisec, fct, *args). Retourne un id.
Méthode after_cancel(id).
Pour avoir du code exécuté de façon périodique: widget.after_idle (fct, *args).
Codage
Détecter le plus tôt possible les impossibilités et les incohérences.
Bloquer les exceptions remontant au niveau des handlers qui lancent les commande, afficher des dialogues d'erreur lorsqu'elles y remontent / logger les erreurs.
Liens
Repository de modules:
Python Package Index (PyPi): http://www.python.org/pypi Python Vault of Parnassus: http://www.vex.net/parnassus/
Collections de liens
Python eggs: http://www.python-eggs.org/links.html
Exemples
Dive Into Python : http://www.diveintopython.org/
Docs Tkinter
Thinking in Tkinter: http://www.ferg.org/thinking_in_tkinter/index.html
An Introduction to Tkinter: http://www.pythonware.com/library/an-introduction-to-tkinter.htm Tkinter reference: a GUI for Python: http://www.nmt.edu/tcc/help/pubs/lang.html
