Vous êtes sur la page 1sur 108

Initiation ` Python par lexemple a

Raphael.Marvie@lifl.fr 7 mars 2007 Version 1.2.1

Copyright (c) 2003-2007, Raphael MARVIE <raphael.marvie@lifl.fr> Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with the Invariant Sections being "Chapitre 1, Premiers pas", "Chapitre 2, Quelques modules et built-in", "Chapitre 3, Plongeon dans les objets", "Chapitre 4, Python et XML", "Chapitre 5, Python et la persistance de donnes", "Chapitre 6, Python et les interfaces graphiques", the e Front-Cover Text being "Initiation ` Python par lexemple", and no a Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".

c 2003-2007, Raphal Marvie e

Avant-propos
Ce support propose une initiation au langage Python par lexemple. Il fait suite ` a une formation dune semaine et comportant 6 cours. Cette version essaye de complter e les transparents, mais ne regroupe malheureusement pas tout le discours accompagnant la prsentation des transparents. La formation se faisant en salle machine, tous les exemples e taient tests interactivement pendant le cours. Cette approche est volontairement conserve e e e ici et il est conseill dutiliser ce support avec un interprteur lanc pour ((voir ce qui se e e e passe) ). Ce support de cours est destin ` un public tant familier avec au moins un langage ea e de programmation, si possible orient objet, et tre familier avec les notions dobjet. Ce e e support nest pas un cours de programmation, ni un cours complet sur le langage Python, il ne reprsente quune initiation ` direntes choses que lon peut faire avec Python. La e a e version utilise dans ce support est la 2.4.1. Les premiers complments de ce support sont e e les documents associs au langage Python comme la librairie standard [7] le manuel de e rfrence [8] ou bien le tutoriel ociel [9]. ee Sans ambition dtre susant, la mise en ligne de ce support a pour unique objectif e dtre ventuellement utile. Le format retenu permet une impression en ((deux par page)). e e Toute remarque concernant ce support est toujours la bienvenue ! r.m.

c 2003-2007, Raphal Marvie e

Table des mati`res e


Avant-propos Introduction 1 Premiers pas 1.1 Utilisation de Python . . . . . . . . . . . . . . . 1.2 Structures de base . . . . . . . . . . . . . . . . 1.2.1 Commentaires . . . . . . . . . . . . . . . 1.2.2 Typage en Python . . . . . . . . . . . . 1.2.3 Arithmtique . . . . . . . . . . . . . . . e 1.2.4 Cha nes de caract`res . . . . . . . . . . . e 1.2.5 Listes . . . . . . . . . . . . . . . . . . . 1.2.6 Listes et cha nes de caract`res . . . . . . e 1.2.7 Tuples . . . . . . . . . . . . . . . . . . . 1.2.8 Dictionnaires . . . . . . . . . . . . . . . 1.3 Constructions . . . . . . . . . . . . . . . . . . . 1.3.1 Structuration et indentation . . . . . . . 1.3.2 Tests . . . . . . . . . . . . . . . . . . . . 1.3.3 Boucles . . . . . . . . . . . . . . . . . . 1.3.4 Fonctions . . . . . . . . . . . . . . . . . 1.3.5 Documenter . . . . . . . . . . . . . . . . 1.4 Autres lments sur les squences . . . . . . . . ee e 1.4.1 Fonctions de manipulation de squences e 1.4.2 Listes en comprhension . . . . . . . . . e 1.4.3 Itrateurs et gnrateurs . . . . . . . . . e e e 1.4.4 Boucles for problmatiques . . . . . . . e 1.5 Exercices . . . . . . . . . . . . . . . . . . . . . . 1.5.1 Manipulations de donnes . . . . . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 9 11 11 12 12 12 13 13 15 17 17 18 20 20 20 21 22 23 24 24 25 26 27 28 28 29 29 29 32

2 Quelques modules et built-in 2.1 Dnition et utilisation de modules . . . . . . . . . . . . . . . . . . . . . . e 2.1.1 Dnition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . e 2.2 Quelques modules standards et utiles . . . . . . . . . . . . . . . . . . . . . 5

6 2.2.1 Le module sys . . . . . . . . 2.2.2 Le module string . . . . . . 2.2.3 Le module re . . . . . . . . . 2.2.4 Le module os . . . . . . . . . 2.2.5 Le module os.path . . . . . . 2.2.6 Les modules glob et fnmatch 2.2.7 Le module getpass . . . . . . Built-in en Python . . . . . . . . . . 2.3.1 Les chiers . . . . . . . . . . 2.3.2 Conversions de type . . . . . 2.3.3 Evaluation dynamique . . . . 2.3.4 Assertions . . . . . . . . . . . Exercices . . . . . . . . . . . . . . . . 2.4.1 Utilitaire de sauvegarde . . . 2.4.2 Extraction de donnes . . . . e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

` TABLE DES MATIERES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 33 35 36 37 37 38 38 38 40 41 41 42 42 42 43 43 43 43 44 45 47 47 47 48 49 49 50 52 52 53 55 55 55 57 58 59 59 59

2.3

2.4

3 Plongeon dans les objets 3.1 Des objets, que des objets . . . . . . . . . . . 3.1.1 Rappels des principes de base de POO 3.1.2 Objets et rfrences . . . . . . . . . . . ee 3.1.3 Classes . . . . . . . . . . . . . . . . . . 3.1.4 Hritage . . . . . . . . . . . . . . . . . e 3.1.5 Classes vs modules . . . . . . . . . . . 3.2 Structures des objets . . . . . . . . . . . . . . 3.2.1 Introspection simple . . . . . . . . . . 3.2.2 Classes et attributs . . . . . . . . . . . 3.3 Les objets, version avance . . . . . . . . . . . e 3.3.1 Un peu de rexion . . . . . . . . . . . e 3.3.2 Un peu plus de rexion avec inspect e 3.4 Les exceptions en python . . . . . . . . . . . . 3.4.1 Dnition et lancement . . . . . . . . . e 3.4.2 Traitement des exceptions . . . . . . . 3.4.3 Traitement dexceptions et hritage . . e 3.5 Toujours ` propos des objets . . . . . . . . . . a 3.5.1 Unication des types et des classes . . 3.5.2 Dnition de proprits . . . . . . . . . e ee 3.5.3 Dcorateurs . . . . . . . . . . . . . . . e 3.6 Exercices . . . . . . . . . . . . . . . . . . . . . 3.6.1 Premi`res classes . . . . . . . . . . . . e 3.6.2 Design pattern tat . . . . . . . . . . . e

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . .

c 2003-2007, Raphal Marvie e

` TABLE DES MATIERES 4 Python et XML 4.1 XML, avec une vision DOM . . . . . . . . . . . . . 4.1.1 Langages de balises . . . . . . . . . . . . . . 4.1.2 XML, quels outils ? . . . . . . . . . . . . . . 4.1.3 DOM, petit rappel . . . . . . . . . . . . . . 4.1.4 Exemple du chapitre . . . . . . . . . . . . . 4.2 Naviguer dans un arbre DOM . . . . . . . . . . . . 4.2.1 minidom ((il fait le maximum)) . . . . . . . . 4.2.2 Parser un document XML . . . . . . . . . . 4.2.3 Parcourir un arbre DOM . . . . . . . . . . . 4.2.4 Recherche dans un arbre DOM . . . . . . . 4.2.5 NodeList et objets squences . . . . . . . . e 4.3 Accder aux informations dun noeud . . . . . . . . e 4.3.1 Informations lies au noeud . . . . . . . . . e 4.3.2 Informations lies aux attributs dun noeud e 4.4 Construire un document XML . . . . . . . . . . . . 4.4.1 Crer un arbre DOM . . . . . . . . . . . . . e 4.4.2 Crer des noeuds DOM . . . . . . . . . . . . e 4.4.3 Ajout de noeuds dans un arbre . . . . . . . 4.4.4 Supprimer des noeuds dun arbre DOM . . . 4.4.5 Srialiser un document XML . . . . . . . . . e 4.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . 5 Python et la persistance de donnes e 5.1 Fichiers DBM . . . . . . . . . . . . . 5.1.1 Description et utilisation . . . 5.1.2 Limitations . . . . . . . . . . 5.2 Pickle et Shelve . . . . . . . . . . . . 5.2.1 Object pickling . . . . . . . . 5.2.2 (D)Srialisation et chiers . . e e 5.2.3 (D)Srialisation et cha e e nes . 5.2.4 DBM + Pickle = Shelves . . . 5.2.5 Remarques . . . . . . . . . . . 5.3 Python et SQL . . . . . . . . . . . . 5.3.1 Exemple avec Postgres . . . . 5.3.2 Oprations de base . . . . . . e 5.3.3 Gestion de dates . . . . . . . 5.3.4 Gestion de donnes binaires . e 5.4 Exercices . . . . . . . . . . . . . . . . 5.4.1 Module ((Mod`le)) du MVC . . e 5.4.2 Module ((Contrleur)) du MVC o c 2003-2007, Raphal Marvie e

7 61 61 61 61 61 62 63 63 63 63 64 65 65 65 66 67 67 67 68 68 69 69 71 71 71 72 72 72 73 73 74 74 74 74 75 76 77 77 77 77

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

8 6 Python et les interfaces graphiques 6.1 Python et Tkinter . . . . . . . . . . . . . . 6.1.1 Tkinter . . . . . . . . . . . . . . . 6.1.2 Premier pas . . . . . . . . . . . . . 6.1.3 Conguration de widgets . . . . . . 6.1.4 Composition de widgets avec pack 6.1.5 Lancer des commandes . . . . . . . 6.1.6 Composition et redimensionnement 6.1.7 Boutons et traitements . . . . . . . 6.1.8 Dnition de bindings . . . . . . . e 6.1.9 Assemblage de widgets . . . . . . . 6.1.10 Widgets orients objet . . . . . . . e 6.1.11 A propos de laspect . . . . . . . . 6.1.12 Application multi-fentre . . . . . . e 6.2 Petit tour des widgets courants . . . . . . 6.2.1 Entry : Entres de texte . . . . . . e 6.2.2 Agencement de widgets . . . . . . . 6.2.3 Zone de texte . . . . . . . . . . . . 6.2.4 Listboxes . . . . . . . . . . . . . . 6.2.5 Barres de dlement . . . . . . . . e 6.2.6 Bo ` cocher et boutons radio . . tes a 6.3 Autres widgets prt ` lemploi . . . . . . . e a 6.3.1 Bo de dialogue . . . . . . . . . tes 6.3.2 Barre de menus . . . . . . . . . . . 6.4 Autres extensions disponibles . . . . . . . 6.5 Exercices . . . . . . . . . . . . . . . . . . . 6.5.1 Module ((Vue)) du MVC . . . . . . Remerciements

` TABLE DES MATIERES 79 79 79 79 80 80 80 81 81 82 84 85 85 86 86 86 87 88 89 89 90 92 92 93 94 95 95 97 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 99 101 101 102 103 104 104 105 105 105 105

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . .

A GNU Free Documentation License A.1 Applicability and Denitions . . . . . . . . . . . . . . . . A.2 Verbatim Copying . . . . . . . . . . . . . . . . . . . . . . A.3 Copying in Quantity . . . . . . . . . . . . . . . . . . . . A.4 Modications . . . . . . . . . . . . . . . . . . . . . . . . A.5 Combining Documents . . . . . . . . . . . . . . . . . . . A.6 Collections of Documents . . . . . . . . . . . . . . . . . . A.7 Aggregation with Independent Works . . . . . . . . . . . A.8 Translation . . . . . . . . . . . . . . . . . . . . . . . . . A.9 Termination . . . . . . . . . . . . . . . . . . . . . . . . . A.10 Future Revisions of this License . . . . . . . . . . . . . . A.11 Addendum : How to use this License for your documents

c 2003-2007, Raphal Marvie e

Introduction
Un peu dhistoire
Python est un langage de programmation objet interprt. Son origine est le langage de ee script du syst`me dexploitation Amoeba (1990). Il a t dvelopp par Guido Von Rossum e ee e e au CWI, ` lUniversit dAmsterdam et nomm par rapport au Monthy Pythons Flying a e e Circus. Depuis, Python est devenu un langage de programmation gnraliste (comp.lang.python e e est cr en 1994). Il ore un environnement complet de dveloppement comprenant un ee e interprteur performant et de nombreux modules. Un atout indniable est sa disponibilit e e e sur la grande majorit des plates-formes courantes (BeOS, Mac OS X, Unix, Windows). e Python est un langage open source support, dvelopp et utilis par une large come e e e munaut : 300, 000 utilisateurs et plus de 500, 000 downloads par an. e

Python, ` quoi bon ? a


Pour rsumer Python en quatre points forts. e Qualit Lutilisation de Python permet de produire facilement du code volutif et maine e tenable et ore les avantages de la programmation oriente-objet. e Productivit Python permet de produire rapidement du code comprhensible en relguant e e e nombre de dtails au niveau de linterprteur. e e Portabilit La disponibilit de linterprteur sur de nombreuses plates-formes permet e e e lexcution du mme code sur un PDA ou un gros syst`me1 . e e e Intgration Lutilisation de Python est parfaitement adapte lintgration de composants e e e crit dans un autre langage de programmation (C, C++, Java avec Jython). Embare quer un interprteur dans une application permet lintgration de scripts Python au e e sein de programmes. Quelques caractristiques intressantes e e langage interprt (pas de phase de compilation explicite) ee pas de dclarations de types (dclaration ` laectation) e e a gestion automatique de la mmoire (comptage de rfrences) e ee
1

Mme si un tel cas semblerait un peu bizarre. e

10

` TABLE DES MATIERES programmation orient objet, procdural et fonctionnel e e par nature dynamique et interactif possibilit de gnrer du byte-code (amliore les performances par rapport ` une e e e e a interprtation perpetuelle) e interactions standards (appels syst`mes, protocoles, etc.) e intgrations avec les langages C et C++ e

Python ou pas Python ?


Comme tout langage de programmation Python nest pas la solution ultime ` tous les a besoins. Toutefois, on retrouve son utilisation dans dirents contextes [4] comme Google, e la NASA, YouTube, Industrial Light & Magic, le projet One Laptop Per Child, lenvironnement Opie sur pocket PC, etc. Python est donc adapt pour raliser de ((grosses e e applications)). Quand Python ? Python est un tr`s bon langage pour le dveloppement agile [1] et e e itratif. Il permet dtre ractif et vite le cycle lourd programmer / compiler / tester. De e e e e plus, le langage permet de vrier tr`s rapidement des hypoth`ses de mise en uvre. Une e e e fois la solution ralise en Python, il est alors toujours possible de loptimiser davantage e e en redveloppant certain de ses composants en C++ par exemple. e Python permet de produire des applications facilement extensibles non seulement par le dveloppeur mais aussi dans certains cas par lusager (de nombreuses librairies scientiques e sont disponibles). Enn, Python est un bon candidat pour lautomatisation de tches syst`mes. Le syst`me a e e dadministration de la distribution Gentoo Linux portage est dvelopp en Python. Une e e partie au moins du support de lintgration continue chez Google est fait en Python. e Quand pas python ? Dynamicit est rarement compatible avec haute performance, Pye thon nest donc certainement pas le meilleur langage pour faire du traitement intensif. Dans certain cas, les usagers prf`rent limiter lutilisation de Python ` laspect intgration ee a e de composants an de produire des syst`mes performants. La version Python fournit une e preuve de concept ou une version fonctionnelle avant de redvelopper les points faibles. e Toutefois, les performances de Python sont souvent susante pour des applications ` forte a charge (cf. YouTube) Une certitude pour terminer, Python permet didentier rapidement une mauvaise ide... e

c 2003-2007, Raphal Marvie e

Chapitre 1 Premiers pas


1.1 Utilisation de Python

Python, comme la majorit des langages dit de script, peut tre utilis aussi bien en e e e mode interactif quen mode script / programme. Dans le premier cas, il y a un dialogue entre lutilisateur et linterprteur : les come mandes entres par lutilisateur sont values au fur et ` mesure. Cette premi`re solution e e e a e est pratique pour le prototypage, ainsi que pour tester tout ou partie dun programme ou plus simplement pour interagir aisment et rapidement avec des structures de donnes e e complexes. Le listing suivant prsente comment lancer linterprteur (simplement en tapant e e python ` linvite du shell1 ) et comment en sortir (en tapant Ctrl-D). a
$ python Python 2.4.3 ( # 1 , Apr 7 2006 , 10:54:33) [ GCC 4.0.1 ( Apple Computer , Inc . build 5250)] on darwin Type " help " , " copyright " , " credits " or " license " for more information . >>> print hello world ! hello world ! >>> ^ D $

Pour une utilisation en mode script les instructions ` valuer par linterprteur sont a e e sauvegardes, comme nimporte quel programme informatique, dans un chier. Dans ce e second cas, lutilisateur doit saisir lintgralit des instructions quil souhaite voir valuer e e e ` laide de son diteur de texte favori, puis demander leur excution ` linterprteur. Les a e e a e chiers Python sont identis par lextension .py. Le listing suivant, linterprteur est ape e pel avec en param`tre le nom du programme ` valuer (le traditionnel hello world). Dans e e ae le cas dun syst`me Unix, la premi`re ligne du chier hello.py prcise quel interprteur e e e e utiliser pour valuer le chier si ce dernier est excutable. Il sut dans ce cas de taper le e e nom du chier ` linvite du shell. a
$ cat hello . py
1

Dans tout ce support linvite du shell sera identi par la lettre $. e

11

12
# ! / usr / bin / env python print hello world ! $ python hello . py hello world !

Premiers pas

1.2
1.2.1

Structures de base
Commentaires

Comme dans la majorit des langages de script, les commentaires Python sont dnis e e ` laide du caract`re #. Quil soit utilis comme premier caract`re ou non, le # introa e e e duit un commentaire jusqu` la n de la ligne. Comme toujours, les commentaires sont ` a a utiliser abondamment avec parcimonie. Il ne faut pas hsiter ` commenter le code, sans e a pour autant mettre des commentaires qui napportent rien. Le listing suivant prsente une e ligne de commentaire en Python. Les commentaires seront de nouveaux abords en 1.3.5 e pour lauto-documentation. Les commentaires introduits par # devraient tre rservs au e e e remarques sur le code en sa mise en uvre.
>>> # ceci est un commentaire >>> print bouh # ceci est aussi un commentaire bouh

1.2.2

Typage en Python

En Python, tout est objet. Quelque soit les donnes que lon manipule, ces donnes e e sont des objets dont les classes sont dnies par lusager, ou par lenvironnement Python e pour les types de base. Une consquence est que lutilisateur manipule les donnes au e e travers de rfrences (qui donnent acc`s aux fonctionnalits des instances). Cette approche ee e e permet de rendre homog`ne les donnes manipules par lutilisateur (comme ctait le cas e e e e en SmallTalk). Ainsi, toutes les donnes suivantes suivant sont des objets : 1, [2, 3, 4], 5.6, e toto, une instance de Foo. Python est un langage ` typage dynamique. Ceci ne veut pas dire que les donnes que a e lon manipule ne sont pas types, mais que leur type est ((calcul)) lors de leur utilisation2 . e e Dans ce contexte, le type des variables nest pas dni explicitement par lutilisateur. Ainsi, e une mme variable peut rfrencer dans un programme des objets de types dirents3 . e ee e
>>> x = 1 # x reference un entier >>> x = toto # x reference desormais une chaine >>> x = Foo () # x reference desormais une instance de Foo
En Python, ce calcul se rsume ` la possibilit pour lobjet de recevoir un message particulier. e a e Il est toutefois ` noter que cette facilit ne devrait tre utilises que sous couvert du polymorphisme, a e e e sans quoi la lisibilit du programme sen trouve rduite. e e
3 2

c 2003-2007, Raphal Marvie e

1.2 Structures de base

13

1.2.3

Arithmtique e

Python permet dexprimer tr`s simplement des oprations arithmtiques. Dans le cas e e e o` tous les oprandes sont des entiers, alors les rsultats seront aussi des entiers. Lorsu e e quau moins un des oprandes est de type rel, alors tous les oprandes sont automatie e e quement convertis en rels. La colonne de droite du listing suivant prsente des oprations e e e lmentaires sur des entiers, la colonne de droite sur des rels. ee e
>>> x >>> y >>> y 3 >>> y 2 >>> y >>> y 11.0 >>> x >>> x 4.0 = 1 + 2 = 5 * 2 / x % x = 5.5 * 2

= 12.0 / 3

Dans le contexte de larithmtique, les aections peuvent prendre deux formes. Ces deux e formes ont un sens dirent. Le listing suivant prsente deux aectations qui pourraient tre e e e comprises de mani`re identique. Toutefois, la premi`re forme (ligne 2) a pour consquence e e e de crer une nouvelle instance dentier pour contenir lajout de 2 ` la valeur de x. La seconde e a forme (ligne 3) ajoute 2 ` la valeur de x sans crer de nouvelle instance. La mani`re dcrire a e e e une opration a donc un impact sur son valuation. e e
>>> x = 4 >>> x = x + 2 >>> x += 2

1.2.4

Cha nes de caract`res e

Les cha nes de caract`res se dnissent de plusieurs mani`res en Python. Il est possible e e e dutiliser indiremment des guillemets simples ou des guillemets doubles. Le choix est e souvent impos par le contenu de la cha : une cha contenant des guillemets simples e ne ne sera dclare avec des guillemets doubles et rciproquement. Pour les autres cas, cest e e e indirent. Enn, comme tout est objet en Python une cha est donc un objet. Le listing e ne suivant dclarer deux cha e nes rfrences par x et y. Enn, la cha rfrence par z est ee e ne e e e une cha de caract`res multiligne (utilisation de trois quotes / guillemets simples ou ne e doubles).
>>> x = hello >>> y = " world ! " >>> z = hello world

c 2003-2007, Raphal Marvie e

14 1.2.4.1 Concatnation e

Premiers pas

La concatnation de ces cha e nes de caract`res peut prendre deux formes. Dans les deux e cas, loprateur + est utilis pour exprimer la concatnation. La forme de droite est un e e e raccourci dcriture. e
>>> x = x + y >>> x hello world ! >>> x += y >>> x hello world !

1.2.4.2

Achage

Lachage de cha nes de caract`res ` laide de la fonction print peut se faire en e a concatnant explicitement des cha e nes (que ce soit avec loprateur de concatnation ou en e e utilisant des virgules) ou en utilisant une cha de formatage comme la fonction printf du ne langage C. Cette seconde option est un peu plus puissante, mais aussi un peu plus lourde ` utiliser. Le listing suivant prsente trois mani`re dacher des cha de caract`res. a e e ne e
>>> print I I say : hello >>> print x , hello world ! >>> print " I I say : hello say : + x world ! 2 , times 2 times say : % s % d time ( s ) " % (x , 2) world ! 2 time ( s )

1.2.4.3

Manipulations

Python ore une mthode simple pour accder aux caract`res contenus dans une cha : e e e ne une cha est manipule comme une squence indexe de caract`res. Ainsi, chaque cane e e e e ract`re est accessible directement par son index (le premier tant index 0) en utilisation e e e des crochets. En plus de cet acc`s unitaire aux caract`res, il est possible daccder ` des e e e a sous-cha nes en prcisant la tranche souhaite lindex de dbut (qui est inclu) tant spar e e e e e e de lindex de n (qui est exclu) par le caract`re :. Dans le cas des sous-cha e nes, la valeur fournie est une copie et non un acc`s ` une partie de la cha dorigine. e a ne Le listing suivant donne quelques exemples dacc`s ` un caract`re (ligne 2), ou ` une e a e a sous-cha pour le reste. La colonne de gauche prsente des acc`s ` partir du dbut de la ne e e a e cha nes (les index sont positifs). La ligne 6 signie que lon souhaite le contenu de x du quatri`me caract`re ` la n. La colonne de droite prsente des exemples de manipulation e e a e o` certains index sont donns ` partir de la n de la cha (ils sont ngatifs). Enn, la u e a ne e derni`re ligne ralise une copie de la cha x. e e ne
>>> x = hello world ! >>> x [4] o >>> x [2:4] ll

>>> x [ -3:] ld !

c 2003-2007, Raphal Marvie e

1.2 Structures de base


>>> x [3:] lo world ! >>> x [:] hello world ! >>> x [1: -1] ello world

15

1.2.5

Listes

Les listes Python sont des ensemble ordonns et dynamique dlments. Ces ensemble e ee peuvent contenir des lments de dirents types, leur seul point commun est que ce sont ee e des objets. Et comme tout est objet, les listes sont elles mmes des objets (instances de e la classe list). Lexemple suivant cre tout dabord une variable contenant la valeur vrai, e puis une liste nomme foo contenant la cha bar, lentier 12345 et le contenu de la e ne variable x.
>>> x = True >>> foo = [ bar , 12345 , x ]

Lajout dlments dans une liste se fait ` laide des mthodes append pour un ajout en ee a e n de liste, et insert, pour un ajout ` un index donn. Enn, la mthode extend ajoute a e e le contenu dune liste pass en param`tre ` la n de la liste. e e a
>>> foo . append ( new ) >>> foo [ bar , 12345 , 1 , new ] >>> foo . insert (2 , new ) >>> foo [ bar , 12345 , new , 1 , new ] >>> foo . extend ([67 , 89]) >>> foo [ bar , 12345 , new , 1 , new , 67 , 89]

La mthode index permet de conna lindex de la premi`re occurrence dun lment e tre e ee dans une liste. Dans le cas o` llment fournit en param`tre nest pas prsent, la mthode u ee e e e l`ve lexception ValueError. Lutilisation de la construction in retourne quant ` elle True e a si llment est prsent dans la liste et False sinon. ee e
>>> foo . index ( new ) 2 >>> foo . index (34) Traceback ( most recent call last ): File " < stdin > " , line 1 , in ? ValueError : list . index ( x ): x not in list >>> 34 in foo False

Les listes et les cha nes ont pour point commun le fait dtre des ensembles ordonns. e e Lacc`s ` un lment dune liste se fait donc aussi par indexation (ligne 1). Il est possible de e a ee c 2003-2007, Raphal Marvie e

16

Premiers pas

prendre une partie de liste (ligne 3) et dobtenir une copie de liste (ligne 5). Cette derni`re e manipulation est tr`s importante lors de parcours de listes (voir section 1.4.4) pour ne pas e modier la liste qui est parcourue.
>>> foo [2] new >>> foo [1: -3] [12345 , new , 1] >>> bar = foo [:] >>> bar . append (3) >>> foo [ -1:] [89] >>> bar [ -1] 3

Les listes peuvent tre fusionnes par concatnation. Ces concatnations peuvent aussi e e e e se faire par copie ou par ajout. La ligne 1 reprsente une concatnation par copie des deux e e listes existantes. La ligne 4 prsente est une copie par concatnation dlments ` une liste e e ee a existante. Enn, la ligne 7 prsente une mani`re simple de crer une liste par rptition e e e e e dun motif (qui est une sous liste).
>>> >>> [0 , >>> >>> [0 , >>> [0 , bar = [0 , 1] + [1 , 0] bar 1 , 1 , 0] bar += [2 , 3] bar 1 , 1 , 0 , 2 , 3] [0 , 1] * 3 1 , 0 , 1 , 0 , 1]

De mani`re symtrique ` lajout dlments dans une liste, il est possible den supprimer. e e a ee La mthode remove permet de supprimer la premi`re occurrence dun lment dune liste en e e ee le dsignant (ligne 1). Si llment fourni en param`tre nexiste pas dans la liste, lexception e ee e ValueError est leve (ligne 4). Loprateur del (delete) permet de dtruire tout objet e e e Python, y compris une sous liste (ligne 8).
>>> foo . remove ( new ) >>> foo [ bar , 12345 , 1 , new , 67 , 89] >>> foo . remove (34) Traceback ( most recent call last ): File " < stdin > " , line 1 , in ? ValueError : list . remove ( x ): x not in list >>> del foo [1:3] >>> foo [ bar , new , 67 , 89]

Dautres formes plus avances de manipulation de listes sont prsentes dans la section e e e 1.4.2. c 2003-2007, Raphal Marvie e

1.2 Structures de base

17

1.2.6

Listes et cha nes de caract`res e

Les listes et les cha nes de caract`res sont similaire dans leur structure et dans leur mae nipulation. Certaines mthodes disponibles sur les cha e nes manipulent les deux structures de donnes. e La mthode join disponible sur les cha permet de construire une cha de caract`re e ne ne e depuis une liste de cha nes. La cha sur laquelle est invoque la mthode join est alors ne e e utilis comme sparateur des dirents lments de la liste. e e e ee
>>> ; . join ([ a , b , c ]) a ; b ; c

De mani`re symtrique, la mthode split, disponible sur les cha e e e nes, permet de dcomposer e une cha de caract`res en une liste de sous cha ne e nes. Ce dcoupage se fait par rapport e ` un ou plusieurs caract`res (ligne 1). Dans le cas o` un entier est pass comme second a e u e argument, il prcise le nombre maximum de dcoupage. e e
>>> hello crazy world ! . split ( " " ) [ hello , crazy , world ] >>> hello crazy world ! . split (" " , 1) [ hello , crazy world ! ]

1.2.7

Tuples

Les tuples sont des ensemble ordonns et immuables dlments. Comme les listes, les e ee tuples peuvent contenir des donnes de dirents types. La ligne 1 prsente une dclaration e e e e classique (avec des parenth`ses) alors que la ligne 2 prsente la notation abrge. La virgule e e e e est importante pour prciser que lon parle dun tuple ` un lment et non de la valeur 12. e a ee Cette remarque serait valable dans la cas dune dclaration parenthse dun tuple ` un e ee a lment. ee
>>> foo = ( bar , 12345 , x ) >>> bar = 12 ,

Comme les listes, les tuples sont accessibles par indexation (ligne 1 et 3), et la construction in permet de tester lexistance (ligne 5). Cependant, une fois cr le contenu dun tuple ee ne peut tre modi. e e
>>> foo [1] 12345 >>> foo [: -1] ( bar , 12345) >>> bar in foo True

Remarque Crit`res de choix entre une liste et un tuple : e les tuples sont plus rapides ` parcourir que les listes, a c 2003-2007, Raphal Marvie e

18

Premiers pas

pour dnir des constantes, utiliser des tuples. e Il est possible de convertir des tuples vers des listes (ligne 1) et rciproquement (ligne 3). e
>>> [1 , >>> >>> (1 , list ((1 , 2 , 3)) 2 , 3] foo = tuple ([1 , 2 , 3]) foo 2 , 3)

Pour terminer, Python ore laectation multiple pour assigner direntes valeurs dee puis un tuples (ligne 1) de mani`e simultane. Ici encore, les parenth`ses peuvent tre r e e e omises (ligne 4).
>>> >>> 1 >>> >>> 2 (x , y , z ) = foo x a , b , c = foo b

1.2.8

Dictionnaires

Les dictionnaires, parfois appels tableaux associatifs, sont des ensembles non ordonns e e dlments indexs par des cls. Une cl doit obligatoirement tre immuable (cha entier ee e e e e ne, ou tuple). Dautre part, une cl est toujours unique. Un dictionnaire vide est dclar par e e e deux accolades (ligne 1). Lajout (ligne 2 et 3) et lacc`s (ligne 6) aux lments dun e ee dictionnaire se fait par indexation sur la cl associ ` llment. Lachage dun dictionnaire e ea ee (ligne 5) prsente une liste de paires ((cl : valeur)). e e
>>> mydict = {} >>> mydict [ foo ] = 456 >>> mydict [123] = bar >>> mydict {123: bar , foo : 456} >>> mydict [123] bar

Les dictionnaires orent des mthodes pour manipuler les cls. La mthode keys ree e e tourne une liste de toutes les cls du dictionnaire (ligne 1) et la mthode has_key retourne e e True so la cl donn en param`tre est prsente dans le dictionnaire et False dans le cas e e e e contraire.
>>> mydict . keys () [123 , foo ] >>> mydict . has_key ( bar ) False

c 2003-2007, Raphal Marvie e

1.2 Structures de base

19

La mthode values donne acc`s ` une liste des valeurs contenues dans le dictionnaire e e a (ligne 1) et la mthode items donne une liste de tuples, contenant chacun une paire cl, e e valeur (ligne 3)..
>>> mydict . values () [ bar , 456] >>> mydict . items () [(123 , bar ) , ( foo , 456)]

La modication dune valeur associe ` une cl se fait simplement en aectant de e a e nouveaux la valeur indexe dans le dictionnaire par la cl en question (ligne 1). Enn, e e loprateur del permet de supprimer une association association du dictionnaire (ligne 4). e
>>> mydict [123] = 789 >>> mydict {123: 789 , foo : 456} >>> del mydict [ foo ] >>> mydict {123: 789}

A laides des mthodes de manipulation des cl et des valeurs, il est possible de parcourir e e un dictionnaire de plusieurs mani`res. Les quelques lignes suivantes donnent deux exemples e de parcours.
>>> flames = { windows : bof , unix : cool } >>> for key in flames . keys (): ... print key , is , flames [ key ] ... windows is bof unix is cool >>> for key , value in flames . items (): ... print key , is , value ... windows is bof unix is cool

Ce dernier exemple prsente un parcours de dictionnaire avec une utilisation dun list e mapping et dune cha de formatage (dont lutilisation ne se limite pas ` lachage). ne a
>>> bar = { a : aa , b : bb , c : cc } >>> [ " % s =% s " % (x , y ) for x , y in bar . items ()] [ a = aa , c = cc , b = bb ]

c 2003-2007, Raphal Marvie e

20

Premiers pas

1.3
1.3.1

Constructions
Structuration et indentation

La structuration dun programme Python est dnie par son indentation. Le dbut e e dun bloc est dni par un :, la premi`re ligne pouvant tre considre comme un en-tte e e e ee e (test, boucle, dnition, etc.). Le corps du bloc est alors indent de mani`re plus importante e e e (mais rguli`re) que len-tte. Enn, la n du bloc est dlimit par le retour ` lindentation e e e e e a de len-tte. Les bloc peuvent tre imbriqus e e e
<en - tete >: < instructions >

Dans le cas de bloc de taille rduite, par exemple une seule instruction, un bloc peut e tre dni sur une seule ligne. Le caract`re : sert toujours de dlimiteur entre len-tte e e e e e 4 et le corps. Les instructions du corps sont alors spars par des ; . Cependant, cette e e utilisation nest pas ncessairement bnque quant ` la lisibilit du code, elle est donc ` e e e a e a viter5 . e
>>> <en - tete >: < instruction > ; < instruction >

Cette structuration est utilise aussi bien pour dnir des boucles, des tests, des fonce e tions, des classes ou des mthodes. e

1.3.2

Tests

Conditions boolennes En Python, tout ce qui nest pas faux est vrai. Les conditions e boolennes fausses se rsument au donnes ((vide)) : False, 0, "", [], {}, (), None. e e e Python ore une seule construction pour raliser des tests : le if then else. Une pare ticularit de cette mise en uvre est la possibilit dencha e e ner les tests avec la construction elif.
if x == hello : print hello too ! elif x == bonjour : print bonjour aussi ! else : print moi pas comprendre

Les comparaisons entre squences (cha e nes de caract`res, listes et tuples) se fait selon e lordre lexicographique. Les deux tests suivants sont vrais.
(1 , 2 , 3) < (1 , 2 , 4) (1 , 2 , 3) < (1 , 2 , 3 , 4)
Lutilisation des ; en Python est optionnelle en n de ligne et peut toujours tre utilise pour sparer e e e deux instructions sur une mme ligne. e 5 Lpoque o` les caract`res taient compts dans une chier est bien rvolue. e u e e e e
4

c 2003-2007, Raphal Marvie e

1.3 Constructions

21

1.3.3

Boucles

Deux types de boucles sont disponibles : les boucles numres (for) et les boucles e ee bases sur un test de n (while). Ces deux constructions suivent le mme schma : un e e e en-tte qui dcrit lvolution de la boucle, un ensemble dinstructions qui sont values ` e e e e e a chaque tour de boucle et une partie optionnel qui est value en sortie de boucle (introduite e e par le mot-cl else). Enn, comme en C les boucles peuvent contenir les branchements e continue pour passer ` litration suivante et break pour sortir de la boucle (dans ce cas a e la clause else nest pas value). e e 1.3.3.1 Boucles for

Une boucle for dnit une variable qui prend successivement toutes les valeurs de la e squence (liste ou tuple) parcourue (ligne 1). La clause else est valu lorsque la squence e e e e est puise et sil ny a pas eu de break (ligne 3). e e
for <var > in < sequence >: < instructions > else : < instructions , sequence epuisee sans break >

La fonction range produit une liste de tous les entiers entre une borne infrieur et une e borne suprieur. Cette construction est utile lorsquune boucle for repose sur lutilisation e dune squence dentiers. La fonction range est utilisable de trois mani`res : e e un seul param`tre spciant le nombre dlments (ligne 1), e e ee deux param`tres spciant la borne infrieure (inclue) et suprieure (exclue) (ligne e e e e 3), trois param`tres spciant les bornes et le saut (incrment entre deux lments de la e e e ee squence) (ligne 5). e
>>> [0 , >>> [3 , >>> [0 , range (6) 1 , 2 , 3 , 4 , 5] range (3 , 7) 4 , 5 , 6] range (0 , 10 , 3) 3 , 6 , 9]

Boucle for parcourant une squence de cha (ligne 2-3) et parcourant une liste de e ne valeurs (ligne 7-8) pour accder aux lments dune liste. Sil est ncessaire de parcourir e ee e une squence tout en connaissant lindex de llment courant, la fonction enumerate est e ee une solution plus ((pythonesque)) (ligne 11-12).
>>> a = [ hello , world ] >>> for elt in a : ... print elt ... hello world

c 2003-2007, Raphal Marvie e

22
>>> for ... ... 0 hello 1 world >>> for ... ... 0 hello 1 world idx in range ( len ( a )): print idx , a [ idx ]

Premiers pas

idx , val in enumerate ( a ): print idx , val

1.3.3.2

Boucles while

Une boucle while dnit une condition boolenne avec les mme r`gles que pour les e e e e tests (ligne 1). Tant que cette condition est respecte, les instruction du bloc associ au e e while sont values. La clause else est valu losrque la condition est fausse et quil ny e e e e a pas eu de break (ligne 3).
while < condition >: < instructions > else : < instructions , condition fausse >

La boucle suivante reprsente la boucle minimale dnissable avec un while. Certes, e e elle est stupide mais elle permet dillustrer lutilisation du Ctrl-C pour interrompre un traitement en cours dexcution. e
>>> while 1: ... pass ... Traceback ( most recent call last ): File " < stdin > " , line 1 , in ? KeyboardInt errupt

1.3.4

Fonctions

Il ny a que des fonctions en Python. Une fonction est dnie avec le mot cl def. Une e e fonction retourne toujours une valeur. Si une fonction ne contient pas de clause return, la valeur None est alors retourne6 . e
>>> def fib ( n ): # suite de fibonacci jusque n ... a, b = 0, 1 ... while b < n : ... print b , ... a, b = b, a + b
6

Il est ventuellement possible de parler de procdure dans ce cas e e

c 2003-2007, Raphal Marvie e

1.3 Constructions
... >>> fib (100) 1 1 2 3 5 8 13 21 34 55 89

23

Les param`tres dune fonction peuvent tre dnis avec une valeur par dfaut. A lutilie e e e sation de la fonction, ces param`tres sont alors optionnels. Dans le cas dune fonction avec e des param`tres optionnels, lutilisation des param`tres doit tre ordonne, les param`tres e e e e e sont aects dans lordre de leur dnition (ligne 6), ou nomme (ligne 8). e e e
>>> def welcome ( name , greeting = Hello , mark = ! ): ... print greeting , name , mark ... >>> welcome ( world ) Hello world ! >>> welcome ( monde , Bonjour ) Bonjour monde ! >>> welcome ( world , mark = ... ) Hello world ...

Python permet de dnir des fonctions anonymes, en utilisant la forme lambda 7 . Une e telle fonction est rduite ` une simple expression. Cette construction est utile pour passer e a des fonctions en param`tre dautre fonctions pour les congurer8 ou dans le cas des list e mappings (voir section 1.2.5).
>>> def compare (a , b , func =( lambda x , y : x < y )): ... return func (a , b ) ... >>> compare (1 , 2) 1 >>> compare (2 , 1 , func =( lambda x , y : x > y )) 1

1.3.5

Documenter

La documentation fait partie intgrante du code. En plus de la possibilit de mettre e e des commentaires avec lutilisation de #, Python ore la possibilit dcrire du code autoe e document. Ceci est valable pour les fonctions, les classes et les modules. Une telle doe cumentation dun lment est accessible vie lattribut __doc__ de ces dirents lments. ee e ee Cette technique est utilisable automatiquement par les environnements intgrs de dveloppement e e e ou par lutilisation de la fonction help en mode interactif. La dnition des commentaires avec # devrait tre rserv aux remarques techniques e e e e sur le code et pour les dveloppeur de llment en question. La documentation doit quant e ee ` elle tre destine au dveloppeurs mais surtout aux utilisateurs de llment document. a e e e ee e
7 8

Ici encore, cela sent la programmation fonctionnelle type Lisp ` plein nez. . . a Nous verrons un peu plus tard que ce nest pas la seule possibilit. e

c 2003-2007, Raphal Marvie e

24

Premiers pas

Elle doit donc reter le comportement de llment. Cette seconde forme est ` mettre en e ee a parall`le avec la javadoc. e La dnition de la documentation se fait sur la premi`re ligne apr`s la dclaration en e e e e utilisant des cha nes de caract`res multi-lignes9 en utilisant des guillemets doubles (ligne e 2-5). Une bonne mani`re de dnir la documentation est de fournir une version courte sur e e une ligne, de passer une ligne et de fournir des dtails. e
>>> def dummy (): ... " " " Cette fonction est du pipeau ... ... ... Cette fonction est vraiment du pipeau , ... elle ne fait absolument rien . " " " ... pass ... >>> help ( dummy ) Help on function dummy in module __main__ : dummy () Cette fonction est du pipeau ... Cette fonction est vraiment du pipeau , elle ne fait absolument rien .

1.4
1.4.1

Autres lments sur les squences ee e


Fonctions de manipulation de squences e

Python ore un certain nombre de fonction permettant dappliquer des traitements sur tous les lments dune squence an de dnir des ltres, dappliquer des calculs pour ee e e tous ou de calculer des hashcode. 1.4.1.1 filter

La fonction filter applique la fonction passe en premier argument sur chacun des e lments de la squence passe en second argument et retourne une nouvelle liste qui ee e e contient tous les lments de la squence pour lesquels la fonction a retourn une valeur ee e e vrai.
>>> def funct1 ( val ): ... return val > 0 ... >>> filter ( funct1 , [1 , -2 , 3 , -4 , 5]) [1 , 3 , 5]
9

Mme si la documentation tient sur une seule. e

c 2003-2007, Raphal Marvie e

1.4 Autres lments sur les squences ee e


>>> def iseven ( x ): ... return x % 2 ... >>> filter ( iseven , [1 , 2 , 3 , 4 , 5 , 6]) [1 , 3 , 5]

25

1.4.1.2

map

La fonction map applique la fonction passe en premier argument sur chacun des e lments de la ou des squences passes en param`tre. Dans le cas o` plusieurs squences ee e e e u e sont passes en param`tre, la fonction doit prendre autant de param`tres quil y a de e e e squences. map retourne une liste contenant le rsultat de chacun des calculs. e e
>>> ... ... >>> [5 , >>> [1 , def sum (x , y ): return x + y map ( sum , [1 , 2 , 3] , [4 , 5 , 6]) 7 , 9] map ( iseven , [1 , 2 , 3 , 4 , 5 , 6]) 0 , 1 , 0 , 1 , 0]

1.4.1.3

reduce

La fonction reduce rduit une squence par lapplication rcursive dune fonction sur e e e chacun de ses lments. La fonction passe comme premier param`tre doit prendre deux ee e e arguments. La fonction reduce prend un troisi`me param`tre optionnel qui est la valeur e e initiale du calcul rcursif. e
>>> reduce ( sum , [1 , 2 , 3 , 4 , 5]) 15 >>> reduce ( sum , [1 , 2 , 3 , 4 , 5] , -5) 10

1.4.2

Listes en comprhension e

La dnition de listes en comprhension10 permet de crer des listes de mani`re concise e e e e sans utiliser aux fonctions map, filter, etc. Lexemple suivant (ligne 2) permet dappliquer une mme opration ` tous les lments e e a ee dune liste. Cet exemple est donc similaire ` lutilisation de la fonction map. La suite (ligne a 4) permet de ne slectionner que certains lments de la liste, ici les nombres impaires. e ee Cet exemple est similaire ` lutilisation de la fonction filter. La ligne 6 montre une a combinaison des deux formes, en levant au carr les nombres pairs de la liste foo. e e
Comprhension : Ensemble des caract`res qui appartiennent ` un concept et servent ` le dnir. Dnir e e a a e e un ensemble en comprhension. Par opposition ` en extension. e a
10

c 2003-2007, Raphal Marvie e

26
>>> >>> [2 , >>> [1 , >>> [4 , foo = [1 , 2 , 3 , 4] [ elt * 2 for elt in foo ] 4 , 6 , 8] [ elt for elt in foo if elt % 2] 3] [ elt **2 for elt in foo if elt % 2 is 0] 16]

Premiers pas

Il est enn ` noter que lutilisation de ces constructions est en gnral plus performante a e e que lutilisation dune boucle for. En eet, leur mise en oeuvre est faite au coeur de linterprteur au lieu dtre interprte. e e ee

1.4.3

Itrateurs et gnrateurs e e e

Les itrateurs (PEP 234) et les gnrateurs (PEP 255) sont apparus avec les versions e e e 2.2 et 2.3 de Python. Ils sont monnaie courante en Python 2.4. 1.4.3.1 Itrateurs e

Lapparition des itrateurs a modi la philosophie des boucles for pour le parcours de e e squences. Dans les version prcdentes de Python, litration sur une squence se faisait e e e e e en utilisant lindex pour accder aux lments de la squence. Lorsque la squence tait e ee e e e termine, lexception IndexError (voir section 3.4 pour les exceptions) signalait la n de e litration. e Dsormais, un itrateur est un objet (voir le chapitre 3 pour les objets) auquel on dee e mande llment suivant. Lorsquil ny a plus de suivant, lexception StopIteration signale ee la n de litration. Les types de bases comme les listes, dictionnaires, tuples retournent e dsormais des itrateurs pour leur parcours. Ces itrateurs sont utiliss automatiquement e e e e par les boucles for et par loprateur in par exemple. e 1.4.3.2 Gnrateurs e e

Les gnrateurs peuvent tre considrs comme une volution des listes en comprhension. e e e ee e e Syntaxiquement, les [] deviennent des (), comme le montre lexemple suivant. Une des dirences entre les deux formes concerne lutilisation de la mmoire : un gnrateur ne e e e e construit pas toute la squence en mmoire a priori, mais chaque lment de la squence e e ee e est produit lorsque ncessaire. Pour obtenir une squence construite par un gnrateur, il e e e e sut de passer le gnrateur en param`tre de la construction dune liste11 (ligne 8). e e e
>>> ( elt * 2 for elt in foo ) >>> g = ( elt * 2 for elt in foo ) >>> g < generator object at 0 x38cf80 >
En Python 2.4, la notation des listes en comprhension revient ` la construction dune liste ` partir e a a dun gnrateur. e e
11

c 2003-2007, Raphal Marvie e

1.4 Autres lments sur les squences ee e


>>> ... 2 4 >>> [2 , for i in g : print i , 6 8 list ( elt * 2 for elt in foo ) 4 , 6 , 8]

27

La dnition de fonctions gnrateurs se fait en utilisant le mot cl yield. Le droulement e e e e e de la fonction est interrompu ` chaque utilisation de yield, le reste sera valu lorsque a e e lappelant demandera le prochain lment. Le yield peut tre considr comme un return ee e ee qui ne met pas n ` lexcution de la fonction. a e Lorsquil est appel, un gnrateur retourne un itrateur, ce qui permet une utilisation e e e e dans une boucle for comme dans lexemple suivant. Cest lutilisation de litrateur ree tourn qui pilote le droulement du gnrateur : lexcution sarrte sur le yield qui est e e e e e e valu ` chaque appel du suivant sur litrateur. e ea e
>>> def generateur (): ... i = 0 ... while i < 10: ... yield i ... i += 1 ... >>> for i in generateur (): ... print i , ... 0 1 2 3 4 5 6 7 8 9

1.4.4

Boucles for problmatiques e

Certaines boucles de manipulation des listes peuvent tre problmatiques, par exemple e e si la boucle modie la liste quelle est en train de parcourir. Pour que ce genre de boucle se passe bien, et ne soit pas sans n, il est important dans certains cas de faire une copie de la liste pour le parcours et de travailler sur la version originale de la liste. Par dfaut, tout e argument est pass par rfrence et donc sans copie (en fait copie de la liste des rfrences e ee ee 12 et non des objets contenus) la boucle suivante serait sans n .
>>> >>> ... ... >>> [5 ,
12

a = [1 , -2 , 3 , -4 , 5 , -6] for elt in a [:]: if elt > 0: a . insert (0 , elt ) a 3 , 1 , 1 , -2 , 3 , -4 , 5 , -6]

Cette boucle rajoute les lments positifs en dbut de liste, comme le premier lment est positif cette ee e ee boucle est toujours sur llment 1 alors que la liste ne fait que cro ee tre.

c 2003-2007, Raphal Marvie e

28

Premiers pas

1.5
1.5.1

Exercices
Manipulations de donnes e

Le chier listetu.py contient une liste de 10 dictionnaires. Etudier cette structure de donnes et crire une fonction qui crit sur la sortie standard (en sautant une ligne entre e e e chaque che) :
dossier nom prenom universite discipline niveau moyenne : : : : : : : 1 doe john lille1 informatique 4 17

c 2003-2007, Raphal Marvie e

Chapitre 2 Quelques modules et built-in


2.1
2.1.1

Dnition et utilisation de modules e


Dnition e

Dans le chapitre prcdent, lensemble des extraits de code ont t saisis interactivee e ee ment. Cette mthode nest pas viable pour les traitements que lon excute plusieurs fois e e ou que lon souhaite excuter sur plusieurs machines. Pour rendre le code persistant, la e premi`re solution est dcrire un ((programme)), cest-`-dire de saisir le code dans un chier e e a texte avec lextension .py. Un programme peut ainsi tre excut plusieurs fois. Cepene e e dant, mme si ce programme est correctement structur avec des fonctions, il nest pas e e possible de rutiliser facilement ces derni`res (si ce nest avec un copier-coller qui est une e e abomination). Pour capitaliser les dveloppement, Python propose la notion de module. Un module e permet de fournir des biblioth`ques de fonctions, structures de donnes, classes, ` intgrer e e a e dans les programmes. Dans le cas de python, produire un module est identique ` produire a un programme : faire un chier. Les dnitions contenues dans un chier sont utilisable e globalement ou unitairement. Ainsi, le chier examples.py peut tre utilis comme un e e module (nomm comme le chier) et orir lacc`s aux deux fonctions ` tout programme e e a 1 en ayant lutilit . e La cha de documentation doit tre mise avant toute dclaration (cest-`-dire aussi ne e e a avant les clauses import) pour tre considre comme documentation du module. Les deux e ee premi`res lignes de ce chier (optionnelles) ont la signications suivante : e la premi`re ligne de ce chier indique que ce chier sera reconnu comme un proe gramme Python par un environnement Unix (sil a les droits en excution)2 ; e la seconde ligne prcise le type dencodage du chier : ici lencodage standard en Eue rope occidentale supportant la gestion des accents. D`s quun chier Python contient e un accent, cette ligne est oligatoire (dans le cas contraire elle peut tre omise). e
1 2

Si un programme a besoin de ces fonctions, cest un programme tr`s ((social) au vu de leur utilit. . . e ) e La construction # ! sert ` prciser, sous Unix, le programme ` utiliser pour excuter un script. a e a e

29

30 #! /usr/bin/env python # -*- coding: iso-8859-1 -*# # examples.py #

Quelques modules et built-in

""" Regroupe les dfinitions des fonctions relatives au chapitre 1 de e Initiation a python par lexemple. """ def fib(n): """Calcule la suite de Fibonacci jusque n""" a, b = 0, 1 while b < n: print b, a, b = b, a + b def welcome(name, greeting=Hello, mark=!): """Un hello world configurable""" print greeting, name, mark Utilisation dun module La construction import permet dimporter un module et de fournir acc`s ` son contenu3 . Limportation dun module peut se faire de deux mani`re. e a e La premi`re solution est de dsigner le module que lon souhaite utiliser, son contenu est e e alors utilisable de mani`re ((scope)), cest-`-dire en prxant le nom de la fonctionnalit e e a e e du nom du module (ligne 2). La seconde solution repose sur la construction from import o` lon identie la ou les fonctionnalits que lon souhaite importer dun module (ligne u e 4)4 . Lutilisation se fait alors sans prxer par le nom de module (((non scop))). Enn, e e il est possible dimporter, avec cette seconde approche, tous les lments dun module en ee utilisant la notation * (ligne 7).
>>> import examples >>> examples . welcome ( rafi ) Hello rafi ! >>> from examples import welcome >>> welcome ( rafi ) Hello rafi ! >>> from examples import * >>> fib (100) 1 1 2 3 5 8 13 21 34 55 89
3 4

Nous considrons ici que linterprteur a t lanc dans le rpertoire contenant le chier examples.py. e e ee e e Dans le cas dun import de plusieurs fonctionnalits, les noms sont spars par des virgules. e e e

c 2003-2007, Raphal Marvie e

2.1 Dnition et utilisation de modules e

31

Utilisation mixte Un chier peut ` la fois dnir un module et un programme. Cette a e dnition mixte est intressante pour, par exemple, utiliser les fonctionnalits dun proe e e gramme indpendamment de celui-ci, ou pour associer le code de test ` un module. Dans ce e a cas, la n du chier contient la dnition de linitialisation du code comme un programme. e Pour cela, un test est ralis an de savoir si le code est import ou excut. Si le code e e e e e est import, la variable __name__ contient le nom du module, sinon elle contient la cha e ne __main__ (ligne 1). Ici, dans le cas dune excution certaines des fonctions du module sont e testes. (Sinon il ne se passe rien.) e
if __name__ == __main__ : welcome ( world ) welcome ( monde , Bonjour ) welcome ( world , mark = ... ) fib (100)

Lutilisation du chier examples comme un programme donne la trace dexcution e suivante. Que lon utilise explicitement linterprteur ou non (du fait de la premi`re ligne e e du chier) la trace est identique.
$ python examples . py Hello world ! Bonjour monde ! Hello world ... 1 1 2 3 5 8 13 21 34 55 89 \ begin { verbatim } $ ls -l total 100 - rwxr -x - - - 1 rafi rafi 1046 2005 -03 -11 11:51 examples . py * $ ./ examples . py Hello world ! Bonjour monde ! Hello world ... 1 1 2 3 5 8 13 21 34 55 89

Remarques Lors de lutilisation de la construction import, linterprteur recherche la e disponibilit des modules demand dans le chemin dcrit par la variable denvironnement e e e PYTHONPATH. La valeur par dfaut de cette variable contient le rpertoire dinstallation de e e Python et le rpertoire courant. e Lors de lutilisation de la construction from module import *, tout le contenu du module est import ` lexception des dnition dont le nom commence par un _ (qui e a e re`tent la notion de priv en Python). Lutilisation de ce type dimportation all`ge le e e e code saisi, ce qui est intressant en interactif. Toutefois, une fois le prxage par le nom e e de module perdu il peut de nouveau y avoir des conits de noms entre les fonctionnalits e importes depuis plusieurs modules. e Enn, les modules peuvent tre organiss selon une structure hirarchique. Dans ce cas, e e e c 2003-2007, Raphal Marvie e

32

Quelques modules et built-in

les modules contenant des sous-modules, encore nomms packages, sont dnis comme des e e rpertoires sur le syst`me de chier. Le nommage des modules se fait alors par concatnation : e e e mod.submod. An de faciliter la portabilit du code, tout rpertoire doit contenir un chier e e nomm __init__.py. Pour permettre le chargement de tous les sous-modules, ce chier e doit contenir la liste des modules du package (rprtoire) stocke dans la variable __all__. e e
$ cat graphical / __init__ . py __all__ = [ basic , advanced ]

2.2

Quelques modules standards et utiles

Python ore grand nombre de modules. Ne sont prsents ici que les quatre modules e e considrs comme incontournables : ee sys fournit les param`tres et fonctions lies ` lenvironnement dexcution, e e a e string fournit des oprations courantes sur les cha e nes de caract`res (quivalentes aux e e mthodes de la classe string), e re fournit le support des expressions rguli`res pour faire du pattern matching et des e e substitutions, os fournit lacc`s aux services gnrique du syst`me dexploitation. e e e e Pour chacun de ces modules, les fonctionnalits de base sont prsentes et illustres sur e e e e des exemples.

2.2.1

Le module sys

Quelques constantes oertes par le module sys : argv Squence des param`tres pass sur la ligne de commande (argv[0] reprsente le nom e e e e du script). stdin stdout stderr Objets de type file reprsentant les entres et sorties standard. e e Ces objets peuvent tre remplacs par tout objet orant une mthode write. e e e path Squence contenant les chemins de la variable denvironnement PYTHONPATH. Cette e squence peut tre manipule dynamiquement. e e e
>>> sys . path . append ( / tmp / python ) [ , / usr / lib / python2 .2 , / usr / lib / python2 .2/ plat - linux2 , / usr / lib / python2 .2/ lib - tk , / usr / lib / python2 .2/ lib - dynload , / usr / lib / python2 .2/ site - packages , / tmp / python ]

platform Nom du syst`me dexploitation. e


>>> sys . platform darwin

ps1, ps2 Variables contenant les valeurs des prompts, par dfaut >>> et .... e c 2003-2007, Raphal Marvie e

2.2 Quelques modules standards et utiles Quelques fonctions oertes par le module sys :

33

exit([arg]) Mettre n ` lexcution dun programme, arg tant le status de sortie. Cette a e e fonction respecte le nettoyage des clauses finally (voir section 3.4.2.2).

2.2.2

Le module string

Ce module fournit un certain nombre de constantes et de fonctions de manipulation des cha nes de caract`res. Il est gnralement recommand dutiliser les mthodes disponibles e e e e e sur les objets de type string quivalentes. e 2.2.2.1 Quelques constantes

Des constantes pratiques oertes par le module string dnissent des ensembles de e caract`res : e
>>> string . lowercase abcdefghijklmnopqrstuvwxyz >>> string . uppercase ABCDEFGHIJKLMNOPQRSTUVWXYZ >>> string . letters abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ >>> string . digits 0123456789 >>> string . whitespace \ t \ n \ x0b \ x0c \ r >>> string . punctuation !"# $ %&\ ()*+ , -./:; <= >? @ [\\]^ _ {|}~

2.2.2.2

Les fonctions principales

lower upper cap* permettent de grer la casse dune cha de caract`res : mise en mie ne e nuscules, en majuscules, capitalisation de la phrase ou des mots (avec la rduction e des espaces).
>>> string . lower ( FOO ) foo >>> string . upper ( foo ) FOO >>> string . capitalize ( foo ) Foo >>> string . capwords ( hello Hello World !

world ! )

strip expandtabs permettent de grer les espaces dans une cha de caract`res en supe ne e primant les blancs non signicatifs ou en remplaant les tabulations par un nombre c xe despaces. c 2003-2007, Raphal Marvie e

34

Quelques modules et built-in


>>> string . strip ( hello world ! \ n ) # [2 nd arg ] hello world ! >>> string . expandtabs ( \ thello world ! , 4) hello world !

find permet de rechercher un motif dans une cha (` partir du dbut ou de la n pour ne a e rfind) en retournant lindice o` le motif est trouv pour la premi`re fois ou -1. (La u e e fonction index est similaire mais l`ve une exception pour un motif non trouv.) e e
>>> string . find ( bonjour le monde , on ) 1 >>> string . rfind ( bonjour le monde , on ) 12 >>> string . rfind ( bonjour le monde , om ) -1

split permet de dcouper une cha en une liste de mots (par dfaut sur les espaces, ou e ne e alors sur une cha passe en second argument) et join permet lopration inverse ne e e qui est de construire une cha ` partir dune liste de mots et une cha de liaison. ne a ne
>>> string . split ( foo bar 123 ) [ foo , bar , 123 ] >>> string . split ( " hello world " , " wo " ) [ hello , rld ] >>> string . join ([ foo , bar , 123 ] , ; ) foo ; bar ;123

count replace permettent respectivement de compter les occurence dun motif dans une cha et le remplacement de ce motif par un autre. ne
>>> string . count ( bonjour le monde , on ) 2 >>> string . replace ( bonjour le monde , on , ONON ) bONONjour le mONONde

zfill center rjust ljust permettent de grer lachage : zfill compl`te un nombre e e avec des zros en tte pour une largeur dachage constant, les trois autres fonctions e e permettent de justier une phrase sur une largeur donne. e
>>> string . zfill ( str (123) , 5) 00123 >>> string . center ( hi ! , 10) hi ! >>> string . rjust ( hi ! , 10) hi ! >>> string . ljust ( hi ! , 10) hi !

c 2003-2007, Raphal Marvie e

2.2 Quelques modules standards et utiles

35

2.2.3

Le module re

Ce module permet la manipulation des expressions rguli`res [2]. Ces expressions sont e e par dfaut identiques ` Perl et louvrage ((Mastering Regular Expressions)) de Jerey Friedl e a (OReilly) est un bon complment pour qui doit utiliser les expressions rguli`res. An de e e e ne pas devoir toujours utiliser des \ dans les expressions, il est possible dutiliser des Raw regular expressions en prxant la cha dnissant lexpression par un r : r(.*)\n. La e ne e derni`re question quil faut se poser avant de commencer ` utiliser les expressions rguli`res e a e e est lencodage support. Le module re peut utiliser lun ou lautre de ces deux modules : e sre Support unicode (module utilis par dfaut, implmentation masque par re) e e e e pre Sans support unicode (mais ce module est dsormais deprecated ) e 2.2.3.1 Oprations de recherche e

search(pattern, chaine) permet de rechercher le pattern dans la cha et retourne ne un objet de type SRE_Match dcrivant la rponse ou bien None. La classe SRE_Match e e fournit des mthodes pour obtenir lindice de dbut (start()) et de n (end()) du e e motif dans la cha ne. Ici, la mthode matching utilise span() qui fournit un tuple e contenant les deux indices.
>>> def matching ( res ): ... if res : print res . span () ... else : print no matching >>> matching ( re . search ( ada , abracadabra )) (5 , 8)

match(pattern, chaine) test si la cha commence par le pattern et retourne un objet ne de type SRE_Match dcrivant la rponse ou bien None. e e
>>> res = re . match ( abr , abracadabra ) >>> matching ( res ) (0 , 3)

2.2.3.2

Oprations de manipulation e

split(pattern, chaine) dcoupe la cha par rapport au pattern. Lexemple suivant e ne fait un dcoupage en mots (tout ce qui nest pas espace ou ponctuation). e
>>> re . split ( \ W + , Hello world ! ) [ Hello , world , ]

sub(pattern, repl, chaine) retourne une cha ou toutes les occurences du pattern ne dans la cha fournie sont remplacs par repl. La cha nest pas modie, une ne e ne e copie est cre. ee
>>> re . sub ( hello , bonjour , hello foo hello bar ) bonjour foo bonjour bar

c 2003-2007, Raphal Marvie e

36 2.2.3.3 Utilisation dexpressions compiles e

Quelques modules et built-in

Lorsquune expression rguli`re est utilise de mani`re rptitive dans un programme, il e e e e e e devient intressant de compiler le pattern. Les fonctionnalits sont similaires ` celles vues e e a prcdamment (mthodes) mais la performance est meilleure. e e e compile permet la cration dun objet reprsentant lexpression rguli`re sous forme e e e e compile. Un fois lobjet cr, les fonctions sont appeles sur cet objet et non par e ee e rapport au module. La mthode group() sur lobjet SRE_Match donne acc`s au i-`me e e e 5 motif (dans le cas dune expression compose de plusieurs motifs comme ici) trouv e e par la fonction search.
>>> exp = re . compile ( <a href ="(.*)" >(.*) </ a > ) >>> res = exp . search ( Cliquer <a href =" foo . html " > ici </ a >! ) >>> matching ( res ) (8 , 34) >>> res . group (0) <a href =" foo . html " > ici </ a > >>> res . group (1) foo . html >>> res . group (2) ici >>> exp = re . compile ( r .* < a href ="(.*)" >.* </ a >.* ) >>> exp . sub ( r \1 , Cliquer <a href =" foo . html " > ici </ a >! ) foo . html

2.2.4

Le module os

Ce module permet daccder aux fonctions des syst`mes dexploitation et de faire de la e e programmation syst`me ou de ladministration. Les fonctions sont disponibles sur (presque) e tous les syst`me. Toutefois, il faut toujours tre conscient des limites pour la portabilit e e e du code : la notion de droits sur un chier nest pas similaire sur tous les syst`mes. e Les principaux sous modules de os sont : path manipulation de chemins, glob fnmatch pattern matching de chiers et rpertoires, e time acc`s et manipulation de lheure, e getpass manipulation de mots de passe et identiants. utilisateur 2.2.4.1 Quelques constantes

name donne le nom de limplementation du module os : posix, nt, dos, mac, java, etc. environ Dictionnaire contenant les variables denvironnement (au sens Unix mais aussi relatives au lancement de linterprteur Python). e
5

Un motif au sein dune expression rguli`re est dni par des parenth`ses. e e e e

c 2003-2007, Raphal Marvie e

2.2 Quelques modules standards et utiles


>>> os . environ { USER : rafi , HOME : / home / rafi , PATH : / bin :/ usr / bin :/ opt / bin :/ home / rafi / bin , HOSTNAME : alfri . lifl . fr , PWD : / home / rafi / enseign / python / scripts }

37

2.2.5

Le module os.path

Ce module fournit quelques primitives (courantes sous Unix) de manipulation des noms de chiers et des chiers. basename dirname permettent respectivement dextraire dun chemin le nom du chier ou le nom du rpertoire (ou de larborescence dans le cas dun chemin compos). e e
>>> os . path . basename ( / tmp / foo . txt ) foo . txt >>> os . path . dirname ( / tmp / foo . txt ) / tmp

split join permettent respectivement de dcouper et de construire un chemin. Lutilie sation de la fonction join est fortement recommande pour construire des chemin e car elle respecte implicitement le bon sparateur de chemin pour le syst`me courant. e e
>>> os . path . split ( / tmp / foo . txt ) ( / tmp , foo . txt ) >>> os . path . join ( / tmp , foo . txt ) / tmp / foo . txt

exists isdir isfile permettent de tester lexistance et le type dun chier (ou rpertoire). e
>>> os . path . exists ( / tmp / bar . txt ) False >>> os . path . isdir ( / tmp ) True >>> os . path . isfile ( / tmp ) False

2.2.6

Les modules glob et fnmatch

Ces deux modules fournissent principalement une fonction portant le mme nom. e glob est lquivalent du ls Unix. Cette fonction retourne une liste des chiers dun e rpertoire avec utilisation de jockers. e
>>> glob . glob ( *. py ) [ hello . py , examples . py ] >>> glob . glob ( / tmp /*. tmp ) [ / tmp / sv3e2 . tmp , / tmp / sv001 . tmp , / tmp / sv3e4 . tmp ]

c 2003-2007, Raphal Marvie e

38

Quelques modules et built-in

fnmatch et filter permettent de faire du pattern matching sur des cha nes de caract`res e reprsentant des noms de chiers : respectivement est ce quun nom suit un pattern e de nommage et quels sont les lments dune liste respectant un pattern. ee
>>> fnmatch . fnmatch ( examples . py , *. py ) 1 >>> fnmatch . filter ([ examples . py , hello . pyc ] , *. py ) [ examples . py ]

2.2.7

Le module getpass

Ce module permet de demander au syst`me le nom de lutilisateur connect et de e e demander de mani`re ((cache)) un mot de passe. e e getuser() demande au syst`me le nom de login de lusager e
>>> getpass . getuser () rafi

getpass() demande proprement (en masquant les caract`res saisis) un mot de passe ` e a lusager. Lappel ` cette fonction est bloquant jusqu` ce que lusager ait tap entre. a a e e
>>> p = getpass . getpass () # bloquant jusqu au \ n Password : >>> print p q u e l mau v ais m o t d e p a s s e

2.3

Built-in en Python

Les built-in sont les fonctionnalits cables en dur dans linterprteur Python, et dans e e e un certain sens linterprteur lui-mme. Ces fonctionnalits ne sont pas crite en Python e e e e car elles sont plus que largement utilises et leur mise en uvre en C contribue ` obtenir e a de meilleures performances.

2.3.1
2.3.1.1

Les chiers
Les objets chiers

Les chiers sont reprsents comme des objets de type file. Ils peuvent tre textuels e e e ou binaires et tre utiliss en lecture ou en criture. e e e open ouvre un chier (cre lobjet associ) en lecture par dfaut. e e e
>>> foo = open ( / tmp / foo . txt ) >>> foo < open file / tmp / foo . txt , mode r at 0 x81a3fd8 >

c 2003-2007, Raphal Marvie e

2.3 Built-in en Python close ferme un chier (mais ne dtruit pas lobjet associ). e e
>>> foo . close () >>> foo < closed file / tmp / foo . txt , mode r at 0 x81a3fd8 >

39

2.3.1.2

Lecture dans un chier

Il y a plusieurs mani`res de lire un chier. e readline() permet de lire une ligne (position courante jusquau prochain \n) ` la fois a dans le chier.
>>> foo = open ( / tmp / foo . txt , r ) >>> print foo . readline () hello world !\ n

readlines() permet de lire toutes les lignes dun chier en une seule fois (retourne une squence de cha e nes).
>>> foo . readlines () [ bonjour le monde !\ n , au revoir le monde !\ n ]

read([n]) permet de lire tout le chier ` partir de la position courante, ou au maximum n a octets lorque un argument est donn. Cette fonction retourne une cha La fonction e ne. seek permet de se dplacer dans le chier de faon absolue : ici nous retournons au e c dbut (indice 0). e
>>> foo . seek (0) ; foo . read () hello world !\ nbonjour le monde !\ nau revoir le monde !\ n >>> foo . close ()

Comparaison des approches de lecture Il ny a pas de solution idale pour la lecture e des chiers. Il faut choisir en fonction de la situation et des besoins. La lecture globale (readlines) dun chier est plus performante pour laspect rcupration e e des informations car elle reprsente un gros acc`s disque puis un parcours de squence e e e en mmoire. Toutefois, cette approche est coteuse en mmoire vive : imaginez la e u e prsence dun chier texte de 500Mo en mmoire. e e Lecture ligne par ligne (readline) est plus coteuse pour lire un chier car elle u reprsente de nombreux acc`s disques pour des petites quantits dinformation. Toue e e tefois, cette approche permet de manipuler des gros chiers : un chier de 10Go peut tre lu ligne par ligne sur une machine ayant 64Mo de mmoire. e e Depuis Python 2.3, il est possible ditrer simplement ligne par ligne sur un chier e ouvert (sans avoir ` utiliser la fonction readline). Cette mani`re de faire repose sur les a e itrateurs (voir la section 1.4.3.1). e c 2003-2007, Raphal Marvie e

40
>>> fichier = open ( / tmp / foo . txt ) >>> for line in fichier : ... print line . strip () ... fichier . close () ... hello world ! bonjour le monde ! au revoir le monde !

Quelques modules et built-in

2.3.1.3

Ecriture dans un chier

Il faut quun chier soit ouvert en criture pour pouvoir crire dedans, on le prcise donc e e e ` louverture en donnant un second param`tre w (Python suit les modes douverture du a e langage C, pour les chiers binaires il faut prciser b en plus). Tant que le chier nest e pas ferm, son contenu nest pas garanti sur le disque. e write permet dcrire des donnes (une cha de texte) reprsentant une ou plusieurs e e ne e lignes de texte (utilisation de \n). Les donns peuvent aussi tre binaires. e e
>>> foo = open ( / tmp / foo . txt , w ) >>> foo . write ( hello world !\ n )

writelines permet dcrire des donnes contenues dans une squence (de cha e e e nes). Si chaque cha contenue dans la squence reprsente une ligne de texte dans le chier, ne e e il faut alors quelles contiennent toute la squence de n de ligne \n. Dans le cas e contraire, tout sera crit dans le chier, mais la notion de ligne sera dnie par les e e \n contenus (mme sils ntient pas en n dune des cha e e nes).
>>> lines = [ bonjour le monde !\ n , au revoir le monde !\ n ] >>> foo . writelines ( lines ) >>> foo . close ()

2.3.2

Conversions de type

Utilisation du nom des types pour convertir les cha nes, en entiers, ottants, etc. (et rciproquement.) La fonction str permet de convertir tout objet en cha e ne.
>>> str (123) 123 >>> int ( 123 ) 123 >>> float ( 123 ) 123.0 >>> float (123) 123.0 >>> long ( 123 ) 123 L

c 2003-2007, Raphal Marvie e

2.3 Built-in en Python Mais Attention aux arrondis


>>> float ( 12.3 ) 12.3 00 00 00 00000 00 1

41

2.3.3

Evaluation dynamique

Python permet dexcuter des commandes ` la vole6 : une cha de caract`res reprsentant e a e ne e e une commande est execute. La cha peut tre compile explicitement ou non avant son e ne e e valuation. Cette possibilit permet de faire de la gnration dynamique de commandes. e e e e compile() retourne une version compile de lexpression (ou du chier) pass en pae e ram`tre. Le second argument prcise o` doit se faire la sortie derreur au cas o` une e e u u exception serait leve. Le dernier argument prcise quel usage est envisag, ici nous e e e prvoyons de lutiliser avec la fonction eval() e
>>> obj = compile ( x + 1 , < string > , eval ) >>> obj < code object ? at 0 x81685d8 , file " < string > " , line -1 >

eval() value une expression (compile ou non) pass en param`tre. e e e e


>>> x = 2 >>> eval ( x + 1 ) 3 >>> eval ( obj ) 3

2.3.4

Assertions

Les assertions permettent de traiter les situations sans appel : soit la condition est respecte, soit le programme est arrt. (Dans la pratique, une exception est leve.) e ee e assert value une expression logique et arrte le programme en achant un message e e derreur (qui est optionnel et fourni spar par une virgule) si lexpression logique est e e fausse (cf section 1.3.2). Lexpression peut inclure des appels de fonctions.
>>> assert 1 >>> assert 0 , oups Traceback ( most recent call last ): File " < stdin > " , line 1 , in ? AssertionError : oups >>> try : assert 0 ... except AssertionError : print sic ... sic
Bien que tout est dynamiquement valu en python, il est possible de faire des choses encore plus e e dynamiquement.
6

c 2003-2007, Raphal Marvie e

42

Quelques modules et built-in

2.4
2.4.1

Exercices
Utilitaire de sauvegarde

En saidant de la fonction os.stat qui permet de conna tres la dates de modication des chiers, crire un utilitaire de backup dune arborescence. Cet utilitaire doit faire un e backup incrmental (sauf la premi`re fois) des chiers modis. e e e
>>> print os . stat . __doc__ stat ( path ) -> ( st_mode , st_ino , st_dev , st_nlink , st_uid , st_gid , st_size , st_atime , st_mtime , st_ctime ) Perform a stat system call on the given path .

2.4.2

Extraction de donnes e

Cet exercice propose dutiliser des fonctions du module regular exressions pour extraires des donnes dun chier texte. Ecrire un programme analysant un chier texte de type mbox e et qui produit la liste de toutes les personnes ayant envoy un e-mail, en triant la liste de e leurs adresses par ordre alphabtique avec la date de le-mail reu le plus rcent. e c e

c 2003-2007, Raphal Marvie e

Chapitre 3 Plongeon dans les objets


3.1
3.1.1

Des objets, que des objets


Rappels des principes de base de POO

Instanciation Un objet est cr ` partir dun moule, sa classe qui dnit une structure (les ee a e attributs) et un comportement (les mthodes). Une classe dnit un type dobjets. e e Un objet est instance dune unique classe. Encapsulation Les donnes sont ((caches)) au sein des objets, et leur acc`s est contrl e e e oe par les mthodes. Ltat dun objet ne devrait pas tre manipul directement. Lobjet e e e e peut tre vu comme un fournisseur de services (et non de donnes). e e Polymorphisme Des objets respectant une mme interface (la signature de mthodes e e sut dans le cas de Python) peuvent tre manipuls de mani`re gnrique, mme si e e e e e e leur type exact est dirent. Ce principe permet aussi la substitution dune instance e par une autre (tant que les interfaces sont compatibles). Hritage Mcanisme qui permet la rutilisation de dnitions de base, comportements par e e e e dfaut, et la spcialisation de certains comportements. La relation entre dhritage e e e entre deux classes ne se limite pas ` une facilit de capitalisation de code. La classe a e qui hrite doit ( etre un)) de la classe dont elle hrite : un chat ((est un)) animal, chat e ( e peut donc tre une sous classe de animal. e

3.1.2

Objets et rfrences ee

En Python, le monde est uniforme. Tout est objet : les cha nes, les entiers, les listes, les fonctions, les classes, les modules, etc. Tout est ri et manipulable dynamiquement. e e Tout objet est manipul par rfrence : une variable contient une rfrence vers un e ee ee objet et un objet peut tre rfrenc par plusieurs variables. e ee e Une fonction, une classe, un module sont des espaces de nommage organiss de e mani`re hirarchique : un module contient des classes qui contiennent des fonctions e e 43

44 (les mthodes). e

Plongeon dans les objets

3.1.3
3.1.3.1

Classes
Dnition et instanciation e

La dnition dune classe suit la r`gle des blocs (cf section 1.3.1) en utilisant le mot cl e e e class. Toute mthode est dnie comme une fonction avec un premier argument (self) e e qui reprsente lobjet sur lequel elle sera applique ` lexcution. En Java ou C++, le this e e a e est dnie implicitement, en Python il est explicite est cest toujours le premier param`tre e e dune mthode. Le nom est libre, mais on utilise en gnral self. Une mthode ne prenant e e e e pas de param`tres aura donc quand mme un argument. e e
>>> class Dummy : ... def hello ( self ): ... print hello world !

Linstanciation se fait sans mot cl particulier (il ny a pas de new en Python). Il sut e de faire suivre un nom de classe de parenth`ses (contenant ou non des param`tres) pour e e dclancher une instanciation. Linvocation se fait ` laide de la notation pointe, un appel e a e de mthode sur une variable rfrenant un objet. e ee c
>>> d = Dummy () >>> d < __main__ . Dummy instance at 0 x817b124 > >>> d . hello () hello world !

3.1.3.2

Dnition dattributs et du constructeur e

Les attributs sont dnis ` leur premi`re aectation. Une variable est considre comme e a e ee un attribut si elle est ( (rattache)) ` lobjet : elle est accde par self. Tout acc`s ` un e a e e e a attribut ou ` une mthode de lobjet depuis sa mise en oeuvre se fait obligatoirement par a e la variable self. Le constructeur est une ((mthode)) nomme __init__. Comme toute e e mthode, certain de ses param`tres peuvent avoir des valeurs par dfaut. Cette possibilit e e e e est important car une classe a un seul constructeur en Python (contrairement ` dautre a langages).
>>> class Compteur : ... def __init__ ( self , v =0): ... self . val = v ... def value ( self ): ... return self . val

En termes de gnie logiciel (et de bon sens), il est recommand de toujours initialie e ser ltat des objets (ses attributs) lors de son linstanciation, donc dans le constructeur. e Dautre part, un constructeur qui ne fait rien nest pas stupide ! Il dit clairement ce quil en est : labsence de constructeur ne serait pas un oubli. c 2003-2007, Raphal Marvie e

3.1 Des objets, que des objets

45

Visibilit des attributs et mthodes Les attributs, comme les mthodes, ont par e e e dfaut une visibilit ((publique)) en Python. Dans le cas des instances de la classe Compteur, e e il est possible de manipuler directement la valeur de lattribut (ou mthodes) val. Une e convention en Python est de prxer les attributs par un souglin pour annoncer quils ne e e sont pas destins ` tre utiliss par les clients. Il est ` noter que cest une convention et e ae e a rien nempche un utilisatieurde lire un attribut dont le nom est prx par un soulign1 . e e e e Enn, lutilisation de deux souligns comme prxe (et pas de soulign comme postxe) e e e dun nom dattribut (ou de mthode) permet de dnir un attribut ((priv)) et donc non e e e visible par les clients de la classe.
>>> class Foo : ... def __init__ ( self ): ... self . _a = v ... self . __b = 1 ... >>> f = Foo () >>> f . _a 0 >>> f . __b Traceback ( most recent call last ): File " < stdin > " , line 1 , in ? AttributeError : Compteur instance has no attribute __b

3.1.4

Hritage e

Python supporte lhritage simple et lhritage multiple. Dans une relation dhritage, e e e il est faut prciser le nom de la classe m`re (entre parenth`ses apr`s le nom de la classe en e e e e cours de dnition) et appeler explicitement le constructeur de la super classe. e
class A : def __init__ ( self , n = none ): self . _name = n def name ( self ): return self . _name class B ( A ): def __init__ ( self , val =0 , n = none ): A . __init__ ( self , n ) self . _wheels = val def wheels ( self ): return self . _wheels

Dans le cas de lhritage multiple, il sut de prciser les direntes classes m`res et e e e e dappeler leurs constructeurs respectifs.
Il est vrai que dans le cas de Python la notion de ( (protg) repose sur la conance, mais si vous roulez e e) a ` 180 Km/h en ville qui est responsable, la voiture ou vous ?
1

c 2003-2007, Raphal Marvie e

46
class C : def __init__ ( self , t = ): self . _title = t def title ( self ): return self . _title class D (A , C ): def __init__ ( self , n = none , t = ): A . __init__ ( self , n ) C . __init__ ( self , t ) def fullname ( self ): return self . _title + + self . _name

Plongeon dans les objets

Lexemple suivant donne une utilisation des trois classes prcdentes. Il ny a rien de e e particulier ` lutilisation que la classe ait t dnie enti`rement ou par hritage ne change a ee e e e rien.
>>> a = A ( rafi ) >>> print a . name () rafi >>> b = B (4 , car ) >>> print b . name () car >>> print b . wheels () 4 >>> d = D ( t = dr ) >>> print d . fullname () dr none

Hritage multiple problmatique Lhritage multiple pose probl`me lorsque deux e e e e classes hrites ore une mthode portant le mme nom. Dans ce cas, il est possible de e e e e prxer les mthodes par le nom de la classe qui les dnies ou dutiliser des alias de e e e mthodes pour rsoudre les conits. e e
class X : def name ( self ): return I am class Y : def name ( self ): return I am class Z (X , Y ): xname = X . name yname = Y . name def name ( self ): return I am and

an X

an Y

an Z , ie + self . xname () + \ + self . yname ()

c 2003-2007, Raphal Marvie e

3.2 Structures des objets

47

Lexemple suivant propose une utilisation des trois classes X, Y, Z prcdentes avec une e e invocation de la mthode name() sur les trois instances cres. e ee
>>> for ... ... ... I am an I am an I am an clss in [X , Y , Z ]: obj = clss () print obj . name () X Y Z , ie I am an X and I am an Y

3.1.5

Classes vs modules

Il semblerait que la vision suivante doit bien accepte de la communaut de dveloppeurs e e e 2 Python : Utiliser des classes lorsque Les donnes reprsentent un tat et doivent tre protges. e e e e e e Les traitements et donnes sont fortement lis (les donnes voluent). e e e e Utiliser des modules de fonctions lorsque Les traitements et donnes sont ((indpendants)) (ex : data mining). e e Les donnes sont stockes dans des BD ou chiers, et non modies. e e e

3.2
3.2.1

Structures des objets


Introspection simple

La fonction dir() donne le contenu de tout objet (liste de ses attributs et mthodes). e Associe ` lattribut __doc__, cela fournit une documentation de base sur tout objet. Do` e a u lintrt de bien auto-documenter le code (voir section 1.3.5). ee
>>> dir ( Compteur ) [ __doc__ , __init__ , __module__ , value ] >>> c = Compteur () >>> dir ( c ) [ __doc__ , __init__ , __module__ , val , value ]

La fonction type() donne le type dune rfrence. ee


>>> type ( c ) < type instance > >>> type ([1 , 2]) < type list >
2

Personnellement tout est dni comme des classes, no comment. . . e

c 2003-2007, Raphal Marvie e

48

Plongeon dans les objets

3.2.2

Classes et attributs

Une classe ne contient que des attributs. Elle peut tre vue comme un simple dictione naire contenant des associations nom / rfrence. Une fonction de la classe (ou mthode) ee e est en fait un attribut qui est excutable (callable). e
>>> class OneTwoThree : ... value = 123 # reference un entier ... def function ( self ): # reference une fonction ... return self . value ... >>> ott = OneTwoThree () >>> dir ( ott ) [ __doc__ , __module__ , function , value ] >>> ott . function < bound method OneTwoThree . function of < __main__ . OneTwoThree

Dans le cas dun conit de nom entre un attribut et une mthode, la priorit va ` late e a tribut. Ici, linterprteur explique que lon ne peut utiliser lattribut name comme si ctait e e une fonction (ou mthode) car cest une cha donc on ne peut demander son excution e ne, e (object is not callable). La mthode name est masque par lattribut portant le mme e e e nom.
>>> class Conflict : ... def __init__ ( self ): ... self . name = Conflict ... def name ( self ): ... return You will never get this string ! ... >>> c = Conflict () >>> c . name () Traceback ( most recent call last ): File " < stdin > " , line 1 , in ? TypeError : str object is not callable

Lutilisation systmatique dattributs ((protgs)) est donc une bonne ide qui a pour e e e e consquence dviter les conits de noms entre attributs et mthodes. e e e
>>> class NoConflict : ... def __init__ ( self ): ... self . _name = NoConflict ... def name ( self ): ... return self . _name ... >>> c = NoConflict () >>> print c . name () NoConflict

c 2003-2007, Raphal Marvie e

3.3 Les objets, version avance e

49

Il est possible de dnir dynamiquement des attributs sur une classe ou une instance. e Ce genre de facilit ne se limite pas ` laspect ludique, cest parfois la meilleure solution ` e a a un probl`me. Toutefois, attention o` lon met les pieds lorsque lon modie dynamiquement e u des objets.
>>> class Empty : ... pass >>> Empty . value = 0 >>> def funct ( self ): ... self . value += 1 ... return self . value ... >>> Empty . funct = funct >>> dir ( Empty ) [ __doc__ , __module__ , funct , value ] >>> e = Empty () >>> e . funct () 1

Quelques attributs notoires __doc__ contient la documentation de la classe, de lobjet, de la fonction, du module, etc. __module__ contient le nom du module contenant la dnition de la classe, de lobjet, de e la fonction, du module, etc. __name__ contient le nom de la fonction ou de la mthode. e __file__ contient le nom du chier contenant le code du module.

3.3
3.3.1

Les objets, version avance e


Un peu de rexion e

Les techniques de rexion permettent de dcouvrir (instrospection) et de manipuler e e dynamiquement et automatiquement les attributs (et fonctions) dun objet. Ces techniques sont utilisables, par exemple, pour le chargement de code dynamique comme la mise en uvre dun mcanisme de plug-ins. Elles sont aussi couramment utiliss dans les environnee e ments de dveloppement qui font de la compltion automatique (il faut bien aller chercher e e linformation quelque part). Il existe trois fonctions de base en Python : hasattr() test si un attribut existe, getattr() donne acc`s ` la valeur dun attribut, e a setattr() xe la valeur dun attribut (avec cration si lattribut est inexistant). e Dans lexemple suivant, nous manipulons linstance tendue de la classe Empty : apr`s e e avoir test son existence, nous rcuprons dynamiquement la mthode nomme funct pour e e e e e en demander ensuite lexcution. Enn, nous dnissons un nouvel attribut name dont la e e valeur est xe ` myempty. e a c 2003-2007, Raphal Marvie e

50
>>> hasattr (e , funct ) 1 >>> f = getattr (e , funct ) >>> f < function funct at 0 x81b7334 > >>> f ( e ) 2 >>> setattr (e , name , myempty ) >>> e . name myempty

Plongeon dans les objets

3.3.2

Un peu plus de rexion avec inspect e

Le module inspect ore des moyens supplmentaires pour lintrospection, par exemple e dcouvrir ce que contient une classe, un objet ou un module. Lexemple suivant rcup`re e e e les membres de la classe E puis les membres dune instance de cette classe. Pour chaque membre de lobjet (classe ou instance), un tuple est fourni contenant le nom de lattribut et sa valeur. Nous pouvons constater que la dirence se limite ` ltat de la fonction f : non e a e lie dans le cas de la classe, donc que lon ne peut excuter directement, et lie ` linstance e e e a dans le cas de lobjet que lon peut donc excuter directement apr`s un getattr. e e
>>> class E : ... def f ( self ): ... return hello ... >>> e = E () >>> import inspect >>> inspect . getmembers ( E ) [( __doc__ , None ) , ( __module__ , __main__ ) , ( f , < unbound method E .f >)] >>> inspect . getmembers ( e ) [( __doc__ , None ) , ( __module__ , __main__ ) , ( f , < bound method E . f of < __main__ . E instance at 0 x825ec54 > >)]

Ce module permet aussi de savoir ce que lon est en train de manipuler : quel est le type dun objet (classe, instance, attribut). La fonction ismethod() permet de savoir si un objet donn est, ou non, une mthode (lie ou non). e e e
>>> 1 >>> >>> 0 >>> 1 >>> inspect . isclass ( E ) f = getattr (e , f ) inspect . isfunction ( f ) inspect . ismethod ( f ) F = getattr (E , f )

c 2003-2007, Raphal Marvie e

3.3 Les objets, version avance e


>>> inspect . ismethod ( F ) 1

51

Lassociation de lintrospection de base et du module inspect permet dautomatiser lutilisation des mthodes dune instance : invocation gnrique dune mthode rcupre e e e e e ee dynamiquement apr`s contrle que cest bien une mthode. Lexemple suivant montre aussi e o e les deux mani`res dinvoquer une mthode, et la signication du self : a.foo() est en fait e e traduit en A.foo(a) par linterprteur (considrant que a est une instance de la classe A). e e
>>> f1 = getattr (e , f ) >>> f2 = getattr (E , f ) >>> if inspect . ismethod ( f1 ): ... f1 () # f1 est liee a e ... hello >>> if inspect . ismethod ( f2 ): ... f2 ( e ) # f2 n est pas liee , argument 1 == self ... hello

Le module inspect permet mme daccder dynamiquement au code source dun objet. e e Toutefois, cela nest pas valable pour le code saisi en interactif (ce qui est somme toute normale vu quil nest pas stock dans un chier). e
>>> from examples import Conflict

getfile() donne le nom du chier de dnition de lobjet (TypeError si cette opration e e est impossible).
>>> inspect . getfile ( Conflict ) examples . py

getmodule() donne le nom du module dnissant lobjet (sans garantie par exemple dans e le cas du code dynamiquement cr). ee
>>> inspect . getmodule ( Conflict ) < module examples from examples . py >

getdoc() retourne la documentation de lobjet.


>>> inspect . getdoc ( Conflict ) Illustration de conflit attribut / methode

getcomments() retourne la ligne de commentaire prcdant la dnition de lobjet. e e e getsourcelines() donne un tuple contenant la liste des lignes de code source dnissant e lobjet pass en param`tre et la ligne du dbut de la dnition dans le chier. e e e e
>>> lines , num = inspect . getsourcelines ( Conflict ) >>> for l in lines : print num , l , ; num += 1 ...

c 2003-2007, Raphal Marvie e

52

Plongeon dans les objets


34 class Conflict : 35 Illustration de conflit attribut / methode 36 def __init__ ( self ): 37 self . name = Conflict 38 def name ( self ): 39 return You will never get this string !

getsource() est similaire ` la prcdente, mais retourne uniquement le code de la dnition a e e e sous la forme dune cha de caract`res. ne e

3.4
3.4.1

Les exceptions en python


Dnition et lancement e

Les exceptions sont des objets comme les autres, donc dnies par des classes comme e les autres (ou presque). Elles sont simplement un penchant pour ne rien faire (les classes dexception contiennent rarement des traitements). La dnition minimale dune classe e pour une exception revient ` tendre la classe de base Exception. ae
>>> class MonErreur ( Exception ): ... pass ...

La mot-cl raise permet de lever une exception (dnie par lusager ou standard). Si e e lon souhaite associ de linformation ` une exception, il sut de faire suivre le type de e a lexception dun message (spar par une virgule). 3 e e
>>> raise MonErreur Traceback ( most recent call last ): File " < stdin > " , line 1 , in ? __main__ . MonErreur >>> raise MonErreur () Traceback ( most recent call last ): File " < stdin > " , line 1 , in ? __main__ . MonErreur >>> raise NameError , cela coince Traceback ( most recent call last ): File " < stdin > " , line 1 , in ? NameError : cela coince

Une exception peut aussi contenir des attributs et mthodes (en gnral pour fournir de e e e linformation). Ici, la mthode standard __str__ (traduction de lobjet en cha et utilise e ne) e pour accder facilement ` la valeur contenue dans lexception (par dfaut le mcanisme e a e e
Les exceptions sont leves comme des objets. Une classe est dnie par un objet dans linterprteur. e e e Donc la dnition de la classe peut tre leve comme une exception. Ce qui nest pas si choquant pour les e e e cas simple (exception avec message derreur).
3

c 2003-2007, Raphal Marvie e

3.4 Les exceptions en python

53

dexception appelle cette mthode). Pour fournir de linformation ` une exception, il sut e a de linstancier en passant des param`tres au constructeur lors de lutilisation de raise. e
>>> class MonErreurToo ( Exception ): ... def __init__ ( self , val = None ): ... self . _value = val ... def __str__ ( self ): ... return str ( self . _value ) ... >>> raise MonErreurToo (12) Traceback ( most recent call last ): File " < stdin > " , line 1 , in ? __main__ . MonErreurToo : 12

3.4.2

Traitement des exceptions

Il y a deux approches pour le traitement des exceptions en Python dont le choix dpend e des besoins : quoi faire en cas de probl`me, e que faut il toujours faire mme sil y a un probl`me. e e 3.4.2.1 try ... except

Gestion des probl`mes, le try ... except permet en cas de leve dexception, de e e pouvoir tenter de traiter le probl`me. La clause else est optionnelle est permet de faire e un traitement si tout sest bien pass. Il peut y avoir plusieurs clauses except pour traiter e dirents cas exceptionnels. e
try : < instructions > ( except < exception >: < instructions traitement exception >)+ [ else : < instruction si d roulement correct >] e

Lidentication dune <exception> peut prendre plusieurs formes : ExceptionType est utile lorsque seul le type de lexception est important, par exemple parce quelle ne contient pas dinformation ; ExceptionType, variable permet de rcuprer lexception du type spci dans e e e e variable et donc depxloiter les donnes et traitements de lexception ; e (ExceptionType1, ExceptionType2, ...) permet de prendre en compte un ensemble dexception car le traitement de cas particulier est mutualisable. Exemple 1 Lecture dun chier texte : on ne lit le chier que si louverture sest bien passe. On utilise la clause else pour le code qui ne doit tre fait que si aucune e e exception nest leve. Cela permet disoler lappel qui pose potentiellement probl`me e e c 2003-2007, Raphal Marvie e

54

Plongeon dans les objets dans le bloc try (et non de mettre tout le code dans ce bloc sans savoir ensuite qui a vraiment pos probl`me). e e
>>> try : ... f = open ( / tmp / bar . txt ) ... except IOError , e : ... print e ... else : ... for line in f . readlines (): ... print line , ... f . close () ... hello world ! bonjour le monde !

Exemple 2 Gestion de plusieurs exceptions : lachage va dpendre de lexception qui e est leve (elle mme leve de mani`re alatoire). Une cha tant un objet, elle peut e e e e e ne e tre utilise comme exception. Cette mani`re de faire est toutefois ` proscrire. e e e a
>>> try : ... if int ( random . random () * 100) % 2: ... raise impair ... else : ... raise pair ... except pair : ... print " c est un nombre pair " ... except impair : ... print " c est un nombre pair " ... c est un nombre pair

3.4.2.2

try ... finally

Quoi quil arrive, le try ... finally permet de faire un traitement mme si une e exception a t leve. Le bloc finally est valu avant un return contenu dans le bloc ee e e e try et ce quil y ait ou non eu une exception de lev. Attention : Un return dans le e finally masque un return dans le try.
try : < instructions > finally : < traitements syst matiques > e

Attention : Dans ce cas, on ne sait pas ce qui sest mal pass. Il ny a pas moyen de e faire de gestion derreur dans le finally qui ((laisse ler)) les exceptions.
>>> try : ... raise Keyb oardInterru pt

c 2003-2007, Raphal Marvie e

3.5 Toujours ` propos des objets a


... finally : ... print ki C ki A ta P < ctrl -C > ? ... ki C ki A ta P < ctrl -C > ? Traceback ( most recent call last ): File " < stdin > " , line 2 , in ? Keybo ardInt errupt

55

Il nest pas possible de composer les deux formes dans un seul bloc, lutilisation imbrique des deux formes est donc parfois ncessaire. e e

3.4.3

Traitement dexceptions et hritage e

Petit probl`me courant, attention ` lordonnancement des except ! Il faut toujours, e a dans le cas o` les exceptions sont dnies par une relation dhritage, commencer par u e e traiter les exceptions les plus spciques. Dans le cas contraire, la gestion des exceptions e les plus gnrales masque les traitements relatifs aux exceptions les plus spciques qui ne e e e sont jamais utiliss. e
class A ( Exception ): pass class B ( A ): pass >>> for x in [A , B ]: ... try : raise x ... except B : print ... except A : print A B >>> for x in [A , B ]: ... try : raise x ... except A : print ... except B : print A A

B , A ,

A , B ,

3.5

Toujours ` propos des objets a

Cette section est pour certain aspects plutt ` lire une fois familier avec Python. o a

3.5.1

Unication des types et des classes

Depuis Python 2.2, les types et les classes ont t unis en Python. Cest-`-dire quil ee e a ny a plus de dirence fondamentale entre les types de base et les classes dnies par e e lutilisateur. Le bnce de cette unication est quil est dsormais possible de dnir des e e e e classes hritant des types de base. e c 2003-2007, Raphal Marvie e

56

Plongeon dans les objets

Suite ` cette unication, et pour ne pas briser la compatibilit avec les programmes a e existants, la dclaration des classe a un peu volu (ce que nous avons vu jusquici est e e e toujours valable). Pour prciser quune classe est dnie avec la nouvelle forme, il faut la e e faire hriter de object, dun type de base ou dune classe hritant de object). Attention, e e les classes de la librairie standard ne suivent pas toute la nouvelle forme et sont donc considres comme ((direntes)). ee e Lexemple suivant prsente les deux formes de dclaration de classes simultanment. e e e Lutilisation de la fonction type sur des instances de ces deux classes illustre bien la dirence de statut vis-`-vis de linterprteur (lignes 9-12). e a e
>>> class Foo : ... pass ... >>> class Bar ( object ): ... pass ... >>> f = Foo () >>> b = Bar () >>> type ( f ) < type instance > >>> type ( b ) < class __main__ . Bar >

Avec cette nouvelle forme, lutilisation de mthodes fournies par les super-classes est e aussi modie. Lors de la rednition dune mthode dans une sous-classe, la fonction e e e super permet daccder ` la dnition (originale) de cette mthode dans la super-classe e a e e (ou une des super-classes). La fonction super prend comme premier param`tre le type ` partir duquel doit se faire e a la recherche4 et comme second param`tre self (ligne 8 de lexemple suivant). Contrairee ment ` lancienne forme, il nest plus ncessaire de passer self en premier argument de a e la mthode (voir la section 3.1.4). La fonction super est aussi utilisable dans la dnition e e des constructeurs.
>>> class Foo ( object ): ... def foo ( self ): ... print Foo . foo ... >>> class FooToo ( Foo ): ... def foo ( self ): ... print FooToo . foo ... super ( FooToo , self ). foo () ... >>> f2 = FooToo ()
Dans le cas dune hirarchie ` plusieurs niveaux, la recherche de la mthode hrit ne se fait pas e a e e e ncessairement ` partir de la super-classe, mais elle peut se faire ` partir de la super-super-classe par e a a exemple.
4

c 2003-2007, Raphal Marvie e

3.5 Toujours ` propos des objets a


>>> f2 . foo () FooToo . foo Foo . foo

57

3.5.2

Dnition de proprits e e e

Avec lunication classe / type, la notion de proprit est apparue en Python. Une ee proprit permet de manipuler un attribut ` laide daccesseurs de mani`re transparente ee a e (cest-`-dire que lon ne dit pas explicitement que lon utilise les accesseurs). Une proprit a ee est dnie ` laide de la fonction property dans le contexte dune classe qui tend (mme e a e e indirectement) object. La fonction property prend en param`tre la fonction pour la lecture, la fonction pour e lcriture, la fonction pour la suppression de la valeur associe et une cha de documene e ne tation. Tous les param`tres sont optionnels (eh oui, il est mme possible de dnir une e e e proprit ne fait rien, mme pas tre lue). ee e e Dans lexemple suivant, la classe A est dnie avec une proprit value en lecture et e ee criture : elle est dnie avec une mthode pour la lecture et une pour lcriture. La classe e e e e B est quant ` elle dnie avec une proprit value en lecture seule : seule une mthode de a e ee e lecture est fournie.
>>> class A ( object ): ... def __init__ ( self , val =0): ... self . _value = val ... def get_value ( self ): ... return self . _value ... def set_value ( self , val ): ... self . _value = val ... value = property ( get_value , set_value ) ... >>> class B ( object ): ... def __init__ ( self ): ... self . _value = 0 ... def get_value ( self ): ... return self . _value ... value = property ( get_value ) ...

Une proprit est utilis comme un attribut. Dans le cas courant lutilisation est peu ee e dirente dun attribut classique, mme les mthode de lecture / criture pourrait tr`s e e e e e bien aller chercher linformation dans un chier ou autre. Enn, la tentative dcriture de e la proprit value sur une instance de B se solde par une exception. Il est donc intressant ee e dutiliser des proprits pour faire du contrle dacc`s sur des attributs. ee o e
>>> a = A (1) >>> a . value 1

c 2003-2007, Raphal Marvie e

58
>>> a . value = 2 >>> a . value 2 >>> b = B (2) >>> b . value 2 >>> b . value = 1 Traceback ( most recent call last ): File " < stdin > " , line 1 , in ? AttributeError : can t set attribute

Plongeon dans les objets

3.5.3

Dcorateurs e

Le concept de dcorateur de fonction (ou de mthode) a t introduit dans la version e e ee 2.4 (PEP 318). La notion de dcorateur nest pas des plus simple ` expliquer, mais on peut e a la voire comme une fonction qui applique des traitements sur une autre fonction pour en changer le comportement. Un dcorateur peut donc tre toute fonction prenant en argue e ment une fonction (ou tout objet appelable). Lutilisation dune fonction comme dcorateur e dune autre fonction se fait en utilisant le nouvel oprateur @. Considrant un dcorateur e e e decorateur et une fonction foo les deux dclarations suivantes sont quivalentes. e e
@decorateur def foo (): pass def foo (): pass foo = decorateur ( foo )

Lexemple suivant prend le grand classique de la trace des appel de fonction pour illustrer la dnition et lutilisation dun dcorateur. La fonction trace dnie une fonction e e e demballage (un wrapper) _trace qui va, en plus du comportement normal de la fonction quelle emballe, acher le nom et les arguments de celle-ci. Lutilisation de trace permet donc de substituer la dnition de base dune fonction par une version incluant la trace : e trace retourne tout simplement une fonction. Notre fonction trace va tre utilisable sur toute fonction comme un dcorateur pour e e acher sur la sortie standard les appels ` cette fonction. Ici, nous traons la fonction bar, a c dont la dnition est tout ce quil y a de plus normal, si ce nest la dclaration @trace. e e
>>> def trace ( fct ): ... def _trace (* args ): ... print < % s % s > % ( fct . __name__ , args ) ... return fct ( args ) ... return _trace ... >>> @trace

c 2003-2007, Raphal Marvie e

3.6 Exercices
... def bar ( name ): ... print hello % s % name ... >>> bar ( rafi ) < bar ( rafi ,) > hello rafi

59

Il est ` noter que les dcorateurs sont tr`s pratiques dans le cas des classes pour, par a e e exemple dnir des mthodes comme des mthodes de classe, des mthodes statiques ou e e e e bien synchronises (dans la cas de la programmation multi-thread)5 . Une fonction (ou e mthode) peut tre dcore plusieurs fois. e e e e

3.6
3.6.1

Exercices
Premi`res classes e

Implanter des classes Pile et File utilisant les liste comme structure de donnes e interne et respectant linterface suivante (utiliser lhritage). e
class Base : def pop ( self ): pass def push ( self , elt ): pass

Reprendre lexercice 2.4.2 en implantant les fonctionnalits au sein dune classe. e

3.6.2

Design pattern tat e

Ltat dun objet a de type A est implant par plusieurs classes. Linstance de ces e e classes qui reprsente ltat de lobjet varie au cours du cycle de vie de lobjet. Les e e mthodes de lobjet sont dlgues ` linstance reprsentant ltat ` un moment e ee e a e e a donn. e Implanter ce design pattern pour reprsenter un feu tricolore (une classe dtat par e e couleur, une mthode pour changer la couleur du feu et une mthode qui donne le e e droit de passage).

NpA : Ajouter une section sur ces trois types de mthodes et une section sur la programmation e multi-thread en Python.

c 2003-2007, Raphal Marvie e

60

Plongeon dans les objets

c 2003-2007, Raphal Marvie e

Chapitre 4 Python et XML


4.1
4.1.1

XML, avec une vision DOM


Langages de balises

Au commencement tait SGML e Standard Generalized Markup Language Simpli ` outrance avec HTML pour le Web ea Transform en produit marketing avec XML e Python supporte toute la petite famille HTML, XHTML et SGML pour HTML XML, DOM et SAX

4.1.2

XML, quels outils ?

Il existe plusieurs librairies pour manipuler des documents XMl avec Python, mais ce chapitre se limite ` une partie du package standard xml. Ce package fournit plusieurs a sous-packages : dom contient minidom, une implmentation de DOM en Python, e sax est un dictionnaire des implmentation disponibles, e parsers contient les parsers utiliss en interne par DOM et SAX. e En complments, plusieurs librairies et extensions sont disponibles. Elles fournissent, e par exemple, des abstractions de plus haut niveau et des outils typs par rapport ` une e a utilisation donne. e

4.1.3

DOM, petit rappel

Pour ce qui est de la manipulation dun chier XML, nous allons uniquement utiliser DOM (Document Object Model). DOM propose de manipuler un document XML en 61

62

Python et XML

mmoire comme un arbre dobjets reprsentant les noeuds du document. Les interfaces e e standard DOM sont les suivantes. Interface Node NodeList Document Element Attr Comment Text Reprsentation de e Interface de base des noeuds Squence de noeuds e Reprsente un document complet e Elment de la hirarchie e e Noeud reprsentant un attribut dun noeud e Noeud reprntant un commentaire e Noeud de donnes textuelles e

4.1.4

Exemple du chapitre

Le listing suivant prsente un exemple de document XML utilis dans la suite du e e chapitre pour illustrer la manipulation de tels documents.
<? xml version = " 1.0 " ? > < contacts > < contact name = " doe " firstname = " john " > < address > < road value = " 10 , binary street " / > < postal value = " 0001 " / > < city value = " cpu " / > </ address > < programming lang = " asm " / > </ contact > < contact name = " dupont " firstname = " jean " > < address > < road value = " impasse de l assembleur " / > < postal value = " 0100 " / > < city value = " dram " / > </ address > < programming lang = " c " / > </ contact > < contact name = " terprette " firstname = " quentin " > < address > < road value = " avenue du script " / > < postal value = " 1001 " / > < city value = " salt snake city " / > </ address > < programming lang = " python " / > </ contact > </ contacts >

c 2003-2007, Raphal Marvie e

4.2 Naviguer dans un arbre DOM

63

4.2
4.2.1

Naviguer dans un arbre DOM


minidom ((il fait le maximum))

Le module minidom est une mise en uvre de DOM pour Python. Il fournit toutes les interfaces de base DOM et un parser de chier (ou de cha ne) XML. Il est disponible en standard dans lenvironnement (librairie PyXML).

4.2.2

Parser un document XML

La fonction minidom.parse permet danalyser un chier XML et dobtenir un arbre DOM correspondant. Elle retourne un objet de type Document. En une ligne, elle est pas belle la vie ?
>>> from xml . dom import minidom >>> doc = minidom . parse ( / tmp / contacts . xml ) >>> doc < xml . dom . minidom . Document instance at 0 x827fb9c >

4.2.3

Parcourir un arbre DOM

Un certain nombre doprations et dattributs disponibles sur tous les lments dun e ee arbre DOM pour en permettre son parcours. hasChildNodes() indique si un noeud a des ls.
>>> doc . hasChildNodes () 1

childNodes donne acc`s aux ls dun noeud (sous la forme dune liste). e
>>> doc . childNodes [ < DOM Element : contacts at 137763676 >] >>> doc . childNodes [0]. hasChildNodes 1

documentElement fournit le noeud racine dun document DOM.


>>> root = doc . documentElement

firstChild, lastChild donnent acc`s respectivement au premier et au dernier ls dun e noeud.


>>> root . childNodes [ < DOM Text node " \ n " >, < DOM Element : contact at 137757692 > , < DOM Text node " \ n " >, < DOM Element : contact at 137437676 > , < DOM Text node " \ n " >, < DOM Element : contact at 136723316 > , < DOM Text node " \ n " >]

c 2003-2007, Raphal Marvie e

64
>>> root . firstChild < DOM Text node " \ n " > >>> root . lastChild < DOM Text node " \ n " >

Python et XML

nextSibling, previousSibling donnent respectivement acc`s au ls suivant et au ls e prcdent (ou None si plus de ls). Le calcul se fait par rapport ` une racine commune. e e a
>>> current = root . firstChild >>> while current : ... print current , ... current = current . nextSibling ... < DOM Text node " " > < DOM Element : contact at 137757692 > < DOM Text node " " > < DOM Element : contact at 137437676 > < DOM Text node " " > < DOM Element : contact at 136723316 > < DOM Text node " ">

parentNode donne acc`s au parent (direct) dun noeud. e


>>> root < DOM Element : contacts at 137763676 > >>> root . firstChild < DOM Text node " \ n " > >>> root . firstChild . parentNode < DOM Element : contacts at 137763676 >

isSameNode() permet de tester si deux noeuds sont gaux (galit au sens de lidentit, e e e e parle-t-on de la mme personne). e
>>> root . firstChild . isSameNode ( root . lastChild ) 0 >>> root . firstChild . isSameNode ( root . childNodes [0]) 1

4.2.4

Recherche dans un arbre DOM

La recherche dans un arbre DOM se fait principalement par nom de tag (nom de noeud). La fonction getElementsByTagName(), disponible sur les noeuds de type Document et Element, donne tous les ls (et sousn -ls) portant le nom de tag fourni.
>>> root . g e t Ele m e nt s B y T a g Na m e ( contact ) [ < DOM Element : contact at 137757692 > , < DOM Element : contact at 137437676 > , < DOM Element : contact at 136723316 >] >>> root . g e t Ele m e nt s B y T a g Na m e ( programming ) [ < DOM Element : programming at 137788492 > ,

c 2003-2007, Raphal Marvie e

4.3 Accder aux informations dun noeud e


< DOM Element : programming at 137755692 > , < DOM Element : programming at 137602140 >]

65

4.2.5

NodeList et objets squences e

Le rsultat retourn par les fonctions childNodes et getElementsByTagName est de e e type NodeList et se comporte comme une squence ((classique)). e Pour se comporter comme une squence, un objet doit orir (au minimum) les e mthodes suivantes : e __len__() et __getitem__(i) pour lacc`s aux lments (boucle for), e ee __setitem__(i) et __delitem__(i) pour les squences modiables. e

4.3
4.3.1

Accder aux informations dun noeud e


Informations lies au noeud e

nodeType donne une constante (1-10) reprsentant le type du noeud : e ELEMENT_NODE, ATTRIBUTE_NODE, TEXT_NODE, CDATA_SECTION_NODE, ENTITY_NODE, PROCESSING_INSTRUCTION_NODE, COMMENT_NODE, DOCUMENT_NODE, DOCUMENT_TYPE_NODE, NOTATION_NODE.
>>> root . nodeType == minidom . Node . ELEMENT_NODE 1 >>> root . firstChild . nodeType == minidom . Node . ELEMENT_NODE 0 >>> root . firstChild . nodeType == minidom . Node . TEXT_NODE 1

nodeName donne le nom du nud (tag de la balise). Attention, le comportement est variable selon les noeuds : pour un lment ce sera le nom de la balise XML, pour ee un noeud reprsentant du texte, ce sera #text e
>>> root . nodeName u contacts >>> root . firstChild . nodeName # text

nodeValue donne la valeur du nud (contenu). Attention, le comportement est variable selon les noeuds : pour un lment ce sera None pour un noeuds contenant de linee formation ce sera cette information. Pour les noeuds contenant du texte, il est aussi possible dutiliser lattribut data.
>>> root . nodeValue >>> root . firstChild . nodeValue u \ n

c 2003-2007, Raphal Marvie e

66
>>> root . firstChild . data u \ n

Python et XML

4.3.2

Informations lies aux attributs dun noeud e


>>> root . hasAttributes () 0 >>> root . childNodes [1]. hasAttributes () 1

hasAttributes() teste la prsence dattributs dans un noeud. e

attributes fourni les attributs du noeud (objet du type NamedNodeMap ou None).


>>> root . firstChild . attributes >>> root . childNodes [1]. attributes < xml . dom . minidom . NamedNodeMap object at 0 x81b298c >

getAttribute() retourne la valeur dun attribut comme une cha ne.


>>> c = root . childNodes [1] >>> print c . getAttribute ( name ) doe

getAttributeNode() retourne la valeur dun attribut comme un objet de type Attr.


>>> print c . getAttributeNode ( name ) < xml . dom . minidom . Attr instance at 0 x8360424 >

Une NamedNodeMap se comporte comme un dictionnaire. La mthode item() permet e daccder aux couples nom dattribut / valeur textuelle dattribut, la mthode keys() e e donne acc`s aux noms des attributs et la mthode values() donne acc`s ` la liste des e e e a objets Attr reprsentant les attributs. e
>>> attr . items () [( u name , u doe ) , ( u firstname , u john )] >>> attr . keys () [ u name , u firstname ] >>> attr . values () [ < xml . dom . minidom . Attr instance at 0 x302ffd28 > , < xml . dom . minidom . Attr instance at 0 x302ffd78 >] >>> for a in attr . values (): ... print a . nodeType , a . nodeName , a . nodeValue ... 2 name doe 2 firstname john

En plus des mthodes classiques sur les dictionnaires, il existe deux mthodes pour e e manipuler les NamedNodeMap : c 2003-2007, Raphal Marvie e

4.4 Construire un document XML length donne la longueur de la map dattributs, item(i) donne le i-eme lment (de type Attr) de la map ou None. ee
>>> attrs = root . childNodes [1]. attributes >>> for idx in range (0 , attrs . length ): ... a = attrs . item ( idx ) ... print ( + a . name + ) , ... print a . nodeType , a . nodeName , a . nodeValue ... ( name ) 2 name doe ( firstname ) 2 firstname john

67

4.4
4.4.1

Construire un document XML


Crer un arbre DOM e

La cration dun document (de son arbre DOM) se fait par instanciation de la classe e Document (cest un objet comme un autre). Cette classe fournit des mthodes pour fabrie quer les noeuds. A la cration, un document ne contient rien, pas mme de noeud racine. e e
>>> newdoc = minidom . Document () >>> newdoc < xml . dom . minidom . Document instance at 0 x827fe7c > >>> newdoc . documentElement >>>

4.4.2

Crer des noeuds DOM e

Les mthodes de cration de noeud nincluent pas lajout de llment cr dans larbre. e e ee ee Ici, nous allons crer un document excessivement simple : e une racine root avec un attribut name, un commentaire, un noeud de texte contenu dans un noeud sometext. createElement(tag) cre un nouvel lment (de type Element) avec le nom de tag pass e ee e en param`tre et le retourne. e
>>> newroot = newdoc . createElement ( root )

createAttribute(name) cre un noeud de type Attr avec le nom name. Une fois le noeud e cr, la valeur peut tre xe avec lattribut nodeValue. ee e e
>>> rootattr = newdoc . createAttribute ( name ) >>> rootattr . nodeValue = foo

createTextNode(data) cre un noeud de donne contenant le text pass en param`tre e e e e (` inclure dans un noeud englobant, ici le noeud sometext cr pour). a ee c 2003-2007, Raphal Marvie e

68

Python et XML
>>> textnode = newdoc . createElement ( sometext ) >>> text = newdoc . createTextNode ( this node \ ncontains text ) >>> textnode . appendChild ( text )

createComment(text) cre un noeud de commentaires contenant le text pass en pae e ram`tre. e


>>> comment = newdoc . createComment ( a very usefull comment )

4.4.3

Ajout de noeuds dans un arbre

Les mthodes dajout dans un arbre viennent en complment des mthodes de cration. e e e e Leur dissociation est due aux multiples usages que lon peut faire dun noeud. Il est possible de construire un document XML partir dun document existant, dans ce cas on ne va pas recrer tout les noeuds, mais peut tre simplement les rorganiser. e e e appendChild(new) ajoute un lment ` la n de la liste des ls dun noeud. ee a
>>> newdoc . appendChild ( newroot ) < DOM Element : root at 137797476 > >>> textnode . appendChild ( text ) < DOM Text node " this node c ... " >

insertBefore(new, old) ajoute un lment avant un ls donn dun noeud. ee e


>>> newroot . insertBefore ( comment , textnode ) < DOM Comment node " a very use ... " >

replaceChild(new, old) remplace un lment ls dun noeud par un autre lment. ee ee setAttribute(name, value) cre un nouvel attribut sur un noeud sans passer par une e instance de type Attr.
>>> newroot . setAttribute ( usefull , nop )

setAttributeNode(new) ajoute un noeud attribut au noeud considr. ee


>>> newroot . setAttributeNode ( rootattr )

4.4.4

Supprimer des noeuds dun arbre DOM

Il est aussi possible de supprimer des noeuds dans un arbre DOM, par exemple pour en crer une nouvelle version plus pure ou pour une restructuration dun document XML. e e e removeChild(old) supprime un ls dun noeud ` utiliser conjointement avec unlink().1 a
1

retrouver pourquoi

c 2003-2007, Raphal Marvie e

4.5 Exercices
>>> try : ... old = root . removeChild ( root . firstChild ) ... old . unlink () ... except ValueError : print failed ...

69

removeAttribute(name) supprime un attribut dun noeud par son nom.


>>> root . firstChild < DOM Element : contact at 137757692 > >>> root . firstChild . removeAttribute ( firstname )

removeAttributeNode(old) supprime un attribut dun noeud par la rfrence de lobjet ee Attr le reprsentant ou l`ve lexception NotFoundErr. e e

4.4.5

Srialiser un document XML e

Lobjectif de faire un document XML est dobtenir un chier. Les fonctions toxml(), toprettyxml() donnent la version texte dun arbre DOM (une ligne ou multi-ligne indentes). e Elles sont disponibles sur tous les noeuds et lvaluation est automatiquement rcursive. e e Pour srialiser un document, il sut dappeler une de ces mthodes sur lobjet document. e e Si lappel est fait sur un noeud, alors le chier sera un sous ensemble du document XML.
>>> newdoc . toxml () <? xml version ="1.0" ? >\n < root name =" foo " usefull =" nop " > \ <! - - a very usefull comment - - > \ < text > this node \ ncontains text </ text > </ root > >>> output = open ( / tmp / tmp . xml , w ) >>> output . write ( newdoc . toprettyxml ()) >>> output . close ()

4.5

Exercices

Le chier etudiants.xml contient 400 dossiers dtudiants (gnrs alatoirement) avec e e ee e la structure dcrite ci-dessous. Le but de lexercice est de produire trois listes sous forme e de chiers XML contenant (par ordre dcroissant pour les deux premi`res) les tudiants e e e admissibles, sur liste complmentaire ou refuss. e e
<? xml version = " 1.0 " ? > < etudiants > < etudiant nom = " doe " prenom = " john " dossier = " 0 " > < origine universite = " mit " / > < formation discipline = " informatique " niveau = " 4 " / > < resultats moyenne = " 16 " / > </ etudiant > </ etudiants >

c 2003-2007, Raphal Marvie e

70

Python et XML

Pour les trois listes, les informations conserves sont le nom, prnom, luniversit dorie e e gine et les rsultats. Les r`gles de selection sont les suivantes. e e pour tre admis, un(e) tudiant(e) doit avoir un niveau Bac+4, dans une formation e e en informatique, avec une moyenne suprieure ` 12 ; e a si sa discipline nest pas informatique (mais toujours avec les crit`res de niveau et de e moyenne), il (elle) est sur liste complmentaire ; e sinon il(elle) est refus(e). e Il faut pour cela parser le chier etudiants.xml, naviguer dans larbre DOM ainsi produit et construire trois arbres DOM qui seront en n de traitement srialiss dans les e e chiers admissibles.xml, complementaires.xml et refuses.xml. La structure de ces trois chiers est dcrite ci-dessous. e
<? xml version = " 1.0 " ? > < admissibles | complementaires | refuses > < etudiant nom = " doe " prenom = " john " dossier = " 0 " > < origine universite = " mit " / > < resultats moyenne = " 16 " / > </ etudiant > </ admissibles | complementaires | refuses >

c 2003-2007, Raphal Marvie e

Chapitre 5 Python et la persistance de donnes e


5.1
5.1.1

Fichiers DBM
Description et utilisation

Le module anydbm ore une solution pour des besoins simples de persistance en utilisant des chiers plats. Il propose une solution standard indpendante de limplmentation. e e Un chier DBM sutilise comme un dictionnaire, donc relativement simplement, seul linitialisation est dirente (ouverture du chier). Les donnes sont manipules comme des e e e cha nes et accessibles ` laide de cls. a e open(name, c) ouvre le chier nomm name (c signie ((en le crant sil nexsite e e pas) )).
>>> import anydbm >>> file = anydbm . open ( blabla , c )

close() ferme le chier (requis ou non selon les implmentations, pour tre sr que les e e u donnes sont sauves il vaut mieux utiliser explicitement close). e e
>>> file . close ()

La lecture et lcriture se fait comme dans un dictionnaire, mais les cls sont obligatoie e rement des cha nes. Lexemple suivant cre deux entres (foo et bar) dans le chier e e DBM, les re-lit et ferme le chier.
>>> file = anydbm . open ( blabla , c ) >>> file [ foo ] = perrier c foo >>> file [ bar ] = cd bar ; more beer >>> print file [ foo ] perrier c foo >>> print file [ bar ] cd bar ; more beer >>> file . close ()

71

72 has key() test la prsence dune cl. e e

Python et la persistance de donnes e

>>> file = anydbm . open ( blabla , c ) >>> file . has_key ( foo ) 1

keys() donne la liste des cls du chier. Obtenir les cl est un pr-requis ` tout parcours e e e a dun chier DBM.
>>> file . keys () [ foo , bar ] >>> for key in file . keys (): print key , file [ key ] foo perrier c foo bar cd bar ; more beer

len() donne le nombre dentres dun chier. footnote e


>>> len ( file ) 2

del permet de supprimer une entre (ce qui suit le fonctionnement standard dun dictione naire).
>>> file . keys () [ foo , bar ] >>> del file [ foo ] >>> file . keys () [ bar ] >>> len ( file ) 1 >>> file . close ()

5.1.2

Limitations

Les chiers DBM permettent uniquement de rendre persistant des cha de caract`res. nes e La conversion objet vers cha (et rciproquement) doit tre gre manuellement, ce qui ne e e ee rend leur utilisation rapidement complexe pour des objets composites.

5.2
5.2.1

Pickle et Shelve
Object pickling

Le module pickle (standard en Python) permet la srialisation des objets mmoire en e e cha nes (et rciproquement). Il est utile pour la persistance et le transferts de donnes sur e e un rseau. e
>>> import pickle

c 2003-2007, Raphal Marvie e

5.2 Pickle et Shelve

73

La manipulation des donnes utilise un chier par action de srialisation, o` les donnes e e u e sont stockes sous forme de cha e nes. Il ny a pas de structuration des donnes (donc pas e de recherche rapide).

5.2.2

(D)Srialisation et chiers e e

La classe Pickler est un srialiseur vers un chier et la fonction dump() ralise la e e srialisation dun objet (il existe aussi une fonction quivalente dans le module). Lexemple e e suivant srialise un dictionnaire dans le chier foo.saved. e
>>> >>> >>> >>> >>> foo = { a : aaa , b : bbb , c : ccc } output = open ( foo . saved , w ) p = pickle . Pickler ( output ) # (1) p . dump ( foo ) # (2) output . close ()

ou bien
>>> output = open ( foo . saved , w ) >>> pickle . dump ( foo , output ) >>> output . close () # (1 ,2)

La classe Unpickler est un d-srialiseur depuis un chier et la fonction load() ralise e e e la d-srialisation dun objet (il existe aussi une fonction quivalente dans le module). e e e Lexemple suivant recharge depuis le chier foo.saved le dictionnaire srialis dans lexemple e e prcdent. e e
>>> input = open ( foo . saved , r ) >>> p = pickle . Unpickler ( input ) >>> foo2 = p . load () >>> input . close () >>> foo2 { a : aaa , b : bbb , c : ccc } # (1) # (2)

ou bien
>>> input = open ( foo . saved , r ) >>> foo2 = pickle . load ( input ) >>> input . close () # (1 ,2)

5.2.3

(D)Srialisation et cha e e nes

dumps() srialise un objet vers une cha (et non plus vers un chier). Cette opration e ne e est pratique pour changer des messages sur un rseau par exemple. e e
>>> data = pickle . dumps ( foo ) >>> data " ( dp0 \ nS a \ np1 \ nS aaa \ np2 \ nsS c \ np3 \ nS ccc \ np4 \ \ nsS b \ np5 \ nS bbb \ np6 \ ns . "

c 2003-2007, Raphal Marvie e

74 loads() d-srialise une cha vers un objet. e e ne

Python et la persistance de donnes e

>>> foo3 = pickle . loads ( data ) >>> foo3 { a : aaa , c : ccc , b : bbb }

5.2.4

DBM + Pickle = Shelves

Le module shelves exploite les deux modules prcdents (en orant linterface du e e second) : pickle pour srialiser les objets (ventuellement complexes), e e anydbm pour la gestion des cls et des chiers. e Lexemple suivant cre un chier base dans lequel nous stockons un dictionnaire associ e e ` la cl foo. Puis, nous rouvrons ce chier pour rcuprer, dans ce dictionnaire, lentre a e e e e e associe ` la cl a. e a e
>>> import shelve >>> base = shelve . open ( base ) >>> base [ foo ] = { a : [ a1 , a2 ] , b : [ b1 , b2 ]} >>> base . close () >>> base2 = shelve . open ( base ) >>> print base2 [ foo ][ a ] [ a1 , a2 ] >>> base2 . close ()

5.2.5

Remarques

La concurrence de mise ` jour nest pas supporte avec shelve, une possibilit est a e e dutiliser fcntl. La dnition des classes doit tre importable au moment du chargement des donnes e e e par pickle. La compatibilit des chiers nest pas garantie entre deux implmentations de DBM. e e Il ny a donc que portabilit du code, pas des donnes. e e

5.3
5.3.1

Python et SQL
Exemple avec Postgres

Python inclut un module dacc`s aux bases de donnes orant une interface standardise e e e (de facto). Des mises en oeuvre existent pour les direntes bases de donnes courantes. e e Toutefois, lutilisation de chaque base peut varier, donc le code Python dacc`s ` une base e a 1 nest pas 100% portable .
1

Il est donc recommand dans une application de dnir une couche dabstraction de la base. e e

c 2003-2007, Raphal Marvie e

5.3 Python et SQL

75

Lutilisation dune base de donnes est ici illustr avec une base Postgres2 . Le module e e psycopg fournit lacc`s ` une base Postgres depuis Python. Il permet de trouver le bon e a compromis entre la puissance du langage et de la base de donnes : raliser une partie des e e traitements sur les donnes en SQL et une partie en Python. e Cration dune base personnelle sur la machine locale. e cration de la base sur le lesystem (une fois), e lancement du serveur (` chaque dmarrage de la machine), a e cration de la base (et dutilisateurs si ncessaire), e e administrateur = user au sens Unix, sans mot de passe.
$ initdb -D < repertoire > $ pg_ctl -D < repertoire > start [ - o " -i " # pour le r seau ] e $ createdb test

5.3.2

Oprations de base e

Lopration connect() retourne un objet reprsentant la connexion ` une base de donnes. e e a e Les arguments sont variables selon les bases ou les contextes (par exemple, host nest pas obligatoire si la base est locale).
>>> import psycopg >>> connexion = psycopg . connect ( ... " host = localhost dbname = test user = rafi " )

Des curseurs sont utiliss pour les interactions avec la base : mission de requtes SQL. e e e Ils sont crs par lobjet connexion. Un curseur ore la mthode execute qui permet ee e de demander ` la base lvaluation dune requte SQL. Le curseur est ici utilis pour a e e e crer une table test1 ayant un seul champ val de type entier. Ensuite, le curseur e est utilis pour faire 10 insertions dans cette table. e
>>> curseur = connexion . cursor () >>> curseur . execute ( ... " CREATE TABLE test1 ( val int4 ) " ) >>> for i in range (10): ... curseur . execute ( ... " INSERT INTO test1 VALUES (% d ) " , (i ,))

Exemples dinsertions. Une insertion peut se faire en utilisant un tuple (comme dans lexemple prcdent) ou un dictionnaire pour fournir les valeurs. Dans le cas de lutie e lisation des tuples, les donnes sont prises dans lordre du tuple qui doit tre de e e mme longueur que le tuple de format de la requte (argument de la clause VALUES). e e Lexemple suivant cre une nouvelle table et utilise un dictionnaire pour fournir les e
La mme chose avec MySQL di`re peu, par exemple sur la connexion et la gestion des commits, ` e e a ajouter.
2

c 2003-2007, Raphal Marvie e

76

Python et la persistance de donnes e valeurs ` insrer. La mthode executemany permet dinsrer une squence de donnes a e e e e e dans une table sans avoir ` faire une boucle en Python. a
>>> >>> ... >>> ... ... >>> >>> ... curseur = connexion . cursor () curseur . execute ( CREATE TABLE test2 ( name text , firstname text ) ) curseur . execute ( INSERT INTO test2 VALUES (%( name )s , %( firstname ) s ) , { name : doe , firstname : john }) valeurs = (( martin , pierre ) , ( dupont , paul )) curseur . executemany ( INSERT INTO test2 VALUES (% s , % s ) , valeurs )

Les resultats de requtes (rponses ` une command select) sont des structures de donnes e e a e Python : listes (ensemble des rponses) de tuples (les donnes dune rponse). Les e e e opration fetchone() et fetchall() oertes par le curseur permettent de rcuprer e e e respectivement une valeur (en fait les valeurs une par une) ou toutes les valeurs3 . Lexemple suivant excute une requte sur la base et rcup`re dabord la premi`re e e e e e rponse, en achant le premier champs, puis toutes les rponses restantes, en ae e chant les deux champs.
>>> curseur . execute ( " SELECT * FROM test2 " ) >>> prem = curseur . fetchone () >>> print prem [0] doe >>> valeurs = curseur . fetchall () >>> for v in valeurs : ... print v [0] , v [1] ... martin pierre dupont paul

close() demande explicitement la fermeture dune connexion (cest implicite lorsque lobjet connexion est dtruit au sens Python). e commit() valide une transaction avec la base (oert par un objet connexion). rollback() annule une transaction avec la base (oert par un objet connexion). autocommit(1|0) active ou dsactive lautocommit des oprations (oert par lobjet e e connexion).

5.3.3

Gestion de dates

Le module mx (associ ` psycopg) fournit des classes, principalement DateTime, pour ea la gestion des dates et timestamps.
3

Attention sur les select retournant beaucoup de rponses, le fetchall() a une borne suprieure. e e

c 2003-2007, Raphal Marvie e

5.4 Exercices
>>> import mx >>> mx . DateTime . now () < DateTime object for 2003 -06 -12 18:47:36.54 at 8 aa0a30 > >>> t1 = psycopg . TimestampFromMx ( mx . DateTime . now ()) >>> t2 = psycopg . Timestamp (2003 , 06 , 15 , 15 , 32 , 07)

77

5.3.4

Gestion de donnes binaires e

Lutilisation de donnes binaires (images ou sons par exemple) doit tre dclar explie e e e citement ` linsertion avec la classe Binary. Lexemple suivant cre une table pour a e stocker des photos avec leur nom, puis ins`re une photo. e
>>> >>> ... ... >>> ... ... curseur = connexion . cursor () curseur . execute ( CREATE TABLE test3 ( id int4 , name text , photo bytea ) ) curseur . execute ( INSERT INTO test3 VALUES (% d , %s , % s ) , (1 , shoes . jpg , psycopg . Binary ( open ( shoes . jpg ). read ())))

La rcupration des donnes binaire est similaire aux donnes classiques. Lexemple suie e e e vant rcup`re la photo qui est stocke dans la base et la sauvegarde dans un chier e e e nomm new_shoes.jpg. e
>>> >>> >>> >>> curseur = connexion . cursor () curseur . execute ( SELECT * FROM test3 ) val = curseur . fetchone () open ( new_ + val [1] , wb ). write ( val [2])

5.4
5.4.1

Exercices
Module ((Mod`le)) du MVC e

Ecrire un script Python qui cre une table reprsentant des tudiants avec les champs e e e suivants (le type des donnes est prcis entre parenth`ses) : num dossier (int4), nom e e e e (text), prnom (text), universit (text), discipline (text), niveau (int4), moyenne(int4). e e Ecrire un programme Python chargeant lensemble des donnes du chier etudiants.xml e dans cette table. Pour cela, une partie du code de lexercice prcdent est rutilisable pour e e e le parcours de larbre DOM.

5.4.2

Module ((Contrleur)) du MVC o

Dvelopper trois classes orant une mthode eval() ralisant les traitements suivants e e e sur la base de donnes : e c 2003-2007, Raphal Marvie e

78

Python et la persistance de donnes e

obtenir la liste des numros de dossiers, nom et prnom des tudiants, e e e obtenir la che compl`te dun tudiant par rapport ` son numro de dossier, e e a e insrer une che dtudiant en fournissant toutes les informations. e e Dvelopper une classe Controleur qui est une composition des trois classes prcdentes e e e et qui fournit des mthodes pour accder aux instances lors de lexcution (pour permettre e e e les interactions comme dcrite dans lexemple suivant). e
ctrl = Controleur (...) list_all_ctrl = ctrl . get_l ist_al l_ctrl () student_list = list_all_ctrl . eval ()

c 2003-2007, Raphal Marvie e

Chapitre 6 Python et les interfaces graphiques


6.1
6.1.1

Python et Tkinter
Tkinter

Le module Tkinter [3] est bas sur Tk, la librairie dveloppe par J. Ousterout pour e e e faire des interfaces graphiques en Tcl[10], et disponible sur plusieurs plates-formes (dont X11, MS-Windows, Mac OS X). Tkinter est le standard de facto pour Python orant une vision objet de Tk. Toutefois, Tcl est un langage o` tout est cha u nes de caract`res. Il en e rsulte quun certain nombre de valeur utilises dans le cas de Tkinter sont des cha e e nes de caract`res (utilises directement comme tel ou bien sous couvert de variables oertes par e e le module). Comme tout programme avec une interface graphique, lexcution est dirige par les e e vnements. Les interactions entre Python et linterface graphique peut prendre plusieurs e e formes : Traitement GUI Python Tkinter Tk Librairie graphique. Ev`nement graphique Tk Tkinter Traitements Python. e

6.1.2

Premier pas

Le ((hello world !)) version graphique tient en quatre lignes, prsentes dans lexemple e e suivant. Le module Tkinter est charg. Un widget (ici un Label) est cr puis ajout ` e ee ea lenvironnement graphique (pack). Enn, la boucle dvnements est dmarre. Elle est e e e e active tant que la fentre nest pas ferme (et le prompt de linterprteur reste suspendu). e e e
>>> >>> >>> >>> import Tkinter widget = Tkinter . Label ( None , text = hello world ! ) widget . pack () widget . mainloop ()

79

80

Python et les interfaces graphiques

6.1.3

Conguration de widgets

Dans le cas du Label de ((hello world !)), il ny a pas de widget parent (premier argument None). Il est attach directement ` la fentre par dfaut. Le texte du Label reprsente sa e a e e e conguration. La conguration peut tre ralise ou change apr`s la cration avec la e e e e e e mthode config() des widgets. Lexemple suivant est identique en terme de rsultat ` e e a lexemple prcdent. e e
>>> >>> >>> >>> widget = Tkinter . Label ( None ) widget . config ( text = hello world ! ) widget . pack () widget . mainloop ()

6.1.4

Composition de widgets avec pack

Les composition des widgets est dlgu au gestionnaire de gomtrie. ee e e e Le placement du widget se fait par rapport ` son contenant (avec loption de cona guration side) en utilisant un placement cardinal (Tkinter.TOP, Tkinter.LEFT, Tkinter.RIGHT, Tkinter.BOTTOM). Par dfaut, un widget est attach en haut, ou e e au-dessous des widgets existants Si lon souhaite une occupation maximale de lespace, utiliser loption de conguration expand=YES. La direction de loccupation maximale est prcise par fill. Elle peut e e tre en largeur (Tkinter.X), en hauteur (Tkinter.Y) ou les deux (Tkinter.BOTH). e

6.1.5

Lancer des commandes

Pour initier un traitement depuis une interface graphique, la mthode courante est de e dnir un bouton, un menu, une scrollbar, etc. et dy associer un traitement (fonction e ou mthode sans argument). Lexemple suivant cre un bouton et y associe la commande e e sys.exit pour quitter lexcution du programme (dans le cas courant linterprteur come e plet). Loption text prcise le texte qui appara sur le bouton. e t
>>> >>> >>> >>> >>> import sys widget = Tkinter . Button ( None ) widget . config ( text = press to quit , command = sys . exit ) widget . pack () widget . mainloop ()

c 2003-2007, Raphal Marvie e

6.1 Python et Tkinter

81

6.1.6

Composition et redimensionnement

Relations entre la composition et le redimensionnement : par dfaut le widget conserve sa taille initiale, e pour suivre les changements utiliser expand. Lexemple suivant congure le bouton de telle sorte quil occupe toujours tout lespace en largeur lors du redimensionnement de la fentre. Par contre, le bouton noccupe pas e tout lespace en hauteur.
>>> >>> >>> >>> >>> >>> import Tkinter import sys widget = Tkinter . Button ( None ) widget . config ( text = press to quit , command = sys . exit ) widget . pack ( expand = Tkinter . YES , fill = Tkinter . X ) widget . mainloop ()

6.1.7

Boutons et traitements

Un bouton ne peut dclencher quun traitement, il est donc souvent ncessaire dutiliser e e une fonction qui regroupe les traitements. Dans lexemple suivant, la fonction handler ache ((hello world) sur la sortie standard avant de quitter lapplication. )
>>> >>> >>> ... ... ... >>> >>> >>> >>> import Tkinter import sys def handler (): print hello world ! sys . exit () widget = Tkinter . Button ( None ) widget . config ( text = press to quit , command = handler ) widget . pack ( expand = Tkinter . YES , fill = Tkinter . X ) widget . mainloop ()

Une classe dutilisation dun widget graphique est une bonne mani`re de crer une e e relation forte entre widget, traitements et donnes. Cet ensemble (bouton, donnes, traitee e c 2003-2007, Raphal Marvie e

82

Python et les interfaces graphiques

ments) est facilement rutilisable. Lexemple prsente un exemple de bouton pour quitter e e une application o` le message est paramtrable. u e
>>> >>> >>> ... ... ... ... ... ... ... ... ... >>> >>> import Tkinter import sys class HelloQuitButton : def __init__ ( self , msg = Quit ): self . msg = msg b = Tkinter . Button ( None ) b . config ( text = self . msg , command = self . handle ) b . pack () def handle ( self ): print self . msg sys . exit () hqb = HelloQuitButton () Tkinter . mainloop ()

Un handler peut tre dni comme un objet : dnition dune classe reprsentant une e e e e fonction et instanciation pour lutilisation. Lexemple suivant rednit le handler prcdent e e e comme une classe.
>>> >>> >>> ... ... ... ... ... ... ... >>> >>> >>> >>> import Tkinter import sys class Callable : def __init__ ( self ): self . msg = hello world ! def __call__ ( self ): print self . msg import sys sys . exit () widget = Tkinter . Button ( None ) widget . config ( text = hello , command = Callable ()) widget . pack () Tkinter . mainloop ()

6.1.8

Dnition de bindings e

La fonction bind permet dassocier une fonction (` 1 argument) ` un vnement et a a e e ` un widget. Les vnements les plus courants sont les clics souris et la saisie au clavier. a e e Lexemple suivant cre deux fonctions pour acher ((hello world !)) et pour acher ((bye) e ) sur la sortie standard avant de quitter le programme. Ensuite, il cre un label et y associe e la fonction hello au clic gauche et la fonction quit au double clic.
>>> import Tkinter >>> import sys

c 2003-2007, Raphal Marvie e

6.1 Python et Tkinter


>>> def hello ( event ): ... print hello world ! ... >>> def quit ( event ): ... print bye ... sys . exit () ... >>> widget = Tkinter . Label ( None , text = press ) >>> widget . pack () >>> widget . bind ( < Button -1 > , hello ) 805810704 hello >>> widget . bind ( < Double -1 > , quit ) 805810224 quit >>> widget . mainloop ()

83

Lvnement ((reu)) par un handler contient des informations qui peuvent tre ine e c e terprtes dans le cadre du traitement. Lexemple suivant dnit deux fonctions dont le ee e but est dacher un caract`re tap au clavier et dacher les coordonnes de la souris. e e e La classe Tk reprsente la fentre principale du programme. Le label cr est associ ` e e ee e a cette fentre (premier param`tre du constructeur). Puis, les deux fonctions sont associes e e e au clavier et au clic sur le label. Lutilisation de focus slectionne le label pour recevoir e les vnements clavier. Enn, la boucle dvnements est dmarr sur la fentre princie e e e e e e pale. Lorsque la fentre est active et que lon tape une touche au clavier, cela gn`re un e e e vnement pass ` la fonction onKey qui va en extraire le caract`re associ. (Mme principe e e ea e e e pour le clic de souris.)
>>> import Tkinter >>> def onKey ( event ): ... print got key , event . char ... >>> def onClick ( event ): ... print event . widget , event .x , event . y ... >>> root = Tkinter . Tk () >>> lab = Tkinter . Label ( root , text = hello world ) >>> lab . bind ( < KeyPress > , onKey ) 805787968 onKey >>> lab . bind ( < Button -1 > , onClick ) 808388888 onClick >>> lab . focus () >>> lab . pack () >>> root . mainloop () .805789368 30 14 .805789368 44 11 got key e got key r

c 2003-2007, Raphal Marvie e

84 Quelques noms de bindings courants <KeyPress> <KeyPress-a> <KeyPress-A> <Return> <Escape> <Up> <Down> <Button-1> <Button-2> <Button-3> <ButtonRelease> <Motion> <B1-Motion> <Enter> <Leave> <Configure> <Map> <Unmap>

Python et les interfaces graphiques

Pression sur une touche Pression sur la touche A (minuscule) Pression sur la touche A (majuscule) Pression sur entre e Touche dchappement e Pression sur les `ches e Click souris gauche Click souris milieu (ou les deux) Click souris droit Fin de click gauche Mouvement de la souris Mouvement de la souris avec click gauche Entre et sortie souris dun widget e Redimensionnement de la fentre e Ouverture et iconication de la fentre e

6.1.9

Assemblage de widgets

Lassemblage de widgets se fait par utilisation de containers graphiques, principalement en dnissant des Frames auxquels sont rattachs les widgets. Lexemple suivant utilise une e e Frame pour regrouper deux boutons. La commande associe au second bouton permet la e fermeture de la fentre sans arrter linterprteur. e e e
>>> >>> ... ... >>> >>> >>> >>> >>> >>> >>> >>> import Tkinter def hello (): print hello world ! win = Tkinter . Frame () win . pack () Tkinter . Label ( win , text = hello world ! ). pack ( side = Tkinter . TOP ) b1 = Tkinter . Button ( win , text = hello , command = hello ) b1 . pack ( side = Tkinter . LEFT ) b2 = Tkinter . Button ( win , text = quit , command = win . quit ) b2 . pack ( side = Tkinter . RIGHT ) win . mainloop ()

c 2003-2007, Raphal Marvie e

6.1 Python et Tkinter

85

6.1.10

Widgets orients objet e

Lapproche objet sapplique bien aux interfaces graphiques en utilisant lhritage pour e dnir de nouveaux widgets par spcialisation ou extension. Lexemple suivant prsente une e e e spcialisation du widget Button en bouton pour quitter lapplication (en fait le bouton ne e dtruit que lui). e
>>> class MyByeButton ( Tkinter . Button ): ... def __init__ ( self , parent = None , ** config ): ... Tkinter . Button . __init__ ( self , parent , config ) ... self . pack () ... self . config ( command = self . callback ) ... def callback ( self ): ... print bye ... ... self . destroy () ... >>> MyByeButton ( text = hello world ) >>> Tkinter . mainloop ()

6.1.11

A propos de laspect

La spcication de la taille et de la couleur est valable pour tous les widgets de Tkinter. e La spcication des polices, tailles et styles de caract`res est valable pour tout widget e e contenant du texte. Lexemple suivant dnit un label crit en jaune sur fond bleu avec la e e police Courrier 20 gras dans une surface totale de 3 lignes sur 20 caract`res. e
>>> >>> >>> >>> >>> >>> root = Tkinter . Tk () msg = Tkinter . Label ( root , text = hello world ) msg . config ( font =( courier , 20 , bold )) msg . config ( bg = blue , fg = yellow ) msg . config ( height =3 , width =20) msg . pack ( expand = Tkinter . YES , fill = Tkinter . BOTH )

c 2003-2007, Raphal Marvie e

86

Python et les interfaces graphiques

6.1.12

Application multi-fentre e

Il est possible de dnir dans une mme applications des fentres indpendantes (non e e e e contenues visuellement dans la mme fentre). Lexemple suivant dnit deux fentres e e e e indpendantes contenant les labels ((hello)) et ((world)). e
>>> >>> >>> >>> >>> root = Tkinter . Tk () win1 = Tkinter . Toplevel ( root ) Tkinter . Label ( win1 , text = hello ). pack () win2 = Tkinter . Toplevel ( root ) Tkinter . Label ( win2 , text = world ). pack ()

Terminaison dune application multi-fentres : e destroy() supprime rcursivement la fentre concerne, e e e quit() termine la boucle dvnements sans dtruire la fentre. e e e e
>>> >>> >>> >>> >>> >>> >>> >>> >>> >>> root = Tkinter . Tk () win1 = Tkinter . Toplevel ( root ) b1 = Tkinter . Button ( win1 ) b1 . config ( text = moi , command = win1 . destroy ) b1 . pack () win2 = Tkinter . Toplevel ( root ) b2 = Tkinter . Button ( win2 ) b2 . config ( text = nous , command = root . destroy ) b2 . pack () root . mainloop ()

6.2

Petit tour des widgets courants

Dans la suite du chapitre nous considrons que le contenu module Tkinter est import e e dans lespace courant. Bien qutant plutt un dfenseur de lutilisation des modules avec e o e leur prxe, il est vrai que, en mode interactif, cela a ses avantages de tout importer dans e le scope global. Mais faites toujours attention aux risques de conits de nom !
>>> from Tkinter import *

6.2.1

Entry : Entres de texte e

Le widget Entry ore un champ de saisie de texte sur une seule ligne. Il dpend des e options de conguration suivantes : state=disable lecture seule, show=* saisie masque. e Lexemple suivant construit une petit interface avec une zone de saisie et deux boutons. La touche entre est associe dans la boite de saisie ` la fonction fetch(). Le premier e e a bouton ache sur la sortie standard le contenu de la zone de saisie. Pour cela, il utilise aussi la commande fetch(). Le second bouton ferme linterface. c 2003-2007, Raphal Marvie e

6.2 Petit tour des widgets courants


>>> ... ... >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> def fetch (): print Texte : <%s > % ent . get () root = Tk () ent = Entry ( root ) ent . insert (0 , Saisir texte ) ent . pack ( side = TOP , fill = X ) ent . bind ( < Return > , ( lambda event : fetch ())) b1 = Button ( root , text = Fetch , command = fetch ) b1 . pack ( side = LEFT ) b2 = Button ( root , text = Quit , command = root . destroy ) b2 . pack ( side = RIGHT ) root . mainloop ()

87

Manipulations de texte index dans une entre de texte : De 0 ` END, e a position dinsertion du curseur INSERT, get(deb, fin) retourne le texte ` la position donne, a e insert(pos, txt) insert le texte txt ` la position pos, a delete(deb [,fin]) supprime le texte entre les position deb et fin (le second est optionnel).

6.2.2

Agencement de widgets

Un formulaire de saisie est un exemple type dagencement de plusieurs widgets Label et Entry. An davoir un formulaire bien align, lutilisation du gestionnaire cardinal e (au travers de pack) est remplac par lutilisation du gestionnaire ((grille)). La mthode e e grid(row=X, column=Y) permet lalignement des dirents lments dans une grille. Lexemple e ee suivant construit un formulaire ` trois entres. a e
>>> root = Tk () >>> r = 0 >>> for item in [ foo , bar , stuff ]: ... l = Label ( root , text = item , width =10) ... e = Entry ( root , width =10) ... l . grid ( row =r , column =0) ... e . grid ( row =r , column =1) ... r += 1

c 2003-2007, Raphal Marvie e

88

Python et les interfaces graphiques

Attention Les deux gestionnaires (cardinal et grille) ne se marient pas toujours bien.

6.2.3

Zone de texte

Le widget Text ore une zone de saisie et de manipulation de texte sous la forme dune cha de caract`res multi-lignes. Lexemple suivant dnit une zone de texte et ne e e un bouton. Lutilisation de ce dernier ache le contenu de la zone de texte sur la sortie standard ` laide de la fonction fetch(). Loption wrap=WORD de la zone de texte prcise a e que le dcoupage de son contenu se fait sur les mots (lorsquun mot ne tient pas sur la e ligne, la zone de texte passe automatiquement ` la ligne). a
>>> ... ... >>> >>> >>> >>> >>> >>> def fetch (): print txt . get ( 1.0 , END + -1 c ) root = Tk () txt = Text ( root , height =5 , width =20 , wrap = WORD ) txt . insert ( 1.0 , Saisir du texte sans couper les mots ... ) txt . pack ( side = TOP ) Button ( root , text = fetch , command = fetch ). pack () root . mainloop ()

Manipulation de texte index dans une zone de texte : de 1.0 (ligne.colonne) ` END, a INSERT donne la position dinsertion du curseur, e e SEL FIRST, SEL LAST contient les position de dbut et n de la slection, get(deb, fin) retourne le texte ` la position donne, a e get(1.0, END+-1c) retourne tout le texte contenu dans la zone. insert(li.co, txt) ajoute le texte ` la position li.co, a c 2003-2007, Raphal Marvie e

6.2 Petit tour des widgets courants

89

delete(deb [,fin]) supprime le texte entre les position deb et n, search(chaine, deb, fin) retourne la position de dbut de la cha dans la zone e ne de texte, see(li.co) Fait dler lachage pour rendre la position donne visible, e e pour les dplacements relatifs dans une zone de texte par rapport ` une position : e a +/- un certain nombre de c (caract`re), w (mot) ou l (ligne). e

6.2.4

Listboxes

Le widget Listbox permet de grer des listes dlments et ore des mthodes pour e ee e lajout, le retrait et la slection dlments. Lexemple suivant dnit une listbox contenant e ee e 10 entre et un bouton. Lutilisation du bouton dclenche la fonction fetch() qui ache e e sur la sortie standard lentre de la liste slectionne (ou la premi`re ligne par dfaut). e e e e e
>>> ... ... >>> >>> >>> >>> >>> >>> ... ... ... >>> def fetch (): print list . get ( ACTIVE ) root = Tk () list = Listbox ( root ) list . pack ( side = TOP ) Button ( root , text = fetch , command = fetch ). pack () idx = 0 for i in range (10): list . insert ( idx , ligne - + str ( i )) idx += 1 root . mainloop ()

Manipulation de listes index dans une liste : de 0 ` END. a curselection() retourne lindex slectionn, e e get(idx) retourne llment ` lindex idx, ee a get(ACTIVE) Retourne llment slectionn, ee e e insert(idx, element) ajoute llment ` lindex idx, ee a delete(deb [,fin]) supprime les lments entre les index deb et n (le second est ee optionnel).

6.2.5

Barres de dlement e

Le widget scrollbar permet de grer le dlement (horizontal ou vertical) des zones de e e texte et des listboxes. Il utilise des mthodes de dlement fournies par ces deux widgets. e e Lexemple suivant reprend le prcdent en y ajoutant une barre de dlement pour grer e e e e une liste de 100 lments. Dans un premier temps, il cre une frame pour regrouper la ee e c 2003-2007, Raphal Marvie e

90

Python et les interfaces graphiques

liste et la barre. Ces deux derni`res sont congures pour que la liste volue en fonction de e e e lutilisation de la barre.
>>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> ... ... >>> root = Tk () frame = Frame ( root ) frame . pack ( side = TOP ) list = Listbox ( frame ) sbar = Scrollbar ( frame ) sbar . config ( command = list . yview ) list . config ( yscrollcommand = sbar . set ) sbar . pack ( side = RIGHT , fill = Y ) list . pack ( side = LEFT , expand = YES , fill = BOTH ) Button ( root , text = fetch , command = fetch ). pack ( side = BOTTOM ) idx = 0 for i in range (100): list . insert ( idx , ligne - + str ( i )) ; idx +=1 root . mainloop ()

6.2.6

Bo tes ` cocher et boutons radio a

Les deux widgets suivants permettent de grer des collections de donnes : e e checkbutton permet un choix multiple (bo ` cocher), tes a radiobutton permet un choix unique (boutons radio). Les options de ces deux widgets sont : command pour associer une action, variable pour xer et rcuprer la valeur. e e La variable doit tre dclare comme une variable Tkinter. Cela permet une interace e e tion entre Tk et Python initie par Tk (principe du callback) : IntVar et StringVar e permettent de crer des objets de stockage de valeurs enti`res ou de cha e e nes. c 2003-2007, Raphal Marvie e

6.2 Petit tour des widgets courants

91

Bo ` cocher Lexemple suivant cre un ensemble de trois bo te a e tes ` cocher dont la a valeur va tre reprsente par un entier. Chaque bo est indpendante, et cest le fait e e e te e de mmoriser les trois variables Tkinter dans une liste qui les relie. La fonction state() e dclenche par le bouton ache ltat des direntes bo e e e e tes.
>>> >>> >>> >>> >>> ... ... ... >>> ... ... ... >>> >>> >>> vars = list () root = Tk () for item in [ foo , bar , stuff ]: var = IntVar () Checkbutton ( root , text = item , variable = var ). pack ( side = LEFT ) vars . append ( var ) def state (): for v in vars : print v . get () , b = Button ( root , text = State , command = state ) b . pack ( side = LEFT ) root . mainloop ()

Boutons radio Lexemple suivant cre un ensemble de trois boutons radio dont la valeur e va tre reprsente par une cha e e e ne. Les trois boutons sont indpendant et cest le fait e dutiliser la mme variable Tkinter qui les relie. La fonction state() dclenche par le e e e bouton ache le nom du bouton radio actuellement slectionn. e e
>>> >>> >>> ... ... ... ... ... >>> ... ... >>> >>> >>> root = Tk () var = StringVar () for item in [ foo , bar , stuff ]: rb = Radiobutton ( root , text = item , value = item , variable = var ) rb . pack ( side = LEFT ) def state (): print var . get () b = Button ( root , text = State , command = state ) b . pack () root . mainloop ()

c 2003-2007, Raphal Marvie e

92

Python et les interfaces graphiques

6.3
6.3.1

Autres widgets prt ` lemploi e a


Bo tes de dialogue

Le module tkMessageBox ore un certain nombre de bo de dialogue standard pour tes lachage de messages (avec une icne associe). Ces bo o e tes prennent le contrle de la o boucle dvnements (tant quelle ne sont par fermes). Les trois bo de base sont : e e e tes showinfo pour donner de linformation, showwarning pour signaler un warning, showerror pour signaler une erreur.
>>> from Tkinter import * >>> from tkMessageBox import * >>> root = Tk () >>> showinfo ( Information , " Python c est simple " ) ok >>> showwarning ( Attention , " Risque de dependance " ) ok >>> showerror ( Trop tard , " Peux plus m en passer " ) ok

Pour les interactions primitives avec lusager, les widgets askyesno et askokcancel permettent davoir une rponse boolenne ` une question : 1 si yes et 0 si no. e e a
>>> root = Tk () >>> if askyesno ( Question , " Python c est simple " ): ... showinfo ( xxx , Merci !!! )

c 2003-2007, Raphal Marvie e

6.3 Autres widgets prt ` lemploi e a


... else : ... showwarning ( xxx , Dommage ... ) ...

93

Pour des interactions basiques complmentaires avec lusager, askfloat, askinteger e et askstring permettent de demander des rponses types. e e
>>> from tkSimpleDialog import * >>> root = Tk () >>> askfloat ( Float , Entrer un nombre decimal ) 123 >>> askinteger ( Integer , Entrer un nombre entier ) 123.4 >>> askstring ( String , Entrer une chaine ) qwerty

Le module tkFileDialog fournit des bo de dialogue pour les interactions relatives tes aux chiers. Les direntes widgets oerts respectent les normes de linterface graphique e (X11, Mac OS X ou MS-Windows) : askopenfilename, asksaveasfilename et askdirectory retournent le nom du chier slectionn ou une cha vide, e e ne askopenfile et asksaveasfile retournent lobjet reprsentant le chier en mode e r (lecture), w (criture) , ou None, e filetypes, initialdir et initialfile sont des variables destins congurer la e recherche de chiers.
>>> from tkFileDialog import * >>> askopenfilename ( filetypes =[( Text , . txt )]) / home / rafi / enseign / python / bar . txt >>> asks aveasf ilename ( initialdir = / tmp ) / tmp / foo . txt

6.3.2

Barre de menus

La dnition de menus dans une fentre se fait ` laide dune Frame ddie. Le widget e e a e e Menubutton permet de dnir un lment de la barre et le widget Menu permet de dnir les e ee e c 2003-2007, Raphal Marvie e

94

Python et les interfaces graphiques

commandes associes ` llment. Lexemple suivant cre une frame pour servir de barre de e a ee e boutons puis un lment de cette barre pour les commandes relatives aux chiers. Ensuite, ee une entre est ajout dans ce premier menu orant la fonction ((Quit)). e e
>>> >>> >>> >>> >>> >>> >>> ... >>> root = Tk () menubar = Frame ( root ) menubar . pack ( side = TOP , fill = X ) fbutton = Menubutton ( menubar , text = File , underline =0) fbutton . pack ( side = LEFT ) file = Menu ( fbutton ) file . add_command ( label = Quit , command = root . destroy , underline =0) fbutton . config ( menu = file ) # lien entre bouton et menu

Lorganisation des menus dans la barre se fait ` laide des variables et fonctions suia vantes : bd, relief nombre de points et relief du menu (RAISED, SUNKEN, RIDGE), add_separator() ajoute une sparation entre deux commandes dun menu, e add_cascade() cration dun sous-menu, e entryconfig(num, state=...) xe laspect disponible (ENABLED, valeur par dfaut) e ou non disponible (DISABLED) dune entre dun menu. e Lexemple suivant dnit un sous menu ((Stu)) ` notre menu ((File)). e a
>>> >>> >>> ... ... >>> ... submenu = Menu ( fbutton , tearoff =0) submenu . config ( bd =2) submenu . add_command ( label = Sub stuff ( destroy ) , command = root . destroy , underline =0) file . add_cascade ( label = Stuff , menu = submenu , underline =0)

6.4

Autres extensions disponibles

Tix Tk Interface eXtension [5, 6] est une extension de Tkinter qui ore des widgets de plus haut niveau (plus de 40) comme ComboBox, NoteBook, DirTree, FileSelectBox, etc. http://tix.sourceforge.net wxPython ore lacc`s ` la librairie wxWindow http://www.wxpython.org e a c 2003-2007, Raphal Marvie e

6.5 Exercices PyQt ore lacc`s au toolkit Qt (Opie pour Ipaq). e PyKDE ore lacc`s aux librairies KDE. e PyGTK ore lacc`s aux widgets GTK. e

95

6.5
6.5.1

Exercices
Module ((Vue)) du MVC

Dvelopper une interface graphique en utilisant Tkinter, reposant sur les traitements e du contrleur dni dans le chapitre prcdent et composes des lments suivants : o e e e e ee une Listbox associe ` une Scrollbar donne la liste des numros de dossier, nom e a e et prnom des tudiants ; e e un formulaire (ensemble de Label et Entry) donnant les information dun tudiant e slectionn dans la Listbox (par exemple avec un double clic) ; e e un formulaire de saisie associ ` un Button pour entrer de nouvelles ches dtudiants. ea e

c 2003-2007, Raphal Marvie e

96

Python et les interfaces graphiques

c 2003-2007, Raphal Marvie e

Remerciements, historique et ` faire a


Remerciements
Merci ` a Thr`se Libourel pour mavoir demand de monter une formation dune semaine ` ee e a Python et aux participants pour lavoir suivie (base de la version 1.0.0). Fabien Devaux pour ses remarques sur le module re et sur la spcication de lencoe dage dun chier (prises en compte dans la version 1.0.1). Ccile Vnziani et Jeremy Garrouste pour leurs remarques sur les typos et erreurs. e e e

Historique
1.2.1, mars 2007 Correction de typos et rreurs. e 1.2.0, janvier 2007 Correction de typos et respect des r`gles dcriture. e e 1.1.0, juillet 2005 Mise ` jour des exemples et introduction de certaines spcicits de a e e la version 2.4. 1.0.1, Amliorations et corrections derreurs sur le module re et sur lencodage des e chiers.

` A faire
Faire un index. Dnir une signaltique pour direncier ce qui est pour tous de ce qui est une fois e e e Python bien compris. Refaire une passe sur lensemble an damliorer les explications et rajouter, si besoin e est, des exemples. Ajouter des chapitres sur les modules de tests, un ou plusieurs frameworks web, les moyens pour faire de la gnration de code. e e Parler de sqlite et de SQLObject dans le chapitre sur la persistance.

97

98

Python et les interfaces graphiques

c 2003-2007, Raphal Marvie e

Annexe A GNU Free Documentation License


Version 1.2, November 2002 Copyright c 2000,2001,2002 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.

Preamble
The purpose of this License is to make a manual, textbook, or other functional and useful document free in the sense of freedom : to assure everyone the eective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modications made by others. This License is a kind of copyleft, which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software. We have designed this License in order to use it for manuals for free software, because free software needs free documentation : a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals ; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.

A.1

Applicability and Denitions

This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The Document, below, refers to any such 99

100

GNU Free Documentation License

manual or work. Any member of the public is a licensee, and is addressed as you. You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law. A Modied Version of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modications and/or translated into another language. A Secondary Section is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Documents overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them. The Invariant Sections are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not t the above denition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none. The Cover Texts are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words. A Transparent copy of the Document means a machine-readable copy, represented in a format whose specication is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent le format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modication by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not Transparent is called Opaque. Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modication. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only. The Title Page means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, Title Page means the text near the most prominent appearance of the works title, preceding the beginning c 2003-2007, Raphal Marvie e

A.2 Verbatim Copying

101

of the body of the text. A section Entitled XYZ means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specic section name mentioned below, such as Acknowledgements, Dedications, Endorsements, or History.) To Preserve the Title of such a section when you modify the Document means that it remains a section Entitled XYZ according to this denition. The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties : any other implication that these Warranty Disclaimers may have is void and has no eect on the meaning of this License.

A.2

Verbatim Copying

You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3. You may also lend copies, under the same conditions stated above, and you may publicly display copies.

A.3

Copying in Quantity

If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Documents license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts : Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects. If the required texts for either cover are too voluminous to t legibly, you should put the rst ones listed (as many as t reasonably) on the actual cover, and continue the rest onto adjacent pages. If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, c 2003-2007, Raphal Marvie e

102

GNU Free Documentation License

or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public. It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.

A.4

Modications

You may copy and distribute a Modied Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modied Version under precisely this License, with the Modied Version lling the role of the Document, thus licensing distribution and modication of the Modied Version to whoever possesses a copy of it. In addition, you must do these things in the Modied Version : A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission. B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modications in the Modied Version, together with at least ve of the principal authors of the Document (all of its principal authors, if it has fewer than ve), unless they release you from this requirement. C. State on the Title page the name of the publisher of the Modied Version, as the publisher. D. Preserve all the copyright notices of the Document. E. Add an appropriate copyright notice for your modications adjacent to the other copyright notices. F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modied Version under the terms of this License, in the form shown in the Addendum below. G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Documents license notice. H. Include an unaltered copy of this License. I. Preserve the section Entitled History, Preserve its Title, and add to it an item stating at least the title, year, new authors, and publisher of the Modied Version as given on the Title Page. If there is no section Entitled History in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modied Version as stated in the c 2003-2007, Raphal Marvie e

A.5 Combining Documents

103

previous sentence. J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the History section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission. K. For any section Entitled Acknowledgements or Dedications, Preserve the Title of the section, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein. L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles. M. Delete any section Entitled Endorsements. Such a section may not be included in the Modied Version. N. Do not retitle any existing section to be Entitled Endorsements or to conict in title with any Invariant Section. O. Preserve any Warranty Disclaimers. If the Modied Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modied Versions license notice. These titles must be distinct from any other section titles. You may add a section Entitled Endorsements, provided it contains nothing but endorsements of your Modied Version by various partiesfor example, statements of peer review or that the text has been approved by an organization as the authoritative denition of a standard. You may add a passage of up to ve words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modied Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another ; but you may replace the old one, on explicit permission from the previous publisher that added the old one. The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modied Version.

A.5

Combining Documents

You may combine the Document with other documents released under this License, under the terms dened in section 4 above for modied versions, provided that you include c 2003-2007, Raphal Marvie e

104

GNU Free Documentation License

in the combination all of the Invariant Sections of all of the original documents, unmodied, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers. The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but dierent contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work. In the combination, you must combine any sections Entitled History in the various original documents, forming one section Entitled History ; likewise combine any sections Entitled Acknowledgements, and any sections Entitled Dedications. You must delete all sections Entitled Endorsements.

A.6

Collections of Documents

You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects. You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.

A.7

Aggregation with Independent Works

A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an aggregate if the copyright resulting from the compilation is not used to limit the legal rights of the compilations users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document. If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Documents Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate. c 2003-2007, Raphal Marvie e

A.8 Translation

105

A.8

Translation

Translation is considered a kind of modication, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail. If a section in the Document is Entitled Acknowledgements, Dedications, or History, the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.

A.9

Termination

You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.

A.10

Future Revisions of this License

The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may dier in detail to address new problems or concerns. See http ://www.gnu.org/copyleft/. Each version of the License is given a distinguishing version number. If the Document species that a particular numbered version of this License or any later version applies to it, you have the option of following the terms and conditions either of that specied version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation.

A.11

Addendum : How to use this License for your documents

To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page : c 2003-2007, Raphal Marvie e

106

GNU Free Documentation License Copyright c YEAR YOUR NAME. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation ; with no Invariant Sections, no Front-Cover Texts, and no BackCover Texts. A copy of the license is included in the section entitled GNU Free Documentation License.

If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the with...Texts. line with this : with the Invariant Sections being LIST THEIR TITLES, with the Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST. If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation. If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.

c 2003-2007, Raphal Marvie e

Bibliographie
[1] Agile Alliance. Agile Alliance Web site. http://www.agilealliance.org/. [2] A.M. Kuchling. Regular Expressions http://www.python.org/doc/howto/. [3] F. Lundh. An introduction to Tkinter. ?, 1999. [4] OReilly. Python sucess stories. http://www.oreilly.com. [5] Tix Group. The Tix Programming Guide. http://tix.sourceforge.net. [6] Tix Group. The Tix Wdiget Set. http://tix.sourceforge.net. [7] G. van Rossum and F. Drake. Python Library Reference Release 2.3.5. PythonLabs, 2004. http://www.python.org/doc/. [8] G. van Rossum and F. Drake. Python Reference Manual Release 2.3.5. PythonLabs, 2004. http://www.python.org/doc/. [9] G. van Rossum and F. Drake. Python Tutorial Release 2.3.5. PythonLabs, 2004. http://www.python.org/doc/. [10] B. Welch. Practical Programming in Tcl and Tk. Prentice Hall, 1997. ISBN : 0-13616830-2. HOWTO Release 0.03, 2003.

107

108

BIBLIOGRAPHIE

c 2003-2007, Raphal Marvie e

Vous aimerez peut-être aussi