Tutorial Python PDF

Initiation à Python par l’exemple
Raphael.Marvie@lifl.fr
6 juillet 2005
Version 1.0.1
2
Copyright (c) 2003-2005, 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
données", "Chapitre 6, Python et les interfaces graphiques", the
Front-Cover Text being "Initiation à Python par l’exemple", and no
Back-Cover Texts. A copy of the license is included in the section
entitled "GNU Free Documentation License".
c
°2003-2005, Raphaël Marvie
Avant-propos
Ce support propose une initiation au langage Python par l’exemple. Il fait suite à
une formation d’une semaine et comportant 6 cours. Cette version essaye de compléter
les transparents, mais ne regroupe malheureusement pas tout le discours accompgnant la
présentation des transparents. La formation se faisant en salle machine, tous les exemples
étaient testés pendant le cours. Cette approche est volontairement conservée ici et il est
conseillé d’utiliser ce support avec un interpréteur lancé pour «voir ce qui se passe».
Ce support de cours est destiné à un public étant familier avec au moins un langage
de programmation, si possible orienté objet, et être familier avec les notions d’objet. Ce
support n’est pas un cours de programmation, ni un cours complet sur le langage Python,
il ne représente qu’une initiation à différentes choses que l’on peut faire avec Python. La
version utilisée dans ce support est la 2.3.5. Les premiers compléments de ce support sont
les documents associés au langage Python comme la librairie standard [7] le manuel de
référence [8] ou bien le tutoriel officiel [9].
Sans ambition d’être suffisant, la mise en ligne de ce support a pour unique objectif
d’être éventuellement utile. Le format retenu permet une impression en «deux par page».
Toute remarque concernant ce support est toujours la bienvenue !
r.m.
3
4
c
Table des matières
Avant-propos 3
Introduction 9
1 Premiers pas 11
1.1 Utilisation de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.2 Structures de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.2.1 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.2.2 Typage en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.2.3 Arithmétique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.2.4 Chaı̂nes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.2.5 Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.2.6 Listes et chaı̂nes de caractères . . . . . . . . . . . . . . . . . . . . . 17
1.2.7 Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.2.8 Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.3 Constructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.3.1 Structuration et indentation . . . . . . . . . . . . . . . . . . . . . . 20
1.3.2 Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.3.3 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.3.4 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.3.5 Documenter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.4 Autres éléments sur les séquences . . . . . . . . . . . . . . . . . . . . . . . 24
1.4.1 Manpulation de séquences . . . . . . . . . . . . . . . . . . . . . . . 24
1.4.2 Boucles for problématiques . . . . . . . . . . . . . . . . . . . . . . 25
1.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.5.1 Manipulations de données . . . . . . . . . . . . . . . . . . . . . . . 26
2 Quelques modules et built-in 27

2.1 Définition et utilisation de modules . . . . . . . . . . . . . . . . . . . . . . 27
2.1.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.2 Quelques modules standards et utiles . . . . . . . . . . . . . . . . . . . . . 30
2.2.1 Le module sys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.2.2 Le module string . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5
6 TABLE DES MATIÈRES
2.2.3 Le module re . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.2.4 Le module os . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.2.5 Le module os.path . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.2.6 Les modules glob et fnmatch . . . . . . . . . . . . . . . . . . . . . 35
2.2.7 Le module getpass . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.3 Built-in en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.3.1 Les fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2.3.2 Conversions de type . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.3.3 Evaluation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.3.4 Assertions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.4.1 Utilitaire de sauvegarde . . . . . . . . . . . . . . . . . . . . . . . . 39
2.4.2 Extraction de données . . . . . . . . . . . . . . . . . . . . . . . . . 40
3 Plongeon dans les objets 41

3.1 Des objets, que des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.1.1 Rappels des principes de base de POO . . . . . . . . . . . . . . . . 41
3.1.2 Objets et références . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.1.3 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.1.4 Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.1.5 Introspection simple . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.1.6 Classes et attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.1.7 Un peu de réflexion . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.1.8 Un peu plus de réflexion avec inspect . . . . . . . . . . . . . . . . 47
3.1.9 Classes vs modules . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.2 Les exceptions en python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.2.1 Définition et lancement . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.2.2 Traitement des exceptions . . . . . . . . . . . . . . . . . . . . . . . 50
3.2.3 Traitement d’exceptions et héritage . . . . . . . . . . . . . . . . . . 52
3.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.3.1 Premières classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.3.2 Design pattern état . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4 Python et XML 55
4.1 XML, avec une vision DOM . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.1.1 Langages de balises . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.1.2 XML, quels outils ? . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.1.3 DOM, petit rappel . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.1.4 Exemple du chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.2 Naviguer dans un arbre DOM . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.2.1 minidom «il fait le maximum» . . . . . . . . . . . . . . . . . . . . . 57
4.2.2 Parser un document XML . . . . . . . . . . . . . . . . . . . . . . . 57
4.2.3 Parcourir un arbre DOM . . . . . . . . . . . . . . . . . . . . . . . . 57
c
TABLE DES MATIÈRES 7
4.2.4 Recherche dans un arbre DOM . . . . . . . . . . . . . . . . . . . . 58

4.2.5 NodeList et objets séquences . . . . . . . . . . . . . . . . . . . . . 59
4.3 Accéder aux informations d’un noeud . . . . . . . . . . . . . . . . . . . . . 59
4.3.1 Informations liées au noeud . . . . . . . . . . . . . . . . . . . . . . 59
4.3.2 Informations liées aux attributs d’un noeud . . . . . . . . . . . . . 60
4.4 Construire un document XML . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.4.1 Créer un arbre DOM . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.4.2 Créer des noeuds DOM . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.4.3 Ajout de noeuds dans un arbre . . . . . . . . . . . . . . . . . . . . 62
4.4.4 Supprimer des noeuds d’un arbre DOM . . . . . . . . . . . . . . . . 62
4.4.5 Sérialiser un document XML . . . . . . . . . . . . . . . . . . . . . . 63
4.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
5 Python et la persistance de données 65

5.1 Fichiers DBM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
5.1.1 Description et utilisation . . . . . . . . . . . . . . . . . . . . . . . . 65
5.1.2 Limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.2 Pickle et Shelve . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.2.1 Object pickling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.2.2 (Dé)Sérialisation et fichiers . . . . . . . . . . . . . . . . . . . . . . . 67
5.2.3 (Dé)Sérialisation et chaı̂nes . . . . . . . . . . . . . . . . . . . . . . 67
5.2.4 DBM + Pickle = Shelves . . . . . . . . . . . . . . . . . . . . . . . . 68
5.2.5 Remarques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
5.3 Python et SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
5.3.1 Exemple avec Postgres . . . . . . . . . . . . . . . . . . . . . . . . . 68
5.3.2 Opérations de base . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.3.3 Gestion de dates . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.3.4 Gestion de données binaires . . . . . . . . . . . . . . . . . . . . . . 71
5.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5.4.1 Module «Modèle» du MVC . . . . . . . . . . . . . . . . . . . . . . 71
5.4.2 Module «Contrôleur» du MVC . . . . . . . . . . . . . . . . . . . . 71
6 Python et les interfaces graphiques 73

6.1 Python et Tkinter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
6.1.1 Tkinter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
6.1.2 Premier pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
6.1.3 Configuration de widgets . . . . . . . . . . . . . . . . . . . . . . . . 74
6.1.4 Composition de widgets avec pack . . . . . . . . . . . . . . . . . . 74
6.1.5 Lancer des commandes . . . . . . . . . . . . . . . . . . . . . . . . . 74
6.1.6 Composition et redimensionnement . . . . . . . . . . . . . . . . . . 75
6.1.7 Boutons et traitements . . . . . . . . . . . . . . . . . . . . . . . . . 75
6.1.8 Définition de bindings . . . . . . . . . . . . . . . . . . . . . . . . . 76
6.1.9 Assemblage de widgets . . . . . . . . . . . . . . . . . . . . . . . . . 78
c
6.1.10 Widgets orientés objet . . . . . . . . . . . . . . . . . . . . . . . . . 79

6.1.11 A propos de l’aspect . . . . . . . . . . . . . . . . . . . . . . . . . . 79
6.1.12 Application multi-fenêtre . . . . . . . . . . . . . . . . . . . . . . . . 79
6.2 Petit tour des widgets courants . . . . . . . . . . . . . . . . . . . . . . . . 80
6.2.1 Entry : Entrées de texte . . . . . . . . . . . . . . . . . . . . . . . . 80
6.2.2 Agencement de widgets . . . . . . . . . . . . . . . . . . . . . . . . . 81
6.2.3 Zone de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
6.2.4 Listboxes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.2.5 Barres de défilement . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.2.6 Boı̂tes à cocher et boutons radio . . . . . . . . . . . . . . . . . . . . 84
6.3 Autres widgets prêt à l’emploi . . . . . . . . . . . . . . . . . . . . . . . . . 86
6.3.1 Boı̂tes de dialogue . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
6.3.2 Barre de menus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
6.4 Autres extensions disponibles . . . . . . . . . . . . . . . . . . . . . . . . . 88
6.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
6.5.1 Module «Vue» du MVC . . . . . . . . . . . . . . . . . . . . . . . . 88
Remerciements 91
A GNU Free Documentation License 93

A.1 Applicability and Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . 93
A.2 Verbatim Copying . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
A.3 Copying in Quantity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
A.4 Modifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
A.5 Combining Documents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
A.6 Collections of Documents . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
A.7 Aggregation with Independent Works . . . . . . . . . . . . . . . . . . . . . 98
A.8 Translation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
A.9 Termination . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
A.10 Future Revisions of this License . . . . . . . . . . . . . . . . . . . . . . . . 99
A.11 Addendum : How to use this License for your documents . . . . . . . . . . 99
c
Introduction
Un peu d’histoire
Python est un langage de programmation objet interprété. Son origine est le langage de
script du système d’exploitation Amoeba (1990). Il a été développé par Guido Von Rossum
au CWI, à l’Université d’Amsterdam et nommé par rapport au Monthy Python’s Flying
Circus.
Depuis, Python est devenu un langage de programmation généraliste (comp.lang.python
est créé en 1994). Il offre un environnement complet de développement comprenant un
interpréteur performant et de nombreux modules. Un atout indéniable est sa disponibilité
sur les plates-formes courantes.
Python est un langage open source supporté, développé et utilisé par une large com-
munauté : 300, 000 utilisateurs et plus de 500, 000 downloads par an.
Python, à quoi bon ?

Pour résumer Python en quatre points forts.
Qualité L’utilisation de Python permet de produire facilement du code évolutif et main-
tenable et offre les avantages de la programmation orientée-objet.
Productivité Python permet de produire rapidement du code compréhensible en reléguant
nombre de détails au niveau de l’interpréteur.
Portabilité La disponibilité de l’interpréteur sur de nombreuses plates-formes permet
l’exécution du même code sur un PDA ou un gros système1 .
Intégration L’utilisation de Python est parfaitement adaptée l’intégration de composants
écrit dans un autre langage de programmation (C, C++, Java avec Jython). Embar-
quer un interpréteur dans une application permet l’intrégration de scripts Python au
sein de programmes.
Quelques caractéristiques intéressantes

– langage interprété (pas de phase de compilation explicite)
– pas de déclarations de types (déclaration à l’affectation)
– gestion automatique de la mémoire (comptage de références)
1
Même si un tel cas semblerait un peu bizarre.
9
– programmation orienté objet

– par nature dynamique et interactif
– possibilité de générer du byte-code (améliore les performances par rapport à une
interprétation perpetuelle)
– interactions standards (appels systèmes, protocoles, etc.)
– intégrations avec les langages C et C++
Python ou pas Python ?

Comme tout langage de programmation Python n’est pas la solution ultime à tous les
besoins. Toutefois, on retrouve son utilisation dans différents contextes [4] comme Google,
la NASA, l’environnement Opie sur pocket PC, etc. Python est donc adapté pour réaliser
de «grosses applications».
Quand Python ? Python est un très bon langage pour le développement agile [1] et
itératif. Il permet d’être réactif et évite le cycle lourd programmer / compiler / tester.
De plus, le langage permet de vérifier très rapidement des hypothèses de mise en œuvre.
Une fois la solution réalisée en Python, il est alors toujours possible de l’optimiser en
redéveloppant certain de ses composants en C++ par exemple.
Python permet de produire des applications facilement extensibles non seulement par
le développeur mais aussi par l’usager.
Enfin, Python est un bon candidat pour l’automatisation de tâches systèmes. Le système
d’administration de la distribution Gentoo Linux portage est développé en Python.
Quand pas python ? Dynamicité est rarement compatible avec performance, Python
n’est donc certainement pas le meilleur langage pour faire du traitement intensif.
Dans certain cas, les usagers préfèrent limiter l’utilisation de Python à l’aspect intégration
de composants afin de produire des systèmes performants. La version Python fournit une
preuve de concept ou une version fonctionnelle avant de redévelopper les points faibles.
Une certitude pour terminer, Python permet d’identifier rapidement une mauvaise
idée...
c
Chapitre 1
Premiers pas
1.1 Utilisation de Python

Python, comme la majorité des langages dit de script, peut être utilisé aussi bien en
mode interactif qu’en mode script.
Dans le premier cas, il y a un dialogue entre l’utilisateur et l’interpréteur : les com-
mandes entrées par l’utilisateur sont évaluées au fur et à mesure. Cette première solution
est pratique pour le prototypage, ainsi que pour tester tout ou partie d’un programme ou
plus simplement pour ineragir simplement avec des structures de données complexes. Le
listing suivant présente comment démarrer l’interpréteur (simplement en tapant python à
l’invite du shell1 ) et comment en sortir (en tapant Ctrl-D).
$ python
Python 2.3.5 ( # 2 , Feb 9 2005 , 11:52:33)
[ GCC 3.3.5 ( Debian 1:3.3.5 -8)] on linux2
Type " help " , " copyright " , " credits " or " license " for more information .
> > > print ’ hello world ! ’
hello world !
>>> ^D
$
Pour une utilisation en mode script les instructions à évaluer par l’interpréteur sont
sauvegardées, comme n’importe quel programme informatique, dans un fichier. Dans ce
second cas, l’utilisateur doit saisir l’intégralité des instructions qu’il souhaite voir évaluer
à l’aide de son éditeur de texte favori, puis demander leur exécution à l’interpréteur. Les
fichiers Python sont identifiés par l’extension .py. Le listing suivant, l’interpréteur est ap-
pelé avec en paramètre le nom du programme à évaluer (le traditionnel ‘hello world’). Dans
le cas d’un système Unix, la première ligne du fichier hello.py précise quel interpréteur
utiliser pour évaluer le fichier si ce dernier est exécutable. Il suffit dans ce cas de taper le
nom du fichier à l’invite du shell.
$ cat hello . py
1
Dans tout ce support l’invite du shell sera identifié par la lettre $.
11
12 Premiers pas
# ! / usr / bin / env python

print ’ hello world ! ’
$ python hello . py
hello world !
1.2 Structures de base

1.2.1 Commentaires
Comme dans la majorité des langages de script, les commentaires Python sont définis
à l’aide du caractère #. Qu’il soit utilisé comme premier caractère ou non, le # intro-
duit un commentaire jusqu’à la fin de la ligne. Comme toujours, les commentaires sont à
utiliser abondamment avec parcimonie. Il ne faut pas hésiter à commenter le code, sans
pour autant mettre des commentaires qui n’apportent rien. Le listing suivant présente une
ligne de commentaire en Python. Les commentaires seront de nouveaux abordés en 1.3.5
pour l’auto-documentation. Les commentaires introduits par # devraient être réservés au
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 données que l’on manipule, ces données
sont des objets dont les classes sont définies par l’usager, ou par l’environnement Python
pour les types de base. Une conséquence est que l’utilisateur manipule les données au
travers de références (qui donnent accès aux fonctionnalités des instances). Cette approche
permet de rendre homogène les données manipulées par l’utilisateur (comme c’était le cas
en SmallTalk). Ainsi, toutes les données suivantes suivant sont des objets : 1, [2, 3, 4], 5.6,
’toto’, une instance de Foo.
Python est un langage à typage dynamique. Ceci ne veut pas dire que les données que
l’on manipule ne sont pas typées, mais que leur type est «calculé» lors de leur utilisation2 .
Dans ce contexte, le type des variables n’est pas défini explicitement par l’utilisateur. Ainsi,
une même variable peut référencer dans un programme des objets de types différents3 .
>>> x = 1 # x reference un entier
> > > x = ’ toto ’ # x reference desormais une chaine
> > > x = Foo () # x reference desormais une instance de Foo
2
En Python, ce calcul se résume à la possibilité pour l’objet de recevoir un message particulier.
3
Il est toutefois à noter que cette faclité ne devrait être utilisées que sous couvert du polymorphisme,
sans quoi la lisibilité du programme s’en trouve réduite.
c
1.2 Structures de base 13
1.2.3 Arithmétique
Python permet d’exprimer très simplement des opérations arithmétiques. Dans le cas
où tous les opérandes sont des entiers, alors les résultats seront aussi des entiers. Lors-
qu’au moins un des opérandes est de type réel, alors tous les opérandes sont automati-
quement convertis en réels. La colonne de droite du listing suivant présente des opérations
élémentaires sur des entiers, la colonne de droite sur des réels.
>>> x = 1 + 2
>>> y = 5 * 2
>>> y / x
3
>>> y % x
2
>>> y = 5.5 * 2
>>> y
11.0
>>> x = 12.0 / 3
>>> x
4.0
Dans le contexte de l’arithmétique, les affections peuvent prendre deux formes. Ces deux
formes ont un sens différent. Le listing suivant présente deux affectations qui pourraient être
comprises de manière identique. Toutefois, la première forme (ligne 2) a pour conséquence
de créer une nouvelle instance d’entier pour contenir l’ajout de 2 à la valeur de x. La seconde
forme (ligne 3) ajoute 2 à la valeur de x sans créer de nouvelle instance. La manière d’écrire
une opération a donc un impact sur son évaluation.
>>> x = 4
>>> x = x + 2
> > > x += 2
1.2.4 Chaı̂nes de caractères

Les chaı̂nes de caractères se définissent de plusieurs manières en Python. Il est possible
d’utiliser indifféramment des guillemets simples ou des guillemets doubles. Le choix est
souvent imposé par le contenu de la chaı̂ne : une chaı̂ne contenant des guillemets simples
sera déclarée avec des guillemets doubles et réciproquement. Pour les autres cas, c’est
indifférent. Enfin, comme tout est objet en Python une chaı̂ne est donc un objet. Le listing
suivant déclarer deux chaı̂nes référencées par x et y. Enfin, la chaı̂ne référencée par z est
une chaı̂ne de caractères multiligne (utilisation de trois quotes simples ou doubles).
> > > x = ’ hello ’
> > > y = " world ! "
> > > z = ’ ’ ’ hello
world ’ ’ ’
c
14 Premiers pas
1.2.4.1 Concaténation
La concaténation de ces chaı̂nes de caractères peut prendre deux formes. Dans les deux
cas, l’opérateur + est utilisé pour exprimer la concaténation. La forme de droite est un
raccourci d’écriture.
>>> x = x + y > > > x += y
>>> x >>> x
’ hello world ! ’ ’ hello world ! ’
1.2.4.2 Affichage
L’affichage de chaı̂nes de caractères à l’aide de la fonction print peut se faire en
concaténant explicitement des chaı̂nes (que ce soit avec l’opérateur de concaténation ou en
utilisant des virgules) ou en utilisant une chaı̂ne de formatage comme la fonction printf du
langage C. Cette seconde option est un peu plus puissante, mais aussi un peu plus lourde
à utiliser. Le listing suivant présente trois manière d’afficher des chaı̂ne de caractères.
> > > print ’I say : ’ + x
I say : hello world !
> > > print x , 2 , ’ times ’
hello world ! 2 times
> > > print " I say : % s % d time ( s ) " % ( x , 2)
I say : hello world ! 2 time ( s )
1.2.4.3 Manipulations
Python offre une méthode simple pour accéder aux caractères contenus dans une chaı̂ne :
une chaı̂ne est manipulée comme une séquence indexée de caractères. Ainsi, chaque ca-
ractère est accessible directement par son index (le premier étant indexé 0) en utilisation
des crochets. En plus de cet accès unitaire aux caractères, il est possible d’accéder à des
sous-chaı̂nes en précisant la tranche souhaitée l’index de début (qui est inclu) étant séparé
de l’index de fin (qui est exclu) par le caractère ‘ :’. Dans le cas des sous-chaı̂nes, la valeur
fournie est une copie et non un accès à une partie de la chaı̂ne d’origine.
Le listing suivant donne quelques exemples d’accès à un caractère (ligne 2), ou à une
sous-chaı̂ne pour le reste. La colonne de gauche présente des accès à partir du début de
la chı̂nes (les index sont positifs). La ligne 6 signifie que l’on souhaite le contenu de x du
quatrième caractère à la fin. La colonne de droite présente des exemples de manipulation
où certains index sont donnés à partir de la fin de la chaı̂ne (ils sont négatifs). Enfin, la
dernière ligne réalise une copie de la chaı̂ne x.
> > > x = ’ hello world ! ’
> > > x [4]
’o ’
> > > x [2:4] > > > x [ -3:]
’ ll ’ ’ ld ! ’
c
> > > x [3:] > > > x [1: -1]

’ lo world ! ’ ’ ello world ’
> > > x [:]
’ hello world ! ’
1.2.5 Listes
Les listes Python sont des ensemble ordonnés et dynamique d’éléments. Ces ensemble
peuvent contenir des éléments de différents types, leur seul point commun est que ce sont
des objets. Et comme tout est objet, les listes sont elles mêmes des objets (instances de la
classe list). L’exemple suivant cré tout d’abord une variable contenant la valeur vrai, puis
une liste nommée foo contenant la chaı̂ne ’bar’, l’entier 12345 et le contenu de la variable
x.
> > > x = True
> > > foo = [ ’ bar ’ , 12345 , x ]
L’ajout d’éléments dans une liste se fait à l’aide des méthodes append pour un ajout en
fin de liste, et insert, pour un ajout à un index donné. Enfin, la méthode extend ajoute
le contenu d’une liste passé en paramètre à la fin de la liste.
> > > 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 méthode index permet de connaı̂tre l’index de la première occurence d’un élément
dans une liste. Dans le cas où l’élément fournit en paramètre n’est pas présent, la méthode
lève l’exception ValueError. L’utilisation de la construction in retourne quant à elle True
si l’élément est présent dans la liste et False sinon.
> > > 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 d’être des ensembles ordonnés.
L’accès à un élément d’une liste se fait donc aussi par indexation (ligne 1). Il est possible de
c
16 Premiers pas
prendre une partie de liste (ligne 3) et d’obtenir une copie de liste (ligne 5). Cette dernière
manipulation est très importante lors de parcours de listes (voir section 1.4.2) pour ne pas
modifier la liste qui est parcourrue.
> > > foo [2]
’ new ’
> > > foo [1: -3]
[12345 , ’ new ’ , 1]
> > > bar = foo [:]
> > > bar . append (3)
> > > foo [ -1:]
[89]
> > > bar [ -1]
3
Les listes peuvent être fusionnées par concaténation. Ces concaténations peuvent aussi
se faire par copie ou par ajout. La ligne 1 représente une concaténation par copie des deux
listes existantes. La ligne 4 présente est une copie par concaténation d’éléments à une liste
existante. Enfin, la ligne 7 présente une manière simple de créer une liste par répétition
d’un motif (qui est une sous liste).
>>> bar = [0 , 1] + [1 , 0]
>>> bar
[0 , 1 , 1 , 0]
>>> bar += [2 , 3]
[0 , 1 , 1 , 0 , 2 , 3]
>>> bar
>>> [0 , 1] * 3
[0 , 1 , 0 , 1 , 0 , 1]
De manière symétrique à l’ajout d’éléments dans une liste, il est possible d’en supprimer.
La méthode remove permet de supprimer la première occurence d’un élément d’une liste en
le désignant (ligne 1). Si l’élément fourni en paramétre n’existe pas dans la liste, l’exception
ValueError est levée (ligne 4). L’opérateur del (delete) permet de détruire tout objet
Python, y compris une sous liste (ligne 8).
> > > foo . remove ( ’ new ’)
> > > foo
[ ’ bar ’ , 12345 , 1 , ’ new ’ , 67 , 89]
> > > foo . remove (34)
ValueError : list . remove ( x ): x not in list
> > > del foo [1:3]
> > > foo
[ ’ bar ’ , ’ new ’ , 67 , 89]
c
La notion de list mapping permet d’appliquer une opération sur tous les éléments d’une
liste. La ligne 2 dit que tout élément de foo est multiplié par deux4 .
> > > foo = [1 , 2 , 3 , 4]
> > > [ elt * 2 for elt in foo ]
[2 , 4 , 6 , 8]
1.2.6 Listes et chaı̂nes de caractères

Les listes et les chaı̂nes de caractères sont similaire dans leur structure et dans leur ma-
nipulation. Certaines méthodes disponibles sur les chaı̂nes manipulent les deux structures
de données.
La méthode join disponible sur les chaı̂ne permet de construire une chaı̂ne de caractère
depuis une liste de chaı̂nes. La chaı̂ne sur laquelle est invoquée la méthode join est alors
utilisé comme séparateur des différents éléments de la liste.
> > > ’ ; ’ . join ([ ’a ’ , ’b ’ , ’c ’ ])
’a ; b ; c ’
De manière symétrique, la méthode split, disponible sur les chaı̂nes, permet de décomposer
une chaı̂ne de caractères en une liste de sous chaı̂nes. Ce découpage se fait par rapport
à un ou plusieurs caractères (ligne 1). Dans le cas où un entier est passé comme second
argument, il précise le nombre maximum de découpage.
> > > ’ hello crazy world ! ’ . split ( " " )
[ ’ hello ’ , ’ crazy , ’ world ’]
> > > ’ hello crazy world ! ’ . split (" " , 1)
[ ’ hello ’ , ’ crazy world ! ’]
1.2.7 Tuples
Les tuples sont des ensemble ordonnés et immuables d’éléments. Comme les listes, les
tuples peuvent contenir des données de différents types. La ligne 1 présente une déclaration
classique (avec des parenthèses) alors que la ligne 2 présente la notation abrégée. La virgule
est importante pour préciser que l’on parle d’un tupe à un élément et non de la valeur 12.
Cette remarque serait valable dans la cas d’une déclaration parenthésée d’un tuple à un
élément.
> > > foo = ( ’ bar ’ , 12345 , x )
> > > bar = 12 ,
Comme les listes, les tuples sont accessibles par indexation (ligne 1 et 3), et la construc-
tion in permet de tester l’existance (ligne 5). Cependant, une fois créé le contenu d’un tuple
ne peut être modifié.
4
Cette construction est très proche de la programmation fonctionnelle telle que fournie par Lisp.
c
18 Premiers pas
> > > foo [1]

12345
> > > foo [: -1]
( ’ bar ’ , 12345)
> > > ’ bar ’ in foo
True
Remarque Critères de choix entre une liste et un tuple :

– les tuples sont plus rapides à parcourir que les listes,
– pour définir des constantes, utiliser des tuples.
Il est possible de convertir des tuples vers des listes (ligne 1) et réciproquement (ligne 3).
>>> list ((1 , 2 , 3))
[1 , 2 , 3]
>>> foo = tuple ([1 , 2 , 3])
>>> foo
(1 , 2 , 3)
Pour terminer, Python offre l’affectation multiple pour assigner différentes valeurs de-
puis un tuples (ligne 1) de manir̀e simultanée. Ici encore, les parenthèses peuvent être
omises (ligne 4).
>>> (x , y , z ) = foo
>>> x
1
>>> a , b , c = foo
>>> b
2
1.2.8 Dictionnaires
Les disctionnaires, parfois appelés tableaux associatifs, sont des ensembles non ordonnés
d’éléments indexés par des clés. Une clé doit obligatoirement être immuable (chaı̂ne, entier
ou tuple). D’autre part, une clé est toujours unique. Un dictionnaire vide est déclaré par
deux accolades (ligne 1). L’ajout (ligne 2 et 3) et l’accès (ligne 6) aux éléments d’un
dictionnaire se fait par indexation sur la clé associé à l’élément. L’affichage d’un dictionnaire
(ligne 5) présente une liste de paires «clé : valeur».
> > > mydict = {}
> > > mydict [ ’ foo ’ ] = 456
> > > mydict [123] = ’ bar ’
> > > mydict
{123: ’ bar ’ , ’ foo ’ : 456}
> > > mydict [123]
’ bar ’
c
Les dictionnaires offrent des méthodes pour manipuler les clés. La méthode keys re-
tourne une liste de toutes les clés du dictionnaire (ligne 1) et la méthode has_key retourne
True so la clé donné en paramètre est présente dans le dictionnaire et False dans le cas
contraire.
> > > mydict . keys ()
[123 , ’ foo ’]
> > > mydict . has_key ( ’ bar ’)
False
La méthode values donne accès à une liste des valeurs contenues dans le dictionnaire
(ligne 1) et la méthode items donne une liste de tuples, contenant chacun une paire clé,
valeur (ligne 3)..
> > > mydict . values ()
[ ’ bar ’ , 456]
> > > mydict . items ()
[(123 , ’ bar ’ ) , ( ’ foo ’ , 456)]
La modification d’une valeur associée à une clé se fait simplement en affectant de
nouveaux la valeur indéxée dans le dictionnaire par la clé en question (ligne 1). Enfin,
l’opérateur del permet de supprimer une associaion association du dictionnaire (ligne 4).
> > > mydict [123] = 789
> > > mydict
{123: 789 , ’ foo ’ : 456}
> > > del mydict [ ’ foo ’]
> > > mydict
{123: 789}
A l’aides des méthodes de manipulation des clé et des valeurs, il est possible de parcourir
un dictionnaire de plusieurs manières. Les quelques lignes suivantes donnent deux exemples
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 présente un parcours de dictionnaire avec une utilisation d’un list
mapping et d’une chaı̂ne de formattage (dont l’utilisation ne se limite pas à l’affichage).
> > > bar = { ’a ’ : ’ aa ’ , ’b ’ : ’ bb ’ , ’c ’ : ’ cc ’}
c
20 Premiers pas
> > > [ " % s =% s " % ( x , y ) for x , y in bar . items ()]

[ ’a = aa ’ , ’c = cc ’ , ’b = bb ’]
1.3 Constructions
1.3.1 Structuration et indentation
La structuration d’un programme Python est définie par son indentation. Le début
d’un bloc est défini par un ’ :’, la première ligne pouvant être considérée comme un en-tête
(test, boucle, définition, etc.). Le corps du bloc est alors indenté de manière plus importante
(mais régulière) que l’en-tête. Enfin, la fin du bloc est délimité par le retour à l’indentation
de l’en-tête. Les bloc peuvent être imbriqués
<en - tete >:
< instructions >
Dans le cas de bloc de taille réduite, par exemple une seule instruction, un bloc peut
être défini sur une seule ligne. Le caractère ‘ :’ sert toujours de délimiteur entre l’en-tête
et le corps. Les instructions du corps sont alors séparés par des ‘ ;’5 . Cependant, cette
utilisation n’est pas nécessairement bénéfique quant à la lisibilité du code, elle est donc à
éviter6 .
> > > < en - tete >: < instruction > ; < instruction >
Cette structuration est utilisée aussi bien pour définir des boucles, des tests, des fonc-
tions, des classes ou des méthodes.
1.3.2 Tests
Conditions booléennes En Python, tout ce qui n’est pas faux est vrai. Les conditions
booléennes fausses se résument au données «vide» : False, 0, "", [], {}, (), None.
Python offre une seule construction pour réaliser des tests : le if then else. Une par-
ticularité de cette mise en œuvre est la possibilité d’enchaı̂ner les tests avec la construction
elif.
if x == ’ hello ’:
print ’ hello too ! ’
elif x == ’ bonjour ’:
print ’ bonjour aussi ! ’
else :
print ’ moi pas comprendre ’
5
L’utilisation des ‘ ;’ en Python est optionnelle en fin de ligne et peut toujours être utilisée pour séparer
deux instructions sur une même ligne.
6
L’époque où les caractères étaient comptés dans une fichier est bien révolue.
c
1.3 Constructions 21
Les comparaisons entre séquences (chaı̂nes de caractères, listes et tuples) se fait selon
l’ordre lexicographique. Les deux tests suivants sont vrais.
(1 , 2 , 3) < (1 , 2 , 4)
(1 , 2 , 3) < (1 , 2 , 3 , 4)
1.3.3 Boucles
Deux types de boucles sont disponibles : les boucles énumérées (for) et les boucles
basées sur un test de fin (while). Ces deux constructions suivent le même schéma : un
en-tête qui décrit l’évolution de la boucle, un ensemble d’isntructions qui sont évaluées à
chaque tour de boucle et une partie optionnel qui est évaluée en sortie de boucle (introduite
par le mot-clé else). Enfin, comme en C les boucles peuvent contenir les branchements
continue pour passer à l’itération suivante et break pour sortir de la boucle (dans ce cas
la clause else n’est pas évaluée).
1.3.3.1 Boucles for

Une boucle for définit une variabble qui prend successivement toutes les valeurs de la
séquence (liste ou tuple) parcourrue (ligne 1). La clause else est évalué losrque la séquence
est épuisée et s’il n’y a pas eu de break (ligne 3).
for < var > in < sequence >:
< instructions >
else :
< instructions , sequence epuisee sans break >
La fonction range produit une liste de tous les entiers entre une borne inférieur et une
borne supérieur. Cette construction est utile lorsqu’une boucle for repose sur l’utilisation
d’une séquence d’entiers. La fonction range est utilisable de trois manières :
– un seul paramètre spécifiant le nombre d’éléments (ligne 1),
– deux paramètres spécifiant la borne inférieure (inclu) et supérieure (exclu) (ligne 3),
– trois paramètres spécifiant les bornes et le saut (incrément entre deux éléments de la
séquence) (ligne 5).
>>> range (6)
[0 , 1, 2, 3 , 4 , 5]
>>> range (3 , 7)
[3 , 4, 5, 6]
>>> range (0 , 10 , 3)
[0 , 3, 6, 9]
Boucle for parcourant une séquence de chaı̂ne (ligne 2-3) et parcourant une liste de
valeurs (ligne 7-8).
> > > a = [ ’ hello ’ , ’ world ’]
> > > for elt in a :
c
22 Premiers pas
... print elt

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

Une boucle while définit une condition boolénne avec les même règles que pour les
tests (ligne 1). Tant que cette condition est respectée, les instruction du bloc associé au
while sont évaluées. La clause else est évalué losrque la condition est fausse et qu’il n’y
a pas eu de break (ligne 3).
while < condition >:
< instructions >
else :
< instructions , condition fausse >
La boucle suivant représente la boucle minimale définissable avec un while. Certes,
elle est stupide mais elle permet d’illustrer l’utilisation du Ctrl-C pour interrompre un
traitement en cours d’exécution.
> > > while 1:
... pass
...
KeyboardInt errupt
1.3.4 Fonctions
Il n’y a que des fonctions en Python. Une fonction est définie avec le mot clé def. Un
fonction retourne toujours une valeur. Si une fonction ne contient pas de clause return, la
valeur None est alors retournée7 .
> > > def fib ( n ): # suite de fibonacci jusque n
... a, b = 0, 1
... while b < n :
... print b ,
... a, b = b, a + b
...
7
Il est éventuellement possible de parler de procédure dans ce cas
c
1.3 Constructions 23
> > > fib (100)

1 1 2 3 5 8 13 21 34 55 89
Les paramètres d’une fonction peuvent être définis avec une valeur par défaut. A l’utili-
sation de la fonction, ces paramètres sont alors optionnels. Dans le cas d’une fonction avec
des paramètres optionnels, l’utilisation des paramètres doit être ordonnée, les paramètres
sont affectés dans l’ordre de leur définition (ligne 6), ou nommée (ligne 8).
> > > 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 définir des fonctions anonymes, en utilisant la forme lambda 8 . Une
telle fonction est réduite à une simple expression. Cette construction est utile pour passer
des fonctions en paramètre d’autre fonctions pour les configurer9 ou dans le cas des list
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 intégrante du code. En plus de la possibilité de mettre
des commentaires avec l’utilisation de #, Python offre la possiblité d’écrire du code auto-
documenté. Ceci est valable pour les fonctions, les classes et les modules. Une telle do-
cumentation d’un élément est accessible vie l’attribut __doc__ de ces différents éléments.
Cette technique est utilisable automatiquement par les environnements intégrés de développement
ou par l’utilisation de la fonction help en mode interactif.
La définition des commentaires avec # devrait être réservé aux remarques techniques
sur le code et pour les développeur de l’élément en question. La documentation doit quant
à elle être destinée au développeurs mais surtout aux utilisateurs de l’élément documenté.
Elle doit donc refléter le comportement de l’élément. Cette seconde forme est à mettre en
parallèle avec la javadoc.
8
Ici encore, cela sent la programmation fonctionnelle type Lisp à plein nez. . .
9
Nous verrons un peu plus tard que ce n’est pas la seule possibilité.
c
24 Premiers pas
La définition de la documentation se fait sur la première ligne après la déclaration en

utilisant des chaı̂nes de caractères multi-lignes10 (ligne 2-5). Une bonne manière de définir
la documentation est de fournir une version courte sur une ligne, de passer une ligne et de
fournir des détails.
> > > 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 Autres éléments sur les séquences

1.4.1 Manpulation de séquences
Python offre un certain nombre de fonction permettant d’appliquer des traitements sur
tous les éléments d’une séquence afin de définir des filtres, d’appliquer des calculs pour
tous ou de calculer des hashcode.
1.4.1.1 filter
La fonction filter applique la fonction passée en premier argument sur chacun des
éléments de la séquence passée en second argument et retourne une nouvelle liste qui
contient tous les éléments de la séquence pour lesquels la fonction a retourné une valeur
vrai.
>>> def funct1 ( val ):
... return val > 0
...
>>> filter ( funct1 , [1 , -2 , 3 , -4 , 5])
[1 , 3 , 5]
>>> def iseven ( x ):
... return x % 2
10
Même si la documentation tient sur une seule.
c
1.4 Autres éléments sur les séquences 25
...
> > > filter ( iseven , [1 , 2 , 3 , 4 , 5 , 6])
[1 , 3 , 5]
1.4.1.2 map
La fonction map applique la fonction passée en premier argument sur chacun des
éléments de la ou des séquences passées en paramètre. Dans le cas où plusieurs séquences
sont passées en paramètre, la fonction doit prendre autant de paramètres qu’il y a de
séquences. map retourne une liste contenant le résultat de chacun des calculs.
>>> def sum ( x , y ):
... return x + y
...
>>> map ( sum , [1 , 2 , 3] , [4 , 5 , 6])
[5 , 7 , 9]
>>> map ( iseven , [1 , 2 , 3 , 4 , 5 , 6])
[1 , 0 , 1 , 0 , 1 , 0]
1.4.1.3 reduce
La fonction reduce applique réduit une séquence par l’application récursive d’une fonc-
tion sur chacun de ses éléments. La fonction passée comme premier paramètre doit prendre
deux arguments. La fonction map prend un troisième paramètre optionel qui est la valeur
initiale du calcul récursif.
> > > reduce ( sum , [1 , 2 , 3 , 4 , 5])
15
> > > reduce ( sum , [1 , 2 , 3 , 4 , 5] , -5)
10
1.4.2 Boucles for problématiques

Certaines boucles de manipulation des listes peuvent être problématiques, par exemple
si la boucle modifie la liste qu’elle est en train de parcourir. Pour que ce genre de boucle se
passe bien, et ne soit pas sans fin, 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 défaut, tout
argument est passé par référence et donc sans copie (en fait copie de la liste des références
et non des objets contenus) la boucle suivante serait sans fin11 .
> > > a = [1 , -2 , 3 , -4 , 5 , -6]
> > > for elt in a [:]:
... if elt > 0: a . insert (0 , elt )
11
Cette boucle rajoute les éléments positifs en début de liste, comme le premier élément est positif cette
boucle est toujours sur l’élément 1 alors que la liste ne fait que croı̂tre.
c
26 Premiers pas
...
>>> a
[5 , 3 , 1 , 1 , -2 , 3 , -4 , 5 , -6]
1.5 Exercices
1.5.1 Manipulations de données
Le fichier listetu.py contient une liste de 10 dictionnaires. Etudier cette structure de
données et écrire une fonction qui écrit sur la sortie standard (en sautant une ligne entre
chaque fiche) :
dossier : 1
nom : doe
prenom : john
universite : lille1
discipline : informatique
niveau : 4
moyenne : 17
c
Chapitre 2
Quelques modules et built-in
2.1 Définition et utilisation de modules

2.1.1 Définition
Dans le chapitre précédent, l’ensemble des extraits de code ont été saisis interactive-
ment. Cette méthode n’est pas viable pour les traitements que l’on exécute plusieurs fois
ou que l’on souhaite exécuter sur plusieurs machines. Pour rendre le code persistant, la
première solution est d’écrire un «programme», c’est-à-dire de saisir le code dans un fichier
texte avec l’extension .py. Un programme peut ainsi être exécuté plusieurs fois. Cepen-
dant, même si ce programme est correctement structuré avec des fonctions, il n’est pas
possible de réutiliser facilement ces dernières (si ce n’est avec un copier-coller qui est une
abomination).
Pour capitaliser les développement, Python propose la notion de module. Un module
permet de fournir des bilbiothèques de fonctions, structures de données, classes, à intégrer
dans les programmes. Dans le cas de python, produire un module est identique à produire
un programme : faire un fichier. Les définitions contenues dans un fichier sont utilisable
globalement ou unitairement. Ainsi, le fichier examples.py peut être utilisé comme un
module (nommé comme le fichier) et offrir l’accès aux deux fonctions à tout programme
en ayant l’utilité1 .
La chaı̂ne de documentation doit être mise avant toute déclaration (c’est-à-dire aussi
avant les clauses import) pour être considérée comme documentation du module. Les deux
premières lignes de ce fichier (optionnelles) ont la significations suivante :
– la première ligne de ce fichier indique que ce fichier sera reconnu comme un pro-
gramme Python par un envieonnement Unix (s’il a les droits en exécution)2 ;
– la seconde ligne précise le type d’encodage du fichier : ici l’encodage standard en eu-
rope occidentale supportant la gestion des accents. Dès qu’un fichier Python contient
un accent, cette ligne est oligatoire (dans le cas contraire elle peut être omise).
1
Si un programme a besoin de ces fonctions, c’est un programme très «social» au vu de leur utilité. . .
2
La construction # ! sert à préciser, sous Unix, le programme à utiliser pour exécuter un script.
27
28 Quelques modules et built-in
#! /usr/bin/env python
# -*- coding: iso-8859-1 -*-
#
# examples.py
#
"""
Regroupe les définitions des fonctions relatives au chapitre 1 de
‘Initiation a python par l’exemple’.
"""
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 d’un module La construction import permet d’importer un module et de

fournir accès à son contenu3 . L’importation d’un module peut se faire de deux manière.
La première solution est de désigner le module que l’on souhaite utiliser, son contenu est
alors utilisable de manière «scopée», c’est-à-dire en préfixant le nom de la fonctionnalité
du nom du module (ligne 2). La seconde solution repose sur la construction from import
où l’on identifie la ou les fonctionnalités que l’on souhaite importer d’un module (ligne
4)4 . L’utilisation se fait alors sans préfixer par le nom de module («non scopé»). Enfin,
il est possible d’importer, avec cette seconde approche, tous les éléments d’un module en
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
Nous considérons ici que l’interpréteur a été lancé dans le répertoire contenant le fichier examples.py.
4
Dnas le cas d’un import de plusieurs fonctionnalités, les noms sont séparés par des virgules.
c
2.1 Définition et utilisation de modules 29
Utilisation mixte Un fichier peut à la fois définir un module et un programme. Cette

définition mixte est intéressante pour, par exemple, utiliser les fonctionnalités d’un pro-
gramme indépendamment de celui-ci, ou pour associer le code de test à un module. Dans ce
cas, la fin du fichier contient la définition de l’initialisation du code comme un programme.
Pour cela, un test est réalisé afin de savoir si le code est importé ou exécuté. Si le code
est importé, la variable __name__ contient le nom du module, sinon elle contient la chaı̂ne
__main__ (ligne 1). Ici, dans le cas d’une exécution certaines des fonctions du module sont
testées. (Sinon il ne se passe rien.)
if __name__ == ’ __main__ ’:
welcome ( ’ world ’)
welcome ( ’ monde ’ , ’ Bonjour ’)
welcome ( ’ world ’ , mark = ’ ... ’)
fib (100)
L’utilisation du fichier examples comme un programme donne la trace d’exécution
suivante. Que l’on utilise explicitement l’interpréteur ou non (du fait de la première ligne
du fichier) 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 l’utilisation de la construction import, l’interpréteur recherche la

disponibilité des modules demandé dans le chemin décrit par la variable d’environnement
PYTHONPATH. La valeur par défaut de cette variable contient le répertoire d’installation de
Python et le répertoire courant.
Lors de l’utilisation de la construction from module import *, tout le contenu du
module est importé à l’exception des définition dont le nom commence par un ‘_’ (qui
reflètent la notion de privé en Python). L’utilisation de ce type d’importation allège le
code saisi, ce qui est intéressant en interactif. Toutefois, une fois le préfixage par le nom
de module perdu il peut de nouveau y avoir des conflits de noms entre les fonctionnalités
importées depuis plusieurs modules.
Enfin, les modules peuvent être organisés selon une structure hiérarchique. Dans ce cas,
c
les modules contenant des sous-modules, encore nommés packages, sont définis comme des
répertoires sur le système de fichier. Le nommage des modules se fait alors par concaténation :
mod.submod. Afin de faciliter la portabilité du code, tout répertoire doit contenir un fichier
nommé __init__.py. Pour permettre le chargement de tous les sous-modules, ce fichier
doit contenir la liste des modules du package (réprtoire) stockée dans la variable __all__.
$ cat graphical / __init__ . py
__all__ = [ ’ basic ’ , ’ advanced ’]
2.2 Quelques modules standards et utiles

Python offre grand nombre de modules. Ne sont présentés ici que les quatres modules
considérés comme incontournables :
sys fournit les paramètres et fonctions liées à l’environnement d’exécution,
string fournit des opérations courantes sur les chaı̂nes de caractères (équivalentes aux
méthodes de la classe string),
re fournit le support des expressions régulières pour faire du pattern matching et des
substitutions,
os fournit l’accès aux services générique du système d’exploitation.
Pour chacun de ces modules, les fonctionnalités de base sont présentées et illustrées sur
des exemples.
2.2.1 Le module sys

Quelques constantes offertes par le module sys :
argv Séquence des paramètres passé sur la ligne de commande (argv[0] représente le nom
du script).
stdin stdout stderr Objets de type file représentant les entrées et sorties standard.
Ces objets peuvent être remplacés par tout objet offrant une méthode write.
path Séquence contenant les chemins de la variable d’environnement PYTHONPATH. Cette
séquence peut être manipulée dynamiquement.
> > > 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 système d’exploitation.

> > > sys . platform
’ darwin ’
ps1, ps2 Variables contenant les valeurs des prompts, par défaut ’>>>’ et ’...’.
c
2.2 Quelques modules standards et utiles 31
Quelques fonctions offertes par le module sys :

exit ([arg]) Mettre fin à l’exécution d’un programme, arg étant le status de sortie.
Cette fonction respecte le nettoyage des clauses finally (voir section 3.2.2.2).
2.2.2 Le module string

Ce module fournit un certain nombre de constantes et de fonctions de manipualtion des
chı̂nes de caractères. Il est généralement recommandé d’utiliser les méthodes disponibles
sur les objets de type string équivalentes.
2.2.2.1 Quelques constantes

Des constantes pratiques offertes par le module string définissent des ensembles de
caractères :
> > > 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 gérer la casse d’une chaı̂ne de caractères : mise en mi-
nuscules, en majuscules, capitalisation de la phrase ou des mots (avec la réduction
des espaces).
> > > string . lower ( ’ FOO ’)
’ foo ’
> > > string . upper ( ’ foo ’)
’ FOO ’
> > > string . capitalize ( ’ foo ’)
’ Foo ’
> > > string . capwords ( ’ hello world ! ’)
’ Hello World ! ’
strip expandtabs permettent de gérer les espaces dans une chaı̂ne de caractères en sup-
primant les blancs non significatifs ou en remplaçant les tabulations par un nombre
fixe d’espaces.
c
> > > string . strip ( ’ hello world ! \ n ’ ) # [2 nd arg ]

> > > string . expandtabs ( ’\ thello world ! ’ , 4)
find permet de rechercher un motif dans une chaı̂ne (à partir du début ou de la fin pour
rfind) en retournant l’indice où le motif est trouvé pour la première fois ou -1. (La
fonction index est similaire mais lève une exception pour un motif non trouvé.)
> > > string . find ( ’ bonjour le monde ’ , ’ on ’)
1
> > > string . rfind ( ’ bonjour le monde ’ , ’ on ’)
12
> > > string . rfind ( ’ bonjour le monde ’ , ’ om ’)
-1
split permet de découper une chaı̂ne en une liste de mots (par défaut sur les espaces, ou
alors sur une chaı̂ne passée en second argument) et join permet l’opération inverse
qui est de construire une chaı̂ne à partir d’une liste de mots et une chaı̂ne de liaison.
> > > 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 d’un motif dans une
chaı̂ne et le remplacement de ce motif par un autre.
> > > string . count ( ’ bonjour le monde ’ , ’ on ’)
2
> > > string . replace ( ’ bonjour le monde ’ , ’ on ’ , ’ ONON ’)
’ bONONjour le mONONde ’
zfill center rjust ljust permettent de gérer l’affichage : zfill complète un nombre
avec des zéros en tête pour une largeur d’affichage constant, les trois autres fonctions
permettent de justifier 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
2.2.3 Le module re
Ce module permet la manipulation des expressions régulières [2]. Ces expressions sont
par défaut identiques à Perl et l’ouvrage «Mastering Regular Expressions» de Jeffrey Friedl
(O’Reilly) est un bon complément pour qui doit utiliser les expressions régulières. Afin de
ne pas devoir toujours utiliser des ‘\’ dans les expressions, il est possible d’utiliser des Raw
regular expressions en préfixant la chaı̂ne définissant l’expression par un ‘r’ : r’(.*)\n’. La
dernière question qu’il faut se poser avant de commencer à utiliser les expressions régulières
est l’encodage supporté. Le module re peut utiliser l’un ou l’autre de ces deux modules :
– sre Support unicode (module utilisé par défaut, implémentation masquée par re)
– pre Sans support unicode (mais ce module est désormais deprecated )
2.2.3.1 Opérations de recherche

search (pattern, chaine) permet de rechercher le pattern dans la chaı̂ne et retourne
un objet de type SRE_Match décrivant la réponse ou bien None. La classe SRE_Match
fournit des méthodes pour obtenir l’indice de début (start()) et de fin (end()) du
motif dans la chaı̂ne. Ici, la méthode matching utilise span() qui fournit un tuple
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ı̂ne commence par le pattern et retourne un objet
de type SRE_Match décrivant la réponse ou bien None.
> > > res = re . match ( ’ abr ’ , ’ abracadabra ’)
> > > matching ( res )
(0 , 3)
2.2.3.2 Opérations de manipulation

split (pattern, chaine) découpe la chaı̂ne par rapport au pattern. L’exemple suivant
fait un découpage en mots (tout ce qui n’est pas espace ou ponctuation).
> > > re . split ( ’\ W + ’ , ’ Hello world ! ’)
[ ’ Hello ’ , ’ world ’ , ’ ’]
sub (pattern, repl, chaine) retourne une chaı̂ne ou toutes les occurences du pattern
dans la chaı̂ne fournie sont remplacés par repl. La chaı̂ne n’est pas modifiée, une
copie est créée.
> > > re . sub ( ’ hello ’ , ’ bonjour ’ , ’ hello foo hello bar ’)
’ bonjour foo bonjour bar ’
c
2.2.3.3 Utilisation d’expressions compilées

Lorsqu’une expression régulière est utilisée de manière répétitive dans un programme, il
devient intéressant de compiler le pattern. Les fonctionnalités sont similaires à celles vues
précédamment (méthodes) mais la performance est meilleure.
compile permet la création d’un objet représentant l’expression régulière sous forme
compilée. Un fois l’objet créé, les fonctions sont appelées sur cet objet et non par
rapport au module. La méthode group() sur l’objet SRE_Match donne accès au i-ème
motif (dans le cas d’une expression composée de plusieurs motifs5 comme ici) trouvé
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 d’accéder aux fonctions des systèmes d’exploitation et de faire de la
programmation système ou de l’administration. Les fonctions sont disponibles sur (presque)
tous les système. Toutefois, il faut toujours être conscient des limites pour la portabilité
du code : la notion de droits sur un fichier n’est pas similaire sur tous les systèmes.
Les principaux sous modules deos sont :
– path manipulation de chemins,
– glob fnmatch pattern matching de fichiers et répertoires,
– time accès et manipulation de l’heure,
– getpass manipulation de mots de passe et identifiants. utilisateur
2.2.4.1 Quelques constantes

name donne le nom de l’implementation du module os : posix, nt, dos, mac, java,
etc.
environ Dictionnaire contenant les variables d’environnement (au sens Unix mais aussi
relatives au lancement de l’interpréteur Python).
5
Un motif au sein d’une expression régulière est défini par des parenthèses.
c
> > > 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 ’}
2.2.5 Le module os.path

Ce module fournit quelques primitives (courantes sous Unix) de manipulation des noms
de fichiers et des fichiers.
basename dirname permettent respectivement d’extraire d’un chemin le nom du fichier
ou le nom du répertoire (ou de l’arborescence dans le cas d’un chemin composé).
> > > os . path . basename ( ’/ tmp / foo . txt ’)
’ foo . txt ’
> > > os . path . dirname ( ’/ tmp / foo . txt ’)
’/ tmp ’
> > > os . path . dirname ( ’/ tmp / foo . txt ’)
’/ tmp ’
split join permettent respectivement de découper et de construire un chemin. L’utili-

sation de la fonction join est fortement recommandée pour construire des chemin
car elle respecte implicitement le bon séparateur de chemin pour le système courant.
> > > os . path . split ( ’/ tmp / foo . txt ’)
( ’/ tmp ’ , ’ foo . txt ’)
> > > os . path . join ( ’/ tmp ’ , ’ foo . txt ’)
’/ tmp / foo . txt ’
exists isdir isfile permettent de tester l’existance et le type d’un fichier (ou répertoire).
> > > 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 même nom.
glob est l’équivalent du ls Unix. Cette fonction retourne une liste des fichiers d’un
répertoire avec utilisation de jockers.
c
> > > glob . glob ( ’ *. py ’)

[ ’ hello . py ’ , ’ examples . py ’]
> > > glob . glob ( ’/ tmp /*. tmp ’)
[ ’/ tmp / sv3e2 . tmp ’ , ’/ tmp / sv001 . tmp ’ , ’/ tmp / sv3e4 . tmp ’]
fnmatch et filter permettent de faire du pattern matching sur des chaı̂nes de caractères
représentant des noms de fichiers : respectivement est ce qu’un nom suit un pattern
de nommage et quels sont les éléments d’une liste respectant un pattern.
> > > 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 système le nom de l’utilisateur connecté et de
demander de manière «cachée» un mot de passe.
getuser() demande au système le nom de login de l’usager
> > > getpass . getuser ()
’ rafi ’
getpass() demande proprement (en masquant les caractères saisis) un mot de passe à
l’usager. L’appel à cette fonction est bloquant jusqu’à ce que l’usager ait tapé entrée.
> > > p = getpass . getpass () # bloquant jusqu ’ au ’\ n ’
Password :
> > > print p
’ q u e lma u v ai s m o t d e p a s s e ’
2.3 Built-in en Python

Les built-in sont les fonctionnalités cablées en dur dans l’interpréteur Python, et dans
un certain sens l’interpréteur lui-même. Ces fonctionnalités ne sont pas écrite en Python
car elles sont plus que largement utilisées et leur mise en œuvre en C contribue à obtenir
de meilleures performances.
2.3.1 Les fichiers

2.3.1.1 Les objets fichiers
Les fichiers sont représentés comme des objets de type file. Ils peuvent être textuels
ou binaires et être utilisés en lecture ou en écriture.
c
2.3 Built-in en Python 37
open ouvre un fichier (crée l’objet associé) en lecture par défaut.

> > > foo = open ( ’/ tmp / foo . txt ’)
> > > foo
< open file ’/ tmp / foo . txt ’ , mode ’r ’ at 0 x81a3fd8 >
close ferme un fichier (mais ne détruit pas l’objet associé).

> > > foo . close ()
> > > foo
< closed file ’/ tmp / foo . txt ’ , mode ’r ’ at 0 x81a3fd8 >
2.3.1.2 Lecture dans un fichier

Il y a plusieurs manières de lire un fichier.
readline () permet de lire une ligne (position courante jusqu’au prochain \n) à la fois
dans le fichier.
> > > foo = open ( ’/ tmp / foo . txt ’ , ’r ’)
> > > print foo . readline ()
’ hello world !\ n ’
readlines () permet de lire toutes les lignes d’un fichier en une seule fois (retourne une
séquence de chaı̂nes).
> > > foo . readlines ()
[ ’ bonjour le monde !\ n ’ , ’ au revoir le monde !\ n ’]
read ([n]) permet de lire tout le fichier à partir de la position courante, ou au maximum
n octets lorque un argument est donné. Cette fonction retourne une chaı̂ne. La fonc-
tion seek permet de se déplacer dans le fichier de façon absolue : ici nous retournons
au début (indice 0).
> > > foo . seek (0) ; foo . read ()
’ hello world !\ nbonjour le monde !\ nau revoir le monde !\ n ’
Comparaison des approches de lecture Il n’y a pas de solution idéale pour la lecture
des fichiers. Il faut choisir en fonction de la situation et des besoins.
– La lecture globale (readlines) d’un fichier est plus performante pour l’aspect récupération
des informations car elle représente un gros accès disque puis un parcours de séquence
en mémoire. Toutefois, cette approche est coûteuse en mémoire vive : imaginez la
présence d’un fichier texte de 500Mo en mémoire.
– Lecture ligne par ligne (readline) est plus coûteuse pour lire un fichier car elle
représente de nombreux accès disques pour des petites quantités d’information. Tou-
tefois, cette approche permet de manipuler des gros fichiers : un fichier de 10Go peut
être lu ligne par ligne sur une machine ayant 64Mo de mémoire.
c
2.3.1.3 Ecriture dans un fichier

Il faut qu’un fichier soit ouvert en écriture pour pouvor écrire dedans, on le précise donc
à l’ouverture en donnant un second paramètre ’w’ (les modes d’ouverture du langage C,
pour les fichiers binaires il faut préciser ’b’ en plus). Tant que le fichier n’est pas fermé,
son contenu n’est pas garanti sur le disque.
write permet d’écrire des données (une chaı̂ne de texte) représentant une ouplusieurs
lignes de texte (utilisation de ‘\n’).
> > > foo = open ( ’/ tmp / foo . txt ’ , ’w ’)
> > > foo . write ( ’ hello world !\ n ’)
writelines permet d’écrire des données contenues dans une séquence (de chaı̂nes). Si
chaque chaı̂ne contenue dans la séquence représente une ligne de texte dans le fichier,
il faut alors qu’elles contiennent la séquence de fin de ligne ‘\n’.
> > > lines = [ ’ bonjour le monde !\ n ’ , ’ au revoir le monde !\ n ’]
> > > foo . writelines ( lines )
2.3.2 Conversions de type

Utilisation du nom des types pour convertir les chaı̂nes, en entiers, flottants, etc. (et
réciproquement.) La fonction str permet de convertir tout objet en chaı̂ne.
> > > str (123)
’ 123 ’
> > > int ( ’ 123 ’)
123
> > > float ( ’ 123 ’)
123.0
> > > float (123)
123.0
> > > long ( ’ 123 ’)
123 L
Mais Attention aux arrondis

> > > float ( ’ 12.3 ’)
12 .3 00 0000 00000 00 1
2.3.3 Evaluation dynamique

Python permet d’exécuter des commandes à la volée : une chaı̂ne de caractères représentant
une commande est executée. La chaı̂ne peut être compilée explicitement ou non avant son
évaluation.
c
2.4 Exercices 39
compile () retourne une version compilée de l’expression (ou du fichier) passé en pa-
ramètre. Le second argument précise où doit se faire la sortie d’erreur au cas où une
exception serait levée. Le dernier argument précise quel usage est envisagé, ici nous
prévoyons de l’utiliser avec la fonction eval()
> > > obj = compile ( ’x + 1 ’ , ’ < string > ’ , ’ eval ’)
> > > obj
< code object ? at 0 x81685d8 , file " < string > " , line -1 >
eval () évalue une expression (compilée ou non) passé en paramètre.

>>> 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́e, soit le programme est arrêté. (Dans la pratique, une exception est levée.)
assert évalue une expression logique et arrête le programme en affichant un message
d’erreur (qui est optionnel et fourni séparé par une virgule) si l’expression logique est
fausse (cf section 1.3.2). L’expression peut inclure des appels de fonctions.
> > > assert 1
> > > assert 0 , ’ oups ’
AssertionError : oups
> > > try : assert 0
... except AssertionError : print ’ sic ’
...
sic
2.4 Exercices
2.4.1 Utilitaire de sauvegarde
En s’aidant de la fonction os.stat qui permet de connaı̂tres la dates de modification
des fichiers, écrire un utilitaire de backup d’une arborescence. Cet utilitaire doit faire un
backup incrémental (sauf la première fois) des fichiers modifiés.
> > > print os . stat . __doc__
stat ( path ) - > ( st_mode , st_ino , st_dev , st_nlink ,
c
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 données

Cet exercice propose d’utiliser des fonctions du module regular exressions pour extraires
des données d’un fichier texte. Ecrire un programme analysant un fichier texte de type mbox
et qui produit la liste de toutes les personnes ayant envoyé un e-mail, en triant la liste de
leurs adresses par ordre alphabétique avec la date de l’e-mail reçu le plus récent.
c
Chapitre 3
Plongeon dans les objets
3.1 Des objets, que des objets

3.1.1 Rappels des principes de base de POO
Instanciation Un objet est créé à partir d’un moule, sa classe qui définit une structure (les
attributs) et un comportement (les méthodes). Une classe définit un type d’objets.
Un objet est instance d’une unique classse.
Encapsulation Les données sont «cachées» au sein des objets, et leur accès est contrôlé
par les méthodes. L’état d’un objet ne devrait pas être manipulé directement. L’objet
peut être vu comme un fournisseur de services (et non de données).
Polymorphisme Des objets respectant une même interface (la signature de méthodes
suffit dans le cas de Python) peuvent être manipulés de manière générique, même si
leur type exact est différent. Ce principe permet aussi la substitution d’une instance
par une autre (tant que les interfaces sont compatibles).
Héritage Mécanisme qui permet la réutilisation de définitions de base, comportements par
défaut, et la spécialisation de certains comportements. La relation entre d’héritage
entre deux classes ne se limite pas à une facilité de capitalisation de code. La classe
qui hérite doit «être un» de la classe dont elle hérite : un chat «est un» animal, chat
peut donc être une sous classe de animal.
3.1.2 Objets et références

En Python, le monde est uniforme.
– Tout est objet : les chaı̂nes, les entiers, les listes, les classes, les modules, etc. Tout
est réifié et manipulable dynamiquement.
– Tout est manipulé par référence : une variable contient une référence vers un objet
et un objet peut être référencé par plusieurs variables.
– Une fonction, une classe, un module sont des espaces de nommage organisés de
manière hiérarchique : un module contient des classes qui contiennent des fonctions.
41
42 Plongeon dans les objets
3.1.3 Classes
3.1.3.1 Définition et instanciation
La définition d’une classe suit la règle des blocs (cf section 1.3.1) en utilisant le mot clé
class. Toute méthode est définie comme une fonction avec un premier argument (self)
qui représente l’objet sur lequel elle sera appliquée à l’exécution. En Java ou C++, le this
est définie implicitement, en Python il est explicite est c’est toujours le premier paramètre
d’une méthode. Le nom est libre, mais on utilise en général self. Une méthode ne prenant
pas de paramètres aura donc quand même un argument.
> > > class Dummy :
... def hello ( self ):
... print ’ hello world ! ’
L’instanciation se fait sans mot clé particulier (il n’y a pas de new en Python). Il suffit
de faire suivre un nom de classe de parenthèses (cnotenant ou non des paramètres) pour
déclancher une instanciation. L’invocation se fait à l’aide de la notation pointée, un appel
de méthode sur une variable référençant un objet.
> > > d = Dummy ()
>>> d
< __main__ . Dummy instance at 0 x817b124 >
> > > d . hello ()
hello world !
3.1.3.2 Définition d’attributs et du constructeur
Les attributs sont définis à leur première affectation. Une variable est considérée comme
un attribut si elle est «rattachée» à l’objet : elle est accédée par self. Tout accès à un
attribut ou à une méthode de l’objet se fait obligatoirement par la variable self. Le
constructeur est une «méthode» nommée __init__. Comme toute méthode, certain de
ses paramètres peuvent avoir des valeurs par défaut (un seul constructeur en Python).
> > > class Compteur :
... def __init__ ( self , v = 0):
... self . val = v
... def value ( self ):
... return self . val
En termes de génie logiciel (et de bon sens), il est recommandé de toujours initiali-
ser l’état des objets (ses attributs) lors de son l’instanciation, donc dans le constructeur.
D’autre part, un constructeur qui ne fait rien n’est pas stupide ! Il dit clairement ce qu’il
en est : l’absence de constructeur ne serait pas un oubli.
c
3.1 Des objets, que des objets 43
3.1.4 Héritage
Python supporte l’héritage simple et l’héritage multiple. Dans une relation d’héritage,
il est faut préciser le nom de la classe mère (entre parenthèses après le nom de la classe en
cours de définition) et appeler explicitement le constructeur de la super classe.
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 l’héritage multiple, il suffit de préciser les différentes classes mères et
d’appeler leurs constructeurs respectifs.
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
L’exemple suivant donne une utilisation des trois classes précédentes. Il n’y a rien de
particulier, à l’utilisation que la classe ait été définie entièrement ou par héritage ne change
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
c
Héritage multiple problématique L’héritage multiple pose problème lorsque deux

classes héritées offre une méthode portant le même nom. Dans ce cas, il est possible de
préfixer les méthodes par le nom de la classe qui les définies ou d’utiliser des alias de
méthodes pour résoudre les conflits.
class X :
def name ( self ):
return ’I am an X ’
class Y :
def name ( self ):
return ’I am an Y ’
class Z ( X , Y ):
xname = X . name
yname = Y . name
def name ( self ):
return ’I am an Z , ie ’ + self . xname () + \
’ and ’ + self . yname ()
L’exemple suivant propose une utilisation des trois classes X, Y, Z précédentes avec une
invocation de la méthode name () sur les trois instances créées.
> > > for clss in [ X , Y , Z ]:
... obj = clss ()
... print obj . name ()
...
I am an X
I am an Y
I am an Z , ie I am an X and I am an Y
3.1.5 Introspection simple

La fonction dir () donne le contenu de tout objet (liste de ses attributs et méthodes).
Associée à l’attribut __doc__, cela fournit une documentation de base sur tout objet. D’où
l’intérêt de bien auto-documenter le code (voir section 1.3.5).
> > > dir ( Compteur )
[ ’ __doc__ ’ , ’ __init__ ’ , ’ __module__ ’ , ’ value ’]
> > > c = Compteur ()
> > > dir ( c )
[ ’ __doc__ ’ , ’ __init__ ’ , ’ __module__ ’ , ’ val ’ , ’ value ’]
La fonction type () donne le type d’une référence.
> > > type ( c )
< type ’ instance ’ >
> > > type ([1 , 2])
< type ’ list ’ >
c
3.1.6 Classes et attributs

Une classe ne contient que des attributs. Elle peut être vue comme un simple diction-
naire contenant des associations nom / référence. Une fonction de la classe (ou méthode)
est en fait un attribut qui est exécutable (callable).
> > > 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 d’un conflit de nom entre un attribut et une méthode, la priorité va à
l’attribut. Ici, l’interpréteur explique que l’on ne peut utiliser l’attribut name comme si
c’était une fonction (ou méthode) car c’est une chaı̂ne, donc on ne peut demander son
exécution (object is not callable).
> > > class Conflict :
... def __init__ ( self ):
... self . name = ’ Conflict ’
... def name ( self ):
... return ’ You will never get this string ! ’
...
> > > c = Conflict ()
> > > c . name ()
TypeError : ’ str ’ object is not callable
Une convention est de préfixer par ‘_’ les constituants d’une classe que l’on souhaite
ne pas être considérés comme publiques. De par le principe d’encapsulation, les attributs
devraient toujours être protégés. Il est vrai que dans le cas de Python la notion de «protegé»
repose sur la confiance, mais si vous roulez à 180 Km/h en ville qui est responsable, la
voiture ou vous ?
> > > class NoConflict :
... self . _name = ’ NoConflict ’
... def name ( self ):
... return self . _name
...
> > > c = NoConflict ()
> > > print c . name ()
c
NoConflict
Il est possible de définir dynamiquement des attributs sur une classe ou une instance.
Ce genre de facilité ne se limite pas à l’aspect ludique, c’est parfois la meilleure solution à
un problème. Toutefois, attention où l’on met les pieds lorsque l’on modifie dynamiquement
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 l’objet, de la fonction, du module, etc.
__module__ contient le nom du module contenant la définition de la classe, de l’objet, de
la fonction, du module, etc.
__name__ contient le nom de la fonction ou de la méthode.
__file__ contient le nom du fichier contenant le code du module.
3.1.7 Un peu de réflexion

Les techniques de réflexion permettent de découvrir (instrospection) et de manipuler
dynamiquement et automatiquement les attributs (et fonctions) d’un objet. Ces techniques
sont utilisables, par exemple, pour le chargement de code dynamique comme la mise en
œuvre d’un mécanisme de plug-ins. Elles sont aussi courament utilisés dans les environne-
ments de développement qui font de la complétion automatique (il faut bien aller chercher
l’information quelque part). Il existe trois fonctions de base en Python :
– hasattr () test si un attribut existe,
– getattr () donne accès à la valeur d’un attribut,
– setattr () fixe la valeur d’un attribut (avec création si l’attribut est inexistant).
Dans l’exemple suivant, nous manipulons l’instance étendue de la classe Empty : après
avoir testé son existance, nous récupérons dynamiquement la méthode nommée funct pour
en demander ensuite l’exécution. Enfin, nous définissons un nouvel attribut name dont la
valeur est fixée à myempty.
c
> > > hasattr ( e , ’ funct ’)

1
> > > f = getattr ( e , ’ funct ’)
>>> f
< function funct at 0 x81b7334 >
>>> f (e)
2
> > > setattr ( e , ’ name ’ , ’ myempty ’)
> > > e . name
’ myempty ’
3.1.8 Un peu plus de réflexion avec inspect

Le module inspect offre des moyens supplémentaires pour l’introspection, par exemple
découvrir ce que contient une classe, un objet ou un module. L’exemple suivant récupère
les membres de la classe E puis les membres d’une instance de cette classe. Pour chaque
membre de l’objet (classe ou instance), un tuple est fourni contenant le nom de l’attribut et
sa valeur. Nous pouvons constater que la différence se limite à l’état de la fonction f : non
liée dans le cas de la classe, donc que l’on ne peut exécuter directement, et liée à l’instance
dans le cas de l’objet que l’on peut donc exécuter directement après un getattr.
> > > 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 l’on est en train de manipuler : quel est le
type d’un objet (classe, instance, attribut). La fonction ismethod() permet de savoir si
un objet donné est, ou non, une méthode (liée ou non).
>>> inspect . isclass ( E )
1
>>> f = getattr ( e , ’f ’)
>>> inspect . isfunction ( f )
0
>>> inspect . ismethod ( f )
1
>>> F = getattr ( E , ’f ’)
c
> > > inspect . ismethod ( F )

1
L’association de l’introspection de base et du module inspect permet d’automatiser
l’utilisation des méthodes d’une instance : invocation générique d’une méthode récupérée
dynamiquement après contrôle que c’est bien une méthode. L’exemple suivant montre aussi
les deux manières d’invoquer une méthode, et la signification du self : a.foo() est en fait
traduit en A.foo(a) par l’interpréteur (considérant que a est une instance de la classe A).
> > > 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 même d’accéder dynamiquement au code source d’un objet.
Toutefois, cela n’est pas valable pour le code saisi en interactif (ce qui est somme toute
normale vu qu’il n’est pas stocké dans un fichier).
> > > from examples import Conflict
getfile () donne le nom du fichier de définition de l’objet (TypeError si cette opération

est impossible).
> > > inspect . getfile ( Conflict )
’ examples . py ’
getmodule () donne le nom du module définissant l’objet (sans garantie par exemple
dans le cas du code dynamiquement créé).
> > > inspect . getmodule ( Conflict )
< module ’ examples ’ from ’ examples . py ’ >
getdoc () retourne la documentation de l’objet.

> > > inspect . getdoc ( Conflict )
’ Illustration de conflit attribut / methode ’
getcomments () retrourne la ligne de commentaire précédant la définition de l’objet.

getsourcelines () donne un tuple contenant la liste des lignes de code source définissant
l’objet passé en paramètre et la ligne du début de la définition dans le fichier.
> > > lines , num = inspect . getsourcelines ( Conflict )
> > > for l in lines : print num , l , ; num += 1
...
c
3.2 Les exceptions en python 49
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 à la précédente, mais retourne uniquement le code de la

définition sous la sorme d’une chaı̂ne de caractères.
3.1.9 Classes vs modules

Il semblerait que la vision suivante doit bien acceptée de la communauté de développeurs
Python1 :
– Utiliser des classes lorsque
– Les données représentent un état et doivent être protégées.
– Les traitements et données sont fortement liés (les données évoluent).
– Utiliser des modules de fonctions lorsque
– Les traitements et données sont «indépendants» (ex : data mining).
– Les données sont stockées dans des BD ou fichiers, et non modifiées.
3.2 Les exceptions en python

3.2.1 Définition et lancement
Les exceptions sont des objets commes les autres, donc définies par des classes comme
les autres (ou presque). Elles sont simplement un penchant pour ne rien faire (les classes
d’exception contiennent rarement des traitements). La définition minimale d’une classe
pour une exception revient à étendre la classe de base Exception.
> > > class MonErreur ( Exception ):
... pass
...
La mot-clé raise permet de lever une exception (définie par l’usager ou standard). Si
l’on souhaite associé de l’information à une exception, il suffit de faire suivre le type de
l’exception d’un message (séparé par une virgule). 2
> > > raise MonErreur
1
Personnellement tout est défini comme des classes, no comment. . .
2
Les exceptions sont levées comme des objets. Une classe est définie par un objet dans l’interpréteur.
Donc la définition de la classe peut être levée comme une exception. Ce qui n’est pas si choquant pour les
cas simple (exception avec message d’erreur).
c
__main__ . MonErreur
> > > raise MonErreur ()
__main__ . MonErreur
> > > raise NameError , ’ cela coince ’
NameError : cela coince
Une exception peut aussi contenir des attributs et méthodes (en général pour fournir de
l’information). Ici, la méthode standard __str__ (traduction de l’objet en chaı̂ne) et utilisée
pour accéder facilement à la valeur contenue dans l’exception (par défaut le mécanisme
d’exception appelle cette méthode). Pour fournir de l’information à une exception, il suffit
de l’instancier en passant des paramètres au constructeur lors de l’utilisation de raise.
> > > class MonErreurToo ( Exception ):
... def __init__ ( self , val = None ):
... self . _value = val
... def __str__ ( self ):
... return str ( self . _value )
...
> > > raise MonErreurToo (12)
__main__ . MonErreurToo : 12
3.2.2 Traitement des exceptions

Il y a deux approches pour le traitement des exceptions en Python dont le choix dépend
des besoins :
– quoi faire en cas de problème,
– que faut il toujours faire même s’il y a un problème.
3.2.2.1 try ... except

Gestion des problèmes, le try ... except permet en cas de levée d’exception, de
pouvoir tenter de traiter le problème. La clause else est optionnelle est permet de faire
un traitement si tout s’est bien passé. Il peut y avoir plusieurs clauses except pour traiter
différents cas exceptionnels.
try :
< instructions >
( except < exception >:
< instructions traitement exception >)+
[ else :
c
3.2 Les exceptions en python 51
< instruction si édroulement correct >]

L’identification d’une <exception> peut prendre plusieurs formes :
– ExceptionType est utile lorsque seul le type de l’exception est important, par exemple
parce qu’elle ne contient pas d’information ;
– ExceptionType, variable permet de récupérer l’exception du type spécifié dans
variable et donc d’epxloiter les données et traitements de l’exception ;
– (ExceptionType1, ExceptionType2, ...) permet de prendre en compte un en-
semble d’exception car le traitement de cas particulier est mutualisable.
Exemple 1 Lecture d’un fichier texte : on ne lit le fichier que si l’ouverture s’est bien
passée. On utilise la clause else pour le code qui ne doit être fait que si aucune
exception n’est levée. Cela permet d’isoler l’appel qui pose potentiellement problème
dans le bloc try (et non de mettre tout le code dans ce bloc sans savoir ensuite qui
a vraiment posé problème).
> > > 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 : l’affichage va dépendre de l’exception qui
est levée (elle même levée de manière aléatoire). Une chaı̂ne étant un objet, elle peut
être utilisée comme exception. Cette manière de faire est toutefois à proscrire.
> > > 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.2.2.2 try ... finally

Quoi qu’il arrive, le try ... finally permet de faire un traitement même si une
exception a été levée. Le bloc finally est évalué avant un return contenu dans le bloc
c
try et ce qu’il y ait ou non eu une exception de levé. Attention : Un return dans le
finally masque un return dans le try.
try :
< instructions >
finally :
< traitements ésystmatiques >
Attention : Dans ce cas, on ne sait pas ce qui s’est mal passé. Il n’y a pas moyen de
faire de gestion d’erreur dans le finally qui «laisse filer» les exceptions.
> > > try :
... raise K eyboar dInterrupt
... finally :
... print ’ ki C ki A ta P < ctrl -C > ? ’
...
ki C ki A ta P < ctrl -C > ?
Keybo ardInt errupt
Il n’est pas possible de composer les deux formes dans un seul bloc, l’utilisation im-
briquée des deux formes est donc parfois nécessaire.
3.2.3 Traitement d’exceptions et héritage

Petit problème courant, attention à l’ordonnacement des except ! Il faut toujours, dans
le cas où les exceptions sont définies par une relation d’héritage, commencer par traiter
les exceptions les plus spécifiques. Dans le cas contraire, la gestion des exceptions les plus
générales masque les traitements relatifs aux exceptions les plus spécifiques qui ne sont
jamais utilisés.
class A ( Exception ): pass
class B ( A ): pass
> > > for x in [ A , B ]:

... try : raise x
... except B : print ’B ’ ,
... except A : print ’A ’ ,
A B
> > > for x in [ A , B ]:
... try : raise x
... except A : print ’A ’ ,
... except B : print ’B ’ ,
A A
c
3.3 Exercices 53
3.3 Exercices
3.3.1 Premières classes
– Implanter des classes Pile et File utilisant les liste comme structure de données
interne et respectant l’interface suivante (utiliser l’héritage).
class Base :
def pop ( self ):
pass
def push ( self , elt ):
pass
– Reprendre l’exercice 2.4.2 en implantant les fonctionnalités au sein d’une classe.
3.3.2 Design pattern état

– L’état d’un objet a de type A est implanté par plusieurs classes. L’instance de ces
classes qui représente l’état de l’objet varie au cours du cycle de vie de l’objet. Les
méthodes de l’objet sont déléguées à l’instance représentant l’état à un moment
donné.
– Implanter ce design pattern pour représenter un feu tricolore (une classe d’état par
couleur, une méthode pour changer la couleur du feu et une méthode qui donne le
droit de passage).
c
c
Chapitre 4
Python et XML
4.1 XML, avec une vision DOM

4.1.1 Langages de balises
– Au commencement était SGML
– Standard Generalized Markup Language
– Simplifié à outrance avec HTML pour le Web
– Transformé en produit marketing avec XML
– 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 à une partie du package standard xml. Ce package fournit plusieurs
sous-packages :
– dom contient minidom, une implémentation de DOM en Python,
– sax est un dictionnaire des implémentation disponibles,
– parsers contient les parsers tilisés en interne par DOM et SAX.
En compléments, plusieurs librairies et extensions sont diponibles. Elles fournissent,
par exemple, des abstractions de plus haut niveau et des outils typés par rapport à une
utilisation donnée.
4.1.3 DOM, petit rappel

Pour ce qui est de la manipulation d’un fichier XML, nous allons uniquement utili-
ser DOM (Document Object Model). DOM propose de manipuler un document XML en
55
56 Python et XML
mémoire comme un arbre d’objets représentant les noeuds du document. Les interfaces
standard DOM sont les suivantes.
Interface Représentation de
Node Interface de base des noeuds
NodeList Séquence de noeuds
Document Représente un document complet
Element Elément de la hiérarchie
Attr Noeud représentant un attribut d’un noeud
Comment Noeud repréntant un commentaire
Text Noeud de données textuelles
4.1.4 Exemple du chapitre

Le listing suivant présente un exemple de document XML utilisé dans la suite du
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
4.2 Naviguer dans un arbre DOM 57
4.2 Naviguer dans un arbre DOM

4.2.1 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 fichier (ou de chaı̂ne) XML. Il est disponible en
standard dans l’environnement (librairie PyXML).
4.2.2 Parser un document XML

La fonction minidom.parse permet d’analyser un fichier XML et d’obtenir 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 d’opérations et d’attributs disponibles sur tous les éléments d’un
arbre DOM pour en permettre son parcours.
hasChildNodes () indique si un noeud a des fils.
> > > doc . hasChildNodes ()
1
childNodes donne accès aux fils d’un noeud (sous la forme d’une liste).
> > > doc . childNodes
[ < DOM Element : contacts at 137763676 >]
> > > doc . childNodes [0] . hasChildNodes
1
documentElement fournit le noeud racine d’un document DOM.

> > > root = doc . documentElement
firstChild, lastChild donnent accès respectivement au premier et au dernier fils d’un

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
58 Python et XML
> > > root . firstChild

< DOM Text node " \ n " >
> > > root . lastChild
nextSibling, previousSibling donnent respectivement accès au fils suivant et au fils

précédent (ou None si plus de fils). Le calcul se fait par rapport à une racine commune.
> > > current = root . firstChild
> > > while current :
... print current ,
... current = current . nextSibling
...
< DOM Text node "
" > < DOM Element : contact at 137757692 > < DOM Text node "
">
parentNode donne accès au parent (direct) d’un noeud.

> > > root
< DOM Element : contacts at 137763676 >
> > > root . firstChild . parentNode
< DOM Element : contacts at 137763676 >
isSameNode () permet de tester si deux noeuds sont égaux (égalité au sens de l’indentité,
parle-t-on de la même personne).
> > > 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 fontion getElementsByTagName (), disponible sur les noeuds de type Document et
Element, donne tous les fils (et sousn -fils) portant le nom de tag fourni.
> > > root . g etE l e men t s B y T a g N a m e ( ’ contact ’)
[ < DOM Element : contact at 137757692 > ,
< DOM Element : contact at 137437676 > ,
< DOM Element : contact at 136723316 >]
> > > root . g etE l e men t s B y T a g N a m e ( ’ programming ’)
[ < DOM Element : programming at 137788492 > ,
c
4.3 Accéder aux informations d’un noeud 59
< DOM Element : programming at 137755692 > ,

< DOM Element : programming at 137602140 >]
4.2.5 NodeList et objets séquences

Le résultat retourné par les fonctions childNodes et getElementsByTagName est de
type NodeList et se comporte comme une séquence «classique».
Pour se comporter comme une séquence, un objet doit offrir (au minimum) les
méthodes suivantes :
– __len__() et __getitem__(i) pour l’accès aux éléments (boucle for),
– __setitem__(i) et __delitem__(i) pour les séquences modifiables.
4.3 Accéder aux informations d’un noeud

4.3.1 Informations liées au noeud
nodeType donne une constante (1-10) représentant le type du noeud :
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 nœud (tag de la balise). Attention, le comportement est

variable selon les noeuds : pour un élément ce sera le nom de la balise XML, pour
un noeud représentant du texte, ce sera #text
> > > root . nodeName
u ’ contacts ’
> > > root . firstChild . nodeName
’# text ’
nodeValue donne la valeur du nœud (contenu). Attention, le comportement est variable

selon les noeuds : pour un élément ce sera None pour un noeuds contenant de l’in-
formation ce sera cette information. Pour les noeuds contenant du texte, il est aussi
possible d’utiliser l’attribut data.
> > > root . nodeValue
> > > root . firstChild . nodeValue
u ’\ n ’
c
60 Python et XML
> > > root . firstChild . data

u ’\ n ’
4.3.2 Informations liées aux attributs d’un noeud

hasAttributes () teste la présence d’attributs dans un noeud.
> > > root . hasAttributes ()
0
> > > root . childNodes [1] . hasAttributes ()
1
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 d’un attribut comme une chaı̂ne.

> > > c = root . childNodes [1]
> > > print c . getAttribute ( ’ name ’)
doe
getAttributeNode () retourne la valeur d’un 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 méthode item() permet

d’accéder aux couples nom d’attribut / valeur textuelle d’attribut, la méthode keys()
donne accès aux noms des attributs et la méthode values() donne accès à la liste des
objets Attr représentant les attributs.
> > > 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 méthodes classiques sur les dictionnaires, il existe deux méthodes pour
manipuler les NamedNodeMap :
c
4.4 Construire un document XML 61
– length donne la longeur de la map d’attributs,

– item (i) donne le i-eme élément (de type Attr) de la map ou None.
> > > 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
4.4 Construire un document XML

4.4.1 Créer un arbre DOM
La création d’un document (de son arbre DOM) se fait par instanciation de la classe
Document (c’est un objet comme un autre). Cette classe fournit des méthodes pour fabri-
quer les noeuds. A la création, un document ne contient rien, pas même de noeud racine.
> > > newdoc = minidom . Document ()
> > > newdoc
< xml . dom . minidom . Document instance at 0 x827fe7c >
> > > newdoc . documentElement
>>>
4.4.2 Créer des noeuds DOM

Les méthodes de création de noeud n’incluent pas l’ajout de l’élément créé dans l’arbre.
Ici, nous allons créer un document excessivement simple :
– une racine root avec un attribut name,
– un commentaire,
– un noeud de texte contenu dans un noeud sometext.
createElement (tag) crée un nouvel élément (de type Element) avec le nom de tag
passé en paramètre et le retourne.
> > > newroot = newdoc . createElement ( ’ root ’)
createAttribute (name) crée un noeud de type Attr avec le nom name. Une fois le
noeud créé, la valeur peut être fixée avec l’attribut nodeValue.
> > > rootattr = newdoc . createAttribute ( ’ name ’)
> > > rootattr . nodeValue = ’ foo ’
createTextNode (data) crée un noeud de donnée contenant le text passé en paramètre

(à inclure dans un noeud englobant, ici le noeud sometext créé pour).
c
62 Python et XML
> > > textnode = newdoc . createElement ( ’ sometext ’)

> > > text = newdoc . createTextNode ( ’ this node \ ncontains text ’)
createComment (text) crée un noeud de commentaires contenant le text passé en pa-

ramètre.
> > > comment = newdoc . createComment ( ’a very usefull comment ’)
4.4.3 Ajout de noeuds dans un arbre

Les méthodes d’ajout dans un arbre viennent en complément des méthodes de création.
Leur dissociation est dûe aux multiples usages que l’on peut faire d’un noeud. Il est possible
de construire un document XML partir d’un document existant, dans ce cas on ne va pas
recréer tout les noeuds, mais peut être simplement les réorganiser.
appendChild (new) ajoute un élément à la fin de la liste des fils d’un noeud.
> > > newdoc . appendChild ( newroot )
< DOM Element : root at 137797476 >
> > > textnode . appendChild ( text )
< DOM Text node " this node
c ... " >
insertBefore (new, old) ajoute un élément avant un fils donné d’un noeud.
> > > newroot . insertBefore ( comment , textnode )
< DOM Comment node " a very use ... " >
replaceChild (new, old) remplace un élément fils d’un noeud par un autre élément.
setAttribute (name, value) crée un nouvel attribut sur un noeud sans passer par une
instance de type Attr.
> > > newroot . setAttribute ( ’ usefull ’ , ’ nop ’)
setAttributeNode (new) ajoute un noeud attribut au noeud considéré.

> > > newroot . setAttributeNode ( rootattr )
4.4.4 Supprimer des noeuds d’un arbre DOM

Il est aussi possible de supprimer des noeuds dans un arbre DOM, par exemple pour en
créer une nouvelle version plus épurée ou pour une restructuration d’un document XML.
removeChild (old) supprime un fils d’un noeud à utiliser conjointement avec unlink().1
1
retrouver pourquoi
c
4.5 Exercices 63
> > > try :

... old = root . removeChild ( root . firstChild )
... old . unlink ()
... except ValueError : print ’ failed ’
...
removeAttribute (name) supprime un attribut d’un noeud par son nom.

< DOM Element : contact at 137757692 >
> > > root . firstChild . removeAttribute ( ’ firstname ’)
removeAttributeNode (old) supprime un attribut d’un noeud par la référence de l’objet

Attr le représentant ou lève l’exception NotFoundErr.
4.4.5 Sérialiser un document XML

L’objectif de faire un document XML est d’obtenir un fichier. Les fonctions toxml
(), toprettyxml () donnent la version texte d’un arbre DOM (une ligne ou multi-ligne
indentées). Elles sont disponibles sur tous les noeuds et l’évluation est automatiquement
récursive. Pour sérialiser un document, il suffit d’appeler une de ces méthodes sur l’ob-
jet document. Si l’appel est fait sur un noeud, alors le fichier 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 fichier etudiants.xml contient 400 dossiers d’étudiants (générés aléatoirements)
avec la structure décrite ci-dessous. Le but de l’exercice est de produire trois listes sous
forme de fichiers XML contenant (par ordre décroissant pour les deux premières) les
étudiants admissibles, sur liste complémentaire ou refusés.
<? xml version = " 1.0 " ? >
< etudiants >
< etudiant nom = " doe " prenom = " john " dossier = " 0 " >
< origine universite = " mit " / >
< formation discipline = " informatique " niveau = " 4 " / >
< resultats moyenne = " 16 " / >
</ etudiant >
c
64 Python et XML
</ etudiants >

Pour les trois listes, les informations conservées sont le nom, prénom, l’université d’ori-
gine et les résultats. Les règles de selection sont les suivantes.
– pour être admis, un(e) étudiant(e) doit avoir un niveau Bac+4, dans une formation
en informatique, avec une moyenne supérieure à 12 ;
– si sa discipline n’est pas informatique (mais toujours avec les critères de niveau et de
moyenne), il(elle) est sur liste complémentaire ;
– sinon il(elle) est refusé(e).
Il faut pour cela parser le fichier etudiants.xml, naviguer dans l’arbre DOM ainsi
produit et construire trois arbres DOM qui seront en fin de traitement sérialisés dans les
fichiers admissibles.xml, complementaires.xml et refuses.xml. La structure de ces
trois fichiers est décrite ci-dessous.
<? 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
Chapitre 5
Python et la persistance de données
5.1 Fichiers DBM

5.1.1 Description et utilisation
Le module anydbm offre une solution pour des besoins simples de persistance en utili-
sant des fichiers plats. Il propose une solution standard indépendante de l’implémentation.
Un fichier DBM s’utilise comme un dictionnaire, donc relativement simplement, seul l’ini-
tialisation est différente (ouverture du fichier). Les données sont manipulées comme des
chaı̂nes et accessibles à l’aide de clés.
open (name, ’c’) ouvre le fichier nommé name (’c’ signifie «en le créant s’il n’exsite
pas»).
> > > import anydbm
> > > file = anydbm . open ( ’ blabla ’ , ’c ’)
close () ferme le fichier (requis ou non selon les implémentations, pour être sûr que les
données sont sauvées il vaut mieux utiliser explicitement close).
> > > file . close ()
La lecture et l’écriture se fait comme dans un dictionnaire, mais les clés sont obligatoi-
rement des chaı̂nes. L’exemple suivant crée deux entrées (foo et bar) dans le fichier
DBM, les re-lit et ferme le fichier.
> > > file [ ’ foo ’ ] = ’ perrier c foo ’
> > > file [ ’ bar ’ ] = ’ cd bar ; more beer ’
> > > print file [ ’ foo ’]
perrier c foo
> > > print file [ ’ bar ’]
cd bar ; more beer
65
66 Python et la persistance de données
has key () test la présence d’une clé.

> > > file . has_key ( ’ foo ’)
1
keys () donne la liste des clés du fichier. Obtenir les clé est un pré-requis à tout parcours
d’un fichier 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 d’entrées d’un fichier. footnote

> > > len ( file )
2
del permet de supprimer une entrée (ce qui suit le fonctionnememnt standard d’un disc-
tionnaire).
[ ’ foo ’ , ’ bar ’]
> > > del file [ ’ foo ’]
[ ’ bar ’]
> > > len ( file )
1
5.1.2 Limitations
Les fichiers DBM permettent uniquement de rendre persistant des chaı̂nes de caractères.
La conversion objet vers chaı̂ne (et réciproquement) doit être gérée manuellement, ce qui
rend leur utilisation rapidement complexe pour des objets composites.
5.2 Pickle et Shelve

5.2.1 Object pickling
Le module pickle (standard en Python) permet la sérialisation des objets mémoire en
chaı̂nes (et réciproquement). Il est utile pour la persistance et le transferts de données sur
un réseau.
> > > import pickle
c
5.2 Pickle et Shelve 67
La manipulation des données utilise un fichier par action de sérialisation, où les données
sont stockées sous forme de chaı̂nes. Il n’y a pas de structuration des données (donc pas
de recherche rapide).
5.2.2 (Dé)Sérialisation et fichiers

La classe Pickler est un sérialiseur vers un fichier et la fonction dump () réalise la
sérialisation d’un objet (il existe aussi une fonction équivalente dans le module). L’exemple
suivant sérialise un dictionnaire dans le fichier foo.saved.
>>> 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 ) # (1 ,2)
> > > output . close ()
La classe Unpickler est un dé-sérialiseur depuis un fichier et la fonction load ()
réalise la dé-sérialisation d’un objet (il existe aussi une fonction équivalente dans le mo-
dule). L’exemple suivant recharge depuis le fichier foo.saved le dictionnaire sérialisé dans
l’exemple précédent.
> > > input = open ( ’ foo . saved ’ , ’r ’)
> > > p = pickle . Unpickler ( input ) # (1)
> > > foo2 = p . load () # (2)
> > > input . close ()
> > > foo2
{ ’a ’ : ’ aaa ’ , ’b ’ : ’ bbb ’ , ’c ’ : ’ ccc ’}
ou bien
> > > input = open ( ’ foo . saved ’ , ’r ’)
> > > foo2 = pickle . load ( input ) # (1 ,2)
> > > input . close ()
5.2.3 (Dé)Sérialisation et chaı̂nes

dumps () sérialise un objet vers une chaı̂ne (et non plus vers un fichier). Cette opération
est pratique pour échanger des messages sur un réseau par exemple.
> > > 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
loads () dé-sérialise une chaı̂ne vers un objet.

> > > foo3 = pickle . loads ( data )
> > > foo3
{ ’a ’ : ’ aaa ’ , ’c ’ : ’ ccc ’ , ’b ’ : ’ bbb ’}
5.2.4 DBM + Pickle = Shelves

Le module shelves exploite les deux modules précédents (en offrant l’interface du
second) :
– pickle pour sérialiser les objets (éventuellement complexes),
– anydbm pour la gestion des clés et des fichiers.
L’exemple suivant crée un fichier base dans lequel nous stockons un dictionnaire associé
à la clé foo. Puis, nous réouvrons ce fichier pour récupérer, dans ce dictionnaire, l’entrée
associée à la clé a.
> > > 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 à jour n’est pas supportée avec shelve, une possibilité est
d’utiliser fcntl.
– La définition des classes doit être importable au moment du chargement dse données
par pickle.
– La compatibilité des fichiers n’est pas garantie entre deux implémentations de DBM.
Il n’y a donc que portabilité du code, pas des données.
5.3 Python et SQL

5.3.1 Exemple avec Postgres
Python inclut un module d’accès aux bases de données offrant une interface standardisée
(de facto). Des mises en oeuvre existent pour les différentes bases de données courantes.
Toutefois, l’utilisation de chaque base peut varier, donc le code Python d’accès à une base
n’est pas 100% portable 1 .
1
Il est donc recommandé dans une application de définir une couche d’abstraction de la base.
c
5.3 Python et SQL 69
L’utilisation d’une base de données est ici illustré avec une base Postgres2 . Le module
psycopg fournit l’accès à une base Postgres depuis Python. Il permet de trouver le bon
compromis entre la puissance du langage et de la base de données : réaliser une partie des
traitements sur les données en SQL et une partie en Python.
Création d’une base personnelle sur la machine locale.

– création de la base sur le filesystem (une fois),
– lancement du serveur (à chaque démarrage de la machine),
– création de la base (et d’utilisateurs si nécessaire),
– administrateur = user au sens Unix, sans mot de passe.
$ initdb - D < repertoire >
$ pg_ctl - D < repertoire > start [ - o " -i " # pour le érseau ]
$ createdb test
5.3.2 Opérations de base

L’opération connect () retourne un objet représentant la connexion à une base de
données. Les arguments sont variables selon les bases ou les contextes (par exemple,
host n’est pas obligatoire si la base est locale).
> > > import psycopg
> > > connexion = psycopg . connect (
... " host = localhost dbname = test user = rafi " )
Des curseurs sont utilisés pour les interactions avec la base : émission de requêtes SQL.
Ils sont créés par l’objet connexion. Un curseur offre la méthode execute qui permet
de demander à la base l’évaluation d’une requête SQL. Le curseur est ici utilisé pour
créer une table test1 ayant un seul champ val de type entier. Ensuite, le curseur
est utilisé pour faire 10 insertions dans cette table.
> > > curseur = connexion . cursor ()
> > > curseur . execute (
... " CREATE TABLE test1 ( val int4 ) " )
> > > for i in range (10):
... curseur . execute (
... " INSERT INTO test1 VALUES (% d ) " , (i ,))
Exemples d’insertions. Une insertion peut se faire en utilisant un tuple (comme dans
l’exemple précédent) ou un dictionnaire pour fournir les valeurs. Dans le cas de l’uti-
lisation des tuples, les données sont prises dans l’ordre du tuple qui doit être de
même longueur que le tuple de format de la requête (argument de la clause VALUES).
L’exemple suivant crée une nouvelle table et utilise un dictionnaire pour fournir les
2
La même chose avec MySQL diffère peu, par exemple sur la connexion et la gestion des commits, à
ajouter.
c
valeurs à insérer. La méthode executemany permet d’insérer une séquence de données

dans une table sans avoir à faire une boucle en Python.
>>> 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 requêtes (réponses à une command select) sont des structures de données
Python : listes (ensemble des réponses) de tuples (les données d’une réponse). Les
opération fetchone() et fetchall() offertes par le curseur permettent de récupérer
respectivement une valeur (en fait les valeurs une par une) ou toutes les valeurs3 .
L’exemple suivant exécute une requête sur la base et récupère d’abord la première
réponse, en affichant le premier champs, puis toutes les réponses restantes, en affi-
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 d’une connexion (c’est implicite lorsque

l’objet connexion est détruit au sens Python).
commit () valide une transaction avec la base (offert par un objet connexion).
rollback () annule une transaction avec la base (offert par un objet connexion).
autocommit (1|0) active ou désactive l’autocommit des opérations (offert par l’objet
connexion).
5.3.3 Gestion de dates

Le module mx (associé à psycopg) fournit des classes, principalement DateTime, pour
la gestion des dates et timestamps.
3
Attention sur les select retournant beaucoup de réponses, le fetchall() a une borne supérieure.
c
5.4 Exercices 71
> > > 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)
5.3.4 Gestion de données binaires

L’utilisation de données binaires (images ou sons par exemple) doit être déclaré expli-
citement à l’insertion avec la classe Binary. L’exemple suivant crée une table pour
stocker des photos avec leur nom, puis insère une photo.
>>> 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 récupération des données binaire est similaire aux données classiques. L’exemple sui-
vant récupère la photo qui est stockée dans la base et la sauvegarde dans un fichier
nommé new_shoes.jpg.
>>> curseur . execute ( ’ SELECT * FROM test3 ’)
>>> val = curseur . fetchone ()
>>> open ( ’ new_ ’ + val [1] , ’ wb ’ ) . write ( val [2])
5.4 Exercices
5.4.1 Module «Modèle» du MVC
Ecrire un script Python qui crée une table représentant des étudiants avec les champs
suivants (le type des données est précisé entre parenthèses) : num dossier (int4), nom
(text), prénom (text), université (text), discipline (text), niveau (int4), moyenne(int4).
Ecrire un programme Python chargeant l’ensemble des données du fichier etudiants.xml
dans cette table. Pour cela, une partie du code de l’exercice précédent est réutilisable pour
le parcours de l’arbre DOM.
5.4.2 Module «Contrôleur» du MVC

Développer trois classes offrant une méthode eval () réalisant les traitements suivants
sur la base de données :
c
– obtenir la liste des numéros de dossiers, nom et prénom des étudiants,

– obtenir la fiche complète d’un étudiant par rapport à son numéro de dossier,
– insérer une fiche d’étudiant en fournissant toutes les informations.
Développer une classe Controleur qui est une composition des trois classes précédentes
et qui fournit des méthodes pour accéder aux instances lors de l’exécution (pour permettre
les interactions comme décrite dans l’exemple suivant).
ctrl = Controleur (...)
list_all_ctrl = ctrl . get_l ist_al l_ctrl ()
student_list = list_all_ctrl . eval ()
c
Chapitre 6
Python et les interfaces graphiques
6.1 Python et Tkinter

6.1.1 Tkinter
Le module Tkinter [3] est basé sur Tk, la librairie développée par J. Ousterout pour
faire des interfaces graphiques en Tcl[10], et disponible sur plusieurs plates-formes (dont
X11, MS-Windows, Macintosh). Tkinter est le standard de facto pour Python offrant une
vision objet de Tk. Toutefois, Tcl est un langage où tout est chaı̂nes de caractères. Il en
résulte qu’un certain nombre de valeur utilisées dans le cas de Tkinter sont des chaı̂nes de
caractères (utilisées directement comme tel ou bien sous couvert de variables offertes par
le module).
Comme tout programme avec une interface graphique, l’exécution est dirigée par les
événements. Les interactions entre Python et l’interface graphique peut prendre plusieurs
formes :
– Traitement GUI Python → Tkinter → Tk → Librairie graphique.
– Evènement graphique → Tk → Tkinter → Traitements Python.
6.1.2 Premier pas

Le «hello world !» version graphique tient en quatre lignes, présentées dans l’exemple
suivant. Le module Tkinter est chargé. Un widget (ici un Label) est créé puis ajouté à
l’environnement graphique (pack). Enfin, la boucle d’événements est démarrée. Elle est
active tant que la fenêtre n’est pas fermée (et le prompt de l’interpréteur reste suspendu).
>>> import Tkinter
>>> widget = Tkinter . Label ( None , text = ’ hello world ! ’)
>>> widget . pack ()
>>> widget . mainloop ()
73
74 Python et les interfaces graphiques
6.1.3 Configuration de widgets

Dans le cas du Label de «hello world !», il n’y a pas de widget parent (premier argument
None). Il est attaché directement à la fenêtre par défaut. Le texte du Label représente sa
configuration. La configuration peut être réalisée ou changée après la création avec la
méthode config () des widgets. L’exemple suivant est identique en terme de résultat à
l’exemple précédent.
>>> widget = Tkinter . Label ( None )
>>> widget . config ( text = ’ hello world ! ’)
6.1.4 Composition de widgets avec pack

Les composition des widgets est délégué au gestionnaire de géométrie.
– Le placement du widget se fait par rapport à son contenant (avec l’option de confi-
guration side) en utilisant un placement cardinal (Tkinter.TOP, Tkinter.LEFT,
Tkinter.RIGHT, Tkinter.BOTTOM). Par défaut, un widget est attaché en haut, ou
au-dessous des widgets existants
– Si l’on souhaite une occupation maximale de l’espace, utiliser l’option de configuration
expand=YES. La direction de l’occupation maximale est précisée par fill. Elle peut
être en largeur (Tkinter.X), en hauteur (Tkinter.Y) ou les deux (Tkinter.BOTH).
6.1.5 Lancer des commandes

Pour initier un traitement depuis une interface graphique, la méthode courante est de
définir un bouton, un menu, une scrollbar, etc. et d’y associer un traitement (fonction
ou méthode sans argument). L’exemple suivant crée un bouton et y associe la commande
sys.exit pour quitter l’exécution du programme (dans le cas courant l’interpréteur com-
plet). L’option text précise le texte qui apparaı̂t sur le bouton.
>>> import sys
>>> widget = Tkinter . Button ( None )
>>> widget . config ( text = ’ press to quit ’ , command = sys . exit )
c
6.1 Python et Tkinter 75
6.1.6 Composition et redimensionnement

Relations entre la composition et le redimensonnement :
– par défaut le widget conserve sa taille initiale,
– pour suivre les changements utiliser expand.
L’exemple suivant configure le bouton de telle sorte qu’il occupe toujours tout l’espace
en largeur lors du redimensionnement de la fenêtre. Par contre, le bouton n’occupe pas
tout l’espace en hauteur.
>>> import Tkinter
>>> import sys
>>> widget . config ( text = ’ press to quit ’ , command = sys . exit )
>>> widget . pack ( expand = Tkinter . YES , fill = Tkinter . X )
6.1.7 Boutons et traitements

Un bouton ne peut déclancher qu’un traitement, il est donc souvent nécessaire d’utiliser
une fonction qui regroupe les traitements. Dans l’exemple suivant, la fonction handler
affiche «hello world» sur la sortie standard avant de quitter l’application.
>>> import Tkinter
>>> import sys
>>> def handler ():
... sys . exit ()
...
>>> widget . config ( text = ’ press to quit ’ , command = handler )
>>> widget . pack ( expand = Tkinter . YES , fill = Tkinter . X )
Une classe d’utilisation d’un widget graphique est une bonne manière de créer une
relation forte entre widget, traitements et données. Cet ensemble (bouton, données, traite-
ments) est facilement réutilisable. L’exemple présente un exemple de bouton pour quitter
une application où le message est paramétrable.
> > > import Tkinter
> > > import sys
> > > class HelloQuitButton :
c
... 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 être défini comme un objet : définition d’une classe représentant une
fonction et instanciation pour l’utilisation. L’exemple suivant redéfinit le handler précédent
comme une classe.
>>> import Tkinter
>>> import sys
>>> class Callable :
... self . msg = ’ hello world ! ’
... def __call__ ( self ):
... print self . msg
... import sys
... sys . exit ()
...
>>> widget . config ( text = ’ hello ’ , command = Callable ())
>>> Tkinter . mainloop ()
6.1.8 Définition de bindings

La fonction bind permet d’associer une fonction (à 1 argument) à un événement et
à un widget. Les événements les plus courants sont les clics souris et la saisie au clavier.
L’exemple suivant crée deux fonctions pour afficher «hello world !» et pour afficher «bye»
sur la sortie standard avant de quitter le programme. Ensuite, il crée un label et y associe
la fonction hello au clic gauche et la fonction quit au double clic.
>>> import Tkinter
>>> import sys
>>> def hello ( event ):
...
>>> def quit ( event ):
... print ’ bye ’
c
... 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 ()
L’événement «reçu» par un handler contient des informations qui peuvent être in-
terprétées dans le cadre du traitement. L’exemple suivant définit deux fonctions dont le
but est d’afficher un caractère tapé au clavier et d’afficher les coordonnées de la souris.
La classe Tk représente la fenêtre principale du programme. Le label créé est associé à
cette fenêtre (premier paramètre du constructeur). Puis, les deux fonctions sont associées
au clavier et au clic sur le label. L’utilisation de focus selectionne le label pour recevoir
les événements clavier. Enfin, la boucle d’événements est démarré sur la fenêtre princi-
pale. Lorsque la fenêtre est acitive et que l’on tape une touche au clavier, cela génère un
événement passé à la fonction onKey qui va en extraire le caractère associé. (Même principe
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
Quelques noms de bindings courants
c
<KeyPress> Pression sur une touche

<KeyPress-a> Pression sur la touche ‘A’ (minuscule)
<KeyPress-A> Pression sur la touche ‘A’ (majuscule)
<Return> Pression sur entrée
<Escape> Touche d’échappement
<Up> <Down> Pression sur les flèches
<Button-1> Click souris gauche
<Button-2> Click souris milieu (ou les deux)
<Button-3> Click souris droit
<ButtonRelease> Fin de click gauche
<Motion> Mouvement de la souris
<B1-Motion> Mouvement de la souris avec click gauche
<Enter> <Leave> Entrée et sortie souris d’un widget
<Configure> Redimensionnement de la fenêtre
<Map> <Unmap> Ouverture et iconification de la fenêtre
6.1.9 Assemblage de widgets

L’assemblage de widgets se fait par utilisation de containers graphiques, pincipalement
en définissant des Frames auxquels sont rattachés les widgets. L’exemple suivant utilise
une Frame pour regrouper deux boutons. La commande associée au second bouton permet
la fermeture de la fenêtre sans arrêter l’interpréteur.
>>> import Tkinter

>>> def hello ():
...
>>> 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
6.1.10 Widgets orientés objet

L’approche objet s’applique bien aux interfaces graphiques en utilisant l’héritage pour
définir de nouveaux widgets par spécialisation ou extension. L’exemple suivant présente une
spécialisation du widget Button en bouton pour quitter l’application (en fait le bouton ne
détruit que lui).
> > > 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 l’aspect

La spécification de la taille et de la couleur est valable pour tous les widgets de Tkinter.
La spécification des polices, tailles et styles de charactères est valable pour tout widget
contenant du texte. L’exemple suivant définit un label écrit en jaune sur fond bleu avec la
police Courier 20 gras dans une surface totale de 3 lignes sur 20 caractères.
>>> 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 )
6.1.12 Application multi-fenêtre

Il est possible de définir dans une même applications des fenêtres indépendantes (non
contenues visuellement dans la même fenêtre). L’exemple suivant définit deux fenêtres
c
indépendantes contenant les labels «hello» et «world».

>>> win1 = Tkinter . Toplevel ( root )
>>> Tkinter . Label ( win1 , text = ’ hello ’ ) . pack ()
>>> Tkinter . Label ( win2 , text = ’ world ’ ) . pack ()
Terminaison d’une application multi-fenêtres :
– destroy () supprime récursivement la fenêtre concernée,
– quit () termine la boucle d’événements sans détruire la fenêtre.
>>> b1 = Tkinter . Button ( win1 )
>>> b1 . config ( text = ’ moi ’ , command = win1 . destroy )
>>> b1 . pack ()
>>> 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 considérons que le contenu module Tkinter est importé
dans l’espace courant. Bien qu’étant plutôt un défenseur de l’utilisation des modules avec
leur préfixe, il est vrai que, en mode interactif, cela a ses avantages de tout importer dans
le scope global. Mais faites toujours attention aux risques de conflits de nom !
> > > from Tkinter import *
6.2.1 Entry : Entrées de texte

Le widget Entry offre un champ de saisie de texte sur une seule ligne. Il dépend des
options de configuration suivantes :
– state=’disable’ lecture seule,
– show=’*’ saisie masquée.
L’exemple suivant construit une petit interface avec une zone de saisie et deux boutons.
La touche entrée est associée dans la boite de saisie à la fonction fetch(). Le premier
bouton affiche sur la sortie standard le contenu de la zone de saisie. Pour cela, il utilise
aussi la commande fetch(). Le second bouton ferme l’interface.
> > > def fetch ():
... print ’ Texte : <% s > ’ % ent . get ()
...
c
6.2 Petit tour des widgets courants 81
>>> 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 )
Manipulations de texte
– index dans une entrée de texte : De ’0’ à END,
– position d’insertion du curseur INSERT,
– get (deb, fin) retourne le texte à la position donnée,
– insert (pos, txt) insert le texte txt à la position pos,
– 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 d’agencement de plusieurs widgets Label
et Entry. Afin d’avoir un formulaire bien aligné, l’utilisation du gestionnaire cardinal (au
travers de pack) est remplacé par l’utilisation du gestionnaire «grille». La méthode grid
(row=X, column=Y) permet l’alignement des différents éléments dans une grille. L’exemple
suivant construit un formulaire à trois entrées.
> > > 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
Attention Les deux gestionnaires (cardinal et grille) ne se marient pas toujours bien.
6.2.3 Zone de texte

Le widget Text offre une zone de saisie et de manipulation de texte sous la forme
d’une chaı̂ne de caractères multi-lignes. L’exemple suivant définit une zone de texte et
un bouton. L’utilisation de ce dernier affiche le contenu de la zone de texte sur la sortie
standard à l’aide de la fonction fetch(). L’option wrap=WORD de la zone de texte précise
que le découpage de son contenu se fait sur les mots (lorsqu’un mot ne tient pas sur la
ligne, la zone de texte passe automatiquement à la ligne).
>>> 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 texte ’)
>>> txt . pack ( side = TOP )
>>> Button ( root , text = ’ fetch ’ , command = fetch ) . pack ()
Manipulation de texte
– index dans une zone de texte : de ’1.0’ (ligne.colonne) à END,
– INSERT donne la position d’insertion du curseur,
– SEL FIRST, SEL LAST contient les position de début et fin de la sélection,
– get (deb, fin) retourne le texte à la position donnée,
– get (’1.0’, END+’-1c’) retourne tout le texte contenu dans la zone.
– insert (’li.co’, txt) ajoute le texte à la position ’li.co’,
– delete (deb [,fin]) supprime le texte entre les position deb et fin,
c
– search (chaine, deb, fin) retourne la position de début de la chaı̂ne dans la zone
de texte,
– see (’li.co’) Fait défiler l’affichage pour rendre la position donnée visible,
– pour les déplacements relatifs dans une zone de texte par rapport à une position :
+/- un certain nombre de ’c’ (caractère), ’w’ (mot) ou ’l’ (ligne).
6.2.4 Listboxes
Le widget Listbox permet de gérer des listes d’éléments et offre des méthodes pour
l’ajout, le retrait et la selection d’éléments. L’exemple suivant définit une listbox contenant
10 entrée et un bouton. L’utilisation du bouton déclanche la fonction fetch() qui affiche
sur la sortie standard l’entrée de la liste sélectionnée (ou la première ligne par défaut).
>>> 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
...
Manipulation de listes
– index dans une liste : de ’0’ à END.
– curselection () retourne l’index selectionné,
– get (idx) retourne l’élément à l’index idx,
– get (ACTIVE) Retourne l’élément sélectionné,
– insert (idx, element) ajoute l’élément à l’index idx,
– delete (deb [,fin]) supprime les éléments entre les index deb et fin (le second est
optionnel).
6.2.5 Barres de défilement

Le widget scrollbar permet de gérer le défilement (horizontal ou vertical) des zones de
texte et des listboxes. Il utilise des méthodes de défilement fournies par ces deux widgets.
L’exemple suivant reprend le précédent en y ajoutant une barre de défilement pour gérer
une liste de 100 éléments. Dans un premier temps, il crée une frame pour regrouper la
liste et la barre. Ces deux dernières sont configurées pour que la liste évolue en fonction de
l’utilisation de la barre.
c
>>> 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
...
6.2.6 Boı̂tes à cocher et boutons radio

Les deux widgets suivants permettent de gérer des collections de données :
– checkbutton permet un choix multiple (boı̂tes à cocher),
– radiobutton permet un choix unique (boutons radio).
Les options de ces deux widgets sont :
– command pour associer une action,
– variable pour fixer et récupérer la valeur.
La variable doit être déclarée comme une variable Tkinter. Cela permet une interac-
tion entre Tk et Python initiée par Tk (principe du callback) : IntVar et StringVar
permettent de créer des objets de stockage de valeurs entières ou de chaı̂nes.
Boı̂te à cocher L’exemple suivant crée un ensemble de trois boı̂tes à cocher dont la
valeur va être représentée par un entier. Chaque boı̂te est indépendante, et c’est le fait
c
de mémoriser les trois variables Tkinter dans une liste qui les relie. La fonction state()
déclanchée par le bouton affiche l’état des différentes boı̂tes.
>>> vars = []
>>> 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 )
Boutons radio L’exemple suivant crée un ensemble de trois boutons radio dont la valeur
va être représentée par une chaı̂ne. Les trois boutons sont indépendant et c’est le fait
d’utiliser la même variable Tkinter qui les relie. La fonction state() déclanchée par le
bouton affiche le nom du bouton radio actuellement sélectionné.
>>> 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 ()
c
6.3 Autres widgets prêt à l’emploi

6.3.1 Boı̂tes de dialogue
Le module tkMessageBox offre un certain nombre de boı̂tes de dialogue standard pour
l’affichage de messages (avec une icône associée). Ces boı̂tes prennent le contrôle de la
boucle d’événements (tant qu’elle ne sont par fermées). Les trois boı̂tes de base sont :
– showinfo pour donner de l’information,
– 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 l’usager, les widgets askyesno et askokcancel
permettent d’avoir une réponse booléenne à une question : 1 si ’yes’ et 0 si ’no’.
> > > root = Tk ()
> > > if askyesno ( ’ Question ’ , " Python c ’ est simple " ):
... showinfo ( ’ xxx ’ , ’ Merci !!! ’)
... else :
... showwarning ( ’ xxx ’ , ’ Dommage ... ’)
...
c
6.3 Autres widgets prêt à l’emploi 87
Pour des interactions basiques complémentaires avec l’usager, askfloat, askinteger

et askstring permettent de demander des réponses typées.
> > > 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ı̂tes de dialogue pour les interactions relatives
aux fichiers. Les différentes widgets offerts respectent les normes de l’interface graphique
(X11, Mac OS X ou MS-Windows) :
– askopenfilename, asksaveasfilename et askdirectory retournent le nom du fi-
chier selectionné ou une chaı̂ne vide,
– askopenfile et asksaveasfile retournent l’objet représentant le fichier en mode
’r’ (lecture), ’w’ (écriture) , ou None,
– filetypes, initialdir et initialfile sont des variables destinés configurer la
recherche de fichiers.
> > > from tkFileDialog import *
> > > askopenfilename ( filetypes =[( ’ Text ’ , ’. txt ’ )])
’/ home / rafi / enseign / python / bar . txt ’
> > > as ksave asfilename ( initialdir = ’/ tmp ’)
’/ tmp / foo . txt ’
6.3.2 Barre de menus

La définition de menus dans une fenêtre se fait à l’aide d’une Frame dédiée. Le widget
Menubutton permet de définir un élément de la barre et le widget Menu permet de définir
les commandes associées à l’élément. L’exemple suivant crée une frame pour servire de
barre de boutons puis un élément de cette barre pour les commandes relatives aux fichiers.
Ensuite, une entrée est ajouté dans ce premier menu offrant la fonction «Quit».
>>> 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
c
L’organisation des menus dans la barre se fait à l’aide des variables et fonctions sui-
vantes :
– bd, relief nombre de points et relief du menu (RAISED, SUNKEN, RIDGE),
– add_separator () ajoute une séparation entre deux commandes d’un menu,
– add_cascade () création d’un sous-menu,
– entryconfig (num, state=...) fixe l’aspect disponible (ENABLED, valeur par défaut)
ou non disponible (DISABLED) d’une entrée d’un menu.
L’exemple suivant définit un sous menu «Stuff» à notre menu «File».
>>> 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 offre des widgets de plus
haut niveau (plus de 40) comme ComboBox, NoteBook, DirTree, FileSelectBox, etc.
http://tix.sourceforge.net
wxPython offre l’accès à la librairie wxWindow http://www.wxpython.org
PyQt offre l’accès au toolkit Qt (Opie pour Ipaq).
PyKDE offre l’accès aux librairies KDE.
PyGTK offre l’accès aux widgets GTK.
6.5 Exercices
6.5.1 Module «Vue» du MVC
Développer une interface graphique en utilisant Tkinter, reposant sur les traitements
du contrôleur défini dans le chapitre précédent et composées des éléments suivants :
c
6.5 Exercices 89
– une Listbox associée à une Scrollbar donne la liste des numéros de dossier, nom
et prénom des étudiants ;
– un formulaire (ensemble de Label et Entry) donnant les information d’un étudiant
sélectionné dans la Listbox (par exemple avec un double clic) ;
– un formulaire de saisie associé à un Button pour entrer de nouvelles fiches d’étudiants.
c
c
Remerciements
Merci à
– Thérèse Libourel pour m’avoir demandé de monter une formation d’une semaine à
Python et aux participants pour l’avoir suivie (base de la version 1.0.0).
– Fabien Devaux pour ses remarques sur le module re et sur la spécification de l’enco-
dage d’un fichier (prises en compte dans la version 1.0.1).
91
c
Annexe A
GNU Free Documentation License
Version 1.2, November 2002
c
Copyright °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 effective freedom to
copy and redistribute it, with or without modifying it, either commercially or noncommer-
cially. Secondarily, this License preserves for the author and publisher a way to get credit
for their work, while not being considered responsible for modifications 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 provi-
ding 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 Definitions

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
93
94 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 ”Modified Version” of the Document means any work containing the Document
or a portion of it, either copied verbatim, or with modifications and/or translated into
another language.
A ”Secondary Section” is a named appendix or a front-matter section of the Do-
cument that deals exclusively with the relationship of the publishers or authors of the
Document to the Document’s 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 fit the above definition 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 specification 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 file format
whose markup, or absence of markup, has been arranged to thwart or discourage subsequent
modification 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 mar-
kup, 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 mo-
dification. 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 work’s title, preceding the beginning
c
A.2 Verbatim Copying 95
of the body of the text.

A section ”Entitled XYZ” means a named subunit of the Document whose title ei-
ther is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in
another language. (Here XYZ stands for a specific section name mentioned below, such as
”Acknowledgements”, ”Dedications”, ”Endorsements”, or ”History”.) To ”Pre-
serve the Title” of such a section when you modify the Document means that it remains
a section ”Entitled XYZ” according to this definition.
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 effect 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 Document’s 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 fit legibly, you should put
the first ones listed (as many as fit 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
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 Modifications
You may copy and distribute a Modified Version of the Document under the conditions
of sections 2 and 3 above, provided that you release the Modified Version under precisely
this License, with the Modified Version filling the role of the Document, thus licensing
distribution and modification of the Modified Version to whoever possesses a copy of it. In
addition, you must do these things in the Modified 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 modifications in the Modified Version, together with at least five
of the principal authors of the Document (all of its principal authors, if it has fewer
than five), unless they release you from this requirement.
C. State on the Title page the name of the publisher of the Modified Version, as the
publisher.
D. Preserve all the copyright notices of the Document.
E. Add an appropriate copyright notice for your modifications adjacent to the other
copyright notices.
F. Include, immediately after the copyright notices, a license notice giving the public
permission to use the Modified 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 Document’s 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 Modified 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 Modified Version as stated in the
c
A.5 Combining Documents 97
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 Modified Version.
N. Do not retitle any existing section to be Entitled ”Endorsements” or to conflict in
title with any Invariant Section.
O. Preserve any Warranty Disclaimers.
If the Modified 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 Modified Version’s 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 Modified Version by various parties–for example, statements of peer
review or that the text has been approved by an organization as the authoritative definition
of a standard.
You may add a passage of up to five 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 Modified
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 Modified
Version.
A.5 Combining Documents

You may combine the Document with other documents released under this License,
under the terms defined in section 4 above for modified versions, provided that you include
c
in the combination all of the Invariant Sections of all of the original documents, unmodified,
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 different 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 docu-
ments 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 compilation’s 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 Document’s 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
A.8 Translation 99
A.8 Translation
Translation is considered a kind of modification, 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 ”His-
tory”, 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 differ 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
specifies 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 specified
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
c
Copyright °YEAR YOUR NAME. Permission is granted to copy, distribute
and/or modify this document under the terms of the GNU Free Documenta-
tion License, Version 1.2 or any later version published by the Free Software
Foundation ; with no Invariant Sections, no Front-Cover Texts, and no Back-
Cover 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 relea-
sing 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
Bibliographie
[1] Agile Alliance. Agile Alliance Web site. http://www.agilealliance.org/.

[2] A.M. Kuchling. Regular Expressions HOWTO Release 0.03, 2003.
http://www.python.org/doc/howto/.
[3] F. Lundh. An introduction to Tkinter. ?, 1999.
[4] O’Reilly. 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-13-
616830-2.
101
102 BIBLIOGRAPHIE
c

Tutorial Python PDF

Transféré par

Droits d'auteur :

Formats disponibles

Tutorial Python PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Tutorial Python PDF

Transféré par

Droits d'auteur :

Formats disponibles

Initiation à Python par l’exemple

Copyright (c) 2003-2005, Raphael MARVIE <raphael.marvie@lifl.fr>

2 Quelques modules et built-in 27

3 Plongeon dans les objets 41

4.2.4 Recherche dans un arbre DOM . . . . . . . . . . . . . . . . . . . . 58

5 Python et la persistance de données 65

6 Python et les interfaces graphiques 73

6.1.10 Widgets orientés objet . . . . . . . . . . . . . . . . . . . . . . . . . 79

A GNU Free Documentation License 93

Python, à quoi bon ?

Quelques caractéristiques intéressantes

– programmation orienté objet

Python ou pas Python ?

1.1 Utilisation de Python

# ! / usr / bin / env python

1.2 Structures de base

1.2.2 Typage en Python

1.2.4 Chaı̂nes de caractères

> > > x [3:] > > > x [1: -1]

1.2.6 Listes et chaı̂nes de caractères

> > > foo [1]

Remarque Critères de choix entre une liste et un tuple :

> > > [ " % s =% s " % ( x , y ) for x , y in bar . items ()]

1.3.3.1 Boucles for

... print elt

1.3.3.2 Boucles while

> > > fib (100)

La définition de la documentation se fait sur la première ligne après la déclaration en

Cette fonction est vraiment du pipeau ,

1.4 Autres éléments sur les séquences

1.4.2 Boucles for problématiques

Quelques modules et built-in

2.1 Définition et utilisation de modules

def fib (n):

def welcome (name, greeting=’Hello’, mark=’!’):

Utilisation d’un module La construction import permet d’importer un module et de

Utilisation mixte Un fichier peut à la fois définir un module et un programme. Cette

Remarques Lors de l’utilisation de la construction import, l’interpréteur recherche la

2.2 Quelques modules standards et utiles

2.2.1 Le module sys

platform Nom du système d’exploitation.

Quelques fonctions offertes par le module sys :

2.2.2 Le module string

2.2.2.1 Quelques constantes

2.2.2.2 Les fonctions principales

> > > string . strip ( ’ hello world ! \ n ’ ) # [2 nd arg ]

2.2.3.1 Opérations de recherche

2.2.3.2 Opérations de manipulation

2.2.3.3 Utilisation d’expressions compilées

2.2.4.1 Quelques constantes

> > > os . environ

2.2.5 Le module os.path

split join permettent respectivement de découper et de construire un chemin. L’utili-

2.2.6 Les modules glob et fnmatch

> > > glob . glob ( ’ *. py ’)

2.2.7 Le module getpass

2.3 Built-in en Python

2.3.1 Les fichiers

open ouvre un fichier (crée l’objet associé) en lecture par défaut.