Initiation Via Python Ellipse Mai 2010 PDF

Langages Informatiques
Programmation
avec le langage Python
Un outil commode au service de lingnieur
Xavier Dupr
Avant-propos
Quelques annes passes initier les lves linformatique avec diffrents langages
me poussent dire que le langage Python est sans doute un langage qui sapprend
plus vite sans pour autant tre limit. Les ordinateurs ont progress et il nest plus
souvent ncessaire dutiliser des langages tels que le C certes plus rapide et plus
connu mais aussi plus difficile matriser. A partir de 2004, le langage Python a
t utilis lENSAE 1 pour initier les lves la programmation et, depuis cette
date, jai pu observer un regain dintrt des lves pour cette matire qui sappuyait
auparavant sur le langage C. Certains tudiants avouent mme stre amuss ; leur
projet de programmation nest plus centr sur un langage mais sur les rsultats quil
permet dobtenir.
Le langage Python suffit pour la plupart des besoins dun ingnieur et permet de
raliser beaucoup plus rapidement des programmes informatiques qui fonctionnent
sur les principaux systmes dexploitation. Internet fournit galement un panel trs
large de librairies pour faire du calcul scientifique, des jeux ou encore des sites
Internet. Il suffit parfois de quelques minutes pour tlcharger une extension et sen
servir. Malgr ces avantages, il existe peu de livres de langue franaise sur ce langage,
beaucoup moins que ceux crits en langue anglaise dont quelques uns seulement sont
traduits.
Ce livre naborde pas des sujets comme la programmation web ou lutilisation
conjointe des langages Python et SQL. La description du langage couvre les be-
soins qui sont ceux dun ingnieur, cest--dire une personne dont la programma-
tion ne constitue pas lessentiel de son travail. Chaque notion est illustre par des
exemples 2 . Ceux-ci sont particulirement prsents lors de lintroduction de notions
pas toujours videntes comprendre comme les threads, les interfaces graphiques et
lutilisation de C++. Le livre se ferme sur plusieurs chapitres ne contenant que des
exercices et leurs corrections. Ces exercices sont de deux types : des travaux dirigs
et des problmes courts. Ces derniers ont t poss lors des examens lENSAE et
ont t conus pour prparer les lves rpondre aux questions techniques lors des
entretiens dembauche.
Le langage Python volue assez vite, il est de plus en plus utilis ce qui explique la
multitude dinformations quon peut trouver sur Internet. Le site officiel 3 recense
la plupart des extensions (plus dune centaine) accessibles gratuitement. Il existe
galement de nombreux sites daide comme WikiPython 4 qui recense des exemples
de programmes sur des sujets varis. Langlais est la langue dchange par excellence
1. Ecole Nationale de la Statistique et de lAdministration Economique, http://www.ensae.fr/
2. Lensemble de ces exemples est accessible depuis le site http://www.xavierdupre.fr.
3. http://www.python.org/
4. http://wikipython.flibuste.net/
dans le monde informatique et le langage Python ny chappe pas mme si les
moteurs de recherches retournent presque toujours des rsultats en franais pour
des requtes concernant Python, condition toutefois dy insrer un mot de syntaxe
exclusivement franaise.
Il nest pas utile de lire tous les chapitres pour savoir programmer. Le chapitre 1
dcrit linstallation du langage Python et son utilisation via des diteurs de texte.
Les chapitres 2 et 3 introduisent les premiers concepts, partir de l, il est dj
possible dcrire des programmes consquents et notamment de lire les chapitres 11
12 pour sexercer.
Les chapitres 4 et 5 sintressent la programmation objet, qui nest pas indispen-
sable dans un premier temps. La programmation est utilise en tant quoutil pour
atteindre un objectif, raliser une tude ou tester un modle. Nombreux sont les
lves qui choisissent de contourner les classes et les objets sans pour autant nuire
la qualit de leur travail ; les programmes quils conoivent sont sans doute moins
lisibles mais ils parviennent lobjectif fix.
Le chapitre 6 prsente comment crer ses propres extensions. Les derniers para-
graphes ne concernent que des utilisateurs experts puisquils parlent de lutilisation
conjointe des langages Python et C++ partir dun exemple conu cet effet et
utilisable en peu de temps 5 . Cette technique est intressante dans des domaines o
les calculs doivent tre imprativement trs rapides comme en finance, matire
laquelle sont forms les tudiants de lENSAE.
Le chapitre 7 introduit les fichiers o comment conserves des rsultats sur disque
dur. Le chapitre 8 prsente les interfaces graphiques et le chapitre 9 les threads. Les
chapitres 10 12 ne contiennent que des exercices et problmes sur lesquels plusieurs
promotions de lENSAE ont t values.
5. Concernant ce point, cet exemple tlchargeable permet de construire entirement un module

Python crit en C++, lajout dune fonctionnalit ne prenant que quelques minutes. Cet exemple
fonctionne sous Microsoft Windows avec Microsoft Visual C++, il utilise la librairie Boost Python.
Microsoft Windows est le systme dexploitation le plus courant dans les socits.
Table des matires
partie I Le langage Python 9
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.1 Ordinateur et langages . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2 Prsentation du langage Python . . . . . . . . . . . . . . . . . . . . . 12
1.3 Installation du langage Python . . . . . . . . . . . . . . . . . . . . . 14
1.4 Installation dun diteur de texte . . . . . . . . . . . . . . . . . . . . 18
1.5 Premier programme . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.6 Installation dextensions (ou modules externes) . . . . . . . . . . . . 23
1.7 Outils connexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2. Types et variables du langage Python . . . . . . . . . . . . . . . . . . . . . 31

2.1 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.2 Types immuables (ou immutable) . . . . . . . . . . . . . . . . . . . . 32
2.3 Types modifiables (ou mutable) . . . . . . . . . . . . . . . . . . . . . 42
2.4 Extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3. Syntaxe du langage Python (boucles, tests, fonctions) . . . . . . . . . . . . 57

3.1 Les trois concepts des algorithmes . . . . . . . . . . . . . . . . . . . . 57
3.2 Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
3.3 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.4 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
3.5 Indentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
3.6 Fonctions usuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
3.7 Constructions classiques . . . . . . . . . . . . . . . . . . . . . . . . . 87
4. Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
4.1 Prsentation des classes : mthodes et attributs . . . . . . . . . . . . 93
4.2 Constructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
4.3 Apport du langage Python . . . . . . . . . . . . . . . . . . . . . . . . 99
4.4 Oprateurs, itrateurs . . . . . . . . . . . . . . . . . . . . . . . . . . 103
4.5 Mthodes, attributs statiques et ajout de mthodes . . . . . . . . . . 108
4.6 Copie dinstances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
4.7 Attributs figs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
4.8 Hritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
4.9 Compilation de classes . . . . . . . . . . . . . . . . . . . . . . . . . . 133
5. Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
5.1 Principe des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . 138
5.2 Dfinir ses propres exceptions . . . . . . . . . . . . . . . . . . . . . . 145
5.3 Exemples dutilisation des exceptions . . . . . . . . . . . . . . . . . . 146
6. Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
6.1 Modules et fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
6.2 Modules internes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
6.3 Modules externes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
6.4 Python et les autres langages . . . . . . . . . . . . . . . . . . . . . . 157
6.5 Boost Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
7. Fichiers, expressions rgulires, dates . . . . . . . . . . . . . . . . . . . . . 169

7.1 Format texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
7.2 Fichiers zip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
7.3 Manipulation de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . 175
7.4 Format binaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
7.5 Paramtres en ligne de commande . . . . . . . . . . . . . . . . . . . 182
7.6 Expressions rgulires . . . . . . . . . . . . . . . . . . . . . . . . . . 184
7.7 Dates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
7.8 Problme de jeux de caractres . . . . . . . . . . . . . . . . . . . . . 191
8. Interface graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

8.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
8.2 Les objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
8.3 Disposition des objets dans une fentre . . . . . . . . . . . . . . . . . 206
8.4 Evnements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
8.5 Dautres fentres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
9. Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
9.1 Premier thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
9.2 Synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
9.3 Interface graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
9.4 Files de messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
partie II Enoncs pratiques, exercices 237
10. Exercices pratiques pour sentraner . . . . . . . . . . . . . . . . . . . . . . 238

10.1 Montant numrique, montant littral . . . . . . . . . . . . . . . . . . 238
10.2 Reprsentation des donnes, partie de dames . . . . . . . . . . . . . . 242
10.3 Reconnatre la langue dun texte . . . . . . . . . . . . . . . . . . . . 245
10.4 Carrs magiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
10.5 Tri rapide ou quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . 261
11. Exercices pratiques pour svaluer . . . . . . . . . . . . . . . . . . . . . . . 270

11.1 Recherche dichotomique . . . . . . . . . . . . . . . . . . . . . . . . . 270
11.2 Ajouter un jour fri . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
11.3 Frquentation dun site Internet . . . . . . . . . . . . . . . . . . . . 276
12. Exercices crits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280

12.1 Premier nonc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
12.2 Second nonc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
12.3 Troisme nonc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
12.4 Quatrime nonc . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
12.5 Exercices supplmentaires . . . . . . . . . . . . . . . . . . . . . . . . 319
Index 323
Premire partie
LE LANGAGE PYTHON
Les programmes informatiques sont souvent laboutissement dun raisonnement,

dune construction, dune ide, parfois imprcise mais dont le principe gnral est
compris. Et pour valider cette ide, on utilise un langage de programmation qui ne
tolre jamais limprcision, qui refuse de comprendre au moindre signe de ponctua-
tion oubli, qui est dune syntaxe si rigide.
On reste parfois indcis devant une erreur qui se produit avec un exemple quon a
pourtant recopi sans ajout. On compare les deux versions sans faire attention aux
petits dtails qui ne changent rien pour le concepteur et beaucoup pour le langage.
Cest un espace en plus ou en moins, un symbole : oubli... Il est frquent de ne
pas vrifier ces petits dtails lorsquon commence programmer. Et ils dcouragent
souvent. On shabitue peu peu au fait quil ne faut pas confondre parenthses et
crochets, quil manque des guillemets, quil y a une lettre en plus, ou en moins.
Lorsque sa syntaxe nest pas respecte, le langage de programmation ne cherche
jamais comprendre lintention du programmeur. Il faut penser la vrifier en
premier lorsquune erreur se produit. Les messages derreur, obscurs au premier
abord, donnent nanmoins un bon indice pour corriger un programme. Et si cela
ne suffisait pas, il ne faut pas hsiter recopier ce message dans un moteur de
recherche sur Internet pour y trouver une indication ds les premiers rsultats, et le
plus souvent en franais.
Cette premire partie est consacre la description du langage Python. Il est parfois
utile de reproduire un des exemples, de le faire fonctionner, de le modifier, dy
introduire des erreurs puis de les corriger. Plus tard, dans de plus longs programmes,
les mmes erreurs seront plus difficiles dceler et lexprience montre quon fait
presque toujours les mmes erreurs.
Chapitre 1
Introduction
Ce chapitre sintresse tout dabord linstallation du langage Python et la ra-

lisation dun premier programme avec des instructions dont le sens est intuitif. Les
derniers paragraphes prsentent de nombreuses extensions disponibles sur Internet.
Elles rendent le langage Python trs attractif dans des domaines varis. Ces exten-
sions tmoignent que ce langage emporte ladhsion de nombreux informaticiens qui
en retour assurent sa prennit. Il permet de relier facilement diffrents lments,
diffrentes applications. Cest une des raisons de son succs.
1.1 Ordinateur et langages

Il est rare aujourdhui de ne pas avoir dj entendu ou lu les termes informatiques
dfinis ci-dessous. Cest un rapide rappel.
1.1.1 Lordinateur
On peut considrer simplement quun ordinateur est compos de trois ensembles :
le microprocesseur, la mmoire, les priphriques. Cette description na pas vari en
cinquante ans depuis quun scientifique du nom de von Neumann la imagine.
Le microprocesseur est le cur de lordinateur, il suit les instructions quon lui
donne et ne peut travailler quavec un trs petit nombre dinformations. Sa vitesse
se mesure en GigaHertz (GHz) qui correspondent au nombre doprations quil est
capable deffectuer en une seconde et en nombre de curs qui dtermine le nombre
doprations en parallle quil est capable dexcuter. On lui adjoint une mmoire
avec laquelle il change sans arrt des donnes. Sa capacit se mesure en octets (kilo-
octets, mgaoctets, gigaoctets ou leurs abrviations Ko, Mo, Go 1 ). Ces changes
entre processeur et mmoire sont rapides.
Les priphriques regroupent tout le reste (cran, clavier, souris, disque dur, im-
primante...). Ils sont principalement de deux types : les priphriques de stockages
(disque dur, DVD) et ceux qui nous permettent de dialoguer avec lordinateur, que
ce soit pour afficher, sonoriser (cran, enceintes) ou pour recevoir (souris, clavier,
webcam, micro...).
1. Un kilo-octets quivaut 1024 = 210 octets, un Mo 1024 Ko et un Go 1024 Mo.
1. Introduction 11
1.1.2 Termes informatiques

Certains termes reviendront frquemment dans le livre. Ils sont souvent utiliss
comme si tout le monde les connaissait comme la notion dalgorithme qui parat
plutt abstraite si on se rfre sa dfinition dans le dictionnaire. Dans la pratique,
on confond souvent algorithme avec programme informatique.
Dfinition 1.1 : algorithme

Un algorithme est une suite finie de rgles appliquer dans un ordre dtermin
un nombre fini de donnes pour arriver avec certitude, en un nombre fini
dtapes, un certain rsultat et cela, indpendamment des donnes.
Leur criture est indpendante du langage choisi, quil soit crit en Basic, en Pascal,
en C, en Perl, en PHP, en Python, en franais, un algorithme reste le mme. Pour les
algorithmes simples (un tri par exemple), le passage dun langage lautre consiste
souvent traduire mot--mot, ce qui favorise lapprentissage dun nouveau langage
informatique lorsquon en connat dj un. Les diffrences entre ces langages rsident
dans leur spcialisation, le Visual Basic permet de piloter les applications Microsoft
Office, le PHP, le JavaScript sont ddis la programmation Internet. Le langage
Python nest pas spcialis. Il est souvent moins efficace que chaque langage appliqu
son domaine de prdilection mais il peut viter lapprentissage dune syntaxe
diffrente.
Dfinition 1.2 : programme

Un programme informatique est une suite dinstructions ou squence dins-
tructions. Cest la ralisation informatique dun ou plusieurs algorithmes. Il
dpend du langage.
Dfinition 1.3 : compilateur et compilation

Le compilateur est un programme qui traduit un code crit dans un langage
de programmation en langage dit "machine", comprhensible par lordinateur.
La compilation est le fait de traduire un programme afin que lordinateur le
comprenne.
Dfinition 1.4 : langage interprt

Un langage interprt est converti en instructions propres la machine au fur
et mesure de son excution.
Le langage Python nest pas un langage compil car un programme Python nest pas
traduit en langage machine, il est un langage interprt. Entre son criture et son
excution, il ny a pas dtape intermdiaire telle que la compilation et on peut ainsi
tester un programme plus rapidement mme si son excution est alors plus lente.
Dfinition 1.5 : mot-cl

Un mot-cl est une composante du langage et fait partie de sa grammaire qui
comprend galement les oprateurs numriques.
La table 3.1 (page 58) regroupe les mots-cls du langage Python. Elle contient peu de
12 I. Le langage Python
mots-cls : son concepteur sest attach crer un langage objet avec la grammaire
la plus simple possible.
Dfinition 1.6 : instruction

Ce terme est assez vague et dpend en gnral du langage. On peut considrer
quune instruction est une expression syntaxiquement correcte pour un langage
donn.
Les instructions sont trs courtes et tiennent sur une ligne mais si on nen prend
quune partie, elle perd son sens. Ce serait comme considrer une phrase avec un
verbe transitif mais sans son complment dobjet direct.
1.2 Prsentation du langage Python

1.2.1 Histoire rsume
Python est un langage objet interprt de haut niveau, il a t cr au dbut des an-
nes quatre-vingt-dix par Guido van Rossum. Entre 1995 et 2001, Rossum a chang
plusieurs fois de travail tout en continuant llaboration du langage Python. En
2001, la PSF (Python Software Foundation) est cre. Il sagit dune organisation
but non lucratif dtenant les droits de proprit intellectuelle de Python. Il est de-
puis distribu sous forme de logiciel libre. Python est couvert par sa propre licence 2 .
Toutes les versions depuis la 2.0.1 sont compatibles avec la licence GPL 3 . Selon Wi-
kipedia 4 , Rossum travaillerait maintenant pour lentreprise Google qui propose une
plate-forme de dveloppement de sites web en Python 5 et qui hberge de nombreux
projets en langage Python via son projet Google Code 6 .
1.2.2 Le langage en quelques points

On distingue plusieurs classes parmi les langages informatiques selon la syntaxe quils
proposent ou les possibilits quils offrent. Python est un langage : interprt, orient
objet, de haut niveau, modulaire, syntaxe positionnelle, au typage dynamique.
Le langage Python est dit interprt car il est directement excut sans passer par
une phase de compilation qui traduit le programme en langage machine, comme
cest le cas pour le langage C. En quelque sorte, il fonctionne autant comme une
calculatrice que comme un langage de programmation. Afin dacclrer lexcution
dun programme Python, il est traduit dans un langage intermdiaire 7 qui est ensuite
interprt par une machine virtuelle Python. Ce mcanisme est semblable celui
propre au langage Java.
Le langage est orient objet car il intgre le concept de classe ou dobjet. Un objet
2. Voir le site http://www.python.org/psf/license/, cette licence autorise les usages commerciaux.
3. Ou GNU Public Licence (voir le site http://www.gnu.org/copyleft/gpl.html).
4. http://fr.wikipedia.org/wiki/Python_(langage)
5. http://code.google.com/appengine/
6. http://code.google.com/
7. Celui-ci est appel bytecode. Ce mot ne signifie pas grand chose except que ce bytecode est
seulement comprhensible par la machine virtuelle Python.
1. Introduction 13
regroupe un ensemble de donnes et un ensemble de fonctionnalits attaches ces

donnes. Ce concept relie la description des donnes et les algorithmes qui leur sont
appliqus comme un tout indissociable. Un objet est en quelque sorte une entit
autonome avec laquelle on peut communiquer via une interface.
On considre que le langage Python est de haut niveau car il propose des fonctionna-
lits avances et automatiques comme le garbage collecting. Cette tche correspond
la destruction automatique des objets lorsquils ne sont plus utiliss. Cette fonc-
tionnalit est propose par la plupart des langages interprts ou encore Java mais
pas C++. Il propose galement des structures de donnes complexes loignes des
types numriques standards telles que des dictionnaires.
Le langage Python est modulaire. La dfinition du langage est trs succincte et
autour de ce noyau concis, de nombreuses librairies ou modules ont t dveloppes.
Python est assez intuitif. Etre laise avec ce langage revient connatre tout
autant sa syntaxe que les nombreux modules disponibles. Comme il est assez simple
de construire un pont entre Python et C++, de nombreux projets open source
antrieurs Python sont maintenant accessibles dans ce langage et sous toutes les
plateformes.
Le langage Python est syntaxe positionnelle en ce sens que lindentation fait partie
du langage. Le point virgule permet de sparer les instructions en langage C, lac-
colade permet de commencer un bloc dinstructions. En Python, seule lindentation
permet de marquer le dbut et la fin dun tel bloc, ce procd consiste dcaler les
lignes vers la droite pour signifier quelles appartiennent au mme bloc dinstructions
et quelles doivent tre excutes ensemble. Cette contrainte rend les programmes
Python souvent plus faciles lire.
Le langage Python est typage dynamique. Le type dune variable, dune donne
est dfinie lors de lexcution du programme. Chaque information est dsigne par
un identificateur qui est manipul tout au long du programme. Le fait que telle ou
telle opration soit valide est vrifie au moment o elle doit tre ralise et non au
moment o le programme est traduit en langage machine, cest--dire compil.
1.2.3 Avantages et inconvnients du langage Python

Alors quil y a quelques annes, le langage C puis C++ simposaient souvent comme
langage de programmation, il existe dornavant une profusion de langages (Java,
JavaScript, PHP, Visual Basic, C#, Perl, PHP, ...). Il est souvent possible de trans-
poser les mmes algorithmes dun langage un autre. Le choix appropri est bien
souvent celui qui offre la plus grande simplicit lors de la mise en uvre dun pro-
gramme mme si cette simplicit sacquiert au dtriment de la vitesse dexcution.
Le langage PHP est par exemple trs utilis pour la conception de sites Internet car
il propose beaucoup de fonctions trs utiles dans ce contexte. Dans ce domaine, le
langage Python est une solution alternative intressante.
Comme la plupart des langages, le langage Python est tout dabord portable puis-
quun mme programme peut tre excut sur un grand nombre de systmes dex-
ploitation comme Linux, Microsoft Windows, Mac OS X... Python possde galement
lavantage dtre entirement gratuit tout en proposant la possibilit de pouvoir ra-
liser des applications commerciales laide de ce langage.
Si le langage C reste le langage de prdilection pour limplmentation dalgorithmes

complexes et gourmands en temps de calcul ou en capacits de stockage, un langage
tel que Python suffit dans la plupart des cas. De plus, lorsque ce dernier ne convient
pas, il offre toujours la possibilit, pour une grande exigence de rapidit, dintgrer
un code crit dans un autre langage tel que le C/C++ 8 ou Java, et ce, dune
manire assez simple. La question du choix du langage pour lensemble dun projet
est souvent superflue, il est courant aujourdhui dutiliser plusieurs langages et de
les assembler. Le langage C reste incontournable pour concevoir des applications
rapides, en revanche, il est de plus en plus frquent d"habiller" un programme avec
une interface graphique programme dans un langage tel que Python.
En rsum, lutilisation du langage Python nest pas restreinte un domaine : elle
comprend le calcul scientifique, les interfaces graphiques, la programmation Internet.
Sa gratuit, la richesse des extensions disponibles sur Internet le rendent sduisant
dans des environnements universitaire et professionnel. Le langage est vivant et
lintrt quon lui porte ne dcrot pas. Cest un critre important lorsquon choisit
un outil parmi la myriade de projets open source. De plus, il existe diffrentes
solutions pour amliorer son principal point faible qui est la vitesse dexcution.
1.3 Installation du langage Python

1.3.1 Installation du langage Python
Python a lavantage dtre disponible sur de nombreuses plates-formes comme Mi-
crosoft Windows, Linux ou Mac OS X. Linstallation sous Windows est simple. Le
langage Python est dj intgr aux systmes dexploitation Linux et Mac OS X.
Sous Microsoft Windows, il suffit dexcuter le fichier python-2.6.5.msi 9 ou tout
autre version plus rcente. En rgle gnrale, il est conseill de tlcharger la dernire
version stable du langage, celle avec laquelle le plus grande nombre dextensions
seront compatibles, en particulier toutes celles dont vous avez besoin. Les options
dinstallation choisies sont celles par dfaut, le rpertoire dinstallation est par dfaut
C:/Python26. A la fin de cette installation apparat un menu supplmentaire dans
le menu Dmarrer (ou Start) de Microsoft Windows comme le montre la figure 1.1.
Ce menu contient les intituls suivant :
IDLE (Python GUI) diteur de texte, pour programmer
Module Docs pour rechercher des informations dans la docu-
mentation
Python (command line) ligne de commande Python
Python Manuals documentation propos du langage Python
Uninstall Python pour dsinstaller Python
La documentation (de langue anglaise 10 ) dcrit en dtail le langage Python, elle in-
clut galement un tutoriel 11 qui permet de le dcouvrir. La ligne de commande (voir
8. Ce point est dailleurs abord au paragraphe 6.5, page 158.
9. Cette version est disponible ladresse http://www.python.org/download/. Cest la version
utilise pour dvelopper les exemples prsents dans ce livre.
10. http://www.python.org/doc/
11. La requte python franais de nombreux sites de documentation sur Python en franais.
1. Introduction 15
Figure 1.1 : Menu ajout Microsoft Windows.
figure 1.2) permet dexcuter des instructions en langage Python. Elle est pratique
pour effectuer des calculs mais il est ncessaire dutiliser un diteur de texte pour
crire un programme, de le sauvegarder, et de ne lexcuter quune fois termin au
lieu que chaque ligne de celui-ci ne soit interprte immdiatement aprs quelle a
t crite comme cest le cas pour une ligne de commande.
Figure 1.2 : Ligne de commande, la premire ligne affecte la valeur 3 la variable x, la

seconde ligne laffiche.
1.3.2 Particularit de Mac OS X et Linux

Le langage Python est dj prsent sur les ordinateurs dApple si ceux-ci sont quips
du systme dexploitation Mac OS X. Il est galement prsent dans les distributions
Linux. Linstallation de Python est parfois rendue ncessaire si on dsire utiliser la
dernire version du langage. Linstallation des extensions du langage est similaire
celle dautres extensions Linux.
Il ne faut pas oublier de vrifier la version du langage Python installe sur lor-
dinateur Linux et Mac OS X. Il suffit pour cela de taper la ligne help() pour en
prendre connaissance. Cela signifie que toutes les extensions qui doivent tre ins-
talles doivent ltre pour cette version quil est nanmoins possible de mettre
jour 12 .
1.3.3 Utilisation de lditeur de texte

La figure 1.1 montre le menu install par Python dans le menu "Dmarrer" de
Microsoft Windows. En choisissant lintitul "IDLE (Python GUI)", on active la
fentre de commande de Python(voir figure 1.3). Les instructions sont interprtes
12. voir la page http://www.python.org/download/mac/ ou http://www.python.org/download/
linux/
Figure 1.3 : Fentre de commande fournie avec le langage Python.
au fur et mesure quelles sont tapes au clavier. Aprs chaque ligne, cette fentre
de commande conserve la mmoire de tout ce qui a t excut. Par exemple :
>>> x = 3
>>> y = 6
>>> z = x * y
>>> print z
18
>>>
Aprs lexcution de ces quelques lignes, les variables 13 x, y, z existent toujours. La

ligne de commande ressemble une calculatrice amliore. Pour effacer toutes les
variables cres, il suffit de redmarrer linterprteur par lintermdiaire du menu
Shell>Restart Shell. Les trois variables prcdentes auront disparu.
Il nest pas possible de conserver le texte qui a t saisi au clavier, il est seulement
possible de rappeler une instruction dj excute par lintermdiaire de la com-
binaison de touches ALT + p, presse une ou plusieurs fois. La combinaison ALT + n
permet de revenir linstruction suivante. Pour crire un programme et ainsi conser-
ver toutes les instructions, il faut dactionner le menu File>New Window qui ouvre
une seconde fentre qui fonctionne comme un diteur de texte (voir figure 1.4).
Aprs que le programme a t saisi, le menu RunRun Module excute le programme.
Il demande au pralable sil faut enregistrer le programme et rinitialise linterpr-
teur Python pour effacer les traces des excutions prcdentes. Le rsultat apparat
dans la premire fentre (celle de la figure 1.3). La pression des touches "Ctrl + C"
permet darrter le programme avant quil narrive sa fin.
Remarque 1.7 : fentre intempestive
Si on veut se dbarrasser de cette fentre intempestive qui demande confirma-
13. Les variables sont dfinies au chapitre 2. En rsum, on peut considrer une variable comme
une lettre, un mot qui dsigne une information. Dans cet exemple, les trois variables dsignent des
informations numriques quon peut manipuler comme si elles taient effectivement des nombres.
Les variables supprimes, les informations quelles dsignaient ne plus accessibles et sont perdues
galement.
1. Introduction 17
Figure 1.4 : Fentre

de programme, le menu
RunRun Module permet de
lancer lexcution du pro-
gramme. Linterprteur Py-
thon est rinitialis au dbut
de lexcution et ne conserve
aucune trace des travaux
prcdents.
tion pour enregistrer les dernires modifications, il suffit daller dans le menu
Options>Configure IDLE et de choisir No prompt sur la quatrime ligne dans la ru-
brique General (voir figure 1.5). Ce dsagrment apparat sur la plupart des diteurs
de texte et se rsout de la mme manire.
Cette description succincte permet nanmoins de raliser puis dexcuter des pro-
grammes. Les autres fonctionnalits sont celles dun diteur de texte classique, no-
tamment la touche F1 qui dbouche sur laide associe au langage Python. Il est
possible douvrir autant de fentres quil y a de fichiers modifier simultanment.
Nanmoins, il est prfrable dutiliser dautres diteurs plus riches comme celui pro-
pos au paragraphe 1.4.1. Ils proposent des fonctions ddition plus volues que
lditeur install avec Python.
Figure 1.5 : Cliquer sur

General puis sur Noprompt
pour se dbarrasser de la
fentre intempestive qui
demande lutilisateur de
confirmer la sauvegarde
des dernires modifications.
Dautres diteurs de texte
se comportent de la mme
manire et disposent dune
option similaire.
1.4 Installation dun diteur de texte

1.4.1 Editeur SciTe
Il existe de nombreux diteurs de texte, payants ou gratuits. Le premier propos
dans ce livre est SciTe, il est gratuit et fonctionne avec de nombreux compilateurs
de langages diffrents (voir figure 1.6). Lditeur SciTe 14 est lger et son utilisa-
tion ne ncessite pas de droits spcifiques 15 . La gestion des erreurs est galement
plus pratique puisquil suffit de cliquer sur une erreur pour que lditeur positionne
automatiquement le curseur sur la ligne ayant gnr cette erreur.
Une fois install, il faut configurer lditeur de manire ce quil puisse utiliser
le compilateur Python. Il faut cliquer sur le menu Option et choisir la rubrique
Open python.properties (voir figure 1.6).
Figure 1.6 : Configuration de

lditeur de texte SciTe. Il faut cli-
quer sur le menu Option, puis sur
Open python.properties pour ouvrir
les paramtres de configuration asso-
cies au langage Python.
Aprs avoir slectionn ce menu, un fichier texte souvre. Vers la fin, on trouve les
lignes suivantes qui contiennent la ligne de commande qui permet dexcuter un
programme Python :
if PLAT_WIN
command.go.*.py=python -u "$(FileNameExt)"
command.go.subsystem.*.py=0
command.go.*.pyw=pythonw -u "$(FileNameExt)"
command.go.subsystem.*.pyw=1
Il suffit de prciser le rpertoire o se trouve linterprteur qui devrait tre

c : /python26 sur Microsoft Windows si le rpertoire dinstallation par dfaut du
langage Python na pas t modifi.
14. Cet diteur est accessible depuis ladresse http://www.scintilla.org/SciTE.html et tlchar-
geable depuis ladresse http://scintilla.sourceforge.net/SciTEDownload.html.
15. Il arrive frquemment que des universits, des socits interdisent leurs utilisateurs lins-
tallation de nouveaux logiciels sur leurs machines pour des raisons de scurit. Il faut des droits
spcifiques pour contourner cette interdiction.
1. Introduction 19
if PLAT_WIN
command.go.*.py=c:\Python26\python -u "$(FileNameExt)"
command.go.subsystem.*.py=0
command.go.*.pyw=c:\Python26\pythonw -u "$(FileNameExt)"
command.go.subsystem.*.pyw=1
Une fois ce fichier enregistr, il ne reste plus qu crire un programme Python. Une
fois termin, la touche F5 lance son excution. Lexemple de la figure 1.7 montre un
cas o lexcution a t interrompue par une erreur.
Figure 1.7 : Excution dun

programme interrompue par une
erreur. Pour cet diteur, il suffit
de cliquer sur le message der-
reur pour placer le curseur sur
la ligne errone.
Le site Internet de SciTe propose quelques trucs et astuces pour configurer lditeur
votre convenance. Comme peu prs tous les logiciels, il dispose dune rubrique
FAQ 16 (Frequently Asked Questions) qui recense les questions et les rponses les
plus couramment poses. Cette rubrique existe pour la plupart des diteurs et plus
gnralement pour la plupart des applications disponibles sur Internet.
1.4.2 Python Scripter

Le second diteur propos dans ce livre est Python Scripter 17 (voir figure 1.8). Il
est plus lourd mais offre plus de fonctionnalits notamment un dbugger qui permet
dexcuter pas pas un programme afin de vrifier chaque ligne de son excution.
Lorsquun programme produit de mauvais rsultats, la premire solution consiste
afficher de nombreux rsultats intermdiaires mais cela ncessite dajouter des ins-
tructions un peu partout dans le programme. La seconde mthode est lutilisation
du dbugger. Sans modifier le code informatique, il est possible darrter temporai-
rement lexcution une ligne donne pour inspecter le contenu des variables cet
instant de lexcution. Ce logiciel fonctionne sans autre manipulation supplmentaire
autre que son installation.
Cet diteur, contrairement SciTe, ne fonctionne quavec Python et ne peut tre
utilis avec dautres langages. Son apparence est adapte au dveloppement. Il per-
16. http://scintilla.sourceforge.net/SciTEFAQ.html
17. http://mmm-experts.com/
Figure 1.8 : Copie dcran de lditeur Python Scripter.
met galement de voir la liste des variables, fonctions, classes, prsentes dans un
programme.
1.4.3 Eclipse et PyDev

Eclipse 18 est un environnement complet de dveloppement adapt une multitude
de langages dont Python via une extension appel PyDev 19 . Cette solution sadresse
plus des gens ayant dj une exprience en informatique ou souhaitant construire
un projet consquent. En constante volution, Eclipse est un diteur trs complet
mais son utilisation ncessite un apprentissage non ngligeable qui nest pas indis-
pensable pour des projets de petite taille.
1.4.4 Ct Mac OS X : TextWrangler

Un diteur possible est TextWrangler 20 qui est gratuit. Lorsquon programme
la fois sous Microsoft Windows et Linux ou Mac OS X, les fichiers contiennent
des codes de fins de lignes diffrents et lditeur vous le fait remarquer chaque
excution. Pour viter ce dsagrment, il convient dcraser le fichier contenant le
programme en le sauvegardant nouveau en prenant soin de choisir des fins de
lignes identiques celles du monde Linux. Linux fait galement la diffrence entre
les minuscules et les majuscules en ce qui concerne les noms de fichiers contrairement
18. http://www.eclipse.org/
19. http://pydev.sourceforge.net/
20. http://www.barebones.com/products/textwrangler/
1. Introduction 21
Microsoft Windows 21 . Lenvironnement de dveloppement XCode est aussi une

solution.
1.4.5 Autres diteurs

Certains diteurs de texte sont eux-mmes crits en Python, ce qui leur permet
de fonctionner sur toutes les plates-formes. Trois sont assez connues, DrPython 22 ,
Boa Constructor 23 , The Eric Python IDE 24 . Ce dernier sappuie sur une interface
graphique de type pyQt 25 , son interface est riche, presque trop lorsquon commence
programmer. Boa Constructor sappuie sur wxPython et offre des outils permettant
de dessiner des interfaces graphiques. DrPython est le plus simple des trois.
Certains diteurs connus du monde Linux ont t dclins pour le monde Windows,
cest le cas de Emacs 26 . SciTe est souvent utilis car cest le plus simple. Les autres
offrent des fonctionnalits varies dont lutilit napparat que pour des programmes
consquents. Le site officiel 27 rpertorie dautres diteurs de texte dont certains sont
de vritables environnements de dveloppements. Il nest pas aberrant den utiliser
plus dun car chacun deux est plus appropri dans telle situation ou pour tel type
de programme.
1.4.6 Tabulations
De nombreux diteurs utilisent les tabulations pour mettre en forme un programme
et tenir compte des dcalages (indentation) dun bloc par rapport un autre. Il est
conseill de remplacer ces tabulations par des espaces, cela vite les confusions et
les mauvaises interprtations lorsque tabulations et espaces sont mlangs. La taille
dune tabulation peut varier dun diteur lautre contrairement aux espaces.
1.5 Premier programme

Aprs avoir install le langage Python ainsi quun diteur, il suffit dcrire quelques
lignes pour vrifier que cette premire tape sest acheve correctement. Tous les
programmes Python porte lextension .py.
1.5.1 Afficher le rsultat dun calcul

Le programme suivant, quon peut appeler premier.py, affiche le message
premier message une fois quil est excut. Le mot-cl print prcdant le message
- toujours entre guillemets ou entre apostrophes sauf si ce sont des nombres - stipule
quil faut afficher quelque chose.
21. Lusage de la commande dos2unix peut se rvler utile.
22. http://drpython.sourceforge.net/
23. http://boa-constructor.sourceforge.net/
24. http://www.die-offenbachs.de/eric/index.html
25. Voir le paragraphe 1.6.5 sur les interfaces graphiques.
26. http://www.gnu.org/software/emacs/windows/
27. plus prcisment ladresse http://wiki.python.org/moin/PythonEditors ou encore ladresse
http://wiki.python.org/moin/IntegratedDevelopmentEnvironments
print "premier message"
Un programme ne barbouille pas lcran de texte indsirable, il naffiche que ce

que le programmeur lui demande dafficher et cette intention se matrialise grce
linstruction print. On peut ensuite crire quelques lignes quon pourrait galement
taper sur une calculatrice :
print 3.141592 * 5*5

print 3.141592 * 5**2
Ces deux lignes affichent 78.5398 qui est la surface dun cercle de 5 mtres de ct.
Le symbole correspond lopration puissance. Il existe une constante PI ou
mais qui ne fait pas partie du langage lui-mme : elle est dfinie dans une extension
interne 28 du langage qui contient bon nombre de fonctions mathmatiques telles
que les cosinus, sinus...
from math import * # permet dutiliser les extensions mathmatiques de Python

print pi * 5**2
Remarque 1.8 : print Python 3.0

A partir de la version 3.0 du langage Python, la syntaxe de print change et il faudra
dornavant utiliser des parenthses. Il est suggr dutiliser cette syntaxe qui est
valide quelque soit la version du lanage.
print (3.141592 * 5*5)
1.5.2 Les accents

Le langage Python est conu pour le monde anglophone et lutilisation des accents
ne va pas de soi. Le programme suivant qui demande dafficher un message contenant
un accent provoque lapparition dune erreur :
print "accentu"
Lerreur est la suivante :

File "essai.py", line 1
SyntaxError: Non-ASCII character \xe9 in file i.py on line 1,
but no encoding declared;
see http://www.python.org/peps/pep-0263.html for details
Dans ce cas, il faut ajouter une ligne place en premire position qui prcise que des
accents pourront tre utiliss. Lexcution du programme qui suit ne soulve aucune
erreur.
28. Cette extension est installe automatiquement avec Python contrairement une extension
externe.
1. Introduction 23
# coding: latin-1
print "accentu"
Cette ligne prcise en fait que linterprteur Python doit utiliser un jeu de caractres
spcial. Ces jeux de caractres ont parfois leur importance, les navigateurs naiment
pas trop les accents au sein des adresses Internet : il est parfois prfrable de ne pas
utiliser daccents sur les sites de rservations dhtels, de trains ou davions.
Par dfaut, linterprteur Python utilise le jeu de caractres le plus rduit, il faut
lui prciser quil doit en utiliser un plus tendu incluant les accents. On trouve
galement sous Microsoft Windows la syntaxe quivalente suivante :
# coding: cp1252
print "accentu"
Enfin, sil fallait utiliser des caractres autres que latins, il faudrait alors choisir le
jeu de caractres utf 8 qui sappliquent aussi aux langues orientales.
# coding: utf-8
print "accentu"
A cause des accents, la plupart des exemples cits dans ce livre ne fonctionnent
pas sans cette premire ligne qui a parfois t enleve lors de limpression pour des
questions de lisibilit. Il faut penser lajouter pour reproduire les exemples. Le
paragraphe 7.8 page 191 est plus complet ce sujet.
Remarque 1.9 : #!/usr/local/bin/python
Sur Internet, on trouve de nombreux exemples commenant par la ligne suivante :
#!/usr/local/bin/python
On rencontre souvent cette ligne pour un programme crit sur une machine Linux,
elle indique lemplacement de linterprteur Python utiliser. Cette ligne sappelle
un shebang.
1.6 Installation dextensions (ou modules externes)

Les extensions ou modules ou packages sont des bibliothques de fonctions non stan-
dard. Ce sont souvent des programmes existant conus dans un autre langage tel
que C++ et qui ont t "coiffs" dune interface permettant de les utiliser sous
Python. Les paragraphes qui suivent dcrivent quelques extensions couramment uti-
lises. Certains besoins reviennent frquemment comme dessiner un graphe, charger
une image, faire du calcul matriciel et Python seul ne permet pas de rpondre ce
problme.
La premire information connatre avant dinstaller un package est la version du
langage Python installe sur votre ordinateur. Il faut imprativement utiliser la
version du module labore pour la mme version 29 . Il est ncessaire de connatre
galement le systme dexploitation de votre ordinateur.
29. Linstruction help() saisie sur la ligne de commande Python retourne entre autres le numro
de version.
Par consquent, il ne faut pas installer le module scipy (calcul scientifique) labor
pour Python 2.5 alors que sur votre ordinateur est installe la version 2.4, il y a
de fortes chances que cela ne fonctionne pas. Certains modules dpendent dautres,
lors de leur installation, il faut vrifier que les modules dont ils dpendent ont t
pralablement installs.
Le site officiel 30 recense une longue liste de modules existants (plusieurs centaines).
Il recense galement les dernires mises jour. Avant de commencer programmer,
il est conseill daller chercher sur ce site ou dutiliser un moteur de recherche pour
savoir si un module ne ferait pas dj une partie du travail.
Il est parfois intressant de consulter des forums dchanges entre programmeurs au-
tour de Python. Il est parfois plus intressant de jeter un il sur de tels sites 31 avant
de se lancer dans la recherche dun module spcifique. Internet fournit galement de
nombreux exemples de programmes dont on peut sinspirer.
Les modules cits dans ce paragraphe ne sont pas installs automatiquement avec le
langage Python mais sont parfois trs utiles dans le cadre dun travail dingnieur.
Ils existent depuis plusieurs annes et sont pour la plupart rgulirement maintenus
jour. Ils sont tous facilement accessibles depuis un moteur de recherche.
1.6.1 Graphes
matplotlib 32 : ce module reprend la mme logique que le logiciel MatLab ou Oc-
tave. Pour ceux que la finance intresse, il comporte galement des fonctions qui
permettent de rcuprer des historiques quotidiens de cours dactions depuis le site
Yahoo ! Finance 33 .
biggles 34 : ce module permet de dessiner des courbes (2D, 3D) et de convertir des
graphiques sous forme dimages de tout format. Ce module ncessite linstallation
de fichiers supplmentaires (libpng, zlib, plotutils) 35 .
pydot 36 : ce module propose le dessin de graphes dans une image (arbre gnalogique,
rseau de distribution, ...). Le module pydot permet de dessiner tout type de graphe.
Ce module ncessite un autre module pyparsing 37 et une application Graphviz 38 .
Avec cet outil, on peut raliser des graphes comme celui de la figure 1.9. Ce module
est utilis lors de lexercice 4 page 261.
pyx 39 : ce module est aussi une librairie qui permet de tracer des graphes avec la
possibilit de convertir directement ceux-ci en fichiers PDF ou EPS.
30. http://pypi.python.org/pypi
31. On peut citer http://wikipython.flibuste.net/ ou http://www.afpy.org/, deux sites franais qui
regroupent des informations intressantes sur de nouveaux modules ou des exemples dutilisation
de modules courants.
32. http://matplotlib.sourceforge.net/
33. Avec la fonction fetch_historical_yahoo.
34. http://biggles.sourceforge.net/
35. Accessibles depuis ladresse http://www.gnu.org/software/plotutils/, ces informations sont dis-
ponibles depuis la page de tlchargement de biggles.
36. http://code.google.com/p/pydot/
37. http://pyparsing.wikispaces.com/
38. http://www.graphviz.org/
39. http://pyx.sourceforge.net/
1. Introduction 25
Figure 1.9 : Image dun

graphe, extraite du site
http ://www.graphviz.org/
o est disponible loutil
Graphviz. Il permet de re-
prsenter des graphes sur
une page en minimisant les
croisements darcs ce qui est
un problme complexe.
Sans utiliser ncessairement une extension, il existe des outils comme GNUPlot 40
venu du monde Linux qui sexcutent facilement en ligne de commande. Cet outil
propose son propre langage de programmation ddi la cration de graphiques.
Une fois ce langage matris, il est facile de construire un programme qui permet de
lexcuter en ligne de commande pour rcuprer limage du graphique.
Remarque 1.10 : sortie texte et graphique
Un des moyens simples de construire un rapport mlangeant rsultats numriques
et graphiques est de construire un fichier au format HTML 41 puis de lafficher grce
un navigateur Internet. Il est mme possible de construire un fichier au format
PDF en utilisant loutil Latex 42 .
1.6.2 Calculs scientifiques

numpy 43 : ce module manipule efficacement les tableaux de grandes dimensions,
intgre le calcul matriciel, la transforme de Fourier.
scipy 44 : ce module propose de nombreux algorithmes, algorithmes de classification,
intgration, optimisation, gnration de nombres alatoires, traitement du signal,
interpolation, algorithmes gntiques, algbre linaire, transforme de Fourier, dessin
de courbes 2D, 3D. Son installation requiert dabord celle du module numpy.
orange 45 : cest un module qui permet de faire ce quon appelle du datamining ou
fouille de donnes. Il propose de nombreux algorithmes de classifications, danalyse
des donnes qui ont trait au machine learning.
Rpy 46 : le langage R 47 est un langage ddi aux calculs statistiques. Il est optimis
pour la manipulation de grandes matrices et des calculs statistiques et matriciels
rapides. Il dispose galement de nombreux graphiques. Il faut au pralable installer
Python et R puis le module Rpy fera la liaison entre les deux.
40. http://www.gnuplot.info/
41. Il est facile de trouver des pages Internet dcrivant cette syntaxe via un moteur de recherche.
Lexercice 7, page 267 en dira plus ce sujet.
42. voir lexercice 7, page 268
43. http://numpy.scipy.org/
44. http://www.scipy.org/
45. http://www.ailab.si/orange/
46. http://rpy.sourceforge.net/
47. http://www.r-project.org/
On pourrait galement citer le module mdp 48 qui offre quelques fonctionnalits rela-
tives lanalyse des donnes tels que lanalyse en composante principale (ACP) ou
encore le module cvxopt 49 qui propose des algorithmes doptimisation quadratique
sous contraintes.
1.6.3 Images
PythonImageLibrary(PIL) 50 : ce module permet dutiliser les images, quelque soit
leur format. Elle propose galement quelques traitements dimages simples, rotation,
zoom, histogrammes.
1.6.4 Base de donnes

SQLObject 51 : ce module offre la possibilit de se connecter la plupart des
serveurs de bases de donnes et dy accder via une syntaxe objet plutt quau
travers de requtes SQL.
SQLAlchemy 52 : ce module propose les mmes fonctionnalits que le prcdent.
Cest le plus riche des deux. Il est souvent utilis en association avec le module
elixir 53 .
1.6.5 Interfaces graphiques

Le langage Python propose un module interne permettant de raliser des interfaces
graphiques : Tkinter. Il suffit pour des applications simples qui ne ncessitent que
quelques fentres. Pour des applications plus ambitieuses qui doivent afficher des
donnes sous forme de matrices par exemple ou pour obtenir un aspect plus profes-
sionnel, il est impratif dutiliser un module externe. Il est nanmoins conseill de
savoir utiliser Tkinter et de comprendre la programmation vnementielle avant de
se lancer dans lapprentissage de wxPython, pyQt ou pyGTK. Ces trois modules pro-
posent des fonctionnalits quivalentes, le choix porte surtout sur des besoins prcis
quun module couvre et sur des questions desthtisme.
wxPython 54 : il propose des interfaces graphiques plus compltes que le module stan-
dard Tkinter comme une fentre tableur. Utilis par de nombreuses applications, il
est rgulirement mis jour. Il est entirement gratuit et peut servir des appli-
cations commerciales. Il sinspire des MFC ou Microsoft Fundation Class issues de
Microsoft mais a lavantage dtre portable. Aujourdhui, cest avant tout un projet
open source en constante volution.
pyQt 55 : il est moins rpandu que wxPython sans doute car il est produit par une
48. http://mdp-toolkit.sourceforge.net/
49. http://abel.ee.ucla.edu/cvxopt/
50. http://www.pythonware.com/products/pil/
51. http://www.sqlobject.org/
52. http://www.sqlalchemy.org/
53. http://elixir.ematia.de/trac/
54. http://www.wxpython.org/
55. http://www.riverbankcomputing.co.uk/software/pyqt/intro
1. Introduction 27
socit et nest pas open source. Il est rput pour tre mieux structur. Il existe
des restrictions pour la conception dapplications commerciales.
pyGTK 56 : il est plus proche de Tkinter que les deux autres modules. Venu du monde
Linux, laspect de linterface lui est plus ressemblant qu celui du monde Windows.
Lorsquon souhaite raliser un jeu, il est ncessaire davoir une interface graphique
plus conciliante avec la gestion des images, des dessins, des sons voire des vidos.
Cest le cas du module qui suit.
pygame 57 : ce module est prvu pour concevoir des jeux en Python. Il permet entre
autres dcouter les morceaux enregistrs sur un CD, dafficher un film et galement
dafficher des images, de rcuprer les touches presses au clavier, les mouvements
de la souris, ceux de la manette de jeux. Il suffit dune heure ou deux pour crire
ses premiers programmes avec pygame. Il nest pas prvu pour raliser des jeux en
3D mais suffit pour bon nombre de jeux de plateau, jeux de rflexion.
Pour la ralisation dimages et danimations 3D, on peut utiliser le module
pyOpenGL 58 qui sinterface avec pygame, wxPython ou pyQt. Cest un module dont
la matrise ne se compte plus en heures mais en dizaine dheures tout comme le
module directpython 59 qui est lquivalent de pyOpenGL mais uniquement sous Mi-
crosoft Windows.
1.6.6 Microsoft Windows, Microsoft Excel, PDF

win32com 60 : ce module permet de communiquer avec les applications Microsoft
Windows tels que Microsoft Excel. Il est ainsi possible de crer une feuille Excel
depuis un programme Python, de limprimer, de la sauvegarder sans avoir ouvrir
Excel. Un moteur de recherche permettra de trouver de nombreux petits exemples
utilisant ce module 61 .
reportlab 62 : ce module permet de manipuler les fichiers PDF, autant pour lire les
informations quil contient que pour les modifier.
1.6.7 Acclration de Python

Python est un langage interprt et pour cette raison, il est lent ce qui ne veut pas
dire quil nexiste pas des solutions pour contourner ce problme.
psyco : ce module permet de multiplier la vitesse dexcution dun programme par
trois ou quatre. Il suffit dajouter au programme les instructions suivantes :
import psyco
psyco.full ()
56. http://www.pygtk.org/
57. http://www.pygame.org/
58. http://pyopengl.sourceforge.net/
59. http://sourceforge.net/projects/directpython/
60. http://python.net/crew/mhammond/win32/Downloads.html
61. comme http://wikipython.flibuste.net/CodeWindows#ExempleavecExcel
62. http://www.reportlab.com/software/opensource/rl-toolkit/
Dans les faits, le programme sexcute plus vite mais pas uniformment plus vite :
les calculs sont le plus favoriss. Toutefois, mme avec ce module, le langage Py-
thon reste trs lent par rapport un langage compil comme le C++. Loutil Py-
rex 63 propose une solution en permettant linsertion de code C++ au sein dun pro-
gramme Python. Pyrex nest pas un module, cest un interprteur Python modifi
pour prendre en compte ces insertions C++. Il est essentiel de connatre la syntaxe
du langage C++. Pyrex propose des temps dexcution tout fait acceptable par
rapport ceux du C++ et il accrot fortement la vitesse dcriture des programmes.
Son installation nest pas toujours vidente car il faut le relier au compilateur C++
GCC 64 . Une approche semblable est dveloppe par lextension Weave 65 du module
scipy 66 . Pyrex et Weave offre des performances bien suprieures Python seul,
proches de celle du langage C. Weave conviendra sans doute mieux ceux qui ont
dj programm en C.
Lacclration de lexcution dun programme Python suscite lintrt de nombreux
informaticiens, cest aussi lobjectif de loutil PyPy 67 qui rcrit automatiquement
certaines partie du code en langage C et lintgre au programme existant.
1.7 Outils connexes

Ce paragraphe sort du cadre de ce livre. Nanmoins, on ne conoit pas un pro-
gramme denvergure sans outil autre que Python. Lorsquon travaille plusieurs, il
faut pouvoir conserver les diffrentes versions dun programme, tre capable de fu-
sionner des modifications effectues par deux personnes, changer de linformation.
Ce sont ces tches auxquelles les applications qui suivent tentent dapporter des r-
ponses. La liste des outils prsents dans ce livre est loin dtre exhaustive. Il existe
de nombreuses applications open source qui amliorent lusage quon peut avoir des
ordinateurs. De nombreux internautes changent autour de problmes rencontres,
comparent diffrents logiciels. On fait parfoirs quelques trouvailles en y jetant un
coup dil rgulirement.
1.7.1 Outils quotidiens

SVN 68 : cest un logiciel de suivi de source, il permet de conserver diffrentes
versions dune arborescence de fichiers, de fusionner des modifications faites par
plusieurs personnes. Cest trs pratique pour travailler plusieurs. Une interface
graphique est galement disponible : TortoiseSVN 69 .
MoinMoin 70 : les wikis sont devenus des outils presque incontournables qui per-
mettent de conserver tout type dinformation. Wikipedia est le wiki le plus clbre.
63. http://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/
64. http://gcc.gnu.org/, ce compilateur prsent sur toute machine Linux est port galement sur
Microsoft Windows (voir le site http://www.mingw.org/).
65. http://www.scipy.org/Weave
66. http://www.scipy.org/
67. http://codespeak.net/pypy/dist/pypy/doc/home.html
68. http://subversion.tigris.org/
69. http://tortoisesvn.tigris.org/
70. http://moinmo.in/
1. Introduction 29
Ces outils sont trs utiles pour partager linformation au sein dune entreprise, pour
archiver les rapports de runions par exemple. Ils intgrent souvent un moteur de
recherche.
1.7.2 Outils occasionnels

doxygen 71 : associ au module doxypy 72 , cet outil offre une alternative plus riche
que epydoc, il peut utiliser galement Graphviz 73 pour produire des graphes.
Sphinx 74 : cest loutil qui gnre laide associe au langage Python telle quelle ap-
parat ladresse http://docs.python.org/. Il cre des pages HTML et des documents
au format PDF pour tout projet Python.
HTML Help Workshop 75 : cet outil permet de convertir une documentation au
format HTML en un format CHM propre Microsoft Windows. Loutil doxygen
propose une option qui facilite cette conversion via ce logiciel.
InnoSetup 76 : cette application permet de construire un installateur qui sexcute
automatiquement. Lorsque vous souhaitez transmettre votre travail sous Python
quelquun dautre, celui-ci doit rcuprer le langage, un diteur, les fichiers Py-
thon, dventuelles donnes. Linstallation permettra de regrouper lensemble de ces
oprations sans que lutilisateur final nait se soucier de quoi que ce soit. Cette
application ne fonctionne que sous Microsoft Windows.
1.7.3 Outils pour des besoins spcifiques

Le langage Python sinterface avec de nombreuses applications, les outils qui suivent
peuvent aider des programmeurs confirms automatiser certaines tches fasti-
dieuses.
BuildBot 77 : cet utilitaire est crit en Python, lorsquil est coupl avec SVN, il
facilite la conception dapplications informatiques plusieurs. A chaque mise jour
du code source, BuildBot recompile les sources, passe les tests de non-rgression 78 ,
avertit le ou les programmeurs concerns par des erreurs ventuellement introduites
lors dune mise jour. Il permet de suivre en temps rel la stabilit dune application.
Le projet PyBots 79 regroupe plusieurs outils dautomatisation intressants.
MySQL 80 : cest un serveur de base de donnes. Les bases de donnes sont deve-
71. http://www.stack.nl/~dimitri/doxygen/
72. http://code.foosel.org/doxypy
74. http://sphinx.pocoo.org/
75. http://www.microsoft.com/downloads/ puis saisir HTML Help Workshop dans la barre de
recherche
76. http://www.innosetup.com/
77. http://buildbot.net/trac
78. Les tests de non-rgression ont pour objectif de limiter le nombre derreurs dans un pro-
gramme. Pour une fonction retournant le rsultat dun calcul scientifique, un test de non-rgression
consiste vrifier que ce calcul, pour des donnes bien prcises, aboutit toujours au mme rsultat
malgr les modifications apportes au programme. La dtection dune erreur dbouche souvent sur
un test de non-rgression afin de sassurer quelle ne se reproduira pas.
79. http://www.pybots.org/
80. http://www.mysql.fr/
nus incontournables, elles permettent de stocker et de consulter un grand nombre

dinformations de faon beaucoup plus efficace que des fichiers quels quils soient.
Le langage Python permet facilement de dialoguer directement avec les logiciels de
bases de donnes les plus connus dont MySQL. Le module MySQLdb 81 permet de sy
connecter depuis Python.
SQLite 82 : cette application traite galement les bases de donnes mais sans le
ct serveur. Les bases de donnes sont stockes sous forme de fichiers. Cet outil est
intgr la version 2.5 du langage Python. Lapplication SQLiteSpy 83 permet sous
Microsoft Windows de visualiser le contenu de ces fichiers et de lancer des requtes
SQL.
Remote Python Call (RPyC) 84 : ce module facilite lcriture de programmes
Python qui doivent sexcuter sur plusieurs machines avec tous les problmes que
cela comporte : synchronisation, partage dinformations, ...
Mercurial 85 : cest un autre logiciel de suivi de source crit en Python, son mode
de fonctionnement - dcentralis - est diffrent de celui de SVN. Avec Mercurial, il
ny a plus une rfrence des fichiers sources dun programme, Mercurial est capable
dassembler des versions do quelles viennent.
Bazaar 86 : encore un logiciel de suivi de source cr plus rcemment qui parat plus
convivial.
1.7.4 Outils Internet

django 87 : cet outil facilite la conception de sites Internet qui ne sont pas rduits
de simples pages HTML mais incluent des parties crites en Python. Il propose
des exemples de pages, des accs des bases de donnes. Il est souvent utilis en
combinaison avec loutil suivant.
CherryPy 88 : il permet de raliser des applications Internet. Il est suffisamment
robuste pour tre utilis par de nombreux sites Internet. Il peut paratre fastidieux
de sy plonger mais ce genre doutil offre un rel gain de temps lors de la conception
de sites qui incluent de nombreux changes avec les utilisateurs.
TurboGears 89 : cet outil en regroupe plusieurs dont CherryPy, cest un environe-
ment complet pour crer des sites Internet.
Zope 90 : cest encore un outil pour concevoir des sites Internet, il est plus vieux
et beaucoup plus riche. Il est galement plus complexe apprhender. Il est plutt
destin au dveloppement de sites consquents.
81. http://sourceforge.net/projects/mysql-python
82. http://www.sqlite.org/
83. http://www.yunqa.de/delphi/doku.php/products/sqlitespy/index
84. http://rpyc.wikispaces.com/
85. http://www.selenic.com/mercurial/wiki/
86. http://bazaar.canonical.com/
87. http://www.django-fr.org/
88. http://www.cherrypy.org/
89. http://turbogears.org/
90. http://www.zope.org/
Chapitre 2
Types et variables du langage Python
2.1 Variables
Il est impossible dcrire un programme sans utiliser de variable. Ce terme dsigne
le fait dattribuer un nom ou identificateur des informations : en les nommant, on
peut manipuler ces informations beaucoup plus facilement. Lautre avantage est de
pouvoir crire des programmes valables pour des valeurs qui varient : on peut changer
la valeur des variables, le programme sexcutera toujours de la mme manire et fera
les mmes types de calculs quelles que soient les valeurs manipules. Les variables
jouent un rle semblable aux inconnues dans une quation mathmatique.
Lordinateur ne sait pas faire laddition de plus de deux nombres mais cela suffit
calculer la somme de n premiers nombres entiers. Pour cela, il est ncessaire de
crer une variable intermdiaire quon appellera par exemple somme de manire
conserver le rsultat des sommes intermdiaires.
somme = 0 # initialisation : la somme est nulle
for i in range(1,n) : # pour tous les indices de 1 n exclu
somme = somme + i # on ajoute le i me lment somme
Dfinition 2.1 : variable

Une variable est caractrise par :
un identificateur : il peut contenir des lettres, des chiffres, des blancs souligns
mais il ne peut commencer par un chiffre. Minuscules et majuscules sont
diffrencies. Il est aussi unique.
un type : cest une information sur le contenu de la variable qui indique
linterprteur Python la manire de manipuler cette information.
Comme le typage est dynamique en Python, le type nest pas prcis explicitement,
il est implicitement lie linformation manipule. Par exemple, en crivant, x = 3.4,
on ne prcise pas le type de la variable x mais il est implicite car x reoit une valeur
relle : x est de type rel ou float en Python. Pour leur premire initialisation, une
variable reoit dans la plupart des cas une constante :
Dfinition 2.2 : constante

Les constantes sont le contraire des variables, ce sont toutes les valeurs num-
riques, chanes de caractres, ..., tout ce qui nest pas dsign par un nom. Les
constantes possdent un type mais pas didentificateur.
Le langage Python possde un certain nombre de types de variables dj dfinis ou

types fondamentaux partir desquels il sera possible de dfinir ses propres types
(voir chapitre 4). Au contraire de langages tels que le C, il nest pas besoin de
dclarer une variable pour signifier quelle existe, il suffit de lui affecter une valeur.
Le type de la variable sera dfini par le type de la constante qui lui est affecte.
Le type dune variable peut changer, il correspond toujours au type de la dernire
affectation.
x = 3.5 # cration dune variable nombre rel appele x initialise 3.5
# 3.5 est un rel, la variable est de type "float"
sc = "chane" # cration dune variable chane de caractres appele str
# initialise "chane", sc est de type "str"
Remarque 2.3 : commentaires

Pour tous les exemples qui suivront, le symbole # apparatra maintes reprises. Il
marque le dbut dun commentaire que la fin de la ligne termine. Autrement dit,
un commentaire est une information aidant la comprhension du programme mais
nen faisant pas partie comme dans lexemple qui suit.
x = 3 # affectation de la valeur entire 3 la variable x
y = 3.0 # affectation de la valeur relle 3.0 la variable y
Remarque 2.4 : instruction sur plusieurs lignes

Le Python impose une instruction par ligne. Il nest pas possible dutiliser deux
lignes pour crire une affectation moins de conclure chaque ligne qui nest pas la
dernire par le symbole \. Lexemple suivant est impossible.
x = Il devrait tre rdig x = \

5.5 comme suit : 5.5
Avec ce symbole, les longues instructions peuvent tre crites sur plusieurs lignes de
manire plus lisibles, de sorte quelles apparaissent en entier lcran. Si le dernier
caractre est une virgule, il est implicite.
Les paragraphes suivant numrent les types incontournables en Python. Ils sont
classs le plus souvent en deux catgories : types immuables ou modifiables. Tous
les types du langage Python sont galement des objets, cest pourquoi on retrouve
dans ce chapitre certaines formes dcriture similaires celles prsentes plus tard
dans le chapitre concernant les classes (chapitre 4).
2.2 Types immuables (ou immutable)
Dfinition 2.5 : type immuable (ou immutable)

Une variable de type immuable ne peut tre modifie. Une opration sur une
variable de ce type entrane ncessairement la cration dune autre variable
du mme type, mme si cette dernire est temporaire.
Autrement dit, la simple instruction x+=3 qui consiste ajouter la variable x la

valeur 3 cre une seconde variable dont la valeur est celle de x augmente de 3 puis
2. Types et variables du langage Python 33
en recopier le contenu dans celui de la variable x. Les nombres sont des types
immuables tout comme les chanes de caractres et les tuple qui sont des tableaux
dobjets. Il nest pas possible de modifier une variable de ce type, il faut en recrer
une autre du mme type qui intgrera la modification.
2.2.1 Type "rien"

Python propose un type None pour signifier quune variable ne contient rien. La
variable est de type None et est gale None.
s = None
print s # affiche None
Certaines fonctions 1 utilisent cette convention lorsquil leur est impossible de re-
tourner un rsultat. Ce nest pas la seule option pour grer cette impossibilit : il
est possible de gnrer une exception 2 , de retourner une valeur par dfaut ou en-
core de retourner None. Il ny a pas de choix meilleur, il suffit juste de prciser la
convention choisie.
2.2.2 Nombres rels et entiers

Il existe deux types de nombres en Python, les nombres rels (float) et les nombres
entiers (int). Linstruction x=3 cre une variable de type int initialise 3 tandis
que y=3.0 cre une variable de type float initialise 3.0. Le programme suivant
permet de vrifier cela en affichant pour les variables x et y, leurs valeurs et leurs
types respectifs grce la fonction type.
x = 3
y = 3.0
print "x =", x, type(x) x = 3 <type int>
print "y =", y, type(y) y = 3.0 <type float>
La liste des oprateurs qui sappliquent aux nombres rels et entiers suit ce para-
graphe. Les trois premiers rsultats sexpliquent en utilisant la reprsentation en
base deux. 8 1 scrit en base deux 100 1 = 1000, ce qui vaut 16 en base d-
cimale : les bits sont dcals vers la droite ce qui quivaut multiplier par deux. De
mme, 7&2 scrit 1011&10 = 10, qui vaut 2 en base dcimale. Les oprateurs <<,
>>, |, & sont des oprateurs bit bit, ils se comprennent partir de la reprsentation
binaire des nombres entiers.
1. Les fonctions sont dfinies au paragraphe 3.4, plus simplement, ce sont des mini-programmes :
elles permettent de dcouper un programme long en tches plus petites. On les distingue des
variables car leur nom est suivi dune liste de constantes ou variables comprises entre parenthses
et spares par une virgule.
2. voir chapitre 5
oprateur signification exemple

<< >> dcalage gauche, droite x = 8 1 (rsultat = 16)
| oprateur logique ou bit bit x = 8|1 (rsultat = 9)
& oprateur logique et bit bit x = 11&2 (rsultat = 2)
+ - addition, soustraction x=y+z
+= -= addition ou soustraction puis affectation x += 3
* / multiplication, division x=yz
division entire, le rsultat est de type
// x = y//3
rel si lun des nombres est rel
% reste dune division entire (modulo) x = y%3
multiplication ou division puis affecta-
*= /= x *= 3
tion
puissance (entire ou non, racine carre
** x = y 3
= ** 0.5)
Les fonctions int et float permettent de convertir un nombre quelconque ou une

chane de caractres respectivement en un entier (arrondi) et en un nombre rel.
x = int (3.5)
y = float (3)
z = int ("3")
print "x:", type(x), " y:", type(y), " z:", type(z)
# affiche x: <type int> y: <type float> z: <type int>
Remarque 2.6 : conversion en nombre entier

Il peut arriver que la conversion en un nombre entier ne soit pas directe. Dans
lexemple qui suit, on cherche convertir une chane de caractres (voir para-
graphe 2.2.4) en entier mais cette chane reprsente un rel. Il faut dabord la
convertir en rel puis en entier, cest ce moment que larrondi sera effectu.
i = int ("3.5") # provoque une erreur
i = int (float ("3.5")) # fonctionne
Les oprateurs lists par le tableau ci-dessus ont des priorits diffrentes, tris par
ordre croissant 3 . Toutefois, il est conseill davoir recours aux parenthses pour
enlever les doutes : 3 2 4 = 3 (2 4).
Remarque 2.7 : division entire
Il existe un cas pour lequel cet oprateur cache un sens implicite : lorsque la division
opre sur deux nombres entiers ainsi que le montre lexemple suivant.
x = 11
y = 2
z = x / y # le rsultat est 5 et non 5.5 car la division est entire
Pour obtenir le rsultat juste incluant la partie dcimale, il faut convertir les entiers
en rels.
3. La page http://docs.python.org/reference/expressions.html#operator-summary est plus com-
plte ce sujet.
x = float (11)
y = float (2)
z = x / y # le rsultat est 5.5 car cest une division entre deux rels
Pour viter dcrire le type float, on peut galement crire 11.0/2 de faon spcifier
explicitement que la valeur 11.0 est relle et non entire. Loprateur // permet
deffectuer une division entire lorsque les deux nombres diviser sont rels, le
rsultat est un entier mais la variable est de type rel si lun des nombres est de type
rel.
2.2.3 Boolen
Les boolens sont le rsultat doprations logiques et ont deux valeurs possibles :
True ou False. Voici la liste des oprateurs qui sappliquent aux boolens.

and or et, ou logique x = True or False (rsultat = True)
not ngation logique x = not x
x = 4 < 5
print x # affiche True
print not x # affiche False
Voici la liste des oprateurs de comparaisons qui retournent des boolens. Ceux-
ci sapplique tout type, aux entiers, rels, chanes de caractres, t-uples... Une
comparaison entre un entier et une chane de caractres est syntaxiquement correcte
mme si le rsultat a peu dintrt.
< > infrieur, suprieur x=5<5
<= >= infrieur ou gal, suprieur ou gal x = 5 <= 5
== != gal, diffrent x = 5 == 5
A linstar des nombres rels, il est prfrable dutiliser les parenthses pour viter les
problmes de priorits doprateurs dans des expressions comme : 3 < x and x < 7.
Toutefois, pour cet exemple, Python accepte lcriture rsume qui enchane des
comparaisons : 3 < x and x < 7 est quivalent 3 < x < 7. Il existe deux autres mots-
cls qui retournent un rsultat de type boolen :
oprateur signification
is test didentification
in test dappartenance
Ces deux oprateurs seront utiliss ultrieurement, in avec les listes, les diction-
naires, les boucles (paragraphe 3.3.2), is lors de ltude des listes (paragraphe 2.3.2)
et des classes (chapitre 4). Bien souvent, les boolens sont utiliss de manire impli-
cite lors de tests (paragraphe 3.2.1) ce qui nempche pas de les dclarer explicite-
ment.
x = True
y = False
2.2.4 Chane de caractres

2.2.4.1 Cration dune chane de caractres
Dfinition 2.8 : chane de caractres

Le terme "chane de caractres" ou string en anglais signifie une suite finie de
caractres, autrement dit, du texte.
Ce texte est compris entre deux guillemets ou deux apostrophes, ces deux symboles
sont interchangeables. Lexemple suivant montre comment crer une chane de ca-
ractres. Il ne faut pas confondre la partie entre guillemets ou apostrophes, qui est
une constante, de la variable qui la contient.
t = "string = texte"
print type (t), t
t = string = texte, initialisation avec apostrophes
print type (t), t
t = "morceau 1" \
"morceau 2" # second morceau ajout au premier par lajout du symbole \,
# il ne doit rien y avoir aprs le symbole \,
# pas despace ni de commentaire
print t
t = """premire ligne
seconde ligne""" # chane de caractres qui stend sur deux lignes
print t
Le rsultat de ce petit programme est le suivant :

<type str> string = texte
<type str> string = texte, initialisation avec apostrophes
morceau 1morceau 2
premire ligne
seconde ligne
La troisime chane de caractres cre lors de ce programme stend sur deux lignes.
Il est parfois plus commode dcrire du texte sur deux lignes plutt que de le laisser
cach par les limites de fentres daffichage. Python offre la possibilit de couper le
texte en deux chanes de caractres recolles laide du symbole \ condition que ce
symbole soit le dernier de la ligne sur laquelle il apparat. De mme, lorsque le texte
contient plusieurs lignes, il suffit de les encadrer entre deux symboles """ ou pour
que linterprteur Python considre lensemble comme une chane de caractres et
non comme une srie dinstructions.
Par dfaut, le Python ne permet pas linsertion de caractres tels que les accents dans
les chanes de caractres, le paragraphe 1.5.2 (page 22) explique comment rsoudre
ce problme. De mme, pour insrer un guillemet dans une chane de caractres
encadre elle-mme par des guillemets, il faut le faire prcder du symbole \. La
squence \ est appele un extra-caractre (voir table 2.1).
Remarque 2.9 : prfixe "r", chane de caractres
Il peut tre fastidieux davoir doubler tous les symboles \ dun nom de fichier.
\ guillemet
\0 apostrophe
\n passage la ligne
\\ insertion du symbole \
\% pourcentage, ce symbole est aussi un caractre spcial
\t tabulation
\r retour la ligne, peu usit, il a surtout son importance lorsquon passe dun
systme Windows Linux car Windows lajoute automatiquement tous
ses fichiers textes
Table 2.1 : Liste des extra-caractres les plus couramment utiliss lintrieur dune chane
de caractres (voir page http:// docs.python.org/ reference/ lexical_analysis.html#strings).
Il est plus simple dans ce cas de prfixer la chane de caractres par r de faon
viter que lutilisation du symbole \ ne dsigne un caractre spcial. Les deux lignes
suivantes sont quivalentes :
s = "C:\\Users\\Dupre\\exemple.txt"
s = r"C:\Users\Dupre\exemple.txt"
Sans la lettre "r", tous les \ doivent tre doubls, dans le cas contraire, Python peut
avoir des effets indsirables selon le caractre qui suit ce symbole.
2.2.4.2 Manipulation dune chane de caractres
Une chane de caractres est semblable un tableau et certains oprateurs qui

sappliquent aux tableaux sappliquent galement aux chanes de caractres. Ceux-ci
sont regroups dans la table 2.2. La fonction str permet de convertir un nombre, un
tableau, un objet (voir chapitre 4) en chane de caractres afin de pouvoir lafficher.
La fonction len retourne la longueur de la chane de caractres.
x = 5.567
s = str (x)
print type(s), s # <type str> 5.567
print len(s) # affiche 5
Il existe dautres fonctions qui permettent de manipuler les chanes de caractres.
syntaxe 2.10 : fonctions et chanes de caractres

res = s.fonction (...)
O s est une chane de caractres, fonction est le nom de lopration que lon
veut appliquer s, res est le rsultat de cette manipulation.
La table 2.3 (page 38) prsente une liste non exhaustive des fonctions disponibles
dont un exemple dutilisation suit. Cette syntaxe variable.fonction(arguments) est
celle des classes 4 .
4. voir chapitre 4

concatnation de chanes de carac-
+ t = abc + def
tres
+= concatnation puis affectation t += "abc"
in, not in une chane en contient-elle une autre ? "ed" in "med"
rptition dune chane de caractres t = abc 4
obtention du nime caractre, le pre- t = abc
[n]
mier caractre a pour indice 0 print t[0] # donne a
obtention des caractres compris
t = abc
[i : j] entre les indices i et j 1 inclus, le
print t[0 : 2] # donne ab
premier caractre a pour indice 0
Table 2.2 : Oprations applicables aux chanes de caractres.
Retourne le nombre doccurrences de la chane de caractres

count( sub, les paramtres par dfaut st et end permettent de rduire
sub[, st la recherche entre les caractres dindice st et end exclu. Par
[, end]]) dfaut, st est nul tandis que end correspond la fin de la chane
de caractres.
find( Recherche une chane de caractres sub, les paramtres par d-
sub[, st faut st et end ont la mme signification que ceux de la fonction
[, end]]) count. Cette fonction retourne -1 si la recherche na pas abouti.
isalpha() Retourne True si tous les caractres sont des lettres, False sinon.
isdigit() Retourne True si tous les caractres sont des chiffres, False sinon.
Retourne une copie de la chane de caractres en remplaant
replace( toutes les occurrences de la chane old par new. Si le paramtre
old, new[, co]) optionnel co est renseign, alors seules les co premires occur-
rences seront remplaces.
Dcoupe la chane de caractres en se servant de la chane sep
split(
comme dlimiteur. Si le paramtre mspl est renseign, au plus
[sep[, mspl]])
mspl coupures seront effectues.
Supprime les espaces au dbut et en fin de chane. Si le paramtre
strip([s]) s est renseign, la fonction strip supprime tous les caractres
qui font partie de s au dbut et en fin de chane.
upper() Remplace les minuscules par des majuscules.
lower() Remplace les majuscules par des minuscules.
Fait la somme dun tableau de chanes de caractres (une liste ou
un T-uple). La chane de caractres sert de sparateur qui doit
join(words)
tre ajout entre chaque lment du tableau words. Un exemple
de cette fonction figure en page 39.
Table 2.3 : Quelques fonctions sappliquant aux chanes de caractres, laide associe au
langage Python fournira la liste complte (voir page http:// docs.python.org/ library/ stdtypes.
html ). Certains des paramtres sont encadrs par des crochets, ceci signifie quils sont fa-
cultatifs.
st = "langage python"
st = st.upper () # mise en lettres majuscules
i = st.find ("PYTHON") # on cherche "PYTHON" dans st
print i # affiche 8
print st.count ("PYTHON") # affiche 1
print st.count ("PYTHON", 9) # affiche 0
Lexemple suivant permet de retourner une chane de caractres contenant plusieurs

lments spars par ; . La chane un; deux; trois doit devenir trois; deux; un.
On utilise pour cela les fonctionnalits split et join (voir table 2.3). Lexemple
utilise galement la fonctionnalit reverse des listes qui seront dcrites plus loin
dans ce chapitre. Il faut simplement retenir quune liste est un tableau. reverse
retourne le tableau.
s = "un;deux;trois"
mots = s.split (";") # mots est gal [un, deux, trois]
mots.reverse () # retourne la liste, mots devient gal
# [trois, deux, un]
s2 = ";".join (mots) # concatnation des lments de mots spars par ";"
print s2 # affiche trois;deux;un
2.2.4.3 Formatage dune chane de caractres
Python offre une manire plus concise de former une chane de caractres laide de
plusieurs types dinformations en vitant la conversion explicite de ces informations
(fonction str) et leur concatnation. Il est particulirement intressant pour les
nombres rels quil est possible dcrire en imposant un nombre de dcimales fixe.
Le format est le suivant :
syntaxe 2.11 : chane de caractres, formatage

".... %c1 .... %c2 " % (v1,v2)
c1 est un code choisi parmi ceux de la table 2.4 (page 40). Il indique le format
dans lequel la variable v1 devra tre transcrite. Il en est de mme pour le
code c2 associ la variable v2. Les codes insrs dans la chane de caractres
seront remplacs par les variables cites entre parenthses aprs le symbole %
suivant la fin de la chane de caractres. Il doit y avoir autant de codes que de
variables, qui peuvent aussi tre des constantes.
Voici concrtement lutilisation de cette syntaxe :

x = 5.5
d = 7
s = "caractres"
res = "un nombre rel %f et un entier %d, une chane de %s, \n" \
"un rel dabord converti en chane de caractres %s" % (x,d,s, str(x+4))
print res
res = "un nombre rel " + str (x) + " et un entier " + str (d) + \
", une chane de " + s + \
",\n un rel dabord converti en chane de caractres " + str(x+4)
print res
La seconde affectation de la variable res propose une solution quivalente la pre-

mire en utilisant loprateur de concatnation +. Les deux solutions sont quiva-
lentes, tout dpend des prfrences de celui qui crit le programme.
un nombre rel 5.500000 et un entier 7, une chane de caractres,
un rel dabord converti en chane de caractres 9.5
un nombre rel 5.5 et un entier 7, une chane de caractres,
un rel dabord converti en chane de caractres 9.5
La premire option permet nanmoins un formatage plus prcis des nombres rels
en imposant par exemple un nombre dfini de dcimal. Le format est le suivant :
syntaxe 2.12 : chane de caractres, formatage des nombres

"%n.df" % x
o n est le nombre de chiffres total et d est le nombre de dcimales, f dsigne

un format rel indiqu par la prsence du symbole %
x = 0.123456789
print x # affiche 0.123456789
print "%1.2f" % x # affiche 0.12
print "%06.2f" % x # affiche 000.12
Il existe dautres formats regroups dans la table 2.4. Laide reste encore le meilleur
rflexe car le langage Python est susceptible dvoluer et dajouter de nouveaux
formats.
d entier relatif
e nombre rel au format exponentiel
f nombre rel au format dcimal
nombre rel, format dcimal ou exponentiel si la puissance est trop grande ou
g
trop petite
s chane de caractres
Table 2.4 : Liste non exhaustive des codes utiliss pour formater des informations dans
une chane de caractres (voir page http:// docs.python.org/ library/ stdtypes.html ).
2.2.5 T-uple
Dfinition 2.13 : T-uple

Les T-uple sont un tableau dobjets qui peuvent tre de tout type. Ils ne sont
pas modifiables.
Un T-uple apparat comme une liste dobjets comprise entre parenthses et spars
par des virgules. Leur cration reprend le mme format :
x = (4,5) # cration dun T-uple compos de 2 entiers
x = ("un",1,"deux",2) # cration dun T-uple compos de 2 chanes de caractres
# et de 2 entiers, lordre dcriture est important

x = (3,) # cration dun T-uple dun lment, sans la virgule,
# le rsultat est un entier
Ces objets sont des vecteurs dobjets. Il est possible deffectuer les oprations re-
groupes dans la table 2.5. Etant donn que les chanes de caractres sont galement
des tableaux, ces oprations reprennent en partie celles de la table 2.2.
x in s vrai si x est un des lments de s

x not in s rciproque de la ligne prcdente
s+t concatnation de s et t
sn concatne n copies de s les unes la suite des autres
s[i] retourne le ime lment de s
retourne un T-uple contenant une copie des lments de s dindices i
s[i : j]
j exclu.
retourne un T-uple contenant une copie des lments de s dont les
s[i : j : k] indices sont compris entre i et j exclu, ces indices sont espacs de k :
i, i + k, i + 2k, i + 3k, ...
len(s) nombre dlments de s
plus petit lment de s, rsultat difficile prvoir lorsque les types
min(s)
des lments sont diffrents
max(s) plus grand lment de s
sum(s) retourne la somme de tous les lments
Table 2.5 : Oprations disponibles sur les T-uples, on suppose que s et t sont des T-uples,
x est quant lui quelconque.
Remarque 2.14 : T-uple, oprateur []

Les T-uples ne sont pas modifiables, cela signifie quil est impossible de modifier un
de leurs lments. Par consquent, la ligne daffectation suivante nest pas correcte :
a = (4,5)
a [0] = 3 # dclenche une erreur dexcution
Le message derreur suivant apparat :

Traceback (most recent call last):
File "<pyshell#78>", line 1, in -toplevel-
a[0]=3
TypeError: object doesnt support item assignment
Pour changer cet lment, il est possible de sy prendre de la manire suivante :

a = (4,5)
a = (3,) + a[1:2] # cre un T-uple dun lment concatn
# avec la partie inchange de a
2.2.6 Autres types

Il existe dautres types comme le type complex permettant de reprsenter les nombres
complexes. Ce type numrique suit les mmes rgles et fonctionne avec les mmes
oprateurs (except les oprateurs de comparaisons) que ceux prsents au para-

graphe 2.2.2 et dcrivant les nombres.
print complex (1,1) # affiche (1+1j)
Le langage Python offre la possibilit de crer ses propres types immuables 5 mais
ils seront dfinis partir des types immuables prsents jusquici.
2.3 Types modifiables (ou mutable)

Les types modifiables sont des conteneurs (ou containers en anglais) : ils contiennent
dautres objets, que ce soit des nombres, des chanes de caractres ou des objets de
type modifiable. Plutt que davoir dix variables pour dsigner dix objets, on en
nutilise quune seule qui dsigne ces dix objets.
Dfinition 2.15 : type modifiable (ou mutable)

Une variable de type modifiable peut tre modifie, elle conserve le mme type
et le mme identificateur. Cest uniquement son contenu qui volue.
2.3.1 Liste
2.3.1.1 Dfinition et fonctions
Dfinition 2.16 : liste

Les listes sont des collections dobjets qui peuvent tre de tout type. Elles sont
modifiables.
Une liste apparat comme une succession dobjets compris entre crochets et spars
par des virgules. Leur cration reprend le mme format :
x = [4,5] # cration dune liste compose de deux entiers

x = ["un",1,"deux",2] # cration dune liste compose de
# deux chanes de caractres
# et de deux entiers, lordre dcriture est important
x = [3,] # cration dune liste dun lment, sans la virgule,
# le rsultat reste une liste
x = [ ] # cre une liste vide
x = list () # cre une liste vide
y = x [0] # accde au premier lment
y = x [-1] # accde au dernier lment
Ces objets sont des listes chanes dautres objets de type quelconque (immuable ou
modifiable). Il est possible deffectuer les oprations regroupes dans la table 2.6.
Ces oprations reprennent celles des T-uples (voir table 2.5) et incluent dautres
fonctionnalits puisque les listes sont modifiables (voir table 2.6). Il est donc possible
5. voir le paragraphe 4.7
dinsrer, de supprimer des lments, de les trier. La syntaxe des oprations sur les
listes est similaire celle des oprations qui sappliquent sur les chanes de caractres,
elles sont prsentes par la table 2.7.
x in l vrai si x est un des lments de l

x not in l rciproque de la ligne prcdente
l+t concatnation de l et t
ln concatne n copies de l les unes la suite des autres
retourne llment ime lment de l, la diffrence des T-uples,
l[i] linstruction l[i] = a est valide, elle remplace llment i par a.
Un indice ngatif correspond la position len(l) + i.
retourne une liste contenant les lments de l dindices i j exclu. Il
est possible de remplacer cette sous-liste par une autre en utilisant
l[i : j]
laffectation l[i : j] = l2 o l2 est une autre liste (ou un T-uple) de
dimension diffrente ou gale.
retourne une liste contenant les lments de l dont les indices sont
compris entre i et j exclu, ces indices sont espacs de k : i, i + k, i +
l[i : j : k] 2k, i + 3k, ... Ici encore, il est possible dcrire laffectation suivante :
l[i : j : k] = l2 mais l2 doit tre une liste (ou un T-uple) de mme
dimension que l[i : j : k].
len(l) nombre dlments de l
plus petit lment de l, rsultat difficile prvoir lorsque les types
min(l)
des lments sont diffrents
max(l) plus grand lment de l
sum(l) retourne la somme de tous les lments
supprime les lments dindices entre i et j exclu. Cette instruction
del l[i : j]
est quivalente l[i : j] = [].
list(x) convertit x en une liste quand cela est possible
Table 2.6 : Oprations disponibles sur les listes, identiques celles des T-uples, on suppose
que l et t sont des listes, i et j sont des entiers. x est quant lui quelconque.
2.3.1.2 Exemples
Lexemple suivant montre une utilisation de la mthode sort.

x = [9,0,3,5,4,7,8] # dfinition dune liste
print x # affiche cette liste
x.sort () # trie la liste par ordre croissant
print x # affiche la liste trie
Voici les deux listes affiches par cet exemple :

[9, 0, 3, 5, 4, 7, 8]
[0, 3, 4, 5, 7, 8, 9]
Pour classer les objets contenus par la liste mais selon un ordre diffrent, il faut
dfinir une fonction qui dtermine un ordre entre deux lments de la liste. Cest la
fonction compare de lexemple suivant.
Retourne le nombre doccurrences de llment x. Cette notation

l.count(x) suit la syntaxe des classes dveloppe au chapitre 4. count est
une mthode de la classe list.
Retourne lindice de la premire occurrence de llment x dans
l.index(x) la liste l. Si celle-ci nexiste pas, une exception est dclenche
(voir le paragraphe 5 ou lexemple page 45).
Ajoute llment x la fin de la liste l. Si x est une liste, cette
l.append(x) fonction ajoute la liste x en tant qulment, au final, la liste l
ne contiendra quun lment de plus.
Ajoute tous les lments de la liste k la liste l. La liste l aura
l.extend(k)
autant dlments supplmentaires quil y en a dans la liste k.
l.insert(i, x) Insre llment x la position i dans la liste l.
Supprime la premire occurrence de llment x dans la liste l.
l.remove(x) Sil ny a aucune occurrence de x, cette mthode dclenche une
exception.
Retourne llment l[i] et le supprime de la liste. Le paramtre
l.pop([i]) i est facultatif, sil nest pas prcis, cest le dernier lment qui
est retourn puis supprim de la liste.
Retourne la liste, le premier et dernier lment change leurs
l.reverse(x)
places, le second et lavant dernier, et ainsi de suite.
Cette fonction trie la liste par ordre croissant. Le paramtre f
est facultatif, il permet de prciser la fonction de comparaison
qui doit tre utilise lors du tri. Cette fonction prend comme
l.sort([f, rev])
paramtre deux lments x et y de la liste et retourne les valeurs
-1,0,1 selon que x < y, x == y ou x > y (voir paragraphe 3.4). Si
rev est True, alors le tri est dcroissant.
Table 2.7 : Oprations permettant de modifier une liste on suppose que l est une liste, x
est quant lui quelconque.
def compare (x,y): # cre une fonction

if x > y : return -1 # qui retourne -1 si x<y,
elif x == y : return 0 # 0 si x == y
else : return 1 # 1 si x < y
x.sort (compare) # trie la liste x laide de la fonction compare

# cela revient la trier par ordre dcroissant
print x
Le programme affiche cette fois-ci la ligne :

[9, 8, 7, 5, 4, 3, 0]
Lexemple suivant illustre un exemple dans lequel on essaye daccder lindice dun
lment qui nexiste pas dans la liste :
x = [9,0,3,5,0]
print x.index (1) # cherche la position de llment 1
Comme cet lment nexiste pas, on dclenche ce quon appelle une exception qui
se traduit par laffichage dun message derreur. Le message indique le nom de lex-
ception gnre (ValueError) ainsi quun message dinformation permettant en rgle
gnrale de connatre lvnement qui en est la cause.
File "c:/temp/temp", line 2, in -toplevel-
print x.index(1)
ValueError: list.index(x): x not in list
Pour viter cela, on choisit dintercepter lexception (voir paragraphe 5).

x = [9,0,3,5,0]
try: print x.index(1)
except ValueError: print "1 nest pas prsent dans la liste x"
else: print "trouv"
Ce programme a pour rsultat :

1 nest pas prsent dans la liste x
2.3.1.3 Fonctions range, xrange
Les listes sont souvent utilises dans des boucles ou notamment par lintermdiaire
de la fonction range. Cette fonction retourne une liste dentiers.
syntaxe 2.17 : range

range (debut, fin [,marche])
Retourne une liste incluant tous les entiers compris entre debut et fin exclu.
Si le paramtre facultatif marche est renseign, la liste contient tous les entiers
n compris debut et fin exclu et tels que n debut soit un multiple de marche.
Exemple :
print range (0,10,2) # affiche [0, 2, 4, 6, 8]
La fonction xrange est dun usage quivalent range. Elle permet de parcourir une
liste dentiers sans la crer vraiment. Elle est plus rapide.
print xrange (0,10,2) # affiche xrange(0,10,2)
Cette fonction est souvent utilise lors de boucles 6 pour parcourir tous les l-
ments dun T-uple, dune liste, dun dictionnaire... Le programme suivant permet
par exemple de calculer la somme de tous les entiers impairs compris entre 1 et 20 ex-
clu.
s = 0
for n in range (1,20,2) : # ce programme est quivalent
s += n # s = sum (range(1,20,2))
6. voir paragraphe 3.3.2

Le programme suivant permet dafficher tous les lments dune liste.
x = ["un", 1, "deux", 2, "trois", 3] x [0] = un

for n in range (0, len(x)) : x [1] = 1
print "x [%d] = %s" % (n, x [n]) x [2] = deux
x [3] = 2
# le rsultat est prsent droite x [4] = trois
x [5] = 3
2.3.1.4 Boucles et listes
Il est possible aussi de ne pas se servir des indices comme intermdiaires pour accder
aux lments dune liste quand il sagit deffectuer un mme traitement pour tous
les lments de la liste x.
x = ["un", 1, "deux", 2]
for el in x :
print "la liste inclut : ", el
Linstruction for el in x : se traduit littralement par : pour tous les lments de la

liste, faire... Ce programme a pour rsultat :
la liste inclut : un
la liste inclut : 1
la liste inclut : deux
la liste inclut : 2
Il existe galement des notations abrges lorsquon cherche construire une liste
partir dune autre. Le programme suivant construit la liste des entiers de 1 5
partir du rsultat retourn par la fonction range.
y = list ()
for i in range(0,5) : y.append (i+1)
print y # affiche [1,2,3,4,5]
Le langage Python offre la possibilit de rsumer cette criture en une seule ligne.
Cette syntaxe sera reprise au paragraphe 3.3.2.2.
y = [ i+1 for i in range (0,5)]
Cette dfinition de liste peut galement inclure des tests ou des boucles imbriques.
y = [ i for i in range(0,5) if i % 2 == 0] # slection les lments pairs

print y # affiche [0,2,4]
z = [ i+j for i in range(0,5) \
for j in range(0,5)] # construit tous les nombres i+j possibles
print z # affiche [0, 1, 2, 3, 4, 1, 2, 3, 4, 5, 2,
# 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8]
2.3.1.5 Collage de squences, fonction zip
On suppose quon dispose de n squences dlments (T-uple, liste), toutes de lon-

gueur l. La fonction zip permet de construire une liste de T-uples qui est la jux-
taposition de toutes ces squences. Le iime T-uple de la liste rsultante contiendra
tous les iime lments des squences juxtaposes. Si les longueurs des squences sont
diffrentes, la liste rsultante aura mme taille que la plus courte des squences.
a = (1,0,7,0,0,0)
b = [2,2,3,5,5,5]
c = [ "un", "deux", "trois", "quatre" ]
d = zip (a,b,c)
print d # affiche [(1, 2, un), (0, 2, deux),
# (7, 3, trois), (0, 5, quatre)]
2.3.1.6 Concatnation de chane de caractres
Il arrive frquemment de constuire une chane de caractres petits bouts par pe-
tits bouts comme le montre le premier exemple ci-dessous. Cette construction peut
savrer trs lente lorsque le rsultat est long. Dans ce cas, il est nettement plus
rapide dajouter chaque morceau dans une liste puis de les concatner en une seule
fois grce la mthode join.
s = "" s = []
while <condition> : s += ... while <condition> : s.append ( ... )
s = "".join (s)
2.3.2 Copie
A linverse des objets de type immuable, une affectation ne signifie pas une copie.
Afin dviter certaines oprations superflues et parfois coteuses en temps de trai-
tement, on doit distinguer la variable de son contenu. Une variable dsigne une liste
avec un mot (ou identificateur), une affection permet de crer un second mot pour
dsigner la mme liste. Il est alors quivalent de faire des oprations avec le premier
mot ou le second comme le montre lexemple suivant avec les listes l et l2.
l = [4,5,6]
l2 = l
print l # affiche [4,5,6]
print l2 # affiche [4,5,6]
l2 [1] = "modif"
print l # affiche [4, modif, 6]
print l2 # affiche [4, modif, 6]
Dans cet exemple, il nest pas utile de crer une seconde variable, dans le suivant,
cela permet quelques raccourcis.
l = [[0,1], [2,3]]
l1 = l [0]
l1 [0] = "modif" # ligne quivalente : l [0][0] = "modif"
Par consquent, lorsquon affecte une liste une variable, celle-ci nest pas recopie,
la liste reoit seulement un nom de variable. Laffectation est en fait lassociation
dun nom avec un objet (voir paragraphe 4.6). Pour copier une liste, il faut utili-
ser la fonction copy du module copy 7 . Ce point sera rappel au paragraphe 4.6.3
(page 118).
import copy
l = [4,5,6]
l2 = copy.copy(l)
print l2 # affiche [4,5,6]
l2 [1] = "modif"
print l2 # affiche [4, modif, 6]
Loprateur == permet de savoir si deux listes sont gales mme si lune est une
copie de lautre. Le mot-cl is permet de vrifier si deux variables font rfrence la
mme liste ou si lune est une copie de lautre comme le montre lexemple suivant :
import copy
l = [1,2,3]
l2 = copy.copy (l)
l3 = l
print l == l2 # affiche True

print l is l2 # affiche False
print l is l3 # affiche True
Remarque 2.18 : fonction copy et deepcopy

Le comportement de la fonction copy peut surprendre dans le cas o une liste
contient dautres listes. Pour tre sr que chaque lment dune liste a t cor-
rectement recopie, il faut utiliser la fonction deepcopy. La fonction est plus longue
mais elle recopie toutes les listes que ce soit une liste incluse dans une liste elle-mme
incluse dans une autre liste elle-mme incluse...
import copy
l = [[1,2,3],[4,5,6]]
l2 = copy.copy (l)
l3 = copy.deepcopy (l)
l [0][0] = 1111
print l # affiche [[1111, 2, 3], [4, 5, 6]]
print l2 # affiche [[1111, 2, 3], [4, 5, 6]]
print l3 # affiche [[1, 2, 3], [4, 5, 6]]
print l is l2 # affiche False
print l [0] is l2 [0] # affiche True
print l [0] is l3 [0] # affiche False
La fonction deepcopy est plus lente excuter car elle prend en compte les rfrences
rcursives comme celles de lexemple suivant o deux listes se contiennent lune
lautre.
7. Le module copy est une extension interne. Cest une librairie de fonctions dont la fonction
copy. Cette syntaxe sera vue au chapitre 6.
l = [1,"a"]
ll = [l,3] # ll contient l
l [0] = ll # l contient ll
print l # affiche [[[...], 3], a]
print ll # affiche [[[...], a], 3]
import copy
z = copy.deepcopy (l)
print z # affiche [[[...], 3], a]
2.3.3 Dictionnaire
Les dictionnaires sont des tableaux plus souples que les listes. Une liste rfrence les
lments en leur donnant une position : la liste associe chaque lment une position
entire comprise entre 0 et n 1 si n est la longueur de la liste. Un dictionnaire
permet dassocier un lment autre chose quune position entire : ce peut tre un
entier, un rel, une chane de caractres, un T-uple contenant des objets immuables.
Dune manire gnrale, un dictionnaire associe une valeur ce quon appelle une
cl de type immuable. Cette cl permettra de retrouver la valeur associe.
Lavantage principal des dictionnaires est la recherche optimise des cls. Par
exemple, on recense les noms des employs dune entreprise dans une liste. On sou-
haite ensuite savoir si une personne ayant un nom prcis lavance appartient
cette liste. Il faudra alors parcourir la liste jusqu trouver ce nom ou parcourir
toute la liste si jamais celui-ci ne sy trouve pas 8 . Dans le cas dun dictionnaire,
cette recherche du nom sera beaucoup plus rapide crire et excuter.
2.3.3.1 Dfinition et fonctions
Dfinition 2.19 : dictionnaire

Les dictionnaires sont des listes de couples. Chaque couple contient une cl et
une valeur. Chaque valeur est indice par sa cl. La valeur peut-tre de tout
type, la cl doit tre de type immuable, ce ne peut donc tre ni une liste, ni
un dictionnaire. Chaque cl comme chaque valeur peut avoir un type diffrent
des autres cls ou valeurs.
Un dictionnaire apparat comme une succession de couples dobjets comprise entre

accolades et spars par des virgules. La cl et sa valeur sont spares par le sym-
bole :. Leur cration reprend le mme format :
x = { "cle1":"valeur1", "cle2":"valeur2" }
y = { } # cre un dictionnaire vide
z = dict () # cre aussi un dictionnaire vide
Les indices ne sont plus entiers mais des chanes de caractres pour cet exemple.
Pour associer la valeur la cl "cle1", il suffit dcrire :
8. voir galement le paragraphe 3.7.1, page 88
print x ["cle1"]
La plupart des fonctions disponibles pour les listes sont interdites pour les diction-
naires comme la concatnation ou lopration de multiplication (). Il nexiste plus
non plus dindices entiers pour reprer les lments, le seul repre est leur cl. La
table 2.8 dresse la liste des oprations simples sur les dictionnaires tandis que la
table 2.9 dresse la liste des mthodes plus complexes.
x in d vrai si x est une des cls de d

x not in d rciproque de la ligne prcdente
d[i] retourne llment associ la cl i
len(d) nombre dlments de d
min(d) plus petite cl
max(d) plus grande cl
del d[i] supprime llment associ la cl i
list(d) retourne une liste contenant toutes les cls du dictionnaire d.
convertit x en un dictionnaire si cela est possible, d est alors gal
dict(x)
dict(d.items())
Table 2.8 : Oprations disponibles sur les dictionnaires, d est un dictionnaire, x est quant
lui quelconque.
d.copy() Retourne une copie de d.

d.has_key(x) Retourne True si x est une cl de d.
Retourne une liste contenant tous les couples (cl, valeur) inclus
d.items()
dans le dictionnaire.
d.keys() Retourne une liste contenant toutes les cls du dictionnaire d.
Retourne une liste contenant toutes les valeurs du dictionnaire
d.values()
d.
d.iteritems() Retourne un itrateur sur les couples (cl, valeur).
d.iterkeys() Retourne un itrateur sur les cls.
d.itervalues() Retourne un itrateur sur les valeurs.
Retourne d[k], si la cl k est manquante, alors la valeur None est
d.get(k[, x]) retourne moins que le paramtre optionnel x soit renseign,
auquel cas, ce sera ce paramtre qui sera retourn.
d.clear() Supprime tous les lments du dictionnaire.
d.update(d2) Le dictionnaire d reoit le contenu de d2.
d.setdefault(
Dfinit d[k] si la cl k existe, sinon, lui affecte x d[k].
k[, x])
d.popitem() Retourne un lment et le supprime du dictionnaire.
Table 2.9 : Mthodes associes aux dictionnaires, d, d2 sont des dictionnaires, x est quant
lui quelconque.
Contrairement une liste, un dictionnaire ne peut tre tri car sa structure interne
est optimise pour effectuer des recherches rapides parmi les lments. On peut aussi
se demander quel est lintrt de la mthode popitem qui retourne un lment puis le
supprime alors quil existe le mot-cl del. Cette mthode est simplement plus rapide
car elle choisit chaque fois llment le moins coteux supprimer, surtout lorsque
le dictionnaire est volumineux.
Les itrateurs sont des objets qui permettent de parcourir rapidement un diction-
naire, ils seront dcrits en dtail au chapitre 4 sur les classes. Un exemple de leur
utilisation est prsent dans le paragraphe suivant.
2.3.3.2 Exemples
Il nest pas possible de trier un dictionnaire. Lexemple suivant permet nanmoins

dafficher tous les lments dun dictionnaire selon un ordre croissant des cls. Ces
exemples font appel aux paragraphes sur les boucles (voir chapitre 3).
d = { "un":1, "zro":0, "deux":2, "trois":3, "quatre":4, "cinq":5, \
"six":6, "sept":1, "huit":8, "neuf":9, "dix":10 }
key = d.keys ()
key.sort ()
for k in key:
print k,d [k]
Lexemple suivant montre un exemple dutilisation des itrateurs. Il sagit de

construire un dictionnaire invers pour lequel les valeurs seront les cls et rcipro-
quement.
d = { "un":1, "zero":0, "deux":2, "trois":3, "quatre":4, "cinq":5, \
dinv = { } # cration dun dictionnaire vide, on parcout

for key,value in d.items () : # les lments du dictionnaire comme si
# ctait une liste de 2-uple (cl,valeur)
dinv [value] = key # on retourne le dictionnaire
print dinv # affiche {0: zero, 1: un, 2: deux,

# 3: trois, 4: quatre, 5: cinq, 6: six,
# 8: huit, 9: neuf, 10: dix}
Pour tre plus efficace, on peut remplacer la ligne for key, value in d.items() : par :
for key, value in d.iteritems() :. De cette manire, on parcourt les lments du dic-
tionnaire sans crer de liste intermdiaire. Il est quivalent dutiliser lune ou lautre
au sein dune boucle mme si le programme suivant montre une diffrence.
d = { "un":1, "zero":0, "deux":2, "trois":3, "quatre":4, "cinq":5, \
print d.items ()
print d.iteritems ()
Il a pour rsultat :
[(trois, 3), (sept, 1), (neuf, 9), (six, 6), (zero, 0),
(un, 1), (dix, 10), (deux, 2), (huit, 8), (quatre, 4),
(cinq, 5)]
<dictionary-itemiterator object at 0x0115DC40>

Remarque 2.20 : modification dun dictionnaire dans une boucle

Dune manire gnrale, il faut viter dajouter ou de supprimer un lment dans une
liste ou un dictionnaire quon est en train de parcourir au sein dune boucle for ou
while. Cela peut marcher mais cela peut aussi aboutir des rsultats imprvisibles
surtout avec lutilisation ditrateurs (fonction iteritems, itervalues, iterkeys). Il
est prfrable de terminer le parcours de la liste ou du dictionnaire puis de faire les
modifications dsires une fois la boucle termine. Dans le meilleur des cas, lerreur
suivante survient :
File "essai.py", line 6, in <module>
for k in d :
RuntimeError: dictionary changed size during iteration
2.3.3.3 Copie
A linstar des listes (voir paragraphe 2.3.2), les dictionnaires sont des objets et une
affectation nest pas quivalente une copie comme le montre le programme suivant.
d = {4:4,5:5,6:6}
d2 = d
print d # affiche {4: 4, 5: 5, 6: 6}
print d2 # affiche {4: 4, 5: 5, 6: 6}
d2 [5] = "modif"
print d # affiche {4: 4, 5: modif, 6: 6}
print d2 # affiche {4: 4, 5: modif, 6: 6}
Lorsquon affecte une liste une variable, celle-ci nest pas recopie, la liste reoit
seulement un nom de variable. Laffectation est en fait lassociation dun nom avec
un objet (voir paragraphe 4.6). Pour copier une liste, il faut utiliser la fonction copy
du module copy.
d = {4:4,5:5,6:6}
import copy
d2 = copy.copy(l)
print d # affiche {4: 4, 5: 5, 6: 6}
print d2 # affiche {4: 4, 5: 5, 6: 6}
d2 [5] = "modif"
print d # affiche {4: 4, 5: 5, 6: 6}
print d2 # affiche {4: 4, 5: modif, 6: 6}
Le mot-cl is a la mme signification pour les dictionnaires que pour les listes,
lexemple du paragraphe 2.3.2 (page 47) est aussi valable pour les dictionnaires. Il
en est de mme pour la remarque concernant la fonction deepcopy. Cette fonction
recopie les listes et les dictionnaires.
2.3.3.4 Cls de type modifiable
Ce paragraphe concerne davantage des utilisateurs avertis qui souhaitent malgr tout
utiliser des cls de type modifiable. Dans lexemple qui suit, la cl dun dictionnaire
est galement un dictionnaire et cela provoque une erreur. Il en serait de mme si
la variable k utilise comme cl tait une liste.
k = { 1:1}
d = { }
File "cledict.py", line 3, in <module>
d [k] = 0
d [k] = 0
TypeError: dict objects are unhashable
Cela ne veut pas dire quil faille renoncer utiliser un dictionnaire ou une liste comme
cl. La fonction id permet dobtenir un entier qui identifie de manire unique tout
objet. Le code suivant est parfaitement correct.
k = { 1:1}
d = { }
d [id (k)] = 0
Toutefois, ce nest pas parce que deux dictionnaires auront des contenus identiques
que leurs identifiants retourns par la fonction id seront gaux. Cest ce qui explique
lerreur que provoque la dernire ligne du programme suivant.
k = {1:1}
d = { }
d [id (k)] = 0
b = k
print d [id(b)] # affiche bien zro
c = {1:1}
print d [id(c)] # provoque une erreur car mme si k et c ont des contenus gaux,
# ils sont distincts, la cl id(c) nexiste pas dans d
Il existe un cas o on peut se passer de la fonction id mais il inclut la notion de classe

dfinie au chapitre 4. Lexemple suivant utilise directement linstance k comme cl.
En affichant le dictionnaire d, on vrifie que la cl est lie au rsultat de linstruction
id(k) mme si ce nest pas la cl.
class A : pass
k = A ()
d = { }
d [k] = 0
print d # affiche {<__main__.A object at 0x0120DB90>: 0}
print id (k), hex(id(k)) # affiche 18930576, 0x120db90
print d [id(k)] # provoque une erreur
La fonction hex convertit un entier en notation hexadcimale. Les nombres affichs

changent chaque excution. Pour conclure, ce dernier exemple montre comment
se passer de la fonction id dans le cas dune cl de type dictionnaire.
class A (dict):
def __hash__(self):
return id(self)
k = A ()
k ["t"]= 4
d = { }
d [k] = 0
print d # affiche {{t: 4}: 0}
2.4 Extensions
2.4.1 Mot-cl print, repr, conversion en chane de caractres
Le mot-cl print est dj apparu dans les exemples prsents ci-dessus, il per-
met dafficher une ou plusieurs variables pralablement dfinies, spares par des
virgules. Les paragraphes qui suivent donnent quelques exemples dutilisation. La
fonction print permet dafficher nimporte quelle variable ou objet lcran, cet af-
fichage suppose la conversion de cette variable ou objet en une chane de caractres.
Deux fonctions permettent deffectuer cette tape sans toutefois afficher le rsultat
lcran.
La fonction str (voir paragraphe 2.2.4.2) permet de convertir toute variable en
chane de caractres. Il existe cependant une autre fonction repr, qui effectue cette
conversion. Dans ce cas, le rsultat peut tre interprt par la fonction eval (voir
paragraphe 2.4.2) qui se charge de la conversion inverse. Pour les types simples
comme ceux prsents dans ce chapitre, ces deux fonctions retournent des rsultats
identiques. Pour lexemple, x dsigne nimporte quelle variable.
x == eval (repr(x)) # est toujours vrai (True)
x == eval (str (x)) # nest pas toujours vrai
2.4.2 Fonction eval

Comme le suggre le paragraphe prcdent, la fonction eval permet dvaluer une
chane de caractres ou plutt de linterprter comme si ctait une instruction en
Python. Le petit exemple suivant permet de tester toutes les oprations de calcul
possibles entre deux entiers.
x = 32
y = 9
op = "+ - * / % // & | and or << >>".split ()
for o in op :
s = str (x) + " " + o + " " + str (y)
print s, " = ", eval (s)
Ceci aboutit au rsultat suivant :

32 + 9 = 41
32 - 9 = 23
32 * 9 = 288
32 / 9 = 3
32 % 9 = 5
32 // 9 = 3
32 & 9 = 0
32 | 9 = 41
32 and 9 = 9
32 or 9 = 32
32 << 9 = 16384
32 >> 9 = 0
Le programme va crer une chane de caractres pour chacune des oprations et celle-
ci sera value grce la fonction eval comme si ctait une expression numrique.
Il faut bien sr que les variables que lexpression mentionne existent durant son
valuation.
2.4.3 Informations fournies par Python

Bien que les fonctions ne soient dfinies que plus tard (paragraphe 3.4), il peut tre
intressant de mentionner la fonction dir qui retourne la liste de toutes les variables
cres et accessibles cet instant du programme. Lexemple suivant :
x = 3
print dir ()
Retourne le rsultat suivant :

[__builtins__, __doc__, __file__, __name__, x]
Certaines variables - des chanes des caractres - existent dj avant mme la pre-
mire instruction. Elles contiennent diffrentes informations concernant lenvironne-
ment dans lequel est excut le programme Python :
Ce module contient tous les lments prsents ds le dbut dun

__builtins__ programme Python, il contient entre autres les types prsents
dans ce chapitre et des fonctions simples comme range.
Cest une chane commentant le fichier, cest une chane de
__doc__ caractres insre aux premires lignes du fichiers et souvent
entoure des symboles (voir chapitre 6).
__file__ Contient le nom du fichier o est crit ce programme.
__name__ Contient le nom du module.
La fonction dir est galement pratique pour afficher toutes les fonctions dun module.
Linstruction dir(sys) affiche la liste des fonctions du module sys (voir chapitre 6).
Remarque 2.21 : fonction dir
La fonction dir appele sans argument donne la liste des fonctions et variables dfi-
nies cet endroit du programme. Ce rsultat peut varier selon quon se trouver dans
une fonction, une mthode de classe ou lextrieur du programme. Linstruction
dir([]) donne la liste des mthodes qui sappliquent une liste.
De la mme manire, la fonction type retourne une information concernant le type
dune variable.
x = 3
print x, type(x) # affiche 3 <type int>
x = 3.5
print x, type(x) # affiche 3.5 <type float>
2.4.4 Affectations multiples

Il est possible deffectuer en Python plusieurs affectations simultanment.
x = 5 # affecte 5 x
y = 6 # affecte 6 y
x,y = 5,6 # affecte en une seule instruction 5 x et 6 y
Cette particularit reviendra lorsque les fonctions seront dcrites puisquil est pos-
sible quune fonction retourne plusieurs rsultats comme la fonction divmod illustre
par le programme suivant.
x,y = divmod (17,5)
print x,y # affiche 3 2
print "17 / 5 = 5 * ", x, " + ",y # affiche 17 / 5 = 5 * 3 + 2
Le langage Python offre la possibilit deffectuer plusieurs affectations sur la mme

ligne. Dans lexemple qui suit, le couple (5, 5) est affect la variable point, puis le
couple x, y reoit les deux valeurs du T-uple point.
x,y = point = 5,5
2.4.5 Type long

Le type long permet dcrire des entiers aussi grands que lon veut. Le langage
Python passe automatiquement du type int long lorsque le nombre considr
devient trop grand. Ils se comportent de la mme manire except que les oprations
sur des types long sont plus longues en temps dexcution 9 .
i = int(2**28) <type int> 536870912

for k in range (0,4) : <type int> 1073741824
i *= int(2) <type long> 2147483648
print type(i),i <type long> 4294967296
2.4.6 Ensemble
Le langage Python dfinit galement ce quon appelle un ensemble. Il est dfini
par les classes set de type modifiable et la classe frozenset de type immuable. Ils
nacceptent que des types identiques et offrent la plupart des oprations lies aux
ensembles comme lintersection, lunion. Dun usage moins frquent, ils ne seront
pas plus dtaills 10 .
print set ( (1,2,3) ) & set ( (2,3,5) )
# construit lintersection qui est set([2, 3])
Ce chapitre a prsent les diffrents types de variables dfinis par le langage Py-
thon pour manipuler des donnes ainsi que les oprations possibles avec ces types
de donnes. Le chapitre suivant va prsenter les tests, les boucles et les fonctions
qui permettent de raliser la plupart des programmes informatiques.
9. La diffrence dpend des oprations effectues.
10. La page http://docs.python.org/library/stdtypes.html#set dcrit lensemble des fonctionnalits
qui leur sont attaches.
Chapitre 3
Syntaxe du langage Python (boucles,
tests, fonctions)
Avec les variables, les boucles et les fonctions, on connat suffisamment dlments
pour crire des programmes. Le plus difficile nest pas forcment de les comprendre
mais plutt darriver dcouper un algorithme complexe en utilisant ces briques
lmentaires. Cest lobjectif des chapitres centrs autour des exercices. Toutefois,
mme si ce chapitre prsente les composants lmentaires du langage, laisance quon
peut acqurir en programmation vient la fois de la connaissance du langage mais
aussi de la connaissance dalgorithmes standards comme celui du tri ou dune re-
cherche dichotomique. Cest cette connaissance tout autant que la matrise dun
langage de programmation qui constitue lexprience en programmation.
3.1 Les trois concepts des algorithmes

Les algorithmes sont composs dinstructions, ce sont des oprations lmentaires
que le processeur excute selon trois schmas :
enchanement des instructions les unes la suite des autres : passage

la squence
dune instruction la suivante
passage dune instruction une autre qui nest pas forcment la
le saut
suivante (cest une rupture de squence)
le test choix entre deux instructions
Le saut napparat plus de manire explicite dans les langages volus car il est une
source frquente derreurs. Il intervient dornavant de manire implicite au travers
des boucles qui combinent un saut et un test comme le montre lexemple suivant :
Version avec boucles :
initialisation de la variable moy 0
faire pour i allant de 1 N
moy reoit moy + ni
moy reoit moy / N
Version quivalente avec sauts :

ligne 1 : initialisation de la variable moy 0
ligne 2 : initialisation de la variable i 1
ligne 3 : moy reoit moy + ni
ligne 4 : i reoit i + 1
ligne 5 : si i est infrieur ou gal N alors aller la ligne 3

ligne 6 : moy reoit moy / N
Tout programme peut se rsumer ces trois concepts. Chaque langage les met en
place avec sa propre syntaxe et parfois quelques nuances mais il est souvent facile
de les reconnatre mme dans des langages inconnus. Le calcul dune somme dcrit
plus haut et crit en Python correspond lexemple suivant :
moy = 0
for i in range(1,N+1): # de 1 N+1 exclu --> de 1 N inclus
moy += n [i]
moy /= N
Le premier lment de cette syntaxe est constitu de ses mots-cls (for et in) (voir
galement table 3.1) et des symboles (=, +=, /=, [, ], (, ), :) (voir table 3.2) La fonction
iskeyword du module keyword 1 permet de savoir si un mot-cl donn fait partie du
langage Python.
import keyword
print keyword.iskeyword("for") # affiche True
print keyword.iskeyword("until") # affiche False
and as assert break class continue def del

elif else except exec finally for from global
if import in is lambda not or pass
print raise return try while with yield
Table 3.1 : Mots-cls du langage Python, voir galement la page http:// docs.python.org/
reference/ lexical_analysis.html#identifiers.
+ / // % << >> & | \

< > <= >= == != <> ( ) [ ]
{ } " , : . = ; += -= *=
/= //= %= &= |= = >>= <<= **= """ #
Table 3.2 : Symbole du langage Python, certains ont plusieurs usages comme : qui est
utilis chaque test ou boucle et qui permet aussi de dterminer une plage dindices dans
un tableau. Loprateur <> est identique ! = mais est dclar obsolte (deprecated) : il
est susceptible de disparatre dans une prochaine version de Python.
Remarque 3.1 : syntaxe et espaces

Les espaces entre les mots-cls et les symboles ont peu dimportance, il peut ny en
avoir aucun comme dix. Les espaces servent sparer un mot-cl, un nombre dune
variable.
1. Les modules seront dcrits au chapitre 6. Dans ce cas-ci, un module est une librairie de
fonctionnalits. La syntaxe keyword.iskeyword permet dexcuter la fonctionnalit iskeyword du
module keyword.
3. Syntaxe du langage Python (boucles, tests, fonctions) 59
3.2 Tests
3.2.1 Dfinition et syntaxe
Dfinition 3.2 : test

Les tests permettent dexcuter des instructions diffrentes selon la valeur
dune condition logique.
syntaxe 3.3 : test

if condition1 :
instruction1
instruction2
...
else :
instruction3
instruction4
...
La clause else est facultative. Lorsque la condition condition1 est fausse et

quil ny a aucune instruction excuter dans ce cas, la clause else est inutile.
La syntaxe du test devient :
if condition1 :
instruction1
instruction2
...
Sil est ncessaire denchaner plusieurs tests daffile, il est possible de conden-
ser lcriture avec le mot-cl elif :
if condition1 :
instruction1
instruction2
...
elif condition2 :
instruction3
instruction4
...
elif condition3 :
instruction5
instruction6
...
else :
instruction7
instruction8
...
Remarque 3.4 : indentation

Le dcalage des instructions par rapport aux lignes contenant les mots-cls if,
elif, else est trs important : il fait partie de la syntaxe du langage et sappelle
lindentation (voir paragraphe 3.5). Celle-ci permet de grouper les instructions en-
semble. Le programme suivant est syntaxiquement correct mme si le rsultat nest
pas celui dsir.
x = 1
if x > 0 :
signe = 1
print "le nombre est positif"
else :
signe = -1
print "le nombre est ngatif" # ligne mal indente
print "signe = ", signe
Une ligne est mal indente (print "le nombre est ngatif"). Elle ne devrait tre
excute que si la condition x > 0 nest pas vrifie. Le fait quelle soit aligne avec
les premires instructions du programme fait que son excution na plus rien voir
avec cette condition. La programme rpond de manire errone :
le nombre est positif
le nombre est ngatif
signe = 1
Dans certains cas, linterprteur Python ne sait pas quel bloc attacher une instruc-
tion, cest le cas de lexemple suivant, la mme ligne a t dcale de deux espaces,
ce qui est diffrent de la ligne qui prcde et de la ligne qui suit.
x = 1
if x > 0 :
signe = 1
print "le nombre est positif"
else :
signe = -1
print "le nombre est ngatif" # ligne mal indente
print "signe = ", signe
Linterprteur retourne lerreur suivante :

File "test.py", line 7
print "le nombre est ngatif"
^
IndentationError: unindent does not match any outer indentation level
3.2.2 Comparaisons possibles

Les comparaisons possibles entre deux entits sont avant tout numriques mais ces
oprateurs peuvent tre dfinis pour tout type (voir chapitre 4), notamment sur
les chanes de caractres pour lesquelles les oprateurs de comparaison transcrivent
lordre alphabtique.
<,> infrieur, suprieur

<= , >= infrieur ou gal, suprieur ou gal
== , ! = gal, diffrent
x is y vrifie que x et y sont gaux, not is, diffrents, loprateur is
is , not is est diffrent de loprateur ==, il est expliqu au paragraphe 2.3.2
(page 47).
in, not in appartient, nappartient pas
3.2.3 Oprateurs logiques

Il existe trois oprateurs logiques qui combinent entre eux les conditions.
not ngation and et logique or ou logique
Remarque 3.5 : priorit des oprations

La priorit des oprations numriques est identique celle rencontre en math-
matiques. Loprateur puissance vient en premier, la multiplication/division ensuite
puis laddition/soustraction. Ces oprations sont prioritaires sur les oprateurs de
comparaisons (>, <, ==, ...) qui sont eux-mmes sur les oprateurs logiques not,
and, or. Il est tout de mme conseill dajouter des parenthses en cas de doute.
3.2.4 Ecriture condense

Il existe deux critures condenses de tests. La premire consiste crire un test et
lunique instruction qui en dpend sur une seule ligne.
if condition : if condition : instruction1

instruction1 Ce code peut tenir en else : instruction2
else : deux lignes :
instruction2
Le second cas dcriture condense concerne les comparaisons enchanes. Le test

if 3 < x and x < 5 : instruction peut tre condens par if 3 < x < 5 : instruction.
Il est ainsi possible de juxtaposer autant de comparaisons que ncessaire :
if 3 < x < y < 5 : instruction.
Le mot-cl in permet galement de condenser certains tests lorsque la variable
tester est entire. if x == 1 or x == 6 or x == 50 : peut tre rsum simplement par
if x in (1, 6, 50) :.
3.2.5 Exemple
Lexemple suivant associe la variable signe le signe de la variable x.
x = -5 x = -5
if x < 0 : if x < 0 : signe = -1
signe = -1 Son criture condense elif x == 0 : signe = 0
elif x == 0 : lorsquil ny a quune else : signe = 1
signe = 0 instruction excuter :
else :
signe = 1
Le programme suivant saisit une ligne au clavier et dit si cest "oui" ou "non" qui
a t saisi.
s = raw_input ("dites oui : ") # voir remarque suivante
if s == "oui" or s [0:1] == "o" or s [0:1] == "O" or s == "1" :
print "oui"
else : print "non"
Remarque 3.6 : fonction raw_input

La fonction raw_input invite lutilisateur dun programme saisir une rponse lors
de lexcution du programme. Tant que la touche entre na pas t presse, lex-
cution du programme ne peut continuer. Cette fonction est en ralit peu utilise.
Les interfaces graphiques sont faciles daccs en Python, on prfre donc saisir une
rponse via une fentre plutt quen ligne de commande. Lexemple suivant montre
comment remplacer cette fonction laide dune fentre graphique, le rsultat ap-
parat dans la figure 3.1. On peut amliorer la fonction question en prcisant une
valeur par dfaut par exemple, le chapitre 8 sera plus explicite ce sujet.
import Tkinter
def question (legende) :
reponse = [""]
root = Tkinter.Tk ()
root.title ("pseudo raw_input")
Tkinter.Label (text = legende).pack (side = Tkinter.LEFT)
s = Tkinter.Entry (text= "def", width=80)
s.pack (side = Tkinter.LEFT)
def rget () :
reponse [0] = s.get ()
root.destroy ()
Tkinter.Button (text = "ok", command = rget).pack (side = Tkinter.LEFT)
root.mainloop ()
return reponse [0]
print "reponse ", question ("texte de la question")
Figure 3.1 : Fentre apparaissant lors de lexcution du programme page 62 proposant une
version graphique de la fonction raw_input.
Remarque 3.7 : if None, if 0

Lcriture de certains tests peut encore tre rduite lorsquon cherche comparer
une variable entire, boolenne ou None comme le prcise le tableau 3.2.5.
type test test quivalent
bool if v : if v == True :
Table 3.3 : Ce tableau prcise le sens de cer- bool if not v : if v == False :
tains tests lorsque leur criture est tronque. int if v : if v != 0 :
On suppose que v est une variable. int if not v : if v == 0 :
float if v : if v != 0.0 :
float if not v : if v == 0.0 :
None if v : if v != None :
None if not v : if v == None :
3.2.6 Passer, instruction pass

Dans certains cas, aucune instruction ne doit tre excute mme si un test est
valid. En Python, le corps dun test ne peut tre vide, il faut utiliser linstruction
pass. Lorsque celle-ci est manquante, Python affiche un message derreur.
signe = 0
x = 0
if x < 0 : signe = -1
elif x == 0:
pass # signe est dj gal 0
else : signe = 1
Dans ce cas prcis, si linstruction pass est oublie, linterprteur Python gnre
lerreur suivante :
File "nopass.py", line 6
else :
^
IndentationError: expected an indented block
3.3 Boucles
Dfinition 3.8 : boucle

Les boucles permettent de rpter une squence dinstructions tant quune
certaine condition est vrifie.
Le langage Python propose deux types de boucles. La boucle while suit scrupuleu-
sement la dfinition 3.8. La boucle for est une boucle while dguise (voir para-
graphe 3.3.2), elle propose une criture simplifie pour rpter la mme squence
dinstructions pour tous les lments dun ensemble.
3.3.1 Boucle while

3.3.1.1 Syntaxe et exemples
Limplmentation dune boucle de type while suit le schma dcriture suivant :
syntaxe 3.9 : boucle while

while cond :
instruction 1
...
instruction n
O cond est une condition qui dtermine la poursuite de la rptition des

instructions incluses dans la boucle. Tant que celle-ci est vraie, les instructions
1 n sont excutes.
Tout comme les tests, la remarque 3.4 concernant lindentation reste vraie. Le d-
calage des lignes dun cran vers la droite par rapport linstruction while permet
de les inclure dans la boucle comme le montre lexemple suivant.
n = 0 lintrieur 0
while n < 3: lintrieur 1
print " lintrieur ", n Rsultat : lintrieur 2
n += 1 lextrieur 3
print " lextrieur ", n
3.3.1.2 Condition
Les conditions suivent la mme syntaxe que celles dfinies lors des tests (voir para-
graphes 3.2.2 et 3.2.3). A moins dinclure linstruction break 2 qui permet de sortir
prmaturment dune boucle, la condition qui rgit cette boucle doit ncessairement
tre modifie lintrieur de celle-ci. Dans le cas contraire, on appelle une telle boucle
une boucle infinie puisquil est impossible den sortir. Lexemple suivant contient
une boucle infinie car le symbole = est manquant dans la dernire instruction. La
variable n nest jamais modifie et la condition n < 3 toujours vraie.
n = 0
while n < 3 :
print n
n + 1 # n nest jamais modifi, linstruction correcte serait n += 1
3.3.2 Boucle for

3.3.2.1 Syntaxe et exemples
Limplmentation dune boucle de type for suit le schma dcriture suivant :
syntaxe 3.10 : boucle for

for x in set :
instruction 1
...
instruction n
O x est un lment de lensemble set. Les instructions 1 n sont excutes

pour chaque lment x de lensemble set. Cet ensemble peut tre une chane de
caractres, un T-uple, une liste, un dictionnaire ou tout autre type incluant des
itrateurs qui sont prsents au chapitre 4 concernant les classes (page 106).
Tout comme les tests, la remarque 3.4 concernant lindentation reste vraie.
Lexemple suivant affiche tous les lments dun T-uple laide dune boucle for.
t = (1,2,3,4)
for x in t: # affiche les nombres 1,2,3,4
print x # chacun sur une ligne diffrente
2. Linstruction break est dcrite au paragraphe 3.3.4.2, page 68.

Lors de laffichage dun dictionnaire, les lments napparaissent pas tris ni dans
lordre dans lequel ils y ont t insrs. Lexemple suivant montre comment afficher
les cls et valeurs dun dictionnaire dans lordre croissant des cls.
d = { 1:2, 3:4, 5:6, 7:-1, 8:-2 }
print d # affiche le dictionnaire {8: -2, 1: 2, 3: 4, 5: 6, 7: -1}
k = d.keys ()
print k # affiche les cls [8, 1, 3, 5, 7]
k.sort ()
print k # affiche les cls tries [1, 3, 5, 7, 8]
for x in k: # affiche les lments du dictionnaire
print x,":",d [x] # tris par cls croissantes
Le langage Python propose nanmoins la fonction sorted qui rduit lexemple sui-
vant en trois lignes :
d = { 1:2, 3:4, 5:6, 7:-1, 8:-2 }
for x in sorted(d): # pour les cls dans lordre croissant
print x,":",d [x]
La boucle la plus rpandue est celle qui parcourt des indices entiers compris entre
0 et n 1. On utilise pour cela la boucle for et la fonction range ou xrange comme
dans lexemple qui suit. La diffrence entre ces deux fonctions a dj t prsente
au paragraphe 2.3.1.3 (page 45).
sum = 0
N = 10
for n in range(0,N): # ou for n in xrange(0,N): (plus rapide)
sum += n # additionne tous les entiers compris entre 0 et N-1
Ou encore pour une liste quelconque :

l = [ 4, 5, 3, -6, 7, 9]
sum = 0
for n in range(0,len (l)): # ou for n in xrange(0,len (l)) : (plus rapide)
sum += l [n] # additionne tous les lments de l
3.3.2.2 Listes et boucle for
Le paragraphe 2.3.1.4 a montr comment le mot-cl for peut tre utilis pour sim-
plifier la cration dune liste partir dune autre. La syntaxe suit le schma suivant :
syntaxe 3.11 : boucle for

[ expression for x in ensemble ]
O expression est une expression numrique incluant ou non x, la variable de

la boucle, ensemble est un ensemble dlments, T-uple, liste, dictionnaire.
Cette syntaxe permet de rsumer en une ligne la cration de la squence y du

programme suivant.
y = list ()
for i in range(0,5) :
y.append (i+1)
Les trois lignes du milieu sont maintenant rsumes en une seule :

y = [ i+1 for i in range(0,5)] # rsume trois lignes du programme prcdent
Un autre exemple de cette syntaxe rduite a t prsent au paragraphe 2.3.1.4

page 46. Cette criture condense est bien souvent plus lisible mme si tout dpend
des prfrences de celui qui programme.
3.3.2.3 Itrateurs
Toute boucle for peut sappliquer sur un objet muni dun itrateur tels que les
chanes de caractres, T-uples, les listes, les dictionnaires.
d = ["un", "deux", "trois"]
for x in d:
print x # affichage de tous les lments de d
Cette syntaxe rduite a dj t introduite pour les listes et les dictionnaires au

chapitre prcdent. Il existe une version quivalente avec la boucle while utilisant
de faon explicite les itrateurs. Il peut tre utile de lire le chapitre suivant sur
les classes et le chapitre 5 sur les exceptions avant de revenir sur la suite de cette
section qui nest de toutes faons pas essentielle. Lexemple prcdent est conver-
tible en une boucle while en faisant apparatre explicitement les itrateurs (voir
paragraphe 4.4.2). Un itrateur est un objet qui permet de parcourir aisment un
ensemble. La fonction it = iter(e) permet dobtenir un itrateur it sur lensemble e.
Lappel linstruction it.next() parcourt du premier lment jusquau dernier en
retournant la valeur de chacun dentre eux. Lorsquil nexiste plus dlment, lex-
ception StopIteration est dclenche (voir paragraphe 5). Il suffit de lintercepter
pour mettre fin au parcours.
it = iter (d) # obtient un itrateur sur d
while True:
try: x = it.next () # obtient llment suivant, sil nexiste pas
except StopIteration: break # dclenche une exception
print x # affichage de tous les lments de d
3.3.2.4 Plusieurs variables de boucles
Jusqu prsent, la boucle for na t utilise quavec une seule variable de boucle,
comme dans lexemple suivant o on parcourt une liste de T-uple pour les afficher.
d = [ (1,0,0), (0,1,0), (0,0,1) ]
for v in d: print v
Lorsque les lments dun ensemble sont des T-uples, des listes ou des dictionnaires
composs de taille fixe, il est possible dutiliser une notation qui rappelle les affec-
tations multiples (voir paragraphe 2.4.4). Lexemple prcdent devient dans ce cas :
d = [ (1,0,0), (0,1,0), (0,0,1) ]

for x,y,z in d: print x,y,z
Cette criture nest valable que parce que chaque lment de la liste d est un T-uple
compos de trois nombres. Lorsquun des lments est de taille diffrente celle des
autres, comme dans lexemple suivant, une erreur survient.
d = [ (1,0,0), (0,1,0,6), (0,0,1) ] # un lment de taille quatre
Ce programme gnre lerreur suivante :

File "c:\temp\delete.py", line 2, in -toplevel-
ValueError: unpack tuple of wrong size
Cette syntaxe est trs pratique associe la fonction zip (voir paragraphe 2.3.1.5).
Il est alors possible de parcourir plusieurs squences (T-uple, liste, dictionnaire)
simultanment.
a = range(0,5) 0 est le carr de 0
b = [x**2 for x in a] 1 est le carr de 1
for x,y in zip (a,b): 4 est le carr de 2
print y, " est le carr de ", x 9 est le carr de 3
# affichage droite 16 est le carr de 4
3.3.3 Ecriture condense

Comme pour les tests, lorsque les boucles ne contiennent quune seule instruction,
il est possible de lcrire sur la mme ligne que celle de la dclaration de la boucle
for ou while.
for x in d: print x # une seule instruction
Il existe peu de cas o la boucle while scrit sur une ligne car elle inclut ncessai-
rement une instruction permettant de modifier la condition darrt.
i = 0
while d [i] != "trois" : i += 1
print "trois a pour position ", i
3.3.4 Pilotage dune boucle

3.3.4.1 Passer litration suivante : continue
Pour certains lments dune boucle, lorsquil nest pas ncessaire dexcuter toutes
les instructions, il est possible de passer directement llment suivant ou litration
suivante. Le programme suivant utilise la crible dEratosthne 3 pour dnicher tous
les nombres premiers compris entre 1 et 99.
d = dict ()
for i in range(1,100): # d [i] est vrai si i est un nombre premier
d [i] = True # au dbut, comme on ne sait pas, on suppose
# que tous les nombres sont premiers
for i in range(2,100):
# si d [i] est faux,
if not d [i]: continue # les multiples de i ont dj t cochs
# et peut passer lentier suivant
for j in range (2,100):
if i*j < 100:
d [i*j] = False # d [i*j] est faux pour tous les multiples de i
# infrieurs 100
print "liste des nombres premiers"
for i in d:
if d [i]: print i
Ce programme est quivalent au suivant :

d = dict ()
for i in range(1,100): d [i] = True
if d [i]:
for j in range (2,100):
if i*j < 100 :
d [i*j] = False
print "liste des nombres premiers"

for i in d:
if d [i]: print i
Le mot-cl continue vite de trop nombreuses indentations et rend les programmes

plus lisibles.
3.3.4.2 Sortie prmature : break
Lors de lcriture dune boucle while, il nest pas toujours adquat de rsumer en
une seule condition toutes les raisons pour lesquelles il est ncessaire darrter lex-
cution de cette boucle. De mme, pour une boucle for, il nest pas toujours utile de
3. Le crible dEratosthne est un algorithme permettant de dterminer les nombres premiers.
Pour un nombre premier p, il parat plus simple de considrer tous les entiers de p 1 1 pour
savoir si lun deux divise p. Cest ce quon fait lorsquon doit vrifier le caractre premier dun
seul nombre. Pour plusieurs nombres la fois, le crible dEratosthne est plus efficace : au lieu de
sintresser aux diviseurs, on sintresse aux multiples dun nombre. Pour un nombre i, on sait que
2i, 3i, ... ne sont pas premiers. On les raye de la liste. On continue avec i + 1, 2(i + 1), 3(i + 1)...
visiter tous les lments de lensemble parcourir. Cest le cas par exemple lorsquon
recherche un lment, une fois quil a t trouv, il nest pas ncessaire daller plus
loin. Linstruction break permet de quitter lexcution dune boucle.
l = [6,7,5,4,3]
n = 0
c = 5
for x in l:
if x == c: break # llment a t trouv, on sort de la boucle
n += 1 # si llment a t trouv, cette instruction
# nest pas excute
print "llment ",c, " est en position ",
print n # affiche llment 5 est en position 2
Si deux boucles sont imbriques, linstruction break ne sort que de la boucle dans
laquelle elle est insre. Lexemple suivant vrifie si un entier est la somme des carrs
de deux entiers compris entre 1 et 20.
set = range (1,21)
n = 53
for x in set:
for y in set:
c = x*x + y*y
if c == n: break
if c == n: break # cette seconde instruction break est ncessaire
# pour sortir de la seconde boucle
# lorsque la solution a t trouve
if c == n:
# le symbole \ permet de passer la ligne sans changer dinstruction
print n, " est la somme des carrs de deux entiers :", \
x, "*", x, "+", y, "*", y, "=", n
else:
print n, " nest pas la somme des carrs de deux entiers"
Le programme affiche :
53 est la somme des carrs de deux entiers : 2 * 2 + 7 * 7 = 53
3.3.4.3 Fin normale dune boucle : else
Le mot-cl else existe aussi pour les boucles et sutilise en association avec le mot-
cl break. Linstruction else est place la fin dune boucle, indente au mme
niveau que for ou while. Les lignes qui suivent le mot-cl else ne sont excutes
que si aucune instruction break na t rencontre dans le corps de la boucle. On
reprend lexemple du paragraphe prcdent. On recherche cette fois-ci la valeur 1
qui ne se trouve pas dans la liste L. Les lignes suivant le test if x == c ne seront
jamais excutes au contraire de la dernire.
L = [6,7,5,4,3]
n = 0
c = 1
for x in L :
if x == c :
print "llment ", c, " est en position ", n
break
n += 1
else:
print "aucun lment ", c, " trouv" # affiche aucun lment 1 trouv
Les lignes dpendant de la clause else seront excutes dans tous les cas o lexcu-
tion de la boucle nest pas interrompue par une instruction break ou une instruction
return 4 ou par la leve dune exception 5 .
3.3.4.4 Suppression ou ajout dlments lors dune boucle
En parcourant la liste en se servant des indices, il est possible de supprimer une

partie de cette liste. Il faut nanmoins faire attention ce que le code ne pro-
duise pas derreur comme cest le cas pour le suivant. La boucle for parcourt
la liste range(0, len(li)) qui nest pas modifie en mme temps que linstruction
del li[i : i + 2].
li = range (0,10)
print li # affiche [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in range (0, len (li)):
if i == 5 :
del li [i:i+2]
print li [i] # affiche successivement 0, 1, 2, 3, 4, 7, 8, 9 et
# produit une erreur
print li
Le programme suivant marche parfaitement puisque cette fois-ci la boucle parcourt

la liste li. En revanche, pour la suppression dune partie de celle-ci, il est ncessaire
de conserver en mmoire lindice de llment visit. Cest le rle de la variable i.
li = range (0,10)
print li # affiche [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
i = 0
for t in li :
if i == 5 : del li [i:i+2]
i = i+1
print t # affiche successivement 0, 1, 2, 3, 4, 5, 8, 9
print li # affiche [0, 1, 2, 3, 4, 7, 8, 9]
Le langage Python offre la possibilit de supprimer des lments dune liste alors
mme quon est en train de la parcourir. Le programme qui suit ne marche pas
puisque linstruction del i ne supprime pas un lment de la liste mais lidentificateur
i qui prendra une nouvelle valeur lors du passage suivant dans la boucle.
li = range (0,10)
print li # affiche [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in li :
if i == 5 : del i
print li # affiche [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
4. voir les fonctions au paragraphe 3.4

5. voir paragraphe 5
On pourrait construire des exemples similaires dans le cadre de lajout dun lment
la liste. Il est en rgle gnrale dconseill de modifier une liste, un dictionnaire
pendant quon le parcourt. Malgr tout, si cela savrait indispensable, il convient
de faire plus attention dans ce genre de situations.
3.4 Fonctions
Les fonctions sont des petits programmes qui effectuent des tches plus prcises que
le programme entier. On peut effectivement crire un programme sans fonction mais
ils sont en gnral illisibles. Utiliser des fonctions implique de dcouper un algorithme
en tches lmentaires. Le programme final est ainsi plus facile comprendre. Un
autre avantage est de pouvoir plus facilement isoler une erreur sil sen produit
une : il suffit de tester une une les fonctions pour dterminer laquelle retourne un
mauvais rsultat. Lavantage le plus important intervient lorsquon doit effectuer la
mme chose deux endroits diffrentes dun programme : une seule fonction suffit
et elle sera appele ces deux endroits 6 .
3.4.1 Dfinition, syntaxe
Dfinition 3.12 : fonction

Une fonction est une partie dun programme - ou sous-programme - qui fonc-
tionne indpendamment du reste du programme. Elle reoit une liste de para-
mtres et retourne un rsultat. Le corps de la fonction dsigne toute instruction
du programme qui est excute si la fonction est appele.
Lorsquon crit ses premiers programme, on crit souvent des fonctions plutt
longues avant de sapercevoir que certains parties sont identiques ailleurs. On extrait
donc la partie rpte pour en faire une fonction. Avec lhabitude, on finit par crire
des fonctions plus petites et rutilisables.
syntaxe 3.13 : fonction, dfinition

def fonction_nom (par_1, ..., par_n) :
instruction_1
...
instruction_n
return res_1, ..., res_n
fonction_nom est le nom de la fonction, il suit les mmes rgles que le nom
des variables. par_1 par_n sont les noms des paramtres et res_1 res_n
sont les rsultats retourns par la fonction. Les instructions associes une
fonction doivent tre indentes par rapport au mot-cl def.
Sil ny a aucun rsultat, linstruction return est facultative ou peut tre utilise seule
6. Pour les utilisateurs experts : en langage Python, les fonctions sont galement des variables,
elles ont un identificateur et une valeur qui est dans ce cas un morceau de code. Cette prcision
explique certaines syntaxes du chapitre 8 sur les interfaces graphiques ou celle introduite en fin de
chapitre au paragraphe 3.7.10.
sans tre suivie par une valeur ou une variable. Cette instruction peut apparatre
plusieurs fois dans le code de la fonction mais une seule dentre elles sera excute.
A partir de ce moment, toute autre instruction de la fonction sera ignore. Pour
excuter une fonction ainsi dfinie, il suffit de suivre la syntaxe suivante :
syntaxe 3.14 : fonction, appel

x_1, ..., x_n = fonction_nom (valeur_1, valeur_2, ..., valeur_n)
O fonction_nom est le nom de la fonction, valeur_1 valeur_n sont les noms

des paramtres, x_1 x_n reoivent les rsultats retourns par la fonction.
Cette affectation est facultative. Si on ne souhaite pas conserver les rsultats,
on peut donc appeler la fonction comme suit :
fonction_nom (valeur_1, valeur_2, ..., valeur_n)
Lorsquon commence programmer, il arrive parfois quon confonde le rle des mots-
cls print et return. Dans ce cas, il faut se reporter la remarque 10.3 page 255.
3.4.2 Exemple
Le programme suivant utilise deux fonctions. La premire convertit des coordonnes
cartsiennes en coordonnes polaires. Elle prend deux rels en paramtres et retourne
deux autres rels. La seconde fonction affiche les rsultats de la premire pour tout
couple de valeurs (x, y). Elle ne retourne aucun rsultat.
import math
def coordonnees_polaires (x,y):
rho = math.sqrt(x*x+y*y) # calcul la racine carre de x*x+y*y
theta = math.atan2 (y,x) # calcule larc tangente de y/x en tenant
# compte des signes de x et y
return rho, theta
def affichage (x,y):

r,t = coordonnees_polaires(x,y)
print "cartsien (%f,%f) --> polaire (%f,%f degrs)" \
% (x,y,r,math.degrees(t))
affichage (1,1)
affichage (0.5,1)
affichage (-0.5,1)
affichage (-0.5,-1)
affichage (0.5,-1)
Le programme affiche les lignes suivantes :

cartsien (1.000000,1.000000) --> polaire (1.414214,45.000000 degrs)
cartsien (0.500000,1.000000) --> polaire (1.118034,63.434949 degrs)
cartsien (-0.500000,1.000000) --> polaire (1.118034,116.565051 degrs)
cartsien (-0.500000,-1.000000) --> polaire (1.118034,-116.565051 degrs)
cartsien (0.500000,-1.000000) --> polaire (1.118034,-63.434949 degrs)
3.4.3 Paramtres avec des valeurs par dfaut

Lorsquune fonction est souvent appele avec les mmes valeurs pour ses paramtres,
il est possible de spcifier pour ceux-ci une valeur par dfaut.
syntaxe 3.15 : fonction, valeur par dfaut

def fonction_nom (param_1, param_2 = valeur_2, ..., param_n = valeur_n):
...
O fonction_nom est le nom de la fonction. param_1 param_n sont les noms

des paramtres, valeur_2 valeur_n sont les valeurs par dfaut des para-
mtres param_2 param_n. La seule contrainte lors de cette dfinition est que
si une valeur par dfaut est spcifie pour un paramtre, alors tous ceux qui
suivent devront eux aussi avoir une valeur par dfaut.
Exemple :
def commander_carte_orange (nom, prenom, paiement = "carte", nombre = 1, zone = 2):
print "nom : ", nom
print "prnom : ", prenom
print "paiement : ", paiement
print "nombre : ", nombre
print "zone :", zone
commander_carte_orange ("Dupr", "Xavier", "chque")

# les autres paramtres nombre et zone auront pour valeur
# leurs valeurs par dfaut
Il est impossible quun paramtre sans valeur par dfaut associe se situe aprs un
paramtre dont une valeur par dfaut est prcise. Le programme suivant ne pourra
tre excut.
def commander_carte_orange (nom, prenom, paiement = "carte", nombre = 1, zone):
print "nom : ", nom
# ...
Il dclenche lerreur suivante :

File "problem_zone.py", line 1
def commander_carte_orange (nom, prenom, paiement = "carte", nombre = 1, zone):
SyntaxError: non-default argument follows default argument
Remarque 3.16 : valeurs par dfaut de type modifiable

Les valeurs par dfaut de type modifiable (liste, dictionnaire, classes) peuvent in-
troduire des erreurs inattendues dans les programmes comme le montre lexemple
suivant :
def fonction (l = [0,0]) :
l [0] += 1
return l
print fonction () # affiche [1,0] : rsultat attendu

print fonction () # affiche [2,0] : rsultat surprenant
print fonction ( [0,0]) # affiche [1,0] : rsultat attendu
Lexplication provient du fait que la valeur par dfaut est une liste qui nest pas
recre chaque appel : cest la mme liste chaque fois que la fonction est appele
sans paramtre. Pour remdier cela, il faudrait crire :
import copy
l = copy.copy (l)
l [0] += 1
return l
Lexercice 12.4.7 (page 316) propose un exemple plus complet, voire retors.
3.4.4 Ordre des paramtres

Le paragraphe 3.4.1 a prsent la syntaxe dappel a une fonction. Lors de lappel, le
nom des paramtres nintervient plus, supposant que chaque paramtre reoit pour
valeur celle qui a la mme position que lui lors de lappel la fonction. Il est toutefois
possible de changer cet ordre en prcisant quel paramtre doit recevoir quelle valeur.
syntaxe 3.17 : fonction, ordre des paramtres

x_1, ..., x_n = fonction_nom (param_1 = valeur_1, ..., param_n = valeur_n)
O fonction_nom est le nom de la fonction, param_1 param_n sont les

noms des paramtres, valeur_1 valeur_n sont les valeurs que reoivent
ces paramtres. Avec cette syntaxe, lordre dcriture nimporte pas. La valeur
valeur_i sera toujours attribue param_i. Les variables x_1 x_n reoivent
les rsultats retourns par la fonction. Lordre des rsultats ne peut pas tre
chang. Sil y a plusieurs rsultats retourns, il est impossible de choisir les-
quels conserver : soit tous, soit aucun.
Exemple :
def identite (nom, prenom):
print "nom : ", nom, " prnom : ", prenom
identite("Xavier", "Dupr") # nom : Xavier prnom : Dupr

identite(prenom = "Xavier", nom = "Dupr") # nom : Dupr prnom : Xavier
Cette possibilit est intressante surtout lorsquil y a de nombreux paramtres par

dfaut et que seule la valeur dun des derniers paramtres doit tre change.
def commander_carte_orange (paiement = "carte", nombre = 1, zone = 2):
print "paiement : ", paiement
print "nombre : ", nombre
print "zone :", zone
commander_carte_orange (zone = 5) # seule la valeur par dfaut

# du paramtre zone sera change
3.4.5 Surcharge de fonction

Contrairement dautres langages, Python nautorise pas la surcharge de fonction.
Autrement dit, il nest pas possible que plusieurs fonctions portent le mme nom
mme si chacune dentre elles a un nombre diffrent de paramtres.
def fonction (a,b):
return a + b
def fonction (a,b,c):

return a + b + c
print fonction (5,6)

print fonction (5,6,7)
Le petit programme prcdent est syntaxiquement correct mais son excution gnre
une erreur parce que la seconde dfinition de la fonction fonction efface la premire.

File "cours4.py", line 7, in ?
print fonction (5,6)
TypeError: fonction() takes exactly 3 arguments (2 given)
3.4.6 Commentaires
Le langage Python propose une fonction help qui retourne pour chaque fonction
un commentaire ou mode demploi qui indique comment se servir de cette fonction.
Lexemple suivant affiche le commentaire associ la fonction round.
>>> help (round)
Help on built-in function round:
round(...)
round(number[, ndigits]) -> floating point number
Round a number to a given precision in decimal digits (default 0 digits).

This always returns a floating point number. Precision may be negative.
Lorsquon utilise cette fonction help sur la fonction coordonnees_polaires dfinie

dans lexemple du paragraphe prcdent 3.4.2, le message affich nest pas des plus
explicites.
>>> help (coordonnees_polaires)
Help on function coordonnees_polaires in module __main__:
coordonnees_polaires(x, y)
Pour changer ce message, il suffit dajouter en premire ligne du code de la fonction

une chane de caractres.
import math
def coordonnees_polaires (x,y):
"""convertit des coordonnes cartsiennes en coordonnes polaires
(x,y) --> (pho,theta)"""
rho = math.sqrt(x*x+y*y)
theta = math.atan2 (y,x)
return rho, theta
help (coordonnees_polaires)
Le programme affiche alors le message daide suivant nettement plus explicite :

Help on function coordonnees_polaires in module __main__:
coordonnees_polaires(x, y)
convertit des coordonnes cartsiennes en coordonnes polaires
(x,y) --> (pho,theta)
Il est conseill dcrire ce commentaire pour toute nouvelle fonction avant mme que
son corps ne soit crit. Lexprience montre quon oublie souvent de lcrire aprs.
3.4.7 Paramtres modifiables

Les paramtres de types immuables et modifiables se comportent de manires diff-
rentes lintrieur dune fonction. Ces paramtres sont manipuls dans le corps de
la fonction, voire modifis parfois. Selon le type du paramtre, ces modifications ont
des rpercussions lextrieur de la fonction.
Les types immuables ne peuvent tre modifis et cela reste vrai. Lorsquune fonction
accepte un paramtre de type immuable, elle ne reoit quune copie de sa valeur.
Elle peut donc modifier ce paramtre sans que la variable ou la valeur utilise lors
de lappel de la fonction nen soit affecte. On appelle ceci un passage de paramtre
par valeur. A loppos, toute modification dune variable dun type modifiable
lintrieur dune fonction est rpercute la variable qui a t utilise lors de lappel
de cette fonction. On appelle ce second type de passage un passage par adresse.
Lexemple suivant utilise une fonction somme_n_premier_terme qui modifie ces deux
paramtres. Le premier, n, est immuable, sa modification na aucune incidence sur la
variable nb. En revanche, le premier lment du paramtre liste reoit la valeur 0.
Le premier lment de la liste l na plus la mme valeur aprs lappel de la fonction
somme_n_premier_terme que celle quil avait avant.
def somme_n_premier_terme(n,liste):
"""calcul la somme des n premiers termes dune liste"""
somme = 0
for i in liste:
somme += i
n -= 1 # modification de n (type immuable)
if n <= 0: break
liste[0] = 0 # modification de liste (type modifiable)
return somme
l = [1,2,3,4]
nb = 3
print "avant la fonction ",nb,l # affiche avant la fonction 3 [1, 2, 3, 4]
s = somme_n_premier_terme (nb,l)
print "aprs la fonction ",nb,l # affiche aprs la fonction 3 [0, 2, 3, 4]
print "somme : ", s # affiche somme : 6
La liste l est modifie lintrieur de la fonction somme_n_premier_terme comme

laffichage suivant le montre. En fait, lintrieur de la fonction, la liste l est dsigne
par lidentificateur liste, cest la mme liste. La variable nb est dun type immuable.
Sa valeur a t recopie dans le paramtre n de la fonction somme_n_premier_terme.
Toute modification de n lintrieur de cette fonction na aucune rpercussion
lextrieur de la fonction.
Remarque 3.18 : passage par adresse
Dans lexemple prcdent, il faut faire distinguer le fait que la liste passe en para-
mtre ne soit que modifie et non change. Lexemple suivant inclut une fonction
qui affecte une nouvelle valeur au paramtre liste sans pour autant modifier la liste
envoye en paramtre.
def fonction (liste):
liste = []
liste = [0,1,2]
print liste # affiche [0,1,2]
fonction (liste)
Il faut considrer dans ce programme que la fonction fonction reoit un paramtre

appel liste mais utilise tout de suite cet identificateur pour lassocier un contenu
diffrent. Lidentificateur liste est en quelque sorte pass du statut de paramtre
celui de variable locale. La fonction associe une valeur liste - ici, une liste vide -
sans toucher la valeur que cet identificateur dsignait prcdemment.
Le programme qui suit est diffrent du prcdent mais produit les mmes effets. Ceci
sexplique par le fait que le mot-cl del ne supprime pas le contenu dune variable
mais seulement son identificateur. Le langage Python dtecte ensuite quun objet
nest plus dsign par aucun identificateur pour le supprimer. Cette remarque est
rapprocher de celles du paragraphe 4.6.
del liste
liste = [0,1,2]
fonction (liste)
Le programme qui suit permet cette fois-ci de vider la liste liste passe en paramtre
la fonction fonction. La seule instruction de cette fonction modifie vraiment le
contenu dsign par lidentificateur liste et cela se vrifie aprs lexcution de cette
fonction.
del liste[0:len(liste)] # on peut aussi crire : liste[:] = []
liste = [0,1,2]
fonction (liste)
print liste # affiche []
3.4.8 Fonction rcursive
Dfinition 3.19 : fonction rcursive

Une fonction rcursive est une fonction qui sappelle elle-mme.
La fonction rcursive la plus frquemment cite en exemple est la fonction factorielle.

Celle-ci met en vidence les deux composantes dune fonction rcursive, la rcursion
proprement dite et la condition darrt.
def factorielle(n):
if n == 0 : return 1
else : return n * factorielle(n-1)
La dernire ligne de la fonction factorielle est la rcursion tandis que la prcdente

est la condition darrt, sans laquelle la fonction ne cesserait de sappeler, empchant
le programme de terminer son excution. Si celle-ci est mal spcifie ou absente,
linterprteur Python affiche une suite ininterrompue de messages. Python nautorise
pas plus de 1000 appels rcursifs : factorielle(999) provoque ncessairement une
erreur dexcution mme si la condition darrt est bien spcifie.
File "fact.py", line 5, in <module>
factorielle(999)
File "fact.py", line 3, in factorielle
File "fact.py", line 3, in factorielle
...
La liste des messages derreurs est aussi longue quil y a eu dappels la fonction
rcursive. Dans ce cas, il faut transformer cette fonction en une fonction non rcursive
quivalente, ce qui est toujours possible.
def factorielle_non_recursive (n) :
r = 1
for i in range (2, n+1) :
r *= i
return r
3.4.9 Porte
3.4.9.1 Porte des variables, des paramtres
Lorsquon dfinit une variable, elle nest pas utilisable partout dans le programme.
Par exemple, elle nest pas utilisable avant davoir t dclare au moyen dune
affectation. Le court programme suivant dclenche une erreur.
print x # dclenche une erreur

File "pas_declaree.py", line 1, in <module>
print x
NameError: name x is not defined
Il est galement impossible dutiliser une variable lextrieur dune fonction o elle
a t dclare. Plusieurs fonctions peuvent ainsi utiliser le mme nom de variable
sans qu aucun moment, il ny ait confusion. Le programme suivant dclenche une
erreur identique celle reproduite ci-dessus.
def portee_variable(x):
var = x
print var
portee_variable(3)
print var # dclenche une erreur car var est dclare dans
# la fonction portee_variable
Dfinition 3.20 : porte dune variable

La porte dune variable associe un identificateur recouvre la portion du
programme lintrieur de laquelle ce mme identificateur la dsigne. Ceci
implique que, dans cette portion de code, aucune autre variable, aucune autre
fonction, aucune autre classe, ne peut porter le mme identificateur.
Une variable na donc dexistence que dans la fonction dans laquelle elle est dclare.
On appelle ce type de variable une variable locale. Par dfaut, toute variable utilise
dans une fonction est une variable locale.
Dfinition 3.21 : variable locale

Une variable locale est une variable dont la porte est rduite une fonction.
Par opposition aux variables locales, on dfinit les variables globales qui sont dcla-
res lextrieur de toute fonction.
Dfinition 3.22 : variable globale

Une variable globale est une variable dont la porte est lensemble du pro-
gramme.
Lexemple suivant mlange variable locale et variable globale. Lidentificateur n est

utilis la fois pour dsigner une variable globale gale 1 et une variable locale
gale 1. A lintrieur de la fonction, n dsigne la variable locale gale 2. A
lextrieur de la fonction, n dsigne la variable globale gale 1.
n = 1 # dclaration dune variable globale
def locale_globale():
n = 2 # dclaration dune variable locale
print n # affiche le contenu de la variable locale
print n # affiche 1
locale_globale() # affiche 2
print n # affiche 1
Il est possible de faire rfrence aux variables globales dans une fonction par lin-
termdiaire du mot-cl global. Celui-ci indique la fonction que lidentificateur n
nest plus une variable locale mais dsigne une variable globale dj dclare.
n = 1 # dclaration dune variable globale
def locale_globale():
global n # cette ligne indique que n dsigne la variable globale
n = 2 # change le contenu de la variable globale
print n # affiche le contenu de la variable globale
print n # affiche 1
locale_globale() # affiche 2
print n # affiche 2
Cette possibilit est viter le plus possible car on peut considrer que
locale_globale est en fait une fonction avec un paramtre cach. La fonction
locale_globale nest plus indpendante des autres fonctions puisquelle modifie
une des donnes du programme.
3.4.9.2 Porte des fonctions
Le langage Python considre les fonctions galement comme des variables dun type
particulier. La porte des fonctions obit aux mmes rgles que celles des variables.
Une fonction ne peut tre appele que si elle a t dfinie avant son appel.
print type(factorielle) # affiche <type function>
Comme il est possible de dclarer des variables locales, il est galement possible
de dfinir des fonctions locales ou fonctions imbriques. Une fonction locale nest
appelable qu lintrieur de la fonction dans laquelle elle est dfinie. Dans lexemple
suivant, la fonction affiche_pair inclut une fonction locale qui nest appelable que
par cette fonction affiche_pair.
def affiche_pair():
def fonction_locale(i): # fonction locale ou imbrique
if i % 2 == 0 : return True
else : return False
if fonction_locale(i):
print i
affiche_pair()
fonction_locale(5) # lappel cette fonction locale
# dclenche une erreur dexcution
A lintrieur dune fonction locale, le mot-cl global dsigne toujours les variables
globales du programme et non les variables de la fonction dans laquelle cette sous-
fonction est dfinie.
3.4.10 Nombre de paramtres variable

Il est possible de dfinir des fonctions qui prennent un nombre indtermin de para-
mtres, lorsque celui-ci nest pas connu lavance. Hormis les paramtres transmis
selon le mode prsent dans les paragraphes prcdents, des informations peuvent
tre ajoutes cette liste lors de lappel de la fonction, ces informations sont re-
groupes soit dans une liste de valeurs, soit dans une liste de couples (identificateur,
valeur). La dclaration dune telle fonction obit la syntaxe suivante :
syntaxe 3.23 : fonction, nombre variable de paramtres

def fonction (param_1, ..., param_n, *liste, **dictionnaire) :
O fonction est un nom de fonction, param_1 param_n sont des paramtres

de la fonction, liste est le nom de la liste qui doit recevoir la liste des valeurs
seules envoyes la fonction et qui suivent les paramtres (plus prcisment,
cest un tuple), dictionnaire reoit la liste des couples (identificateur, valeur).
Lappel cette fonction suit quant lui la syntaxe suivante :
syntaxe 3.24 : fonction, nombre variable de paramtres (appel)

fonction (valeur_1, ..., valeur_n, \
liste_valeur_1, ..., liste_valeur_p, \
nom_1 = v_1, ..., nom_q = v_q)
O fonction est un nom de fonction, valeur_1 valeur_n sont les va-

leurs associes aux paramtres param_1 param_n, liste_valeur_1
liste_valeur_p formeront la liste liste, les couples nom_1 : v_1 nom_q : v_q
formeront le dictionnaire dictionnaire.
Exemple :
def fonction(p,*l,**d):
print "p = ",p
print "liste (tuple) l :", l
print "dictionnaire d :", d
fonction (1,2,3,a=5,b=6) # 1 est associ au paramtre p

# 2 et 3 sont insrs dans la liste l
# a=5 et b=6 sont insrs dans le dictionnaire d
Ce programme affiche :
p = 1
liste l : (2, 3)
dictionnaire d : {a: 5, b: 6}
A linstar des paramtres par dfaut, la seule contrainte de cette criture est la
ncessit de respecter lordre dans lequel les informations doivent apparatre. Lors
de lappel, les valeurs sans prcision de nom de paramtre seront places dans une
liste (ici le tuple l). Les valeurs associes un nom de paramtre seront places dans
un dictionnaire (ici d). Les valeurs par dfaut sont obligatoirement places aprs les
paramtres non nomms explicitement.
Une fonction qui accepte des paramtres en nombre variable peut son tour appeler
une autre fonction acceptant des paramtres en nombre variable. Il faut pour cela se
servir du symbole afin de transmettre fonction les valeurs reues par fonction2.
def fonction(p,*l,**d):
print "p = ",p
print "liste l :", l
print "dictionnaire d :", d
def fonction2 (p, *l, **d) :

l += (4,) # on ajoute une valeur au tuple
d ["c"] = 5 # on ajoute un couple (paramtre,valeur)
fonction (p, *l, **d) # ne pas oublier le symbole *
fonction2 (1,2,3,a=5,b=6)
Le programme affiche :
p = 1
liste l : (2, 3, 4)
dictionnaire d : {a: 5, c: 5, b: 6}
3.4.11 Ecriture simplifie pour des fonctions simples

Lorsque le code dune fonction tient en une ligne et est le rsultat dune expression,
il est possible de condenser son criture laide du mot-cl lambda.
syntaxe 3.25 : fonction lambda

nom_fonction = lambda param_1, ..., param_n : expression
nom_fonction est le nom de la fonction, param_1 param_n sont les para-

mtres de cette fonction (ils peuvent galement recevoir des valeurs par d-
faut), expression est lexpression retourne par la fonction.
Lexemple suivant utilise cette criture pour dfinir la fonction min retournant le
plus petit entre deux nombres positifs.
min = lambda x,y : (abs (x+y) - abs (x-y))/2
print min (1,2) # affiche 1

Cette criture correspond lcriture non condense suivante :

def min(x,y):
return (abs (x+y) - abs (x-y))/2

3.4.12 Fonctions gnrateur

Le mot-cl yield est un peu part. Utilis lintrieur dune fonction, il permet din-
terrompre le cours de son excution un endroit prcis de sorte quau prochain appel
de cette fonction, celle-ci reprendra le cours de son excution exactement au mme
endroit avec des variables locales inchanges. Le mot-cl return ne doit pas tre uti-
lis. Ces fonctions ou gnrateurs sont utilises en couple avec le mot-cl for pour
simuler un ensemble. Lexemple suivant implmente une fonction fonction_yield
qui simule lensemble des entiers compris entre 0 et n exclu.
def fonction_yield(n):
i = 0
while i < n-1:
print "yield 1" # affichage : pour voir ce que fait le programme
yield i # arrte la fonction qui reprendra
i = i+1 # la ligne suivante lors du prochain appel
print "yield 2" # affichage : pour voir ce que fait le programme
yield i # arrte la fonction qui ne reprendra pas
# lors du prochain appel car le code de la fonction
# prend fin ici
for a in fonction_yield(2):
print a # affiche tous les lments que retourne la
# fonction fonction_yield, elle simule la liste
# [0,1]
print "-----------------------------------------------"
for a in fonction_yield(3):
print a # nouvel appel, lexcution reprend
# au dbut de la fonction,
# affiche tous les lments que retourne la
# fonction fonction_yield, elle simule la liste
# [0,1,2]
Le programme affiche tous les entiers compris entre 0 et 4 inclus ainsi que le texte
yield 1 ou yield 2 selon linstruction yield qui a retourn le rsultat. Lorsque la
fonction a finalement termin son excution, le prochain appel agit comme si ctait
la premire fois quon lappelait.
yield 1
0
yield 2
1
-----------------------------------------------
yield 1
0
yield 1
1
yield 2
2
3.4.13 Identificateur appelable

La fonction callable retourne un boolen permettant de savoir si un identificateur
est une fonction (voir chapitre 4), de savoir par consquent si tel identificateur est
appelable comme une fonction.
x = 5
def y () :
return None
print callable (x) # affiche False car x est une variable
print callable (y) # affiche True car y est une fonction
3.4.14 Fonctions ajoutes lors de lexcution du programme

3.4.14.1 Fonction eval
Cette fonction a dj t aborde lors des paragraphes 2.4.1 (paragraphe 2.4.2,

page 54). Un exemple a dj t prsent page 54. Elle value toute chane de
caractres contenant une expression crite avec la syntaxe du langage Python. Cette
expression peut utiliser toute variable ou toute fonction accessible au moment o
est appele la fonction eval.
x = 3
y = 4
print eval ("x*x+y*y+2*x*y") # affiche 49
print (x+y)**2 # affiche 49
Si lexpression envoye la fonction eval inclut une variable non dfinie, linterpr-
teur Python gnre une erreur comme le montre lexemple suivant.
x = 3
y = 4
print eval ("x*x+y*y+2*x*y+z")
La variable z nest pas dfinie et lexpression nest pas valuable.

File "c:\temp\cours.py", line 3, in -toplevel-
print eval ("x*x+y*y+2*x*y+z")
File "<string>", line 0, in -toplevel-
NameError: name z is not defined
Lerreur se produit dans une chane de caractres traduite en programme infor-

matique, cest pourquoi linterprteur ne peut pas situer lerreur dans un fichier.
Lerreur ne se produit dans aucun fichier, cette chane de caractres pourrait tre
dfinie dans un autre.
3.4.14.2 Fonctions compile, exec
Plus complte que la fonction eval, la fonction compile permet dajouter une ou
plusieurs fonctions au programme, celle-ci tant dfinie par une chane de carac-
tres. Le code est dabord compil (fonction compile) puis incorpor au programme
(fonction exec) comme le montre lexemple suivant.
import math
str = """def coordonnees_polaires (x,y):
rho = math.sqrt(x*x+y*y)
theta = math.atan2 (y,x)
return rho, theta""" # fonction dfinie par une chane de caractres
obj = compile(str,"","exec") # fonction compile

exec obj # fonction incorpore au programme
print coordonnees_polaires(1,1)# affiche (1.4142135623730951, 0.78539816339744828)
La fonction compile prend en fait trois arguments. Le premier est la chane de

caractres contenant le code compiler. Le second paramtre ("" dans lexemple)
contient un nom de fichier dans lequel seront places les erreurs de compilation. Le
troisime paramtre est une chane de caractres choisir parmi "exec" ou "eval".
Selon ce choix, ce sera la fonction exec ou eval qui devra tre utilise pour agrger le
rsultat de la fonction compile au programme. Lexemple suivant donne un exemple
dutilisation de la fonction compile avec la fonction eval.
import math
str = """math.sqrt(x*x+y*y)""" # expression dfinie par une chane de caractres
obj = compile(str,"","eval") # expression compile

x = 1
y = 2
print eval (obj) # rsultat de lexpression
3.5 Indentation
Lindentation est synonyme de dcalage. Pour toute boucle, test, fonction, et plus
tard, toute dfinition de classe, le fait dindenter ou dcaler les lignes permet de d-
finir une dpendance dun bloc de lignes par rapport un autre. Les lignes indentes
par rapport une boucle for dpendent de celle-ci puisquelle seront excutes
chaque passage dans la boucle. Les lignes indentes par rapport au mot-cl def sont
considres comme faisant partie du corps de la fonction. La remarque 3.4 page 59
prcise lerreur que linterprteur Python retourne en cas de mauvaise indentation.
Contrairement dautres langages comme le C ou PERL, Python nutilise pas de
dlimiteurs pour regrouper les lignes. Lindentation, souvent prsente comme un
moyen de rendre les programmes plus lisibles, est ici intgre la syntaxe du langage.
Il ny a pas non plus de dlimiteurs entre deux instructions autre quun passage la
ligne. Le caractre \ plac la fin dune ligne permet de continuer lcriture dune
instruction la ligne suivante.
3.6 Fonctions usuelles

Certaines fonctions sont communes aux dictionnaires et aux listes, elles sont ga-
lement dfinis pour de nombreux objets prsents dans les extensions du langages.
Quelque soit le contexte, le rsultat attendu la mme signification. Les plus cou-
rantes sont prsentes par la table 3.4.
La fonction map permet dcrire des boucles de faon simplifie. Elle est utile dans
le cas o on souhaite appliquer la mme fonction tous les lments dun ensemble.
Par exemple les deux dernires lignes du programme suivant sont quivalentes.
l = [0,3,4,4,5,6]
print [ est_pair (i) for i in l ] # affiche [0, 1, 0, 0, 1, 0]
print map (est_pair, l) # affiche [0, 1, 0, 0, 1, 0]
Elle peut aider simplifier lcriture lorsque plusieurs listes sont impliques. Ici
encore, les deux dernires lignes sont quivalentes.
def addition (x,y) : return x + y
l = [0,3,4,4,5,6]
m = [1,3,4,5,6,8]
print [ addition (l [i], m [i]) for i in range (0, len (l)) ]
print map (addition, l, m) # affiche [1, 6, 8, 9, 11, 14]
Il est possible de substituer None la fonction f pour obtenir lquivalent de la

fonction zip.
print map (None, l,m) # affiche [(0, 1), (3, 3), (4, 4), (4, 5), (5, 6), (6, 8)]
print zip (l,m) # affiche [(0, 1), (3, 3), (4, 4), (4, 5), (5, 6), (6, 8)]
Comme pour les dictionnaires, la fonction sorted permet de parcourir les lments
dune liste de faon ordonne. Les deux exemples qui suivent sont presque quiva-
lents. Dans le second, la liste l demeure inchange alors quelle est trie dans le
premier programme.
l = [ 4, 5, 3, -6, 7, 9] l = [ 4, 5, 3, -6, 7, 9]
l.sort ()
for n in l : for n in sorted (l) :
print n print n
La fonction enumerate permet dviter lemploi de la fonction range ou xrange lors-

quon souhaite parcourir une liste alors que lindice et llment sont ncessaires.
l = [ 4, 5, 3, -6, 7, 9] l = [ 4, 5, 3, -6, 7, 9]
for i in xrange (0, len (l)) : for i,v in enumerate (l) :
print i, l [i] print i, v
abs(x) Retourne la valeur absolue de x.

callable(x) Dit si la variable x peut tre appele.
chr(i) Retourne le caractre associ au code numrique i.
cmp(x, y) Compare x et y, retourne -1 si x < y, 0 en cas dgalit, 1 sinon.
Retourne lensemble des mthodes associes x qui peut tre
dir(x)
un objet, un module, un variable,...
enumerate(x) parcourt un ensemble itrable (voir paragraphe 3.6)
help(x) Retourne laide associe x.
Retourne un identifiant unique associ lobjet x. Le mot-cl
id(x)
is est reli cet identifiant.
isinstance( Dit si lobjet x est de type classe, voir le chapitre 4 sur les
x, classe classes.
issubclass( Dit si la classe cl1 hrite de la classe cl2, voir le chapitre 4 sur
cl1, cl2) les classes.
len(l) Retourne la longueur de l.
Applique la fonction f sur les listes l1, l2... Voir lexemple
map(f, l1, l2, ...)
page 86.
max(l) Retourne le plus grand lment de l.
min(l) Retourne le plus petit lment de l.
ord(s) Fonction rciproque de chr.
Construit la liste des entiers de i j. Si k est prcis, va de k
range(i, j[, k]
en k partir de i.
reload(module) Recharge un module (voir paragraphe 6).
repr(o) Retourne une chane de caractres qui reprsente lobjet o.
round(x[, n]) Arrondi x n dcimales prs ou aucune si n nest pas prcis.
sorted(x
[, cmp[, key[, tri un ensemble itrable (voir paragraphe 3.6)
reverse]]])
str(o) Retourne une chane de caractres qui reprsente lobjet o.
sum(l) Retourne la somme de lensemble l.
type(o) Retourne le type de la variable o.
Plus rapide que la fonction range mais utilisable que dans une
xrange(i, j[, k]
boucle for.
zip(l1, l2, ...) Construit une liste de tuples au lieu dun tuple de listes.
Table 3.4 : Liste non exhaustive de fonctions dfinis par le langage Python sans quaucune
extension ne soit ncessaire. Elles ne sont pas toujours applicables mme si la syntaxe
dappel est correcte, elles produisent une erreur dans ce cas.
3.7 Constructions classiques

Les paragraphes qui suivent dcrivent des schmas quon retrouve dans les pro-
grammes dans de nombreuses situations. Ce sont des combinaisons simples dune ou
deux boucles, dun test, dune liste, dun dictionnaire.
3.7.1 Recherche dun lment

Rechercher un lment consiste parcourir un ensemble jusqu ce quon le trouve :
le rsultat souhait est sa position ou un rsultat indiquant quil na pas t trouv.
Cette recherche est souvent insre dans une fonction dont voici le schma :
def recherche (li, c) :
for i,v in enumerate (li) :
if v == c : return i
return -1
li = [ 45, 32, 43, 56 ]
print recherche (li, 43) # affiche 2
La mthode index permet de rduire ce programme.

print li.index (43)
Nanmoins, la fonction recherche peut tre adapte pour rechercher la premire

valeur trouve parmi deux possibles, ce quil nest pas possible de faire avec la
mthode index.
def recherche (li, c,d) :
if v in [c,d] : return i
return -1
li = [ 45, 32, 43, 56 ]
print recherche (li, 43, 32) # affiche 1
Ce court exemple montre quil est utile de connatre quelques algorithmes simples. Ils
ne sont pas forcment les plus efficaces mais ils aident construire des programmes
plus rapidement et obtenir un rsultat. Sil est positif alors il sera toujours temps
de se pencher sur loptimisation du programme pour quil soit plus efficace.
3.7.2 Maximum, minimum

La recherche dun extremum comme le calcul dune somme fait toujours intervenir
une boucle. La diffrence est quon souhaite parfois obtenir la position du maximum.
li = [ 0, 434, 43, 6436, 5 ]

m = li [0] # initialisation
for l in li : # boucle
if m < l : m = l # m est le maximum
Ce code est quivalent linstruction li = [ 0, 434, 43, 6436, 5 ]

max(li). Pour rcuprer la position du m = 0
maximum, il faut itrer sur les positions for i in xrange (0, len (li)) :
if li [m] < li [i] : m = i
et non sur les lments.
Pour viter la boucle, on peut utiliser lastuce dcrite au paragraphe 3.7.7 qui
consiste former une liste de couples avec la position initiale :
k = [ (v,i) for i,v in enumerate (li) ]

m = max (k) [1]
Il arrive frquemment quon ne doive pas chercher le maximum dune liste mais le
maximum au sein dun sous-ensemble de cette liste. Dans lexemple qui suit, on
cherche le tuple dont la premire valeur est maximale et dont la seconde valeur est
gale 1.
li = [ (0,0), (434,0), (43,1), (6436,1), (5,0) ]
m = -1 # -1 car le premier lment peut ne pas faire partie du sous-ensemble
for i in range (0, len (li)) :
if li [i][1] == 0 and (m == -1 or li [m][0] < li [i][0]) : m = i
3.7.3 Recherche dichotomique

La recherche dichotomique est plus rapide quune recherche classique mais elle sup-
pose que celle-ci seffectue dans un ensemble tri. Lide est de couper en deux
lintervalle de recherche chaque itration. Comme lensemble est tri, en compa-
rant llment cherch llment central, on peut liminer une partie de lensemble :
la moiti infrieure ou suprieure.
def recherche_dichotomique (li, c) :
a,b = 0, len (li)-1
while a <= b :
m = (a+b)/2
if c == li [m] : return m
elif c < li [m] : b = m-1 # partie suprieure limine
else : a = m+1 # partie infrieure limine
return -1 # lment non trouv
li = range (0,100,2)
print recherche_dichotomique (li, 48) # affiche 24
print recherche_dichotomique (li, 49) # affiche -1
3.7.4 Dcomposition en matrice

Les quelques lignes qui suivent permettent de dcomposer une chane de caractres
en matrice. Chaque ligne et chaque colonne sont spares par des sparateurs diff-
rents. Ce procd intervient souvent lorsquon rcupre des informations depuis un
fichier texte lui-mme provenant dun tableur.
s = "case11;case12;case13|case21;case22;case23"
# dcomposition en matrice
ligne = s.split ("|") # lignes
mat = [ l.split (";") for l in ligne ] # colonnes
Lopration inverse :
ligne = [ ";".join (l) for l in mat ] # colonnes

s = "|".join (ligne) # lignes
3.7.5 Somme
Le calcul dune somme fait toujours intervenir une boucle car le langage Python ne
peut faire des additions quavec deux nombres. Le schma est toujours le mme :
initialisation et boucle.
li = [ 0, 434, 43, 6456 ]
s = 0 # initialisation
for l in li : # boucle
s += l # addition
Ce code est quivalent linstruction sum(li). Dans ce cas o la somme intgre le

rsultat dune fonction et non les lments dune liste, il faudrait crire :
def fonction (x) : return x*x
s = 0
for l in li : s += fonction (l)
Et ces deux lignes pourraient tre rsu- s = sum ( [fonction (l) for l in li] )
mes en une seule grce lune de ces
deux instructions. s = sum ( map (fonction, li) )
Lavantage de la solution avec la boucle est quelle vite la cration dune liste inter-
mdiaire, cest un point prendre en compte si la liste sur laquelle opre la somme
est volumineuse. Il peut tre intressant de regarder lexercice 12.1.9 page 287.
3.7.6 Tri
Le tri est une opration frquente. On na pas toujours le temps de programmer
le tri le plus efficace comme un tri quicksort et un tri plus simple suffit la plupart
du temps. Le tri suivant consiste recherche le plus petit lment puis changer
sa place avec le premier lment du tableau du tableau. On recommence la mme
procdure partir de la seconde position, puis la troisime et ainsi de suite jusqu
la fin du tableau.
for i in xrange (0, len (li)) :
# recherche du minimum entre i et len (li) exclu
pos = i
for j in xrange (i+1, len (li)) :
if li [j] < li [pos] : pos = j
# change
ech = li [pos]
li [pos] = li [i]
li [i] = ech
La mthode sort tri galement une liste mais selon un algorithme plus efficace
que celui-ci dont la logique est prsente par lexercice 4, page 261. Ceci explique
pourquoi on hsite toujours programmer un tri quitte avoir recours une astuce
telle que celle prsentes au paragraphe suivant.
3.7.7 Tri et position initiale

Il arrive parfois quon souhaite trier un tableau puis appliquer la mme transforma-
tion un second tableau. Pour cela, il faut rcuprer la position initiale des lments
dans le tableau tri. Une possibilit consiste trier non pas le tableau mais une liste
de couples (valeur, position) comme le montre lexemple suivant :
tab = ["zro", "un", "deux"] # tableau trier
pos = [ (tab [i],i) for i in range (0, len (tab)) ] # tableau de couples
pos.sort () # tri
print pos # affiche [(deux, 2), (un, 1), (zro, 0)]
La liste [p[1] for p in pos] correspond lensemble des positions initiales des lments
de la liste tab. Les deux lignes qui suivent permettent den dduire la position de
chaque lment dans lensemble tri. ordre[i] est le rang de llment dindice i avant
le tri.
ordre = range (0, len (pos))
for i in xrange (0, len (pos)) : ordre [pos [i][1]] = i
3.7.8 Comptage
On souhaite ici compter le nombre doccurrences de chaque lment dun tableau.
Par exemple, on pourrait connatre par ce moyen la popularit dun mot dans un
discours politique ou ltendue du vocabulaire utilis. Lexemple suivant compte les
mots dune liste de mots.
li = ["un", "deux", "un", "trois"]
d = { }
for l in li :
if l not in d : d [l] = 1
else : d [l] += 1
print d # affiche {un: 2, trois: 1, deux: 1}
La structure la plus approprie ici est un dictionnaire puisquon cherche associer

une valeur un lment dune liste qui peut tre de tout type. Si la liste contient
des lments de type modifiable comme une liste, il faudrait convertir ceux-ci en un
type immuable comme une chane de caractres. Lexemple suivant illustre ce cas
en comptant les occurrences des lignes dune matrice.
mat = [ [1,1,1], [2,2,2], [1,1,1]]
d = { }
for l in mat :
k = str (l) # k = tuple (l) lorsque cela est possible
if k not in d : d [k] = 1
else : d [k] += 1
print d # affiche {[1, 1, 1]: 2, [2, 2, 2]: 1}
On peut galement vouloir non pas compter le nombre doccurrence mais mmoriser
les positions des lments tous identiques. On doit utiliser un dictionnaire de listes :
li = ["un", "deux", "un", "trois"]

d = { }
if v not in d : d [v] = [ i ]
else : d [v].append (i)
print d # affiche {un: [0, 2], trois: [3], deux: [1]}
3.7.9 Matrice en un vecteur

Dans un langage comme le C++, il arrive frquemment quune matrice ne soit pas
reprsente par une liste de listes mais par une seule liste car cette reprsentation
est plus efficace. Il faut donc convertir un indice en deux indices ligne et colonne. Il
faut bien sr que le nombre de colonnes sur chaque ligne soit constant. Le premier
programme convertit une liste de listes en une seule liste.
mat = [[0,1,2],[3,4,5]]
lin = [ i * len (mat [i]) + j \
for i in range (0, len (mat)) \
for j in range (0, len (mat [i])) ]
Le programme suivant fait linverse. Il faut faire attention la position des crochets
et lordre des boucles for.
nc = len (mat [0])
mat = [ [ lin [i * nc + j] for j in range (0, len (mat [i])) ] \
for i in range (0, len (mat)) ]
3.7.10 Fonctions et variables

Une fonction peut aussi recevoir en paramtre une autre fonction. Lexemple sui-
vant inclut la fonction calcul_n_valeur qui prend comme paramtres l et f. Cette
fonction calcule pour toutes les valeurs x de la liste l la valeur f(x). fonction_carre
ou fonction_cube sont passes en paramtres la fonction calcul_n_valeur qui les
excute. Le paragraphe 4.10.1 page 134 prsente le mme programme mais rdig
avec des classes.
def fonction_carre(x) : return x*x
def fonction_cube (x) : return x*x*x
def calcul_n_valeur (l,f):

res = [ f(i) for i in l ]
return res
l = [0,1,2,3]
print l # affiche [0, 1, 2, 3]
l1 = calcul_n_valeur (l, fonction_carre)

print l1 # affiche [0, 1, 4, 9]
l2 = calcul_n_valeur (l, fonction_cube)

print l2 # affiche [0, 1, 8, 27]
Chapitre 4
Classes
Imaginons quune banque dtienne un fichier contenant des informations sur ses
clients et quil soit impossible pour un client davoir accs directement ces infor-
mations. Toutefois, il lui est en thorie possible de demander son banquier quelles
sont les informations le concernant dtenues par sa banque. Il est en thorie gale-
ment possible de les rectifier sil estime quelles sont incorrectes. .
On peut comparer cette banque un objet qui possde des informations et des
moyens permettant de lire ces informations et de les modifier. Vu de lextrieur,
cette banque cache son fonctionnement interne et les informations dont elle dispose,
mais propose des services ses utilisateurs.
On peut considrer la banque comme un objet au sens informatique. Ce terme d-
signe une entit possdant des donnes et des mthodes permettant de les manipuler.
Plus concrtement, une classe est un assemblage de variables appeles attributs et
de fonctions appeles mthodes. Lensemble des proprits associes aux classes est
regroup sous la dsignation de programmation objet.
4.1 Prsentation des classes : mthodes et attributs

4.1.1 Dfinition, dclaration
Dfinition 4.1 : classe

Une classe est un ensemble incluant des variables ou attributs et des fonc-
tions ou mthodes. Les attributs sont des variables accessibles depuis toute
mthode de la classe o elles sont dfinies. En Python, les classes sont des
types modifiables.
syntaxe 4.2 : classe, dfinition

class nom_classe :
# corps de la classe
# ...
Le corps dune classe peut tre vide, inclure des variables ou attributs, des
fonctions ou mthodes. Il est en tout cas indent de faon indiquer linter-
prteur Python les lignes qui forment le corps de la classe.
Les classes sont lunique moyen en langage Python de dfinir de nouveaux types
propres celui qui programme. Il nexiste pas de type "matrice" ou de type "graphe"
en langage Python qui soit prdfini 1 . Il est nanmoins possible de les dfinir au
1. Les matrices sont dfinies dans une extension externe numpy (voir le chapitre 6).
moyen des classes. Une matrice est par exemple un objet qui inclut les attributs
suivant : le nombre de lignes, le nombre de colonnes, les coefficients de la matrice.
Cette matrice inclut aussi des mthodes comme des oprations entre deux matrices
telles que laddition, la soustraction, la multiplication ou des oprations sur elle-
mme comme linversion, la transposition, la diagonalisation.
Cette liste nest pas exhaustive, elle illustre ce que peut tre une classe "matrice"
- reprsentation informatique dun objet "matrice" -, un type complexe incluant des
informations de types varis (entier pour les dimensions, rels pour les coefficients),
et des mthodes propres cet objet, capables de manipuler ces informations.
Il est tout--fait possible de se passer des classes pour rdiger un programme infor-
matique. Leur utilisation amliore nanmoins sa prsentation et la comprhension
quon peut en avoir. Bien souvent, ceux qui passent dun langage uniquement fonc-
tionnel un langage objet ne font pas marche arrire.
syntaxe 4.3 : classe, cration dune variable de type objet

cl = nom_classe ()
La cration dune variable de type objet est identique celle des types stan-
dards du langage Python : elle passe par une simple affectation. On appelle
aussi cl une instance de la classe nom_classe.
Cette syntaxe est identique la syntaxe dappel dune fonction. La cration dune
instance peut galement faire intervenir des paramtres (voir paragraphe 4.4). Le
terme instance va de paire avec le terme classe :
Dfinition 4.4 : instance

Une instance dune classe C dsigne une variable de type C. Le terme instance
ne sapplique quaux variables dont le type est une classe.
Lexemple suivant permet de dfinir une classe vide. Le mot-cl pass permet de
prciser que le corps de la classe ne contient rien.
class classe_vide:
pass
Il est tout de mme possible de dfinir une instance de la classe classe_vide sim-
plement par linstruction suivante :
class classe_vide:
pass
cl = classe_vide ()
Remarque 4.5 : type dune instance

Dans lexemple prcdent, la variable nb nest pas de type exemple_classe mais de
type instance comme le montre la ligne suivante :
print type (cl) # affiche <type instance>
Pour savoir si une variable est une instance dune classe donne, il faut utiliser la
fonction isinstance :
isinstance (cl,classe_vide) # affiche True
4. Classes 95
4.1.2 Mthodes
Dfinition 4.6 : mthode

Les mthodes sont des fonctions qui sont associes de manire explicite une
classe. Elles ont comme particularit un accs privilgi aux donnes de la
classe elle-mme.
Ces donnes ou attributs sont dfinis plus loin. Les mthodes sont en fait des fonc-
tions pour lesquelles la liste des paramtres contient obligatoirement un paramtre
explicite qui est linstance de la classe laquelle cette mthode est associe. Ce
paramtre est le moyen daccder aux donnes de la classe.
syntaxe 4.7 : classe, mthode, dfinition

class nom_classe :
def nom_methode (self, param_1, ..., param_n) :
# corps de la mthode...
A part le premier paramtre qui doit de prfrence sappeler self, la syntaxe

de dfinition dune mthode ressemble en tout point celle dune fonction. Le
corps de la mthode est indent par rapport la dclaration de la mthode,
elle-mme indente par rapport la dclaration de la classe.
Lappel cette mthode obit la syntaxe qui suit :
syntaxe 4.8 : classe, mthode, appel

cl = nom_classe () # variable de type nom_classe
t = cl.nom_methode (valeur_1, ..., valeur_n)
Lappel dune mthode ncessite tout dabord la cration dune variable. Une
fois cette variable cre, il suffit dajouter le symbole "." pour excuter la
mthode. Le paramtre self est ici implicitement remplac par cl lors de
lappel.
Lexemple suivant simule le tirage de nombres alatoires partir dune suite dfinie
par rcurrence un+1 = (un A) mod B o A et B sont des entiers trs grands. Cette
suite nest pas alatoire mais son comportement imite celui dune suite alatoire. Le
terme un est dans cet exemple contenu dans la variable globale rnd.
rnd = 42
class exemple_classe:
def methode1(self,n):
"""simule la gnration dun nombre alatoire
compris entre 0 et n-1 inclus"""
global rnd
rnd = 397204094 * rnd % 2147483647
return int (rnd % n)
nb = exemple_classe ()
l = [ nb.methode1(100) for i in range(0,10) ]
print l # affiche [19, 46, 26, 88, 44, 56, 56, 26, 0, 8]
nb2 = exemple_classe ()
l2 = [ nb2.methode1(100) for i in range(0,10) ]
print l2 # affiche [46, 42, 89, 66, 48, 12, 61, 84, 71, 41]
Deux instances nb et nb2 de la classe exemple_classe sont cres, chacune delles est
utilise pour gnrer alatoirement dix nombres entiers compris entre 0 et 99 inclus.
Les deux listes sont diffrentes puisque linstance nb2 utilise la variable globale rnd
prcdemment modifie par lappel nb.methode1(100).
Remarque 4.9 : mthodes et fonctions
Les mthodes sont des fonctions insres lintrieur dune classe. La syntaxe de
la dclaration dune mthode est identique celle dune fonction en tenant compte
du premier paramtre qui doit imprativement tre self. Les paramtres par d-
faut, lordre des paramtres, les nombres variables de paramtres prsents au pa-
ragraphe 3.4 sont des extensions tout autant applicables aux mthodes quaux fonc-
tions.
4.1.3 Attributs
Dfinition 4.10 : attribut

Les attributs sont des variables qui sont associes de manire explicite une
classe. Les attributs de la classe se comportent comme des variables globales
pour toutes les mthodes de cette classe.
Une classe permet en quelque sorte de regrouper ensemble des informations lies.
Elles nont de sens quensemble et les mthodes manipulent ces donnes lies. Cest
le cas pour un segment qui est toujours dfini par ces deux extrmits qui ne vont
pas lune sans lautre.
syntaxe 4.11 : classe, attribut, dfinition

class nom_classe :
def nom_methode (self, param_1, ..., param_n) :
self.nom_attribut = valeur
Le paramtre self nest pas un mot-cl mme si le premier paramtre est

le plus souvent appel self. Il dsigne linstance de la classe sur laquelle va
sappliquer la mthode. La dclaration dune mthode inclut toujours un pa-
ramtre self de sorte que self.nom_attribut dsigne un attribut de la classe.
nom_attribut seul dsignerait une variable locale sans aucun rapport avec un
attribut portant le mme nom. Les attributs peuvent tre dclars lintrieur
de nimporte quelle mthode, voire lextrieur de la classe elle-mme.
Lendroit o est dclar un attribut a peu dimportance pourvu quil le soit avant sa
premire utilisation. Dans lexemple qui suit, la mthode methode1 utilise lattribut
rnd sans quil ait t cr.
4. Classes 97
self.rnd = 397204094 * self.rnd % 2147483647

return int (self.rnd % n)
print l
Cet exemple dclenche donc une erreur (ou exception) signifiant que lattribut rnd
na pas t cr.
File "cours.py", line 8, in -toplevel-
File "cours.py", line 4, in methode1
self.rnd = 397204094 * self.rnd % 2147483647
AttributeError: exemple_classe instance has no attribute rnd
Pour remdier ce problme, il existe plusieurs endroits o il est possible de crer

lattribut rnd. Il est possible de crer lattribut lintrieur de la mthode methode1.
Mais le programme na plus le mme sens puisqu chaque appel de la mthode
methode1, lattribut rnd reoit la valeur 42. La liste de nombres alatoires contient
dix fois la mme valeur.
self.rnd = 42 # dclaration lintrieur de la mthode,
# doit tre prcd du mot-cl self
self.rnd = 397204094 * self.rnd % 2147483647
print l # affiche [19, 19, 19, 19, 19, 19, 19, 19, 19, 19]
Il est possible de crer lattribut rnd lextrieur de la classe. Cette criture devrait
toutefois tre vite puisque la mthode methode1 ne peut pas tre appele sans que
lattribut rnd ait t ajout.
self.rnd = 397204094 * self.rnd % 2147483647
nb.rnd = 42 # dclaration lextrieur de la classe,
# indispensable pour utiliser la mthode methode1
print l # affiche [19, 46, 26, 88, 44, 56, 56, 26, 0, 8]
4.2 Constructeur
Lendroit le plus appropri pour dclarer un attribut est lintrieur dune mthode
appele le constructeur. Sil est dfini, il est implicitement excut lors de la cration
de chaque instance. Le constructeur dune classe se prsente comme une mthode
et suit la mme syntaxe ceci prs que son nom est impos : __init__. Hormis le
premier paramtre, invariablement self, il nexiste pas de contrainte concernant la
liste des paramtres except que le constructeur ne doit pas retourner de rsultat.
syntaxe 4.12 : classe, constructeur

class nom_classe :
def __init__(self, param_1, ..., param_n):
# code du constructeur
nom_classe est une classe, __init__ est son constructeur, sa syntaxe est
la mme que celle dune mthode sauf que le constructeur ne peut employer
linstruction return.
La modification des paramtres du constructeur implique galement la modification

de la syntaxe de cration dune instance de cette classe.
syntaxe 4.13 : classe, instance

x = nom_classe (valeur_1,...,valeur_n)
nom_classe est une classe, valeur_1 valeur_n sont les valeurs associes aux
paramtres param_1 param_n du constructeur.
Lexemple suivant montre deux classes pour lesquelles un constructeur a t dfini.

La premire najoute aucun paramtre, la cration dune instance ne ncessite pas
de paramtre supplmentaire. La seconde classe ajoute deux paramtres a et b. Lors
de la cration dune instance de la classe classe2, il faut ajouter deux valeurs.
class classe1:
def __init__(self):
# pas de paramtre supplmentaire
print "constructeur de la classe classe1"
self.n = 1 # ajout de lattribut n
x = classe1 () # affiche constructeur de la classe classe1

print x.n # affiche 1
class classe2:
def __init__(self,a,b):
# deux paramtres supplmentaires
print "constructeur de la classe classe2"
self.n = (a+b)/2 # ajout de lattribut n
x = classe2 (5,9) # affiche constructeur de la classe classe2

print x.n # affiche 7
Remarque 4.14 : constructeur et fonction

Le constructeur autorise autant de paramtres quon souhaite lors de la cration
4. Classes 99
dune instance et celle-ci suit la mme syntaxe quune fonction. La cration dune
instance pourrait tre considre comme lappel une fonction ceci prs que le
type du rsultat est une instance de classe.
En utilisant un constructeur, lexemple du paragraphe prcdent simulant une suite
de variable alatoire permet dobtenir une classe autonome qui ne fait pas appel
une variable globale ni une dclaration dattribut extrieur la classe.
def __init__ (self) : # constructeur
self.rnd = 42 # on cre lattribut rnd, identique pour chaque instance
# --> les suites gnres auront toutes le mme dbut
self.rnd = 397204094 * self.rnd % 2147483647
print l # affiche [19, 46, 26, 88, 44, 56, 56, 26, 0, 8]
nb2 = exemple_classe ()
l2 = [ nb2.methode1(100) for i in range(0,10) ]
print l2 # affiche [19, 46, 26, 88, 44, 56, 56, 26, 0, 8]
De la mme manire quil existe un constructeur excut chaque cration dins-

tance, il existe un destructeur excut chaque destruction dinstance. Il suffit pour
cela de redfinir la mthode __del__. A linverse dautres langages comme le C++,
cet oprateur est peu utilis car le Python nettoie automatiquement les objets qui ne
sont plus utiliss ou plus rfrencs par une variable. Un exemple est donn page 115.
4.3 Apport du langage Python

4.3.1 Liste des attributs
Chaque attribut dune instance de classe est insr dans un dictionnaire appel
__dict__, attribut implicitement prsent ds la cration dune instance.
def __init__ (self) :
self.rnd = 42
self.rnd = 397204094 * self.rnd % 2147483647
print nb.__dict__ # affiche {rnd: 42}
Ce dictionnaire offre aussi la possibilit de tester si un attribut existe ou non. Dans

un des exemples du paragraphe prcdent, lattribut rnd tait cr dans la mthode
methode1, sa valeur tait alors initialise chaque appel et la fonction retournait
sans cesse la mme valeur. En testant lexistence de lattribut rnd, il est possible de
le crer dans la mthode methode1 au premier appel sans que les appels suivants ne
rinitialisent sa valeur 42.
if "rnd" not in self.__dict__ : # lattribut existe-t-il ?
self.rnd = 42 # cration de lattribut
self.__dict__ ["rnd"] = 42 # autre criture possible
self.rnd = 397204094 * self.rnd % 2147483647
print l # affiche [19, 46, 26, 88, 44, 56, 56, 26, 0, 8]
4.3.2 Attributs implicites

Certains attributs sont crs de manire implicite lors de la cration dune instance.
Ils contiennent des informations sur linstance.
Contient le nom du module dans lequel est incluse la classe (voir

__module__
chapitre 6).
Contient le nom de la classe de linstance. Ce nom est prcd du
__class__
nom du module suivi dun point.
Contient la liste des attributs de linstance (voir para-
__dict__
graphe 4.3.1).
Contient un commentaire associ la classe (voir para-
__doc__
graphe 4.3.3).
Lattribut __class__ contient lui mme dautres dattributs :
Contient un commentaire associ la classe (voir para-

__doc__
graphe 4.3.3).
Contient la liste des attributs statiques (dfinis hors dune m-
__dict__
thode) et des mthodes (voir paragraphe 4.5.2).
__name__ Contient le nom de linstance.
Contient les classes dont la classe de linstance hrite (voir para-
__bases__
graphe 4.8).
class classe_vide:
pass
cl = classe_vide ()
print cl.__module__ # affiche __main__
print cl.__class__ # affiche __main__.classe_vide ()
print cl.__dict__ # affiche {}
print cl.__doc__ # affiche None (voir paragraphe suivant)
print cl.__class__.__doc__ # affiche None
print cl.__class__.__dict__ # affiche {__module__: __main__,
# __doc__: None}
print cl.__class__.__name__ # affiche classe_vide
print cl.__class__.__bases__ # affiche ()
4. Classes 101
4.3.3 Commentaires, aide

Comme les fonctions et les mthodes, des commentaires peuvent tre associs une
classe, ils sont affichs grce la fonction help. Cette dernire prsente le commen-
taire associ la classe, la liste des mthodes ainsi que chacun des commentaires qui
leur sont associs. Ce commentaire est affect lattribut implicite __doc__. Lap-
pel la fonction help rassemble le commentaire de toutes les mthodes, le rsultat
suit le programme ci-dessous.
"""simule une suite de nombres alatoires"""
"""constructeur : initialisation de la premire valeur"""
self.rnd = 42
self.rnd = 397204094 * self.rnd % 2147483647
help (exemple_classe) # appelle laide associe la classe
class exemple_classe
| simule une suite de nombres alatoires
|
| Methods defined here:
|
| __init__(self)
| constructeur : initialisation de la premire valeur
|
| methode1(self, n)
| simule la gnration dun nombre alatoire
| compris entre 0 et n-1 inclus
Pour obtenir seulement le commentaire associ la classe, il suffit dcrire lune des
trois lignes suivantes :
print exemple_classe.__doc__ # affiche simule une suite de nombres alatoires
print nb.__doc__ # affiche simule une suite de nombres alatoires
print nb.__class__.__doc__ # affiche simule une suite de nombres alatoires
La fonction help permet daccder laide associe une fonction, une classe. Il
existe des outils qui permettent de collecter tous ces commentaires pour construire
une documentation au format HTML laide doutils comme pydoc 2 ou Doxygen 3 .
Ces outils sont souvent assez simples dutilisation.
La fonction dir permet aussi dobtenir des informations sur la classe. Cette fonction
applique la classe ou une instance retourne lensemble de la liste des attributs
et des mthodes. Lexemple suivant utilise la fonction dir avant et aprs lappel de
la mthode meth. Etant donn que cette mthode ajoute un attribut, la fonction dir
retourne une liste plus longue aprs lappel.
2. voir http://pydoc.org/ ou http://docs.python.org/library/pydoc.html
3. http://www.stack.nl/~dimitri/doxygen/ associ doxypy (http://code.foosel.org/doxypy).
class essai_class:
def meth(self):
x = 6
self.y = 7
a = essai_class()
print dir (a) # affiche [__doc__, __module__, meth]
a.meth ()
print dir (a) # affiche [__doc__, __module__, meth, y]
print dir (essai_class) # affiche [__doc__, __module__, meth]
La fonction dir applique la classe elle-mme retourne une liste qui inclut les
mthodes et les attributs dj dclars. Elle ninclut pas ceux qui sont dclars dans
une mthode jamais excute jusqu prsent.
4.3.4 Classe incluse

Parfois, il arrive quune classe soit exclusivement utilise en couple avec une autre,
cest par exemple le cas des itrateurs (voir paragraphe 4.4.2). Il est alors possible
dinclure dans la dclaration dune classe celle dune sous-classe.
Lexemple qui suit contient la classe ensemble_element. Cest un ensemble de points
en trois dimensions (classe element) qui nest utilis que par cette classe. Dclarer la
classe element lintrieur de la classe ensemble_element est un moyen de signifier
ce lien.
class ensemble_element :
class element :
self.x, self.y, self.z = 0,0,0

self.all = [ ensemble_element.element () for i in xrange (0,3) ]
def barycentre (self) :

b = ensemble_element.element ()
for el in self.all :
b.x += el.x
b.y += el.y
b.z += el.z
b.x /= len (self.all)
b.y /= len (self.all)
b.z /= len (self.all)
return b
f = ensemble_element ()
f.all [0].x, f.all [0].y, f.all [0].z = 4.5,1.5,1.5
b = f.barycentre ()
print b.x,b.y,b.z # affiche 1.5 0.5 0.5
Pour crer une instance de la classe element, il faut faire prcder son nom de la
classe o elle est dclare : b = ensemble_element.element() comme cest le cas dans
la mthode barycentre par exemple.
4. Classes 103
4.4 Oprateurs, itrateurs

Les oprateurs sont des symboles du langages comme +, -, +=, ... Au travers des
oprateurs, il est possible de donner un sens une syntaxe comme celle de lexemple
suivant :
class nouvelle_classe:
pass
x = nouvelle_classe () + nouvelle_classe ()
Laddition nest pas le seul symbole concern, le langage Python permet de donner
un sens tous les oprateurs numriques et dautres relis des fonctions du langage
comme len ou max.
4.4.1 Oprateurs
Le programme suivant contient une classe dfinissant un nombre complexe. La m-
thode ajoute dfinit ce quest une addition entre nombres complexes.
class nombre_complexe:
def __init__ (self, a = 0, b= 0) : self.a, self.b = a,b
def get_module (self) : return math.sqrt (self.a * self.a + self.b * self.b)
def ajoute (self,c):

return nombre_complexe (self.a + c.a, self.b + c.b)
c1 = nombre_complexe (0,1)
c = c1.ajoute (c2) # c = c1 + c2
print c.a, c.b
Toutefois, on aimerait bien crire simplement c = c1 + c2 au lieu de c = c1.ajoute(c2)

car cette syntaxe est plus facile lire et surtout plus intuitive. Le langage Py-
thon offre cette possibilit. Il existe en effet des mthodes cls dont limplmenta-
tion dfinit ce qui doit tre fait dans le cas dune addition, dune comparaison, dun
affichage, ... A linstar du constructeur, toutes ces mthodes cls, quon appelle des
oprateurs, sont encadres par deux blancs souligns, leur dclaration suit invaria-
blement le mme schma. Voici celui de loprateur __add__ qui dcrit ce quil faut
faire pour une addition.
syntaxe 4.15 : classe, oprateur __add__

class nom_class :
def __add__ (self, autre) :
# corps de loprateur
return ... # nom_classe
nom_classe est une classe. Loprateur __add__ dfinit laddition entre lins-
tance self et linstance autre et retourne une instance de la classe nom_classe.
Le programme suivant reprend le prcdent de manire ce que laddition de deux

nombres complexes soit dornavant une syntaxe correcte.
def __add__(self, c):

return nombre_complexe (self.a + c.a, self.b + c.b)
c = c1 + c2 # cette expression est maintenant syntaxiquement correcte
c = c1.__add__ (c2) # mme ligne que la prcdente mais crite explicitement
print c.a, c.b
Lavant dernire ligne appelant la mthode __add__ transcrit de faon explicite

ce que le langage Python fait lorsquil rencontre un oprateur + qui sapplique
des classes. Plus prcisment, c1 et c2 pourraient tre de classes diffrentes, lex-
pression serait encore valide du moment que la classe dont dpend c1 a redfini la
mthode __add__. Chaque oprateur possde sa mthode-cl associe. Loprateur
+=, diffrent de + est associ la mthode-cl __iadd__.
syntaxe 4.16 : classe, oprateur __iadd__

class nom_class :
def __iadd__ (self, autre) :
return self
nom_classe est une classe. Loprateur __iadd__ dfinit laddition entre

linstance self et linstance autre. Linstance self est modifie pour recevoir
le rsultat. Loprateur retourne invariablement linstance modifie self.
On toffe la classe nombre_complexe laide de loprateur __iadd__.
def __add__(self, c) : return nombre_complexe (self.a + c.a, self.b + c.b)
def __iadd__(self, c) :
self.a += c.a
self.b += c.b
return self
c1 += c2 # utilisation de loprateur +=
c1.__iadd__ (c2) # cest la transcription explicite de la ligne prcdente
print c1.a, c1.b
Un autre oprateur souvent utilis est __str__ qui permet de redfinir laffichage
dun objet lors dun appel linstruction print.
4. Classes 105
syntaxe 4.17 : classe, oprateur __str__

class nom_class :
def __str__ (self) :
return...
nom_classe est une classe. Loprateur __str__ construit une chane de ca-
ractres quil retourne comme rsultat de faon tre affich.
Lexemple suivant reprend la classe nombre_complexe pour que linstruction print

affiche un nombre complexe sous la forme a + ib.
def __add__(self, c) : return nombre_complexe (self.a + c.a, self.b + c.b)

if self.b == 0 : return "%f" % (self.a)
elif self.b > 0 : return "%f + %f i" % (self.a, self.b)
else : return "%f - %f i" % (self.a, -self.b)
c3 = c1 + c2
print c3 # affiche 1.000000 + 1.000000 i
Il existe de nombreux oprateurs quil est possible de dfinir. La table 4.1 (page 137)
prsente les plus utiliss. Parmi ceux-l, on peut sattarder sur les oprateurs
__getitem__ et __setitem__, ils redfinissent loprateur [] permettant dac-
cder un lment dune liste ou dun dictionnaire. Le premier, __getitem__ est
utilis lors dun calcul, un affichage. Le second, __setitem__, est utilis pour af-
fecter une valeur.
Lexemple suivant dfinit un point de lespace avec trois coordonnes. Il redfinit
ou surcharge les oprateurs __getitem__ et __setitem__ de manire pouvoir
accder aux coordonnes de la classe point_espace qui dfinit un point dans lespace.
En rgle gnrale, lorsque les indices ne sont pas corrects, ces deux oprateurs lvent
lexception IndexError (voir le chapitre 5).
class point_espace:
def __init__ (self, x,y,z): self._x, self._y, self._z = x,y,z
def __getitem__(self,i):
if i == 0 : return self._x
if i == 1 : return self._y
if i == 2 : return self._z
# pour tous les autres cas --> erreur
raise IndexError ("indice impossible, 0,1,2 autoriss")
def __setitem__(self,i,x):
if i == 0 : self._x = x
elif i == 1 : self._y = y
elif i == 2 : self._z = z
def __str__(self):
return "(%f,%f,%f)" % (self._x, self._y, self._z)
a = point_espace (1,-2,3)
print a # affiche (1.000000,-2.000000,3.000000)

a [1] = -3 # (__setitem__) affecte -3 a.y
print "abscisse : ", a [0] # (__getitem__) affiche abscisse : 1
print "ordonne : ", a [1] # (__getitem__) affiche ordonne : -3
print "altitude : ", a [2] # (__getitem__) affiche altitude : 3
Par le biais de lexception IndexError, les expressions a[i] avec i 6= 0, 1, 2 sont impos-
sibles et arrtent le programme par un message comme celui qui suit obtenu aprs
linterprtation de print a [4] :
File "point_espace.py", line 31, in ?
print a [4]
File "point_espace.py", line 13, in __getitem__
raise IndexError, "indice impossible, 0,1,2 autoriss"
IndexError: indice impossible, 0,1,2 autoriss
4.4.2 Itrateurs
Loprateur __iter__ permet de dfinir ce quon appelle un itrateur. Cest un
objet qui permet den explorer un autre, comme une liste ou un dictionnaire. Un
itrateur est un objet qui dsigne un lment dun ensemble parcourir et qui
connat llment suivant visiter. Il doit pour cela contenir une rfrence lobjet
quil doit explorer et inclure une mthode next qui retourne llment suivant ou
lve une exception si llment actuel est le dernier.
Par exemple, on cherche explorer tous les lments dun objet de type
point_espace dfini au paragraphe prcdent. Cette exploration doit seffectuer au
moyen dune boucle for.
for x in a:
print x # affiche successivement 1,-2,3
Cette boucle cache en fait lutilisation dun itrateur qui apparat explicitement dans
lexemple suivant quivalent au prcdent (voir paragraphe 3.3.2.3, page 66).
it = iter (a)
while True:
try : print it.next ()
except StopIteration : break
Afin que cet extrait de programme fonctionne, il faut dfinir un itrateur pour
la classe point_espace. Cet itrateur doit inclure la mthode next. La classe
point_espace doit quant elle dfinir loprateur __iter__ pour retourner lit-
rateur qui permettra de lexplorer.
4. Classes 107
class point_espace:
def __init__ (self, x,y,z):
self._x, self._y, self._z = x,y,z
def __str__(self):
class class_iter:
"""cette classe dfinit un itrateur pour point_espace"""
def __init__ (self,ins):
"""initialisation, self._ins permet de savoir quelle
instance de point_espace on explore,
self._n mmorise lindice de llment explor"""
self._n = 0
self._ins = ins
def __iter__ (self) : # le langage impose cette mthode

return self # dans certaines configurations
def next (self):

"""retourne llment dindice self._n et passe llment suivant"""
if self._n <= 2:
v = self._ins [self._n]
self._n += 1
return v
else :
# si cet lment nexiste pas, lve une exception
raise StopIteration
def __iter__(self):
"""oprateur de la classe point_espace, retourne un itrateur
permettant de lexplorer"""
return point_espace.class_iter (self)
for x in a:
Cette syntaxe peut paratre fastidieuse mais elle montre de manire explicite le
fonctionnement des itrateurs. Cette construction est plus proche de ce que dautres
langages objets proposent. Python offre nanmoins une syntaxe plus courte avec le
mot-cl yield qui permet dviter la cration de la classe class_iter. Le code de la
mthode __iter__ change mais les dernires lignes du programme prcdent qui
affichent successivement les lments de point_espace sont toujours valides.
class point_espace:
def __init__ (self, x,y,z):
self._x, self._y, self._z = x,y,z
def __str__(self):
def __iter__(self):
"""itrateur avec yield (ou gnrateur)"""
_n = 0
while _n <= 2 :
yield self.__getitem__ (_n)
_n += 1
for x in a:
4.5 Mthodes, attributs statiques et ajout de mthodes

4.5.1 Mthode statique
Dfinition 4.18 : mthode statique

Les mthodes statiques sont des mthodes qui peuvent tre appeles mme si
aucune instance de la classe o elles sont dfinies na t cre.
Lexemple suivant dfinit une classe avec une seule mthode. Comme toutes les
mthodes prsentes jusqu prsent, elle inclut le paramtre self qui correspond
linstance pour laquelle elle est appele.
class essai_class:
def methode (self):
print "mthode non statique"
x = essai_class ()
x.methode ()
Une mthode statique ne ncessite pas quune instance soit cre pour tre appele.
Cest donc une mthode nayant pas besoin du paramtre self.
syntaxe 4.19 : classe, mthode statique

class nom_class :
def nom_methode(params, ...) :
# corps de la mthode
...
nom_methode = staticmethod (nom_methode)
nom_classe est une classe, nom_methode est une mthode statique. Il faut
pourtant ajouter la ligne suivante pour indiquer la classe que cette mthode
est bien statique laide du mot-cl staticmethod.
Le programme prcdent est modifi pour inclure une mthode statique. La mthode
methode ne ncessite aucune cration dinstance pour tre appele.
4. Classes 109
class essai_class:
def methode ():
print "mthode statique"
methode = staticmethod(methode)
essai_class.methode ()
Remarque 4.20 : dclaration dune mthode statique

Il est galement possible de dclarer une fonction statique lextrieur dune classe
puis de lajouter en tant que mthode statique cette classe. Le programme suivant
dclare une fonction methode puis indique la classe essai_class que la fonction
est aussi une mthode statique de sa classe (avant-dernire ligne de lexemple).
def methode ():

print "mthode statique"
class essai_class:
pass
essai_class.methode = staticmethod(methode)
essai_class.methode ()
Toutefois, il est conseill de placer linstruction qui contient staticmethod lint-

rieur de la classe. Elle ny sera excute quune seule fois comme le montre lexemple
suivant :
class essai_class:
print "cration dune instance de la classe essai_class"
methode = staticmethod(methode)
cl = classe_vide () # affiche cration dune instance de la classe essai_class
ck = classe_vide () # naffiche rien
Les mthodes statiques sont souvent employes pour crer des instances spcifiques
dune classe.
class Couleur :
def __init__ (self, r, v, b) : self.r, self.v, self.b = r, v, b
def __str__ (self) : return str ( (self.r,self.v,self.b))
def blanc () : return Couleur (255,255,255)
def noir () : return Couleur (0,0,0)
blanc = staticmethod (blanc)
noir = staticmethod (noir)
c = Couleur.blanc ()
print c # affiche (255, 255, 255)
c = Couleur.noir ()
print c # affiche (0, 0, 0)
4.5.2 Attributs statiques
Dfinition 4.21 : attribut statique

Les attributs statiques sont des attributs qui peuvent tre utiliss mme si
aucune instance de la classe o ils sont dfinis na t cre. Ces attributs sont
partags par toutes les instances.
syntaxe 4.22 : classe, attribut statique

class nom_class :
attribut_statique = valeur
def nom_methode (self,params, ...):
nom_class.attribut_statique2 = valeur2
def nom_methode_st (params, ...) :
nom_class.attribut_statique3 = valeur3
nom_methode_st = staticmethod (nom_methode_st)
nom_classe est une classe, nom_methode est une mthode non sta-
tique, nom_methode_st est une mthode statique. Les trois paramtres
attribut_statique, attribut_statique2, attribut_statique3 sont statiques,
soit parce quils sont dclars en dehors dune mthode, soit parce que leur
dclaration fait intervenir le nom de la classe.
Pour le programme suivant, la mthode meth nutilise pas self.x mais essai_class.x.
Lattribut x est alors un attribut statique, partag par toutes les instances. Cest
pourquoi dans lexemple qui suit linstruction z.meth() affiche la valeur 6 puisque
lappel y.meth() a incrment la variable statique x.
class essai_class:
x = 5
def meth(self):
print essai_class.x
essai_class.x += 1
y = essai_class ()
z = essai_class ()
y.meth() # affiche 5
z.meth() # affiche 6
Remarque 4.23 : ambigut

Mme si un attribut est statique, il peut tre utilis avec la syntaxe
self.attribut_statique dans une mthode non statique condition quun attri-
but non statique ne porte pas le mme nom. Si tel est pourtant le cas, certaines
confusions peuvent apparatre :
rnd = 42
def incremente_rnd (self):
self.rnd += 1
return self.rnd
cl = exemple_classe()
4. Classes 111
print cl.__dict__ # affiche {}

print cl.__class__.__dict__ ["rnd"] # affiche 42
cl.incremente_rnd ()
print cl.__dict__ # affiche {rnd: 43}
print cl.__class__.__dict__ ["rnd"] # affiche 42
Dans ce cas, ce sont en fait deux attributs qui sont crs. Le premier est un attribut
statique cr avec la seconde ligne de lexemple rnd = 42. Le second attribut nest pas
statique et apparat ds la premire excution de linstruction self.rnd+=1 comme
le montre son apparition dans lattribut __dict__ qui ne recense pas les attributs
statiques.
4.5.3 Ajout de mthodes

Ce point dcrit une fonctionnalit du langage Python rarement utilise. Il offre la
possibilit dajouter une mthode une classe alors mme que cette fonction est
dfinie lextrieur de la dclaration de la classe. Cette fonction doit obligatoirement
accepter un premier paramtre qui recevra linstance de la classe. La syntaxe utilise
le mot-cl classmethod.
syntaxe 4.24 : classe, classmethod

def nom_methode (cls) :
# code de la fonction}
class nom_classe :
# code de la classe
nom_methode = classmethod (nom_methode) # syntaxe 1
nom_classe.nom_methode = classmethod (nom_methode) # syntaxe 2
nom_classe est une classe, nom_methode est une mthode, nom_methode est
une fonction qui est par la suite considre comme une mthode de la classe
nom_methode grce lune ou lautre des deux instructions incluant le mot-cl
classmethod.
Dans lexemple qui suit, cette syntaxe est utilise pour inclure trois mthodes la
classe essai_class selon que la mthode est dclare et affecte cette classe
lintrieur ou lextrieur du corps de essai_class.
def meth3 (cls): print "ok meth3", cls.x

def meth4 (cls): print "ok meth4", cls.x
class essai_classe:
x = 5
def meth(self): print "ok meth", self.x
def meth2(cls): print "ok meth2", cls.x
meth3 = classmethod (meth3)
x = essai_classe ()
x.meth () # affiche ok meth 5
x.meth2 () # affiche ok meth2 5
essai_classe.meth4 = classmethod (meth4)

4.5.4 Proprits
Cette fonctionnalit est galement peu utilise, elle permet des raccourcis dcriture.
Les proprits permettent de faire croire lutilisateur dune instance de classe quil
utilise une variable alors quil utilise en ralit une ou plusieurs mthodes. A chaque
fois que le programmeur utilise ce faux attribut, il appelle une mthode qui calcule
sa valeur. A chaque fois que le programmeur cherche modifier la valeur de ce faux
attribut, il appelle une autre mthode qui modifie linstance.
syntaxe 4.25 : classe, proprit

class nom_classe :
# code de la classe
nom_propriete = property (fget, fset, fdel, doc)
Au sein de ces trois lignes, nom_classe est une classe, nom_propriete est
le nom de la proprit, fget est la mthode qui doit retourner la valeur du
pseudo-attribut nom_propriete, fset est la mthode qui doit modifier la valeur
du pseudo-attribut nom_propriete, fdel est la mthode qui doit dtruire le
pseudo-attribut nom_propriete, doc est un commentaire qui apparatra lors de
lappel de la fonction help(nom_class) ou help(nom_class.nom_propriete).
Pour illustrer lutilisation des proprits, on part dune classe nombre_complexe qui
ne contient que les parties relle et imaginaire. Lorsquon cherche obtenir le mo-
dule 4 , on fait appel une mthode qui calcule ce module. Lorsquon cherche mo-
difier ce module, on fait appel une autre mthode qui multiplie les parties relle
et imaginaire par un nombre rel positif de manire ce que le nombre complexe
ait le module demand. On procde de mme pour la proprit arg.
La proprit conj retourne quant elle le conjugu du nombre complexe mais la
rciproque nest pas prvue. On ne peut affecter une valeur conj.
import math
class nombre_complexe(object): # voir remarque aprs lexemple

def __init__ (self, a = 0, b= 0):
self.a = a
self.b = b

if self.b == 0 : return "%f" % (self.a)
elif self.b > 0 : return "%f + %f i" % (self.a, self.b)
else : return "%f - %f i" % (self.a, -self.b)
def get_module (self):

return math.sqrt (self.a * self.a + self.b * self.b)
4. Le module
dsigne ici le module dun nombre complexe qui est gal sa norme. On le note
|a + ib| = a2 + b2 .
4. Classes 113
def set_module (self,m):

r = self.get_module ()
if r == 0:
self.a = m
self.b = 0
else :
d = m / r
self.a *= d
self.b *= d
def get_argument (self) :

r = self.get_module ()
if r == 0 : return 0
else : return math.atan2 (self.b / r, self.a / r)
def set_argument (self,arg) :

m = self.get_module ()
self.a = m * math.cos (arg)
self.b = m * math.sin (arg)
def get_conjugue (self):

return nombre_complexe (self.a,-self.b)
module = property (fget = get_module, fset = set_module, doc = "module")

arg = property (fget = get_argument, fset = set_argument, doc = "argument")
conj = property (fget = get_conjugue, doc = "conjugu")
c = nombre_complexe (0.5,math.sqrt (3)/2)

print "c = ", c # affiche c = 0.500000 + 0.866025 i
print "module = ", c.module # affiche module = 1.0
print "argument = ", c.arg # affiche argument = 1.0471975512
c = nombre_complexe ()
c.module = 1
c.arg = math.pi * 2 / 3
print "c = ", c # affiche c = -0.500000 + 0.866025 i
print "module = ", c.module # affiche module = 1.0
print "argument = ", c.arg # affiche argument = 2.09439510239
print "conjugu = ", c.conj # affiche conjugu = -0.500000 - 0.866025 i
La proprit conj ne possde pas de fonction qui permet de la modifier. Par cons-
quent, linstruction c.conj = nombre_complexe(0, 0) produit lerreur suivante :

File "cour2.py", line 53, in ?
c.conj = nombre_complexe (0,0)
AttributeError: cant set attribute
Etant donn quune proprit porte dj le nom de conj, aucun attribut du mme
nom ne peut tre ajout la classe nombre_complexe.
Remarque 4.26 : proprit et hritage
Afin que la proprit fonctionne correctement, il est ncessaire que la classe hrite
de la classe object ou une de ses descendantes (voir galement paragraphe 4.8).
4.6 Copie dinstances

4.6.1 Copie dinstance de classe simple
Aussi trange que cela puisse paratre, le signe = ne permet pas de recopier une
instance de classe. Il permet dobtenir deux noms diffrents pour dsigner le mme
objet. Dans lexemple qui suit, la ligne nb2 = nb ne fait pas de copie de linstance
nb, elle permet dobtenir un second nom nb2 pour linstance nb. Vu de lextrieur,
la ligne nb2.rnd = 0 parat modifier la fois les objets nb et nb2 puisque les lignes
print nb.rnd et print nb2.rnd affichent la mme chose. En ralit, nb et nb2 dsignent
le mme objet.
def __init__ (self) : self.rnd = 42
self.rnd = 397204094 * self.rnd % 2147483647
nb2 = nb
print nb.rnd # affiche 42
print nb2.rnd # affiche 42
nb2.rnd = 0
print nb2.rnd # affiche 0, comme prvu

print nb.rnd # affiche 0, si nb et nb2 taient des objets diffrents,
# cette ligne devrait afficher 42
Pour crer une copie de linstance nb, il faut le dire explicitement en utilisant la
fonction copy du module copy (voir le chapitre 6).
syntaxe 4.27 : fonction copy

import copy
nom_copy = copy.copy (nom_instance)
nom_instance est une instance copier, nom_copy est le nom dsignant la

copie.
Lexemple suivant applique cette copie sur la classe exemple_classe gnrant des
nombres alatoires.
def __init__ (self) : self.rnd = 42
self.rnd = 397204094 * self.rnd % 2147483647
import copy # pour utiliser le module copy

nb2 = copy.copy (nb) # copie explicite

4. Classes 115
nb2.rnd = 0

Remarque 4.28 : suppression de variables associes la mme instance

Le symbole galit ne fait donc pas de copie, ceci signifie quune mme instance de
classe peut porter plusieurs noms.
m = [ 0, 1 ]
m2 = m
del m2 # supprime lidentificateur mais pas la liste
print m # affiche [0, 1]
La suppression dun objet nest effective que sil ne reste aucune variable le rfren-
ant. Lexemple suivant le montre.
class CreationDestruction (object) :

print "constructeur"
def __new__ (self) :

print "__new__"
return object.__new__ (self)
def __del__ (self) :

print "__del__"
print "a"
m = CreationDestruction ()
print "b"
m2 = m
print "c"
del m
print "d"
del m2
print "e"
La sortie de ce programme est la suivante :

a
__new__
constructeur
b
c
d
__del__
e
Le destructeur est appel autant de fois que le constructeur. Il est appel lorsque
plus aucun identificateur nest reli lobjet. Cette configuration survient lors de
lexemple prcdent car le mot-cl del a dtruit tous les identificateurs m et m2 qui
taient relis au mme objet.
4.6.2 Copie dinstance de classes incluant dautres classes

La fonction copy nest pas suffisante lorsquune classe inclut des attributs qui sont
eux-mmes des classes incluant des attributs. Dans lexemple qui suit, la classe
exemple_classe inclut un attribut de type classe_incluse qui contient un attribut
attr. Lors de la copie laide de linstruction nb2 = copy.copy(nb), lattribut inclus
nest pas copi, cest linstruction nb2.inclus = nb.inclus qui est excute. On se
retrouve donc avec deux noms qui dsignent encore le mme objet.
class classe_incluse:
def __init__ (self) : self.attr = 3
self.inclus = classe_incluse ()
self.rnd = 42
import copy # pour utiliser le module copy

nb2 = copy.copy (nb) # copie explicite
print nb.inclus.attr # affiche 3

print nb2.inclus.attr # affiche 3
nb2.inclus.attr = 0
print nb.inclus.attr # affiche 0 (on voudrait 3 ici)

Pour effectivement copier les attributs dont le type est une classe, la premire option
- la plus simple - est de remplacer la fonction copy par la fonction deepcopy. Le
comportement de cette fonction dans le cas des classes est le mme que dans le cas
des listes comme lexplique la remarque 2.18 page 48. La seconde solution, rarement
utilise, est dutiliser loprateur __copy__ et ainsi crire le code associ la copie
des attributs de la classe.
syntaxe 4.29 : classe, oprateur __copy__
class nom_classe :
def __copy__ () :
copie = nom_classe (...)
# ...
return copie
nom_classe est le nom dune classe. La mthode __copy__ doit retourner

une instance de la classe nom_classe, dans cet exemple, cette instance a pour
nom copie.
Lexemple suivant montre un exemple dimplmentation de la classe __copy__.

Cette mthode cre dabord une autre instance copie de la classe exemple_classe
puis initialise un par un ses membres. Lattribut rnd est recopi grce une affec-
tation car cest un nombre. Lattribut inclus est recopi grce la fonction copy
du module copy car cest une instance de classe. Aprs la copie, on vrifie bien que
4. Classes 117
modifier lattribut inclus.attr de linstance nb ne modifie pas lattribut inclus.attr

de linstance nb2.
import copy
self.rnd = 42
def __copy__ (self):
copie = exemple_classe ()
copie.rnd = self.rnd
copie.inclus = copy.copy (self.inclus)
return copie
nb2 = copy.copy (nb) # copie explicite,

# utilise loprateur __copy__,
# cette ligne est quivalente
# nb2 = nb.__copy__()

nb.inclus.attr = 0
nb.rnd = 1

print nb2.inclus.attr # affiche 3 (cest le rsultat souhait)
Remarque 4.30 : affectation et copie

On peut se demander pourquoi laffectation nest pas quivalente une copie. Cela
tient au fait que laffectation en langage Python est sans cesse utilise pour affecter le
rsultat dune fonction une variable. Lorsque ce rsultat est de taille consquente,
une copie peut prendre du temps. Il est prfrable que le rsultat de la fonction
reoive le nom prvu pour le rsultat.
def fonction_liste ():
return range (4,7) # retourne la liste [4,5,6]
l = fonction_liste () # la liste [4,5,6] nest pas recopie,
# lidentificateur l lui est affect
Lorsquune fonction retourne un rsultat mais que celui-ci nest pas attribu un
nom de variable. Le langage Python dtecte automatiquement que ce rsultat nest
plus li aucune variable. Il est dtruit automatiquement.
def fonction_liste ():
return range (4,7)
fonction_liste () # la liste [4,5,6] nest pas recopie,

# elle nest pas non plus attribue une variable,
# elle est alors dtruite automatiquement par le langage Python
4.6.3 Listes et dictionnaires

Les listes et les dictionnaires sont des types modifiables et aussi des classes. Par
consquent, laffectation et la copie ont un comportement identique celui des
classes.
l = [4,5,6]
l2 = l
print l # affiche [4, 5, 6]
print l2 # affiche [4, 5, 6]
l2 [1] = 10
Pour effectuer une copie, il faut crire le code suivant :

l = [4,5,6]
import copy
l2 = copy.copy (l)
l2 [1] = 10
La fonction copy ne suffit pourtant pas lorsque lobjet copier est par exemple une
liste incluant dautres objets. Elle copiera la liste et ne fera pas de copie des objets
eux-mmes.
import copy
l = [ [i] for i in range(0,3)]
ll = copy.copy (l)
print l, " - ", ll # affiche [[0], [1], [2]] - [[0], [1], [2]]
ll [0][0] = 6
Il nest pas possible de modifier la mthode __copy__ dun objet de type liste. Il
existe nanmoins la fonction deepcopy qui permet de faire une copie la fois de la
liste et des objets quelle contient.
import copy
l = [ [i] for i in range(0,3)]
ll = copy.deepcopy (l)
ll [0][0] = 6
4. Classes 119
4.6.4 copy et deepcopy
La fonction copy effectue une copie dun objet, la fonction deepcopy effectue une
copie dun objet et de ceux quil contient. La fonction copy est associe la mthode
__copy__ tandis que la fonction deepcopy est associe la mthode __deepcopy__.
Il est rare que lune de ces deux mthodes doivent tre redfinies. Lintrt de ce
paragraphe est plus de montrer le mcanisme que cache la fonction deepcopy qui est
la raison pour laquelle il existe deux fonctions de copie et non une seule.
syntaxe 4.31 : fonction deepcopy

import copy
memo = { }
nom_copy = copy.deepcopy (nom_instance [,memo])
nom_instance est une instance copier, nom_copy est le nom dsignant la

copie. memo est un paramtre facultatif : sil est envoy la fonction deepcopy,
il contiendra alors la liste de toutes les copies dobjet effectues lors de cet
appel.
syntaxe 4.32 : classe, oprateur __deepcopy__

class nom_classe :
def __deepcopy__ (self,memo) :
copie = copy.copy (self)
# ...
return copie
nom_classe est le nom dune classe. La mthode __deepcopy__ doit retourner

une instance de la classe nom_classe, dans cet exemple, cette instance a pour
nom copie. Le paramtre memo permet de conserver la liste des copies effectues
condition dappeler deepcopy avec un dictionnaire en paramtre.
Le programme suivant reprend le second programme du paragraphe 4.6.2 et modifie

la classe classe_incluse pour distinguer copie et copie profonde. Il peut tre utile
de lire le paragraphe 2.3.3.4 (page 52) pour comprendre pourquoi un dictionnaire
utilisant comme cl une instance de classe est possible.
import copy
self.rnd = 42
def __copy__ (self):
copie = exemple_classe ()
copie.rnd = self.rnd
return copie
def __deepcopy__ (self,memo):
if self in memo : return memo [self]
copie = copy.copy (self)
memo [self] = copie # mmorise la copie de self qui est copie
copie.inclus = copy.deepcopy (self.inclus,memo)

return copie
nb2 = copy.deepcopy (nb) # copie explicite tous niveaux,

# utilise loprateur __copy__,
# cette ligne est quivalente
# nb2 = nb.__deepcopy__()

nb.inclus.attr = 0
nb.rnd = 1

print nb2.inclus.attr # affiche 3 # rsultat souhait
On peut se demander quel est lintrt de la mthode __deepcopy__ et surtout

du paramtre memo modifi par la ligne memo[self] = copie. Ce dtail est important
lorsquun objet inclut un attribut gal lui-mme ou inclut un objet qui fait rfrence
lobjet de dpart comme dans lexemple qui suit.
import copy
class Objet1 :
def __init__ (self, i) : self.i = i
return "o1 " + str (self.i) + " : " + str (self.o2.i)
class Objet2 :
def __init__ (self, i, o) :
self.i = i
self.o1 = o
o.o2 = self
def __deepcopy__ (self,memo) : return Objet2 (self.i, self.o1)
o1 = Objet1 (1)
o2 = Objet2 (2, o1)
print o1 # affiche o1 1 : 2
o3 = copy.deepcopy (o2)
o3.i = 4
print o1 # affiche o1 1 : 4 --> on voudrait 2
On modifie le programme comme suit pour obtenir une recopie dinstances de classes
qui pointent les unes sur vers les autres. Le paramtre memo sert savoir si la copie
4. Classes 121
de lobjet a dj t effectue ou non. Si non, on fait une copie, si oui, on retourne

la copie prcdemment effectue et conserve dans memo.
import copy
class Objet1 :
def __init__ (self, i) : self.i = i
def __deepcopy__ (self,memo={}) :
r = Objet1 (self.i)
memo [self] = r
r.o2 = copy.deepcopy (self.o2, memo)
return r
class Objet2 :
def __init__ (self, i, o) :
self.i = i
self.o1 = o
o.o2 = self
def __deepcopy__ (self,memo = {}) :

r = Objet2 (self.i, self.o1)
memo [self] = r
r.o1 = copy.deepcopy (self.o1, memo)
return r
o1 = Objet1 (1)
o2 = Objet2 (2, o1)
o3 = copy.deepcopy (o2)
o3.i = 4
print o1 # affiche o1 1 : 2 --> on a 2 cette fois-ci
Ces problmatiques se rencontrent souvent lorsquon aborde le problme de la s-

rialisation dun objet qui consiste enregistrer tout objet dans un fichier, mme
si cet objet inclut des rfrences des objets qui font rfrence lui-mme. Cest
ce quon appelle des rfrences circulaires. Lenregistrement dun tel objet avec des
rfrences circulaires et sa relecture depuis un fichier se rsolvent avec les mmes
artifices que ceux proposs ici pour la copie. Lutilisation des oprateurs __copy__
et __deepcopy__ est peu frquente. Les fonctions copy et deepcopy du module copy
suffisent dans la plupart des cas.
4.7 Attributs figs

Il arrive parfois quune classe contienne peu dinformations et soit utilise pour
crer un trs grand nombre dinstances. Les paragraphes prcdents ont montr
que lutilisation des attributs tait assez souple. Il est toujours possible dajouter
un attribut nimporte quelle instance. En contrepartie, chaque instance conserve
en mmoire un dictionnaire __dict__ qui recense tous les attributs qui lui sont
associs. Pour une classe susceptible dtre frquemment instancie comme un point
dans lespace (voir paragraphe 4.5.4), chaque instance na pas besoin davoir une
liste variable dattributs. Le langage Python offre la possibilit de figer cette liste.
syntaxe 4.33 : classe, __slots__

class nom_classe (object) :
__slots__ = "attribut_1", ..., "attribut_n"
nom_classe est le nom de la classe, elle doit hriter de object ou dune classe
qui en hrite elle-mme (voir paragraphe 4.8). Il faut ensuite ajouter au dbut
du corps de la classe la ligne __slots__ = attribut_1, ..., attribut_n
o attribut_1 attribut_n sont les noms des attributs de la classe. Aucun
autre ne sera accept.
Lexemple suivant utilise cette syntaxe pour dfinir un point avec seulement trois
attributs _x, _y, _z.
class point_espace(object):
__slots__ = "_x", "_y", "_z"
def __init__ (self, x,y,z): self._x, self._y, self._z = x,y,z

def __str__(self): return "(%f,%f,%f)" % (self._x, self._y, self._z)
print a
Etant donn que la liste des attributs est fige, linstruction a.j = 6 qui ajoute un
attribut j linstance a dclenche une exception (voir paragraphe 5). La mme erreur
se dclenche si on cherche ajouter cet attribut depuis une mthode (self.j = 6).
File "cours4.py", line 15, in ?
a.j = 6
AttributeError: point_espace object has no attribute j
Lattribut __dict__ nexiste pas non plus, par consquent, lexpres-

sion a.__dict__ gnre la mme exception. La prsence de linstruction
__slots__ = ... na aucun incidence sur les attributs statiques.
4.8 Hritage
Lhritage est un des grands avantages de la programmation objet. Il permet de
crer une classe partir dune autre en ajoutant des attributs, en modifiant ou
4. Classes 123
en ajoutant des mthodes. En quelque sorte, on peut modifier des mthodes dune
classe tout en conservant la possibilit dutiliser les anciennes versions.
4.8.1 Exemple autour de pices de monnaie

On dsire raliser une exprience laide dune pice de monnaie. On effectue cent
tirages successifs et on compte le nombre de fois o la face pile tombe. Le programme
suivant implmente cette exprience sans utiliser la programmation objet.
import random # extension interne incluant des fonctions
# simulant des nombres alatoires,
# random.randint (a,b) --> retourne un nombre entier entre a et b
# cette ligne doit tre ajoute tous les exemples suivant
# mme si elle ny figure plus
def cent_tirages () :
s = 0
for i in range (0,100) : s += random.randint (0,1)
return s
print cent_tirages ()
On dsire maintenant raliser cette mme exprience pour une pice truque pour
laquelle la face pile sort avec une probabilit de 0, 7. Une solution consiste rcrire
la fonction cent_tirages pour la pice truque.
def cent_tirages () :
s = 0
for i in range (0,100) :
t = random.randint (0,10)
if t >= 3 : s += 1
return s
print cent_tirages ()
Toutefois cette solution nest pas satisfaisante car il faudrait rcrire cette fonction
pour chaque pice diffrente pour laquelle on voudrait raliser cette exprience. Une
autre solution consiste donc passer en paramtre de la fonction cent_tirages une
fonction qui reproduit le comportement dune pice, quelle soit normale ou truque.
def piece_normale () :
return random.randint (0,1)
def piece_truquee () :
if t >= 3 : return 1
else : return 0
def cent_tirages (piece) :

s = 0
for i in range (0,100) : s += piece ()
return s
print cent_tirages (piece_normale)

print cent_tirages (piece_truquee)
Mais cette solution possde toujours un inconvnient car les fonctions associes
chaque pice nacceptent aucun paramtre. Il nest pas possible de dfinir une pice
qui est normale si la face pile vient de sortir et qui devient truque si la face face
vient de sortir 5 . On choisit alors de reprsenter une pice normale par une classe.
class piece_normale :
def tirage (self) :
def cent_tirages (self) :

s = 0
for i in range (0,100) : s += self.tirage ()
return s
p = piece_normale ()
print p.cent_tirages ()
On peut aisment recopier et adapter ce code pour la pice truque.

def tirage (self) :

s = 0
return s
class piece_truquee :
def tirage (self) :
else : return 0

s = 0
return s
p2 = piece_truquee ()
print p2.cent_tirages ()
Toutefois, pour les deux classes piece_normale et piece_truquee, la mthode

cent_tirage est exactement la mme. Il serait prfrable de ne pas rpter ce code
puisque si nous devions modifier la premire - un nombre de tirages diffrent par
5. Il faudrait pour cela crer une variable globale.
avant = 0
def piece_tres_truquee() :
global avant
if avant == 0 : avant = piece_truquee()
else : avant = piece_normale()
return avant
Cest comme si la fonction piece_tres_truquee avait un paramtre cach. Cette solution nest
pas conseille car cest le genre de dtail quon oublie par la suite.
4. Classes 125
exemple -, il faudrait galement modifier la seconde. La solution passe par lhri-

tage. On va dfinir la classe piece_truquee partir de la classe piece_normale en
remplaant seulement la mthode tirage puisquelle est la seule changer.
On indique la classe piece_truquee quelle hrite - ou drive - de la classe
piece_normale en mettant piece_normale entre parenthses sur la ligne de la d-
claration de la classe piece_truquee. Comme la mthode cent_tirages ne change
pas, elle na pas besoin dapparatre dans la dfinition de la nouvelle classe mme si
cette mthode est aussi applicable une instance de la classe piece_truquee.
def tirage (self) :

s = 0
return s
class piece_truquee (piece_normale) :

def tirage (self) :
else : return 0
print p2.cent_tirages ()
Enfin, on peut dfinir une pice trs truque qui devient truque si face vient de
sortir et qui redevient normale si pile vient de sortir. Cette pice trs truque
sera implmente par la classe piece_tres_truquee. Elle doit contenir un attri-
but avant qui conserve la valeur du prcdent tirage. Elle doit redfinir la mthode
tirage pour tre une pice normale ou truque selon la valeur de lattribut avant.
Pour viter de rcrire des mthodes dj crites, la mthode tirage de la classe
piece_tres_truquee doit appeler la mthode tirage de la classe piece_truquee ou
celle de la classe piece_normale selon la valeur de lattribut avant.
def tirage (self) :

s = 0
return s
class piece_truquee (piece_normale) :

def tirage (self) :
else : return 0
class piece_tres_truquee (piece_truquee) :

def __init__(self) :
# cration de lattribut avant

self.avant = 0
def tirage (self) :

if self.avant == 0 :
# appel de la mthode tirage de la classe piece_truquee
self.avant = piece_truquee.tirage (self)
else :
# appel de la mthode tirage de la classe piece_normale
self.avant = piece_normale.tirage (self)
return self.avant
print "normale ", p.cent_tirages ()
print "truquee ", p2.cent_tirages ()
p3 = piece_tres_truquee ()
print "tres truquee ", p3.cent_tirages ()
Lhritage propose donc une manire lgante dorganiser un programme. Il rend

possible la modification des classes dun programme sans pour autant les altrer.
Dfinition 4.34 : hritage

On dit quune classe B hrite dune autre classe A si la dclaration de B inclut
les attributs et les mthodes de la classe A.
La surcharge est un autre concept qui va de pair avec lhritage. Elle consiste
redfinir des mthodes dj dfinies chez lanctre. Cela permet de modifier le com-
portement de mthodes bien que celles-ci soient utilises par dautres mthodes dont
la dfinition reste inchange.
Dfinition 4.35 : surcharge

Lorsquune classe B hrite de la classe A et redfinit une mthode de la classe
A portant le mme nom, on dit quelle surcharge cette mthode. Sil nest
pas explicitement prcis quon fait appel une mthode dune classe donne,
cest toujours la mthode surcharge qui est excute.
4.8.2 Syntaxe
syntaxe 4.36 : classe, hritage

class nom_classe (nom_ancetre) :
# corps de la classe
# ...
nom_classe dsigne le nom dune classe qui hrite ou drive dune autre classe
nom_ancetre. Celle-ci nom_ancetre doit tre une classe dj dfinie.
Lutilisation de la fonction help permet de connatre tous les anctres dune classe.
On applique cette fonction la classe piece_tres_truquee dfinie au paragraphe
prcdent.
4. Classes 127
help (piece_tres_truquee)
On obtient le rsultat suivant :

Help on class piece_tres_truquee in module __main__:
class piece_tres_truquee(piece_truquee)
| Method resolution order:
| piece_tres_truquee
| piece_truquee
| piece_normale
|
|
| __init__(self)
|
| tirage(self)
|
| ----------------------------------------------------------------------
| Methods inherited from piece_normale:
|
| cent_tirages(self)
Remarque 4.37 : Method resolution order

La rubrique Method resolution order indique la liste des hritages successifs qui ont
men la classe piece_tres_truquee. Cette rubrique indique aussi que, lorsquon
appelle une mthode de la classe piece_tres_truquee, si elle nest pas redfinie
dans cette classe, le langage Python la cherchera chez lanctre direct, ici, la classe
piece_truquee. Si elle ne sy trouve toujours pas, Python ira la chercher aux niveaux
prcdents jusqu ce quil la trouve.
Lattribut __bases__ dune classe (voir paragraphe 4.3.2) contient le (ou les an-
ctres, voir paragraphe 4.8.4). Il suffit dinterroger cet attribut pour savoir si une
classe hrite dune autre comme le montre lexemple suivant.
for l in piece_tres_truquee.__bases__ :
print l # affiche __main__.piece_truquee
print piece_normale in piece_tres_truquee.__bases__ # affiche False
print piece_truquee in piece_tres_truquee.__bases__ # affiche True
La fonction issubclass permet dobtenir un rsultat quivalent. issubclass(A, B)

indique si la classe A hrite directement ou indirectement de la classe B. Le para-
graphe 4.8.5 revient sur cette fonction.
print issubclass (piece_tres_truquee, piece_normale) # affiche True
print issubclass (piece_truquee, piece_normale) # affiche True
Dans les exemples prcdents, piece_normale ne drive daucune autre classe. Tou-
tefois, le langage Python propose une classe dobjets dont hritent toutes les autres
classes dfinies par le langage : cest la classe object. Les paragraphes prcdents
ont montr quelle offrait certains avantages (voir paragraphe 4.5.4 sur les proprits
ou encore paragraphe 4.7 sur les attributs non lis).
Le paragraphe prcdent a montr quil tait parfois utile dappeler dans une m-
thode une autre mthode appartenant explicitement lanctre direct de cette classe
ou un de ses anctres. La syntaxe est la suivante.
syntaxe 4.38 : classe, appel dune mthode de lanctre

class nom_classe (nom_ancetre) :
def nom_autre_methode (self, ...) :
# ...
def nom_methode (self, ...) :
nom_ancetre.nom_methode (self, ...)
# appel de la mthode dfinie chez lanctre
nom_ancetre.nom_autre_methode (self, ...)
# appel dune autre mthode dfinie chez lanctre
self.nom_autre_methode (...)
# appel dune mthode surcharge
nom_classe dsigne le nom dune classe, nom_ancetre est le nom de la classe

dont nom_classe hrite ou drive. nom_methode est une mthode surcharge
qui appelle la mthode portant le mme nom mais dfinie dans la classe
nom_ancetre ou un de ses anctres. nom_autre_methode est une autre m-
thode. La mthode nom_methode de la classe nom_classe peut faire explicite-
ment appel une mthode dfinie chez lanctre nom_ancetre mme si elle est
galement surcharge ou faire appel la mthode surcharge.
Ces appels sont trs frquents en ce qui concerne les constructeurs qui appellent le
constructeur de lanctre. Il est mme conseill de le faire chaque fois.
class A :
self.x = 0
class B (A) :
A.__init__ (self)
self.y = 0
Remarque 4.39 : surcharge dattributs

Contrairement aux mthodes, la surcharge dattributs nest pas possible. Si un an-
ctre possde un attribut didentificateur a, les classes drives le possdent aussi et
ne peuvent en dclarer un autre du mme nom. Cela tient au fait que quelque soit
la mthode utilise, celle de lanctre ou celle dune classe drive, cest le mme
dictionnaire dattributs __dict__ qui est utilis. En revanche, si la classe anctre
dclare un attribut dans son constructeur, il ne faut pas oublier de lappeler dans le
constructeur de la classe fille afin que cette attribut existe pour la classe fille.
class ancetre :
self.a = 5
return "a = " + str (self.a)
class fille (ancetre) :

ancetre.__init__(self) # cette ligne est importante
4. Classes 129
# car sans elle, lattribut a nexiste pas

self.a += 1
s = "a = " + str (self.a)
return s
x = ancetre ()
print x # affiche a = 5
y = fille ()
print y # affiche a = 6
4.8.3 Sens de lhritage

Il nest pas toujours vident de concevoir le sens dun hritage. En mathmatique,
le carr est un rectangle dont les cts sont gaux. A priori, une classe carre doit
driver dune classe rectangle.
class rectangle :
def __init__(self,a,b) :
self.a,self.b = a,b
return "rectangle " + str (self.a) + " x " + str (self.b)
class carre (rectangle) :

def __init__( self, a) :
rectangle.__init__ (self, a,a)
r = rectangle (3,4)
print r # affiche rectangle 3 x 4
c = carre (5)
print c # affiche rectangle 5 x 5
Toutefois, on peut aussi considrer que la classe carre contient une information
redondante puisquelle possde deux attributs qui seront toujours gaux. On peut se
demander sil nest pas prfrable que la classe rectangle hrite de la classe carre.
class carre :
self.a = a
return "carre " + str (self.a)
class rectangle (carre):

carre.__init__(self, a)
self.b = b
return "rectangle " + str (self.a) + " x " + str (self.b)
r = rectangle (3,4)
c = carre (5)
print c # affiche carre 5
Cette seconde version minimise linformation mmoriser puisque la classe carre

ne contient quun seul attribut et non deux comme dans lexemple prcdent. Nan-
moins, il a fallu surcharger loprateur __str__ afin dafficher la nouvelle informa-

tion.
Il ny a pas de meilleur choix parmi ces deux solutions proposes. La premire solu-
tion va dans le sens des proprits croissantes, les mthodes implmentes pour les
classes de bases restent vraies pour les suivantes. La seconde solution va dans le sens
des attributs croissants, des mthodes implmentes pour les classes de bases doivent
souvent tre adaptes pour les hritiers. En contrepartie, il ny a pas dinformation
redondante.
Ce problme dhritage ne se pose pas chaque fois. Dans lexemple du para-
graphe 4.8.1 autour des pices truques, il y a moins dambigut sur le sens de
lhritage. Celui-ci est guid par le problme rsoudre qui savre plus simple
concevoir dans le sens dun hritage dune pice normale vers une pice truque.
Dans le cas des classes carre et rectangle, il nest pas possible de dterminer la
meilleure solution tant que leur usage ultrieur nest pas connu. Ce problme revient
galement lorsquon dfinit des matrices et des vecteurs. Un vecteur est une matrice
dune seul colonne, il ne possde quune seule dimension au lieu de deux pour une
matrice. Lexercice 12.1.10 page 288 revient sur ce dilemme.
4.8.4 Hritage multiple

Jusqu prsent, tous les exemples dhritages entre classes nont fait intervenir que
deux classes, la classe anctre dont hrite la classe descendante. Lhritage multiple
part du principe quil peut y avoir plusieurs anctres pour une mme classe. La
classe descendante hrite dans ce cas de tous les attributs et mthodes de tous ses
anctres.
Dans lexemple qui suit, la classe C hrite des classes A et B. Elle hrite donc des
mthodes de carre et cube. Chacune des classes A et B contient un constructeur qui
initialise lattribut a. Le constructeur de la classe C appelle le constructeur de la
classe A pour initialiser cet attribut.
class A :
def __init__ (self) : self.a = 5
def carre (self) : return self.a ** 2
class B :
def cube (self) : return self.a ** 3
class C (A,B) :
def __init__ (self):
A.__init__ (self)
x = C ()
print x.carre () # affiche 25
print x.cube () # affiche 125
Mais ces hritages multiples peuvent parfois apporter quelques ambiguts comme
le cas o au moins deux anctres possdent une mthode du mme nom. Dans
lexemple qui suit, la classe C hrite toujours des classes A et B. Ces deux classes
4. Classes 131
possdent une mthode calcul. La classe C, qui hrite des deux, possde aussi une
mthode calcul qui, par dfaut, sera celle de la classe A.
class A :
def calcul (self) : return self.a ** 2
class B :
class C (A,B) :
A.__init__ (self)
x = C ()
print x.calcul () # affiche 25
Cette information est disponible via la fonction help applique la classe C.

Cest dans ce genre de situations que linformation apporte par la section
Method resolution order est importante (voir remarque 4.37 page 127).
class C(A, B)
| C
| A
| B
|
|
| __init__(self)
|
| calcul(self)
Pour prciser que la mthode calcul de la classe C doit appeler la mthode calcul
de la classe B et non A, il faut lcrire explicitement en surchargeant cette mthode.
class A :
class B :
class C (A,B) :
A.__init__ (self)
def calcul (self) :

return B.calcul (self)
x = C ()
print x.calcul () # affiche 125
Remarque 4.40 : hritage multiple et constructeur

Lexemple prcdent est un cas particulier o il nest pas utile dappeler les construc-
teurs des deux classes dont la classe C hrite mais cest un cas particulier. Le construc-
teur de la classe C devrait tre ainsi :
class C (A,B) :
A.__init__ (self)
B.__init__ (self)
4.8.5 Fonctions issubclass et isinstance

La fonction issubclass permet de savoir si une classe hrite dune autre.
syntaxe 4.41 : fonction isubclass

issubclass (B,A)
Le rsultat de cette fonction est vrai si la classe B hrite de la classe A, le

rsultat est faux dans tous les autres cas. La fonction prend comme argument
des classes et non des instances de classes.
Lexemple qui suit utilise cette fonction dont le rsultat est vrai mme pour des
classes qui nhritent pas directement lune de lautre.
class A (object) : pass
class B (A) : pass
class C (B) : pass
print issubclass (A, B) # affiche False

print issubclass (B, A) # affiche True
print issubclass (A, C) # affiche False
print issubclass (C, A) # affiche True
Lorsquon souhaite appliquer la fonction une instance de classe, il faut faire appel
lattribut __class__. En reprenant les classes dfinies par lexemple prcdant
cela donne :
a = A ()
b = B ()
print issubclass (a.__class__, B) # affiche False
print issubclass (b.__class__, A) # affiche True
print issubclass (a.__class__, A) # affiche True
La fonction isinstance permet de savoir si une instance de classe est dune type
donn. Elle est quivalente la fonction issubclass ceci prs quelle prend comme
argument une instance et une classe. Lexemple prcdent devient avec la fonction
isinstance :
a = A ()
b = B ()
print isinstance (a, B) # affiche False
print isinstance (b, A) # affiche True
print isinstance (a, A) # affiche True
4. Classes 133
Lutilisation des fonctions issubclass et isinstance nest pas trs frquente mais
elle permet par exemple dcrire une fonction qui peut prendre en entre des types
variables.
def fonction_somme_list (ens) :
r = "list "
for e in ens : r += e
return r
def fonction_somme_dict (ens) :

r = "dict "
for k,v in ens.items () : r += v
return r
def fonction_somme (ens) :

if isinstance (ens, dict) : return fonction_somme_dict (ens)
elif isinstance (ens, list) : return fonction_somme_list (ens)
else : return "erreur"
li = ["un", "deux", "trois"]

di = {1:"un", 2:"deux", 3:"trois"}
tu = ("un", "deux", "trois")
print fonction_somme (li) # affiche list undeuxtrois
print fonction_somme (di) # affiche dict undeuxtrois
print fonction_somme (tu) # affiche erreur
Lavantage est davoir une seule fonction capable de sadapter diffrents type de
variables, y compris des types crs par un programmeur en utilisant les classes.
4.9 Compilation de classes

La compilation de classe fonctionne de manire similaire celle de la compilation
de fonctions (voir paragraphe 3.4.14.2, page 85). Il sagit de dfinir une classe sous
forme de chane de caractres puis dappeler la fonction compile pour ajouter cette
classe au programme et sen servir. Lexemple suivant reprend deux classes dcrites
au paragraphe 4.8.3. Elles sont incluses dans une chane de caractres, compiles
puis incluses au programme (fonction exec).
s = """class carre :
def __init__( self, a) : self.a = a
def __str__ (self) : return "carre " + str (self.a)
class rectangle (carre):

carre.__init__(self, a)
self.b = b
return "rectangle " + str (self.a) + " x " + str (self.b)"""
obj = compile(s,"","exec") # code compiler

exec (obj) # classes incorpores au programme
r = rectangle (3,4)
c = carre (5)
Comme toute fonction, la fonction compile gnre une exception lorsque la chane
de caractres contient une erreur. Le programme qui suit essaye de compiler une
chane de caractres confondant self et seilf.
# coding: latin-1
"""erreur de compilation incluses dans le code insr dans la
chane de caractre s"""
s = """class carre :
seilf.a = a # erreur de compilation
return "carre " + str (self.a) """
obj = compile(s,"variable s","exec") # code compiler

exec (obj) # classes incorpores au programme
c = carre (5)
Lexcution de ce programme affiche le message suivant :

File "C:\temp\cours.py", line 14, in -toplevel-
c = carre (5)
File "variable s", line 3, in __init__
NameError: global name seilf is not defined
Le message derreur est le mme que pour un programme ne faisant pas appel la
fonction compile ceci prs que le fichier o a lieu lerreur est variable s qui est le
second paramtre envoy la fonction compile. Le numro de ligne fait rfrence la
troisime ligne de la chane de caractres s et non la troisime ligne du programme.

4.10.1 Hritage
Le premier exemple est classique puisquil reprend le programme du para-
graphe 3.7.10 de la page 92 pour le rcrire avec des classes et viter de passer
des fonctions comme paramtre dune autre fonction. La premire classe dfinit le
module des suivantes. La mthode calcul naccepte quun seul paramtre x mais
pourrait galement prendre en compte des constantes si celles-ci sont renseignes
via le constructeur de la classe. Cest lavantage de cette solution dj illustre par
les pices normales et truques.
class Fonction :
def calcul (self, x) : pass
def calcul_n_valeur (self, l) :
res = [ self.calcul (i) for i in l ]
return res
4. Classes 135
class Carre (Fonction) :

def calcul (self, x) : return x*x
class Cube (Fonction) :

def calcul (self, x) : return x*x*x
l = [0,1,2,3]
print l # affiche [0, 1, 2, 3]
l1 = Carre ().calcul_n_valeur (l) # l1 vaut [0, 1, 4, 9]

l2 = Cube () .calcul_n_valeur (l) # l2 vaut [0, 1, 8, 27]
La version suivante mlange hritage et mthodes envoyes comme paramtre une

fonction. Il est prfrable dviter cette construction mme si elle est trs utilise par
les interfaces graphiques. Elle nest pas toujours transposable dans tous les langages
de programmation tandis que le programme prcdent aura un quivalent dans tous
les langages objet.
class Fonction :
def calcul (self, x) : pass
class Carre (Fonction) :
def calcul (self, x) : return x*x
class Cube (Fonction) :
def calcul (self, x) : return x*x*x
def calcul_n_valeur (l,f):

res = [ f(i) for i in l ]
return res
l = [0,1,2,3]
l1 = calcul_n_valeur (l, Carre ().calcul) # l1 vaut [0, 1, 4, 9]
l2 = calcul_n_valeur (l, Cube ().calcul) # l2 vaut [0, 1, 8, 27]
4.10.2 Deux lignes dhritages

Cest une configuration qui arrive frquemment lorsquon a dun ct diffrentes
structures pour les mmes donnes et de lautre diffrents algorithmes pour le mme
objectif. Par exemple, une matrice peut tre dfinie comme une liste de listes ou un
dictionnaire de 2-uples 6 . La multiplication de deux matrices peut tre une multipli-
cation classique ou celle de Strassen 7 .
La question est comment modliser ces deux structures et ces deux multiplications
sachant que les quatre paires structure - algorithme doivent fonctionner. On pourrait
simplement crer deux classes faisant rfrence aux deux structures diffrentes et
lintrieur de chacune dentre elles, avoir deux mthodes de multiplication. Nan-
moins, si une nouvelle structure ou un nouvel algorithme apparat, la mise jour
peut tre fastidieuse.
Il est conseill dans ce cas davoir quatre classes et de dfinir une interface dchanges
communes. Lalgorithme de multiplication ne doit pas savoir quelle structure il ma-
6. voir exercice 10.2, page 242
7. Lalgorithme de multiplication de deux matrices de Strassen est plus rapide quune mul-
ln 7
tiplication classique pour de grandes matrices. Son cot est en O(n ln 2 ) O(n2,807 ) au lieu de
3
O(n ).
nipule : il doit y accder par des mthodes. De cette manire, cest la classe qui
indique lalgorithme choisi et non une mthode. Ajouter un troisime algorithme ou
une troisime structure revient ajouter une classe : linterface dchange ne change
pas. Le programme pourrait suivre le schma qui suit.
class Matrice :
def __init__ (self,lin,col,coef):
self.lin, self.col = lin, col
# interface dchange
def get_lin () : return self.lin
def get_col () : return self.col
def __getitem__(self,i,j): pass
def __setitem__(self,i,j,v): pass
def get_submat(self, i1,j1,i2,j2): pass
def set_submat(self, i1,j1,mat): pass
# fin de linterface dchange
def trace (self) :

class Produit :
t = 0
def calcul (self, mat1, mat2):
for i in xrange (0, self.lin):
pass
t += self (i,i)
return t
class ProduitClassique (Produit) :
def calcul (self, mat1, mat2):
class MatriceList (Matrice) :
#...
return
Matrice.__init__ (self, \
lin, col, coef)
class ProduitStrassen (Produit) :
#...
def calcul (self, mat1,mat2):
#...
def __getitem__ (self, i,j) : #...
return
def __setitem__ (self, i,j, v) : #...
def get_submat(self, i1,j1,i2,j2): #...
def set_submat(self, i1,j1,mat): #...
class MatriceDict (Matrice) :

Matrice.__init__ (self, \
lin, col, coef)
#...
def __getitem__ (self, i,j) : #...

def __setitem__ (self, i,j, v) : #...
def get_submat(self, i1,j1,i2,j2): #...
def set_submat(self, i1,j1,mat): #...
Cette construction autorise mme la multiplication de matrices de structures diff-

rentes. Trs rpandue, cette architecture est souvent plus coteuse au moment de
la conception car il faut bien penser linterface dchange mais elle lest beaucoup
moins par la suite. Il existe dautres assemblages de classes assez frquents, regrou-
ps sous le terme de Design Patterns. Pour peu que ceux-ci soient connus de celui
qui conoit un programme, sa relecture et sa comprhension en sont facilites si les
commentaires font mention du pattern utilis.
4. Classes 137
Retourne un entier gale -1, 0, 1, chacune de ces

valeurs tant associs respectivement : self < x,
__cmp__(self, x)
self == x, self > x. Cet oprateur est appel par la
fonction cmp.
Convertit un objet en une chane de caractre qui sera
__str__(self) affiche par la fonction print ou obtenu avec la fonc-
tion str.
Retourne True ou False selon que x appartient self.
__contains__(self, x) Le mot-cl in renvoie cet oprateur. En dautres
termes, if x in obj : appelle obj.__contains__(x).
Retourne le nombre dlment de self. Cet oprateur
__len__(self)
est appel par la fonction len.
__abs__(self) Cet oprateur est appel par la fonction abs.
Cet oprateur est appel lorsquon cherche acc-
der un lment de lobjet self dindice i comme
__getitem__(self, i)
si ctait une liste. Si lindice i est incorrect, lexcep-
tion IndexError doit tre leve.
Cet oprateur est appel lorsquon cherche affecter
une valeur v un lment de lobjet self dindice i
__setitem__(self, i, v) comme si ctait une liste ou un dictionnaire. Si lin-
dice i est incorrect, lexception IndexError doit tre
leve.
Cet oprateur est appel lorsquon cherche suppri-
mer llment de lobjet self dindice i comme si
__delitem__(self, i)
ctait une liste ou un dictionnaire. Si lindice i est
incorrect, lexception IndexError doit tre leve.
__int__(self)
Ces oprateurs implmente la conversion de linstance
__float__(self)
self en entier, rel ou complexe.
__complex__(self)
__add__(self, x)
__div__(self, x)
__mul__(self, x)
Oprateurs appels pour les oprations +, /, *, -, **,
__sub__(self, x)
<<, >>
__pow__(self, x)
__lshift__(self, x)
__rshift__(self, x)
__iadd__(self, x)
__idiv__(self, x)
__imul__(self, x)
Oprateurs appels pour les oprations +=, /=, *=, -=,
__isub__(self, x)
**=, =, =
__ipow__(self, x)
__ilshift__(self, x)
__irshift__(self, x)
Table 4.1 : Oprateurs ou fonctions spciales les plus utilises. La page http:// docs.
python.org/ reference/ datamodel.html#special-method-names (voir galement http:// docs.
python.org/ library/ operator.html#mapping-operators-to-functions) recense toutes les fonc-
tions spciales quil est possible de redfinir pour une classe.
Chapitre 5
Exceptions
Le petit programme suivant dclenche une erreur parce quil effectue une division
par zro.
x = 0
y = 1.0 / x
Il dclenche une erreur ou ce quon appelle une exception.

File "cours.py", line 2, in ?
y = 1.0 / x
ZeroDivisionError: float division
Le mcanisme des exceptions permet au programme de "rattraper" les erreurs, de

dtecter quune erreur sest produite et dagir en consquence afin que le programme
ne sarrte pas.
5.1 Principe des exceptions

5.1.1 Attraper toutes les erreurs
Dfinition 5.1 : exception

Une exception est un objet qui indique que le programme ne peut continuer
son excution.
On dcide par exemple quon veut rattraper toutes les erreurs du programme et
afficher un message derreur. Le programme suivant appelle la fonction inverse qui
retourne linverse dun nombre.
def inverse (x):
y = 1.0 / x
return y
a = inverse (2)
print a
b = inverse (0)
print b
Lorsque le paramtre x = 0, le programme effectue une division par zro et dclenche

une erreur qui parat diffrente de la premire daprs la longueur du message. Cest
5. Exceptions 139
pourtant la mme erreur : cette liste correspond en fait ce quon appelle la pile
dappels 1 . Si lerreur se produit dans une fonction elle-mme appele par une autre...
la pile dappel permet dobtenir la liste de toutes les fonctions pour remonter jusqu
celle o lerreur sest produite.
File "cours.py", line 8, in ?
b = inverse (0)
File "cours.py", line 3, in inverse
y = 1.0 / x
ZeroDivisionError: float division
Afin de rattraper lerreur, on insre le code susceptible de produire une erreur entre
les mots cls try et except.
def inverse (x):
y = 1.0 / x
return y
try :
a = inverse (2)
print a
b = inverse (0) # dclenche une exception
print b
except :
print "le programme a dclench une erreur"
Le programme essaye dexcuter les quatre instructions incluses entre les instructions
try et except. Si une erreur se produit, le programme excute alors les lignes qui
suivent linstruction except. Lerreur se produit en fait lintrieur de la fonction
inverse mais celle-ci est appele lintrieur dun code "protg" contre les erreurs.
Le programme prcdent affiche les deux lignes suivantes.
0.5
le programme a dclench une erreur
Il est aussi possible dajouter une clause else qui sert de prfixe une liste dins-
tructions qui ne sera excute que si aucune exception nest dclenche.
def inverse (x):
y = 1.0 / x
return y
try :
print inverse (2) # pas derreur
print inverse (1) # pas derreur non plus
except :
else :
print "tout sest bien pass"
Ce dernier programme ne dclenche aucune exception et affiche les lignes suivantes.
1. call stack en anglais

0.5
1.0
tout sest bien pass
Pour rsumer, la syntaxe suivante permet dattraper toutes les erreurs qui se pro-
duisent pendant lexcution dune partie du programme. Cette syntaxe permet en
quelque sorte de protger cette partie du programme contre les erreurs.
syntaxe 5.2 : exception

try :
# ... instructions protger
except :
# ... que faire en cas derreur
else :
# ... que faire lorsque aucune erreur nest apparue
Toute erreur dclenche alors que le programme excute les instructions qui
suivent le mot-cl try dclenche immdiatement lexcution des lignes qui
suivent le mot-cl except. Dans le cas contraire, le programme se poursuit
avec lexcution des lignes qui suivent le mot-cl else. Cette dernire partie
est facultative, la clause else peut ou non tre prsente. Dans tous les cas,
lexcution du programme ne sarrte pas.
Remarque 5.3 : plusieurs erreurs

Lorsquune section de code est protge contre les exceptions, si elle contient
plusieurs erreurs, son excution sarrte la premire des erreurs dcouvertes. Par
exemple, ds la premire erreur qui correspond au calcul dune puissance non entire
dun nombre ngatif, lexcution du programme suivant est dirige vers linstruction
qui suit le mot-cl except.
def inverse (x):
y = 1.0 / x
return y
try :
print (-2.1) ** 3.1 # premire erreur
print inverse (2)
print inverse (0) # seconde erreur
except :
5.1.2 Obtenir le type derreur, attraper un type dexception

Parfois, plusieurs types derreurs peuvent tre dclenchs lintrieur dune portion
de code protge. Pour avoir une information sur ce type, il est possible de rcuprer
une variable de type Exception.
def inverse (x):
y = 1.0 / x
return y
5. Exceptions 141
try :
print inverse (2)
print inverse (0)
except Exception, exc:
print "exception de type ", exc.__class__
# affiche exception de type exceptions.ZeroDivisionError
print "message ", exc
# affiche le message associ lexception
Le programme prcdent rcupre une exception sous la forme dune variable appele
exc. Cette variable est en fait une instance dune classe derreur, exc.__class__
correspond au nom de cette classe. A laide de la fonction isinstance, il est possible
dexcuter des traitements diffrents selon le type derreur.
def inverse (x):
y = 1.0 / x
return y
try :
print (-2.1) ** 3.1 # premire erreur
print inverse (2)
print inverse (0) # seconde erreur
if isinstance (exc, ZeroDivisionError) :
print "division par zro"
else :
print "erreur insouponne : ", exc.__class__
Lexemple prcdent affiche le message qui suit parce que la premire erreur inter-
vient lors du calcul de (2.1) 3.1.
erreur insouponne : exceptions.ValueError
Une autre syntaxe plus simple permet dattraper un type dexception donn en
accolant au mot-cl except le type de lexception quon dsire attraper. Lexemple
prcdent est quivalent au suivant mais syntaxiquement diffrent.
def inverse (x):
y = 1.0 / x
return y
try :
print (-2.1) ** 3.1
print inverse (2)
print inverse (0)
except ZeroDivisionError:
print "division par zro"
print "erreur insouponne : ", exc.__class__
Cette syntaxe obit au schma qui suit.
syntaxe 5.4 : exception dun type donn

try :
# ... instructions protger
except type_exception_1 :
# ... que faire en cas derreur de type type_exception_1
except type_exception_i :
# ... que faire en cas derreur de type type_exception_i
except type_exception_n :
# ... que faire en cas derreur de type type_exception_n
except :
# ... que faire en cas derreur dun type diffrent de tous
# les prcdents types
else :
# ... que faire lorsque une erreur aucune erreur nest apparue
Toute erreur dclenche alors que le programme excute les instructions qui
suivent le mot-cl try dclenche immdiatement lexcution des lignes qui
suivent un mot-cl except. Le programme compare le type dexception aux
types type_exception_1 type_exception_n. Sil existe une correspondance
alors ce sont les instructions de la clause except associe qui seront excutes et
uniquement ces instructions. La dernire clause except est facultative, elle est
utile lorsque aucun type de ceux prvus ne correspond lexception gnre.
La clause else est aussi facultative. Si la dernire clause except nest pas
spcifie et que lexception dclenche ne correspond aucune de celle liste
plus haut, le programme sarrte sur cette erreur moins que celle-ci ne soit
attrape plus tard.
Le langage Python propose une liste dexceptions standards (voir table 5.1,
page 149). Lorsquune erreur ne correspond pas lune de ces exceptions, il est pos-
sible de crer une exception propre un certain type derreur (voir paragraphe 5.2).
Lorsquune fonction ou une mthode dclenche une exception non standard, gn-
ralement, le commentaire qui lui est associ lindique.
5.1.3 Lancer une exception

Lorsquune fonction dtecte une erreur, il lui est possible de dclencher une exception
par lintermdiaire du mot-cl raise. La fonction inverse compare x 0 et dclenche
lexception ValueError si x est nul. Cette exception est attrape plus bas.
def inverse (x):
if x == 0 :
raise ValueError
y = 1.0 / x
return y
try :
print inverse (0) # erreur
except ValueError:
print "erreur"
5. Exceptions 143
Il est parfois utile dassocier un message une exception afin que lutilisateur ne
soit pas perdu. Le programme qui suit est identique au prcdent ceci prs quil
associe lexception ValueError qui prcise lerreur et mentionne la fonction o elle
sest produite. Le message est ensuite intercept plus bas.
def inverse (x):
if x == 0 :
raise ValueError ("valeur nulle interdite, fonction inverse")
y = 1.0 / x
return y
try :
print inverse (0) # erreur
except ValueError, exc:
print "erreur, message : ", exc
Le dclenchement dune exception suit la syntaxe suivante.
syntaxe 5.5 : exception, raise

raise exception_type (message) :
Cette instruction lance lexception exception_type associe au message

message. Le message est facultatif, lorsquil ny en a pas, la syntaxe se r-
sume raise exception_type.
Et pour attraper cette exception et le message qui lui est associ, il faut utiliser la
syntaxe 5.4 dcrite au paragraphe prcdent.
5.1.4 Hritage et exception

Linstruction help(ZeroDivisionError) retourne laide associe lexception
ZeroDivisionError. Celle-ci indique que lexception ZeroDivisionError est en fait
un cas particulier de lexception ArithmeticError, elle-mme un cas particulier de
StandardError.
class ZeroDivisionError(ArithmeticError)
| Second argument to a division or modulo operation was zero.
|
| ZeroDivisionError
| ArithmeticError
| StandardError
| Exception
Toutes les exceptions sont des cas particuliers de lexception de type Exception. Cest
pourquoi linstruction except Exception, e : attrape toutes les exceptions. Linstruc-
tion except ArithmeticError : attrape toutes les erreurs de type ArithmeticError,
ce qui inclut les erreurs de type ZeroDivisionError. Autrement dit, toute exception
de type ZeroDivisionError est attrape par les instructions suivantes :
except ZeroDivisionError :
except ArithmeticError :
except StandardError :
except Exception :
Plus prcisment, chaque exception est une classe qui drive directement ou indirec-
tement de la classe Exception. Linstruction except ArithmeticError : par exemple
attrape toutes les exceptions de type ArithmeticError et toutes celles qui en drivent
comme la classe ZeroDivisionError (voir galement le paragraphe 5.2).
5.1.5 Instructions try, except imbriques

Comme pour les boucles, il est possible dimbriquer les portions protges de code
les unes dans les autres. Dans lexemple qui suit, la premire erreur est lappel une
fonction non dfinie, ce qui dclenche lexception NameError.
def inverse (x):
y = 1.0 / x
return y
try :
try :
print inverses (0) # fonction inexistante --> exception NameError
print inverse (0) # division par zro --> ZeroDivisionError
except NameError:
print "appel une fonction non dfinie"
except ZeroDivisionError, exc:
print "erreur ", exc
En revanche, dans le second exemple, les deux lignes print inverse(0) et

print inverses(0) ont t permutes. La premire exception dclenche est la di-
vision par zro. La premire clause except ninterceptera pas cette erreur puisquelle
nest pas du type recherch.
def inverse (x):
y = 1.0 / x
return y
try :
try :
print inverse (0) # division par zro --> ZeroDivisionError
except NameError:
Une autre imbrication possible est lappel une fonction qui inclut dj une partie
de code protge. Lexemple suivant appelle la fonction inverse qui intercepte les
exceptions de type ZeroDivisionError pour retourner une grande valeur lorsque
x = 0. La seconde exception gnre survient lors de lappel la fonction inverses
qui dclenche lexception NameError, elle aussi intercepte.
def inverse (x):
try :
y = 1.0 / x
5. Exceptions 145

if x > 0 : return 1000000000
else : return -1000000000
return y
try :
print inverse (0) # division par zro --> la fonction inverse sait grer
except NameError:
5.2 Dfinir ses propres exceptions

5.2.1 Driver une classe dexception
Pour dfinir sa propre exception, il faut crer une classe qui drive dune classe
dexception existante (voir paragraphe 5.1.4), par exemple, la classe Exception.
Lexemple suivant cre une exception AucunChiffre qui est lance par la fonction
conversion lorsque la chane de caractres quelle doit convertir ne contient pas que
des chiffres.
class AucunChiffre (Exception) :
"""chane de caractres contenant aussi autre chose que des chiffres"""
def conversion (s) :

"""conversion dune chane de caractres en entier"""
if not s.isdigit () :
raise AucunChiffre (s)
return int (s)
try :
s = "123a"
print s, " = ", conversion (s)
except AucunChiffre, exc :
# on affiche ici le commentaire associ la classe dexception
# et le message associ
print AucunChiffre.__doc__, " : ", exc
Remarque 5.6 : exception et oprateur __str__

En redfinissant loprateur __str__ dune exception, il est possible dafficher des
messages plus explicites avec la seule instruction print.
return self.__doc__ + " " + Exception.__str__ (self)
5.2.2 Personnalisation dune classe dexception

Il est parfois utile quune exception contienne davantage dinformations quun simple
message. Lexemple suivant reprend lexemple du paragraphe prcdent. Lexception
AucunChiffre inclut cette fois-ci un paramtre supplmentaire contenant le nom de

la fonction o lerreur a t dclenche.
La classe AucunChiffre possde dornavant un constructeur qui doit recevoir deux
paramtres : une valeur et un nom de fonction. Lexception est leve laide de
linstruction raise AucunChiffre (s, conversion) qui regroupe dans un T-uple les
paramtres envoyer lexception.
Loprateur __str__ a t modifi de faon ajouter ces deux informations dans
le message associ lexception. Ainsi, linstruction print exc prsente lavant
dernire ligne de cet exemple affiche un message plus complet.
def __init__(self, s, f = "") :
Exception.__init__(self, s)
self.s = s
self.f = f
def __str__(self) :
return """exception AucunChiffre, depuis la fonction """ + self.f + \
" avec le paramtre " + self.s
def conversion (s) :

"""conversion dune chane de caractres en entier"""
if not s.isdigit () :
raise AucunChiffre (s, "conversion")
return int (s)
try :
s = "123a"
i = conversion (s)
print s, " = ", i
except AucunChiffre, exc :
print exc
print "fonction : ", exc.f
Etant donn que le programme dclenche une exception dans la section de code pro-
tge, les deux derniers affichages sont les seuls excuts correctement. Ils produisent
les deux lignes qui suivent.
exception AucunChiffre, depuis la fonction conversion avec le paramtre 123a
fonction : conversion
5.3 Exemples dutilisation des exceptions

5.3.1 Les itrateurs
Les itrateurs sont des outils qui permettent de parcourir des objets qui sont des
ensembles, comme une liste, un dictionnaire. Ils fonctionnent toujours de la mme
manire. Lexemple dj prsent au paragraphe 4.4.2, page 106) et repris en par-
tie ici dfinit une classe contenant trois coordonnes, ainsi quun itrateur permet-
tant de parcourir ces trois coordonnes. Arrive la troisime itration, lexception
StopIteration est dclenche. Cette exception indique une boucle for de sarrter.
5. Exceptions 147
class point_espace:
#...
class class_iter:
def __init__ (self,ins):
self._n = 0
self._ins = ins
def __iter__ (self) :
return self
def next (self):
if self._n <= 2:
v = self._ins [self._n]
self._n += 1
return v
else :
raise StopIteration
def __iter__(self):
return point_espace.class_iter (self)
# ...
Cet exemple montre seulement que les exceptions ninterviennent pas seulement lors
derreurs mais font parfois partie intgrante dun algorithme.
5.3.2 Exception ou valeur aberrante

Sans exception, une solution pour indiquer un cas de mauvaise utilisation dune
fonction est de retourner une valeur aberrante. Retourner -1 pour une fonction dont
le rsultat est ncessairement positif est une valeur aberrante. Cette convention
permet de signifier celui qui appelle la fonction que son appel na pu tre trait
correctement. Dans lexemple qui suit, la fonction racine_carree retourne un couple
de rsultats, True ou False pour savoir si le calcul est possible, suivi du rsultat qui
na un sens que si True est retourne en premire valeur.
def racine_carree(x) :
if x < 0 : return False, 0
else : return True, x ** 0.5
print racine_carree (-1) # (False, 0)
print racine_carree (1) # (True, 1.0)
Plutt que de compliquer le programme avec deux rsultats ou une valeur aberrante,
on prfre souvent dclencher une exception, ici, ValueError. La plupart du temps,
cette exception nest pas dclenche. Il est donc superflu de retourner un couple
plutt quune seule valeur.
def racine_carree(x) :
if x < 0 : raise ValueError ("valeur ngative")
return x ** 0.5
print racine_carree (-1) # dclenche une exception
print racine_carree (1)
5.3.3 Le pige des exceptions

Ce paragraphe voque certains problmes lorsquune exception est leve. Lexemple
utilise les fichiers dcrits au chapitre 7. Lorsquune exception est leve lintrieur
dune fonction, lexcution de celle-ci sinterrompt. Si lexception est attrape, le
programme continue sans problme ; les objets momentanment crs seront dtruits
par le garbage collector. Il faut pourtant faire attention dans le cas par exemple o
lexception est leve alors quun fichier est ouvert : il ne sera pas ferm.
# coding: latin-1
def ajoute_resultat_division (nom, x, y) :
"""ajoute le rsultat de la division x/y au fichier nom"""
f = open (nom, "a")
f.write (str (x) + "/" + str (y) + "= ")
f.write ( str ((float (x)/y)) + "\n" ) # exception si y == 0
f.close ()
for i in range (0, 5) :

try :
print str (i-1) + "/" + str (i-2)
ajoute_resultat_division ("essai.txt", i-1,i-2)
except Exception, e : print "erreur avec i = ", i, ",", e
Les critures dans le fichier se font en mode ajout (a), le fichier essai.txt contien-
dra tout ce qui aura t crit.
-1/-2 -1/-2= 0.5

0/-1 0/-1= 0.0
1/0 2/1= 2.0
erreur avec i = 2 , float division 3/2= 1.5
2/1 1/0=
3/2
ct affichage ct fichier
Il ny pas de surprise du ct des affichages produit par linstruction print. 1/0

prcde 2/1. La diffrence vient de la dernire ligne du fichier qui intervient de faon
surprenante en dernire position. Lorsque y==0, la fonction sinterrompt avant de
fermer le fichier. Cest le garbage collector qui le fermera bien aprs lappel suivant
qui ouvre nouveau le fichier pour crire 2/1= 2.0.
5. Exceptions 149
Elle nest en principe jamais explicitement gnre par les

Exception fonctions Python mais elle permet dattraper toutes les
exceptions car toutes drivent de la classe Exception.
Une rfrence un attribut inexistant ou une affectation a
AttributeError
chou.
ArithmeticError Une opration arithmtique a chou.
FloatingPointError Une opration avec des nombres rels a chou.
Une opration concernant les entres/sorties (In-
IOError put/Output) a chou. Cette erreur survient par exemple
lorsquon cherche lire un fichier qui nexiste pas.
Cette erreur survient lorsquon cherche importer un mo-
ImportError
dule qui nexiste pas (voir chapitre 6).
Linterprteur ne peut interprter une partie du pro-
gramme cause dun problme dindentation. Il nest pas
IndentationError possible dexcuter un programme mal indent mais cette
erreur peut se produire lors de lutilisation de la fonction
compile (voir le paragraphe 3.4.14.2, page 85).
On utilise un index erron pour accder un lment dune
IndexError
liste, dun dictionnaire ou de tout autre tableau.
Une cl est utilise pour accder un lment dun dic-
KeyError
tionnaire dont elle ne fait pas partie.
On utilise une variable, une fonction, une classe qui nexiste
NameError
pas.
Un calcul sur des entiers ou des rels dpasse les capacits
OverflowError
de codage des entiers ou des rels.
Cette exception est utilise pour signifier quun itrateur
StopIteration
atteint la fin dun ensemble, un tableau, un dictionnaire.
Erreur de type, une fonction est applique sur un objet
TypeError
quelle nest pas cense manipuler.
Il faut parfois convertir des chanes de caractres de type
unicode en chanes de caractres de type str et rciproque-
UnicodeError
ment. Cette exception intervient lorsque la conversion nest
pas possible (voir galement le paragraphe 7.8 page 191).
Cette exception survient lorsquune valeur est inapproprie
ValueError pour une certaine opration, par exemple, lobtention du
logarithme dun nombre ngatif.
ZeroDivisionError Cette exception survient pour une division par zro.
Table 5.1 : Exceptions standard les plus couramment utilises. Ces exceptions sont dfinies
par le langage Python. Il nest pas ncessaire dinclure un module. La page http:// docs.
python.org/ library/ exceptions.html recense toutes les exceptions prdfinies.
Chapitre 6
Modules
Il est souvent prfrable de rpartir le code dun grand programme sur plusieurs
fichiers. Parmi tous ces fichiers, un seul est considr comme fichier principal, il
contient son point dentre, les premires instructions excutes. Les autres fichiers
sont considrs comme des modules, en quelque sorte, des annexes qui contiennent
tout ce dont le fichier principal a besoin.
6.1 Modules et fichiers

6.1.1 Exemple
Cet exemple montre comment rpartir un programme sur deux fichiers. Le premier
est appel module car il ninclut pas le point dentre du programme.
Dfinition 6.1 : point dentre du programme

Le point dentre dun programme est la premire instruction excute par
lordinateur lors de lexcution de ce programme.
Cet exemple de module contient une fonction, une classe et une variable. Ces trois
lments peuvent tre utiliss par nimporte quel fichier qui importe ce module. Le
nom dun module correspond au nom du fichier sans son extension.
Fichier : module_exemple.py Fichier : exemple.py

# coding: latin-1 import module_exemple
"""exemple de module, aide associe"""
c = module_exemple.exemple_classe ()
exemple_variable = 3 print c
print module_exemple.exemple_fonction()
def exemple_fonction () : help (module_exemple)
"""exemple de fonction"""
return 0
class exemple_classe :
"""exemple de classe"""
return "exemple_classe"
Pour importer un module, il suffit dinsrer linstruction import nom_module avant

dutiliser une des choses quil dfinit. Ces importations sont souvent regroupes au
dbut du programme, elles sont de cette faon mises en vidence mme sil est pos-
sible de les faire nimporte o. Lexemple ci-dessus droite importe le module dfini
6. Modules 151
gauche. Les modules commencent le plus souvent par une chane de caractres
comme dans lexemple prcdent, celle-ci contient laide associe ce module. Elle
apparat avec linstruction help(module_exemple).
Rien ne diffrencie les deux fichiers module_exemple.py et exemple.py except le fait
que le second utilise des lments dfinis par le premier. Dans un programme com-
pos de plusieurs fichiers, un seul contient le point dentre et tous les autres sont
des modules.
La syntaxe dappel dun lment dun module est identique celle dune classe. On
peut considrer un module comme une classe avec ses mthodes et ses attributs la
seule diffrence quil ne peut y avoir quune seule instance dun mme module. La
rptition de linstruction import module_exemple naura aucun effet : un module
nest import que lors de la premire instruction import nom_module rencontr lors
de lexcution du programme.
Remarque 6.2 : fichier .pyc
Lutilisation dun module quon a soi-mme conu provoque lapparition dun fichier
dextension pyc. Il correspond la traduction du module en bytecode plus rapidement
exploitable par linterprteur Python. Ce fichier est gnr chaque modification du
module. Lorsquun module est import, Python vrifie la date des deux fichiers
dextension py et pyc. Si le premier est plus rcent, le second est recr. Cela permet
un gain de temps lorsquil y a un grand nombre de modules. Il faut faire attention
lorsque le fichier source dextension py est supprim, il est alors encore possible de
limporter tant que sa version dextension pyc est prsente.
Remarque 6.3 : recharger un module
Le module module_exemple contient une variable exemple_variable peut tre mo-
difie au cours de lexcution du programme. Il est possible de revenir sa valeur
initiale en forant Python recharger le module grce la fonction reload.
import module_exemple
module_exemple.exemple_variable = 10
reload (module_exemple)
print module_exemple.exemple_variable # affiche 3
6.1.2 Autres syntaxes

Il existe trois syntaxes diffrentes pour importer un module. La premire est dcrite
au paragraphe prcdent. Il en existe une autre qui permet daffecter un module
un identificateur diffrent du nom du fichier dans lequel il est dcrit. En ajoutant
linstruction as suivi dun autre nom alias, le module sera dsign par la suite par
lidentificateur alias comme le montre lexemple suivant.
Fichier : exemple2.py
import module_exemple as alias
c = alias.exemple_classe ()
print c
print alias.exemple_fonction ()
help (alias)
Une autre syntaxe permet de se passer didentificateur pour un module en utilisant

le mot-cl from. En utilisant la syntaxe from module import , tous les identificateurs
(fonctions, classes, variables) sont directement accessibles sans les faire prcder dun
identificateur de module ainsi que le montre lexemple suivant.
from module_exemple import *
c = exemple_classe ()
print c
print exemple_fonction ()
La partie import permet dimporter toutes les classes, attributs ou fonctions dun
module mais il est possible dcrire from module_exemple import exemple_class pour
nimporter que cette classe. La fonction exemple_fonction ne sera pas accessible.
Toutefois, cette syntaxe est dconseille. Elle rduit la longueur de certaines fonc-
tions ou classes puisquil nest plus besoin de faire apparatre le module do elle
proviennent et cela ne permet plus de distinguer une classe ou une fonction dfinie
dans ce fichier de celles dfinies dans un autre module import.
Il existe une dernire syntaxe dimportation dun module qui est utile quand on ne
sait pas encore au moment dcriture du programme le nom du module importer.
Celui-ci sera prcis laide dune chane de caractres au moyen de la fonction
__import__.
alias = __import__ ("module_exemple")
c = alias.exemple_classe ()
print c
print alias.exemple_fonction ()
help (alias)
6.1.3 Nom dun module

Le nom dun module est dfini par le nom du fichier sous lequel il est enregis-
tr. Dans lexemple du paragraphe prcdent, le module avait pour nom de fichier
module_exemple.py, le nom de ce module est donc module_exemple.
Nanmoins, ce module peut galement tre excut comme un programme normal.
Si tel est le cas, son nom devient __main__. Cest pourquoi, les quelques lignes qui
suivent apparaissent souvent. Elles ne sont excutes que si ce fichier a pour nom
__main__. Un seul fichier peut porter ce nom : celui qui contient le point dentre.
if __name__ == "__main__" :
print "ce fichier est le programme principal"
Cette astuce est rgulirement utilise pour tester les fonctions et classes dfinies
dans un module. Etant donn que cette partie nest excute que si ce fichier est le
programme principal, ajouter du code aprs le test if __name__ == __main__ :
na aucune incidence sur tout programme incluant ce fichier comme module.
6. Modules 153
6.1.4 Emplacement dun module

Lorsque le module est plac dans le mme rpertoire que le programme qui luti-
lise, linstruction import nom_module_sans_extension suffit. Cette instruction suffit
galement si ce module est plac dans le rpertoire site packages prsent dans le
rpertoire dinstallation de Python. Si ce nest pas le cas, il faut prciser linter-
prteur Python o il doit chercher ce module :
import sys
sys.path.append (sys.path [0] + "/../common")
################ sys.path [0] = rpertoire de ce programme
import nom_module
La variable sys.path contient les rpertoires o Python va chercher les modules.

Le premier dentre eux est le rpertoire du programme. Il suffit dajouter cette
liste le rpertoire dsir, ici, un rpertoire appel common situ au mme niveau que le
rpertoire du programme. A ce sujet, il est conseill dutiliser le plus souvent possible
des chemins relatifs et non absolus 1 . De cette faon, on peut recopier le programme
et ses modules un autre endroit du disque dur sans altrer leur fonctionnement.
6.1.5 Ajouter un module en cours dexcution

De la mme faon que Python est capable dinclure de nouvelles portions de code
en cours dexcution 2 , il est galement capable dinclure en cours dexcution des
modules dont on ne connat pas le nom au dbut de lexcution. Cela seffectue grce
la fonction __import__ dj prsente ci-dessus. Nanmoins, cette fonction ne
peut pas importer un module si celui-ci est dsign par un nom de fichier incluant
son rpertoire. Il faut dabord dterminer le rpertoire o est le module grce la
fonction split du module os.path. Le programme suivant illustre cette possibilit
en proposant une fonction qui importe un module connaissant le nom du fichier qui
le contient.
# coding: latin-1
def import_fichier (module) :
import os.path
import sys
if os.path.exists (module) : # on teste lexistence du fichier
folder,name = os.path.split (module) # on obtient le rpertoire du module
if folder not in sys.path :
sys.path.append (folder) # on ajoute le rpertoire dans la liste
# des rpertoires autoriss
name = name.replace (".py", "") # on enlve lextension
module = __import__ (name) # on importe le module
return module
else :
# si le fichier nexiste pas --> on lve une exception
raise ImportError ("impossible dimporter le module " + module)
1. Depuis un rpertoire courant, les chemins relatifs permettent de faire rfrence dautres
rpertoires sans avoir prendre en compte leur emplacement sur le disque dur contrairement aux
chemins absolus comme C:/Python26/python.exe.
2. grce la fonction exec
# on importe un module
mod = import_fichier (r"D:\Dupre\informatique\programme\corde.py")
# on affiche laide associe
help (mod)
6.1.6 Liste des modules imports

Le dictionnaire modules du module sys contient lensemble des modules imports.
Le programme suivant affiche cette liste.
import sys
for m in sys.modules :
print m, " " * (14 - len(str(m))), sys.modules [m]
os <module os from c:\python26\lib\os.pyc>

os.path <module ntpath from c:\python26\lib\ntpath.pyc>
re <module re from c:\python26\lib\re.pyc>
site <module site from c:\python26\lib\site.pyc>
sys <module sys (built-in)>
types <module types from c:\python26\lib\types.pyc>
...
Lorsque le programme stipule limport dun module, Python vrifie sil nest pas
dj prsent dans cette liste. Dans le cas contraire, il limporte. Chaque module nest
import quune seule fois. La premire instruction import module_exemple rencontre
introduit une nouvelle entre dans le dictionnaire sys.modules :
module_exemple <module module_exemple from D:\python_cours\module_exemple.py>
Le dictionnaire sys.modules peut tre utilis pour vrifier la prsence dun module
ou lui assigner un autre identificateur. Un module est un objet qui nautorise quune
seule instance.
if "module_exemple" in sys.modules :
m = sys.modules ["module_exemple"]
m.exemple_fonction ()
6.1.7 Attributs communs tout module

Une fois imports, tous les modules possdent cinq attributs qui contiennent des
informations comme leur nom, le chemin du fichier correspondant, laide associe.
__all__ Contient toutes les variables, fonctions, classes du module.

Ce dictionnaire contient toutes les fonctions et classes inh-
__builtins__
rentes au langage Python utilises par le module.
__doc__ Contient laide associe au module.
Contient le nom du fichier qui dfinit le module. Son extension
__file__
est pyc).
Cette variable contient a priori le nom du module sauf si le
__name__ module est le point dentre du programme auquel cas cette
variable contient __main__.
6. Modules 155
Ces attributs sont accessibles si le nom du module est utilis comme prfixe. Sans
prfixe, ce sont ceux du module lui-mme.
import os
print os.__name__, os.__doc__
if __name__ == "__main__" : print "ce fichier est le point dentre"
else : print "ce fichier est import"
6.1.8 Arborescence de modules, paquetage

Lorsque le nombre de modules devient consquent, il est parfois souhaitable de r-
partir tous ces fichiers dans plusieurs rpertoires. Il faudrait alors inclure tous ces
rpertoires dans la liste sys.path du module sys ce qui parat fastidieux. Python pro-
pose la dfinition de paquetage, ce dernier englobe tous les fichiers Python dun
rpertoire condition que celui-ci contienne un fichier __init__.py qui peut tre
vide. La figure 6.1 prsente une telle organisation et lexemple suivant explicite com-
ment importer chacun de ces fichiers sans avoir modifier les chemins dimportation.
Figure 6.1 : Arborescence de modules, un paquetage est

dfini par un ensemble de fichiers Python et dun fichier
__init__.py. Les rpertoires sont grises tandis que
les fichiers apparaissent avec leur extension.
import mesmodules.extension
import mesmodules.part1.niveaudeux
import mesmodules.part2.niveaudeuxbis
Lors de la premire instruction import mesmodules.extension, le langage Python ne

sintresse pas quau seul fichier extension.py, il excute galement le contenu du
fichier __init__.py. Si cela est ncessaire, cest ici quil faut insrer les instructions
excuter avant limport de nimporte quel module du paquetage.
6.2 Modules internes

Python dispose de nombreux modules prinstalls 3 . Cette liste est trop longue pour
figurer dans ce document, elle est aussi susceptible de sallonger au fur et mesure
du dveloppement du langage Python. La table 6.2 (page 167) regroupe les modules
les plus utiliss.
3. La page http://docs.python.org/modindex.html recense tous les modules disponibles avec Py-
thon.

Le programme suivant calcule lintgrale de Monte Carlo de la fonction f (x) = x
qui consiste
tirer des nombres alatoires dans lintervalle a, b puis faire la moyenne
des x obtenu.
import random # import du module random : simulation du hasard

import math # import du module math : fonctions mathmatiques
def integrale_monte_carlo (a,b,f,n) :

somme = 0.0
for i in range (0,n) :
x = random.random () * (b-a) + a
y = f(x)
somme += f(x)
return somme / n
def racine (x) : return math.sqrt (x)
print integrale (0,1,racine,100000)
Le programme suivant utilise le module urllib pour tlcharger le contenu dune

page et lafficher.
def get_page_html (url):
import urllib
d = urllib.urlopen(url)
res = d.read ()
d.close ()
return res
url = "http://www.lemonde.fr"
print get_page_html (url)
6.3 Modules externes

Les modules externes ne sont pas fournis avec Python, ils ncessitent une installa-
tion supplmentaire. Il serait impossible de couvrir tous les thmes abords par ces
extensions. La simplicit dutilisation du langage Python et son interfaage facile
avec le langage C contribue sa popularit. Il permet de relier entre eux des projets
conus dans des environnements diffrents, dans des langages diffrents. Depuis les
versions 2.3, 2.4 du langage Python, la plupart des modules externes sont faciles
installer, faciles utiliser daprs les exemples que fournissent de plus en plus les
sites Internet qui les hbergent. De plus, il scoule peu de temps entre la mise
disposition dune nouvelle version du langage Python et la mise jour du module
pour cette version 4 . Le paragraphe 1.6 (page 24) donne une liste de modules utiles
du point de vue dun ingnieur gnraliste.
Nanmoins, de nombreux modules ont t conus pour un besoin spcifique et ne
sont plus maintenus. Cela convient lors de lcriture dun programme qui remplit un
4. Ceci nest pas tout--fait vrai pour la version 3.0 du langage dont les changements sont
trop consquents. Un changement du premier numro de version indique souvent des changements
majeurs.
6. Modules 157
besoin ponctuel. Pour une application plus ambitieuse, il est ncessaire de vrifier
quelques informations comme la date de cration, celle de la dernire mise jour,
la prsence dune documentation, une prvision pour la sortie de la future version,
si cest une personne lambda qui la conu ou si cest une organisation comme celle
qui fournit le module pygoogledesktop 5 . Cest le cas de tous les modules prsents
au pragraphe 1.6.
Concernant leur installation, certains modules externes comme SciPy peuvent tre
installs laide dun fichier excutable sous Windows. Il suffit dexcuter ce fichier
pour pouvoir se servir du module par la suite dans un programme Python. Ce mode
dinstallation est disponible pour la plupart des modules de taille consquente.
Dautres modules apparaissent compresss dans un fichier. Une fois dcompresss, ils
incluent un fichier setup.py. Le langage Python fournit une procdure dinstallation
standard : il suffit dcrire quelques lignes dans une fentre de commande ouverte
dans le rpertoire o a t dcompress le fichier contenant le module installer.
c:\python26\python setup.py install
Sous Linux et Mac OS X, cette ligne devient :

python setup.py install
6.4 Python et les autres langages

Il est impossible dobtenir avec le mme langage la fois une grande vitesse de dve-
loppement et une grande vitesse dexcution. La faon dont est gre la mmoire est
un lment important qui explique lappartenance dun langage lune ou lautre
des deux catgories. Python inclut une fonctionnalit quon appelle le garbage col-
lector. A chaque objet cr correspond un emplacement mmoire. Celui-ci peut tre
cr et dtruit de faon explicite ou tre totalement gr par le langage, ce que fait
Python. Il est inutile de se soucier dun objet dont on ne sert plus, il sera dtruit au-
tomatiquement et la place mmoire quil utilisait sera de nouveau exploitable. Cette
aisance de programmation suppose que le langage sache dterminer avec exactitude
quand une variable nest plus utilise. Ceci signifie que Python mmorise des infor-
mations supplmentaires sur tous les objets crs en cours dexcution pour assurer
leur rfrencement. Python est tout moment en mesure de connatre lensemble
des noms de variables utiliss pour dsigner le mme objet. Le garbage collector
alourdit un programme de faon cache, il le ralentit tout en facilitant la conception
des programmes.
Cest pour acclrer lexcution que le langage Python est parfois associ dautres
langages. Le programme final crit en Python utilise des fonctionnalits haut niveau
codes dans un autre langage plus rapide.
6.4.1 Langage Java

Il est possible dutiliser des classes Java en Python. Cette possibilit ne sera pas
plus dtaille ici car le langage Java est galement un langage interprt mme sil
5. http://code.google.com/p/pythongoogledesktop/
est nettement plus rapide. Pour cela, il faut utiliser une version de linterprteur
Python code lui-mme en Java ce qui est le cas de la version Java de Python :
Jython 6 .
6.4.2 Langage C
Il existe deux faons de construire un programme mlant Python et langage C. La
premire mthode est la ralisation de modules Python crits en C ou C++. A moins
de devoir construire un module le plus efficace possible, il est peu conseill de le
faire directement car cela implique de grer soi-mme le rfrencement des variables
cres en C ou C++ et exportes vers Python 7 . Il est prfrable dutiliser des outils
comme la librairie SWIG 8 , ou encore la librairie Boost Python 9 qui simplifie le
travail dintgration. Cest cette dernire option qui est dtaille dans ce livre.
Lutilisation dun autre langage est en effet indispensable lorsque lexigence de rapi-
dit est trop grande. Les modules scientifiques tels que scipy ou numpy ne rpondent
pas tous les besoins. Il faut parfois dvelopper soi-mme des outils numriques en
C++ 10 mme si la partie interface est assure par Python.
Lautre faon de mlanger les deux langages est linclusion de petites parties C dans
un programme Python. Ce point a dj t voqu au paragraphe 1.6.7 (page 27).
Cela permet une optimisation essentiellement locale et numrique mais pas lutili-
sation sous Python dun projet existant programm en C++ ou C. Sous Microsoft
Windows, il existe galement une version du langage IronPython 11 dveloppe pour
ce systme dexploitation. Lintgration des DLL y est plus facile.
Dune manire gnrale, il est prfrable de scinder nettement les parties dun mme
programme qui soccupent de calculs numriques de celles qui prennent en charge
linterface graphique. Construire un module crit en C++ pour grer les calculs
numriques est une faon drastique et efficace doprer cette scission.
6.5 Boost Python

La librairie Boost 12 est une librairie crite en C++ qui a lavantage dtre portable :
elle est utilisable sur les systmes dexploitation les plus courants. Rgulirement
mise jour, elle propose une extension de la librairie Standard Template Library
(STL) incluant notamment les expressions rgulires, les graphes, les threads, ...
Boost Python est une partie de cette librairie qui se prsente galement sous forme
de template 13 .
6. http://www.jython.org/Project/
7. Il faut tenir compte dans le module en C des oprations ncessaires au garbage collector.
8. http://www.swig.org/
9. http://www.boost.org/doc/libs/1_36_0/libs/python/doc/index.html
10. en finance par exemple
11. http://ironpython.net/
12. http://www.boost.org/
13. Les template ou patron de classe sont un concept de mtaprogrammation. Lorsque deux
classes sont presque identiques lexception dun type, le langage C++ autorise la cration dun
patron unique pour ces deux classes. Le C++ est typage statique : il faut crire deux classes
pour crer un tableau dentiers et un tableau de rels mme si le code est le mme. Les template
6. Modules 159
Il est prfrable davoir programm en C++ et en Python pour pouvoir mettre en

uvre les exemples proposs ci-dessous. La prise en main ncessite un investissement,
une certaine habitude des longs messages derreurs issus des template mais une fois
que cela est fait, la librairie acclre notablement lcriture dun module. Il nest
plus utile de se soucier de linterfaage avec Python et notamment du rfrencement
drfrencement des objets pour le garbage collector 14 .
Remarque 6.4 : utilisation dun logiciel de suivi de source
Le nombre de fichiers est assez important, il est conseill de conserver lhistorique
des modifications grce un logiciel de suivi de source tels que TortoiseSVN 15 . Cela
vite de perdre parfois une demi-journe de travail.
6.5.1 Exemple
Vous pourrez trouver ladresse suivante 16 lensemble des sources ncessaires la
ralisation dun module avec Boost Python 17 . Ce projet est configur pour Microsoft
Visual Studio C++ et dfinit un premier module appel PythonSample qui contient
quelques fonctions et une classe. Le rsultat est une DLL (Dynamic Link Library)
qui sera appele par le langage Python. Cet exemple est conu pour Windows.
Un point important est lutilisation de la librairie c : \python26\python26.lib qui
explique quun module compil pour une version donne de Python ne puisse tre
utilis avec une autre version : un module compil avec la version 2.4 ne fonctionnera
pas avec la version 2.6.
Lexemple propos contient galement diffrentes fonctions de conversion des struc-
tures Python vers des containers de la STL ou Standard Template Library. Il suffit
douvrir le fichier pythonsample.sln avec Microsoft Visual C++ pour avoir accs au
code source, cest ce que montre la figure 6.2. Le fichier exesample.sln dfinit un
programme excutable permettant de tester le module sans Python (voir figure 6.3).
Les paragraphes qui suivent prsentent quelques lments de syntaxe et se concluent
par un exercice qui consiste ajouter une fonction au module.
6.5.2 Les grandes lignes

Un module construit avec Boost Python se compose de trois lments, une inamo-
vible DLL boost_python.dll, un fichier <module>.py portant le nom du module,
une DLL <module>.dll. Les deux premiers fichiers ne changent pas, le dernier
contient les classes et fonctions proposes par le module. Lorganisation propose
dans lexemple du paragraphe 6.5.1 suit le schma de la figure 6.3. Lutilisation dun
permettent de factoriser le code de ces deux classes.
14. Le langage Python dtruit automatique les objets qui ne sont plus utiliss. Cette fonc-
tionnalit sappuie sur un rfrencement de tous les objets crs. Alors quil est implicite en
Python, il est explicite dans un module Python crit en langage C moins dutiliser une li-
brairie comme Boost Python qui prend en charge une partie de cette tche (voir la page http:
//docs.python.org/c-api/intro.html#objects-types-and-reference-counts).
15. http://tortoisesvn.tigris.org/
16. http://www.xavierdupre.fr/
17. Ladresse suivante fournit une aide plus complte que ce document : http://www.boost.org/
libs/python/doc/tutorial/doc/html/index.html.
Figure 6.2 : Copie dcran du projet ouvert

avec Microsoft Visual C++. Les deux projets
dllc boost_python et lib_in_dll boost
contiennent les sources Boost Python. Le
projet lib_in_dll libsample contient le
code dune librairie qui est crite sans te-
nir compte du fait que celle-ci sera utilise
sous forme de module Python. Le dernier pro-
jet dllc pythonsample ajoute la couche qui
fera le pont entre la librairie libsample et
le langage Python. Les fichiers conversion.
contiennent des fonctions de conversion des
types Python vers des types C++ ou plus pr-
cisment de la STL (Standard Template Li-
brary). Le fichier definition.cpp contient
le point dentre du module : la macro
BOOST_PYTHON_MODULE qui dclare Py-
thon les fonctions et classes du module.
programme excutable nest pas indispensable. Toutefois, cela permet de tester le

module sans Python et ainsi de faciliter sa conception.
Figure 6.3 : Schma gnral

de lexemple introduit au para-
graphe 6.5.1. Le code de la librairie est
utilis selon deux faons, lintrieur
dun module Python ce qui est lob-
jectif recherch et lintrieur dun
programme excutable utilis pour
tester cette librairie sans passer par
Python.
Une fois le module prt, il est utilisable dans tout programme Python. Il suffit de
limporter. Lors de cette tape, une fonction va tre excute pour indiquer au
langage Python lensemble des classes et des fonctions prsentes dans le module.
6.5.2.1 Initialiser le module
Linitialisation dun module correspond la dclaration au langage Python de len-

semble des classes et des fonctions exporter. Cette partie peut contenir des tches
qui doivent tre faites la premire fois que Python importe le module (initialisation
de variables globales par exemple, chargement de donnes, ...). Lobjectif de cette
initialisation est de construire pour chaque fonction ou classe ou mthode un objet
Python correspondant.
BOOST_PYTHON_MODULE(PythonSample)
{
6. Modules 161
// tapes dinitialisation
} ;
6.5.2.2 Ajout dune fonction
La fonction boost :: python :: def permet de dclarer une fonction. On peut y prciser
les arguments, des valeurs par dfaut, un message daide retourn par linstruction
Python help.
int fonction (int r, const char * s, double x = 4) ;
BOOST_PYTHON_MODULE(PythonSample)
{
boost::python::def ("fonction", fonction,
(boost::python::arg ("r"),
boost::python::arg ("s"),
boost::python::arg ("x") = 4),
"aide associe la fonction") ;
} ;
Les arguments de boost :: python :: def sont les suivants :

1. Le premier argument est le nom de la fonction exporte en Python. Ce nom peut tout
fait tre diffrent de celui de la fonction C++.
2. Le second argument est la fonction elle-mme.
3. Le troisime argument est la liste des arguments suivis ou non dune valeur par dfaut.
4. Le dernier argument est laide associe la fonction.
Ct Python, cela donne :

import PythonSample
print PythonSample.fonction (4, "second")
print PythonSample.fonction (4, "second", 5)
La surcharge de fonction est possible avec Boost Python mais elle ne sera pas dtaille
ici. Le langage Python nautorise pas la surcharge, la rendre possible revient crer
une fonction qui appellera telle ou telle autre fonction selon le type et le nombre des
paramtres quelle aura reus.
6.5.2.3 Ajout dune classe
La dclaration dune classe suit le mme schma que pour une fonction mais avec le
template boost :: python :: class_. Lorsque le constructeur na pas dargument, la
dclaration suit le schma suivant :
boost::python::class_<PythonClassSample> obj (
"ClassSample",
"help on PythonClassSample") ) ;
Le template class_ est instanci sur la classe exporter, ici PythonClassSample.

On cre un objet obj de type boost :: python :: class_ < PythonClassSample >. Son
constructeur prend comme arguments :
1. Le nom de la classe en Python.

2. Laide qui lui est associe. Ce second paramtre est facultatif mais il est conseill de
le renseigner.
Au cas o la classe aurait un constructeur avec des paramtres, il faudrait ajouter

le code suivant :
boost::python::class_<PythonClassSample> obj (
"ClassSample",
"help on PythonClassSample",
boost::python::init<int,const char*> ( // ajout
(boost::python::arg ("a"), // ajout
boost::python::arg ("s") = "default value for s"), // ajout
"help on PythonClassSample constructor" ) // ajout
) ;
Cest--dire un autre template boost :: python :: init < ... > dont les arguments sont
les types des paramtres du constructeur, cest--dire entier et chane de caractres
dans lexemple prcdent. La suite est identique la dclaration dune fonction. Il
est galement possible de dfinir un hritage de la manire qui suit :
boost::python::class_<PythonClassSample,
boost::python::bases<ClassBase> > obj (
"ClassSample",
"help on PythonClassSample") ;
Le template class_ peut recevoir un autre argument qui est

boost :: python :: bases < ClassBase > avec ClassBase dsignant la classe mre
de la classe dclare. Cette dernire doit avoir t dclare au pralable avec cette
mme syntaxe boost :: python :: class_.
boost::python::class_<PythonClassSample,
boost::python::bases<ClassBase> > obj (
// ...
Remarque 6.5 : template C++

Lorsquun template est un argument dun autre template, il faut insrer un espace
entre deux symboles < ou > conscutifs pour viter la confusion avec les opra-
teurs << ou >> qui existent en C++.
6.5.2.4 Ajout dune mthode
La dclaration dune classe passe par la dclaration dune instance du template

class_. Dans les exemples utiliss, cette instance porte le nom obj. Cest cette
instance qui va permettre de dclarer une mthode exactement de la mme manire
quune fonction :
obj.def ( "Random",
&PythonClassSample::Random,
(boost::python::arg ("pos")),
"help on the method") ;
6. Modules 163
Cette mme mthode def permet galement de surcharge le constructeur au cas o

la classe pourrait tre initialise de diffrentes manires. Cela donne :
boost::python::class_<MyVector> obj ("Vector", "help on vector",
boost::python::init<int> (
(PY_ARG ("n")),
"cre un vecteur de dimension n")) ;
// ajout dun constructeur sans paramtre
obj.def (boost::python::init<MyVector> ()) ;
La classe Python Vector peut tre cre avec un ou aucun paramtre :

v = PythonSample.Vector ()
v2 = PythonSample.Vector (10)
6.5.2.5 Ajout dun attribut
La dclaration dun attribut seffectue avec la mthode def_readwrite :

obj.def_readwrite ("a", &PythonClassSample::_a, "retourne un accs a") ;
Le premier paramtre sera son nom sous Python, le second le paramtre lui-mme, le
troisime laide associe. La mthode def_readwrite permet dexporter un attribut
de sorte quil soit lisible et modifiable.
6.5.3 Exemple concret : ajout dune fonction

Lobjectif est dajouter une fonction au module. La premire tape consiste
dcompresser le fichier tlcharg 18 , compiler lensemble des fichiers sous Mi-
crosoft Visual C++ en version release et debug. Lexcution du programme
PythonSample/test/test.py doit seffectuer sans problme. Ajouter une fonction re-
vient ensuite suivre les tapes suivantes :
1. Dclarer la fonction dans le fichier libSample/mafonction.h quon cre.
2. Implmenter la fonction dans le fichier libSample/mafonction.cpp quon cre ga-
lement.
La partie purement C++ est termine 19 , il faut maintenant dfinir la transition

C++Python grce aux tapes suivantes :
1. On dclare une fonction dans un fichier PythonSample/mafonction.h quon cre. Elle
peut par exemple porter le mme nom que la prcdente mais prfix par python_.
2. On peut passer limplmentation de la fonction Python dans un fichier
PythonSample/mafonction.cpp quon cre aussi. Le code est sensiblement le
mme pour chaque fonction ajoute : il faut convertir les paramtres depuis
des structures Python en type C++, appeler la fonction C++ puis effectuer
la conversion inverse. On pourra saider des fonctions contenues dans le fichier
PythonSample/python/conversion.h.
18. depuis ladresse http://www.xavierdupre.fr/
19. Cest facultatif mais il est galement conseill dcrire dcrire un code pour tester cette
fonction dans le fichier exeSample/source/main.cpp. Cela rduit le risque derreurs dexcution
dans cette partie.
3. Il suffit de dclarer la fonction au sein de la macro BOOST_PYTHON_MODULE dans le

fichier PythonSample/python/definition.cpp.
Il ne reste plus qu tester la fonction nouvellement incluse depuis le programme

PythonSample/test/test.py. Le contenu de chaque fichier modifi lors de ces tapes
est prsent par la figure 6.4 page 168.
6.5.4 Garbage collector et pointeur

Le langage Python gre lui-mme la destruction des objets au travers dun garbage
collector. Cela signifie quun objet cr en Python provenant dun module dfini
dans module en C++ sera lui aussi dtruit par Python. A partir du moment o le
destructeur dun objet libre les pointeurs quil a allou, la mmoire ne sera pas
corrompue. Ce schma ne permet pas de prvoir quand lobjet sera dtruit.
Pour parer aux problmes ventuels qui pourraient survenir notamment lorsquun
objet contient des pointeurs sur des donnes dtenues par un autre objet, il est
possible de spcifier Boost Python quun rsultat est une rfrence : son identifi-
cateur Python peut tre dtruit mais pas lobjet quil dsigne. Cest lobjet du tem-
plate boost :: python :: return_internal_reference <> (). Il est utilis pour spci-
fier quune fonction retourne un rsultat qui ne doit pas tre dtruit.
Par exemple, on utilise cette fonctionnalit pour dfinir un oprateur daffectation
comme loprateur +=. La fonction suivante a la mme signature C++ que lopra-
teur +=.
class PythonClassSample
{
...
PythonClassSample & __iadd__ (const PythonClassSample &a) ;
...
} ;
Son rsultat est une rfrence sur un objet existant. Si aucune mention spcifique
nest prcise lors de lexport de la mthode (avec def), lors dun appel lopra-
teur +=, Python va considrer que le rsultat est un objet diffrent alors quil sagit
de deux identificateurs Python faisant rfrence au mme objet C++. Cest pour
cela quon ajoute largument suivant la mthode def :
x.def ("__iadd__",
&PythonClassSample::__iadd__,
boost::python::return_internal_reference<>(),
"addition") ;
De cette faon, il y aura bien deux identificateurs Python faisant rfrence au mme
objet C++. Cest aussi cette syntaxe qui permet de dclarer une fonction retournant
un pointeur sur un objet C++.
6.5.5 Utilisation, installation

Le module termin se compose de trois fichiers :
6. Modules 165
1. la DLL compile avec le code C++ du module,

2. un fichier portant le mme nom que la DLL mais dextension .py : PythonSample.py,
3. un fichier __init__.py.
Voici ce fichier pour lexemple prsent au paragraphe 6.5.1. La fonction importante

de ce fichier est load_dynamic qui charge la DLL en mmoire au cas o elle naurait
jamais t charge.
import sys
if "PythonSample" not in sys.modules :
PythonSample = imp.load_dynamic (PythonSample, PythonSample.dll)
sys.modules ["PythonSample"] = PythonSample
6.5.6 Dtails sur lexemple du paragraphe 6.5.1

Certains fichiers exposs ici ont t simplifis par rapport lexemple tlchargeable.
Celui-ci a t configur de manire produire deux DLL, une autre pour la version
release PythonSample.dll et une pour la version debug PythonSampled.dll. Ceci per-
met dutiliser lune ou lautre des versions dans le mme programme. La version
debug facilite la correction des erreurs qui pourraient survenir lors de lutilisation
du module sous Python(voir le paragraphe 6.5.7). Il suffit alors dcrire :
import PythonSampled as PythonSample

# au lieu de import PythonSample
De cette faon, passer dune DLL lautre est simple et permet de dbugger, tche
quintroduit le paragraphe suivant. Si le programme Python stale sur plusieurs
fichiers, il est plus pratique dajouter au dbut de chacun fichier qui utilise le mo-
dule C++ :
import sys
if "PythonSampled" in sys.modules : PythonSample = sys.modules ["PythonSampled"]
else : import PythonSample
6.5.7 Debuggage
Il ne serait pas pensable de dvelopper des outils sans pouvoir utiliser un dbug-
geur. Dans lexemple prsent au paragraphe 6.5.1, le fichier testd.py nutilise pas
le module compil dans sa version release mais dans sa version debug . Lexcution
est plus lente mais permet de faire appel au dbuggeur pour corriger une ventuelle
erreur dexcution.
Une manire de dbugger consiste momentanment arrter lexcution du pro-
gramme Python ( laide de la fonction raw_input par exemple), le temps dattacher
le dbuggeur de Microsoft Visual C++ au processus dont le nom est python.exe ou
pythonw.exe. Il ne reste plus qu placer des pointeurs darrt puis continuer lex-
cution du programme Python jusqu ce que ces pointeurs darrt soient atteints.
Une seconde mthode consiste volontairement insrer dans le code C++ du mo-
dule linstruction __debugbreak(). Lorsque le module est excut via un programme
Python et quil arrive sur cette ligne, il vous demande lautorisation de continuer
lexcution via un dbuggeur. Il faudra penser enlever la ligne une fois le module
corrig.
Il reste toutefois une dernire faon plus classique de dbugger qui est lajout dans le
code dinstructions crivant des messages dans un fichier texte. On crit des logs ou
des traces. De cette faon, lorsque le programme provoque une erreur, on connat la
squence de messages gnrs par le programme. Sils sont suffisamment explicites,
cela permet de corriger lerreur. Sinon, lajout de messages supplmentaires puis une
nouvelle excution du programme permettront dtre plus prcis quant la cause
de lerreur.
Outre ces trois mthodes de dbuggage, il est possible quun module doivent retour-
ner un code derreur ou gnrer une exception qui soit attrape par linterprteur
Python puis afficher. Cest lobjet des lignes qui suivent :
if (<condition>)
throw std::runtime_error ("message derreur") ;
Toute exception drivant de runtime_error sera intercepte par linterprteur Py-

thon. La librairie Boost Python gnre galement des exceptions notamment lorsque
les paramtres envoys une fonction du module ne correspondent pas avec sa si-
gnature.
En terme darchitecture, il est conseill de bien scinder la partie utilisant Boost Py-
thon des algorithmes. Boost Python nest quune passerelle vers Python. Il pourrait
tre ncessaire de construire une autre passerelle vers dautres langages tel que le
Visual Basic pour Applications (VBA). De mme, outre la passerelle vers Python,
il est utile de construire un programme excutable permettant de tester les algo-
rithmes crits en C++ avant de les exporter. Cela rduit beaucoup le temps de
dbuggage qui peut alors grer sparment la partie C++ de la partie interfaage
entre Python et C++.
6.5.8 Pour aller plus loin

La librairie Boost Python 20 permet de faire beaucoup plus de choses que ce qui
est prsent dans ces paragraphes. Ceux-ci contiennent nanmoins lessentiel pour
exporter vers Python les objets les plus simples. Il est galement possible de :
surcharger une mthode C++ dans un programme Python,
excuter un programme crit en Python depuis un programme C++.
Il faut parfois une certaine dose de volont et de tnacit pour parvenir matriser
un outil tel que Boost Python, surtout lorsquune erreur se dclare dans le code de
librairie aprs une modification en dehors de cette mme librairie.
20. http://www.boost.org/libs/python/doc/
6. Modules 167
calendar Grer les calendriers, les dates (voir chapitre 7).

cgi Utilis dans les scripts CGI (programmation Internet)
cmath Fonctions mathmatiques complexes.
codecs Jeux de caractres (voir paragraphe 7.8)
copy Copies dinstances de classes.
csv Gestion des fichiers au format CSV (utiliss par Microsoft Excel ).
datetime Calculs sur les dates et heures (voir chapitre 7).
gc Gestion du garbage collector.
Lire les options des paramtres passs en arguments dun programme
getopt
Python.
glob Chercher des fichiers (voir chapitre 7).
hashlib Fonctions de cryptage.
htmllib Lire le format HTML.
math Fonctions mathmatiques standard telles que cos, sin, exp, log...
Fonctions systmes dont certaines fonctions permettant de grer les
os
fichiers (voir chapitre 7).
os.path Manipulations de noms de fichiers (voir chapitre 7).
Srialisation dobjets, la srialisation consiste convertir des donnes
pickle structures de faon complexe en une structure linaire facilement
enregistrable dans un fichier (voir chapitre 7).
profile Etudier le temps pass dans les fonctions dun programme.
random Gnration de nombres alatoires.
re Expressions rgulires (voir paragraphe 7.6).
shutil Copie de fichiers (voir chapitre 7).
Accs aux fonctionnalits du gestionnaire de base de donnes
sqlite3
SQLite3.
string Manipulations des chanes de caractres.
Fonctions systmes, fonctions lies au langage Python (voir cha-
sys
pitre 7).
threading Utilisation de threads (voir chapitre 9).
time Accs lheure, lheure systme, lheure dune fichier.
Tkinter Interface graphique (voir chapitre 8).
unittest Tests unitaires (ou comment amliorer la fiabilit dun programme).
urllib Pour lire le contenu de page HTML sans utiliser un navigateur.
urllib2 Module plus complet que urllib.
xml.dom Lecture du format XML.
xml.sax Lecture du format XML.
zipfile Lecture de fichiers ZIP (voir chapitre 7).
Table 6.1 : Liste de modules souvent utiliss. La liste exhaustive est disponible ladresse
http:// docs.python.org/ modindex.html . Les moteurs de recherche sur Internet retournent
des rsultats assez pertinents sur des requtes du type python + le nom du module. Les
rsultats sont principalement en langue anglaise.
Fichier libSample/mafonction.h Fichier libSample/mafonction.cpp

#ifndef LIB_MAFONCTION_H #include "mafonction.h"
#define LIB_MAFONCTION_H void somme_vecteur (
const std::vector<double> &v1,
#include <vector> const std::vector<double> &v2,
std::vector<double> &res)
void somme_vecteur ( {
const std::vector<double> &v1, if (v1.size () != v2.size ())
const std::vector<double> &v2, throw std::runtime_error (
std::vector<double> &res) ; "dimensions diffrentes") ;
res.resize (v1.size ()) ;
#endif std::vector<double>::
const_iterator it1,it2 ;
std::vector<double>::iterator it3 ;
for (it1 = v1.begin (),
it2 = v2.begin (),
it3 = res.begin () ;
it1 != v1.end () ;
++it1, ++it2, ++it3)
*it3 = *it1 + *it2 ;
}
Fichier PythonSample/mafonction.h Fichier PythonSample/mafonction.cpp
#ifndef PYTHON_MAFONCTION_H #include "python/definition.h"
#define PYTHON_MAFONCTION_H #include "mafonction.h"
#include "../libsample/mafonction.h"
#include "python/definition.h" #include "python/conversion.h"
#include "python/conversion.hpp"
boost::python::list boost::python::list
python_somme_vecteur ( python_somme_vecteur (
boost::python::list v1, boost::python::list v1,
boost::python::list v2) ; boost::python::list v2)
{
#endif std::vector<double> cv1,cv2,cres ;
PythonConvert (v1, cv1) ;
PythonConvert (v2, cv2) ;
somme_vecteur (cv1, cv2, cres) ;
boost::python::list res ;
PythonConvert (cres, res) ;
return res ;
}
Fichier PythonSample/python/main.cpp Fichier PythonSample/test/test.py
// ... import PythonSample as PS
#include "../mafonction.h" v1 = [1.0, 2.0]
BOOST_PYTHON_MODULE(PythonSample) v2 = [6.5, 7.8]
{ v3 = PS.somme_vecteur (v1, v2)
// ...
def ("somme_vecteur",
&python_somme_vecteur,
(boost::python::arg ("v1"),
boost::python::arg ("v2")),
"retourne la somme de deux vecteurs");
// ...
} ;
Figure 6.4 : Six fichiers modifis pour ajouter une fonction dans un module Python crit
en C++ partir de lexemple accessible depuis ladresse http:// www.xavierdupre.fr/ .
Chapitre 7
Fichiers, expressions rgulires, dates
Lorsquun programme termine son excution, toutes les informations stockes dans
des variables sont perdues. Un moyen de les conserver est de les enregistrer dans un
fichier sur disque dur. A lintrieur de celui-ci, ces informations peuvent apparatre
sous un format texte qui est lisible par nimporte quel diteur de texte, dans un
format compress, ou sous un autre format connu par le concepteur du programme.
On appelle ce dernier type un format binaire, il est adquat lorsque les donnes
conserver sont trs nombreuses ou lorsquon dsire que celles-ci ne puissent pas tre
lues par une autre application que le programme lui-mme. En dautres termes, le
format binaire est illisible except pour celui qui la conu.
Ce chapitre abordera pour commencer les formats texte, binaire et compress (zip)
directement manipulable depuis Python. Les manipulations de fichiers suivront pour
terminer sur les expressions rgulires qui sont trs utilises pour effectuer des re-
cherches textuelles. A lissue de ce chapitre, on peut envisager la recherche lint-
rieur de tous les documents textes prsents sur lordinateur, de dates particulires, de
tous les numros de tlphones commenant par 06... En utilisant des modules tels
que reportlab 1 ou encore win32com 2 , il serait possible dtendre cette fonctionnalit
aux fichiers de type pdf et aux fichiers Microsoft Word, Excel.
7.1 Format texte

Les fichiers texte sont les plus simples : ce sont des suites de caractres. Le for-
mat HTML et XML font partie de cette catgorie. Ils servent autant conserver
des informations qu en changer comme par exemple transmettre une matrice
Microsoft Excel.
Ce format, mme sil est simple, implique une certaine organisation dans la faon
de conserver les donnes afin de pouvoir les rcuprer. Le cas le plus frquent est
lenregistrement dune matrice : on choisira dcrire les nombres les uns la suite
des autres en choisissant un sparateur de colonnes et un sparateur de lignes. Ce
point sera abord la fin de cette section.
7.1.1 Ecriture
La premire tape est lcriture. Les informations sont toujours crites sous forme
de chanes de caractres et toujours ajoutes la fin du fichier qui sallonge jusqu
1. http://www.reportlab.com/software/opensource/rl-toolkit/
2. http://python.net/crew/mhammond/win32/Downloads.html
ce que toutes les informations y soient crites. Lcriture seffectue toujours selon le
mme schma.
1. cration ou ouverture du fichier,
2. criture,
3. fermeture.
Lors de louverture, le fichier dans lequel seront crites les informations est cr sil
nexiste pas ou nettoy sil existe dj. La fermeture permet dautres programmes
de lire ce que vous avez plac dans ce fichier. Sans cette dernire tape, il sera
impossible dy accder nouveau pour le lire ou y crire nouveau. A lintrieur
dun programme informatique, crire dans un fichier suit toujours le mme schma :
f = open ("nom-fichier", "w") # ouverture
f.write ( s ) # criture de la chane de caractres s

f.write ( s2 ) # criture de la chane de caractres s2
...
f.close () # fermeture
Les tapes douverture et de fermeture sont toujours prsentes en ce qui concerne

les fichiers. Il sagit dindiquer au systme dexploitation que le programme souhaite
accder un fichier et interdire tout autre programme laccs ce fichier. Un autre
programme qui souhaiterait crer un fichier du mme nom ne le pourrait pas tant
que ltape de fermeture nest pas excute. En revanche, il pourrait tout fait le
lire car la lecture ne perturbe pas lcriture.
Remarque 7.1 : fichiers ouverts et non ferms
Lorsque que le programme se termine, mme sil reste des fichiers "ouverts" pour
lesquels la mthode close na pas t appele, ils seront automatiquement ferms.
Certains caractres sont fort utiles lors de lcriture de fichiers texte afin dorganiser
les donnes. Le symbole ; est trs utilis comme sparateur de colonnes pour une
matrice, on utilise galement le passage la ligne ou la tabulation. Comme ce ne
sont pas des caractres "visibles", ils ont des codes :
\n passage la ligne
\t insertion dune tabulation, indique un passage la colonne suivante dans le
logiciel Microsoft Excel
Il existe peu de manires diffrentes de conserver une matrice dans un fichier, le

programme ressemble dans presque tous les cas celui qui suit :
mat = ... # matrice de type liste de listes
f = open ("mat.txt", "w")
for i in range (0,len (mat)) : # la fonction join est aussi
for j in range (0, len (mat [i])) : # frquemment utilise
f.write ( str (mat [i][j]) + "\t") # pour assembler les chanes
f.write ("\n") # un une seule et rduire le
f.close () # nombre dappels f.write
7. Fichiers, expressions rgulires, dates 171
Remarque 7.2 : fonction open

La fonction open accepte deux paramtres, le premier est le nom du fichier, le second
dfinit le mode douverture : w pour crire (write), "a" pour crire et ajouter
(append), "r" pour lire (read). Ceci signifie que la fonction open sert ouvrir un
fichier quelque soit lutilisation quon en fait.
Remarque 7.3 : autre syntaxe avec print
Il existe une autre syntaxe qui permet de remplacer la mthode write. Elle utilise
la mme syntaxe que celle de linstruction print et fonctionne de la mme manire
ceci prs quelle ajoute >> f, entre le mot-cl print et le texte crire dans le
fichier f. Nanmoins, ce nest pas cette syntaxe qui sera mise en avant dans les
versions futures de Python.
mat = ... # matrice de type liste de listes
f = open ("mat.txt", "w")
for i in range (0,len (mat)) :
for j in range (0, len (mat [i])) :
print >> f, str (mat [i][j]), "\t", # ligne change
print >> f # ligne change
f.close ()
Remarque 7.4 : criture diffre

A la premire criture dans un fichier (premier appel la fonction write), la taille
du fichier cre est souvent nulle. Lcriture dans un fichier nest pas immdiate,
le langage Python attend davoir reu beaucoup dinformations avant de les crire
physiquement sur le disque dur. Les informations sont places dans un tampon ou
buffer. Lorsque le tampon est plein, il est crit sur disque dur. Pour viter ce dlai,
il faut soit fermer puis rouvrir le fichier soit appeler la mthode flush qui ne prend
aucun paramtre. Ce mcanisme vise rduire le nombre daccs au disque dur, il
nest pas beaucoup plus long dy crire un caractre plutt que 1000 en une fois.
7.1.2 Ecriture en mode "ajout"

Lorsquon crit des informations dans un fichier, deux cas se prsentent. Le premier
consiste ne pas tenir compte du prcdent contenu de ce fichier lors de son ouver-
ture pour criture et lcraser. Cest le cas trait par le prcdent paragraphe. Le
second cas consiste ajouter toute nouvelle information celles dj prsentes lors
de louverture du fichier. Ce second cas est presque identique au suivant hormis la
premire ligne qui change :
f = open ("nom-fichier", "a") # ouverture en mode ajout, mode "a"
...
Pour comprendre la diffrence entre ces deux modes douverture, voici deux pro-
grammes. Celui de gauche nutilise pas le mode ajout tandis que celui de droite
lutilise lors de la seconde ouverture.
f = open ("essai.txt", "w") f = open ("essai.txt", "w")

f.write (" premiere fois ") f.write (" premiere fois ")
f.close () f.close ()
f = open ("essai.txt", "w") f = open ("essai.txt", "a") ###
f.write (" seconde fois ") f.write (" seconde fois ")
f.close () f.close ()
# essai.txt : seconde fois # essai.txt : premiere fois seconde fois
Le premier programme cre un fichier essai.txt qui ne contient que les informa-
tions crites lors de la seconde phase dcriture, soit seconde fois. Le second utilise
le mode ajout lors de la seconde ouverture. Le fichier essai.txt, mme sil exis-
tait avant lexcution de ce programme, est effac puis rempli avec linformation
premiere fois. Lors de la seconde ouverture, en mode ajout, une seconde chane
de caractres est ajoute. le fichier essai.txt, aprs lexcution du programme
contient donc le message : premiere fois seconde fois.
Remarque 7.5 : fichier de traces
Un des moyens pour comprendre ou suivre lvolution dun programme est dcrire
des informations dans un fichier ouvert en mode ajout qui est ouvert et ferm sans
cesse. Ce sont des fichiers de traces ou de log. Ils sont souvent utiliss pour vrifier des
calculs complexes. Ils permettent par exemple de comparer deux versions diffrentes
dun programme pour trouver quel endroit ils commencent diverger.
7.1.3 Lecture
La lecture dun fichier permet de retrouver les informations stockes grce une
tape pralable dcriture. Elle se droule selon le mme principe, savoir :
1. ouverture du fichier en mode lecture,
2. lecture,
3. fermeture.
Une diffrence apparat cependant lors de la lecture dun fichier : celle-ci seffectue
ligne par ligne alors que lcriture ne suit pas forcment un dcoupage en ligne.
Les instructions crire pour lire un fichier diffrent rarement du schma qui suit
o seule la ligne indique par () change en fonction ce quil faut faire avec les
informations lues.
f = open ("essai.txt", "r") # ouverture du fichier en mode lecture
for ligne in f : # pour toutes les lignes du fichier
print ligne # on affiche la ligne (*)
f.close () # on ferme le fichier
Pour des fichiers qui ne sont pas trop gros (< 100000 lignes), il est possible dutiliser
la mthode readlines qui rcupre toutes les lignes dun fichier texte en une seule
fois. Le programme suivant donne le mme rsultat que le prcdent.
l = f.readlines () # lecture de toutes les lignes, places dans une liste
f.close () # fermeture du fichier
for s in l : print s # on affiche les lignes lcran (*)

Remarque 7.6 : code de fin de ligne

Lorsque le programme prcdent lit une ligne dans un fichier, le rsultat lu inclut
le ou les caractres (\n \r) qui marquent la fin dune ligne. Cest pour cela que la
lecture est parfois suivie dune tape de nettoyage.
l = f.readlines () # lecture de toutes les lignes, places dans une liste
# contiendra la liste des lignes nettoyes

l_net = [ s.strip ("\n\r") for s in l ]
Les informations peuvent tre structures de faon plus labore dans un fichier
texte, cest le cas des formats HTML ou XML. Pour ce type de format plus com-
plexe, il est dconseill de concevoir soi-mme un programme capable de les lire,
il existe presque toujours un module qui permette de le faire. Cest le cas du mo-
dule HTMLParser pour le format HTML ou xml.sax pour le format XML. De plus,
les modules sont rgulirement mis jour et suivent lvolution des formats quils
dcryptent.
Un fichier texte est le moyen le plus simple dchanger des matrices avec un tableur
et il nest pas besoin de modules dans ce cas. Lorsquon enregistre une feuille de
calcul sous format texte, le fichier obtenu est organis en colonnes : sur une mme
ligne, les informations sont disposes en colonne dlimites par un sparateur qui
est souvent une tabulation (\t) ou un point virgule comme dans lexemple suivant :
nom ; prnom ; livre

Hugo ; Victor ; Les misrables
Kessel ; Joseph ; Le lion
Woolf ; Virginia ; Mrs Dalloway
Calvino ; Italo ; Le baron perch
Pour lire ce fichier, il est ncessaire de scinder chaque ligne en une liste de chanes
de caractres, on utilise pour cela la mthode split des chanes de caractres.
mat = [] # cration dune liste vide,
for li in f : # pour toutes les lignes du fichier
s = li.strip ("\n\r") # on enlve les caractres de fin de ligne
l = s.split (";") # on dcoupe en colonnes
mat.append (l) # on ajoute la ligne la matrice
Ce format de fichier texte est appel CSV 3 , il peut tre relu depuis un programme
Python comme le montre lexemple prcdent ou tre charg depuis Microsoft Excel
en prcisant que le format du fichier est le format CSV. Pour les valeurs numriques,
il ne faut pas oublier de convertir en caractres lors de lcriture et de convertir en
nombres lors de la lecture.
Remarque 7.7 : nombres franais et anglais
Les nombres rels scrivent en anglais avec un point pour sparer la partie entire
3. Comma Separated Value
de la partie dcimale. En franais, il sagit dune virgule. Il est possible que, lors
de la conversion dune matrice, il faille remplacer les points par des virgules et
rciproquement pour viter les problmes de conversion.
7.2 Fichiers zip

Les fichiers zip sont trs rpandus de nos jours et constituent un standard de com-
pression facile daccs quelque soit lordinateur et son systme dexploitation. Le
langage Python propose quelques fonctions pour compresser et dcompresser ces
fichiers par lintermdiaire du module zipfile. Le format de compression zip est
un des plus rpandus bien quil ne soit pas le plus performant 4 . Ce format nest
pas seulement utilis pour compresser mais aussi comme un moyen de regrouper
plusieurs fichiers en un seul.
7.2.1 Lecture
Lexemple suivant permet par exemple dobtenir la liste des fichiers inclus dans un
fichier zip :
import zipfile
file = zipfile.ZipFile ("exemplezip.zip", "r")
for info in file.infolist () :
print info.filename, info.date_time, info.file_size
file.close ()
Les fichiers compresss ne sont pas forcment des fichiers textes mais de tout format.
Le programme suivant extrait un fichier parmi ceux qui ont t compresss puis
affiche son contenu (on suppose que le fichier lu est au format texte donc lisible).
import zipfile
file = zipfile.ZipFile ("exemplezip.zip", "r")
data = file.read ("informatique/testzip.py")
file.close ()
print data
On retrouve dans ce cas les tapes douverture et de fermeture mme si la premire

est implicitement inclus dans le constructeur de la classe ZipFile.
7.2.2 Ecriture
Pour crer un fichier zip, le procd ressemble la cration de nimporte quel fichier.
La seule diffrence provient du fait quil est possible de stocker le fichier compresser
sous un autre nom lintrieur du fichier zip, ce qui explique les deux premiers
arguments de la mthode write. Le troisime paramtre indique si le fichier doit
tre compress (zipfile.ZIP_DEFLATED) ou non (zipfile.ZIP_STORED).
4. Dautres formats proposent de meilleurs taux de compressions sur les fichiers textes existent,
voir http://www.7-zip.org/.
import zipfile
file = zipfile.ZipFile ("test.zip", "w")
file.write ("fichier.txt", "nom_fichier_dans_zip.txt", zipfile.ZIP_DEFLATED)
file.close ()
Une utilisation possible de ce procd serait lenvoi automatique dun mail contenant
un fichier zip en pice jointe. Une requte comme python prcdant le nom de votre
serveur de mail permettra, via un moteur de recherche, de trouver des exemples sur
Internet.
7.3 Manipulation de fichiers

Il arrive frquemment de copier, recopier, dplacer, effacer des fichiers. Lorsquil
sagit de quelques fichiers, le faire manuellement ne pose pas de problme. Lorsquil
sagit de traiter plusieurs centaines de fichiers, il est prfrable dcrire un programme
qui soccupe de le faire automatiquement. Cela peut tre la cration automatique
dun fichier zip incluant tous les fichiers modifis durant la journe ou la rorgani-
sation de fichiers musicaux au format mp3 laide de modules complmentaires tel
que mutagen 5 ou pymedia 6 .
Remarque 7.8 : majuscules et minuscules
Pour ceux qui ne sont pas familiers des systmes dexploitation, il faut noter que
Windows ne fait pas de diffrences entre les majuscules et les minuscules lintrieur
dun nom de fichier. Les systmes Linux et Mac OS X font cette diffrence 7 .
7.3.1 Gestion des noms de chemins

Le module os.path propose plusieurs fonctions trs utiles qui permettent entre autres
de tester lexistence dun fichier, dun rpertoire, de rcuprer diverses informations
comme sa date de cration, sa taille... Cette liste prsente par la table 7.1 est loin
dtre exhaustive mais elle donne une ide de ce quil est possible de faire.
7.3.2 Copie, suppression

Le module shutil permet de copier des fichiers, le module os permet de les supprimer
ou de les renommer, il permet galement de crer ou de supprimer des rpertoires.
Ces oprations sont regroupes dans la table 7.2.
7.3.3 Liste de fichiers

La fonction listdir du module os permet de retourner les listes des lments inclus
dans un rpertoire (fichiers et sous-rpertoires). Toutefois, le module glob propose
5. http://code.google.com/p/mutagen/
6. http://pymedia.org/
7. Ceci explique que certains programmes aient des comportements diffrents selon le systme
dexploitation sur lequel ils sont excuts ou encore que certains liens Internet vers des fichiers ne
dbouchent sur rien car ils ont t saisis avec des diffrences au niveau des minuscules majuscules.
abspath(path) Retourne le chemin absolu dun fichier ou dun rpertoire.

Retourne le plus grand prfixe commun un ensemble de
commonprefix(list)
chemins.
dirname(path) Retourne le nom du rpertoire.
exists(path) Dit si un chemin est valide ou non.
getatime(path) Retourne diverses dates concernant un chemin, date du
getmtime(path) dernier accs (getatime), date de la dernire modification
getctime(path) (getmtime), date de cration (getctime).
getsize(file) Retourne la taille dun fichier.
isabs(path) Retourne True si le chemin est un chemin absolu.
isfile(path) Retourne True si le chemin fait rfrence un fichier.
isdir(path) Retourne True si le chemin fait rfrence un rpertoire.
Construit un nom de chemin tant donn une liste de r-
join(p1, p2, ...)
pertoires.
Dcoupe un chemin, isole le nom du fichier ou le dernier
split(path)
rpertoire des autres rpertoires.
splitext(path) Dcoupe un chemin en nom + extension.
Table 7.1 : Liste non exhaustive des fonctionnalits offertes par le module os.path. La page
http:// docs.python.org/ library/ os.path.html rfrence toutes les fonctions de ce module.
copy(f1, f2) (module shutil) Copie le fichier f1 vers f2

(module os) Change le rpertoire courant, cette fonction peut
tre importante lorsquon utilise la fonction system du module os
pour lancer une instruction en ligne de commande ou lorsquon
chdir(p) crit un fichier sans prciser le nom du rpertoire, le fichier sera
crit dans ce rpertoire courant qui est par dfaut le rpertoire
o est situ le programme Python. Cest partir du rpertoire
courant que sont dfinis les chemins relatifs.
(module os) Retourne le rpertoire courant, voir la fonction
getcwd()
chdir.
mkdir(p) (module os) Cre le rpertoire p.
(module os) Cre le rpertoire p et tous les rpertoires des ni-
veaux suprieurs sils nexistent pas. Dans le cas du rpertoire
makedirs(p)
d : /base/repfinal, cre dabord d : /base sil nexiste pas, puis
d : /base/repfinal.
remove(f) (module os) Supprime un fichier.
rename(f1, f2) (module os) Renomme un fichier
rmdir(p) (module os) Supprime un rpertoire
Table 7.2 : Liste non exhaustive des fonctionnalits offertes par les modules shutil et
os. Les page http:// docs.python.org/ library/ shutil.html et http:// docs.python.org/ library/
os.html rfrencent toutes les fonctions de ces modules.
une fonction plus intressante qui permet de retourner la liste des lments dun
rpertoire en appliquant un filtre. Le programme suivant permet par exemple de
retourner la liste des fichiers et des rpertoires inclus dans un rpertoire.
# coding: latin-1
import glob
import os.path
def liste_fichier_repertoire (folder, filter) :

# rsultats
file,fold = [], []
# recherche des fichiers obissant au filtre

res = glob.glob (folder + "\\" + filter)
# on inclut les sous-rpertoires qui nauraient pas t

# slectionns par le filtre
rep = glob.glob (folder + "\\*")
for r in rep :
if r not in res and os.path.isdir (r) :
res.append (r)
# on ajoute fichiers et rpertoires aux rsultats

for r in res :
path = r
if os.path.isfile (path) :
# un fichier, rien faire part lajouter
file.append (path)
else :
# sous-rpertoire : on appelle nouveau la fonction
# pour retourner la liste des fichiers inclus
fold.append (path)
fi,fo = liste_fichier_repertoire (path, filter)
file.extend (fi) # on tend la liste des fichiers
fold.extend (fo) # on tend la liste des rpertoires
# fin
return file,fold
folder = r"D:\Dupre\_data\informatique"
filter = "*.tex"
file,fold = liste_fichier_repertoire (folder, filter)
for f in file : print "fichier ", f

for f in fold : print "rpertoire ", f
Le programme repose sur lutilisation dune fonction rcursive qui explore dabord le
premier rpertoire. Elle se contente dajouter une liste les fichiers quelle dcouvre
puis cette fonction sappelle elle-mme sur le premier sous-rpertoire quelle ren-
contre. La fonction walk permet dobtenir la liste des fichiers et des sous-rpertoire.
Cette fonction parcourt automatiquement les sous-rpertoires inclus, le programme
est plus court mais elle ne prend pas en compte le filtre qui peut tre alors pris en
compte grce aux expressions rgulires (paragraphe 7.6).
# coding: latin-1
import os
def liste_fichier_repertoire (folder) :

file, rep = [], []

for r, d, f in os.walk (folder) :
for a in d : rep.append (r + "/" + a)
for a in f : file.append (r + "/" + a)
return file, rep
folder = r"D:\Dupre\_data\informatique"
file,fold = liste_fichier_repertoire (folder)
for f in file : print "fichier ", f

for f in fold : print "rpertoire ", f
7.4 Format binaire

Ecrire et lire des informations au travers dun fichier texte revient convertir les
informations quel que soit leur type dans un format lisible pour tout utilisateur.
Un entier est crit sous forme de caractres dcimaux alors que sa reprsentation
en mmoire est binaire. Cette conversion dans un sens puis dans lautre est parfois
juge coteuse en temps de traitement et souvent plus gourmande en terme de
taille de fichiers 8 mme si elle permet de relire les informations crites grce
nimporte quel diteur de texte. Il est parfois plus judicieux pour une grande masse
dinformations dutiliser directement le format binaire, cest--dire celui dans lequel
elles sont stockes en mmoire. Les informations apparaissent dans leur forme la
plus simple pour lordinateur : une suite doctets (bytes en anglais). Deux tapes
vont intervenir que ce soit pour lcriture :
1. On rcupre les informations dans une suite doctets (fonction pack du module
struct).
2. On les crit dans un fichier (mthode write affilie aux fichiers).
Ou la lecture :
1. On lit une suite doctets depuis un fichier (mthode read affilie aux fichiers).
2. On transforme cette suite doctets pour retrouver linformation quelle formait initia-
lement (fonction unpack du module struct).
Lutilisation de fichiers binaires est moins vidente quil ny parat et il faut faire
appel des modules spcialiss alors que la gestion des fichiers texte ne pose aucun
problme. Cela vient du fait que Python ne donne pas directement accs la manire
dont sont stockes les informations en mmoire contrairement des langages tels
que le C++. Lintrt de ces fichiers rside dans le fait que linformation quils
contiennent prend moins de place stocke en binaire plutt que convertie en chanes
de caractres au format texte 9 .
Lcriture et la lecture dun fichier binaire soulvent les mmes problmes que pour
un fichier texte : il faut organiser les donnes avant de les enregistrer pour savoir com-
ment les retrouver. Les types immuables (rel, entier, caractre) sont assez simples
8. Un fichier texte compress, au format zip par exemple, est une alternative aux fichiers binaires
en terme de taille mais il allonge la lecture et lcriture par des tapes de compression et de
dcompression.
9. Par exemple, un rel est toujours quivalent huit caractres en format binaire alors que sa
conversion au format texte va souvent jusqu quinze caractres.
grer dans ce format. Pour les objets complexes, Python propose une solution grce
au module pickle.
7.4.1 Ecriture dans un fichier binaire

Lcriture dun fichier binaire commence par louverture du fichier en mode criture
par linstruction file = open ("<nom_fichier>", "wb"). Cest le code wb qui
est important (w pour write, b pour binary), il spcifie le mode douverture w et
le format b. La fermeture est la mme que pour un fichier texte.
Le module struct et la fonction pack permet de convertir les informations sous forme
de chane de caractres avant de les enregistrer au format binaire. La fonction pack
construit une chane de caractres gale au contenu de la mmoire. Son affichage
avec la fonction print produit quelque chose dillisible le plus souvent. Le tableau
suivant montre les principaux formats de conversion 10 .
code type correspondant

c caractre
B caractre non sign (octet)
i entier (4 octets)
I entier non sign (4 octets)
d double (8 octets)
Lutilisation de ces codes est illustre au paragraphe 7.4.3.
7.4.2 Lecture dun fichier binaire

Le code associ louverture dun fichier binaire en mode lecture est rb, cela
donne : file = open ("<nom_fichier>", "rb"). La lecture utilise la fonction
unpack pour effectuer la conversion inverse, celle dune chane de caractres en en-
tiers, rels, ... Le paragraphe suivant illustre la lecture et lcriture au format binaire.
7.4.3 Exemple complet

Cet exemple cre un fichier info.bin puis crit des informations lintrieur. Il ne
sera pas possible dafficher le contenu du fichier laide dun diteur de texte. La
mthode pack accepte un nombre de paramtres variable 11 , ceci explique la syntaxe
struct.pack(cccc, s).
# coding: latin-1
import struct
# on enregistre un entier, un rel et 4 caractres
i = 10
x = 3.1415692
s = "ABCD"
# criture
file = open ("info.bin", "wb")
10. La liste complte figure ladresse http://docs.python.org/library/struct.html.

11. voir galement paragraphe 3.4.10, page 81
file.write ( struct.pack ("i" , i) )

file.write ( struct.pack ("d" , x) )
file.write ( struct.pack ("cccc" , *s) )
file.close ()
# lecture
file = open ("info.bin", "rb")
i = struct.unpack ("i", file.read (4))
x = struct.unpack ("d", file.read (8))
s = struct.unpack ("cccc", file.read (4))
file.close ()
# affichage pour vrifier que les donnes ont t bien lues

print i # affiche (10,)
print x # affiche (3.1415692000000002,)
print s # affiche (A, B, C, D)
Les rsultats de la mthode unpack apparaissent dans un tuple mais les donnes
sont correctement rcupres. Ce programme fait aussi apparatre une des particu-
larit du format binaire. On suppose ici que la chane de caractres est toujours
de longueur 4. En fait, pour stocker une information de dimension variable, il faut
dabord enregistrer cette dimension puis sen servir lors de la relecture pour connatre
le nombre doctets lire. On modifie le programme prcdent pour sauvegarder une
chane de caractres de longueur variable.
# coding: latin-1
import struct
# on enregistre un entier, un rel et n caractres
i = 10
x = 3.1415692
s = "ABCDEDF"
# criture
file = open ("info.bin", "wb")
file.write ( struct.pack ("i" , i) )
file.write ( struct.pack ("d" , x) )
file.write ( struct.pack ("i" , len(s)) ) # on sauve la dimension de s
file.write ( struct.pack ("c" * len(s) , *s) )
file.close ()
# lecture
file = open ("info.bin", "rb")
i = struct.unpack ("i", file.read (4))
x = struct.unpack ("d", file.read (8))
l = struct.unpack ("i", file.read (4)) # on rcupre la dimension de s
l = l [0] # l est un tuple, on sintresse son unique lment
s = struct.unpack ("c" * l, file.read (l))
file.close ()
# affichage pour contrler

print i # affiche (10,)
print x # affiche (3.1415692000000002,)
print s # affiche (A, B, C, D, E, D, F)
Cette mthode utilise pour les chanes de caractres est applicable aux listes et aux
dictionnaires de longueur variable : il faut dabord stocker leur dimension. Il faut
retenir galement que la taille dun rel est de huit octets, celle dun entier de quatre
octets et celle dun caractre dun octet 12 . Cette taille doit tre passe en argument
la mthode read.
7.4.4 Objets plus complexes

Il existe un moyen de sauvegarder dans un fichier des objets plus complexes laide
du module pickle. Celui-ci permet de stocker dans un fichier le contenu dun dic-
tionnaire partir du moment o celui-ci contient des objets standard du langage
Python. Le principe pour lcriture est le suivant :
import pickle
dico = {a: [1, 2.0, 3, "e"], b: (string, 2), c: None}

lis = [1, 2, 3]
f = open (data.bin, wb)

pickle.dump (dico, f)
pickle.dump (lis, f)
f.close()
La lecture est aussi simple :

f = open (data.bin, rb)
dico = pickle.load (f)
lis = pickle.load (f)
f.close()
Un des avantages du module pickle est de pouvoir grer les rfrences circulaires :
il est capable denregistrer et de relire une liste qui se contient elle-mme, ce peut
tre galement une liste qui en contient une autre qui contient la premire...
Le module pickle peut aussi grer les classes dfinies par un programmeur condi-
tion quelles puissent convertir leur contenu en un dictionnaire dans un sens et dans
lautre, ce qui correspond la plupart des cas.
import pickle
import copy
class Test :
self.chaine = "a"
self.entier = 5
self.tuple = { "h":1, 5:"j" }
t = Test ()
f = open(data.bin, wb) # lecture

pickle.dump (t, f)
12. Cette rgle est toujours vrai sur des ordinateurs 32 bits. Cette taille varie sur les ordinateurs
64 bits qui commencent se rpandre. Le programme suivant donnera la bonne rponse.
from struct import pack
print len(pack(0 i0 , 0)) # longueur dun entier
print len(pack(0 d0 , 0)) # longueur dun rel
print len(pack(0 c0 , e)) # longueur dun caractre
f.close()
f = open(data.bin, rb) # criture

t = pickle.load (f)
f.close()
Lorsque la conversion ncessite un traitement spcial, il faut surcharger les opra-

teurs __getstate__ et __setstate__. Ce cas se produit par exemple lorsquil
nest pas ncessaire denregistrer tous les attributs de la classe car certains sont
calculs ainsi que le montre lexemple suivant :
import pickle
import copy
class Test :
self.x = 5
self.y = 3
self.calcule_norme () # attribut calcul
def calcule_norme (self) :
self.n = (self.x ** 2 + self.y ** 2) ** 0.5
def __getstate__ (self) :
"""conversion de Test en un dictionnaire"""
d = copy.copy (self.__dict__)
del d ["n"] # attribut calcul, on le sauve pas
return d
def __setstate__ (self,dic) :
"""conversion dun dictionnaire dic en Test"""
self.__dict__.update (dic)
self.calcule_norme () # attribut calcul
t = Test ()
f = open(data.bin, wb) # lecture

pickle.dump (t, f)
f.close()
f = open(data.bin, rb) # criture

t = pickle.load (f)
f.close()
7.5 Paramtres en ligne de commande

Certains dveloppements ncessitent de pouvoir excuter un programme Python en
ligne de commande sans intervention extrieure. Ce peut tre un programme de syn-
chronisation de deux rpertoires ou la rcupration du contenu de pages HTML, des
tches souvent excutes la nuit une heure o personne nest prsent pour le faire.
Prenons par exemple le cas dun programme trs simple de synchronisation qui reco-
pie tous les fichiers dun rpertoire vers un autre. La fonctionne copie_repertoire
effectue cette tche.
# coding: latin-1
import glob
import shutil
def copie_repertoire (rep1, rep2) :

"""copie tous les fichiers dun rpertoire rep1 vers un autre rep2"""
li = glob.glob (rep1 + "/*.*") # rcupre dans une liste fichiers et
# rpertoires qui respectent le filtre
for l in li :
to = l.replace (rep1, rep2) # nom du fichier copi
# (on remplace rep1 par rep2)
shutil.copy (l, to)
copie_repertoire ("c:/original", "c:/backup")
Cette tche est en plus excute sur deux rpertoires et on ne voudrait pas avoir
deux programmes diffrents alors que la tche est la mme quelque soit le couple de
rpertoire choisi. On souhaite pouvoir lancer le programme Python et lui spcifier
les deux rpertoires, cest--dire tre capable de lancer le programme comme suit
(voir galement figure 7.1) :
c:\python26\python.exe synchro.py c:/original c:/backup
Figure 7.1 : Un programme Python lanc en ligne de commande.
Pour lancer un programme Python en ligne de commande, il faut crire dans une
fentre de commande ou un programme dextension bat les instructions suivantes
spares par des espaces :
interprteur_python programme_python argument1 argument2 ...
Il faut maintenant rcuprer ces paramtres au sein du programme Python grce

au module sys qui contient une variable argv contenant la liste des paramtres de
la ligne de commande. Sil y a deux paramtres, cette liste argv contiendra trois
lments :
1. nom du programme
2. paramtre 1
3. paramtre 2
Le programme suivante utilise ce mcanisme avec le programme synchro contenant
la fonction copie_repertoire :
# coding: latin-1
import glob
import shutil
def copie_repertoire (rep1, rep2) :
"""copie tous les fichiers dun rpertoire rep1 vers un autre rep2"""
li = glob.glob (rep1 + "/*.*")
for l in li :
to = l.replace (rep1, rep2) # nom du fichier copi
# (on remplace rep1 par rep2)
shutil.copy (l, to)
import sys
# sys.argv [0] --> nom du programme (ici, synchro.py)
rep1 = sys.argv [1] # rcupration du premier paramtre
rep2 = sys.argv [2] # rcupration du second paramtre
copie_repertoire (rep1, rep2)
Remarque 7.9 : paramtres contenant des espaces

Lorsque les paramtres crits sur la ligne de commande contiennent eux-mmes des
espaces, il faut les entourer avec des guillemets.
c:\python26\python.exe c:\batch\synchro.py
"c:\Program Files\source" "c:\Program Files\backup"
Pour des besoins plus complexes, le module getopt propose des fonctions plus labo-
res pour traiter les paramtres de la ligne de commande. Il est galement possible
de lancer un programme en ligne de commande depuis Python grce la fonction
system du module os comme ceci :
import os
os.system ("c:\python26\python.exe c:\batch\synchro.py " \
"\"c:\Program Files\source\" \"c:\Program Files\backup\"")
Le programme suivant est un autre exemple de lutilit de la fonction system. Il

crit une matrice au format HTML 13 puis utilise la fonction system pour lancer le
navigateur Firefox ou Internet Explorer afin de pouvoir visualiser la page cre.
mat = ["Victor Hugo 6".split (), "Marcel Proust 3".split () ]
f = open ("tableau.html", "w")
f.write ("<body><html>\n")
f.write ("<table border=\"1\">\n")
for m in mat :
f.write ("<tr>")
for c in m :
f.write ("<td>" + c + "</td>")
f.write ("</tr>\n")
f.write ("</table>")
f.close ()
import os
os.system ("\"C:\\Program Files\\Mozilla Firefox\\firefox.exe\" tableau.html")
os.system ("\"C:\\Program Files\\Internet Explorer\\iexplore.exe\"" \
" d:\\temp\\tableau.html")
7.6 Expressions rgulires

7.6.1 Premiers pas
Chercher un mot dans un texte est une tche facile, cest lobjectif de la mthode
find attache aux chanes de caractres, elle suffit encore lorsquon cherche un mot
13. La description du langage HTML sort du cadre de ce livre mais la requte HTML syntaxe
effectue sur nimporte quel moteur de recherche Internet retournera des rsultats intressants.
au pluriel ou au singulier mais il faut lappeler au moins deux fois pour chercher
ces deux formes. Pour des expressions plus compliques, il est conseill dutiliser
les expressions rgulires. Cest une fonctionnalit quon retrouve dans beaucoup de
langages. Cest une forme de grammaire qui permet de rechercher des expressions.
Lorsquon remplit un formulaire, on voit souvent le format "MM/JJ/AAAA" qui
prcise sous quelle forme on sattend ce quune date soit crite. Les expressions
rgulires permettent de dfinir galement ce format et de chercher dans un texte
toutes les chanes de caractres qui sont conformes ce format.
La liste qui suit contient des dates de naissance. On cherche obtenir toutes les dates
de cet exemple sachant que les jours ou les mois contiennent un ou deux chiffres, les
annes deux ou quatre.
s = """date 0 : 14/9/2000
date 1 : 20/04/1971 date 2 : 14/09/1913 date 3 : 2/3/1978
date 4 : 1/7/1986 date 5 : 7/3/47 date 6 : 15/10/1914
date 7 : 08/03/1941 date 8 : 8/1/1980 date 9 : 30/6/1976"""
Le premier chiffre du jour est soit 0, 1, 2, ou 3 ; ceci se traduit par [0 3]. Le second
chiffre est compris entre 0 et 9, soit [0 9]. Le format des jours est traduit par
[0 3][0 9]. Mais le premier jour est facultatif, ce quon prcise avec le symbole ? :
[0 3]?[0 9]. Les mois suivent le mme principe : [0 1]?[0 9]. Pour les annes, ce
sont les deux premiers chiffres qui sont facultatifs, le symbole ? sappliquent sur les
deux premiers chiffres, ce quon prcise avec des parenthses : ([0-2][0-9]) ?[0-9][0-9].
Le format final dune date devient :
[0-3]?[0-9]/[0-1]?[0-9]/([0-2][0-9])?[0-9][0-9]
Le module re gre les expressions rgulires, celui-ci traite diffremment les parties
de lexpression rgulire qui sont entre parenthses de celles qui ne le sont pas :
cest un moyen de dire au module re que nous nous intressons telle partie de
lexpression qui est signale entre parenthses. Comme la partie qui nous intresse
- une date - concerne lintgralit de lexpression rgulire, il faut insrer celle-ci
entre parenthses.
La premire tape consiste construire lexpression rgulire, la seconde recher-
cher toutes les fois quun morceau de la chane s dfinie plus haut correspond
lexpression rgulire.
import re
# premire tape : construction
expression = re.compile ("([0-3]?[0-9]/[0-1]?[0-9]/([0-2][0-9])?[0-9][0-9])")
# seconde tape : recherche
res = expression.findall (s)
print res
Le rsultat de ce programme est le suivant :

[(14/9/2000, 20), (20/04/1971, 19), (14/09/1913, 19),
(2/3/1978, 19), (1/7/1986, 19), (7/3/47, ),
(15/10/1914, 19), (08/03/1941, 19), (8/1/1980, 19),
(30/6/1976, 19)]
Cest une liste de couples dont chaque lment correspond aux parties comprises
entre parenthses quon appelle des groupes. Lorsque les expressions rgulires sont
utilises, on doit dabord se demander comment dfinir ce quon cherche puis quelles
fonctions utiliser pour obtenir les rsultats de cette recherche. Les deux paragraphes
qui suivent y rpondent.
7.6.2 Syntaxe
La syntaxe des expressions rgulires est dcrite sur le site officiel de Python 14 .
Comme toute grammaire, celle des expressions rgulires est susceptible dvoluer
au fur et mesure des versions du langage Python.
7.6.2.1 Les ensembles de caractres
Lors dune recherche, on sintresse aux caractres et souvent aux classes de carac-
tres : on cherche un chiffre, une lettre, un caractre dans un ensemble prcis ou
un caractre qui nappartient pas un ensemble prcis. Certains ensembles sont
prdfinis, dautres doivent tre dfinis laide de crochets.
Pour dfinir un ensemble de caractres, il faut crire cet ensemble entre crochets :
[0123456789] dsigne un chiffre. Comme cest une squence de caractres conscutifs,
on peut rsumer cette criture en [0-9]. Pour inclure les symboles , +, il suffit
dcrire : [-0-9+]. Il faut penser mettre le symbole au dbut pour viter quil
ne dsigne une squence.
Le caractre ^ insr au dbut du groupe signifie que le caractre cherch ne doit
pas tre un de ceux qui suivent. Le tableau suivant dcrit les ensembles prdfinis 15
et leur quivalent en terme densemble de caractres :
. dsigne tout caractre non spcial quel quil soit

\d dsigne tout chiffre, est quivalent [0-9]
\D dsigne tout caractre diffrent dun chiffre, est quivalent [0-9]
\s dsigne tout espace ou caractre approch, est quivalent [ \t\n\r\f\v] 16
\S dsigne tout caractre diffrent dun espace, est quivalent [^\t\n\r\f\v]
\w dsigne tout lettre ou chiffre, est quivalent [a-zA-Z0-9_]
dsigne tout caractre diffrent dune lettre ou dun chiffre, est quivalent
\W
[a-zA-Z0-9_]
^ dsigne le dbut dun mot sauf sil est plac entre crochets
$ dsigne la fin dun mot sauf sil est plac entre crochets
A linstar des chanes de caractres, comme le caractre \ est un caractre spcial,

il faut le doubler : [\\]. Avec ce systme, le mot "taxinomie" qui accepte deux
orthographes scrira : tax[io]nomie.
14. La page http://docs.python.org/library/re.html#regular-expression-syntax dcrit la syntaxe, la
page http://docs.python.org/howto/regex.html#regex-howto dcrit comment se servir des expres-
sions rgulires, les deux pages sont en anglais.
15. La page http://docs.python.org/library/re.html#regular-expression-syntax les recense tous.
16. Ces caractres sont spciaux, les plus utiliss sont \t qui est une tabulation, \n qui est une
fin de ligne et qui \r qui est un retour la ligne.
Remarque 7.10 : caractres spciaux et expressions rgulires

Le caractre \ est dj un caractre spcial pour les chanes de caractres en Python,
il faut donc le quadrupler pour linsrer dans un expression rgulire. Lexpression
suivante filtre toutes les images dont lextension est png et qui sont enregistres dans
un rpertoire image.
s = r"D:\Dupre\_data\informatique\support\vba\image/vbatd1_4.png"
print re.compile ( "[\\\\/]image[\\\\/].*[.]png").search(s) # rsultat positif
print re.compile (r"[\\/]image[\\/].*[.]png").search(s) # mme rsultat
7.6.2.2 Les multiplicateurs
Les multiplicateurs permettent de dfinir des expressions rgulires comme : un mot

entre six et huit lettres quon crira [\w]{6, 8}. Le tableau suivant donne la liste des
multiplicateurs principaux 17 :
prsence de lensemble de caractres qui prcde entre 0 fois et linfini

+ prsence de lensemble de caractres qui prcde entre 1 fois et linfini
? prsence de lensemble de caractres qui prcde entre 0 et 1 fois
{m, n} prsence de lensemble de caractres qui prcde entre m et n fois, si
m = n, cette expression peut tre rsume par {n}.
(?!(...)) absence du groupe dsign par les points de suspensions (voir para-
graphe 7.6.4).
Lalgorithme des expressions rgulires essaye toujours de faire correspondre le plus

grand morceau lexpression rgulire. Par exemple, dans la chane <h1>mot</h1>,
<.*> correspond avec <h1>, </h1> ou encore <h1>mot</h1>. Par consquent, lex-
pression rgulire correspond trois morceaux. Par dfaut, il prendra le plus grand.
Pour choisir les plus petits, il faudra crire les multiplicateurs comme ceci : ?, +?,
??.
import re
s = "<h1>mot</h1>"
print re.compile ("(<.*>)") .match (s).groups () # (<h1>mot</h1>,)
print re.compile ("(<.*?>)").match (s).groups () # (<h1>,)
7.6.2.3 Groupes
Lorsquun multiplicateur sapplique sur plus dun caractre, il faut dfinir un groupe
laide de parenthses. Par exemple, le mot yoyo scrira : (yo){2}. Les parenthses
jouent un rle similaire celui quelles jouent dans une expression numrique. Tout
ce qui est compris entre deux parenthses est considr comme un groupe.
7.6.2.4 Assembler les caractres
On peut assembler les groupes de caractres les uns la suite des autres. Dans ce cas,
il suffit de les juxtaposer comme pour trouver les mots commenant par s : s[a z].
17. La page http://docs.python.org/library/re.html#regular-expression-syntax les recense tous.
On peut aussi chercher une chane ou une autre grce au symbole |. Chercher dans
un texte lexpression Xavier Dupont ou M. Dupont scrira : (Xavier)|(M[.])Dupont.
7.6.3 Fonctions
La fonction compile du module re permet de construire un objet "expression rgu-
lire". A partir de cet objet, on peut vrifier la correspondance entre une expression
rgulire et une chane de caractres (mthode match). On peut chercher une expres-
sion rgulire (mthode search). On peut aussi remplacer une expression rgulire
par une chane de caractres (mthode sub). La table 7.3 rcapitule ces mthodes.
Vrifie la correspondance entre lexpression rgulire et

la chane s. Il est possible de neffectuer cette vrification
match(s[, pos[, end]]) quentre les caractres dont les positions sont pos et end.
La fonction retourne None sil ny a pas de correspondance
et sinon un objet de type Match.
Fonction semblable match, au lieu de vrifier la corres-
pondance entre toute la chane et lexpression rgulire,
search(s[, pos[, end]])
cherche la premire chane de caractres extraite corres-
pondant lexpression rgulire.
Recherche toutes les chanes de caractres extraites
qui vrifient lexpression rgulire puis dcoupe cette
chane en fonction des expressions trouves. La m-
thode split dune chane de caractre permet de d-
split(s couper selon un sparateur. La mthode split dune
[, maxsplit = 0]) expression rgulire permet de dcouper selon plusieurs
sparateurs. Cest pratique pour dcouper une chane
de caractres en colonnes spares par ; ou une
tabulation. re.compile([\t; ]).split(a; b\tc; g) donne
[a, b, c, g].
Identique split mais ne retourne pas les morceaux entre
findall(s[, pos[, end]])
les chanes extraites qui vrifient lexpression rgulire.
sub(repl, s Remplace dans la chane repl les lments \1, \2, ... par
[, count = 0]) les parties de s qui valident lexpression rgulire.
Mmorise les options de construction de lexpression r-
flags
gulire. Cest un attribut.
Chane de caractres associe lexpression rgulire.
pattern
Cest un attribut.
Table 7.3 : Liste non exhaustive des mthodes et attributs qui sappliquent un objet
de type "expression rgulire" retourn par la fonction compile du module re. La page
http:// docs.python.org/ library/ re.html contient la documentation associe au module re.
Les mthodes search et match retournent toutes des objets Match dont les mthodes
sont prsentes par la table 7.4. Appliques lexemple dcrit page 185 concernant
les dates, cela donne :
expression = re.compile ("([0-3]?[0-9]/[0-1]?[0-9]/([0-2][0-9])?[0-9][0-9])[^\d]")
print expression.search (s).group(1,2) # affiche (14/9/2000, 20)
c = expression.search (s).span(1) # affiche (9, 18)

print s [c[0]:c[1]] # affiche 14/9/2000
group([g1, ...]) Retourne la chane de caractres valide par les groupes g1...
Retourne la liste des chanes de caractres qui ont t valides
groups([default])
par chacun des groupes.
Retourne les positions dans la chane originale des chanes
span([gr])
extraites valides le groupe gr.
Table 7.4 : Liste non exhaustive des mthodes qui sappliquent un objet de type Match
qui est le rsultat des mthodes search et match. Les groupes sont des sous-parties de
lexpression rgulire, chacune dentre elles incluses entre parenthses. Le nme correspond
au groupe qui suit la nme parenthse ouvrante. Le premier groupe a pour indice 1. La page
http:// docs.python.org/ library/ re.html contient la documentation associe au module re.
7.6.4 Exemple plus complet

Lexemple suivant prsente trois cas dutilisation des expressions rgulires. On
sintresse aux titres de chansons MP3 stockes dans un rpertoire. Le module
mutagen 18 permet de rcuprer certaines informations concernant un fichier MP3
dont le titre, lauteur et la dure.
Le premier problme consiste retrouver les chansons sans titre ou dont le titre
contient seulement son numro : track03, track - 03, audiotrack 03, track 03, piste
03, piste - 03, audiopiste 03, ... Ce titre indsirable doit valider lexpression rgulire
suivante : (((audio) ?track( ) ?( - ) ?[0-9]1,2)|(piste [0-9]1,2))$.
Le second problme consiste retrouver toutes les chansons dont le titre contient le
mot heart mais ni heartland ni heartache. Ce titre doit valider lexpression rgulire :
((heart)( ? !((ache)|(land)))).
Le troisime problme consiste compter le nombre de mots dun titre. Les mots
sont spars par lensemble de caractres [, ; !0 .?& :]. On utilise la mthode split
pour dcouper en mots. Le rsultat est illustr par le programme suivant.
# coding: latin-1
import mutagen.mp3, mutagen.easyid3, os, re
def infoMP3 (file, tags) :

"""retourne des informations sur un fichier MP3 sous forme de
dictionnaire (dure, titre, artiste, ...)"""
a = mutagen.mp3.MP3(file)
b = mutagen.easyid3.EasyID3(file)
info = { "minutes":a.info.length/60, "nom":file }
for k in tags :
try : info [k] = str (b [k][0])
except : continue
return info
def all_files (repertoire, tags, ext = re.compile (".mp3$")) :
18. http://code.google.com/p/quodlibet/wiki/Development/Mutagen
"""retourne les informations pour chaque fichier dun rpertoire"""

all = []
for r, d, f in os.walk (repertoire) :
for a in f :
if not ext.search (a) : continue
t = infoMP3 (r + "/" + a, tags)
if len (t) > 0 : all.append (t)
return all
def heart_notitle_mots (all, avoid,sep,heart) :

"""retourne trois rsultats
- les chansons dont le titre valide lexpression rgulire heart
- les chansons dont le titre valide lexpression rgulire avoid
- le nombre moyen de mots dans le titre dune chanson"""
liheart, notitle = [], []
nbmot,nbsong = 0,0
for a in all :
if "title" not in a :
notitle.append (a)
continue
ti = a ["title"].lower ()
if avoid.match (ti) :
notitle.append (a)
continue
if heart.search (ti) : liheart.append (a)
nbsong += 1
nbmot += len ([ m for m in sep.split (ti) if len (m) > 0 ])
return liheart, notitle, float (nbmot)/nbsong
tags = "title album artist genre tracknumber".split ()

all = all_files (r"D:\musique", tags)
avoid = re.compile ("^(((audio)?track( )?( - )?[0-9]{1,2})|(piste [0-9]{1,2}))$")

sep = re.compile ("[- ,;!.?&:]")
heart = re.compile ("((heart)(?!((ache)|(land))))")
liheart, notitle, moymot = heart_notitle_mots (all, avoid, sep, heart)
print "nombre de mots moyen par titre ", moymot

print "somme des dure contenant heart ", sum ( [ s ["minutes"] for s in liheart] )
print "chanson sans titre ", len (notitle)
print "liste des titres "
for s in liheart : print " ",s ["title"]
Remarque 7.11 : Nommer des groupes

Une expression rgulire ne sert pas seulement de filtre, elle permet galement dex-
traire le texte qui correspond chaque groupe, chaque expression entre paren-
thses. Lexemple suivant montre comment rcuprer le jour, le mois, lanne
lintrieur dune date.
import re
date = "05/22/2010"
exp = "([0-9]{1,2})/([0-9]{1,2})/(((19)|(20))[0-9]{2})"
com = re.compile (exp)
print com.search (date).groups () # (05, 22, 2010, 20, None, 20)
Il nest pas toujours vident de connatre le numro du groupe qui contient linfor-
mation extraire. Cest pourquoi il parat plus simple de les nommer afin de les
rcuprer sous la forme dun dictionnaire et non plus sous forme de tableau. La
syntaxe ( ?P<nom_du_groupe>expression) permet de nommer un groupe. Elle est
applique lexemple prcdent.
exp = "(?P<jj>[0-9]{1,2})/(?P<mm>[0-9]{1,2})/(?P<aa>((19)|(20))[0-9]{2})"
com = re.compile (exp)
print com.search (date).groupdict () # {mm: 22, aa: 2010, jj: 05}
7.7 Dates
Le module datetime 19 fournit une classe datetime qui permet de faire des oprations
et des comparaisons sur les dates et les heures. Lexemple suivant calcule lge dune
personne ne le 11 aot 1975.
import datetime
naissance = datetime.datetime (1975,11,8,10,0,0)
jour = naissance.now () # obtient lheure et la date actuelle
print jour # affiche 2010-05-22 11:24:36.312000
age = jour - naissance # calcule une diffrence
print age # affiche 12614 days, 1:25:10.712000
Lobjet datetime autorise les soustractions et les comparaisons entre deux dates.
Une soustraction retourne un objet de type timedelta qui correspond une dure.
quon peut multiplier par un rel ou ajouter un objet de mme type ou un objet
de type datetime. Lutilisation de ce type dobjet vite de se pencher sur tous les
problmes de conversion.
Le module calendar est assez pratique pour construire des calendriers. Le pro-
gramme ci-dessous affiche une liste de t-uples incluant le jour et le jour de la semaine
du mois daot 1975. Dans cette liste, on y trouve le t-uple (11, 0) qui signifie que le
11 aot 1975 tait un lundi. Cela permet de rcuprer le jour de la semaine dune
date de naissance.
import calendar
c = calendar.Calendar ()
for d in c.itermonthdays2 (1975,8) : print d
7.8 Problme de jeux de caractres

La langue anglaise est la langue dominante en ce qui concerne linformatique mais
cela nempche pas que des programmes anglais manipulent du japonais mme si le
nombre de caractres est beaucoup plus grand. Les jeux de caractres proposent une
solution ce problme : un jeu de caractres dfinit la faon de dcoder une suite
doctets 20 . Les langues latines nont besoin que dun octet pour coder un caractre,
19. Voir galement la page http://docs.python.org/library/datetime.html.
20. On confond souvent jeu de caractres et encodage. Le jeu de caractre dsigne lensemble de
caractres dont le programme a besoin, lencodage dcrit la manire dont on passe dune squence de
caractres franais, japonais, anglais une squence doctets qui est la seule information manipule
par un ordinateur.
les langues asiatiques en ont besoin de plusieurs. Il nexiste pas quun seul jeu de
caractres lorsquon programme. Ils interviennent plusieurs endroits diffrents :
1. Le jeu de caractres utilis par lditeur de texte pour afficher le programme.
2. Le jeu de caractres du programme, par dfaut ascii mais il peut tre chang en
insrant une premire ligne de commentaire (voir paragraphe 1.5.2, page 22). Les
chanes de caractres du programme sont codes avec ce jeu de caractres. Ce jeu
devrait tre identique celui utilis par lditeur de texte afin dviter les erreurs.
3. Le jeu de caractres de la sortie, utilis pour chaque instruction print, il est dsign
par le code cp1252 sur un systme Windows.
4. Le jeu de caractres dans lequel les chanes de caractres sont manipules. Un jeu
standard qui permet de reprsenter toutes les langues est le jeu de caractres utf 8.
Il peut tre diffrent pour chaque variable.
5. Le jeu de caractres dun fichier texte. Il peut tre diffrent pour chaque fichier.
Le langage Python offre deux classes pour reprsenter les chanes de caractres. La
classe str qui est adapte aux langues latines, le jeu de caractres nest pas prcis.
La classe unicode reprsente un caractre sur un quatre octets avec un jeu de
caractres dsign par lappellation unicode. Il est impratif de savoir quel jeu est
utilis quel endroit et il faut faire des conversions de jeux de caractres pour passer
linformation dun endroit un autre. Il existe deux mthodes pour cela prsentes
par la table 7.5.
# coding: latin-1
st = "e"
su = u"e" # raccourci pour su = unicode ("e", "latin-1")
# ou encore su = unicode ("e".decode ("latin-1"))
print type (st) # affiche <type str>

print type (su) # affiche <type unicode>
print len (st), ";", st # affiche 2 ; e
print len (repr (st)), ";", repr (st) # affiche 7 ; e\xe9
print len (su), ";", su.encode ("latin-1") # affiche 2 ; e
print len (repr (su)), ";", repr (su) # affiche 8 ; ue\xe9
Lorsquon manipule plusieurs jeux de caractres, il est prfrable de conserver un

unique jeu de rfrence pour le programme par lintermdiaire de la classe unicode.
Il "suffit" de grer les conversions depuis ces chanes de caractres vers les entres
sorties du programme comme les fichiers texte. Par dfaut, ceux-ci sont crits avec
le jeu de caractres du systme dexploitation. Dans ce cas, la fonction open suf-
fit. En revanche, si le jeu de caractres est diffrent, il convient de le prciser lors
de louverture du fichier. On utilise la fonction open du module codecs qui prend
comme paramtre supplmentaire le jeu de caractres du fichier. Toutes les chanes
de caractres seront lues et converties au format unicode.
import codecs
f = codecs.open ("essai.txt", "r", "cp1252") # jeu Windows
s = "".join (f.readlines ())
f.close ()
print type (s) # affiche <type unicode>
print s.encode ("cp1252") # pour lafficher,
# il faut convertir lunicode en "cp1252"
Cette fonction permet de passer dun jeu de caractres, celui de

la variable, au jeu de caractres prcis par enc moins que ce
ne soit le jeu de caractres par dfaut. Le paramtre err per-
met de prciser comment grer les erreurs, doit-on interrompre le
encode(
programme (valeur 0 strict0 ) ou les ignorer (valeur 0 ignore0 ). La
[enc[, err]])
documentation Python recense toutes les valeurs possibles pour
ces deux paramtres aux adresses http://docs.python.org/library/
codecs.html#id3 et http://docs.python.org/library/stdtypes.html#
id4. Cette fonction retourne un rsultat de type str.
decode( Cette fonction est la fonction inverse de la fonction encode. Avec
[enc[, err]]) les mmes paramtres, elle effectue la transformation inverse.
Table 7.5 : Conversion de jeux de caractres, ce sont deux mthodes qui fonctionnent de
faons identiques pour les deux classes de chanes de caractres disponibles en Python : str
et unicode.
Le programme suivant permet dobtenir le jeu de caractres par dfaut et celui du

systme dexploitation.
import sys
import locale
# retourne le jeu de caractres par dfaut
print sys.getdefaultencoding () # affiche ascii
# retourne le jeu de caractres du systme dexploitation
print locale.getdefaultlocale() # affiche (fr_FR, cp1252)
Les problmes de jeux de caractres peuvent devenir vite compliqus lorsquon ma-
nipule des informations provenant de plusieurs langues diffrentes. Il est rare davoir
sen soucier tant que le programme gre les langues anglaise et franaise. Dans le
cas contraire, il est prfrable dutiliser le type unicode pour toutes les chanes de
caractres. Il est conseill de nutiliser quun seul jeu de caractres pour enregistrer
les informations dans des fichiers et le jeu de caractres utf 8 est le plus indiqu.
Chapitre 8
Interface graphique
Les interfaces graphiques servent rendre les programmes plus conviviaux. Elles
sont pratiques utiliser mais elles demandent un peu de temps pour les concevoir.
Un programme sans interface excute des instructions les unes la suite des autres,
le programme a un dbut - un point dentre - et une fin. Avec une interface, le
programme fonctionne de manire diffrente. Il nexcute plus successivement les
instructions mais attend un vnement - pression dune touche du clavier, clic de
souris - pour excuter une fonction. Cest comme si le programme avait une multi-
tude de points dentre.
Il existe plusieurs modules permettant dexploiter les interfaces graphiques. Le plus
simple est le module Tkinter prsent lors de linstallation du langage Python. Ce
module est simple mais limit. Le module wxPython est plus complet mais un peu
plus compliqu dans son utilisation 1 . Toutefois, le fonctionnement des interfaces
graphiques sous un module ou un autre est identique. Cest pourquoi ce chapitre
nen prsentera quun seul, le module Tkinter. Pour dautres modules, les noms de
classes changent mais la logique reste la mme : il sagit dassocier des vnements
des parties du programme Python.
Les interfaces graphiques voluent sans doute plus vite que les autres modules,
des composantes de plus en plus complexes apparaissent rgulirement. Un module
comme wxPython change de version plusieurs fois par an. Il est possible de trouver sur
Internet des liens 2 qui donnent des exemples de programme. Une excellente source
de documentation sont les forums de discussion qui sont un lieu o des program-
meurs changent questions et rponses. Un message derreur entr sur un moteur de
recherche Internet permet souvent de tomber sur des changes de ce type, sur des
problmes rsolus par dautres.
8.1 Introduction
Un programme muni dune interface graphique fonctionne diffremment dun pro-
gramme classique. Un programme classique est une succession presque linaire dins-
tructions. Il y a un dbut ou point dentre du programme et aucun vnement ex-
trieur ne vient troubler son droulement. Avec une interface graphique, le point
dentre du programme est masqu : il est pris en compte automatiquement. Du
point de vue du programmeur, le programme a plusieurs points dentre : une simple
1. Le paragraphe 1.6.5 page 26 prsente dautres alternatives.
2. Ladresse http://gnuprog.info/prog/python/pwidget.php illustre chaque objet de Tkinter, on
peut citer galement http://effbot.org/tkinterbook/.
8. Interface graphique 195
fentre avec deux boutons (voir figure 8.1) propose deux faons de commencer et il
faut prvoir une action associe chaque bouton.
La conception dune interface graphique se droule gnralement selon deux tapes.
La premire consiste dessiner linterface, cest--dire choisir une position pour
les objets de la fentre (boutons, zone de saisie, liste droulante, ...). La seconde
tape dfinit le fonctionnement de la fentre, cest--dire associer chaque objet des
fonctions qui seront excutes si un tel vnement se ralise (pression dun bouton,
pression dune touche, ...).
Pour le moment, nous allons supposer que ces deux tapes sont scindes mme si elles
sont parfois entremles lorsquun vnement implique la modification de lapparence
de la fentre. La section qui suit dcrit des objets que propose le module Tkinter.
La section suivante prsente la manire de les disposer dans une fentre. La section
daprs dcrit les vnements et le moyen de les relier des fonctions du programme.
Ce chapitre se termine par quelques constructions courantes propos des interfaces
graphiques.
Figure 8.1 : Une fentre contenant deux boutons : ce sont deux

points dentre du programme.
8.2 Les objets

Les interfaces graphiques sont composes dobjets ou widgets 3 . Ce paragraphe dcrit
les principales mthodes qui permettent de modifier le contenu et lapparence des
objets. Il faut se reporter la documentation du langage 4 pour avoir la liste de
toutes les options disponibles.
Les exemples de codes des paragraphes qui suivent permettent de disposer les objets
dans une fentre qui ne saffichera pas sans les quelques lignes de code supplmen-
taires prsentes au paragraphe 8.4.1 et lutilisation dune mthode pack (para-
graphe 8.3). Lexemple suivant cre un objet :
zone_texte = Tkinter.Label (text = "zone de texte")
Et pour lafficher, il faut lenrober :

import Tkinter # import de Tkinter
root = Tkinter.Tk () # cration de la fentre principale
# ...
obj = Tkinter.Label (text = "zone de texte")
# ...
obj.pack () # on ajoute lobjet la fentre principale
root.mainloop () # on affiche enfin la fentre principal et on attend
# les vnements (souris, clic, clavier)
3. On les appelle aussi contrle. Comme ils reoivent des vnements, en un sens, ce sont ces
objets qui pilotent un programme ou qui le contrlent.
4. La page http://wiki.python.org/moin/Tkinter recense quelques liens utiles autour de Tkinter
dont la documentation officielle.
8.2.1 Zone de texte

Une zone de texte sert insrer dans une fentre graphique une lgende indiquant
ce quil faut insrer dans une zone de saisie voisine comme le montre la figure 8.2.
Une zone de texte correspond la classe Label du module Tkinter. Pour crer une
zone de texte, il suffit dcrire la ligne suivante :
zone_texte = Tkinter.Label (text = "zone de texte")
Il est possible que le texte de cette zone de texte doive changer aprs quelques temps.
Dans ce cas, il faut appeler la mthode config comme suit :
zone_texte = Tkinter.Label (text = "premier texte")
# ...
# pour changer de texte
zone_texte.config (text = "second texte")
Figure 8.2 : Exemple de zone de texte ou Label as-

socie une zone de saisie. La seconde image montre
une zone de texte dans ltat DISABLED.
La figure 8.2 montre deux zones de texte. La seconde est grise par rapport la
premire. Pour obtenir cet tat, il suffit dutiliser linstruction suivante :
zone_texte.config (state = Tkinter.DISABLED)
Et pour revenir un tat normal :

zone_texte.config (state = Tkinter.NORMAL)
Ces deux dernires options sont communes tous les objets dune interface gra-
phique. Cette option sera rappele au paragraphe 8.2.11.
8.2.2 Bouton
Un bouton a pour but de faire le lien entre une fonction et un clic de souris. Un
bouton correspond la classe Button du module Tkinter. Pour crer un bouton, il
suffit dcrire la ligne suivante :
bouton = Tkinter.Button (text = "zone de texte")
Il est possible que le texte de ce bouton doive changer aprs quelques temps. Dans
ce cas, il faut appeler la mthode config comme suit :
bouton = Tkinter.Button (text = "premier texte")
# ...
# pour changer de texte
bouton.config (text = "second texte")
Figure 8.3 : Exemple de boutons, non

press, press, gris. Le bouton gris ne
peut tre press.
La figure 8.3 montre trois boutons. Le troisime est gris par rapport au premier. Les
boutons griss ne peuvent pas tre presss. Pour obtenir cet tat, il suffit dutiliser
linstruction suivante :
bouton.config (state = Tkinter.DISABLED)
Et pour revenir un tat normal :

bouton.config (state = Tkinter.NORMAL)
Cest pour cet objet que cette option est la plus intressante car elle permet dinter-
dire la possibilit pour lutilisateur de presser le bouton tout en le laissant visible.
Il est possible galement dassocier une image un bouton. Par exemple, les trois
lignes suivantes crent un bouton, charge une image au format gif puis lassocie
au bouton b. Lors de laffichage de la fentre, le bouton b ne contient pas de texte
mais une image.
b = Tkinter Button ()
im = Tkinter.PhotoImage (file = "chameau.gif")
b.config (image = im)
Les images quil est possible de charger sont ncessairement au format GIF, le seul
que le module Tkinter puisse lire.
8.2.3 Zone de saisie

Une zone de saisie a pour but de recevoir une information entre par lutilisateur.
Une zone de saisie correspond la classe Entry du module Tkinter ; pour en crer
une, il suffit dcrire la ligne suivante :
saisie = Tkinter.Entry ()
Pour modifier le contenu de la zone de saisie, il faut utiliser la mthode insert qui
insre un texte une position donne.
# le premier paramtre est la position
# o insrer le texte (second paramtre)
saisie.insert (pos, "contenu")
Pour obtenir le contenu de la zone de saisie, il faut utiliser la mthode get :

contenu = saisie.get ()
Pour supprimer le contenu de la zone de saisie, il faut utiliser la mthode delete.

Cette mthode supprime le texte entre deux positions.
# supprime le texte entre les positions pos1, pos2
saisie.delete (pos1, pos2)
Par exemple, pour supprimer le contenu dune zone de saisie, on peut utiliser lins-
truction suivante :
saisie.delete (0, len (saisie.get ()))
Figure 8.4 : Exemple de zones de saisie, normale et grise, la

zone grise ne peut tre modifie.
La figure 8.4 montre deux zones de saisie. La seconde est grise par rapport la
premire. Les zones de saisie grises ne peuvent pas tre modifies. Pour obtenir cet
tat, il suffit dutiliser la mthode config comme pour les prcdents objets. Cette
option sera rappele au paragraphe 8.2.11.
8.2.4 Zone de saisie plusieurs lignes

Une zone de saisie plusieurs lignes est identique la prcdente ceci prs quelle
autorise la saisie dun texte sur plusieurs lignes. Cette zone correspond la classe
Text du module Tkinter. Pour crer une telle zone, il suffit dcrire la ligne suivante :
saisie = Tkinter.Text ()
Pour modifier le contenu de la zone de saisie, il faut utiliser la mthode insert qui
insre un texte une position donne. La mthode diffre de celle de la classe Entry
puisque la position dinsertion est maintenant une chane de caractres contenant
deux nombres spars par un point : le premier nombre dsigne la ligne, le second
la position sur cette ligne.
# le premier paramtre est la position
# o insrer le texte (second paramtre)
pos = "0.0"
saisie.insert (pos, "premire ligne\nseconde ligne")
Pour obtenir le contenu de la zone de saisie, il faut utiliser la mthode get qui
retourne le texte entre deux positions. La position de fin nest pas connue, on utilise
la chane de caractres "end" pour dsigner la fin de la zone de saisie.
# retourne le texte entre deux positions
pos1 = "0.0"
pos2 = "end" # ou Tkinter.END
contenu = saisie.get (pos1, pos2)
Pour supprimer le contenu de la zone de saisie, il faut utiliser la mthode delete.

Cette mthode supprime le texte entre deux positions.
# supprime le texte entre les positions pos1, pos2
saisie.delete (pos1, pos2)
Par exemple, pour supprimer le contenu dune zone de saisie plusieurs lignes, on
peut utiliser linstruction suivante :
saisie.delete ("0.0", "end")
# on peut aussi utiliser
# saisie.delete ("0.0", Tkinter.END)
Pour modifier les dimensions de la zone de saisie plusieurs lignes, on utilise lins-
truction suivante :
# modifie les dimensions de la zone

# width <--> largeur
# height <--> hauteur en lignes
saisie.config (width = 10, height = 5)
Limage prcdente montre une zone de saisie plusieurs lignes. Pour griser cette
zone, il suffit dutiliser la mthode config rappele au paragraphe 8.2.11.
8.2.5 Case cocher

Une case cocher correspond la classe Checkbutton du module Tkinter. Pour crer
une case cocher, il suffit dcrire la ligne suivante :
# cre un objet entier pour rcuprer la valeur de la case cocher,
# 0 pour non coche, 1 pour coche
v = Tkinter.IntVar ()
case = Tkinter.Checkbutton (variable = v)
En fait, ce sont deux objets qui sont crs. Le premier, de type IntVar, mmorise la
valeur de la case cocher. Le second objet, de type CheckButton, gre lapparence
au niveau de linterface graphique. La raison de ces deux objets est plus vidente
dans le cas de lobjet RadioButton dcrit au paragraphe suivant. Pour savoir si la
case est coche ou non, il suffit dexcuter linstruction :
v.get () # gal 1 si la case est coche, 0 sinon
Pour cocher et dcocher la case, il faut utiliser les instructions suivantes :

case.select () # pour cocher
case.deselect () # pour dcocher
Il est possible dassocier du texte lobjet case cocher :

case.config (text = "case cocher")
La figure 8.5 montre trois cases. La troisime est grise par rapport la premire.
Les cases grises ne peuvent pas tre coches. Pour obtenir cet tat, il suffit dutiliser
la mthode config rappele au paragraphe 8.2.11.
Figure 8.5 : Exemples de cases cocher, non coche, coche,

grise. Lorsquelle est grise, son tat ne peut tre modifi. La
dernire image montre une case cocher associe un texte.
8.2.6 Case ronde ou bouton radio

Une case ronde ou bouton radio correspond la classe Radiobutton du module
Tkinter. Elles fonctionnent de manire semblable des cases cocher except le
fait quelles napparaissent jamais seules : elles fonctionnent en groupe. Pour crer
un groupe de trois cases rondes, il suffit dcrire la ligne suivante :
# cre un objet entier partag pour rcuprer le numro du bouton radio activ
v = Tkinter.IntVar ()
case1 = Tkinter.Radiobutton (variable = v, value = 10)
La variable v est partage par les trois cases rondes. Loption value du constructeur
permet dassocier un bouton radio une valeur de v. Si v == 10, seul le premier
bouton radio sera slectionn. Si v == 20, seul le second bouton radio le sera. Si
deux valeurs sont identiques pour deux boutons radio, ils seront cochs et dcochs
en mme temps. Et pour savoir quel bouton radio est coch ou non, il suffit dexcuter
linstruction :
v.get () # retourne le numro du bouton radio coch (ici, 10, 20 ou 30)
Pour cocher un des boutons radio, il faut utiliser linstruction suivante :

v.set (numero) # numro du bouton radio cocher
# pour cet exemple, 10, 20 ou 30
Il est possible dassocier du texte un bouton radio (voir figure 8.6) :

case1.config (text = "premier bouton")
case2.config (text = "second bouton")
case3.config (text = "troisime bouton")
Figure 8.6 : Exemples de cases rondes ou boutons radio, non

coche, coche, grise. Lorsquelle est grise, son tat ne peut tre
modifie. La seconde image prsente un groupe de bouton radio.
Un seul peut tre slectionn la fois moins que deux boutons
ne soient associs la mme valeur. Dans ce cas, ils agiront de
pair.
La figure 8.6 montre trois cases. La troisime est grise par rapport la premire. Si
un des boutons radio est gris parmi les trois, le choix du bouton cocher seffectue
parmi les deux restants ou aucun si le bouton radio gris est coch.
8.2.7 Liste
Un objet liste contient une liste dintituls quil est possible de slectionner. Une liste
correspond la classe ListBox du module Tkinter. Pour la crer, il suffit dcrire la
ligne suivante :
li = Tkinter.Listbox ()
truction suivante :
# modifie les dimensions de la liste
# width <--> largeur
# height <--> hauteur en lignes
li.config (width = 10, height = 5)
On peut insrer un lment dans la liste avec la mthode insert :

pos = 0 # un entier, "end" ou Tkinter.END pour insrer ce mot la fin
li.insert (pos, "premire ligne")
On peut supprimer des intituls de cette liste avec la mthode delete.

pos1 = 0 # un entier
pos2 = None # un entier, "end" ou Tkinter.END pour supprimer tous les lments
# de pos1 jusquau dernier
li.delete (pos1, pos2 = None)
Les intituls de cette liste peuvent ou non tre slectionns. Cliquer sur un intitul
le slectionne mais la mthode select_set permet aussi de le faire.
pos1 = 0
li.select_set (pos1, pos2 = None)
# slectionne tous les lments entre les indices pos1 et
# pos2 inclus ou seulement celui dindice pos1 si pos2 == None
Rciproquement, il est possible denlever un intitul de la slection laide de la

mthode select_clear.
pos1 = 0
li.select_clear (pos1, pos2 = None)
# retire la slection de tous les lments entre les indices
# pos1 et pos2 inclus ou seulement celui dindice pos1 si pos2 == None
La mthode curselection permet dobtenir la liste des indices des lments slec-
tionns.
sel = li.curselection ()
La mthode get permet rcuprer un lment de la liste tandis que la mthode size
retourne le nombre dlments :
for i in range (0,li.size ()) :
print li.get (i)
Figure 8.7 : Exemple de liste. La se-

conde liste est grise et ne peut tre mo-
difie.
La figure 8.7 montre deux listes. La seconde est grise par rapport la premire.
Elle ne peut tre modifie. Pour obtenir cet tat, il faut appeler la mthode config
rappele au paragraphe 8.2.11.
Remarque 8.1 : liste et barre de dfilement
Il est possible dadjoindre une barre de dfilement verticale. Il faut pour cela inclure
lobjet dans une sous-fentre Frame qui est dfinie au paragraphe 8.3.2 comme dans
lexemple suivant :
frame = Tkinter.Frame (parent)
scrollbar = Tkinter.Scrollbar (frame)
li = Tkinter.Listbox (frame, width = 88, height = 6, \
yscrollcommand = scrollbar.set)
scrollbar.config (command = li.yview)
li.pack (side = Tkinter.LEFT)
scrollbar.pack (side = Tkinter.RIGHT, fill = Tkinter.Y)
Il suffit de transposer cet exemple pour ajouter une barre de dfilement horizontale.
Toutefois, il est prfrable dutiliser un objet prdfini prsent dans le module Tix
qui est une extension du module Tkinter. Elle est prsente au paragraphe 8.2.8.
Remarque 8.2 : plusieurs Listbox
Lorsquon insre plusieurs objets Listbox dans une seule fentre, ces objets partagent
par dfaut la mme slection. Autrement dit, lorsquon clique sur un lment de la
seconde Listbox, llment slectionn dans la premire ne lest plus. Afin de pouvoir
slectionner un lment dans chaque Listbox, il faut ajouter dans les paramtres du
constructeur loption exportselection = 0 comme lillustre lexemple suivant :
li = Tkinter.Listbox (frame, width = 88, height = 6, exportselection=0)
Il existe des mthodes plus avances qui permettent de modifier laspect graphique
dun lment comme la mthode itemconfigure. Son utilisation est peu frquente
moins de vouloir raliser une belle interface graphique. Le paragraphe 8.6.2 montre
lutilisation quon peut en faire.
8.2.8 Liste avec barre de dfilement, Combobox

Il nexiste pas dans le module Tkinter dobjets List avec une barre de dfilement
incluse mais il existe un autre module interne Tix qui tend la liste des objets
proposs par Tkinter. Ce module propose notamment une liste avec une barre de
dfilement intgre :
# coding: latin-1
import Tix as Tk
root = Tk.Tk ()
o = Tk.ScrolledListBox (root)
for k in range (0,100) : o.listbox.insert (Tk.END, "ligne " + str (k))
o.pack ()
def print_file () : # voir chapitre sur les vnements

print o.listbox.selection_get () # idem
b = Tk.Button (root, text = "print")

b.config (command = print_file) # idem
b.pack ()
root.mainloop () # idem
Le module Tix quoique assez riche puisquil propose des fentres permettant de
slectionner un fichier ou de remplir un tableau est mal document sur Python.
Il existe une documentation officielle 5 et des exemples 6 . La plupart du temps, on
trouve un exemple approch. Dans lexemple prcdent comme dans le suivant avec
une "ComboBox", la pression du bouton print crit la zone slectionne. La figure 8.8
illustre graphiquement ce quest une Combobox.
# coding: latin-1
import Tix as Tk
root = Tk.Tk ()
o = Tk.ComboBox (root, label = "label")

o.insert (Tk.END, "ligne 1")
o.pack ()
def print_file () : # voir le chapitre sur les vnments

print o.cget ("value") # idem
b = Tk.Button (root, text = "print")

b.config (command = print_file) # idem
b.pack ()
root.mainloop () # idem
Lavantage du module Tix est dtre install automatiquement avec le langage Py-
thon. Il reste malgr tout trs peu document et arriver ses fins peut ncessiter
quelques heures de recherche.
8.2.9 Canevas
Pour dessiner, il faut utiliser un objet canevas, correspondant la classe Canvas du
module Tkinter. Pour la crer, il suffit dcrire la ligne suivante :
ca = Tkinter.Canvas ()
5. http://pydoc.org/2.1/Tix.html ou encore http://docs.python.org/library/tix.html

6. http://coverage.livinglogic.de/index.html
Figure 8.8 : Exemple de fentre Combobox dfinie par

le module interne Tix qui est une extension du module
Tkinter. La seconde image est la mme Combobox mais
dplie.
truction suivante :
# modifie les dimensions du canevas
# width <--> largeur en pixels
# height <--> hauteur en pixels
ca.config (width = 10, height = 5)
Cet objet permet de dessiner des lignes, des courbes, dcrire du texte grce aux
mthodes create_line, create_rectangle, create_text. La figure 8.9 illustre ce
que donnent les quelques lignes qui suivent.
# dessine deux lignes du point 10,10 au point 40,100 et au point 200,60
# de couleur bleue, dpaisseur 2
ca.create_line (10,10,40,100, 200,60, fill = "blue", width = 2)
# dessine une courbe du point 10,10 au point 200,60
# de couleur rouge, dpaisseur 2, cest une courbe de Bzier
# pour laquelle le point 40,100 sert dassise
ca.create_line (10,10, 40,100, 200,60, smooth=1, fill = "red", width = 2)
# dessine un rectangle plein de couleur jaune, de bord noir et dpaisseur 2
ca.create_rectangle (300,100,60,120, fill = "gray", width = 2)
# crit du texte de couleur noire au point 80,80 et avec la police arial
ca.create_text (80,80, text = "crire", fill = "black", font = "arial")
Figure 8.9 : Exemple de canevas.
8.2.10 Menus
Les menus apparaissent en haut des fentres. La plupart des applications arborent
un menu commenant par Fichier Edition Affichage... Le paragraphe 8.4.5 page 214
les dcrit en dtail.
8.2.11 Mthodes communes

Nous avons vu que tous les objets prsents dans ce paragraphe possdent une
mthode config qui permet de dfinir ltat du widget (gris ou normal) 7 .
widget.config (state = Tkinter.DISABLED) # gris
widget.config (state = Tkinter.NORMAL) # aspect normal
Elle permet galement de modifier le texte dun objet, sa position, ... De nombreuses
options sont communes tous les objets et certaines sont spcifiques. Laide asso-
cie cette mthode 8 ne fournit aucun renseignement. En fait, le constructeur et
cette mthode ont les mmes paramtres optionnels. Il est quivalent de prciser ces
options lors de lappel au constructeur :
l = Tkinter.Label (text = "lgende")
Ou de les modifier laide de la mthode config :

l = Tkinter.Label ()
l.config (text = "lgende")
Laide associe la mthode config est la suivante :

Help on method configure in module Tkinter:
configure(self, cnf=None, **kw) unbound Tkinter.Label method

Configure resources of a widget.
The values for resources are specified as keyword

arguments. To get an overview about
the allowed keyword arguments call the method keys.
Tandis que laide associe au constructeur de la classe Label 9 donne plus dinfor-
mations :
__init__(self, master=None, cnf={}, **kw) unbound Tkinter.Label method
Construct a label widget with the parent MASTER.
STANDARD OPTIONS
activebackground, activeforeground, anchor,

background, bitmap, borderwidth, cursor,
disabledforeground, font, foreground,
highlightbackground, highlightcolor,
highlightthickness, image, justify,
padx, pady, relief, takefocus, text,
textvariable, underline, wraplength
WIDGET-SPECIFIC OPTIONS
height, state, width
7. La "disparition" dun objet est voque au paragraphe 8.3.

8. Par exemple pour la classe Label, cette aide est affiche grce linstruction
help(Tkinter.Label.config).
9. Affiche avec linstruction help(Tkinter.Label.__init__).
Cette aide mentionne les options communes tous les objets (ou widgets) et les
options spcifiques cet objet, ici de type Label. Toutes ont une valeur par dfaut
quil est possible de changer soit dans le constructeur, soit par la mthode config.
Quelques-unes ont t dcrites, dautres permettent de modifier entre autres la police
avec laquelle est affich le texte de lobjet (option font), la couleur du fond (option
background), lalignement du texte, gauche, droite, centr (option justify),
lpaisseur du bord (option borderwidth), le fait quun objet reoive le focus 10 aprs
la pression de la touche tabulation (takefocus)...
8.3 Disposition des objets dans une fentre

8.3.1 Emplacements
Chacun des objets (ou widgets) prsents au paragraphe prcdent possde trois
mthodes qui permettent de dterminer sa position dans une fentre : pack, grid,
place. Les deux premires permettent de disposer les objets sans se soucier ni de leur
dimension ni de leur position. La fentre gre cela automatiquement. La dernire
place les objets dans une fentre laide de coordonnes sans utiliser laide daucune
grille. Dans une fentre, tous les objets doivent tre placs avec la mme mthode.
Dans le cas contraire, les rsultats risquent ne pas tre ceux attendus.
8.3.1.1 Mthode pack
Cette mthode empile les objets les uns la suite des autres. Par dfaut, elle les
empile les uns en dessous des autres. Par exemple, lexemple suivant produit lem-
pilement des objets de la figure 8.10.
l = Tkinter.Label (text = "premire ligne")
l.pack ()
s = Tkinter.Entry ()
s.pack ()
e = Tkinter.Label (text = "seconde ligne")
e.pack ()
Figure 8.10 : Les objets sont empi-

ls laide de la mthode pack les uns
en dessous des autres pour la premire
image, les uns droite des autres pour
la seconde image.
On peut aussi les empiler les uns droite des autres grce loption side.
l.pack (side = Tkinter.RIGHT)
10. voir paragraphe 8.4.2

s.pack (side = Tkinter.RIGHT)

e.pack (side = Tkinter.RIGHT)
La mthode pack possde trois options :

1. side : choisir entre Tkinter.TOP (valeur par dfaut), Tkinter.LEFT,
Tkinter.BOTTOM, Tkinter.RIGHT.
2. expand : gale True ou False (valeur par dfaut), si cette option est vraie, lobjet
occupe tout lespace.
3. fill : gale None (valeur par dfaut), X, Y, BOTH, lobjet stend selon un axe (X
ou Y ou les deux).
Il nest pas toujours vident dobtenir du premier coup le positionnement des objets
souhaits au dpart et il faut ttonner pour y arriver. Lorsque un objet nest plus
ncessaire, il est possible de le faire disparatre en appelant la mthode pack_forget.
Le rappel de la mthode pack le fera rapparatre mais rarement au mme endroit.
s.pack_forget () # disparition
s.pack () # insertion un autre endroit
8.3.1.2 Mthode grid
La mthode grid suppose que la fentre qui les contient est organise selon une
grille dont chaque case peut recevoir un objet. Lexemple suivant place trois objets
dans les cases de coordonnes (0, 0), (1, 0) et (0, 1). Le rsultat apparat dans la
figure 8.11.
l.grid (column = 0, row = 0)
s.grid (column = 0, row = 1)
e.grid (column = 1, row = 0)
Figure 8.11 : Les objets sont placs dans

une grille laide de la mthode grid. Une
fois que chaque objet a reu une position,
laffichage, il ne sera pas tenu compte des
lignes et colonnes vides.
La mthode grid possde plusieurs options, en voici cinq :

1. column : colonne dans laquelle sera place lobjet.
2. columnspan : nombre de colonnes que doit occuper lobjet.
3. row : ligne dans laquelle sera place lobjet.
4. rowspan : nombre de lignes que doit occuper lobjet.
5. sticky : indique ce quil faut faire lorsque la case est plus grande que lobjet quelle
doit contenir. Par dfaut, lobjet est centr mais il est possible daligner lobjet sur
un ou plusieurs bords en prcisant que sticky = N ou S ou W ou E. Pour
aligner lobjet sur un angle, il suffit de concatner les deux lettres correspondant aux
deux bords concerns. Il est aussi possible dtendre lobjet dun bord lautre en
crivant sticky = N + S ou sticky = E + W.
Enfin, comme pour la mthode pack, il existe une mthode grid_forget qui permet
de faire disparatre les objets.
s.grid_forget () # disparition
8.3.1.3 Mthode place
La mthode place est sans doute la plus simple comprendre puisquelle permet
de placer chaque objet une position dfinie par des coordonnes. Elle peut tre
utilise en parallle avec les mthodes pack et grid.
l.place (x=10,y=50)
La mthode place_forget permet de faire disparatre un objet placer avec cette

mthode. Linconvnient de cette mthode survient lorsquon cherche modifier
lemplacement dun objet : il faut en gnral revoir les positions de tous les autres
lments de la fentre. On procde souvent par ttonnement pour construire une
fentre et disposer les objets. Ce travail est beaucoup plus long avec la mthode
place.
8.3.2 Sous-fentre
Les trois mthodes prcdentes ne permettent pas toujours de placer les lments
comme on le dsire. On souhaite parfois regrouper les objets dans des botes et
placer celles-ci les unes par rapport aux autres. La figure 8.12 montre deux objets
regroups dans un rectangle avec sa gauche une zone de texte. Les botes sont
des instances de la classe Frame. Ce sont des objets comme les autres except le fait
quune bote contient dautres objets y compris de type Frame. Pour crer une bote,
il suffit dcrire la ligne suivante :
f = Tkinter.Frame ()
Ensuite, il faut pouvoir affecter un objet cette bote f. Pour cela, il suffit que f
soit le premier paramtre du constructeur de lobjet cr :
l = Tkinter.Label (f, text = "premire ligne")
Lexemple qui suit correspond au code qui permet dafficher la fentre de la fi-
gure 8.12 :
f = Tkinter.Frame ()
l = Tkinter.Label (f, text = "premire ligne")
l.pack () # positionne l lintrieur de f
s = Tkinter.Entry (f)
s.pack () # positionne s lintrieur de f

f.pack (side = Tkinter.LEFT) # positionne f lintrieur
# de la fentre principale
e.pack_forget ()
e.pack (side = Tkinter.RIGHT) # positionne e lintrieur
# de la fentre principale
Lutilisation de ces blocs Frame est pratique lorsque le mme ensemble de contrles
apparat dans plusieurs fentres diffrentes ou au sein de la mme fentre. Cette
possibilit est envisage au paragraphe 8.6.3.
Figure 8.12 : Les deux premiers objets - une zone

de texte au-dessus dune zone de saisie - sont re-
groups dans une bote - rectangle rouge, invisible
lcran. A droite et centre, une dernire zone de
texte. Cet alignement est plus simple raliser en re-
groupant les deux premiers objets dans un rectangle
(objet Frame).
8.4 Evnements
8.4.1 Fentre principale
Tous les exemples des paragraphes prcdents dcrivent les diffrents objets dispo-
nibles et comment les disposer dans une fentre. Pour afficher cette fentre, il suffit
dajouter au programme les deux lignes suivantes :
# ici, on trouve le code qui dfinit les objets
# et leur positionnement
root.mainloop ()
La premire ligne permet dobtenir un identificateur reli la fentre principale. La

seconde ligne, outre le fait quelle affiche cette fentre, lance ce quon appelle une
boucle de messages. Cette fonction rcupre - intercepte - les vnements comme
un clic de souris, la pression dune touche. Elle parcourt ensuite tous les objets
quelle contient et regarde si lun de ces objets est intress par cet vnement. Sil
est intress, cet objet prend lvnement et le traite. On peut revenir ensuite la
fonction mainloop qui attend nouveau un vnement. Cette fonction est dfinie
par Tkinter, il reste lui indiquer quels vnements un objet dsire intercepter et
ce quil est prvu de faire au cas o cet vnement se produit.
Remarque 8.3 : instruction root = Tkinter.Tk()
Cette premire instruction doit se trouver au dbut du programme. Si elle intervient
alors quune mthode de positionnement (pack, grid, ou place) a dj t appele,
le programme affichera deux fentres dont une vide.
8.4.2 Focus
Une fentre peut contenir plusieurs zones de saisie, toutes capables dintercepter la
pression dune touche du clavier et dajouter la lettre correspondante la zone de
saisie. Or la seule qui ajoute effectivement une lettre son contenu est celle qui a le
focus. La pression de la touche tabulation fait passer le focus dun objet lautre.
La figure 8.13 montre un bouton qui a le focus. Lorsquon dsire quun objet en
particulier ait le focus, il suffit dappeler la mthode focus_set.
e = Tkinter.Entry ()
e.pack ()
e.focus_set ()
Figure 8.13 : Ce bouton est entour dun cercle noir en pointill, il a

le focus.
8.4.3 Lancer une fonction lorsquun bouton est press

La plupart de temps, le seul vnement quon souhaite attraper est la pression
dun bouton. Le code suivant permet de crer un bouton dont lidentificateur
est b. Il a pour intitul fonction change_legende. On dfinit ensuite une fonction
change_legende qui change la lgende de ce bouton. Lavant-dernire ligne permet
dassocier au bouton b la fonction change_legende qui est alors appele lorsque le
bouton est press. La dernire ligne affiche la fentre principale et lance lapplication.
# coding: latin-1
# la premire ligne autorise les accents
import Tkinter
b = Tkinter.Button (text = "fonction change_legende")
b.pack ()
def change_legende () :
global b
b.config (text = "nouvelle lgende")
b.config (command = change_legende)

root.mainloop ()
Lorsque le bouton b est press, on vrifie quil change bien de lgende (voir fi-
gure 8.14).
Remarque 8.4 : vnement associ une mthode
Lexemple prcdent associe une fonction au bouton. Lorsque linterface devient
consquente, la lisibilit du programme en est rduite car le nombre de fonctions
associes des boutons augmentent rapidement. Pour viter cela, il est possible
dassocier au bouton une mthode de classe comme le suggre lexemple du para-
graphe 8.6.3.
Figure 8.14 : La premire fentre est celle qui apparat lorsque le

programme de la page 210 est lanc. Comme le bouton change de
lgende la premire fois quil est press, lapparence de la fentre
change aussi, ce que montre la seconde image.
8.4.4 Associer nimporte quel vnement un objet

Le paragraphe prcdent sest intress lassociation entre une fonction et la pres-
sion dun bouton mais il est possible de faire en sorte que le programme excute
une fonction au moindre dplacement de la souris, la pression dune touche. Il est
possible dassocier une fonction au moindre vnement susceptible dtre intercept
par linterface graphique.
On peut regrouper les vnements en deux classes. La premire classe regroupe les
vnements provenant du clavier ou de la souris. Ce sont des vnements en quelque
sorte bruts. La seconde classe regroupe des vnements produit par des objets tels
quun bouton. En effet, lorsque celui-ci dtecte le clic du bouton droit de la souris,
il construit un vnement pressiondubouton et cest celui-ci qui va dclencher
lexcution dune fonction. Il nest pas souvent ncessaire de revenir aux vnements
bruts car les objets proposent deux-mmes de pouvoir attacher des fonctions des
vnements lis leur apparence.
Toutefois, pour un jeu par exemple, il est parfois ncessaire davoir accs au mouve-
ment de la souris et il faut revenir aux vnements bruts. Un vnement est dcrit
par la classe Event dont les attributs lists par la table 8.1 dcrivent lvnement qui
sera la plupart du temps la pression dune touche du clavier ou le mouvement de la
souris.
Lorsquune touche a t presse, cet attribut contient son code,
il ne tient pas compte des touches dites muettes comme les
char
touches shift, ctrl, alt. Il tient pas compte non plus des
touches return ou suppr.
Lorsquune touche a t presse, cet attribut contient son code,
keysym
quelque soit la touche, muette ou non.
num Contient un identificateur de lobjet ayant reu lvnement.
Coordonnes relatives de la souris par rapport au coin suprieur
x, y
gauche de lobjet ayant reu lvnement.
Coordonnes absolues de la souris par rapport au coin suprieur
x_root, y_root
gauche de lcran.
Identifiant permettant daccder lobjet ayant reu lvne-
widget
ment.
Table 8.1 : Attributs principaux de la classe Event, ils dcrivent les vnements lis
au clavier et la souris. La liste complte est accessible en utilisant linstruction
help(Tkinter.Event).
La mthode bind permet dexcuter une fonction lorsquun certain vnement donn
est intercept par un objet donn. La fonction excute accepte un seul paramtre
de type Event qui est lvnement qui la dclenche. Cette mthode a pour syntaxe :
syntaxe 8.5 : mthode bind

w.bind (ev, fonction)
w est lidentificateur de lobjet devant intercepter lvnement dsign par la

chane de caractres ev (voir table 8.2). fonction est la fonction qui est appele
lorsque lvnement survient. Cette fonction ne prend quun paramtre de type
Event.
Intercepter la pression de nimporte quelle touche du cla-

<Key>
vier.
Intercepter la pression dun bouton de la souris. i doit tre
<Button-i>
remplac par 1,2,3.
Intercepter le relchement dun bouton de la souris. i doit
<ButtonRelease-i>
tre remplac par 1,2,3.
Intercepter la double pression dun bouton de la souris. i
<Double-Button-i>
doit tre remplac par 1,2,3.
Intercepter le mouvement de la souris, ds que le curseur
<Motion>
bouge, la fonction lie lvnement est appele.
Intercepter un vnement correspondant au fait que le cur-
<Enter>
seur de la souris entre la zone graphique de lobjet.
Intercepter un vnement correspondant au fait que le cur-
<Leave>
seur de la souris sorte la zone graphique de lobjet.
Table 8.2 : Chanes de caractres correspondant aux principaux types dvnements quil
est possible dintercepter avec le module Tkinter. La liste complte est accessible en utilisant
linstruction help(Tkinter.Label.bind).
Lexemple suivant utilise la mthode bind pour que le seul bouton de la fentre
intercepte toute pression dune touche, tout mouvement et toute pression du premier
bouton de la souris lorsque le curseur est au dessus de la zone graphique du bouton.
La fentre cre par ce programme ainsi que laffichage qui en rsulte apparaissent
dans la figure 8.15.
import Tkinter
b = Tkinter.Button (text = "appuyer sur une touche")
b.pack ()
def affiche_touche_pressee (evt) :

print "--------------------------- touche pressee"
print "evt.char = ", evt.char
print "evt.keysym = ", evt.keysym
print "evt.num = ", evt.num
print "evt.x,evt.y = ", evt.x, ",", evt.y
print "evt.x_root,evt.y_root = ", evt.x_root, ",", evt.y_root
print "evt.widget = ", evt.widget
b.bind ("<Key>", affiche_touche_pressee)

b.bind ("<Button-1>", affiche_touche_pressee)
b.bind ("<Motion>", affiche_touche_pressee)
b.focus_set ()
root.mainloop ()
evt.char = ?? evt.char =
evt.keysym = ?? evt.keysym = Return
evt.num = 1 evt.num = ??
evt.x,evt.y = 105 , 13 evt.x,evt.y = 105 , 13
evt.x_root,evt.y_root = evt.x_root,evt.y_root =
292 , 239 292 , 239
evt.widget = .9261224 evt.widget = .9261224
Figure 8.15 : Fentre affiche par le programme du paragraphe 8.4.4. La pression dune
touche dclenche laffichage des caractristiques de lvnement. La seconde colonne cor-
respond la pression du premier bouton de la souris. La dernire colonne correspond la
pression de la touche Return.
Remarque 8.6 : focus

Lavant dernire ligne du programme fait intervenir la mthode focus_set. Elle
stipule que le bouton doit recevoir le focus. Cest--dire que cet objet est celui qui
peut intercepter les vnements lis au clavier. Sans cette instruction, cet objet ny
a pas accs, ces vnements sont dirigs vers la fentre principale qui ne sen soucie
pas.
Remarque 8.7 : mauvais vnement
Les messages derreur lis aux vnements ne sont pas forcment trs explicites.
Ainsi linstruction suivante adresse un vnement inexistant.
b.bind ("<button-1>", affiche_touche_pressee)
Lors de lexcution, le programme dclenche la succession dexceptions suivantes qui

signifie que lvnement <button-1> nexiste pas.
File "exemple_bind.py", line 17, in ?
b.bind ("<button-1>", affiche_touche_pressee)
File "c:\python26\lib\lib-tk\Tkinter.py", line 933, in bind
return self._bind((bind, self._w), sequence, func, add)
File "c:\python26\lib\lib-tk\Tkinter.py", line 888, in _bind
self.tk.call(what + (sequence, cmd))
_tkinter.TclError: bad event type or keysym "button"
Remarque 8.8 : associer un vnement tous les objets

Il arrive parfois quun vnement ne doive pas tre associ un seul objet mais tous
ceux que la fentre contient. Cest lobjectif de la mthode bind_all. Sa syntaxe est
exactement la mme que la mthode bind.
b.bind_all ("<Button-1>", affiche_touche_pressee)
On utilise peu cette fonction, on prfre construire des objets propres un pro-
gramme comme suggr au paragraphe 8.6.2.
Remarque 8.9 : dsactiver un vnement
De la mme manire quil est possible dassocier un vnement un objet dune
fentre, il est possible deffectuer lopration inverse qui consiste supprimer cette
association. La mthode unbind dsactive un vnement associ un objet. La m-
thode unbind_all dsactive un vnement associ pour tous les objets dune fentre.
syntaxe 8.10 : mthode unbind

w.unbind (ev)
w.unbind_all (ev)
w est lidentificateur de lobjet interceptant lvnement dsign par la chane

de caractres ev (voir table 8.2). Aprs lappel la mthode unbind, lv-
nement nest plus intercept par lobjet w. Aprs lappel la mthode
unbind_all, lvnement nest plus intercept par aucun objet.
Remarque 8.11 : vnement spcifique

Il est possible de dfinir des vnements propres aux programmes. Ceux-ci ne sont
gnrs par aucun priphrique mais explicitement par le programme lui-mme. Ce
mcanisme est presque toujours coupl lutilisation de threads. Le paragraphe 9.3
(page 231) illustre ce principe laide dun exemple base de thread. Le para-
graphe 8.6.5 page 224 propose un exemple plus simple.
8.4.5 Menu
Les menus fonctionnent de la mme manire que les boutons. Chaque intitul du
menu est reli une fonction qui sera excute la condition que lutilisateur s-
lectionne cet intitul. Lobjet Menu ne dsigne pas le menu dans son ensemble mais
seulement un niveau. Par exemple, le menu prsent par la figure 8.17 est en fait un
assemblage de trois menus auquel on pourrait ajouter dautres sous-menus.
Figure 8.16 : La reprsentation dun menu tient

plus dun graphe que dune liste. Chaque intitul du
menu peut tre connect une fonction ou tre le
point dentre dun nouveau sous-menu.
Pour crer un menu ou un sous-menu, il suffit de crer un objet de type Menu :

m = Tkinter.Menu ()
Ce menu peut tre le menu principal dune fentre auquel cas, il suffit de prciser
la fentre en question que son menu est le suivant :
root.config (menu = m)
root est ici la fentre principale mais ce pourrait tre galement une fentre de type
TopLevel (voir paragraphe 8.5.1). Ce menu peut aussi tre le sous-menu associ
un intitul dun menu existant. La mthode add_cascade permet dajouter un
sous-menu associ un label :
mainmenu = Tkinter.Menu ()
msousmenu = Tkinter.Menu ()
mainmenu.add_cascade (label = "sous-menu 1", menu = msousmenu)
En revanche, si on souhaite affecter une fonction un menu, on utilisera la mthode

add_command :
def fonction1 () :
....
m = Tkinter.Menu ()
mainmenu.add_command (label = "fonction 1", command = fonction1)
Lexemple suivant regroupe les fonctionnalits prsentes ci-dessus.

import Tkinter
e = Tkinter.Text (width = 50, height = 10)

e.pack ()
m = Tkinter.Menu ()
sm1 = Tkinter.Menu ()
sm2 = Tkinter.Menu ()
m.add_cascade (label = "sous-menu 1", menu = sm1)

m.add_cascade (label = "sous-menu 2", menu = sm2)
nb = 0
def affiche () : print "fonction affiche"

def calcul () : print "fonction calcul ", 3 * 4
def ajoute_bouton () :
global nb
nb += 1
b = Tkinter.Button (text = "bouton " + str (nb))
b.pack ()
sm1.add_command (label = "affiche", command = affiche)

sm1.add_command (label = "calcul", command = calcul)
sm2.add_command (label = "ajoute_bouton", command = ajoute_bouton)
sm2.add_command (label = "fin", command = root.destroy)
root.config (menu = m, width = 200)

root.title ("essai de menu")
#help (Tkinter.Tk)
root.mainloop ()
Figure 8.17 : Rsultat de lexemple du para-

graphe 8.4.5, la slection de diffrents intituls du
menu permet dafficher des choses avec linstruction
print ou dajouter des boutons.
Chaque intitul dun menu est ajout en fin de liste, il est possible den supprimer
certains partir de leur position avec la mthode delete :
m = Tkinter.Menu ()
m.add_command (...)
m.delete (1, 2) # supprime le second intitul
# supprime les intituls compris entre 1 et 2 exclu
8.4.6 Fonctions prdfinies

Il est possible de dtruire la fentre principale, ce qui mettra fin au programme
si celui-ci ne prvoit rien aprs la fonction mainloop. La destruction de la fentre
seffectue par la mthode destroy. Le programme suivant cre une fentre avec un
seul bouton qui, sil est press, mettra fin lapplication.
import Tkinter
Tkinter.Button (text = "fin", command = root.destroy).pack ()
root.mainloop ()
La table 8.3 regroupe les fonctions les plus utilises. Celles-ci sapplique une fentre
de type Toplevel qui est aussi le type de la fentre principale.
destroy() Dtruit la fentre.

deiconify() La fentre reprend une taille normale.
Modifie la taille de la fentre. s est une chane de caractres de
geometry(s) type wxhxy. w et h sont la largeur et la hauteur. x et y sont la
position du coin suprieur haut lcran.
iconify() La fentre se rduit un icne.
Spcifie si la fentre peut changer de taille. w et h sont des boo-
resizable(w, h)
lens.
title(s) Change le titre de la fentre, s est une chane de caractres.
withdraw() Fait disparatre la fentre. La fonction inverse est deiconify.
Table 8.3 : Liste non exhaustives des mthodes de la classe Toplevel qui le type de la
fentre principale.
8.5 Dautres fentres

8.5.1 Crer une seconde bote de dialogues
Lorsquun programme doit utiliser plusieurs fentres et non pas une seule, lemploi
de lobjet Toplevel est invitable. Linstruction root = Tkinter.Tk() cre la fentre
principale, linstruction win = Tkinter.Toplevel() cre une seconde fentre qui fonc-
tionne exactement comme la fentre principale puisquelle dispose elle aussi dune
boucle de messages via la mthode mainloop.
import Tkinter
win = Tkinter.Toplevel ()
win.mainloop ()
Un cas dutilisation simple est par exemple un bouton press qui fait apparatre une
fentre permettant de slectionner un fichier, cette seconde fentre sera un objet
Toplevel. Il nest pas ncessaire de stendre plus sur cet objet, son comportement est
identique celui de la fentre principale, les fonctions dcrites au paragraphe 8.4.6
sappliquent galement aux objets Toplevel. Il reste nanmoins prciser un dernier
point. Tous les objets prcdemment dcrits au paragraphe 8.2 doivent inclure un
paramtre supplmentaire dans leur constructeur pour signifier quils appartiennent
un objet Toplevel et non la fentre principale. Par exemple, pour crer une zone
de texte, la syntaxe est la suivante :
# zone_texte appartient la fentre principale
zone_texte = Tkinter.Label (text = "premier texte")
Pour linclure une fentre Toplevel, cette syntaxe devient :

# zone_texte appartient la fentre top
top = Tkinter.Toplevel ()
zone_texte = Tkinter.Label (top, text = "premier texte")
Lors de la dfinition de chaque objet ou widget, si le premier paramtre est de type

Toplevel, alors ce paramtre sera affect la fentre passe en premier argument
et non la fentre principale. Ce principe est le mme que celui de la sous-fentre
Frame (voir paragraphe 8.3.2, page 208). La seule diffrence provient du fait que
lobjet Toplevel est une fentre autonome qui peut attendre un message grce la
mthode mainloop, ce nest pas le cas de lobjet Frame.
Toutefois, il est possible dafficher plusieurs fentre Toplevel simultanment. Le
programme suivant en est un exemple :
# coding: latin-1
import Tkinter
class nouvelle_fenetre :
resultat = []
def top (self) :
sec = Tkinter.Toplevel ()
Tkinter.Label (sec, text="entrer quelque chose").pack ()
saisie = Tkinter.Entry (sec)
saisie.pack()
Tkinter.Button (sec, text = "valider", command = sec.quit).pack ()
sec.mainloop ()
nouvelle_fenetre.resultat.append ( saisie.get () )
sec.destroy ()
root = Tkinter.Tk() #fenetre principale

a = Tkinter.Button (text = "fentre Toplevel",
command = nouvelle_fenetre ().top)
a.pack()
root.mainloop()
for a in nouvelle_fenetre.resultat :
print "contenu ", a
8.5.2 Fentres standard

Le module Tix propose une fentre de slection de fichiers identique celle de la
figure 8.18. Tkinter a lavantage dtre simple et ne ncessite pas un long apprentis-
sage pour le matriser mais il est limit. Pour ce type de fentres quon retrouve dans
la plupart des programmes, il existe presque toujours des solutions toutes faites, via
le module Tix par exemple. On trouve galement de nombreux programmes sur In-
ternet par le biais de moteurs de recherche. Le programme ci-dessous affiche une
fentre qui permet de slectionner un fichier.
import Tix as Tk
root = Tk.Tk ()
def command_print () : print box.cget("value")
box = Tk.FileSelectBox (root)

box.config (directory="c:\\")
box.pack ()
Tk.Button (root, text = "print", command = command_print).pack ()
root.mainloop ()
Figure 8.18 : Exemple dune fentre gra-

phique. Celle-ci permet de slectionner un fi-
chier. Cest une fentre prdfinie du module
Tix qui est une extension de Tkinter.

Lobjectif des paragraphes qui suivent est dintroduire quelques schmas de construc-
tion dinterfaces qui reviennent frquemment. La premire rgle de programmation
quil est prfrable de suivre est disoler la partie interface du reste du programme.
La gestion vnementielle a pour dfaut parfois de dissminer un traitement, un
calcul plusieurs endroits de linterface. Cest le cas par exemple de longs calculs
dont on souhaite connatre lavance. Le calcul est lanc par la pression dun bouton
puis son droulement est "espionn" par un vnement rgulier comme un compte
rebours.
Le principal problme des interfaces survient lors du traitement dun vnement :
pendant ce temps, linterface nest pas ractive et ne ragit plus aux autres v-
nements jusqu ce que le traitement de lvnement en cours soit termin. Pour
contourner ce problme, il est possible soit de dcouper un calcul en petites fonc-
tions chacune trs rapide, cela suppose que ce calcul sera men bien par une
succession dvnements. Il est galement possible de lancer un thread, principe
dcrit au paragraphe 9.3 (page 231).
Cest pourquoi la premire rgle est de bien scinder interface et calculs scientifiques
de faon pouvoir rendre le programme plus lisible et ainsi tre en mesure diso-
ler plus rapidement la source dune erreur. Les paragraphes qui suivent prsentent
quelques aspects rcurrents quil est parfois utile davoir en tte avant de se lancer.
8.6.1 Compte rebours

Il est possible de demander un objet dappeler une fonction aprs un certains laps
de temps exprim un millisecondes. Le programme suivant cre un objet de type
Label. Il contient une fonction qui change son contenu et lui affecte un compte
rebours qui impose lobjet de rappeler cette fonction 1000 millisecondes plus tard.
Le rsultat est un programme qui cre la fentre 8.19 et change son contenu toutes
les secondes.
import Tkinter
l = Tkinter.Label (text = "0 secondes")
l.pack ()
sec = 0
id = None
def change_legende() :
global l
global sec
global id
sec += 1
l.config (text = "%d secondes" % sec)
id = l.after (1000, change_legende)
l.after (1000, change_legende)
root.mainloop ()
Figure 8.19 : Rsultat de lexemple du paragraphe 8.6.1,

lintitul de lobjet Label change toutes les secondes.
La mthode after retourne un entier permettant didentifier le compte re-

bours quil est possible dinterrompre en utilisant la mthode after_cancel. Dans
lexemple prcdent, il faudrait utiliser linstruction suivante :
l.after_cancel (id)
8.6.2 Contrles personnaliss : utilisation des classes

On peut personnifier un contrle. Par exemple, on peut mettre en vidence lintitul
dune liste sous le curseur de la souris. Le moyen le plus simple est de crer une
nouvelle classe qui se substituera au classique Listbox. Il suffit que cette nouvelle
classe hrite de Listbox en prenant soin de lui donner un constructeur reprenant
les mmes paramtres que celui de la classe Listbox. De cette faon, il suffit de
remplacer Listbox par MaListbox pour changer lapparence dune liste.
# coding: latin-1
import Tkinter
class MaListbox (Tkinter.Listbox) :

def __init__ (self, master = None, cnf={}, **kw) :
Tkinter.Listbox.__init__ (self, master, cnf, **kw)
self.bind ("<Motion>", self.mouvement)
self.pos = None # mmoire lancienne position du curseur
def mouvement (self, ev) :
pos = self.nearest (ev.y) # nouvelle position du curseur
if pos < 0 or pos >= self.size () : return
if self.pos != pos :
if self.pos != None : self.itemconfigure(self.pos, bg=)
self.itemconfigure (pos, bg=gray)
self.pos = pos
b = MaListbox ()
b.insert ("end", "ligne 1")
b.pack ()
b.focus_set ()
root.mainloop ()
Dans ce cas prcis, on fait en sorte que le contrle intercepte le mouvement du cur-
seur. Lorsque celui-ci bouge, la mthode mouvement est appele comme le construc-
teur de MaListbox la spcifi. La mthode nearest permet de dfinir lintitul le plus
proche du curseur. La mthode itemconfigure permet de changer le fond de cet in-
titul en gris aprs avoir modifi le fond de lintitul prcdent pour quil retrouve
sa couleur davant. Le rsultat est illustr la figure 8.20.
Figure 8.20 : Aspect de la classe MaListbox dfinie par le pro-

gramme 220. Lintitul sous le curseur de la souris a un fond
gris.
8.6.3 Fentres personnalises : utilisation des classes

Cet exemple prolonge lide du paragraphe prcdent. Lorsque linterface devient
complexe, il peut tre utile de crer ses propres fentres. Jusqu prsent, seules des
fonctions ont t attaches vnement comme la pression dun bouton mais il est
possible dattacher la mthode dune classe ce que dveloppe lexemple qui suit.
# coding: latin-1
import Tkinter as Tk
class MaFenetre :
def __init__ (self, win) :
self.win = win
self.creation ()
def creation (self) :

b1 = Tk.Button (self.win, text="bouton 1", command=self.commande_bouton1)
b3 = Tk.Button (self.win, text="disparition", command=self.disparition)
b1.grid (row=0, column=0)
self.lab = Tk.Label (self.win, text = "-")
def commande_bouton1 (self) :

# on dplace lobjet lab de type Label
self.lab.configure (text = "bouton 1 appuy")
self.lab.grid (row = 1, column = 0)

# on dplace lobjet lab de type Label
self.lab.configure (text = "bouton 2 appuy")
def disparition (self) :

# on fait disparatre lobjet lab de type Label
self.lab.grid_forget ()
if __name__ == "__main__" :
root = Tk.Tk ()
f = MaFenetre (root)
root.mainloop ()
Ce programme cre trois boutons et attache chacun dentre eux une mthode de
la classe MaFenetre. Le constructeur de la classe prend comme unique paramtre un
pointeur sur un objet qui peut tre la fentre principale, un objet de type Frame ou
Toplevel. Cette construction permet de considrer cet ensemble de trois boutons
comme un objet part entire ; de ce fait il peut tre insr plusieurs fois comme le
montre lexemple suivant illustr par la figure 8.21.
root = Tk.Tk ()
f = Tk.Frame ()
f.pack ()
MaFenetre (f) # premire instance
g = Tk.Frame ()
g.pack ()
MaFenetre (g) # seconde instance
root.mainloop ()
Figure 8.21 : Aspect de la classe MaFenetre dfinie

au paragraphe 8.6.3. La fentre est en fait compose de
deux instances de MaFenetre.
8.6.4 Squence dvnements

Il est facile de faire ragir le programme en fonction dun vnement, il suffit dat-
tacher cet vnement une mthode ou une fonction. En revanche, faire ragir le
programme en fonction dune squence dvnements est plus complexe. En effet, le
premier dvnement de la squence active une fonction, il nest pas possible dat-
tendre le second vnement dans cette mme fonction, ce dernier ne sera observable
que si on sort de cette premire fonction pour revenir la fonction mainloop, la seule
capable de saisir le prochain vnement.
La figure 8.22 prcise la gestion des messages. Tkinter se charge de la rception
des messages puis de lappel au traitement correspondant indiqu par la mthode
ou la fonction attache lvnement. Le programmeur peut dfinir les traitements
associs chaque vnement. Ces deux parties sont scindes et moins de repro-
grammer sa boucle de message, il nest pas vident de consulter les vnements
intervenus depuis le dbut du traitement de lun deux.
Figure 8.22 : La rception des vnements est assure

par la fonction mainloop qui consiste attendre le pre-
mier vnement puis appeler la fonction ou la mthode
qui lui est associe si elle existe.
Les classes offrent un moyen simple de grer les squences dvnements au sein dune
fentre. Celle-ci fera lobjet dune classe qui mmorise les squences dvnements.
Tous les vnements feront appel des mthodes diffrentes, chacune delles ajoutera
lvnement une liste. Aprs cette ajout, une autre mthode sera appele pour
rechercher une squence dvnements particulire. Le rsultat est galement illustr
par la figure 8.23.
# coding: latin-1
import Tkinter as Tk
class MaFenetreSeq :
def __init__ (self, win) :
self.win = win
self.creation ()
self.sequence = []
def creation (self) :

b3 = Tk.Button (self.win, text="remise zro", command=self.zero)
self.lab = Tk.Label (self.win, text = "-")

# ajoute 1 la liste self.sequence
self.sequence.append (1)
self.controle ()

# ajoute 2 la liste self.sequence
self.sequence.append (2)
self.controle ()
def zero (self) :

# on vide la liste self.sequence
self.sequence = []
self.lab.grid_forget ()
def controle (self) :

# on compare la liste sequence [1,2,1] et [2,2,1,1]
# dans ce cas, on fait apparatre lobjet lab
l = len (self.sequence)
if l >= 3 and self.sequence [l-3:] == [1,2,1] :
self.lab.configure (text = "squence 1 2 1")
elif l >= 4 and self.sequence [l-4:] == [2,2,1,1] :
self.lab.configure (text = "squence 2 2 1 1")
if __name__ == "__main__" :
root = Tk.Tk ()
f = MaFenetreSeq (root)
root.mainloop ()
Figure 8.23 : Aspect de la classe MaFenetreSeq dfi-

nie au paragraphe 8.6.4.
8.6.5 Communiquer un rsultat par message

Le module Tkinter permet de dfinir ses propres messages qui peuvent servir
communiquer des informations. Une fonction est par exemple appele lorsquun
bouton est press. Celle-ci, une fois termine, retourne son rsultat sous forme de
message envoy linterface graphique. Ce message sera ensuite trait comme tout
autre message et pourra tre intercept ou non.
Le programme suivant utilise ce concept. La pression dun bouton appelle une fonc-
tion event_generate qui gnre un message personnalis <<perso>> avec comme
paramtre rooty = 5. A son tour, celui-ci est attrap et dirig vers la fonction
perso qui affiche lattribut y_root de la classe Event qui a reu la valeur 5 lors
de lappel de la fonction event_generate. Ce procd ne permet toutefois que de
renvoyer que quelques rsultats entiers.
# coding: latin-1
import Tkinter
def affiche_touche_pressee () : root.event_generate ("<<perso>>", rooty = -5)
def perso (evt) : print "perso", evt.y_root
b = Tkinter.Button (text = "clic", \
command = affiche_touche_pressee)
b.pack ()
root.bind ("<<perso>>", perso) # on intercepte un vnement personnalis
root.mainloop ()
Ce principe est plus utilis lorsque linterface graphique est couple avec les threads,
lensemble est prsent au paragraphe 9.3.
Chapitre 9
Threads
Jusquaux annes 2003-2004, lvolution des microprocesseurs tait une course vers
une augmentation de la puissance, autant en terme de nombre de transistors quen
frquence de fonctionnement. Arrivant aux limites de la technologie actuelle, cette
volution sest tourne maintenant vers la construction de processeurs multicurs,
cest--dire des machines capables dexcuter des programmes simultanment, de
maintenir plusieurs fils dexcution en parallle.
Les threads ou fils dexcution ont trois usages principaux. Le premier est reli au
calcul distribu ou calcul parallle. Par exemple, le calcul dune intgrale sur un
intervalle peut tre effectu sur deux intervalles disjoints. Le rsultat final est la
somme des deux rsultats sur chacun des intervalles. De plus, ces deux calculs sont
indpendants et peuvent tre mens de front. Le calcul intgral sera donc deux
fois plus rapide puisque les deux intervalles seront traits en mme temps. Cest la
paralllisation des calculs : les deux calculs sur chaque intervalle seront affects
deux threads simultans.
Le second usage est coupl aux interfaces graphiques. Lorsque lutilisateur entame
un processus long aprs avoir cliqu sur un bouton, linterface graphique ne ragit
plus jusqu ce que ce processus sachve. Afin dviter cet inconvnient, linterface
graphique va commencer un thread qui va excuter ce processus. Linterface gra-
phique na plus qu attendre la fin du thread, et pendant tout ce temps, elle sera
galement capable de traiter tout autre vnement provenant de lutilisateur.
Le dernier usage concerne la communication entre ordinateurs ou plus gnralement
la communication Internet. Cest une communication asynchrone : lordinateur ef-
fectue des tches en mme temps quil coute un port par lequel dautres ordinateurs
communiquent avec lui. Plus prcisment, le programme suit deux fils dexcution :
le fil principal et un thread qui ne fait quattendre et traiter les messages quil reoit
via un port.
La synchronisation est un point commun ces trois usages. Ce terme dsigne la
dpendance entre les threads. Lors dun calcul distribu, le rsultat final dpend
des rsultats retourns par chaque thread, il faut donc attendre que les deux fils
dexcution aient produit le rsultat attendu : il faut que les deux fils dexcution
se synchronisent.
Ce document ne stendra pas longuement sur les threads bien quils soient amens
devenir un lment incontournable de tout programme dsirant tirer parti des
derniers processeurs.
9.1 Premier thread

Le premier exemple consiste excuter un thread uniquement destin faire des
affichages. Deux fils dexcution vont tre lancs en parallle affichant chacun un
message diffrent. Les affichages vont sentremler. Il existe plusieurs manires dex-
cuter un thread, une seule sera prsente en utilisant la classe Thread du module
threading. Pour crer un thread, il suffit de surcharger la mthode run de la classe
Thread. Si le thread a besoin de donnes lors de son excution, il faut surcharger son
constructeur sans oublier dappeler le constructeur de la classe mre. Lexcution de
thread commence par la cration dune instance et lappel la mthode start. En
rsum, il faut retenir les lments suivants :
1. surcharger la classe threading.Thread,
2. surcharger le constructeur sans oublier dappeler le constructeur
threading.Thread.__init__,
3. surcharger la mthode run, cest le code que devra excuter le thread,
4. crer une instance de la nouvelle classe et appeler la mthode start pour lancer le
thread secondaire qui formera le second fil dexcution.
Le programme principal est appel le thread principal. Voici ce que cela donne dans
un exemple :
# coding: cp1252
import threading, time
class MonThread (threading.Thread) :

def __init__ (self, jusqua) : # jusqua = donne supplmentaire
threading.Thread.__init__(self)# ne pas oublier cette ligne
# (appel au constructeur de la classe mre)
self.jusqua = jusqua # donne supplmentaire ajoute la classe
def run (self) :

for i in range (0, self.jusqua) :
print "thread ", i
time.sleep (0.1) # attend 100 millisecondes sans rien faire
# facilite la lecture de laffichage
m = MonThread (1000) # cre le thread

m.start () # dmarre le thread,
# linstruction est excute en quelques millisecondes
# quelque soit la dure du thread

print "programme ", i
time.sleep (0.1) # attend 100 millisecondes sans rien faire
# facilite la lecture de laffichage
Le programme affiche des lignes qui proviennent du thread principal et du thread

secondaire dont les affichages diffrent.
programme 0
thread 0
thread 1
programme 1
thread 2
9. Threads 227
programme 2
programme 3
thread 3
programme 4
thread 4
...
Le prcdent programme a t adapt pour lancer deux threads secondaires en plus

du thread principal. Les lignes modifies par rapport au programme prcdent sont
commentes.
# coding: cp1252

def __init__ (self, jusqua, s) :
threading.Thread.__init__ (self)
self.jusqua = jusqua
self.s = s
def run (self) :

print "thread ", self.s, " : ", i
time.sleep (0.1)
m = MonThread (1000, "A")

m.start ()
m2 = MonThread (1000, "B") # cre un second thread

m2.start () # dmarre le thread,

print "programme ", i
time.sleep (0.1)
thread A : 0 Remarque 9.1 : utilisation le la fonction sleep

programme 0 Tous les exemples prsents dans ce chapitre font souvent
thread B : 0 intervenir linstruction time.sleep(...). A moins que ce ne
thread A : 1
soit explicitement prcis, elle sert la plupart du temps
thread B : 1
programme 1 ralentir lexcution du programme cit en exemple afin
thread B : 2 que celle-ci soit humainement observable ou pour exa-
thread A : 2 grer un dfaut de synchronisation. Cette fonction est
... dordinaire beaucoup moins frquente.
9.2 Synchronisation
9.2.1 Attente
La premire situation dans laquelle on a besoin de synchroniser deux threads est
lattente dun thread secondaire par le thread principal. Et pour ce faire, on a besoin
de laccs par les deux fils dexcution une mme variable qui indiquera ltat du
thread. Dans le programme suivant, on ajoute lattribut etat la classe MonThread
qui va indiquer ltat du thread :
True pour en marche

False pour larrt
Le thread principal va simplement vrifier ltat du thread de temps en temps. Le
premier point important est tout dabord dattendre que le thread se lance car sans
la premire boucle, le thread pourrait passer ltat True aprs tre pass dans la
seconde boucle dattente. Le second point important est de ne pas oublier dinsrer la
fonction sleep du module time afin de permettre au thread principal de temporiser.
Dans le cas contraire, le thread principal passe lessentiel de son temps vrifier ltat
du thread secondaire, ce faisant, il ralentit lordinateur par la rptition inutile de
la mme action un trop grand nombre de fois. Ici, le thread principal vrifie ltat
du thread secondaire tous les 100 millisecondes. Cette dure dpend de ce que fait
le thread secondaire.
# coding: latin-1

def __init__ (self, jusqua) :
self.etat = False # ltat du thread est soit False ( larrt)
# soit True (en marche)
def run (self) :

self.etat = True # on passe en mode marche
print "thread itration ", i
time.sleep (0.1)
self.etat = False # on revient en mode arrt
m = MonThread (10) # cre un thread

print "dbut"
while m.etat == False :

# on attend que le thread dmarre
time.sleep (0.1) # voir remarque ci-dessous
while m.etat == True :

# on attend que le thread sarrte
# il faut introduire linstruction time.sleep pour temporiser, il nest pas
# ncessaire de vrifier sans cesse que le thread est toujours en marche
# il suffit de le vrifier tous les 100 millisecondes
# dans le cas contraire, la machine passe son temps vrifier au lieu
# de se consacrer lexcution du thread
time.sleep (0.1)
print "fin"
Ce mcanisme dattente peut galement tre cod en utilisation les objets Condition
et Event du module threading. Ces deux objets permettent dviter lutilisation de
la mthode sleep.
# coding: latin-1
9. Threads 229

def __init__ (self, jusqua, event) : # event = objet Event
threading.Thread.__init__ (self) # = donne supplmentaire
self.event = event # on garde un accs lobjet Event
def run (self) :

print "thread itration ", i
time.sleep (0.1)
self.event.set () # on indique quon a fini :
# on active lobject self.event
print "dbut"
event = threading.Event () # on cre un objet de type Event

event.clear () # on dsactive lojet Event
m = MonThread (10, event) # cre un thread
event.wait () # on attend jusqu ce que lobjet soit activ
# event.wait (0.1) : nattend quun
print "fin" # seulement 1 dizime de seconde
La mthode wait de lobjet Event attend que lobjet soit activ. Elle peut attendre
indfiniment ou attendre pendant une dure donne seulement. Pour afficher la dure
dattente, on pourrait utiliser une boucle comme la suivante :
m.start () La mthode isSet permet de savoir si lvnement est

while not event.isSet (): bloquant ou non. Le programme affiche j0 attends
print "jattends" puis attend le thread un dixime de secondes. Au del
event.wait (0.1) de cette dure, il vrifie ltat de lvnement puis re-
print "fin"
commence si le thread nest pas fini.
Ces objets de synchronisation sont plus efficaces que le mcanisme dcrit dans le
premier programme car il fait appel aux fonctions du systme dexploitation.
9.2.2 Partage dinformations

La seconde situation dans laquelle on a besoin de synchroniser est laccs par deux
fils dexcution aux mmes informations ou plutt aux mmes variables. Un pro-
blme survient quand parfois un thread lit ou modifie en mme temps quun autre
modifie la mme variable. Le second cas de synchronisation est lajout de verrous
qui permettent de protger une partie du code dun programme contre plusieurs
accs simultans. Ce verrou est galement un objet du module threading.
Dans cet exemple, linformation partage est la chane de caractres message, le
verrou sert protger la fonction ajoute contre des ajouts simultans. Si les deux
threads veulent modifier message en mme temps, un thread va entrer dans la fonc-
tion ajoute alors que lautre nen est pas encore sorti. Les rsultats seraient impr-
visibles car cette fonction modifie la variable quils utilisent. On aboutit lexemple
suivant :
# coding: latin-1
message = ""
verrou = threading.Lock ()
def ajoute (c) :

global message # message et verrou sont des variables gloables
global verrou # pour ne pas quelle disparaisse ds la fin de la fonction
verrou.acquire () # on protge ce qui suit (*)
s = message + c # instructions jamais excute simultanment par 2 threads

time.sleep (0.001) # time.sleep : pour exagrer le dfaut de synchronisation
message = s # si verrou nest pas utilis
verrou.release () # on quitte la section protge (*)

def __init__ (self, jusqua, event, s) :
self.s = s
self.event = event
def run (self) :

ajoute (self.s)
time.sleep (0.003)
self.event.set ()
print "dbut"
# synchronisation attente
e1 = threading.Event ()
e1.clear ()
e2.clear ()
m1 = MonThread (10, e1, "1") # cre un thread

m1.start () # dmarre le thread,
m2 = MonThread (10, e2, "2") # cre un second thread
m2.start () # dmarre le second thread,
e1.wait ()
e2.wait ()
print "longueur ", len(message) # affiche 20

print "message = ", message # affiche quelque chose comme 12212112211212121221
Les trois instructions protges pourraient tre rsumes en une seule : message
+= c ; le rsultat resterait inchang. En revanche, en commentant les instructions
verrou.acquire() et verrou.release() de ce programme 1 , la longueur du rsultat final
message est variable alors quelle devrait tre de 20 puisque les deux threads appellent
chacun 10 fois dans la fonction ajoute. Le tableau suivant montre lvolution des
variables message, c, s durant deux premiers appels qui sentremlent. Le rsultat
devrait tre 12 pour message mais un caractre a t perdu. Il faut retenir que si
1. Celles marques dune toile ().
9. Threads 231
la variable message est globale, les deux autres c, s sont locales et donc diffrentes
pour les deux threads.
ordre thread 1 thread 2 message c s

1 s = message + c 1 1
3 time.sleep(0.001) 1 1
4 time.sleep(0.001) 2 2
5 message = s 1 1 1
6 message = s 2 2 2
Le verrou empche dexcuter une mme portion de code en mme temps, un code
qui modifie des donnes partages. Cest pourquoi le verrou est souvent dclar au
mme endroit que les donnes quil protge. Le verrou de type Lock nautorise quun
seul thread la fois lintrieur de la portion de code protge ce qui aboutit au
schma suivant :
ordre thread 1 thread 2 message c s

2 time.sleep(0.001) 1 1
3 message = s 1 1 1
4 s = message + c 1 2 12
5 time.sleep(0.001) 1 2 12
6 message = s 12 2 12
Remarque 9.2 : rduction des accs quelques threads

Le verrou de type Semaphore autorise un nombre maximal de thread parcourir le
mme code. Ce procd est parfois utile si le code en question permet dimprimer un
document. Cela permet de limiter sans interdire les accs simultans aux ressources
de lordinateur.
Remarque 9.3 : blocage dun programme
Ce mcanisme de verrou peut aboutir des blocages avec deux threads et deux
portions de code protges. Chaque thread est "coinc" dans une section attendant
que lautre libre la sienne. Dans ce cas de figure, il est conseill dutiliser le mme
verrou pour protger les deux sections. Ainsi, chaque thread ne pourra pas entrer
dans lune ou lautre des portions de code protges tant que lune dentre elles est
visite par lautre thread.
9.3 Interface graphique

Un programme bti autour dune interface graphique inclut ncessairement une
boucle de message. Celle-ci attend les messages en provenance de linterface. Lors-
quun de ceux-ci lui commande de lancer un traitement long, linterface graphique
nest plus en mesure de ragir aux vnements qui lui viennent pendant ce temps.
Afin de remdier cela, il suffit dinsrer le traitement dans un thread. A la fin de ce
dernier, un vnement sera envoy linterface afin de lui signifier la fin du traite-
ment.
Le paragraphe 8.4.4 a montr comment associer un vnement particulier une

fentre. La diffrence ici est que lvnement accroch la fentre nest pas pr-
dfini par le module Tkinter mais par le programme lui-mme - dans cet exemple
<<thread_fini>> 2 -. La mthode event_generate permet dinsrer un message
dans la boucle de messages de faon ce que celui-ci soit trait au mme titre quun
clic de souris, la pression dune touche, ...
# coding: latin-1
import threading, time, random, copy
# dfinition du thread
def __init__ (self, win, res) :
self.win = win # on mmorise une rfrence sur la fentre
self.res = res
def run (self) :

for i in range (0, 10) :
print "thread ", i
time.sleep (0.1)
# afin que le thread retourne un rsultat

# self.res dsigne thread_resultat qui reoit un nombre de plus
h = random.randint (0,100)
self.res.append (h)
# on lance un vnement <<thread_fini>> la fentre principale

# pour lui dire que le thread est fini, lvnement est ensuite
# gr par la boucle principale de messages
# on peut transmettre galement le rsultat lors de lenvoi du message
# en utilisant un attribut de la classe Event pour son propre compte
self.win.event_generate ("<<thread_fini>>", x = h)
thread_resultat = []
def lance_thread () :
global thread_resultat
# fonction appele lors de la pression du bouton
# on change la lgnde de la zone de texte
text .config (text = "thread dmarr")
text2.config (text = "thread dmarr")
# on dsactive le bouton pour viter de lancer deux threads en mme temps
bouton.config (state = TK.DISABLED)
# on lance le thread
m = MonThread (root, thread_resultat)
m.start ()
def thread_fini_fonction (e) :

global thread_resultat
# fonction appele lorsque le thread est fini
print "la fentre sait que le thread est fini"
# on change la lgende de la zone de texte
text .config (text = "thread fini + rsultat " + str (thread_resultat))
text2.config (text = "thread fini + rsultat (e.x) " + str (e.x))
# on ractive le bouton de faon pouvoir lancer un autre thread
bouton.config (state = TK.NORMAL)
2. Les symboles << et >> au dbut et la fin du nom de lvnement sont la seule contrainte.
9. Threads 233
import Tkinter as TK
# on cre la fentre
root = TK.Tk ()
bouton = TK.Button (root, text = "thread dpart", command = lance_thread)
text = TK.Label (root, text = "rien")
text2 = TK.Label (root, text = "rien")
bouton.pack ()
text.pack ()
text2.pack ()
# on associe une fonction un vnement <<thread_fini>> propre au programme

root.bind ("<<thread_fini>>", thread_fini_fonction)
# on active la boucle principale de message

root.mainloop ()
La figure 9.1 contient la fentre affiche par le programme lorsquelle attend la

pression du bouton qui lance le thread et lorsquelle attend la fin de lexcution de
ce thread.
Remarque 9.4 : mthode event_generate
Le programme prcdent utilise une astuce pour retourner un rsultat autrement
quun utilisant un paramtre global. On peut adjoindre lors de lappel la mthode
event_generate quelques informations supplmentaires attaches lvnement en
utilisant les attributs prdfinis de la classe Event. Dans cet exemple, on utilise
lattribut x pour retourner le dernier entier tir alatoirement.
Figure 9.1 : La premire image est la fe-

ntre aprs trois excutions du thread. La liste
thread_resultat contient trois nombres. Une fois
lunique bouton press, la fentre change daspect
pour devenir comme la seconde image. Cette transi-
tion est assure par la fonction lance_thread re-
lie au bouton. La transition inverse est assure par
la fonction thread_fini_fonction qui est relie
lvnement que gnre le thread lorsquil a termin.
9.4 Files de messages

Les trois usages principaux des threads sont le calcul distribu, la conception
dune interface graphique ractive et lattente permanente dvnements. En ce qui
concernent les deux premiers usages, on peut considrer quil existe un thread prin-
cipal qui lance et attend lexcution de threads secondaires. Les changes dinforma-
tions ont lieu au dbut et la fin de chaque thread. Il nest pas toujours ncessaire
de partager des variables en cours dexcution : lusage de verrous est peu frquent
pour ces deux schmas sauf pour partager des informations en cours dexcution.
En ce qui concerne le troisime usage, cest un cas o tout au long du programme, il
y a constamment au moins deux threads actifs : un thread principal et un thread qui
attend. Dans ce cas, lchange et la synchronisation dinformations est invitable et
il est souvent fastidieux de concevoir la synchronisation. Cest pourquoi on la conoit
presque toujours sous forme de messages que les threads senvoient.
Il existe un objet Queue du module Queue qui facilite cet aspect. Cest une liste qui
possde son propre verrou de sorte que nimporte quel thread peut ajouter ou retirer
des lments de cette liste. Elle est utilise principalement via quatre mthodes. Deux
mthodes get sont utilises au sein du thread qui possde la pile. Deux mthodes
put sont appeles par des threads trangers.
Retourne un lment de la liste ou attend quil y en ait un,

le supprime si elle en trouve un. Si timeout est renseign,
get([timeout = ...])
la fonction attend au plus timeout secondes, sinon, elle
dclenche lexception Queue.Empty.
Retourne un lment de la liste sil y a en un, dans ce
get_nowait() cas, cet lment est supprim. Dans le cas contraire, la
mthode dclenche lexception Queue.Empty.
Ajoute llment e la liste ou attend quune place se li-
bre si la liste est pleine. Si timeout est renseign, la fonc-
put(e[, timeout = ...])
tion attend au plus timeout secondes, sinon, elle dclenche
lexception Queue.Full.
Ajoute llment e la liste ou dclenche lexception
put_nowait(e)
Queue.Full si la liste est pleine.
qsize() Retourne la taille de la pile.
Cette pile est utilise dans lexemple qui suit pour simuler deux joueurs qui es-
saye de dcouvrir le nombre que lautre joueur a tir au hasard. A chaque essai,
un joueur envoie un message de type (essai, n) lautre joueur pour dire quil
joue le nombre n. Ce joueur lui rpond avec des messages de type (dessous, n),
(dessus, n), (gagne, n).
# coding: latin-1
import threading, time, Queue, random
class Joueur (threading.Thread) :
# initialisation
def __init__ (self, nom, e, nb = 1000, temps = 0.1) :
threading.Thread.__init__(self)
self.nb = nb
self.queue = Queue.Queue ()
self.nom = nom
self.event = e
self.temps = temps # temps de rflexion
def Joueur (self, autre_joueur) : self.autre = autre_joueur
9. Threads 235
# mthodes : ladversaire menvoie un message

def Joue (self, nombre) : self.queue.put_nowait ( ("essai", nombre) )
def Dessus (self, nombre) : self.queue.put_nowait ( ("dessus", nombre) )
def Dessous (self, nombre) : self.queue.put_nowait ( ("dessous", nombre) )
def Gagne (self, nombre) :
while not self.queue.empty () :
try :self.queue.get ()
except : pass
self.queue.put ( ("gagne", nombre) )
# je joue
def run (self) :
x = random.randint (0,self.nb)
print self.nom, " : je joue (", x, ")"
i = 0
a = 0
b = self.nb
while True :
time.sleep (self.temps)
try :
m,n = self.queue.get_nowait () # dsynchronis
#m,n = self.queue.get (timeout = 0.5)# lun aprs lautre
except Queue.Empty : m,n = None,None
# traitement du message --> rponse ladversaire

if m == "essai" :
if n == x :
self.autre.Gagne (n)
print self.nom, " : jai perdu aprs ", i, " essais"
break
elif n < x : self.autre.Dessus (n)
else : self.autre.Dessous (n)
elif m == "dessus" :
a = max (a, n+1)
continue # assure lquit en mode lun aprs lautre
elif m == "dessous" :
b = min (b, n-1)
continue # assure lquit en mode lun aprs lautre
elif m == "gagne" :
print self.nom, " : jai gagn en ", i, " essais, solution ", n
break
# on fait une tentative

if a == b : n = a
else : n = random.randint (a,b)
self.autre.Joue (n)
i += 1
print self.nom, " : je tente ", n, " cart ", b-a, \
" traiter ", self.queue.qsize ()
# fini
print self.nom, " : jarrte"
self.event.set ()
# on cre des verrous pour attendre la fin de la partie

e1.clear ()
e2.clear ()
# cration des joueurs

A = Joueur ("A", e1, 1000, temps = 0.1)
B = Joueur ("B", e2, 1000, temps = 0.3)
# chaque joueur sait qui est lautre

A.Joueur (B)
B.Joueur (A)
# le jeu commence
A.start ()
B.start ()
# on attend la fin de la partie

e1.wait ()
e2.wait ()
Si la mthode get est choisie, les joueurs doivent attendre une tentative de ladver-
saire avant de proposer la leur. Dans lautre cas, la mthode get_nowait permet de
ne pas attendre sa rponse et denvoyer plusieurs propositions ladversaire qui ne
rpondra pas plus vite pour autant. Dans cette configuration, le joueur A est trois
fois plus ractif ce qui explique les rsultats qui suivent.
A : je joue ( 8 )
B : je joue ( 569 )
A : je tente 42 cart 1000 traiter 0
...
B : je tente 20 cart 43 traiter 57
B : je tente 8 cart 43 traiter 59
A : jai perdu aprs 67 essais
A : jarrte
B : jai gagn en 23 essais, solution 8
B : jarrte
Les affichages se chevauchent parfois, il faudrait pour viter cela synchroniser laffi-
chage laide dun verrou.
Deuxime partie
ENONCS PRATIQUES, EXERCICES
Cette partie regroupe quelques noncs que les lves de lENSAE ont tudi ou
partir desquels ils ont t valus entre les annes 2005 et 2008. On retient sou-
vent que le boulot dun informaticien nest pas compliqu, quil est plutt plutt
ennuyeux et redondant. On oublie parfois que sans linformatique, certaines tches
seraient tout autant longues et fastidieuses. Cette partie prsente certaines tournures
desprits qui permettent de gagner du temps lors de la conception de programmes et
peut-tre derendre la programmation moins rptitive, le travail moins fastidieux.
Les premiers noncs illustrent quelques schmas rcurrents de programmation. Les
langages de programmation qui ncessitent de reprogrammer un tri sont trs rares,
la plupart proposent des fonctions qui excutent un tri rapide - ou quicksort -. Mais
connatre certains algorithmes classiques permet de programmer plus rapidement
quavec la seule connaissance des principes de base - boucle, test -. A linstar de
certains jeux de rflexion - les ouvertures avec les checs -, il nest pas ncessaire de
rinventer certains algorithmes ou raisonnements frquemment utiliss.
Cette partie se termine par trois annes dnoncs dexamens dinformatique. Les
exercices proposs illustrent parfois le ct ennuyeux dun programme informatique :
sa mise en uvre dpasse souvent de loin sa conception. La correction des erreurs ou
bugs est la partie la plus longue et la plus rbarbative. Ces exercices ont pour objectif
dacclrer cette tape en proposant des situations qui reviennent frquemment.
Cest aussi pour cela que lors dentretiens dembauche, des exercices similaires sont
prsents aux candidats pour vrifier leur exprience en programmation.
Chapitre 10
Exercices pratiques pour sentraner
10.1 Montant numrique, montant littral

Lobjectif de cet exercice est dcrire un programme qui convertit en entier un
nombre crit sous forme littrale. On suppose que tous les nombres sont crits en
minuscules et correctement orthographis. Cet exercice tourne autour des manipu-
lations de chanes de caractres et principalement les deux fonctions suivantes :
Fonctions utiles :
A lintrieur de la chane s, remplace toutes les occurrences
de la chane old par la chane new. Pour lutiliser, il faut
replace(s, old, new) ajouter au dbut du programme la ligne import string
puis crire l = string . replace (dix neuf, , ),
par exemple.
Retourne une liste contenant tous les mots de la chane
de caractres s. Si le paramtre facultatif sep est rensei-
gn, cest cette chane qui fait office de sparateur entre
split(s[, sep])
mot et non les espaces. Pour lutiliser, il faut ajouter au
dbut du programme la ligne import string puis crire
l = string . split (vingt et un, ), par exemple.
Lappel la fonction replace peut se faire en la considrant comme une mthode

de la classe str ou une fonction du module string.
import string
s = "dix-neuf"
l = s.replace ("-", " ")

l = string.replace ("-", " ")
1) Ecrire une fonction qui prend un nombre littral et retourne une liste contenant
tous ses mots.
2) Ecrire une fonction qui reoit une chane de caractres correspondant un nombre
compris entre 0 et 16 inclus ou un nombre parmi 20, 30, 40, 50, 60. La fonction
doit retourner un entier correspondant sa valeur.
3) A laide de la fonction prcdente, crire une fonction qui reoit une chane de
caractres contenant un nombre compris entre 0 et 99 inclus et qui retourne sa
valeur.
10. Exercices pratiques pour sentraner 239
4) Pour vrifier que la fonction prcdente marche bien dans tous les cas, crire
une fonction qui crit un nombre sous sa forme littrale puis vrifier que ces deux
fonctions marchent correctement pour les nombres compris entre 0 et 99.
Correction
A chaque question correspond une fonction utilisant celles dcrites dans les questions
prcdentes. Le programme complet est obtenu en juxtaposant chaque morceau.
1)
# coding: latin-1
def lire_separation(s):
"""divise un nombre littral en mots"""
s = s.replace ("-", " ") # on remplace les tirets par des espaces
# pour dcouper en mots mme
# les mots composs
return s.split ()
On pourrait crire cette fonction en utilisant les expressions rgulires en utilisant

les expressions rgulires (voir split dcrite au paragraphe 7.6.3). page 188.
import re
def lire_separation(s):
"""divise un nombre littral en mots avec les expressions rgulires"""
return re.compile ("[- ]").split (s)
2) Il nexiste pas quune seule manire de rdiger cette fonction. La premire, la plus
simple, est sans doute la suivante :
def valeur_mot (s) :
"""convertit numriquement les nombres inclus entre 0 et 16 inclus,
20, 30, 40, 50, 60, s est une chane de caractres, le rsultat est entier"""
if s == "zro" : return 0
elif s == "un" : return 1
elif s == "deux" : return 2
elif s == "trois" : return 3
elif s == "quatre" : return 4
elif s == "cinq" : return 5
elif s == "six" : return 6
elif s == "sept" : return 7
elif s == "huit" : return 8
elif s == "neuf" : return 9
elif s == "dix" : return 10
elif s == "onze" : return 11
elif s == "douze" : return 12
elif s == "treize" : return 13
elif s == "quatorze" : return 14
elif s == "quinze" : return 15
elif s == "seize" : return 16
elif s == "vingt" : return 20
elif s == "trente" : return 30
elif s == "quarante" : return 40
elif s == "cinquante" : return 50
elif s == "soixante" : return 60
else : return 0 # ce cas ne doit normalement pas
# se produire
240 II. Enoncs pratiques, exercices
La solution suivante utilise un dictionnaire. Cette criture peut viter un copier-

coller long pour la dernire question.
def valeur_mot (s) :
dico = {cinquante: 50, quarante: 40, onze: 11, huit: 8, six: 6, \
quinze: 15, trente: 30, douze: 12, cinq: 5, deux: 2, \
quatorze: 14, neuf: 9, soixante: 60, quatre: 4, \
zro: 0, treize: 13, trois: 3, seize: 16, \
vingt: 20, un: 1, dix: 10, sept: 7}
if s not in dico : return 0 # cas imprvu, on peut rsumer ces deux lignes
else : return dico [s] # par return dico.get (s, 0)
3) La rponse cette question est divise en deux fonctions. La premire traduit

une liste de mots en un nombre numrique. Ce nombre est la somme des valeurs
retournes par la fonction valeur_mot pour chacun des mots : soixante dix neuf =
60 + 10 + 9. Cette rgle sapplique la plupart du temps sauf pour quatre vingt.
def lire_dizaine_liste(s):
"""convertit une liste de chanes de caractres dont
juxtaposition forme un nombre littral compris entre 0 et 99"""
r = 0 # contient le rsultat final
dizaine = False # a-t-on termin le traitement des dizaines ?
for mot in s:
n = lire_unite (mot)
if n == 20 :
if not dizaine and r > 0 and r != 60 :
r *= n # cas 80
dizaine = True
else : r += n
else : r += n
return r
La seconde fonction remplace tous les traits dunion par des espaces puis divise un
nombre littral en liste de mots spars par des espaces.
def lire_dizaine(s):
li = lire_separation (s)
return lire_dizaine_liste (li)
4) Tout dabord, les deux fonctions rciproques de celles prsentes ci-dessus.
def ecrit_unite (x):

"""convertit un nombre compris inclus entre 0 et 16 inclus,
20, 30, 40, 50, 60 en une chane de caractres"""
if x == 0: return "zro"
elif x == 1: return "un"
elif x == 2: return "deux"
elif x == 3: return "trois"
elif x == 4: return "quatre"
elif x == 5: return "cinq"
elif x == 6: return "six"
elif x == 7: return "sept"
elif x == 8: return "huit"
elif x == 9: return "neuf"
elif x == 10: return "dix"
elif x == 11: return "onze"
elif x == 12: return "douze"

elif x == 13: return "treize"
elif x == 14: return "quatorze"
elif x == 15: return "quinze"
elif x == 16: return "seize"
elif x == 20: return "vingt"
elif x == 30: return "trente"
elif x == 40: return "quarante"
elif x == 50: return "cinquante"
elif x == 60: return "soixante"
elif x == 70: return "soixante-dix"
elif x == 80: return "quatre-vingt"
elif x == 90: return "quatre-vingt-dix"
else : return "zro"
Cette fonction pourrait tre simplifie en utilisant le mme dictionnaire que pour la
fonction valeur_mot mais invers : la valeur devient la cl et rciproquement.
def mot_valeur (x):

"""convertit un nombre compris inclus entre 0 et 16 inclus,
20, 30, 40, 50, 60 en une chane de caractres"""
dico = {cinquante: 50, quarante: 40, onze: 11, huit: 8, six: 6, \
quinze: 15, trente: 30, douze: 12, cinq: 5, deux: 2, \
quatorze: 14, neuf: 9, soixante: 60, quatre: 4, \
zro: 0, treize: 13, trois: 3, seize: 16, \
vingt: 20, un: 1, dix: 10, sept: 7}
inv = {}
for k,v in dico.iteritems () : inv [v] = k
inv [70] = "soixante-dix"
inv [80] = "quatre-vingt"
inv [90] = "quatre-vingt-dix"
return inv [x]
Le programme continue avec lune ou lautre des fonctions prcdente. La fonction

suivante construit le montant littral pour un nombre deux chiffres. Elle traite le
chiffre des dizaines puis des units.
def ecrit_dizaine(x):
"""convertit un nombre entre 0 et 99 sous sa forme littrale"""
if x <= 16 : return ecrit_unite(x)
s = ""
dizaine = x / 10
unite = x % 10
s = mot_valeur (dizaine*10)
s += " "
s += mot_valeur (unite)
return s
Le morceau de code ci-dessous permet de vrifier que le passage dun nombre sous
sa forme littrale et rciproquement fonctionne correctement pour tous les nombres
compris entre 0 et 99 inclus.
for i in xrange(0,100):
s = ecrit_dizaine (i)
j = lire_dizaine (s)
if i != j : print "erreur ", i, " != ", j, " : ", s
10.2 Reprsentation des donnes, partie de dames

Une partie de dames met en jeu quarante pions, vingt noirs, vingt blancs, chacun sur
des cases diffrentes. Lobjectif est de savoir si un pion est en mesure den prendre
un autre. On ne traitera pas le cas des dames. Chaque pion est dfini par :
deux coordonnes entires, chacune comprise entre 1 et 10
une couleur, noir ou blanc
1) On propose deux reprsentations de lensemble de pions :
1. Un tableau de 40 pions indics de 0 39 inclus, chaque pion tant dfini par :
deux coordonnes comprises entre 1 et 10, ou (0,0) si le pion nest plus sur le damier
un entier qui vaut 1 pour blanc, 2 pour noir
2. Un tableau dentiers deux dimensions, chaque case contient :
soit 0 sil ny a pas de pion
soit 1 si la case contient un pion blanc
soit 2 si la case contient un pion noir
Y a-t-il dautres reprsentations de ces informations ? Si on considre que lefficacit
dune mthode est relie sa vitesse - autrement dit aux cots des algorithmes
quelles utilisent -, parmi ces deux reprsentations, quelle est celle qui semble la
plus efficace pour savoir si un pion donn du damier est en mesure den prendre un
autre ?
2) Comment reprsenter un tableau dentiers deux dimensions en langage Python
laide des types standards quil propose, savoir t-uple, liste ou dictionnaire ?
3) On cherche crire lalgorithme qui permet de savoir si un pion donn est un
mesure de prendre un pion. Quels sont les paramtres dentres et les rsultats de
cet algorithme ?
4) Il ne reste plus qu crire cet algorithme.
Correction
1) La seconde reprsentation sous forme de tableau deux dimensions est plus pra-
tique pour effectuer les tests de voisinages. Chaque case a quatre voisines aux quatre
coins, il est ensuite facile de dterminer si ces quatre voisines sont libres ou si elles
contiennent un pion. On sait rapidement le contenu dune case.
Avec la premire reprsentation - le tableau des pions - pour savoir sil existe un
pion dans une case voisine, il faut passer en revue tous les pions pour savoir si lun
deux occupe ou non cette case. Avec la seconde reprsentation - le tableau deux
dimensions - on accde directement cette information sans avoir la rechercher.
On vite une boucle sur les pions avec la seconde reprsentation.
2) Pour reprsenter le tableau en deux dimensions, il existe trois solutions :
1. Une liste de listes, chaque ligne est reprsente par une liste. Toutes ces listes sont
elles-mmes assembles dans une liste globale.
2. Une seule liste, il suffit de numroter les cases du damier de 0 99, en utilisant comme
indice pour la case (i, j) : k = 10 i + j. Rciproquement, la case dindice k aura pour
coordonnes (k/10, k%10).
3. Un dictionnaire dont la cl est un couple dentiers.
3) On dsire savoir si le pion de la case (i, j) peut en prendre un autre. On sup-

pose que le tableau deux dimensions est une liste de dix listes appele damier.
damier[i][j] est donc la couleur du pion de la case (i, j), savoir 0 si la case est vide,
1 si le pion est blanc, 2 si le pion est noir. Pour ces deux derniers cas, la couleur
des pions de ladversaire sera donc 3 damier[i][j]. Les entres de la fonctions sont
donc les indices i, j et le damier damier. La sortie est une variable boolenne qui
indique la possibilit ou non de prendre. On ne souhaite pas dplacer les pions.
4)
def pion_prendre(i,j,damier):
c = damier [i][j]
if c == 0: return False # case vide, impossible de prendre
c = 3 - c # couleur de ladversaire
if damier [i-1][j-1] == c : # sil y a un pion adverse en haut gauche

if damier [i-2][j-2] == 0 : # si la case daprs en diagonale est vide
return True # on peut prendre
# on rpte ce test pour les trois autres cases

if damier [i-1][j+1] == c and damier [i-2][j+2] == 0: return True
if damier [i+1][j-1] == c and damier [i+2][j-2] == 0: return True
if damier [i+1][j+1] == c and damier [i+2][j+2] == 0: return True
# si tous les tests ont chou, on ne peut pas prendre

return False
Voici une fonction quivalente lorsque le damier est un dictionnaire dont la cl est
un couple dentiers.
c = damier [(i,j)] # ou encore damier [i,j]
# test pour une prise du pion dans les quatre cases voisines
if damier [i-1,j-1] == c and damier [i-2,j-2] == 0: return True
if damier [i-1,j+1] == c and damier [i-2,j+2] == 0: return True
if damier [i+1,j-1] == c and damier [i+2,j-2] == 0: return True
if damier [i+1,j+1] == c and damier [i+2,j+2] == 0: return True
# si tous les tests ont chou, on ne peut pas prendre

return False
La mme fonction lorsque le damier est reprsent par une seule liste.
c = damier [10*i+j]
# test pour une prise du pion dans les quatre cases voisines
if damier [10*(i-1)+j-1] == c and damier [10*(i-2)+j-2] == 0: return True

if damier [10*(i-1)+j+1] == c and damier [10*(i-2)+j+2] == 0: return True
if damier [10*(i+1)+j-1] == c and damier [10*(i+2)+j-2] == 0: return True
if damier [10*(i+1)+j+1] == c and damier [10*(i+2)+j+2] == 0: return True
return False
Pour ces trois cas, aucun effet de bord na t envisag. Si la case est trop prs dun
des bords, un des indices i, j, i 1, j 1, i + 1, j + 1, i 2, j 2, i + 2, j + 2
dsignera une case hors du damier. Le code de la fonction pion_prendre devra donc
vrifier que chaque case dont elle vrifie le contenu appartient au damier.
c = damier [i][j]
# on rpte ce test pour les trois autres cases

if i >= 2 and j >= 2 and \
damier [i-1][j-1] == c and damier [i-2][j-2] == 0: return True
if i >= 2 and j < len (damier)-2 and \
damier [i-1][j+1] == c and damier [i-2][j+2] == 0: return True
if i < len (damier)-2 and j >= 2 and \

damier [i+1][j-1] == c and damier [i+2][j-2] == 0: return True
if i < len (damier)-2 and j < len (damier)-2 and \
damier [i+1][j+1] == c and damier [i+2][j+2] == 0: return True
return False
Une autre option consiste entourer le damier dun ensemble de cases dont le
contenu sera gal une constante diffrente de 0, 1 par exemple. Dans ce cas, si le
damier est reprsent par une liste de listes, la premire case du damier aura pour
coordonnes (1, 1) au lieu de (0, 0) car les listes nacceptent pas les indices ngatifs.
Ce nest pas le cas lorsque le damier est reprsent par un dictionnaire car une case
peut tout fait avoir pour coordonnes (1, 1).
Avec cette convention, les tests introduits dans le dernier programme ne seront plus
ncessaires. Il faudra juste rcrire la seconde ligne de chaque fonction pion_prendre
par :
if c <= 0 : return False # au lieu de if c == 0 : return False
Remarque 10.1 : matrice et dictionnaire

Les structures reprsentes ici sont des tableaux deux dimensions : ce sont des
matrices. Les dictionnaires sont particulirement indiqus dans le cas o ces matrices
sont creuses : elles contiennent beaucoup de valeurs nulles. Pour une liste ou une
liste de listes, toutes les cases sont reprsentes. Dans le cas dun dictionnaire, il est
possible dadopter comme convention que si un couple de coordonnes nexiste pas
en tant que cl, cela veut dire que la case associe est nulle. Il en rsulte un gain de
place quivalent la proportion de cases nulles.
Remarque 10.2 : dictionnaire et cl de type tuple
Le second exemple utilise un dictionnaire avec comme cl un tuple. Dans ce cas, les
parenthses sont superflues.
damier [(i-1,j-1)] # est quivalent

damier [ i-1,j-1 ] # cette ligne
10.3 Reconnatre la langue dun texte

Lobjectif est de distinguer un texte anglais dun texte franais sans avoir le lire.
Le premier rflexe consisterait chercher la prsence de mots typiquement anglais
ou franais. Cette direction est sans doute un bon choix lorsque le texte considr
est une uvre littraire. Mais sur Internet, les contenus mlangent frquemment
les deux langues : la prsence de tel mot anglais nest plus aussi discriminante. Il
nest plus aussi vident dtiqueter un document de langue anglaise lorsque les mots
anglais sont prsents partout.
On ne cherche plus dterminer la langue dun texte mais plutt la langue majori-
taire. Il serait encore possible de compter les mots de chacune des langues laide
dun dictionnaire rduit de mots anglais et franais. La langue majoritaire corres-
pondrait celle dont les mots sont les plus frquents. Mais construire un dictionnaire
est dabord fastidieux. Ensuite, il faudrait que celui-ci contienne des mots prsents
dans la plupart des textes. Il faudrait aussi tudier le problme des mots communs
aux deux langues.
Pour ces trois raisons, il parat prfrable dtudier une direction plus simple quitte
revenir aux dictionnaires plus tard. Dans un premier temps, on cherchera donc
distinguer un texte anglais dun texte franais partir de la frquence de certaines
lettres dont lusage est diffrent dans les deux langues comme la lettre w.
La premire tape consiste calculer la frquence des lettres dans diffrents textes
anglais et franais quon peut se procurer depuis le site Gutenberg 1 par exemple. Il
suffit alors de tlcharger quelques textes et de les enregistrer dans des fichiers texte.
1) Il faut tout dabord rcuprer dans un programme Python le contenu de ces
textes dont on suppose quils ont t tlchargs. On pourra sinspirer des exemples
du chapitre 7.
2) On veut construire une fonction qui compte loccurrence de chaque lettre dans
une chane de caractres. Cette fonction prend en entre une chane de caractres
et retourne un dictionnaire. Chaque lment contiendra le nombre de fois quun
caractre apparat.
3) Afin dobtenir des probabilits, on divise chaque nombre par le nombre total de
lettres (attention aux divisions entires).
4) Ecrire une fonction qui retourne la probabilit de chaque lettre dans un fichier
texte.
5) En observant les rsultats obtenus sur un texte franais et un texte anglais,
pensez-vous quil soit possible dcrire une fonction qui dtermine automatiquement
la langue dun texte condition que celle-ci soit langlais ou le franais.
Correction
1. http://www.gutenberg.net/
1) La fonction rpondant la premire question revient rgulirement dans beaucoup

de programmes.
def lit_fichier (nom) :
f = open (nom, "r") # ouverture du fichier
l = f.read () # on rcupre le contenu
f.close () # on ferme le fichier
return l # on retourne le contenu
On pourrait galement souhaiter rcuprer un texte directement depuis Internet

condition den connatre ladresse, ce que fait la fonction suivante. La premire
fonction doit recevoir un nom de fichier, la seconde une adresse Internet.
import urllib # import du module urllib
def lit_url (nom) :
f = urllib.urlopen (nom) # on ouvre lurl
res = f.read () # on lit son contenu
f.close () # on termine la lecture
return res # on retourne le rsultat
On peut regrouper ces deux fonctions et appeler soit lune soit lautre selon que le
nom du texte est un fichier texte ou une adresse Internet :
def lit (texte) :

if texte.startswith ("http") : s = lit_url (texte) # Internet
else : s = lit_fichier (texte) # fichier texte
return s
s = lit ("hugo.txt")
Une autre option consiste utiliser les exceptions : on essaye dabord douvrir un
fichier avec la fonction open. Si cela ne fonctionne pas, on peut supposer que le nom
du fichier fait rfrence une adresse Internet.
def lit (texte) :
try :
s = lit_fichier (texte) # fichier texte
return s
except : # si cela ne marche pas,
s = lit_url (texte) # on suppose que texte
return s # est une adresse Internet
s = lit ("hugo.txt")
2) La fonction suivante compte les occurrences de chaque lettre dans la chane de

caractres texte. Une premire solution consiste appeler 26 fois la mthode count
des chanes de caractres.
def compte_lettre_count (texte) :
texte = texte.upper () # pour viter les accents
res = { } # rsultat, vide pour le moment
for c in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" : # pour tout lalphabet
res [c] = texte.count (c) # on compte les occurrences de c
return res
Une autre solution consiste parcourir le texte puis compter les lettres au fur et
mesure quelles apparaissent.
def compte_lettre (texte) :
texte = texte.upper () # pour viter les accents
res = { } # rsultat, vide pour le moment
for c in texte : # pour tous les caractres du texte
if not("A" <= c <= "Z") : continue # si ce nest pas une lettre, on passe
if c not in res : res [c] = 1 # si elle nest pas l, on lui affecte 1
else : res [c] += 1 # sinon, on augmente son nombre dapparitions
return res
Il nest pas vident de choisir lune ou lautre des mthodes. Calculer le cot algo-
rithmique de chacune des fonctions nest pas toujours vident car la premire utilise
la fonction count dont le fonctionnement est inconnu. Il parat plus facile dans ce
cas de comparer la vitesse dexcution de chaque fonction.
Dans lexemple suivant, la fonction comparaison appelle les deux mthodes sur le
mme texte. Le module profile va ensuite mesurer le temps pass dans chacune des
fonctions.
def comparaison () :
s = lit_fichier ("hugo.txt")
compte_lettre_count (s) # on ne mmorise pas les rsultats
compte_lettre (s) # car on souhaite mesurer le temps pass
import profile # import du module profile

profile.run ("comparaison()") # mesure du temps pass dans la fonction
# comparaison et les fonctions quelle appelle
A la fin du programme, le temps pass dans chaque fonction est affich par le module
profile. On peut y lire le nombre de fois quune fonction a t appele, le temps
moyen pass dans cette fonction.
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.160 0.160 0.174 0.174 langue.py:19(compte_lettre)
1 0.000 0.000 0.017 0.017 langue.py:31(compte_lettre_count)
1 0.000 0.000 0.190 0.190 langue.py:43(comparaison)
ncalls Nombre dappels la fonction

Temps pass uniquement dans la fonction, le temps pass dans une fonction
tottime
appele par celle-ci nest pas compt.
percall Temps moyen pass uniquement dans la fonction.
Temps cumul pass dans la fonction, y compris celui pass dans une fonc-
cumtime
tion appele.
percall Temps cumul moyen.
filename nom du fichier et nom de la fonction entre parenthse
La premire solution est clairement la plus rapide. Ce rsultat sexplique par la

rapidit de la mthode count. Mais cela ne permet de pas de conclure dans tous les
cas. Il faudrait connatre le cot algorithmique de chaque fonction pour cela. Par
exemple, lorsquil sagit de calculer les frquences de tous les caractres et non plus
des seules 26 lettres, on saperoit que la seconde solution nest plus que 1,5 fois plus
lente et non 10 fois.
ncalls tottime percall cumtime percall filename:lineno(function)

1 0.120 0.120 0.133 0.133 langue.py:19(compte_lettre)
1 0.002 0.002 0.082 0.082 langue.py:32(compte_lettre_count)
Lorsque le nombre dlments dont il faut calculer la frquence est assez grand,
la seconde solution est prfrable. La premire solution est efficace dans des cas
particuliers comme celui-ci. On saperoit galement que la fonction compte_lettre
est plus rapide pour cette seconde exprience (0.133 < 0.174) mais cette observation
est peu pertinente car cette fonction na t excute quune fois. Il y a en effet peu de
chance pour que la fonction sexcute chaque fois la mme vitesse car lordinateur
excute un grand nombre de tches simultanment.
Pour obtenir un temps dexcution fiable, il faut appeler la fonction un grand nombre
de fois. Le tableau suivant montre le temps moyen total pass dans chaque fonction
aprs 100 appels la fonction comparaison.
fonction 26 lettres tous les caractres

compte_lettre 0.087 0.061
compte_lettre_count 0.017 0.073
La fonction compte_lettre est effectivement plus rapide dans le second cas. Comme
on sintresse maintenant tous les caractres, le test if not (A <= c <= Z)
nest plus ncessaire : la fonction est dautant plus rapide que cette instruction
tait excute un grand nombre de fois. On remarque galement que la fonction
compte_lettre ne parat pas dpendre du nombre de caractres considrs. La fonc-
tion compte_lettre est un meilleur choix.
3) Il suffit de diviser chaque valeur du def compte_lettre (texte) :

dictionnaire res par la somme de ses va- # ...
s = sum (res.values ())
leurs. On insre donc les trois lignes sui- for k in res :
vantes juste avant linstruction return de res [k] = float (res [k]) / s
la fonction prcdente. return res
4) Le tableau suivant montre les probabilits obtenues pour les quatre lettres
H,U,W,Y pour lesquelles les rsultats montrent des diffrences significatives. Les
deux textes slectionns sont Le dernier jour dun condamn de Victor Hugo et sa
traduction anglaise The Man Who Laughs.
lettre Le dernier jour dun condamn The Man Who Laughs

H 1,22 % 6,90 %
U 6,79 % 2,57 %
W 0,11 % 2,46 %
Y 0,42 % 1,34 %
Ces chiffres ont t obtenus avec le programme suivant qui tlcharge ces deux textes
directement depuis le site Gutenberg 2 . Les frquences de ces quatre lettres montrent
des diffrences significatives, ce que montre de faon plus visuelle la figure 10.1 pour
les lettres W et H.
2. Il est conseill de vrifier ces adresses depuis le site http://www.gutenberg.net/, ces liens
peuvent changer.
# le dernier jour dun condamn

c1 = compte_lettre (lit_url ("http://www.gutenberg.org/dirs/etext04/8ldrj10.txt"))
# the man who laughs
c2 = compte_lettre (lit_url ("http://www.gutenberg.org/files/12587/12587-8.txt"))
car = c1.keys ()
car.sort ()
for k in car :
print k, " : ", "% 2.2f" % (c1 [k] * 100), "%", " % 2.2f" % (c2 [k] * 100), "%"
5) La frquence de la lettre W ou H devrait suffire dpartager un texte franais dun

texte anglais. Pour vrifier cette hypothse, on dcrit chaque texte par deux coor-
donnes correspondant aux frquences des lettres H et W, ce que calcule la fonction
suivante :
def langue_lettre (texte) :
if "http" in texte : s = lit_url (texte) # cas URL
else : s = lit_fichier (texte) # cas fichier
c = compte_lettre (s) # on compte les lettres
return c ["W"], c ["H"] # on retourne deux frquences
La dernire instruction de cette fonction suppose que tous les textes incluent au
moins un W et un H. Dans le cas contraire, la fonction produirait une erreur car elle
ne pourrait pas trouver la cl W ou H dans le dictionnaire c. Pour remdier
cela, on utilise la mthode get des dictionnaires qui permet de retourner une valeur
lorsquune cl est introuvable.
def langue_lettre (texte) :
... # lignes inchanges
return c.get ("W", 0.0), c.get ("H", 0.0) # on retourne deux frquences
Aprs cette correction, la fonction retourne une valeur nulle lorsque les lettres W ou
H napparaissent pas. La fonction suivante permet de construire deux listes cx et cy
qui contiennent les frquences des lettres W et H pour une liste de textes.
def curve (li) :
cx,cy = [], []
for l in li : # pour tous les textes de la liste
x,y = langue_lettre (l) # coordonnes dun texte, frquence W et H
cx.append (x) # on ajoute x la liste des abscisses
cy.append (y) # on ajoute y la liste des ordonnes
return cx,cy
On utilise cette dernire fonction pour faire apparatre sur un graphique plusieurs
textes anglais et franais. Chaque texte est reprsent par deux coordonnes : la fr-
quence des lettres W et H. On obtient un nuage de points dans un plan ce que montre
le graphe de la figure 10.1. Ce dernier a t trac laide du module matplotlib 3 .
Il sinspire du logiciel Matlab dans la manire de constuire des graphes 4 .
4. Il a linconvnient de ne pas supporter les accents franais mais il est possible de contourner
cet obstacle en associant MatPlotLib et Latex qui permet galement dafficher des formules ma-
frcx,frcy = curve (fr) # on rcupre les coordonnes des textes franais

encx,ency = curve (en) # on rcupre les coordonnes des textes anglais
import pylab # import du module matplotlib

pylab.plot (frcx, frcy, "rx",ms=10,\
mew=2.5) # on trace la courbe des textes franais
pylab.plot (encx, ency, "bv") # on trace la courbe des textes anglais
pylab.legend (("francais", "anglais"), loc=2) # lgende (sans accent)
pylab.title ("langue") # titre
pylab.xlabel ("frequence de W") # lgende de laxe des abscisses
pylab.ylabel ("frequence de H") # lgende de laxe des ordonnes
pylab.savefig ("graphe.png") # enregistrement sous forme dimage
pylab.show () # on fait apparatre le graphique
Figure 10.1 : Les textes anglais et franais

sont cantonns chacun dans une zone prcise
du graphe : il apparat que les frquences des
lettres H et W permettent toutes deux de dis-
tinguer des textes anglais et franais. Une
frquence infrieure 1% pour la lettre W
signifie un texte franais.
La figure 10.1 montre quau del dune frquence de 1% pour la lettre W, le texte est
anglais. On en dduit la fonction qui permet de dterminer la langue dun texte.
def est_anglais (texte) :
w,h = langue_lettre (texte)
return w > 0.01
La rponse la dernire question pourrait sarrter ici. Toutefois, les paragraphes

qui suivent sintressent la fiabilit de la fonction de la fonction est_anglais dans
un autre contexte : Internet.
Interprtation
En effet, ce dernier rsultat peut tre critiqu : ce seuil sappuie sur seulement quatre
textes. Ces derniers sont longs : la frquence des lettres en est dautant plus fiable.
Sur un texte dune centaine de lettres, la frquence de la lettre W est soit nulle, soit
suprieure 1%. Au del de ce cas difficile et peu frquent, on vrifie la fiabilit de
la fonction est_anglais sur des articles de journaux franais et anglais.
Internet va nous aider construire une base de textes : il est facile des rcuprer
automatiquement de nombreux articles de journaux sur des sites tels que celui du
thmatiques sur le graphique. Lutilisation de ce genre de modules est plutt facile, de nombreux
exemples de graphiques sont proposs avec le programme Python qui a permis de les raliser. Il
suffit souvent des recopier et de les adapter. Une autre solution consiste crire les courbes dans
un fichier texte puis les rcuprer avec un tableur tel que OpenOffice pour les reprsenter sous
forme de graphe (voir lexemple page 170).
journal Le Monde ou le New-York Times. On pourra ensuite calculer la frquence

des lettres W et H pour chacun dentre eux.
Rcupration de pages HTML
Une page Internet contient du texte dont la prsentation est dcrite par le format
HTML. On y trouve tout type de contenu, des images, de la vido, du texte, et
des hyperliens. Le site du journal Le Monde 5 contient beaucoup de liens vers des
articles qui eux-mmes contiennent des liens vers dautres articles (voir figure 10.2).
A partir dune seule page, on rcupre une myriade de liens Internet. Lobjectif est
ici dexplorer quelques pages pour rcuprer des liens vers des articles de ce journal.
La rcupration des pages Internet dun site sinspire de la rcupration de la liste
de tous les fichiers inclus dans un rpertoire 6 .
La principale diffrence provient du fait que les liens ne dsignent pas toujours une
page nouvelle mais parfois la premire page du site ou une autre page dj vue dont
il ne faut pas tenir compte. Lautre diffrence vient du faite que le nombre de pages
sur un site comme Le Monde peut savrer trs grand : il faut bien souvent se limiter
aux premires pages et celles qui appartiennent ce site.
Figure 10.2 : Un site Internet contient g-

nralement une page qui est le moyen dacc-
der toutes les pages du site. Cest un point
dentre qui mne directement ou indirecte-
ment lensemble des pages du site. Il suffit
de suivre les liens pour en tablir une liste.
Certains liens mnent des pages nouvelles,
dautres des pages dj vue : ce graphe est
cyclique.
Le format HTML fonctionne par balises : une information est encadre par deux ba-
lises : <balise> texte ... </balise>. Les hyperliens utilisent une syntaxe peine
plus complique puisquune balise peut aussi recevoir quelques paramtres : <balise
param1="valeur1" param2="valeur2"> texte ... </balise>. Selon cette syn-
taxe, un lien vers une autre page est indiqu comme suit :
<a href="http://...."> texte qui apparat lcran </a>
Les expressions rgulires 7 permettent de retrouver aisment tous les liens insrs
dans une page sans avoir se soucier du format HTML. Lalgorithme de recherche
consiste recenser tous les liens de la premire page. La syntaxe HTML nous apprend
que ces liens sont compris entre guillemets. On considre ensuite chacune des pages
recenses et on procde de mme. On sarrte aprs avoir obtenu le nombre de pages
souhait.
import urllib # pour accder une adresse internet
import re # pour traiter les expressions rgulires
5. http://www.lemonde.fr/
6. voir paragraphe 7.3.3 page 177
7. voir paragraphe 7.6 page 184
def list_url (site, root, nbpage = 100) :
# expression rgulires
# tous les liens commenant par root et entre guillemets
# exemple : "http://www.lemonde.fr/index,0.26.html"
# on place entre parenthses la partie intressante :
# cest--dire tout ce quil y a entre les guillemets
s = "\"(" + root + "[-_~a-zA-Z0-9/.?,]*?)\""
exp = re.compile (s, re.IGNORECASE)
res = [ ] # rsultat
pile = [ site ] # page explorer
while len (pile) > 0 and len (res) < nbpage :
# on bascule toutes les pages de pile vers res

for u in pile :
if u not in res : res.append (u)
u = pile.pop () # on sintresse la prochaine page
try :
f = urllib.urlopen (u) # accs lurl
text = f.read () # on lit son contenu
f.close () # fin de laccs
liens = exp.findall (text) # recherche de tous les liens

for u in liens :
if u in pile or u in res : # on passe au suivant si
continue # dj vu
# on enlve les images et autres fichiers indsirables

if ".gif" in u or ".png" in u or ".jpg" in u : continue
if ".cs" in u or ".css" in u or ".js" in u : continue
# on ajoute le liens la liste des liens explorer

pile.append (u)
except IOError, exc:

print "problme avec url ", u
continue
return res
Il ne reste plus qu appeler cette fonction pour rcuprer la liste des URLs :
url = "http://www.lemonde.fr/" # un journal franais
res = list_url (url, url)
for r in res : print r
url = "http://www.nytimes.com/" # un journal amricain

res = list_url (url, url)
Rsultats
On dtermine alors la frquence des lettres sur 88 textes franais et 181 textes
anglais. Les rsultats obtenus sont ceux de la figure 10.3. La frontire est nettement
plus floue et montre premire vue quil nest pas toujours possible de distinguer
une page franaise dune page anglaise. Toutefois, la plupart des pages mal classes
par cette mthode contiennent peu de texte et plus dimages : les frquences portent
plus sur la syntaxe HTML que sur un contenu littraire. Il faudrait pour amliorer
la qualit des rsultats filtrer les pages pour ne conserver que leur contenu textuel.
Cela montre aussi que cette mthode est plutt robuste puisquon voit deux classes
se dessiner nettement malgr les caractres parasites HTML.
Figure 10.3 : La frontire entre texte an-

glais et franais parat plus floue et ne dpend
plus de la frquence dune seule lettre. Laxe
des X reprsente la frquence de la lettre W,
laxe des Y celle de la lettre H.
Pour aller plus loin

Jusqu prsent, seules les lettres W et H ont t utilises. Les deux autres lettres int-
ressantes U et Y ont t laisses de ct. On peut se demander quelle est la meilleure
faon de procder avec quatre lettres. Chaque texte est maintenant reprsent par
quatre frquences, soit quatre coordonnes et il nest possible de nen reprsenter
que deux.
Dans ce nuage de points quatre dimension, lanalyse en composantes principales
(ACP) 8 est une mthode qui permet de calculer un plan de projection, plus exac-
tement le meilleur plan de projection : celui qui minimise les distances de chaque
point au plan. On utilise pour cela le module mdp 9 qui implmente cet algorithme.
On suppose dans lexemple suivant que fr4 et en4 sont deux matrices de quatre
colonnes reprsentant les coordonnes de chaque document. La figure 10.4 montre
que lutilisation des quatre lettres H, U, W, Y permet de construire une frontire plus
efficiente quavec lutilisation de W, H seulement.
import mdp,copy,numpy
nbfr,nben = len (fr), len (en)
all = numpy.array (fr + en) # construction du nuage de points
node = mdp.nodes.PCANode() # ACP

node.train (all) # construction de lACP
y = node (all) # on peut aussi crire y = mdp.pca (all)
# obtention des coordonnes des points dans le plan de projection

frcx = [ y [i,0] for i in range (0, nbfr) ]
frcy = [ y [i,1] for i in range (0, nbfr) ]
8. voir le livre Probabilits, analyse des donnes et statistique de Gilbert Saporta (ditions
Technip).
9. http://mdp-toolkit.sourceforge.net/
encx = [ y [i,0] for i in range (nbfr, nbfr + nben) ]

ency = [ y [i,1] for i in range (nbfr, nbfr + nben) ]
# dessin des points dans le plan de projection

# cest le mme code que prcdemment
# ...
Figure 10.4 : La frontire entre les textes anglais

et franais est beaucoup plus nette dans ce plan de
projection issu de lanalyse en composantes princi-
pales.
LACP donne de bons rsultats dans la mesure o les deux classes sont visiblement
disctinctes et concentres. Dans un cas comme celui-ci pourtant, il serait plus ad-
quat dutiliser une Analyse Discriminante Linaire ou Fisher Discriminant Analysis
(FDA) en anglais. Il sagit de dterminer la meilleure sparation linaire entre ces
deux classes. Les rsultats sont dans ce cas assez proches.
# mme dbut que le programme prcdent

allfr = numpy.array (fr) # points franais
allen = numpy.array (en) # points anglais
node = mdp.nodes.FDANode ()
node.train (allfr, "fr")
node.train (allen, "en")
node.stop_training ()
node.train (allfr, "fr")
node.train (allen, "en")
y = node (all)
10.4 Carrs magiques

Un carr magique est un carr 3x3 dont chaque case contient un nombre entier et
pour lequel les sommes sur chacune des lignes, chacune des colonnes, chacune des
diagonales sont gales, soit huit sommes gales. Le plus simple des carrs magiques
est celui dont tous les chiffres sont gaux :
1 1 1
1 1 1
1 1 1
1) Un carr magique nest a priori quune

matrice de trois lignes et trois colonnes. class CarreMagique :
Dans un premier temps, on va donc def __init__ (self, nb) :
construire une classe CarreMagique qui self.nb = nb
contiendra une liste de trois listes, chacune
m = [ [9, 3, 3], [ 4,5,6] , [3,8,2] ]
de trois colonnes. Complter le programme
pour crer un carr magique cm.
2) On dsire afficher le carr magique. Que

donne linstruction print cm ? On ajoute la def __str__ (self) :
mthode __str__. Que produit linstruc- s = ""
tion print cm maintenant ? Que faudrait-il s += str (self.nb [0][0])
return s
changer pour que le programme affiche le
carr en entier ?
3) Ecrire une mthode qui calcule la somme des chiffres sur la ligne i.
4) Ajouter une ligne dans la mthode __str__ afin dafficher aussi la somme des
chiffres sur la ligne 0. Cette information correspond la somme des chiffres sur
chaque ligne ou chaque colonne si le carr est magique.
5) Ecrire une mthode qui calcule la somme des chiffres sur la colonne j.
6) Sans tenir compte des diagonales, crire une mthode qui dtermine si un carr
est magique.
7) Il ne reste plus qu inclure les diagonales.
8) Ecrire une fonction qui dtermine si tous les nombres du carr magique sont
diffrents.
9) Terminer le programme pour dterminer tous les carrs magiques 3x3 dont les
nombres sont tous diffrents.
Remarque 10.3 : diffrence entre print et return
A la fin dun calcul, afin de voir son rsultat, on utilise souvent linstruction print.
On peut se demander alors si la fin de chaque fonction, il ne faudrait pas utiliser
linstruction print. A quoi servirait alors linstruction return ? On suppose quun
calcul est en fait le rsultat de trois calculs la suite :
a = calcul1 (3)
b = calcul2 (a)
c = calcul3 (b) # c rsultat souhait et affich
Chaque terme calculx cache une fonction or seul le rsultat de la dernire nous
intresse et doit tre affich. Pour les deux premires, la seule chose importante est
que leur rsultat soit transmis la fonction suivante et ceci ne peut se faire que
grce linstruction return. Linstruction print insre dans le code de la fonction
calcul1 ou calcul2 permettra dafficher le rsultat mais ne le transmettra pas et il
sera perdu. Linstruction return est donc indispensable, print facultative.
En revanche, dans la dernire fonction calcul3, il est possible de se passer de return
et de se contenter uniquement dun print. Cependant, il est conseill dutiliser quand
mme return au cas o le rsultat de la fonction calcul3 serait utilis par une autre
fonction.
Correction
1) Il suffit de crer instance de type CarreMagique.
cm = CarreMagique (m)
2) Le message affich par linstruction print cm avant dajouter la mthode __str__

correspond au suivant :
<__main__.CarreMagique instance at 0x01A254E0>
La rponse cette question et aux suivantes sont prsentes dun seul tenant. Des
commentaires permettent de retrouver les rponses aux questions de lnonc except
pour la dernire question.
# coding: latin-1
class CarreMagique :
def __init__ (self, nb) :

"""on place la matrice nb (liste de listes)
dans la classe accessible par le mot-cl self"""
self.nb = nb
# rponse la question 2
"""mthode appele lorsque on cherche afficher
un carr magique avec linstruction print"""
s = ""
for i in range (0, len (self.nb)) :
for j in range (0, len (self.nb)) : s += str ( self.nb [i][j]) + " "
s += "\n" # pour passer la ligne
s += "somme " + str (self.somme_ligne (0))
return s
def somme_ligne (self, i) :
s = 0
for j in range (0, len (self.nb)) : s += self.nb [i][j]
return s
def somme_colonne (self, j) :
s = 0
for i in range (0, len (self.nb)) : s += self.nb [i][j]
return s
def est_magique (self) :
# on stocke toutes les sommes
l = []
for i in range (0, len (self.nb)) : l.append ( self.somme_ligne (i) )
for j in range (0, len (self.nb)) : l.append ( self.somme_colonne (j) )
l.append ( self.somme_diagonale (0))
l.append ( self.somme_diagonale (1))
# on trie la liste
l.sort ()
# on compare le plus petit et le plus grand, sil sont gaux,

# le carr est magique
return l [0] == l [ len(l)-1 ]
def somme_diagonale (self, d) :
"""d vaut 0 ou 1, premire ou seconde diagonale"""
s = 0
if d == 0 :
for i in range (0, len (self.nb)) : s += self.nb [i][i]
else :
s += self.nb [i][len(self.nb)-i-1]
return s
def nombre_differents (self) :
"""retourne True si tous les nombres sont diffrents,
on place les nombres un par un dans un dictionnaire,
ds que lun deux sy trouve dj,
on sait que deux nombres sont identiques, le rsultat est False"""
k = { }
for j in range (0, len (self.nb)) :
c = self.nb [i][j]
if c in k : return False # pas besoin daller plus loin
# il y a deux nombres identiques
else : k [c] = 0
return True
m = [ [9, 3, 7], [ 4,5,6] , [1,8,2] ]

cm = CarreMagique (m) # rponse la question 1
print cm # affiche 15
print cm.est_magique () # affiche False
print cm.nombre_differents () # affiche True
m = [ [9, 9, 9], [9, 9, 9], [9, 9, 9] ]

cm = CarreMagique (m)
print cm # affiche 15
print cm.est_magique () # affiche True
print cm.nombre_differents () # affiche False
La dernire question consiste trouver tous les carrs magiques dont les nombres
sont tous diffrents. Il faut donc passer en revue tous les carrs 3x3 et ne conserver
que ceux pour lesquels les mthodes est_magique et nombre_differents retournent
un rsultat positif. On suppose que le programme prcdent contenant la classe
CarreMagique porte le nom de carre_magique.py. Ceci explique la ligne from....
from carre_magique import CarreMagique

res = []
for a in range (1,10) :
for b in range (1,10) :
for c in range (1,10) :

for d in range (1,10) :
for e in range (1,10) :
for f in range (1,10) :
for g in range (1,10) :
for h in range (1,10) :
l = [ [a,b,c], [d,e,f], [g,h,i] ]
cm = CarreMagique (l)
if cm.nombre_differents () and \
cm.est_magique () :
res.append (cm)
print len (res)

for r in res :
print r
Linconvnient de cette solution est quelle est inadapte pour des carrs dune autre
dimension que 3x3. Il faudrait pouvoir inclure un nombre de boucles variable ce qui
est impossible. Lautre solution est de programmer un compteur en reproduisant
lalgorithme dune addition. Cest lobjectif du programme suivant.
# coding: latin-1
dim = 3
nb = dim*dim
res = [] # contiendra la liste des carrs magiques
# le compteur : neuf nombres 1

ind = [1 for i in range (0,nb) ]
while ind [0] <= nb :
# transformation dune liste en une liste de listes

# [1,2,3,4,5,6,7,8,9] --> [[1,2,3],[4,5,6],[7,8,9]]
l = []
for i in range (0, dim) :
l.append ( ind [i*dim:(i+1)*dim] )
# on vrifie que le carr est magique et

# a des nombres tous diffrents
if cm.nombre_differents () and cm.est_magique () :
res.append (cm)
# on passe au carr suivant :

i = nb-1 # dernier indice (9 ici)
ind [i] += 1 # addition de 1 au dernier indice
while i > 0 and ind [i] > nb :
ind [i-1] += 1 # un des indices est suprieur nb (9 ici)
ind [i] = 1 # on le remet 1
i -= 1 # et on propage linformation lindice infrieur
# rsultat final
print len (res)
Il existe une autre manire de parcourir les carrs magiques en dcomposant un

entier compris entre 1 et 99 en une succession de neuf P
entiers. On utilise pour cela
la dcomposition dun nombre en base neuf : n 1 = 9k=1 k (ik 1) o tous les
nombres ik sont dans lensemble {1, . . . , 9}.
# coding: latin-1
dim = 3
nb = dim*dim
M = 9 ** nb # on va tester 9^9 carrs possibles
res = [] # contiendra la liste des carrs magiques
for n in xrange (0,M) :
# on dcompose n en liste
ind = []
k = n
for t in range (0,nb) :
dec = k % nb
k = k / nb
ind.append (dec+1)
# transformation dune liste en une liste de listes

# [1,2,3,4,5,6,7,8,9] --> [[1,2,3],[4,5,6],[7,8,9]]
l = []
for i in range (0, dim) :
l.append ( ind [i*dim:(i+1)*dim] )
# on vrifie que le carr est magique et

# a des nombres tous diffrents
if cm.nombre_differents () and cm.est_magique () :
res.append (cm)
# rsultat final
print len (res)
Il faut noter lutilisation de la fonction xrange au lieu de la fonction range lors de la

premire boucle. La fonction xrange ne cre pas de liste, elle simule un itrateur qui
parcourt une liste. Dans notre cas, la fonction range cre une liste de 99 lments
qui ne tient pas en mmoire, lerreur suivante est dclenche :
File "carre_magique_tous5.py", line 9, in <module>
for n in range (0,M) :
MemoryError
Ces trois solutions sont trs lentes car elles explorent 99 solutions. Comme on ne
cherche que les carrs magiques dont les lments sont tous diffrents, on pour-
rait nexplorer que les permutations soit 9! configurations. On cre une fonction
permutation qui parcourt toutes les permutations possibles par rcurrence (voir fi-
gure 10.5).
# coding: latin-1
Figure 10.5 : Cest une illus-

tration de lide permettant de
parcourir les permutations. On
suppose que la partie du ct
gauche du trait en pointill (re-
li la variable pos, ici gale
4) est fige. On lchange tour
tour avec les chiffre droite
configuration lors de lappel rcursif suivant
(pos + 1,pos + 2, ...). A chaque
change, on appelle nouveau la
fonction permutation rcursive
en dcalant le trait en pointill
dun cran vers la droite. Aprs
cet appel, on effectue lchange in-
verse.
def echange (p, i, pos) :

# change de deux lments dindice i et pos du tableau p
if i != pos :
e = p [i]
p [i] = p [pos]
p [pos] = e
def permutation (res, dim, pos = 0, p = None) :

# parcours des permutations par rcurrence
# pour le premier appel la fonction permutation
if p == None : p = range (1, dim*dim+1)
if pos < len (p) :

# on organise les permutations de llment p [pos], p [pos+1], ...
for i in range (pos, len (p)) :
echange (p, i, pos)
permutation (res, dim, pos+1, p)
echange (p, i, pos)
else :
# pos correspond au dernier lment : il ny a plus de permutation
# possible avec les lments qui suivent
# on teste donc le nouveau carr
l = []
for i in range (0, len (p)/dim) :
l.append ( p [i*dim:(i+1)*dim] )
if cm.est_magique () : res.append (cm)
# permutations
res = []
permutation ( res, 3 )
# rsultats
print "nombre de carrs ", len (res)
Le programme indique huit carrs magiques qui sont en fait huit fois le mme carr
obtenus par rotation ou symtrie. La somme des chiffres est 15.
10.5 Tri rapide ou quicksort

Cet nonc a pour objectif de prsenter lalgorithme de tri quicksort qui permet
de trier par ordre croissant un ensemble dlments (ici des chanes de caractres)
avec un cot moyen 10 en O (n ln n) o n est le nombre dlments classer. Le
tri quicksort apparat rarement sous la forme dun graphe : il est plus simple
programmer sans les graphes mais il est plus simple apprhender avec les graphes.
Dans cette dernire version, lalgorithme insre un un les lments dune liste
trier dans un graphe comme celui de la figure 10.6 (page 265). Chaque nud de ce
graphe est reli deux autres nuds :
1. Un nud avant ou < qui permet daccder des lments classs avant celui de
ce nud.
2. Un nud apres ou > qui permet daccder des lments classs aprs celui de
ce nud.
Les nuds avant et apres sont appels les successeurs. Le terme oppos est prd-
cesseur. Ces deux nuds ont ncessairement un prdcesseur mais un nud na pas
forcment de successeurs. Sil en avait toujours un, larbre serait infini.
1) On cherche construire une classe ayant pour nom NoeudTri et qui contient une
chane de caractres initialise lors de la cration de la classe : n = NoeudTri(essai).
2) On crit la mthode __str__ de sorte que linstruction print n affiche la chane
de caractres que contient n.
3) On cherche maintenant dfinir dautres nuds, relis des attributs avant et
apres. On suppose que les nuds utilisent lattribut mot, on cre alors une mthode
insere(s) qui :
Si s < self.mot, alors on ajoute lattribut avant = NoeudTri(s).
Si s > self.mot, alors on ajoute lattribut apres = NoeudTri(s).
Fonction utile :
Compare deux chanes de caractres, retourne -1,0,1 selon
cmp(s1, s2)
que s1 est classe avant, est gale ou est classe aprs s2.
4) La mthode __str__ naffiche pour le moment quun mot. Il sagit maintenant

de prendre en compte les attributs avant et apres afin que linstruction print n
affiche avant.__str__() et apres.__str__(). Il faudra galement faire en sorte
que la mthode avant.__str__() ne soit appele que si lattribut avant existe.
Comme la liste des mots trier est finie, il faut bien que certains nuds naient pas
de successeurs. On pourra sinspirer du programme page 99 (attribut __dict__).
Quest-ce quaffiche le programme suivant ?
10. Lorsquon parle de cot moyen, cela signifie que le cot nest pas constant en fonction de
la dimension du problme. Ici, le cot moyen dsigne le cot moyen dun tri quicksort obtenu en
faisant la moyenne du cot du mme algorithme sur toutes les permutations possibles de lensemble
de dpart.
racine = NoeudTri ("un")

racine.insere ("unite")
racine.insere ("deux")
print racine
5) Est-il possible de trier plus de trois mots avec ce programme ? Que faut-il modifier
dans la mthode insere afin de pouvoir trier un nombre quelconque de mots ?
6) Ajouter le code ncessaire afin que la mthode insere gnre une exception lors-
quun mot dj prsent dans larbre est nouveau insr.
7) On se propose de construire une image reprsentant larbre contenant les mots
tris par lalgorithme quicksort. Cette reprsentation utilise le module pydot qui
utilise loutil Graphviz 11 ainsi que le module pyparsing 12 . Leur installation est as-
sez facile sous Windows puisquelle consiste seulement excuter un programme
dinstallation. Il faut ensuite installer manuellement le module pydot 13 . Aprs avoir
dcompress les fichiers de ce module, il faut se placer dans le mme rpertoire et
utiliser la ligne de commande suivante :
c:\python26\python setup.py install
Le trac dun graphe passe par lcriture dun fichier dans lequel on indique les
nuds et les arcs. Un nud est un numro suivi de [label = deux] qui indique
que ce nud contient le mot deux. Si on ajoute , style = filled, shape = record,
le nud est reprsent par un rectangle au fond gris. Un arc est un couple de
numros spars par ->. Le texte [label="<"] permet dtiqueter cet arc. Selon
cette syntaxe, le texte suivant dcrit limage situe droite :
digraph GA {
2 [label="deux",style=filled,shape=record]
3 [label="abc" ,style=filled,shape=record]
2 -> 3 [label="<"]
}
Fonction utile :
id(obj) Retourne un identifiant entier unique pour chaque variable obj.
Une fois que cette chane de caractres a t construite, il suffit de lcrire dans
un fichier puis dappeler le module pydot pour le convertir en image avec le code
suivant :
g = open ("graph.txt", "w") #
g.write (graph) # partie criture dans un fichier
g.close () #
dot = pydot.graph_from_dot_file ("graph.txt") # partie graphe
dot.write_png ("graph.png", prog="dot") # avec pydot
12. http://pyparsing.wikispaces.com/
13. http://code.google.com/p/pydot/
Lobjectif de cette question est de construire une chane de caractres pour len-
semble du graphe. La correction de cette exercice envisage galement de construire
une page HTML contenant le graphe et la liste trie ainsi que la cration automa-
tique dun fichier au format PDF par le biais de Latex 14 .
Correction
1) La chane de caractres que contient NoeudTri sappelle mot.
class NoeudTri (object):

def __init__(self,s):
self.mot = s
2)

def __init__(self,s): self.mot = s
def __str__(self) : return self.mot + "\n" # \n : passage la ligne
3)

def __str__(self) : return self.mot + "\n"
def insere (self,s):

c = cmp (s, self.mot)
if c == -1 : self.avant = NoeudTri (s) # ajout dun successeur
elif c == 1 : self.apres = NoeudTri (s) # ajout dun successeur
La mthode insere prvoit de ne rien faire dans le cas o le mot s pass en argument
est gal lattribut mot : cela revient ignorer les doublons dans la liste de mots
trier.
4)

def __str__(self):
s = ""
if "avant" in self.__dict__: s += self.avant.__str__ ()
s += self.mot + "\n"
if "apres" in self.__dict__: s += self.apres.__str__()
return s

if c == -1 : self.avant = NoeudTri (s)
elif c == 1 : self.apres = NoeudTri (s)
14. Latex est un langage adapt aux publications scientifiques, galement lcriture de livres
comme celui-ci. En utilisant sa syntaxe, il permet de crer rapidement un fichier au format PDF.
Linsertion des mots donns dans lnonc produit le code suivant :

deux
un
unite
5) 6) Il reste complter la fonction insere afin quelle puisse trouver le bon nud
o insrer un nouveau mot. Cette mthode est rcursive : si un nud contient deux
attributs avant et apres, cela signifie que le nouveau mot doit tre insr plus bas,
dans des nuds relis soit avant soit apres. La mthode insere choisit donc un
des attributs et dlgue le problme la mthode insere de ce nud.
# coding: latin-1
import string
class SecondeInserstion (AttributeError):

"insertion dun mot dj insr"
class NoeudTri :
# la cration dun nouveau noeud a t place dans une mthode

def nouveau_noeud (self, s) :
return self.__class__ (s)
#return NoeudTri (s)
def __str__(self):
s = ""
if "avant" in self.__dict__: s += self.avant.__str__ ()
s += self.mot + "\n"
if "apres" in self.__dict__: s += self.apres.__str__()
return s

if c == -1:
if "avant" in self.__dict__ : self.avant.insere (s) # dlgation
else : self.avant = self.nouveau_noeud (s) # cration
elif c == 1:
if "apres" in self.__dict__ : self.apres.insere (s) # dlgation
else: self.apres = self.nouveau_noeud (s) # cration
else:
raise SecondeInsertion, "mot : " + s
l = ["un", "deux", "unite", "dizaine", "exception", "dire", \

"programme", "abc", "xyz", "opera", "quel"]
racine = None
for mot in l :
if racine == None :
# premier cas : aucun mot --> on cre le premier noeud
racine = NoeudTri (mot)
else :
# second cas : il y a dj un mot, on ajoute le mot suivant
# larbre
racine.insere (mot)
print racine
Chaque nouveau mot va partir du tronc pour saccrocher une feuille de larbre
pour devenir son tour une feuille. La mthode nouveau_noeud cre un nouveau
nud dans le graphe. Son utilit est mise en vidence par le prochain programme.
7) La figure 10.6 dtient le graphe obtenu par le programme qui suit. Plutt que
de modifier la classe NoeudTri, une seconde est cre qui hrite de la premire. On
lui adjoint la mthode chaine_graphe qui convertit un graphe en une chane de
caractres dont le format reprend celui nonc plus haut. Cette fonction soccupe
de construire rcursivement cette chane de caractres. Pour identifier chaque nud,
on utilise la fonction id qui retourne un identifiant distinct pour chaque instance de
classe.
Figure 10.6 : Graphe de tri obtenu lors du tri quicksort.

Chaque nud du graphe inclut un mot. Les symboles "<"
et ">" des arcs dsignent les membres avant et apres de
la classe NoeudTri. Tous les mots attachs un arc "<"
dun nud sont classs avant le mot de ce nud. De mme,
tous les mots attachs un arc ">" dun nud sont classs
aprs le mot de ce nud.
# coding: latin-1
import string
import pydot
import quicksort
class NoeudTri2 (quicksort.NoeudTri):
def chaine_graphe (self):

# le principe est le mme que pour la mthode __str__
# except que le format est diffrent
g = str (id (self)) + [label=" + self.mot \
+ ",style=filled,shape=record,fontsize=60]\n
if "avant" in self.__dict__:
h = self.avant.chaine_graphe ()
g += h + str (id (self)) + " -> " + str (id (self.avant)) \
+ [label="<",fontsize=60] + \n
if "apres" in self.__dict__:
h = self.apres.chaine_graphe ()
g += h + str (id (self)) + " -> " + str (id (self.apres)) \
+ [label=">",fontsize=60] + "\n"
return g
#def nouveau_noeud (self, s) : return NoeudTri2 (s)

def image (self, file, im) :

# on cre un graphe : on rcupre le code du graphe
graph = self.chaine_graphe ()
# auquel on ajoute un dbut et une fin
graph = "digraph GA {\n" + graph + "}\n"
# puis on lcrit dans le fichier file

g = open (file, "w")
g.write (graph)
g.close ()
# enfin, on convertit ce fichier en image

dot = pydot.graph_from_dot_file (file)
dot.write_png (im, prog="dot")
def construit_arbre () :
# mme code que dans le programme prcdent
# mais inclus dans une fonction
l = ["un", "deux", "unite", "dizaine", "exception", "dire", \
"programme", "abc", "xyz", "opera", "quel"]
racine = None
for mot in l :
if racine == None : racine = NoeudTri2 (mot)
else : racine.insere (mot)
return racine
racine = construit_arbre ()
print racine
racine.image ("graph.txt", "graph.png")
La mthode nouveau_noeud permet de sassurer que tous les nuds insrs lors
de la cration du graphe seront bien du type NoeudTri2 qui inclut la mthode
chaine_graphe. Cette mthode serait inutile sil ny avait quune seule classe
NoeudTri contenant toutes les mthodes. Si on la met en commentaire, le message
derreur suivant apparat :
File "quicksort2.py", line 53, in <module>
File "quicksort2.py", line 27, in image
graph = self.chaine_graphe ()
File "quicksort2.py", line 14, in chaine_graphe
h = self.avant.chaine_graphe ()
AttributeError: NoeudTri instance has no attribute chaine_graphe
Lerreur signifie que le programmeur cherche appeler une mthode qui nexiste
pas dans la classe NoeudTri parce que seul le premier nud de larbre est de type
NoeudTri2 contrairement aux nuds insrs par la mthode nouveau_noeud de la
classe NoeudTri. En surchargeant cette mthode, on sassure que tous les nuds
sont du mme type NoeudTri2. Il existe nanmoins une faon dviter de surcharger
cette fonction chaque fous. Il suffit quelle cre automatiquement la bonne classe,
que lobjet soit une instance de NoeudTri ou NoeudTri2. Cest ce que fait lexemple
suivant o self.__class__ correspond la classe de lobjet.
def nouveau_noeud (self, s) : return self.__class__ (s)

Au final, la mthode image construit limage du graphe. Le fichier graphe.txt doit

ressembler ce qui suit :
digraph GA {
18853120 [label="un",style=filled,shape=record]
28505472 [label="deux",style=filled,shape=record]
28505712 [label="abc",style=filled,shape=record]
28505472 -> 28505712 [label="<"]
28505552 [label="dizaine",style=filled,shape=record]
28505592 [label="dire",style=filled,shape=record]
28505552 -> 28505592 [label="<"]
28505632 [label="exception",style=filled,shape=record]
28505672 [label="programme",style=filled,shape=record]
28505792 [label="opera",style=filled,shape=record]
28505672 -> 28505792 [label="<"]
28505832 [label="quel",style=filled,shape=record]
28505672 -> 28505832 [label=">"]
28505632 -> 28505672 [label=">"]
28505552 -> 28505632 [label=">"]
28505472 -> 28505552 [label=">"]
18853120 -> 28505472 [label="<"]
28505512 [label="unite",style=filled,shape=record]
28505752 [label="xyz",style=filled,shape=record]
28505512 -> 28505752 [label=">"]
18853120 -> 28505512 [label=">"]
}
La numrotation des nuds importe peu du moment que chaque nud reoit un
identifiant unique. Cest pour cela que la fonction id est pratique dans ce cas-l.
Le programme suivant construit une sortie au format HTML mlangeant image et
texte. Il commence par importer le programme quicksort2 qui nest autre que celui
incluant la classe NoeudTri2. Il termine en appelant le navigateur Mozilla Firefox
afin dafficher le rsultat automatiquement.
# coding: latin-1
import quicksort2
# construction de larbre
racine = quicksort2.construit_arbre ()
# construction de limage du graphe
# cration dun fichier HTML

f = open ("page.html", "w")
f.write ("<body><html>\n") # dbut
f.write ("<H1> liste trie </H1>\n") # titre pour la liste trie

s = str (racine) # on rcupre la liste trie
s = s.replace ("\n", "<BR>\n") # <BR> permet de passer la ligne
f.write (s)
f.write ("<H1> graphe </H1>\n") # titre pour limage

f.write (<img src="graph.png" width=400/>\n) # image
f.write ("<H1> code du graphe </H1>\n") # titre pour le code du graphe

s = racine.chaine_graphe () # on rcupre le code du graphe
f.write ("<pre>\n") # on laffiche tel quel
f.write (s)
f.write ("</pre>\n")
f.write ("</html></body>\n") # fin

f.close ()
# on lance le navigateur automatiquement pour afficher la page

import os
os.system (r"C:\Program Files\Mozilla Firefox\firefox" page.html)
Le fichier page.html contient les lignes suivantes except les points de suspension qui
remplacent la partie tronque quon peut aisment deviner.
<body><html>
<H1> liste trie </H1>
abc<BR>
deux<BR>
...
unite<BR>
xyz<BR>
<H1> graphe </H1>
<img src="graph.png" width=400/>
<H1> code du graphe </H1>
<pre>
13697312 [label="un",style=filled,shape=record,fontsize=60]
13697192 [label="deux",style=filled,shape=record,fontsize=60]
34692472 [label="abc",style=filled,shape=record,fontsize=60]
...
13697232 -> 34692592 [label=">",fontsize=60]
13697312 -> 13697232 [label=">",fontsize=60]
</pre>
</html></body>
On veut modifier ce programme pour que la sortie ne soit plus au format HTML
mais au format PDF. Pour cela, on utilise comme intermdiaire le langage Latex
qui soccupe de crer ce fichier au format PDF. Les dernires lignes sont propres au
systme Windows o on suppose que la version de Latex installe est Miktex 2.7 15 .
Il faut galement le logiciel Adobe Reader 16 .
# coding: latin-1
import quicksort2
# construction de larbre
racine = quicksort2.construit_arbre ()
# construction de limage du graphe
# construction du dbut du fichier tex

package = """a4 amsmath amssymb subfigure float latexsym amsfonts
epic eepic makeidx multido varindex moreverb alltt fancyvrb fancyhdr
color eurosym tabularx placeins url shorttoc""".split ()
header = """\\documentclass[french,11pt]{article}\n\\usepackage[french]{babel}
\\usepackage[usenames]{color}\\usepackage{""" + \
"}\n\\usepackage{".join (package) + \
15. http://miktex.org/, ce logiciel est volumineux et assez long tlcharger.

16. http://www.adobe.com/fr/products/acrobat/readstep2.html
"""}\\usepackage[small,normal]{caption2}\\urlstyle{sf}
\\usepackage[pdftex]{graphicx}\usepackage[T1]{fontenc}
\DefineVerbatimEnvironment{verbatimx}{Verbatim}{frame=single,
framerule=.1pt, framesep=1.5mm, fontsize=\\footnotesize,xleftmargin=0pt}
\\begin{document}\n"""
# cration dun fichier tex

f = open ("page.tex", "w")
f.write (header)
f.write ("\\title{Tri quicksort}\n") # dfinit le titre

f.write ("\\maketitle\n") # crit le titre
f.write ("\\tableofcontents\n") # table des matires
f.write ("\\section{liste trie}\n") # titre pour la liste trie

s = str (racine) # on rcupre la liste trie
s = s.replace ("\n", "\\\\ \n") # \\ passe la ligne
f.write ("\\begin{tabular}{|l|}\n")
f.write (s)
f.write ("\\end{tabular}\n")
f.write ("\\section{graphe}\n") # titre pour limage

f.write (\\includegraphics[height=5cm]{graph.png}\n) # image
f.write ("\\section{code du graphe}\n") # titre pour le code du graphe

s = racine.chaine_graphe () # on rcupre le code du graphe
f.write ("\\begin{verbatimx}\n") # on laffiche tel quel
f.write (s)
f.write ("\\end{verbatimx}\n")
f.write ("\\end{document}\n") # fin

f.close ()
# on compile deux fois le fichier pour que la table des matires

# soit bien prise en compte
import os
os.system (r"C:\Program Files\MiKTeX 2.7\miktex\bin\pdflatex" page.tex)
os.system (r"C:\Program Files\MiKTeX 2.7\miktex\bin\pdflatex" page.tex)
# on affiche le rsultat avec Adobe Reader

os.system (r"C:\Program Files\Adobe\Reader 9.0\Reader\AcroRd32.exe" page.pdf)
La partie header est longue dans cet exemple, elle inclut des packages Latex qui
ne sont pas utiliss mais qui pourraient ltre dans le cas dun rapport plus long.
Il faut bien sr connatre quelques rudiments de ce langage pour construire le do-
cument PDF. Lavantage de ce systme est de pouvoir retravailler manuellement
le document final. Il est galement indiqu lorsque le rapport mlange tableaux de
chiffres rcuprs depuis diffrentes sources et graphiques qui peuvent tre gnrs
par Python via un module comme matplotlib 17 .
Sous Linux, il suffit de modifier les chemins daccs aux diffrentes applications. Une
dernire remarque, il existe sous Windows un diteur convenable qui est TeXnic-
Center 18 .
18. http://www.toolscenter.org/
Chapitre 11
Exercices pratiques pour svaluer
Les trois noncs qui suivent sont prvus pour tre raliss en deux heures sur un
ordinateur. Ils ne font rfrence aucun algorithme ou mthode connue. Il suffit
de connatre les types standard du Python, les boucles, les tests et les fonctions. Le
second nonc ncessite galement quelques notions sur les classes.
11.1 Recherche dichotomique

Lobjectif de cet exercice est de programmer une recherche dans une liste trie.
1) Il faut dabord rcuprer un fichier texte disponible sur Intranet 1 . Ce fichier
contient un mot par ligne. Il faut lire ce fichier et construire une liste avec tous ces
mots.
2) Construire une fonction qui vrifie que la liste charge la question prcdente
est trie.
3) Construire une fonction qui recherche un mot X dans la liste et qui retourne sa
position ou -1 si ce mot ny est pas. Cette fonction prend deux paramtres : la liste
et le mot chercher. Elle retourne un entier. On prcise que pour savoir si deux
chanes de caractres sont gales, il faut utiliser loprateur ==.
4) Quels sont les positions des mots "UN" et "DEUX" ? La rponse doit figurer en
commentaire dans le programme. Il faudra crire aussi le nombre de comparaisons
effectues pour trouver ces deux positions.
5) Lorsquune liste est trie, rechercher un lment est beaucoup plus rapide. Si on
cherche le mot X dans la liste, il suffit de le comparer au mot du milieu pour savoir
si ce mot est situ dans la partie basse (X infrieur au mot du milieu), la partie
haute (X suprieur au mot du milieu). Sil est gal, le mot a t trouv. Si le mot
na pas t trouv, on recommence avec la sous-liste infrieure ou suprieure selon
les cas jusqu ce quon ait trouv le mot ou quon soit sr que le mot cherch ny
est pas.
Le rsultat de la recherche est la position du mot dans la liste ou -1 si ce mot na
pas t trouv. Cette recherche sappelle une recherche dichotomique.
Ecrire la fonction qui effectue la recherche dichotomique dun mot dans une liste
trie de mots. Vrifiez que les deux fonctions retournent bien les mmes rsultats.
Cette fonction peut tre rcursive ou non. Elle prend au moins les deux mmes
paramtres que ceux de la question 3, si elle en a dautres, il faudra leur donner
1. http://www.xavierdupre.fr/enseignement/initiation/td_note_texte.txt
11. Exercices pratiques pour svaluer 271
une valeur par dfaut. On prcise que les comparaisons entre chanes de caractres
utilisent aussi les oprateurs <, ==, >.
6) Normalement, les positions des mots "UN" et "DEUX" nont pas chang mais il
faut de nouveau dterminer le nombre ditrations effectues pour trouver ces deux
positions avec la recherche dichotomique.
7) Quel est, au pire 2 , le cot dune recherche non dichotomique ? La rponse doit
figurer en commentaire dans le programme.
8) Quel est, au pire, le cot dune recherche dichotomique ? La rponse doit figurer
en commentaire dans le programme.
Correction
# coding: latin-1
# question 1
def lit_fichier (file) :
f = open (file, "r")
mot = []
for l in f :
mot.append ( l.replace ("\n", "") )
f.close ()
return mot
mot = lit_fichier ("td_note_texte.txt")

print mot
# question 2
def est_trie (mot) :
for i in range (1, len (mot)) :
if mot [i-1] > mot [i] :
return False
return True
tri = est_trie (mot)

print "liste trie ", tri
# question 3
def cherche (mot, m) :
for i in range (0, len (mot)) :
if mot [i] == m :
return i
return -1
print "mot ACHATS ", cherche (mot, "ACHATS")

print "mot achats ", cherche (mot, "achats")
# question 4
un = cherche (mot, "UN")
deux = cherche (mot, "DEUX")
print "recherche normale ", un, deux
print "nombre ditrations", un + deux
# question 5, 6, nbun et nbdeux contiennent le nombre de comparaisons

def cherche_dicho (mot, m) :
2. On cherche la meilleure majoration du cot de la recherche non dichotomique en fonction de

la taille n de la liste.
a = 0
b = len (mot)-1
nb = 0
while a < b :
nb += 1
p = (a+b)/2
if mot [p] == m : return p,nb
elif mot [p] > m : b = p-1
else : a = p+1
return -1,nb
un,nbun = cherche_dicho (mot, "UN")

deux,nbdeux = cherche_dicho (mot, "DEUX")
print "recherche dichotomique ", un, deux
print "nombre ditrations ", nbun + nbdeux
# question 7
"""
Lors dune recherche simple, au pire, llment cherche sera
en dernire position, ce qui signifie n itrations pour le trouver.
Le cot de la recherche simple est en O(n).
"""
# question 8
"""
Lors de la recherche dichotomique, chaque itration, on divise par deux
lensemble dans lequel la recherche seffectue,
au dpart n, puis n/2, puis n/4 jusqu ce que n/2^k soit nul
cest--dire k = partie entire de ln n / ln 2
il y a au plus k itrations donc le cot de lalgorithme est en O (ln n).
"""
11.2 Ajouter un jour fri

11.2.1 Avec des fonctions uniquement
Le gouvernement dsire ajouter un jour fri mais il voudrait le faire une date
loigne des jours fris existant. On suppose galement que ce jour ne sera pas
insr entre Nol et le jour de lan. On va donc calculer le nombre de jours qui
spare deux jours fris dont voici la liste pour lanne 2007 :
Jour de lan 1er janvier 2007

Lundi de Pques 9 avril 2007
Fte du travail 1er mai 2007
Victoire de 1945 8 mai 2007
Ascension 17 mai 2007
Lundi de Pentecte 4 juin 2007
Fte nationale 14 juillet 2007
Assomption 15 aot 2007
Toussaint 1er novembre 2007
Armistice de 1918 11 novembre 2007
Nol 25 dcembre 2007
On rappelle que lanne 2007 nest pas une anne bissextile et quen consquence,
le mois de fvrier ne comporte que 28 jours.
1) Afin de simplifier la tche, on cherche attribuer un numro de jour chaque
jour fri : lanne a 365 jours, pour le numro du lundi de Pques, soit 31 (mois
de janvier) + 28 (fvrier) + 31 (mars) + 9 = 89. La premire question consiste
construire une fonction qui calcule le numro dune date tant donn un jour et un
mois. Cette fonction prend comme entre :
un numro de jour
un numro de mois
une liste de 12 nombres correspondant au nombre de jours dans chacun des douze mois
de lanne
2) Si on dfinit la liste des jours fris comme tant une liste de couples (jour, mois)
trie par ordre chronologique, il est facile de convertir cette liste en une liste de
nombres correspondant leur numro dans lanne. La fonction crire ici appelle
la prcdente et prend une liste de couples en entre et retourne comme rsultat une
liste dentiers.
3) A partir de cette liste dentiers, il est facile de calculer lcart ou le nombre de
jours qui sparent deux jours fris. Il ne reste plus qu crire une fonction qui
retourne lcart maximal entre deux jours fris, ceux-ci tant dfinis par la liste
de numros dfinie par la question prcdente. Un affichage du rsultat permet de
dterminer les deux jours fris les plus loigns lun de lautre. Quels sont-ils ?
11.2.2 Programme quivalent avec des classes

Le programme prcdent nutilise pas de classe. Lobjectif de ce second exercice est
de le rcrire avec une classe.
1) Une fonction du programme prcdent effectue la conversion entre un couple jour-
mois et un numro de jour. Les calculs sont faits avec le numro mais le rsultat
dsir est une date : les numros ne sont que des intermdiaires de calculs qui ne
devraient pas apparatre aussi explicitement. La premire question consiste crer
une classe Date :
class Date :
def __init__ (self, jour, mois) :
...
2) A cette classe, on ajoute une mthode qui retourne la conversion du couple jour-
mois en un numro de jour de lanne.
3) On ajoute maintenant une mthode calculant le nombre de jours sparant deux
dates (ou objet de type Date et non pas numros). Cette mthode pourra par exemple
sappeler difference.
4) Il ne reste plus qu complter le programme pour obtenir les mmes rsultats
que le programme de lexercice 1.
5) Avec ce programme, lors du calcul des carts entre tous les jours fris conscutifs,
combien de fois effectuez-vous la conversion du couple jour-mois en numro pour
le second jour fri de lanne ? Est-ce le mme nombre que pour le programme
prcdent (en toute logique, la rponse pour le premier programme est 1) ?
6) La rponse la question prcdente vous suggre-t-elle une modification de ce
second programme ?
Correction
# coding: latin-1
####################################
# exercice 1
####################################
# question 1
def numero (jour, mois, duree = [31, 28, 31,30,31,30,31,31,30,31,30,31] ) :
s = 0
for i in range (0,mois-1) :
s += duree [i]
s += jour - 1
return s+1
# question 2
def conversion_liste (li) :
res = []
for jour,mois in s : res.append ( numero (jour, mois))
# pareil que
# for i in range (0, len (s)) : res.append ( numero (s [i][0], s [i][1]))
return res
def ecart (num) :

res = []
for i in range (1, len (num)) :
d = num [i] - num [i-1]
res.append (d)
return res
s = [ (1,1), (9,4), (1,5), (8,5), (17,5), (4,6), (14,7), \

(15,8), (1,11), (11,11), (25,12) ]
r = conversion_liste (s)
ec = ecart (r)
# question 3
pos = ec.index ( max (ec) )
print "position de lcart le plus grand ", pos
print "jour ", s [pos], " --> ", s [pos+1]
####################################
# exercice 2
####################################
# question 4
class Date :
self.jour = jour
self.mois = mois
self.duree = [31, 28, 31,30,31,30,31,31,30,31,30,31]
# question 5
def numero (self) :
s = 0
for i in range (0,self.mois-1) :
s += self.duree [i]
s += self.jour - 1
return s+1
# question 6
def difference (self, autre) :
return self.numero () - autre.numero ()
def conversion_date (s) :

res = []
for jour,mois in s :
res.append ( Date (jour, mois) )
return res
def ecart_date (date) :

ec = []
for i in range (1, len (date)) :
ec.append ( date [i].difference ( date [i-1] ) )
return ec
# question 7
s = [ (1,1), (9,4), (1,5), (8,5), (17,5), (4,6), \
(14,7), (15,8), (1,11), (11,11), (25,12) ]
r = conversion_date (s)
ec = ecart_date (r)
print "position de lecart le plus grand ", pos
# question 8
"""
La conversion en Date est faite une fois pour les dates (1,1) et (25,12)
et 2 fois pour les autres en effet, la mthode difference effectue
la conversion en numros des dates self et autre
la fonction ecart_date calcule date [i].difference ( date [i-1] ) et
date [i+1].difference ( date [i] )
--> la date [i] est convertie 2 fois
"""
# question 9
"""
On peut par exemple stocker la conversion en numro
dans le constructeur comme suit :
"""
class Date :
self.jour = jour
self.mois = mois
self.duree = [31, 28, 31,30,31,30,31,31,30,31,30,31]
self.num = self.numero ()
# question 5
def numero (self) :

s = 0
for i in range (0,self.mois-1) :
s += self.duree [i]
s += self.jour - 1
return s+1
# question 6
def difference (self, autre) :
return self.num - autre.num
r = conversion_date (s)
ec = ecart_date (r)
print "position de lcart le plus grand ", pos
On pourrait encore amliorer la dernire classe Date en crant un attribut statique

pour lattribut duree qui est identique pour toutes les instances de la classe Date.
11.3 Frquentation dun site Internet

Lorsquon se connecte un site internet, celui-ci enregistre votre adresse IP, lheure
et la date de connexion ainsi que la page ou le fichier dsir. Ainsi le fichier logpdf.txt 3
recense ces quatre informations spares par des espaces pour les fichiers dextension
pdf tlchargs sur le site http://www.xavierdupre.fr/.
1) La premire tape consiste charger les informations depuis le fichier texte dans
une matrice de 4 colonnes (liste de listes, liste de t-uples). On utilisera pour cela les
fonctions open et les mthodes split, replace associes aux chanes de caractres.
On pourra saider des corrections des TD prcdents.
2) On souhaite dans un premier temps faire des statistiques sur les dates : on veut
compter le nombre de fichiers tlchargs pour chaque date prsente dans les don-
nes. On pourra pour cela utiliser un dictionnaire dont la cl sera bien choisie. Le
rsultat devra tre insr dans une fonction prenant comme entre une matrice (ou
liste de listes, liste de t-uples) et retournant un dictionnaire comme rsultat.
3) On sintresse au programme suivant :
l = [ (1, "un"), (3, "deux",), (2, "deux"), (1, "hun"), (-1, "moinsun") ]
l.sort (reverse = True)
print l
Donc le rsultat est :

[(3, deux), (2, deux), (1, un), (1, hun), (-1, moinsun)]
Que sest-il pass ?

4) On dsire maintenant connatre les 10 dates pour lesquelles il y a eu le plus
de tlchargements ces jours-l. Linconvnient est que le dictionnaire labor la
3. Il faut tlcharger ce fichier depuis ladresse http://www.xavierdupre.fr/enseignement/
initiation/logpdf.txt
question 2 ne retourne pas les rponses dans lordre souhait : il faut classer les
dates par nombre de tlchargements croissants. Il faut ici imaginer une fonction
qui retourne ces dix meilleures dates et des dix frquentations correspondantes en
se servant de la remarque de la question 3.
5) Effectuez le mme travail pour dterminer les dix documents les plus tlchargs.
6) Ecrire une fonction qui retourne lheure sous forme dentier partir dune
date dfinie par une chane de caractres au format hh : mm : ss. Par exemple,
pour 14 : 55 : 34, la fonction doit retourner 14 sous forme dentier. Linstruction
int(14) convertit une chane de caractres en un entier.
7) Calculer le nombre de documents tlchargs pour chaque heure de la journe.
Le site est-il consult plutt le matin ou le soir ? Serait-il possible de conclure aussi
rapidement pour un site daudience internationale ?
Correction
# coding: latin-1
# la premire ligne autorise les accents dans un programme Python
# la langue anglaise est la langue de linformatique,
# les mots-cls de tous les langages
# sont crits dans cette langue.
####################################
# exercice 1
####################################
#
# question 1
def lit_fichier (file) :
f = open (file, "r")
li = f.readlines () # dcoupage sous forme de lignes
f.close ()
res = []
for l in li :
s = l.replace ("\n", "")
s = s.split (" ") # le sparateur des colonnes est lespace
res.append (s)
return res
mat = lit_fichier ("logpdf.txt")

for m in mat [0:5] : # on affiche les 5 premires lignes
print m # parce que sinon, cest trop long
# question 2
def compte_date (mat) :
d = { }
for m in mat :
date = m [1] # cl
if date in d : d [date] += 1
else : d [date] = 1
return d
dico_date = compte_date (mat)

print dico_date
# remarque gnrale : si le fichier logpdf.txt contient des lignes

# vides la fin, il se produira une erreur la ligne 34 (date = m [1])
# car la matrice mat contiendra des lignes avec une seule colonne et non quatre.
# Il suffit soit de supprimer les lignes vides du fichier logpdf.txt
# soit de ne pas les prendre en compte lors de la lecture de ce fichier.
# question 3
# La mthode sort trie la liste mais comment ?
# Il est facile de trier une liste de nombres mais une liste de couples de
# nombres ? Lexemple montre que la liste est trie selon le premier lment de
# chaque couple. Pour les cas o deux couples ont un premier lment en commun,
# les lments semblent tris selon le second lment. Lexemple suivant le monte :
l = [(1, "un"), (3, "deux",), (2, "deux"), (1, "hun"), (1, "un"), (-1, "moinsun")]
l.sort (reverse = True)
print l # affiche [(3, deux), (2, deux), (1, un),
# (1, un), (1, hun), (-1, moinsun)]
# question 4
def dix_meilleures (dico) :
# dans cette fonction on cre une liste de couples (valeur,cl) ou
# la cl reprsente une date et valeur le nombre de tlchargement
# pour cette date
li = []
for d in dico :
cle = d
valeur = dico [cle]
li.append ( ( valeur, cle ) )
li.sort (reverse = True)
return li [0:10]
dix = dix_meilleures (dico_date)

print dix # la premire date est (283, 26/Sep/2007)
# les quatre premires dates correspondent aux quatre premiers TD en 2007 lENSAE
# question 5
# la date est en colonne 1, le document en colonne 3
# on fait un copier-coller de la fonction compte_date en changeant un paramtre
def compte_document (mat) :
d = { }
for m in mat :
doc = m [3] # cl, 3 au lieu de 1 la question 2
if doc in d : d [doc] += 1
else : d [doc] = 1
return d
dix = dix_meilleures ( compte_document (mat) )

print dix # le premier document est
# (323, /mywiki/Enseignements?.....target=python_cours.pdf),
# question 6
def heure (s) :
hs = s [0:2] # on extrait la partie correspondant lheure
return int (hs) # on retourne la conversion sous forme dentiers
# question 7
# on recommence avec un copier-coller
def compte_heure (mat) :
d = { }
for m in mat :
h = m [2] # cl, 2 au lieu de 1 la question 2
cle = heure (h)
if cle in d : d [cle] += 1
else : d [cle] = 1
return d
h = compte_heure (mat)
dix = dix_meilleures ( h )
print dix # la premire heure est (432, 17), ce qui correspond lheure des TD
for i in h :
print i, "h ", h [i]
# Il y a beaucoup plus de tlchargement entre 20h et 2h du matin

# que le matin avant 10h.
# Le site est plutt consult le soir.
# La conclusion ne serait pas aussi vidente avec un site consult par des gens
# du monde entier puisque 6h du matin est une heure de laprs midi au Japon.
# Il faudrait croiser lheure avec la position gographique de la personne
# qui consulte le site.
Chapitre 12
Exercices crits
Chacun des noncs qui suit est une srie dexercices auxquels une personne ex-
primente peut rpondre en une heure. Cest souvent le temps imparti un test
informatique lors dun entretien dembauche pendant lequel le candidat propose des
ides plus quil ne rdige des solutions. Chaque nonc est un panel reprsentatif
des problmes que la programmation amne invitablement. La difficult de chaque
exercice est note du plus facile au plus difficile : *, **, ***. Le sixime nonc 12
est structur sous forme de problme. Il cherche reproduire la dmarche suivie lors
de la conception dun algorithme.
12.1 Premier nonc

12.1.1 Programme deviner *
Que fait le programme suivant ? Que contiendra res la fin du programme ?
l = [ 0,1,2,3,4,6,5,8,9,10]
res = True
for i in range (1,len (l)) :
if l[i-1] > l[i] :
res = False
Correction
Le programme vrifie que la liste l est trie, res vaut True si elle est trie, False
sinon. Et dans ce cas prcis, elle vaut False car la liste nest pas trie (4,6,5).
12.1.2 Somme des chiffres dun nombre *

Ecrire une fonction qui calcule la somme des chiffres dun entier positif.
Correction
Tout dabord, obtenir la liste des chiffres dun nombre entier n nest pas immdiat
bien quelle puisse scrire en une ligne :
def somme (n) :
return sum ( [ int (c) for c in str (n) ] )
12. Exercices crits 281
Cette criture rsume cache une conversion en chane de caractres. Une boucle est
invitable moins de procder par rcurrence. Commenons par une version plus
tendue et qui passe par les chanes de caractres. Pour cette version, il ne faut pas
oublier de faire la conversion inverse, cest--dire celle dun caractre en nombre.
def somme (n) :
l = str (n) # il ne faut pas confondre l=str (n) avec l = "n"
s = 0
for c in l : # ou for i in range (0, len (c)) :
s += int (c) # ou s += int (c [i])
return s
Une version numrique maintenant, celle qui utilise lopration % ou modulo pour
obtenir le dernier chiffre :
def somme (n) :
s = 0
while n > 0 :
s += n % 10
n /= 10 # ici, cest une division entire, si vous ntes pas sr :
# n = int (n/10)
return n
Enfin, une autre solution utilisant la rcurrence et sans oublier la condition darrt :
def somme (n) :

if n <= 0 : return 0
else : return (n % 10) + somme ( n / 10 )
Parmi les autres solutions, certaines, exotiques, ont utilis la fonction log en base
10 ou encore la fonction exp. En voici une :
import math
def somme (n) :
k = int (math.log (n) / math.log (10) + 1)
s = 0
for i in range (1,k+1) :
d = 10 ** i # ou encore d = int (exp ( k * log (10) ) )
c = n / d
e = n - c * d
f = e / (d / 10)
s += f
return s
Lide principale permet de construire une fonction retournant le rsultat souhait

mais il faut avouer quil est plus facile de faire une erreur dans cette dernire fonction
que dans les trois prcdentes.
12.1.3 Calculer le rsultat dun programme **

Que vaut n la fin de lexcution du programme suivant ? Expliquez en quelques
mots le raisonnement suivi.
n = 0
if (n + i) % 3 == 0 :
n += 1
Correction
Lensemble range(0, 10) est gale la liste [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]. Dans ce pro-
gramme, n est incrment lorsque i + n est un multiple de 3. La premire incr-
mentation a lieu lors de la premire itration puisque 0 est un multiple de 3. On
droule le programme dans le tableau suivant :
i 0 1 2 3 4 5 6 7 8 9
n avant le test 0 1 1 2 2 3 3 4 4 5
i+n 0 2 3 5 6 8 9 11 12 14
n aprs le test 1 1 2 2 3 3 4 4 5 5
range(0, 10) contient les nombres de 0 10 exclu. La rponse cherche est donc 5.
12.1.4 Suite rcurrente (Fibonacci) *

Ecrire un programme qui calcule llment u13 de la suite dfinie par :
u1 = 1
u2 = 2
n 2, un = un1 + un2
u13 est le nombre de manires possibles pour une grenouille de monter en haut
dune chelle de 13 barreaux si elle peut faire des bonds de un ou deux barreaux
seulement. Si cette affirmation, qui nest pas dmontrer, vous semble douteuse,
avant dy revenir, faites dabord le reste de lnonc.
Correction
Tout dabord, la grenouille : elle peut faire des bonds de un ou deux barreaux
chaque fois. Donc, lorsquelle est sur le barreau n, elle a pu venir du barreau n 1
et faire un saut de 1 barreau ou venir du barreau n 2 et faire un bond de 2 bar-
reaux. Par consquent, le nombre de manires qua la grenouille datterrir sur le
barreau n, cest la somme des manires possibles de venir jusquau barreau n 1 et
du barreau n 2.
Maintenant, comment le programmer ? Tout dabord les solutions rcursives, les plus
simples programmer :
def grenouille (n) :
elif n == 1 : return 1
else : return grenouille (n-1) + grenouille (n-2)
print grenouille (13)
Cette solution nest pas trs rapide car si grenouille(13) va tre appele une fois,
grenouille(12) une fois aussi, mais grenouille(11) va tre appele deux fois... Cette
solution implique un grand nombre de calculs inutiles.
Aprs la solution rcursive descendante (n dcrot), la solution rcursive montante
(n crot) :
def grenouille (fin, n = 2, u1 = 1, u2 = 2) :
if fin == 1 : return u1
elif fin == 2 : return u2
elif n == fin : return u2
u = u1 + u2
return grenouille (fin, n+1, u2, u)
La mthode la plus simple est non rcursive mais il ne faut pas se tromper dans les
indices :
u1 = 1
u2 = 2
for i in range (3,n+1) :
u = u1 + u2 # il est impossible de
u1 = u2 # rsumer ces trois lignes
u2 = u # en deux
return u2
Quelques variantes utilisant les listes :

u = [1,2]
u.append (u [i-1] + u [i-2])
return u [n-1]
Ou encore :
u = range (0, n) # il ne faut pas oublier de crer le tableau
# avec autant de cases que ncessaire
# ici 13
u [0] = 1
u [1] = 2
u [i] = u [i-1] + u [i-2]
return u [n-1]
12.1.5 Comprendre une erreur dexcution *

On crit le programme suivant :
a = "abcdefghijklmnopqrstuvwxyz"
print len (a)
d = {}
for i in range (0,len (a)) :
d [ a [ i ] ] = i
print d ["M"]
Une erreur est dclenche lors de lexcution :

examen.py:14: KeyError: M
Que faudrait-il crire pour que le programme marche ? Quaffichera-t-il alors ?
Correction
Lerreur signifie que la cl M nest pas prsente dans le dictionnaire d. Elle nest
prsente quen minuscule. La modification propose est la suivante :
print len (a)
d = {}
d [ a [ i ] ] = i
print d ["m"] ###### ligne modifie
Mais il tait galement possible de procder comme suit :

a = a.upper () ####### ligne ajoute
print len (a)
d = {}
d [ a [ i ] ] = i
print d ["M"]
Dans les deux cas, le programme affiche la position de M dans lalphabet qui est 12
car les indices commencent 0.
12.1.6 Copie de variables **

def somme (tab) :
l = tab[0]
for i in range (1, len (tab)) :
l += tab [i]
return l
ens = [[0,1],[2,3]]
print somme ( ens ) # affiche [0,1,2,3]
print ens # affiche [ [0,1,2,3], [2,3] ]
La fonction somme est cense faire la concatnation de toutes les listes contenues
dans ens. Le rsultat retourn est effectivement celui dsir mais la fonction modifie
galement la liste ens, pourquoi ?
Correction
Le problme vient du fait quune affectation en Python (seconde ligne de la fonction
somme) ne fait pas une copie mais cre un second identificateur pour dsigner la
mme chose. Ici, l et tab[0] dsignent la mme liste, modifier lune modifie lautre.
Ceci explique le rsultat. Pour corriger, il fallait faire une copie explicite de tab[0] :
import copy ###### ligne ajoute

def somme (tab) :
l = copy.copy (tab[0]) ###### ligne modifie
for i in range (1, len (tab)) :
l += tab [i]
return l
ens = [[0,1],[2,3]]
Il tait possible, dans ce cas, de se passer de copie en crivant :

def somme (tab) :
l = [] ###### ligne modifie
for i in range (0, len (tab)) : ###### ligne modifie
l += tab [i]
return l
ens = [[0,1],[2,3]]
12.1.7 Comprendre une erreur dexcution **

On crit le programme suivant :
li = range (0,10)
sup = [0,9]
for i in sup :
del li [i]
print li
Mais il produit une erreur :

examen.py:44: IndexError: list assignment index out of range
Que se passe-t-il ? Comment corriger le programme pour quil marche correctement ?

Quaffichera-t-il alors ?
Correction
Lerreur signifie quon cherche accder un lment de la liste mais lindice est
soit ngatif, soit trop grand. Pour comprendre pourquoi cette erreur se produit, il
faut suivre les modifications de la liste li dans la boucle for. Au dpart, li vaut
range(0, 10), soit :
[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Lors du premier passage de la boucle, on supprime llment dindice 0, la liste li

est donc gale :
[ 1, 2, 3, 4, 5, 6, 7, 8, 9]
Et elle ne contient plus que 9 lments au lieu de 10, donc le dernier lment est celui
dindice 8. Or lors du second passage dans la boucle for, on cherche supprimer
llment dindice 9, ce qui est impossible. Lide la plus simple pour corriger lerreur
est de supprimer les lments en commenant par ordre dindices dcroissant :
li = range (0,10)
sup = [9,0] ####### ligne modifie
for i in sup :
del li [i]
print li
Mais on pouvait tout fait crire aussi sup = [0, 8] mme si ce nest la rponse que
je conseillerais. Lobjectif du programme ntait pas de supprimer toute la liste li.
Une dernire prcision, pour supprimer llment dindice i de la liste li, on peut
crire soit del li[i] soit del li[i :i+1].
12.1.8 Comprendre une erreur de logique **

Le programme suivant fonctionne mais le rsultat nest pas celui escompt.
l = ["un", "deux", "trois", "quatre", "cinq"]
mi = i
for j in range (i, len (l)) :
if l[mi] < l [j] : mi = j
e = l [i]
l [mi] = l [i]
l [i] = e
print l
Le rsultat affich est :

[un, deux, deux, deux, cinq]
Quest cens faire ce programme ? Quelle est lerreur ?
Correction
Ce programme est cens effectuer un tri par ordre alphabtique dcroissant. Le
problme intervient lors de la permutation de llment l[i] avec llment l[mi]. Il
faut donc crire :
l = ["un", "deux", "trois", "quatre", "cinq"]
mi = i
for j in range (i, len (l)) :
if l[mi] < l [j] : mi = j
e = l [mi] ######## ligne modifie
l [mi] = l [i]
l [i] = e
print l
12.1.9 Cot dun algorithme **

Le cot dun algorithme ou dun programme est le nombre doprations (additions,
multiplications, tests, ...) quil effectue. Il sexprime comme un multiple dune fonc-
tion de la dimension des donnes que le programme manipule. Par exemple : O(n),
O(n2 ), O(n ln n), ...
Quel est le cot de la fonction variance en fonction de la longueur de la liste tab ?
Ny a-t-il pas moyen de faire plus rapide ?
def moyenne (tab) :
s = 0.0
for x in tab :
s += x
return s / len (tab)
def variance (tab) :

s = 0.0
for x in tab :
t = x - moyenne (tab)
s += t * t
l = [ 0,1,2, 2,3,1,3,0]
print moyenne (l)
print variance (l)
Correction
Tout dabord, le cot dun algorithme est trs souvent exprim comme un multiple
de la dimension des donnes quil traite. Ici, la dimension est la taille du tableau
tab. Par exemple, si on note n = len(tab), alors le cot de la fonction moyenne scrit
O(n) car cette fonction fait la somme des n lments du tableau.
La fonction variance contient quant elle un petit pige. Si elle contient elle aussi
une boucle, chacun des n passages dans cette boucle fait appel la fonction moyenne.
Le cot de la fonction variance est donc O(n2 ).
Il est possible dacclrer le programme car la fonction moyenne retourne le mme
rsultat chaque passage dans la boucle. Il suffit de mmoriser son rsultat dans
une variable avant dentrer dans la boucle comme suit :
def variance (tab) :
s = 0.0
m = moyenne (tab)
for x in tab :
t = x - m
s += t * t
Le cot de la fonction variance est alors O(n).

Remarque 12.1 : cot dun algorithme
Le cot dun algorithme peut tre valu de manire plus prcise et ncessiter un
rsultat comme n2 + 3n + 2 mais cette exigence est rarement utile pour des lan-
gages comme Python. Lexpression for x in tab : cache ncessairement un test quil
faudrait prendre en compte si plus de prcision tait exige. Il faudrait galement

se tourner vers un autre langage de programmation, plus prcis dans sa syntaxe.
Par exemple, lorsquon conoit un programme avec le langage C ou C++, par-
tir du mme code informatique, on peut construire deux programmes excutables.
Le premier (ou version debug), lent, sert la mise au point : il inclut des tests
supplmentaires permettant de vrifier chaque tape quil ny a pas eu derreur
(une division par zro par exemple). Lorsquon est sr que le programme marche,
on construit la seconde version (ou release), plus rapide, dont ont t ts tous ces
tests de conception devenus inutiles.
Python aboutit un programme lent qui inclut une quantit de tests invisibles pour
celui qui programme mais qui dtecte les erreurs plus vite et favorise une conception
rapide. Il nest pas adapt au traitement dinformation en grand nombre et fait une
multitude doprations caches.
12.1.10 Hritage **
On a besoin dans un programme de crer une classe carre et une classe rectangle.
Mais on ne sait pas quelle classe doit hriter de lautre. Dans le premier programme,
rectangle hrite de carre.
class carre :
def __init__ (self, a) :
self.a = a
def surface (self) :
return self.a ** 2
class rectangle (carre) :

def __init__ (self, a,b) :
carre.__init__(self,a)
self.b = b
return self.a * self.b
Dans le second programme, cest la classe carre qui hrite de la classe rectangle.
class rectangle :
self.a = a
self.b = b
class carre (rectangle) :

rectangle.__init__ (self, a,a)
return self.a ** 2
1) Dans le second programme, est-il ncessaire de redfinir la mthode surface dans

la classe carre ? Justifiez.
2) Quel est le sens dhritage qui vous parat le plus cens, class rectangle(carre)
ou class carre(rectangle) ? Justifiez.
3) On dsire ajouter la classe losange. Est-il plus simple que rectangle hrite de la
classe carre ou linverse pour introduire la classe losange ? Quel ou quels attributs
supplmentaires faut-il introduire dans la classe losange ?
Correction
1) Le principe de lhritage est quune classe carre hritant de la classe rectangle
hrite de ses attributs et mthodes. Laire dun carr est gale celle dun rectangle
dont les cts sont gaux, par consquent, la mthode surface de la classe retourne
la mme valeur que celle de la classe rectangle. Il nest donc pas ncessaire de la
redfinir.
2) Daprs la rponse de la premire question, il parat plus logique de considrer
que carre hrite de rectangle.
3) Un losange est dfini par un ct et un angle ou un ct et la longueur dune de
ses diagonales, soit dans les deux cas, deux paramtres. Dans la premire question,
il paraissait plus logique que la classe la plus spcifique hrite de la classe la plus
gnrale afin de bnficier de ses mthodes. Pour introduire le losange, il parat plus
logique de partir du plus spcifique pour aller au plus gnral afin que chaque classe
ne contienne que les informations qui lui sont ncessaires.
class carre :
self.a = a
return self.a ** 2
class rectangle (carre) :

self.b = b
class losange (carre) :

def __init__ (self, a,theta) :
self.theta = theta
return self.a * math.cos (self.theta) * self.a * math.sin (self.theta) * 2
Le sens de lhritage dpend de vos besoins. Si lhritage porte principalement sur

les mthodes, il est prfrable de partir du plus gnral pour aller au plus spci-
fique. La premire classe sert dinterface pour toutes ses filles. Si lhritage porte
principalement sur les attributs, il est prfrable de partir du plus spcifique au plus
gnral. Dans le cas gnral, il ny a pas dhritage plus sens quun autre mais pour
un problme donn, il y a souvent un hritage plus sens quun autre.
12.1.11 Prcision des calculs ***

1) On excute le programme suivant :
x = 1.0
x = x / 10
print i, "\t", 1.0 - x, "\t", x, "\t", x **(0.5)
Il affiche lcran le rsultat suivant :

0 0.90000000000000002220 0.1 0.316227766017
1 0.98999999999999999112 0.01 0.1
2 0.99899999999999999911 0.001 0.0316227766017
3 0.99990000000000001101 0.0001 0.01
4 0.99999000000000004551 1e-05 0.00316227766017
5 0.99999899999999997124 1e-06 0.001
6 0.99999990000000005264 1e-07 0.000316227766017
7 0.99999998999999994975 1e-08 0.0001
8 0.99999999900000002828 1e-09 3.16227766017e-05
9 0.99999999989999999173 1e-10 1e-05
10 0.99999999998999999917 1e-11 3.16227766017e-06
11 0.99999999999900002212 1e-12 1e-06
12 0.99999999999989996891 1e-13 3.16227766017e-07
13 0.99999999999999000799 1e-14 1e-07
14 0.99999999999999900080 1e-15 3.16227766017e-08
15 0.99999999999999988898 1e-16 1e-08
16 1.00000000000000000000 1e-17 3.16227766017e-09
17 1.00000000000000000000 1e-18 1e-09
18 1.00000000000000000000 1e-19 3.16227766017e-10
19 1.00000000000000000000 1e-20 1e-10
Que peut-on en dduire ?

2) On crit une classe matrice_carree_2 qui reprsente une matrice carre de di-
mension 2.
class matrice_carree_2 :
def __init__ (self, a,b,c,d) :
self.a, self.b, self.c, self.d = a,b,c,d
def determinant (self) :

return self.a * self.d - self.b * self.c
m1 = matrice_carree_2 (1.0,1e-6,1e-6,1.0)
m2 = matrice_carree_2 (1.0,1e-9,1e-9,1.0)
print m1.determinant ()
print m2.determinant ()
Quaffichent les deux dernires lignes ?

109

1
3) On considre la matrice M = .
109 1
On pose D = det(M ) = 1 1018 et T = tr(M ) = 2. est le dterminant de M et
T sa trace. On sait que les valeurs propres de M notes 1 , 2 vrifient :
D = 1 2
T = 1 + 2
On vrifie que (x 1 ) (x 2 ) = x2 x (1 + 2 ) + 1 2 . Les valeurs propres de

M sont donc solutions de lquation : x2 T x + D = 0.
Le discriminant de ce polynme est = T 2 4D. On peut donc exprimer les valeurs
propres de la matrice M par :

T
1 = 2
T+
2 = 2
On ajoute donc la mthode suivante la classe matrice_carree_2 :

def valeurs_propres (self) :
det = self.determinant ()
trace = self.a + self.d
delta = trace ** 2 - 4 * det
l1 = 0.5 * (trace - (delta ** (0.5)) )
l2 = 0.5 * (trace + (delta ** (0.5)) )
return l1,l2
Daprs la prcdente question, que retourne cette mthode pour la matrice M ? (

justifier)
109

1 0 0
4) On dcompose la matrice M = + = I + M 0.
0 1 109 0
On peut dmontrer que si est une valeur propre de M 0 , alors 1 + est une valeur
propre de M . Que donne le calcul des valeurs propres de M 0 si on utilise la mthode
valeurs_propres pour ces deux matrices ?
109

00 1
5) On considre maintenant la matrice M = . En dcomposant
109 1
la matrice M 00 de la mme manire qu la question 4, quelles sont les valeurs propres
retournes par le programme pour la matrice M 00 ? Quelles sont ses vraies valeurs
propres ?
Correction
Lexercice a pour but de montrer que lordinateur ne fait que des calculs approchs
et que la prcision du rsultat dpend de la mthode numrique employe.
1) Le programme montre que lordinateur affiche 1 lorsquil calcule 1 1017 . Cela
signifie que la prcision des calculs en Python est au mieux de 1016 .
2) Il sagit ici de donner le rsultat que calcule lordinateur et non le rsultat tho-
rique qui sera toujours exact. On cherche calculer ici le dterminant des matrices
M1 et M2 dfinies par :
106 109

1 1
M1 = et M2 =
106 1 109 1
Or, le programme propos calcule les dterminants comme suit :
det M1 = 1 1012 et det M2 = 1 1018
Daprs les affichages du programme de la question 1, le programme de la question 2

donnera comme rponse :
0.99999999999900002212
1.00000000000000000000
La seconde valeur est donc fausse.

3) Le dterminant est utilis pour calculer les valeurs propres dune matrice. Cette
question sintresse la rpercussion de lapproximation faite pour le dterminant
sur les valeurs propres. Daprs lnonc, les deux valeurs propres sont calcules
comme tant :
l1 = 0.5 * (trace - ((trace ** 2 - 4 * det) ** (0.5)) )
l2 = 0.5 * (trace + ((trace ** 2 - 4 * det) ** (0.5)) )
Pour la matrice M1 , on obtient donc en remplaant le dterminant par

0.99999999999900002212, on obtient les rponses donnes par le petit programme
de la question 1 :
l1 = 1,000001
l2 = 0.99999899999999997124 # gale 1 - 1e-6
Pour la matrice M2 , le dterminant vaut 1. En remplaant trace par 2 et det par 1,

on obtient :
l1 = 1
l2 = 1
4)
On change la mthode de calcul pour la matrice M2 , on crit que M2 = I +
0 10 9
= I + M20 . Cette fois-ci le dterminant calcul par Python est bien
109 0
1e 18. La trace de la matrice M20 est nulle, on applique les formules suivantes la
matrice M20 pour trouver :
l1 = 0.5 * (trace - ((trace ** 2 - 4 * det) ** (0.5)) ) = - det ** 0.5 = -1e-9

l2 = 0.5 * (trace + ((trace ** 2 - 4 * det) ** (0.5)) ) = det ** 0.5 = 1e-9
Daprs lnonc, les valeurs propres de la matrice M2 sont les sommes de celles de
la matrice I et de la matrice M20 . Par consquent, ce second calcul mne au rsultat
suivant :
l1 = 1-1e-9 = 0.99999999900000002828
l2 = 1+ 1e-9 = 1.000000001
5) La matrice M 00 nest en fait pas diagonalisable, cest--dire que tr (M 00 )2 4

det M 00 = 4 4(1 + 1018 ) < 0. Or le calcul propos par la question 3 aboutit au
mme rsultat faux que pour la matrice M2 , les deux valeurs propres trouves seront
gales 1. Si on applique la dcomposition de la question 4 :
109

0
M 00 = I + = I + N 00
109 0
Le programme calcule sans erreur le discriminant ngatif de la matrice N 00 qui nest

pas diagonalisable. Il est donc impossible dobtenir des valeurs propres relles pour
la matrice M 00 avec cette seconde mthode.
Cette question montre quune erreur dapproximation peut rendre une matrice dia-
gonalisable alors quelle ne lest pas. Il est possible daccrotre la prcision des calculs
mais il faut faire appel des modules externes 1 .
12.2 Second nonc

12.2.1 Logarithme en base deux **
On veut crire une fonction qui retourne n tel que n soit le premier entier qui vrifie
2n k. Cette fonction prend comme paramtre dentre k et retourne galement un
entier. Elle ne devra utiliser ni logarithme ni exponentielle. On prcise quen langage
Python, 2**n signifie 2 la puissance n. Une boucle for ne semble pas indique dans
ce cas.
Correction
Lindication qui prconisait dutiliser autre chose quune boucle for ne voulait pas
dire ne pas utiliser de boucle du tout mais une boucle while. La majorit des lves
ont russi trouver la fonction suivante :
def fonction_log2 (k) :
n = 0
while 2**n < k :
n += 1
return n
Mme sil est possible dutiliser malgr tout une boucle for :
if 2**i >= k :
return i
Voici un exemple de fonction rcursive :

if k <= 1 : return 0
else : return fonction_log2 ((k+1)/2)+1

On dfinit la fonction suivante :
def parcours (n) :
i = 1
j = 1
1. comme le module GMPy, http://code.google.com/p/gmpy/

while i+j < n :

print (i,j)
i += 1
j -= 1
if j < 1 :
j = i+j
i = 1
Quelles sont les 6 lignes quaffiche cette fonction si n = 5 ?
Correction
La solution est : Et si on continue :
(1,1) (1,4)
(1,2) (2,3)
(2,1) (3,2)
(1,3) (4,1)
(2,2) (1,5)
(3,1) (2,4)
(3,3)
...
Il fallait voir deux choses importantes dans lnonc de lexercice, tout dabord, les
deux lignes suivantes :
i += 1
j -= 1
Elles signifient que lorsque i augmente de 1, j diminue de 1. Lautre information est

que j ne devient jamais infrieur 1 :
if j < 1 :
j = i+j
i = 1
Et lorsque ce cas arrive, i devient gal 1, j devient gale i+j, soit i+1 puisque la
condition est vrifie lorsque j == 1. Ce programme propose une faon de parcourir
lensemble des nombres rationnels de la forme ji .

Que vaut n la fin du programme suivant ? Il nest en principe pas ncessaire daller
jusqu i = 10.
def suite (n) :
n = n ** 2 / 2 + 1
return n
n = 3
n = suite (n) % 17
print n
Correction
Il est difficile darriver au bout des calculs correctement lors de cet exercice. La
premire chose faire est didentifier la relation entre n et n + 1. On rappelle que
le symbole % dsigne le reste dune division entire et que / dsigne une division
entire car tous les nombresh manipuls
i dans ce programme sont entiers. La fonction
2
suite aboutit f (n) = E n2 + 1 o E [x] dsigne la partie entire de x. Ajout
aux trois dernires lignes, on obtient :
2
n
un+1 = f (un )%17 = E + 1 %17
2
Mme si i nest pas utilis dans la boucle for, celle-ci sexcute quand mme 10 fois.
Pour trouver la valeur finale de n, on calcule donc les premiers termes comme suit :
i 0 1 2 3 4
ui = n 3 5 13 0 1
n2 h i 9 25 169 0 1
n2
y=E 2 + 1 4 12 85 1 1
ui+1 = y%17 5 13 0 1 1
A partir de i = 3, la suite reste constante et gale 1. Il nest pas ncessaire daller

plus loin.

Le programme suivant est incorrect.
def compte_lettre (s) :
nombre = {}
for c in s :
nombre [c] += 1
return nombre
print compte_lettre ( "mysteres" )
Il retourne lerreur suivante :

KeyError: m
1) Quelle est la cause de lerreur ?

2) Quelle est la correction apporter pour que cette fonction compte les lettres dun
mot ?
3) Quafficherait le programme une fois corrig ?
4) La fonction compte_lettre est-elle rserve aux chanes de caractres ? Voyez-
vous dautres types de donnes auxquels elle pourrait sappliquer ?
Correction
1) Lerreur provient de la ligne nombre [c] += 1 pour c =0 m0 , cette ligne quivaut
nombre[c] = nombre[c] + 1. Cela signifie que nombre[c] doit exister avant lexcution
de la ligne, cest--dire que le dictionnaire nombre doit avoir une valeur associe la
cl c =0 m0 , ce qui nest pas le cas ici.
Dans ce programme, nombre est un dictionnaire et non une liste (ou un tableau) et les
dictionnaires acceptent des indices autres que des entiers, ils acceptent comme indice
ou cl toute variable de type immuable : les nombres (entiers, rels), les caractres,
les t-uples.
2) 3) La solution compte le nombre doccurrences de chaque lettre dans le mot s.
def compteur (s) :

nombre = {}
for c in s : nombre [c] = 0 # ligne ajoute
for c in s :
nombre [c] += 1
return nombre
Ou encore :
def compteur (s) :
nombre = {}
for c in s :
if c not in nombre : nombre [c] = 0 # ligne ajoute
nombre [c] += 1
return nombre
Ces deux programmes retournent :

{e: 2, m: 1, s: 2, r: 1, t: 1, y: 1}
La dernire solution pour ceux qui naiment pas les dictionnaires :

def compteur (s) :
alpha = "abcdefghijklmnopqrstuvwxyz"
nombre = [ 0 for c in alpha ]
for c in s :
i = alpha.index (c)
nombre [i] += 1
return nombre
Le programme retourne :
[0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 2, 1, 0, 0, 0, 0, 1, 0]
4) La fonction compteur accepte dautres types de donnes condition que les deux
lignes for c in s : et nombre[c]+=1 aient un sens et elles ne sont valables que si le
paramtre s contient des lments susceptibles de servir de cl pour le dictionnaire s,
cest--dire un autre dictionnaire, un tuple, une liste dlments de type immuable.
Autrement dit, les lignes suivantes sont correctes :
print compteur ( "mysteres" )

print compteur ( compteur ("mysteres") )
print compteur ( [0,1,1,4,-1, (6,0), 5.5, "ch"] )
print compteur ( { 1:1, 2:2, 1:[] } )
Mais pas celle-ci :

print compteur ( [0, [0,0] ] )
Toutefois, cette dernire ligne est valide si la fonction compteur se contente seulement
de compter le nombre dlments, cest--dire la premire solution cite aux questions
2) et 3).
12.2.5 Comprendre une erreur de logique ***

On prcise que linstruction random.randint(0, 1) retourne un nombre alatoire
choisi dans lensemble {0, 1} avec des probabilits quivalentes ( (X = 0) = 21 et
(X = 1) = 21 ). La fonction ligne_nulle doit compter le nombre de lignes nulles
de la matrice mat donne comme paramtre.
def ligne_nulle (mat) :
nb = 0
for i in range (0, len (mat)) :
lig = 0
if mat [i][j] > 0 : lig += 1
if lig == 0 : nb += 1
return nb
matri = [ [ random.randint (0,1) for i in range (0,4) ] for j in range (0,20) ]

print ligne_nulle (matri)
Aprs avoir excut le programme trois fois de suite, les rsultats affichs sont succes-
sivement 15, 19, 17. Bien que lexcution du programme ne provoque aucune erreur,
le concepteur de la fonction sinterroge quand mme sur ces rsultats.
1) Sachant que chaque case de la matrice reoit alatoirement 0 ou 1, quelle est la
probabilit quune ligne soit nulle ? Quelle est la probabilit davoir 15 lignes nulles
dans la matrice sachant que cette matrice a 20 lignes ? Ces deux rponses peuvent
tre littrales. Donnez-vous raison celui qui a crit le programme (il pense stre
tromp) ?
2) Si vous lui donnez raison, ce qui est fort probable, o serait son erreur ?
Correction
1) La probabilit davoir une ligne nulle est la probabilit davoir 4 zros, cest donc :
4
1 1
(ligne nulle) = =
2 16
Comment calculer la probabilit davoir 15 lignes nulles parmi 20 ? Cela revient

estimer la probabilit de tirer 15 fois sur 20 une boule blanche lors dun tirage
remise sachant que dans lurne, il y a 1 boule blanche et 15 boules noires. Le nombre
1
de boules blanches tires suit une loi binomiale de paramtre p = 16 . On en dduit
que :
15
1 5 220

15 1
(15 lignes nulles sur 20) = C20 1 15
16 16 10
Cette probabilit est trs faible, il est donc presque impossible dobtenir trois fois
de suite un nombre de lignes suprieur 15. Le programme est sans aucun doute
faux.
2) La construction de la matrice est manifestement correcte, cest donc le comptage
des lignes nulles qui est faux. Cette erreur intervient lors de la ligne if lig ==
0 : nb += 1. Celle-ci est incluse dans la seconde boucle for ce qui a pour effet
dincrmenter lig ds quun premier zro est rencontr sur une ligne. Au final, la
fonction retourne le nombre de lignes contenant au moins un zro. Voici donc la
correction apporter :
def ligne_nulle (mat) :
nb = 0
for i in range (0, len (mat)) :
lig = 0
if mat [i][j] > 0 : lig += 1
if lig == 0 : nb += 1 # ligne dcale vers la gauche
return nb
12.2.6 Rcursivit *
Le programme suivant provoque une erreur dont le message parat sans fin.
class erreur :
self.e = erreur ()
e = erreur ()
Auriez-vous une explication pour ce qui suit ?

File "examen2007.py", line 4, in ?
e = erreur ()
File "examen2007.py", line 2, in __init__
self.e = erreur ()
self.e = erreur ()
self.e = erreur ()
...
Correction
Lerreur retourne est une erreur dexcution et non une erreur de syntaxe. Cela
veut dire que le programme de lexercice est syntaxiquement correct. Il nest donc
pas possible de dire que lattribut e nest pas dfini et de corriger le programme
comme suit pour expliquer lerreur :
class erreur :
def __init__ (self,e) :
self.e = e
En fait, la classe erreur dfinit un attribut qui est galement de type erreur. Cet
attribut va lui aussi dfinir un attribut de type erreur. Ce schma va se reproduire
linfini puisqu aucun moment, le code du programme ne prvoit la possibilit de
sarrter. Le programme cre donc des instances de la classe erreur linfini jusqu
atteindre une certaine limite dpendant du langage Python. Cest ce moment-l
que se produit lerreur cite dans lnonc.
12.2.7 Complter un programme **

11 (base dcimale) scrit 102 en base 3 puisque 11 = 1 32 + 0 31 + 2 30 .
Lobjectif de cet exercice est dcrire une fonction qui crit un nombre entier en
base 3. Cette fonction prend comme paramtre dentre un entier et retourne une
chane de caractres. On prcise que loprateur % calcule le reste dune division
entire et que 11/3 3 car cest une division entire dont le rsultat est un entier
gal au quotient de la division. La fonction str permet de convertir un nombre en
une chane de caractres. Il ne reste plus qu complter les deux lignes manquantes
du programme suivant :
def base3 (n) :
s = ""
while n > 0 :
r = n % 3
# ....... complter
# ....... complter
return s
Correction
Il y a effectivement deux lignes corriger. r dsigne le reste de la division de n par
3. Il faut le convertir en chane de caractres et lajouter gauche la chane s.
On passe au chiffre suivant en division n par 3 ce qui est rassurant puisque n va
tendre vers zro et le programme sarrter ncessairement au bout dun moment.
Pour vrifier que ce programme est correct, il suffit de lappliquer un nombre, voire
appliquer le mme algorithme mais en base 10 pour tre vraiment sr.
def base3 (n) :
s = ""
while n > 0 :
r = n % 3
s = str (r) + s
n = n / 3 # quivalent n = (n-r) / 3
# puisque / est une division entire
return s

Un professeur dsireux de tester une rpartition alatoire des notes un examen
dcide de tirer au hasard les notes de ses lves selon une loi normale de moyenne 15
et dcart-type 3. Il arrondit ses notes lentier le plus proche en nomettant pas de
vrifier que ses notes sont bien dans lintervalle [0, 20]. On prcise que linstruction
float(i) convertit un nombre i en nombre rel, cette conversion est utilise pour
tre sr que le rsultat final sera bien rel et non le rsultat doprations sur des
entiers. Cette conversion intervient le plus souvent lors de divisions.
import copy
import math
import random
class Eleve :
def __init__ (self, note) :
self.note = note
e = Eleve (0)
l = []
e.note = int (random.gauss (15, 3) + 0.5) # tirage alatoire et arrondi
if e.note >= 20 : e.note = 20 # pas de note au-dessus de 20
if e.note < 0 : e.note = 0 # pas de note ngative
l.append (e)
moy = 0
var = 0
for e in l :
moy += e.note
moy = float (moy) / len (l) # les notes sont entires,
# il faut convertir avant de diviser
# pour obtenir la moyenne
for e in l :
var += (e.note - moy) ** 2
var = math.sqrt ( float (var) ) / len (l)
print "moyenne ", moy

print "cart-type ", var
Il songe vrifier nanmoins que la moyenne de ses notes arrondies est bien conforme
ce quil a chafaud.
moyenne 16.0
cart-type 0.0
La moyenne gale 16 ne le perturbe gure, il se dit que larrondi a t plutt

gnreux. Toutefois lcart-type nul le laisse perplexe.
1) Que signifie un cart-type nul ? Quelle est lerreur du professeur ? (Elle est situe
lintrieur de la boucle for i in range(0, 81) :, ce nest pas une erreur lors du calcul
de lcart-type ni une erreur de dfinition de la classe Eleve.)
2) Proposer deux solutions pour corriger ce problme, chacune delles revient rem-
placer la ligne l.append(e).
3) On sait que la variance dune variable alatoire X vrifie : (X) = X 2

[ (X)]2 . Cette astuce mathmatique permet-elle de rduire le nombre de boucles

du programme, si oui, comment ?
Correction
1) Un cart-type nul signifie que toutes les notes sont identiques et gales la
moyenne. Selon le programme, tous les lves ont donc 16. Lerreur provient du
fait que linstruction l.append(e) ajoute chaque fois la mme variable de type
Eleve. A la fin de la boucle, la liste l contient 81 fois le mme objet Eleve ou plus
exactement 81 fois la mme instance de la classe Eleve. On modifie la note de cet
unique objet en crivant : e.note = int(random.gauss(15, 3) + 0.5). 16 est donc la note
attribue au dernier lve, la dernire note tire alatoirement.
2) Les deux corrections possibles consistent crer chaque itration une nouvelle
instance de la classe Eleve.
1. l.append(e) devient l.append(Eleve(e.note))
2. l.append(e) devient l.append(copy.copy(e))
La variable e dans la boucle est un Eleve temporaire, il est ensuite recr ou recopi
avant lajout dans la liste. Ceci veut dire que linstance ajoute dans la liste nest
pas la mme que celle utilise dans la boucle.
Une troisime solution est envisageable mme si elle introduit des modifications
dans la suite du programme, elle est logiquement correcte : l.append(e) devient
l.append(e.note). La liste l nest plus une liste de Eleve mais une liste dentiers. Le
programme devient :
#...
e = Eleve (0)
l = []
e.note = int (random.gauss (15, 3) + 0.5)
if e.note >= 20 : e.note = 20
if e.note < 0 : e.note = 0
l.append (e.note) # ligne modifie
moy = 0
var = 0
for note in l : # ligne modifie

moy += note # ligne modifie
moy = float (moy) / len (l)
for note in l : # ligne modifie
var += (note - moy) ** 2 # ligne modifie
var = math.sqrt ( float (var) ) / len (l)

3) La formule mathmatique permet de rduire le nombre de boucles deux. Lors

de la version initiale du programme, la premire sert crer la liste l, la seconde
calculer la moyenne, la troisime calculer la variance. On regroupe les deux

dernires boucles en une seule.
moy = 0
var = 0
for note in l :
moy += note
var += note * note
moy = float (moy) / len (l)
var = float (var) / len (l)
var = var - moy * moy
var = math.sqrt ( float (var) )

12.3 Troisme nonc

12.3.1 Calcul dun arrondi *
Ecrire une fonction qui arrondit un nombre rel 0.5 prs ? Ecrire une autre fonction
qui arrondit 0.125 prs ? Ecrire une fonction qui arrondit r prs o r est un
rel ? Rpondre uniquement cette dernire question suffit pour rpondre aux trois
questions.
Correction
Pour arrondi 1 prs, il suffit de prendre la partie entire de x + 0.5, arrondir x
0.5 prs revient arrondi 2x 1 prs.
def arrondi_05 (x) :
return float (int (x * 2 + 0.5)) / 2
def arrondi_0125 (x) :

return float (int (x * 8 + 0.5)) / 8
def arrondi (x, p) :

return float (int (x / p + 0.5)) * p
12.3.2 Mme programme avec 1,2,3 boucles **

Le programme suivant affiche toutes les listes de trois entiers, chaque entier tant
compris entre 0 et 9.
for a in range (0, 10) :
for b in range (0, 10) :
for c in range (0, 10) :
print [a,b,c]
1) Proposez une solution avec une boucle while et deux tests if.
2) Proposez une solution avec deux boucles while.
Correction
1) Une seule boucle contrle les indices a, b, c. Quand un indice atteint sa limite,
on incrmente le suivant et on remet lindice 0.
a,b,c = 0,0,0
while c < 10 :
print [a,b,c]
a += 1
if a == 10 :
b += 1
a = 0
if b == 10 :
c += 1
b = 1
2) Lavantage de cette dernire solution est quelle ne dpend pas du nombre din-
dices. Cest cette solution quil faut prconiser pour crire une fonction dont le code
est adapt quelque soit la valeur de n.
l = [0,0,0]
while l [-1] < 10 :
print l
l [0] += 1
i = 0
while i < len (l)-1 and l [i] == 10 :
l [i] = 0
l [i+1] += 1
i += 1
Ce problme tait mal pos : il nest pas difficile dintroduire des tests ou des boucles
redondantes ou denlever une des conditions dune boucle while pour la remplacer
un test reli une sortie de la boucle.
12.3.3 Suite rcurrente (Fibonacci) **

La fonction fibo retourne la valeur de la suite de Fibonacci pour tout entier n. Quel
est son cot en fonction de O(n) ?
def fibo (n) :
else : return fibo (n-1) + fibo (n-2)
Correction
Lorsquon cherche calculer fibo(n), on calcule fibo(n 1) et fibo(n 2) : le cot du
calcul fibo(n) est gal la somme des cots des calculs de fibo(n 1) et fibo(n 2)
plus une addition et un test. Le cot de la fonction fibo(n) est plus facile dfinir
par rcurrence. Le cot cn du calcul de fibo(n) vrifie donc :
c0 = c1 = c2 = 1 (12.1)
cn = cn1 + cn2 + 2 (12.2)
Le terme 1 dans (12.1) correspond au premier test. Le terme 2 dans (12.2) correspond
au test et laddition. Le cot du calcul de fibo(n) est gal une constante prs
une suite de Fibonacci. Le code suivant permet de le vrifier en introduisant une
variable globale. On modifie galement la fonction fibo de faon pouvoir changer
u0 et u1 .
nb = 0 # variable globale suites de la forme (12.3) :
def fibo (n,p) :
global nb u0 = p
if n <= 2 : u1 = p
nb += 1
return p # plus de rcurrence u2 = u0 + u1 + d = 2p + d
else : u3 = u1 + u2 + d = 3p + 2d
nb += 2
return fibo (n-1,p) + fibo (n-2,p) u4 = u2 + u3 + d = 5p + 4d
u5 = u3 + u4 + d = 8p + 7d
for n in range (1, 20) :
nb = 0 # remis zro, chaque fois u6 = u4 + u5 + d = 13p + 12d
# nb est la mesure du cot
u7 = u5 + u6 + d = 21p + 20d
print fibo(n,3)-2, nb # nombres identiques
# nb vrifie la rcurrence de la suite c(n) u8 = u6 + u7 + d = 34p + 33d
# c(n) = c(n-1) + c(n-2) + 2
...
Dans cet exemple, on saperoit que la suite est gale son cot. Pour le dmontrer
dune faon plus thorique, on sintresse aux suites de la forme suivante dont la
rcurrence est dveloppe ci-dessus droite :
u0 = u1 = u2 = p
un = un1 + un2 + d (12.3)
Par une astuce de calcul, on peut rduire lcriture de la suite (un ) une somme
linaire de deux suites (Un ) et (Vn ). La suite (Un ) est dfinie par U0 = 1, U1 = 1,
Un = Un1 + Un2 et la suite (Vn ) dfinie par V0 = 0, V1 = 0, Vn = Vn1 + Vn2 + 1.
On en dduit que :
un = Un p + Vn d
Si on arrive montrer que Un = Vn + 1, cela montrera que la fonction fibo cite

dans la correction est bien gale son cot. Or :
Vn + 1 = Vn1 + Vn2 + 1 + 1 = (Vn1 + 1) + (Vn2 + 1)

La suite Vn = Vn + 1 suit bien la rcurrence de la suite Un . On vrifie que les
premires valeurs sont identiques et cela montre que Un = Vn + 1. On en dduit
que :
un = Un p + (Un 1)d = Un (p + d) d
Pour conclure, une

suite de Fibonacci

vrifie la rcurrence un = un1 + un2 . Si
on pose 1 = 1+2 5 et 2 = 12 5 . Cette suite peut scrire sous la forme un =
An1 + Bn2 . Le second terme tant ngligeable par rapport au premier, le cot de la
fonction fibo est donc en O (n1 ). En dautres termes, si on calcule le cot du calcul
rcursif dune suite de Fibonacci, ce dernier est quivalent la suite elle-mme.
12.3.4 Calculer le rsultat dun programme *

1) Quaffiche le code suivant :
l = [0,1,2,3,4,5]
g = l
for i in range (0, len (l)-1) :
g [i] = g [i+1]
print l
print g
2) Et celui-ci :
l = [0,1,2,3,4,5]
g = [0,1,2,3,4,5]
for i in range (0, len (l)-1) :
g [i] = g [i+1]
print l
print g
3) Et encore celui-l :
l = [0,1,2,3,4,5]
g = [0,1,2,3,4,5]
for i in range (0, len (l)) :
g [i] = g [(i+1)%len (l)]
print l
print g
4) A votre avis, quel est lobjectif du programme et que suggrez-vous dcrire ?

5) Voyez-vous un moyen dcrire plus simplement la seconde ligne g = [0, 1, 2, 3, 4, 5]
tout en laissant inchang le rsultat ?
Correction
1) Linstruction g = l implique que ces deux variables dsignent la mme liste. La
boucle dcale les nombres vers la gauche.
[1, 2, 3, 4, 5, 5]
[1, 2, 3, 4, 5, 5]
2) Linstruction g = [0, 1, 2, 3, 4, 5] implique que ces deux variables ne dsignent plus

la mme liste. Linstruction print l affiche le contenu du dbut.
[0, 1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 5]
3) La boucle sintresse cette fois-ci au dplacement du premier lment en premire

position. Le programmeur a pris soin dutiliser le modulo, n%n = 0 mais le premier
lment de la liste g est devenu le second. Le rsultat est donc :
[0, 1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 1]
4) Le programme souhaite dcaler les lments dune liste vers la gauche, le premier
lment devenant le dernier.
l = [0,1,2,3,4,5]
g = [0,1,2,3,4,5]
g [i] = l [(i+1)%len (l)] # ligne modifie, g devient l
print l
print g
5) La seconde ligne impose de rpter le contenu de la liste. Il existe une fonction

qui permet de le faire :
import copy
l = [0,1,2,3,4,5]
g = copy.copy (l) # on pourrait aussi crire g = list (l)
# ou encore g = [ i for i in l ]
g [i] = l [(i+1)%len (l)]
print l
print g
12.3.5 Comprendre une erreur de logique **

1) Un individu a crit la fonction suivante, il inclut un seul commentaire et il faut
deviner ce quelle fait. Aprs excution, le programme affiche 4.
def mystere (l) :
"""cette fonction sapplique des listes de nombres"""
l.sort ()
nb = 0
if l [i-1] != l [i] : nb += 1
return nb+1
l = [4,3,1,2,3,4]
print mystere (l) # affiche 4
2) Aprs avoir crit linstruction print l, on saperoit que la liste l a t modifie

par la fonction mystere. Quaffiche cette instruction ?
3) Comment corriger le programme pour que la liste ne soit pas modifie ?
Correction
1) La fonction travaille sur une liste de nombres tris. La fonction parcourt cette
liste et compte le nombre de fois que la liste trie contient deux lments successifs
diffrents. La fonction retourne donc le nombre dlments distincts dune liste.
2) La fonction trie la liste, elle ressort donc trie de la fonction car le passage des
listes une fonction seffectue par adresse. Le rsultat de linstruction print l est
donc :
[1, 2, 3, 3, 4, 4]
3) Il suffit dutiliser le module copy.

import copy
def mystere (l) :
"""cette fonction sapplique des listes de nombres"""
l = copy.copy (l) # ligne insre
# on peut crire aussi l = list (l)
l.sort ()
nb = 0
if l [i-1] != l [i] : nb += 1
return nb+1
12.3.6 Hritage **
class Personne : class Personne :

def __init__ (self, nom) : def __init__ (self, nom, entete) :
self.nom = nom self.nom = nom
def entete (self) : self.entete = entete
return "" def __str__ (self) :
def __str__ (self) : s = self.entete + self.nom
s = self.entete () + self.nom return s
return s
h = Personne ("Hector", "M. ")
class Homme (Personne) : f = Personne ("Gertrude", "Melle ")
def __init__ (self, nom) : print h
Personne.__init__ (self, nom) print f
def entete (self) :
return "M. "
class Femme (Personne) :

def __init__ (self, nom) :
Personne.__init__ (self, nom)
def entete (self) :
return "Melle "
h = Homme ("Hector")
f = Femme ("Gertrude")
print h
print f
Programme A Programme B
1) Les deux programmes prcdents affichent-ils les mmes choses ? Quaffichent-
ils ?
2) On souhaite ajouter une personne hermaphrodite, comment modifier chacun des
deux programmes pour prendre en compte ce cas ?
3) Quel programme conseilleriez-vous quelquun qui doit manipuler cent millions
de personnes et qui a peur de manquer de mmoire ? Justifiez.
Correction
1) Les programmes affichent la mme chose et ils affichent :
M. Hector
Melle Gertrude
2)
class Personne : class Personne :
def __init__ (self, nom) : def __init__ (self, nom, entete) :
self.nom = nom self.nom = nom
def entete (self) : self.entete = entete
return "" def __str__ (self) :
def __str__ (self) : s = self.entete + self.nom
s = self.entete () + self.nom return s
return s
h = Personne ("Hector", "M. ")
class Homme (Personne) : f = Personne ("Gertrude", "Melle ")
def __init__ (self, nom) : g = Personne ("Marie-Jean", \
Personne.__init__ (self, nom) "Melle et M. ")
def entete (self) : print h
return "M. " print f
print g
class Femme (Personne) :
def entete (self) :
return "Melle "
class Hermaphrodite (Personne) :

def entete (self) :
return "Melle et M. "
h = Homme ("Hector")
f = Femme ("Gertrude")
g = Hermaphrodite ("Marie-Jean")
print h
print f
print g
Programme A Programme B
3) Les deux programmes dfinissent une personne avec un prnom et un en-tte.

Dans le second programme, len-tte est un attribut de la classe et cette classe
permet de modliser les hommes et les femmes. Dans le premier programme, len-
tte est dfini par le type de la classe utilise. Il y a moins dinformation mmorise,
en contre partie, il nest pas possible davoir dautres en-ttes que M. et Melle. Pour
manipuler 100 millions de personnes, il vaut mieux utiliser le premier programme
avec deux classes, il sera moins gourmant en mmoire.
12.3.7 Analyser un programme ***

On considre la fonction suivante qui prend comme entre une liste dentiers. Elle
ne retourne pas de rsultat car elle modifie la liste. Appeler cette fonction modifie la
liste donne comme paramtre. Elle est compose de quatre groupes dinstructions.
def tri_entiers(l):
"""cette fonction sapplique une liste dentiers"""
# groupe 1
m = l [0]
M = l [0]
for k in range(1,len(l)):
if l [k] < m : m = l [k]
if l [k] > M : M = l [k]
# groupe 2
p = [0 for i in range (m,M+1) ]
p [ l [i] - m ] += 1
# groupe 3
R = [0 for i in range (m,M+1) ]
R [0] = p [0]
for k in range (1, len (p)) :
R [k] = R [k-1] + p [k]
# groupe 4
pos = 0
while R [pos] < i : pos += 1
l [i-1] = pos + m
l [len (l)-1] = M
1) Que fait le groupe 1 ?

5) Quel est la boucle contenant le plus grand nombre ditrations ?
Correction
1) Le groupe 1 dtermine les minimum et maximum de la liste l.
2) Dans le groupe 2, la liste p compte le nombre doccurrences dun lment dans la
liste l. p[0] correspond au nombre de fois que le minimum est prsent dans la liste,
p[len(l) 1] correspond au nombre de fois que le maximum est prsent.
3) Le groupe 3 construit la fonction de rpartition de la liste l. Si m est le minimum
de la liste l, R[i] est le nombre dlments infrieurs ou gaux i + m que la liste
contient.
4) Le dernier groupe trie la liste l. Si X est une variable alatoire de fonction de
rpartition F alors F (X) suit une loi uniforme sur [0, 1]. Cest le mme principe
ici. La figure 12.1 illustre la fonction de rpartition. A chaque marche correspond
un lment de la liste et chaque marche correspond une case du tableau R. En
parcourant les marches du tableau R, on retrouve les lments de la liste l tris. La
marche plus haute traite le cas de plusieurs lments gaux.
5) Le groupe 1 inclut une boucle de n itrations o n est le nombre dlments de
la liste l. Les groupes 2 et 3 incluent une boucle de M n itrations. Le groupe 4
inclut deux boucles, la premire inclut n itrations, la seconde implique une variable
pos qui passe de m M . Le cot de ce bloc est en O(n + M n). Cest ce dernier
bloc le plus long.
Figure 12.1 : Construction de

la fonction de rpartition.

Chaque anne, une socit reoit des cadeaux de ses clients et son patron souhaite
organiser une tombola pour attribuer ces cadeaux de sorte que les plus bas salaires
aient plus de chance de recevoir un cadeau. Il a donc choisi la mthode suivante :
Chaque employ considre son salaire net par mois et le divise par 1000, il obtient un
nombre entier ni .
Dans une urne, on place des boules numrotes que lon tire avec remise.
Le premier employ dont la boule est sortie autant de fois que ni gagne le lot.
La socit a distribu plus de 100 cadeaux en quelques annes mais jamais le patron
nen a gagn un seul, son salaire nest pourtant que cinq fois celui de sa scr-
taire. Son systme est-il quitable ? Il fait donc une simulation sur 1000 cadeaux
en Python que voici. Sa socit emploie quatre personnes dont les salaires sont
[2000, 3000, 5000, 10000].
import random
def tirage (poids) :

nb = [ 0 for p in poids ]
while True :
i = random.randint (0, len (poids)-1)
nb [i] += 1
if nb [i] == poids [i] :
return i
salaire = [ 10000, 5000, 3000, 2000 ]

poids = [ int (s / 1000) for s in salaire ]
nombre = [ 0 for s in salaire ]
for n in range (0,1000) :

p = tirage (poids)
nombre [p] += 1
for i in range (0, len (poids)) :

print "salaire ", salaire [i], " : nb : ", nombre [i]
Les rsultats sont plus que probants :

salaire 10000 : nb : 0
salaire 5000 : nb : 49
salaire 3000 : nb : 301

salaire 2000 : nb : 650
Il na aucune chance de gagner moins que son programme soit faux. Ne sen
sortant plus, il dcide dengager un expert car il trouve particulirement injuste que
sa secrtaire ait encore gagn cette dernire bouteille de vin.
1) Avez-vous suffisamment confiance en vos connaissances en Python et en probabi-
lits pour dclarer le programme correct ou incorrect ? Deux ou trois mots dexpli-
cations seraient les bienvenus.
2) Le patron, aprs une folle nuit de rflexion, dcida de se dbarrasser de son expert
perdu dans des probabilits compliques et modifia son programme pour obtenir le
suivant :
import random
def tirage (poids, nb) :

while True :
i = random.randint (0, len (poids)-1)
nb [i] += 1
if nb [i] % poids [i] == 0 :
return i
salaire = [ 10000, 5000, 3000, 2000 ]

poids = [ int (s / 1000) for s in salaire ]
nombre = [ 0 for s in salaire ]
temp = [ 0 for s in salaire ]
for n in range (0,1000) :

p = tirage (poids, temp)
nombre [p] += 1
for i in range (0, len (poids)) :

print "salaire ", salaire [i], " : nb : ", nombre [i]
Et le rsultat est beaucoup plus conforme ses attentes :

salaire 10000 : nb : 90
salaire 5000 : nb : 178
salaire 3000 : nb : 303
salaire 2000 : nb : 429
Quelle est la modification dans les rgles quil a apporte ? Vous paraissent-elles
justes ?
Correction
1) Le programme est correct, ses rsultats aussi. Prenons le cas simple o il ny
a que le patron et sa scrtaire. Le patron gagne 10000 euros et sa secrtaire
seulement 1000 euros. On reformule le problme. On construit ensuite une suite
de 10 nombres choisis uniformment au hasard dans lensemble {0, 1}. Le patron
gagne si les 10 nombres sont les siens. Ce jeu est quivalent celui dcrit dans
lnonc ceci prs quon continue le tirage mme si quelquun gagne. Et avec cette
nouvelle prsentation, on peut conclure quil y a exactement 210 tirages possibles et
quil ny a quun seul tirage gagnant pour le patron. La probabilit de gagner est
seulement de 210 et non 10 1
comme le patron le souhaitait.
Si on revient au jeu quatre personnes et les salaires de lnonc, la probabilit de
gagner du patron est cette fois de 410 , celle de sa scrtaire est au moins suprieure
1
16 qui correspond sa probabilit de gagner en deux tirages. Si le patron ne gagne
pas, cest que sa probabilit de gagner est beaucoup trop petite par rapport au
nombre de tirages. Il en faudrait au moins 410 pour avoir une probabilit non
ngligeable que le patron gagne au moins une fois.
2) 90 5 = 450 qui nest pas trs loin de 429 ou encore 178/2 5 = 445. La secrtaire
parat avoir 5 fois plus de chances de gagner que son patron et 5/2 fois plus que la
personne paye 5000 euros.
La fonction tirage reoit un nouvel lment nb qui est un compteur. Le programme
ne remet plus zro ce compteur entre deux tirages. Cela signifie que si la boule du
patron est sortie trois fois alors que la secrtaire a gagn. Lors du prochain tirage,
le compteur du patron partira de 3 et celui de sa secrtaire de 0.
Si on ne remet jamais les compteurs zro, au bout de 1000 tirages (et non 1000
cadeaux), la boule du patron est sortie environ autant de fois que celle de la secr-
taire, soit 250 fois puisquil y a quatre employs. La secrtaire aura gagn 2502 = 125
250 2
fois, le patron aura gagn 10 = 25 soit 5 fois moins .
12.4 Quatrime nonc

12.4.1 Suite rcurrente (Fibonacci) *
Rcrire la fonction u de faon ce quelle ne soit plus rcurrente.
def u (n) :
else : return u (n-1) + u (n-2) + u (n-3)
Correction
def u_non_recursif (n) :
u0 = 1
u1 = 1
u2 = 1
i = 3
while i <= n :
u = u0 + u1 + u2
u0 = u1
u1 = u2
u2 = u
i += 1
return u
2. Je cite ici la plus belle des rponses retourne par un lve : Les patrons qui organisent des
tombolas sont toujours maris leur secrtaire donc la question ne se pose pas.

1) Quaffiche le programme suivant :
def fonction (n) :
return n + (n % 2)
print fonction (10)

print fonction (11)
2) Que fait la fonction fonction ?

3) Ecrire une fonction qui retourne le premier multiple de 3 suprieur n ?
Correction
1) La fonction fonction ajoute 1 si n est impair, 0 sinon. Le programme affiche :
10
12
2) La fonction retourne le plus petit entier pair suprieur ou gal n.

3) On cherche retourner le plus petit multiple de 3 suprieur ou gal n. Tout
dabord, on remarque que n + (n%3) nest pas la rponse cherche car 4 + 4%3 = 5
qui nest pas divisible par 3. Les fonctions les plus simples sont les suivantes :
def fonction3 (n) :
k = 0
while k < n : k += 3
return k
Ou encore :
def fonction3 (n) :
if n % 3 == 0 : return n
elif n % 3 == 1 : return n + 2
else : return n + 1
Ou encore :
def fonction3 (n) :
if n % 3 == 0 : return n
else : return n + 3 - (n % 3)

1) Quaffiche le programme suivant :
def division (n) :
return n / 2
print division (1)

print division (0.9)
2) Proposez une solution pour que le rsultat de la fonction soit 0.5 lors dune
instruction print division... ?
Correction
1) 1/2 est gal zro en Python car cest une division de deux entiers et le rsultat
est gal la partie entire. La seconde division est une division entre un rel et un
entier, le rsultat est rel. Le programme affiche :
0
0.45
2) Voici deux solutions print division(1.0) ou print division(float(1)). Il est ga-

lement possible de convertir n lintrieur de la fonction division.
12.4.4 Ecrire un programme partir dun algorithme **

On considre deux listes dentiers. La premire est infrieure la seconde si lune
des deux conditions suivantes est vrifie :
les n premiers nombres sont gaux mais la premire liste ne contient que n lments
tandis que la seconde est plus longue
les n premiers nombres sont gaux mais que le n + 1me de la premire liste est infrieur
au n + 1me de la seconde liste
Par consquent, si l est la longueur de la liste la plus courte, comparer ces deux listes
dentiers revient parcourir tous les indices depuis 0 jusqu l exclu et sarrter
sur la premire diffrence qui dtermine le rsultat. Sil ny pas de diffrence, alors
la liste la plus courte est la premire. Il faut crire une fonction compare_liste(p, q)
qui implmente cet algorithme.
Correction
Cet algorithme de comparaison est en fait celui utilis pour comparer deux chanes
de caractres.
def compare_liste (p,q) :
i = 0
while i < len (p) and i < len (q) :
if p [i] < q [i] : return -1 # on peut dcider
elif p [i] > q [i] : return 1 # on peut dcider
i += 1 # on ne peut pas dcider
# fin de la boucle, il faut dcider partir des longueurs des listes
if len (p) < len (q) : return -1
elif len (p) > len (q) : return 1
else : return 0
On pourrait galement crire cette fonction avec la fonction cmp qui permet de
comparer deux lments quels quils soient.
def compare_liste (p,q) :
i = 0
while i < len (p) and i < len (q) :
c = cmp (p [i], q [i])
if c != 0 : return c # on peut dcider
i += 1 # on ne peut pas dcider
# fin de la boucle, il faut dcider partir des longueurs des listes
return cmp (len (p), len (q))

Le programme suivant est erron.
l = [0,1,2,3,4,5,6,7,8,9]
i = 1
while i < len (l) :
print l [i], l [i+1]
i += 2
Il affiche des rsultats puis une erreur.

1 2
3 4
5 6
7 8
9
File "examen2008_rattrapage.py", line 43, in <module>
print l [i], l [i+1]
IndexError: list index out of range
Pourquoi ?
Correction
Le programme affiche les nombres par groupes de deux nombres conscutifs. Une
itration de la boucle commence si la liste contient un lment suivant et non deux.
Le programme est donc contraint lerreur car lors de la dernire itration, la liste
contient un dixime nombre mais non un onzime. Le programme affiche le dixime
lment (9) puis provoque une erreur list index out of range.
12.4.6 Prcision des calculs **

On cherche calculer la somme des termes dune suite gomtriques de raison 21 .
On dfinit r = 12 , on cherche donc calculer i
P
i=0 r qui une somme convergente
mais infinie. Le programme suivant permet den calculer une valeur approche. Il
retourne, outre le rsultat, le nombre ditrations qui ont permis destimer le rsultat.
def suite_geometrique_1 (r) :

x = 1.0
y = 0.0
n = 0
while x > 0 :
y += x
x *= r
n += 1
return y,n
print suite_geometrique_1 (0.5) #affiche (2.0, 1075)
Un informaticien plus expriment a crit le programme suivant qui retourne le

mme rsultat mais avec un nombre ditrations beaucoup plus petit.
def suite_geometrique_2 (r) :

x = 1.0
y = 0.0
n = 0
yold = y + 1
while abs (yold - y) > 0 :
yold = y
y += x
x *= r
n += 1
return y,n
print suite_geometrique_2 (0.5) #affiche (2.0, 55)
Expliquez pourquoi le second programme est plus rapide tout en retournant le mme
rsultat. Repre numrique : 255 2, 8.1017 .
Correction
Tout dabord le second programme est plus rapide car il effectue moins ditrations,
55 au lieu de 1075. Maintenant, il sagit de savoir pourquoi le second programme
retourne le mme rsultat que le premier mais plus rapidement. Lordinateur ne
peut pas calculer numriquement une somme infinie, il sagit toujours dune valeur
approche. Lapproximation dpend de la prcision des calculs, environ 14 chiffres
pour Python. Dans le premier programme, on sarrte lorsque rn devient nul, autre-
ment dit, on sarrte lorsque x est si petit que Python ne peut plus le reprsenter
autrement que par 0, cest--dire quil nest pas possible de reprsenter un nombre
dans lintervalle 0, 21055 .

Toutefois, il nest pas indispensable daller aussi loin car lordinateur nest de toute
faon pas capable dajouter un nombre aussi petit un nombre plus grand que 1.
Par exemple, 1 + 1017 = 1, 000 000 000 000 000 01. Comme la prcision des calculs
nest que de 15 chiffres, pour Python, 1 + 1017 = 1. Le second programme sinspire
de cette remarque : le calcul sarrte lorsque le rsultat de la somme nvolue plus
car il additionne des nombres trop petits un nombre trop grand. Lide est donc
de comparer la somme dune itration lautre et de sarrter lorsquelle nvolue
plus.
Ce raisonnement
Pn i nest pas toujours applicable. Il est valide dans ce cas car la srie
sn = i=0 r est P croissante et positive. Il est valide pour une srie convergente de
la forme sn = ni=0 ui et une suite un de module dcroissant.
12.4.7 Analyser un programme **

Un chercheur cherche vrifier quune suite de 0 et de 1 est alatoire. Pour cela, il
souhaite compter le nombre de squences de n nombres successifs. Par exemple, pour
la suite 01100111 et n = 3, les triplets sont 011, 110, 100, 001, 011, 111. Le triplet
011 apparat deux fois, les autres une fois. Si la suite est alatoire, les occurrences
de chaque triplet sont en nombres quivalents.
Le chercheur souhaite galement faire varier n et calculer les frquences des triplets,
quadruplets, quintuplets, ... Pour compter ses occurrences, il hsite entre deux struc-
tures, la premire base de listes ( dconseiller) :
def hyper_cube_liste (n, m = [0,0]) :

if n > 1 :
m [0] = [0,0]
m [1] = [0,0]
m [0] = hyper_cube_liste (n-1, m [0])
return m
h = hyper_cube_liste (3)
print h # affiche [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
La seconde base de dictionnaire (plus facile manipuler) :
def hyper_cube_dico (n) :

r = { }
ind = [ 0 for i in range (0,n) ]
while ind [0] <= 1 :
cle = tuple ( ind ) # conversion dune liste en tuple
r [cle] = 0
ind [ len (ind)-1] += 1
k = len (ind)-1
while ind [ k ] == 2 and k > 0 :
ind [k] = 0
ind [k-1] += 1
k -= 1
return r
h = hyper_cube_dico (3)
print h # affiche {(0, 1, 1): 0, (1, 1, 0): 0, (1, 0, 0): 0, (0, 0, 1): 0,
# (1, 0, 1): 0, (0, 0, 0): 0, (0, 1, 0): 0, (1, 1, 1): 0}
Le chercheur a commenc crire son programme :
def occurrence (l,n) :

d = ....... # choix dun hyper_cube (n)
.....
return d
suite = [ 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1 ]
h = occurrence (suite, 3)
print h
Sur quelle structure se porte votre choix (a priori celle avec dictionnaire), complter
la fonction occurrence.
Correction
Tout dabord, la structure matricielle est dconseiller fortement mme si un
exemple dutilisation en sera donn. La solution avec dictionnaire est assez simple :

d = hyper_cube_dico (n)
for i in range (0, len (l)-n) :
cle = tuple (l [i:i+n])
d [cle] += 1
return d
Il est mme possible de se passer de la fonction hyper_cube_dico :

d = { }
cle = tuple (l [i:i+n])
if cle not in d : d [cle] = 0
d [cle] += 1
return d
La seule diffrence apparat lorsquun n-uplet napparat pas dans la liste. Avec la
fonction hyper_cube_dico, ce n-uplet recevra la frquence 0, sans cette fonction,
ce n-uplet ne sera pas prsent dans le dictionnaire d. Le mme programme avec la
structure matricielle est plus une curiosit quun cas utile.
d = hyper_cube_liste (n, [0,0]) # * remarque voir plus bas
cle = l [i:i+n]
t = d #
for k in range (0,n-1) : # point cl de la fonction :
t = t [ cle [k] ] # accs un lment
t [cle [ n-1] ] += 1
return d
Si on remplace la ligne marque dune toile par d = hyper_cube_list(n), le pro-

gramme retourne une erreur :

File "examen2008_rattrapage.py", line 166, in <module>
h = occurrence (suite, n)
File "examen2008_rattrapage.py", line 160, in occurrence
t [cle [ n-1] ] += 1
TypeError: int object is not iterable
Cette erreur est assez incomprhensible puisque la modification a consist appeler

une fonction avec un paramtre de moins qui tait de toutes faons gal la valeur
par dfaut associe au paramtre. Pour comprendre cette erreur, il faut excuter le
programme suivant :
l [0] += 1
return l
print fonction () # affiche [1,0] : rsultat attendu

print fonction () # affiche [2,0] : rsultat surprenant
print fonction ( [0,0]) # affiche [1,0] : rsultat attendu
Lexplication provient du fait que la valeur par dfaut est une liste qui nest pas
recre chaque appel mais cest la mme liste chaque fois que la fonction est
appele sans paramtre. Pour remdier cela, il faudrait crire :
import copy
l = copy.copy (l)
l [0] += 1
return l
Dans le cas de lhypercube, il faudrait crire :
def hyper_cube_liste (n, m = [0,0]) :

m = copy.copy (m)
if n > 1 :
m [0] = [0,0]
m [1] = [0,0]
return m
12.5 Exercices supplmentaires

12.5.1 Position initiale dun lment aprs un tri **
On suppose quon peut trier la liste l = [...] avec la mthode sort. Une fois le tableau
tri, comment obtenir la position du plus petit lment dans le tableau initial ?
Correction
Lide est de ne pas trier la liste mais une liste de couples incluant chaque lment
avec sa position. On suppose que la liste l existe. La mthode sort utilisera le
premier lment de chaque couple pour tier la liste de couples.
l2 = [ ( l [i], i ) for i in range (0, len (l)) ]
l2.sort ()
print l2 [0][1] # affiche la position du plus petit lment
# dans le tableau initial
12.5.2 Comprendre une erreur de logique *

1) Quel est le rsultat affich par le programme suivant :
def ensemble_lettre (s) :
ens = []
for i in range (0, len (s)) :
c = s [i]
if c in ens :
ens.append (c)
return ens
print lettre ("baaa")
Est-ce que ce rsultat change si on appelle la fonction ensemble_lettre avec un

autre mot ?
2) Le programme prcdent nest vraisemblablement pas fidle aux intentions de son
auteur. Celui-ci avait pour objectif de dterminer lensemble des lettres diffrentes
de la chane de caractres passe en entre. Que faut-il faire pour le corriger ? Que
sera le rsultat de linstruction ensemble_lettre(baaa) en tenant compte de la
modification suggre ?
Correction
1) Linstruction if c in ens : signifie que le caractre c est ajout seulement sil est
dj prsent dans la liste s qui est vide au dbut de la fonction. Elle sera donc
toujours vide la fin de lexcution de la fonction et sera vide quelque soit le mot s
fourni en entre comme paramtre. Le rsultat ne dpend donc pas du mot.
2) Il suffit de changer if c in ens : en if c not in ens : pour donner :
def ensemble_lettre (s) :

ens = []
for i in range (0, len (s)) :
c = s [i]
if c not in ens :
ens.append (c)
return ens
Le rsultat pour le mot baaa est [b, a].

k = [10,14,15,-1,6]
l = []
for i in range (0,len (k)) :
l.append ( k [ len (k) - i ] )
Le programme gnre une exception de type IndexError, pourquoi ?
Correction
Lors du premier passage dans la boucle for, le premier ajout dans la liste l est
k[len(k)] qui nexistent pas puisque les indices vont de 0 len(k). Voici la correction :
k = [10,14,15,-1,6]
l = []
for i in range (0,len (k)) :
l.append ( k [ len (k) - i-1 ] ) # -1 a t ajout
12.5.4 Prcision des calculs ***

2 3 4
On cherche calculer ln 2 grce la formule ln (1 + x) = x x2 + x3 x4 + .... Pour
x = 1, cette suite est convergente et permet de calculer ln 2.
1) On propose deux programmes. Le premier utilise une fonction puiss. Le second
ne lutilise pas :
def puiss (x, n) : # ......

s = 1.0 # ......
for i in range (0,n) : # ......
s *= x # ......
return s # ......
# ......
def log_suite (x) : def log_suite (x) :
x = float (x-1) x = float (x-1)
# ...... x0 = x
s = 0 s = 0
old = -1 old = -1
n = 1 n = 1
while abs (old - s) > 1e-10 : while abs (old - s) > 1e-10 :
old = s old = s
po = puiss (x,n) / n po = x / n
if n % 2 == 0 : po = -po if n % 2 == 0 : po = -po
s += po s += po
n += 1 n += 1
# ...... x *= x0
return s return s
print log_suite (2) print log_suite (2)
Quel est le programme le plus rapide et pourquoi ? Quels sont les cots des deux
algorithmes ?
2) Combien faut-il ditrations pour que la fonction retourne un rsultat ?

3) On introduit la fonction racine_carree qui calcule k. Celle-ci est issue de la
rsolution de lquation f (x) = 0 avec f (x) = x2 k laide de la mthode de
Newton 3 .
def racine_carree (k) :
x0 = float (k)+1
x = float (k)
while abs (x-x0) > 1e-10 :
x0 = x
x = (k-x*x) / (2 * x) + x
return x

Cette fonction
retourne unrsultat pour 2en 6 itrations. On dcompose ensuite
2

ln 2 = ln ( 2) = 2 ln 2 = 2 ln 1 + 2 1 . En utilisant cette astuce et
la fonction racine2, combien estimez-vous grossirement le nombre ditrations
ncessaires pour calculer ln 2 : 10, 40 ou 100 ? Justifiez. On rappelle que 210n 103n .
4) Que proposez-vous pour calculer ln 100 ?
Correction
1) Le second programme est le plus rapide. A chaque boucle du premier programme,
la fonction puiss calcule xn avec n multiplications, ce calcul est remplac par une
seule multiplication dans le second programme.
3. Cette mthode est utilise pour rsoudre lquation f (x) = 0. On construit une suite conver-
geant vers la solution dfinie par xn+1 = xn ff0(x n)
(xn )
. Sous certaines conditions, la suite (xn )
converge vers la solution. Il suffit dappliquer cela la fonction f (x) = x2 k o k est le nombre
dont on veut trouver la racine.
Les deux programmes excuteront exactement le mme nombre de fois la boucle

while. Soit n ce nombre ditrations, le cot du premier programme est 1 + 2 + 3 +
4 + ... + n O(n2 ) car la fonction puiss fait i passages dans sa boucle for pour
litration i. Le cot du second programme est en O(n).
n k
(1)k+1 xk , la condition darrt de la fonction log_suite
P
2) Si on pose sn =
k=1
correspond : k
10
x
|sn sn1 | > 10 > 1010
k
Comme on calcule ln(1 + 1), x = 1, la condition est donc quivalente :
1
> 1010 k < 1010
k
La fonction log_suite fait dix milliards de passages dans la boucle while, dix mil-
liards ditrations.

3) Cette fois-ci, on cherche calculer
k ln 2 = ln 1 + 2 1 , do x = 2 1.
La condition darrt est toujours k > 1010 et on cherche majorer le nombre
x

ditrations ncessaires pour que la fonction converge vers un rsultat. 2 1.414 <
1 1
2 . On majore donc x par 2 :

2 1k

= > 1010

k

1
= k > 1010
2 k
1
= k > 1010 = 2k < 1010
2
On utilise lapproximation donne par lnonc savoir 210n 103n .
100
2k < 1010 210k < 10100 103k < 10100 3k < 100 k < k < 34
3

Si on ajoute 34 aux 6 itrations ncessaires pour calculer 2, on trouve 40 itrations.
4) ln (1 + x) nest calculable que pour |x| < 1. Il faut fonc transformer ln 100 pour
le calculer partir dune racine carre et de ln (1 + x) pour un x tel que x < 1 (dans
le cas contraire, la suite ne converge pas) :

5
ln 100 = 2 ln 10 = 2 ln 2 + 2 ln 5 = 2 ln 2 + 2 ln 4
4

5 5
= 2 ln 2 + 2 ln 4 + 2 ln = 2 ln 2 + 4 ln 2 + 2 ln 1 + 1
4 4

1
= 6 ln 2 + 2 ln 1 +
4
Cest une dcomposition, ce nest pas la seule possible.
Index 323
Index
False . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 break . . . . . . . . . . . . . . . . . . . . . . . . . 68
None . . . . . . . . . . . . . . . . . . . . . . . . . . 33, 62 continue . . . . . . . . . . . . . . . . . . . . . 68
True . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 fin normale dune boucle . . . . . . 69
__builtins__ . . . . . . . . . . . . . . . . . . 55 infinie. . . . . . . . . . . . . . . . . . . . . . . . .64
__class__ . . . . . . . . . . . . . . . . . . . . . 132 itration suivante . . . . . . . . . . . . . 68
__doc__ . . . . . . . . . . . . . . . . . . . . . . . . 55 sortie prmature . . . . . . . . . . . . . 69
__file__ . . . . . . . . . . . . . . . . . . . . . . . 55 byte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
__init__.py . . . . . . . . . . . . . . 155, 165 bytecode . . . . . . . . . . . . . . . . . . . . . 12, 151
__main__ . . . . . . . . . . . . . . . . . . . . . . 152
__name__ . . . . . . . . . . . . . . . . . . . . . . . 55 C
C, C++ . . . . . . . . . . . . . . . . . . . . . . . . . 158
A calcul
accent . . . . . . . . . . . . . . . . . . . . . . . . 22, 192 distribu . . . . . . . . . . . . . . . . . . . . . 225
affectation . . . . . . . . . . . . . . . . . . . . . . . 117 parallle . . . . . . . . . . . . . . . . . . . . . 225
multiple . . . . . . . . . . . . . . . . . . . 56, 67 prcision . . . . . . . . . . . 290, 315, 320
aide . . . . . . . . . . . . . . . . . . . . . . . . . . 75, 101 call stack . . . . . . . . . . . . . . . . . . . . 139, 298
algorithme . . . . . . . . . . . . . . . . . . . . . . . . 11 carr magique . . . . . . . . . . . . . . . . . . . . 254
analyse discriminante linaire (ADL, chane de caractres . . . . . . . . . . . . . . . 36
FDA) . . . . . . . . . . . . . . . . . . . . 254 concatnation . . . . . . . . . . . . . 37, 47
analyse en composantes principales conversion . . . . . . . . . . . . . . . . . 37, 54
(ACP) . . . . . . . . . . . . . . . . . . . 253 encodage . . . . . . . . . . . . . . . . . . . . 191
anctre . . . . . . . . . . . . . . . . . . . . . . . . . . 127 formatage . . . . . . . . . . . . . . . . . . . . . 39
appelable . . . . . . . . . . . . . . . . . . . . . . . . . 84 manipulation. . . . . . . . . . . . . . . . . .37
arborescence . . . . . . . . . . . . . . . . . . . . . 175 prfixe r . . . . . . . . . . . . . . . . . . . . . . 37
arc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261 prfixe u . . . . . . . . . . . . . . . . . . . . . 192
architecture . . . . . . . . . . . . . . . . . . . . . . 166 chemin relatif, absolu. . . . . . . .153, 176
arrondi . . . . . . . . . . . . . 34, 302, 303, 313 classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
ascii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192 anctre. . . . . . . . . . . . . . . . . .127, 130
asynchrone . . . . . . . . . . . . . . . . . . . . . . . 225 attribut . . . . . . . . . . . . . . 93, 96, 128
attribut attribut implicite . . . . . . . . . . . . 100
__bases__ . . . . . . . . . . . . 100, 127 classe incluse . . . . . . . . . . . . . . . . 102
__class__ . . . . . . . . . . . . . . . . 100 commentaire . . . . . . . . . . . . . . . . . 101
__dict__ . . . . 99, 100, 122, 128 compilation . . . . . . . . . . . . . . . . . . 133
__doc__ . . . . . . . . . . . . . . . . . . . 100 constructeur . . . . . . . . . . . . . 98, 115
__module__ . . . . . . . . . . . . . . . 100 copie . . . . . . . . . . . . . . . 114, 116, 119
__name__ . . . . . . . . . . . . . . . . . . 100 copie profonde . . . . . . . . . . . . . . . 119
__slots__ . . . . . . . . . . . . . . . . 122 driver . . . . . . . . . . . . . . . . . . . . . . . 125
statique . . . . . . . . . . . . . . . . . 110, 122 destructeur . . . . . . . . . . . . . . . 99, 115
attributs croissants . . . . . . . . . . . . . . . 130 hritage . . . . . . . . . . . . . . . . . 122, 288
hritage multiple . . . . . . . . . . . . . 130
B instance. . . . . . . . . . . . . . . . . . . . . . .94
boucle . . . . . . . . . . . . . . . . . . . . . . . . . 45, 63 itrateur . . . . . . . . . . . . . . . . . . . . . 106
324 Index
liste des attributs . . . . . . . . . . . . . 99 Eratosthne . . . . . . . . . . . . . . . . . . . . . . . 68

mthode . . . . . . . . . . . . . . . . . . 93, 95 vnement . . . . . . . . . . . . . . . . . . . . . . . 194
oprateur . . . . . . . . . . . . . . . . . . . . 103 brut . . . . . . . . . . . . . . . . . . . . . . . . . 211
proprit. . . . . . . . . . . . . . . . . . . . .112 exception. . .44, 45, 138, 139, 166, 246
sous-classe . . . . . . . . . . . . . . . . . . . 102 hritage. . . . . . . . . . . . . . . . . . . . . .143
surcharge . . . . . . . . . . 105, 126, 266 imbrication . . . . . . . . . . . . . . . . . . 144
classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 message . . . . . . . . . . . . . . . . . 142, 143
cl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 pige . . . . . . . . . . . . . . . . . . . . . . . . 148
commentaire . . . . . . . . . . . . . . 32, 75, 101 exercice
compilation . . . . . . . . . . . . . . . . . . . . . . 133 arrondi. . . . . . . . . . . . . . . . . .302, 313
constructeur . . . . . . . . . . . . . . . . . . . . . . 98 boucles . . . . . . . . . . . . . . . . . . . . . . 302
conteneur . . . . . . . . . . . . . . . . . . . . . . . . . 42 calcul . . . . . . . . . . . . . . . . . . . 281, 294
contrle (graphique) . . . . . . . . . . . . . 195 classe . . . . . . . . . . . . . . . . . . . 298, 300
conversion . . . . . . . . . . . . 34, 37, 54, 280 comparaison . . . . . . . . . . . . . . . . . 314
copie . . . . . . . . . . . . . . . . . . . . . . . . 117, 119 comptage . . . . . . 295, 306, 316, 319
copie profonde . . . . . . . . . . . . . . . . . . . 119 copie . . . . . . . . . . . . . . . . . . . . 284, 300
cot dun algorithme . . . 247, 287, 288 cot dun algorithme . . . . . . . . . 287
crible dEratosthne . . . . . . . . . . . . . . . 68 dictionnaire . . . . . . . . 283, 295, 316
CSV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 division . . . . . . . . . . . . . . . . . . . . . . 313
criture en base 3 . . . . . . . . . . . . 299
D Fibonacci . . . . . . . . . . 282, 303, 312
dames . . . . . . . . . . . . . . . . . . . . . . . . . . . 242 grenouille . . . . . . . . . . . . . . . . . . . . 282
datamining. . . . . . . . . . . . . . . . . . . . . . . .25 hritage . . . . . . . . . . . . . . . . . 288, 307
date de naissance . . . . . . . . . . . . . . . . 191 liste . . . . . . . . . . . . . . . . . . . . . . . . . 305
dates . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 logarithme . . . . . . . . . . . . . . 293, 320
debug . . . . . . . . . . . . . . . . . . . . . . . 165, 288 matrice . . . . . . . . . . . . . . . . . . . . . . 290
dbugger . . . . . . . . . . . . . . . . . . . . . 19, 165 moyenne . . . . . . . . . . . . . . . . 287, 300
deprecated . . . . . . . . . . . . . . . . . . . . . . . . 58 parcours . . . . . . . 293, 302, 315, 320
driver . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 prcision des calculs 290, 315, 320
Design Patterns . . . . . . . . . . . . . . . . . . 136 probabilit . . . . . . . . . . . . . . 297, 310
dichotomie . . . . . . . . . . . . . . . . . . . 89, 270 somme de chiffres . . . . . . . . . . . . 280
dictionnaire suite rcurrente281, 282, 303, 312
cl . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 suppression dans une boucle . 285
cl modifiable . . . . . . . . . . . . . . . . . 52 tri . . . . . . . . . . . . . . . . . . . . . . 280, 286
copie . . . . . . . . . . . . . . . . . . . . . . . . . . 52 tri dentiers . . . . . . . . . . . . . . . . . . 308
exemple . . . . . . . . . . . . . . . . . . . . . . . 51 tri, position . . . . . . . . . . . . . . . . . . 319
valeur . . . . . . . . . . . . . . . . . . . . . . . . . 49 valeurs propres. . . . . . . . . . . . . . .290
division entire . . . . . . . . . . . . . . . . . . . . 34 variance. . . . . . . . . . . . . . . . .287, 300
Dynamic Link Library (DLL) . . . . 159 expressions rgulires . . . . . . . . . . . . 184
assemblage. . . . . . . . . . . . . . . . . . .188
E
caractres spciaux . . . . . . . . . . 187
efficacit . . . . . . . . . . . . . . . . . . . . . . . . . 242
ensemble de caractres . . . . . . . 186
encodage . . . . . . . . . . . . . . . . . . . . . . . . . 191
exemple . . . . . . . . . . . . . . . . . . . . . 189
nonc
groupe . . . . . . . . . . . . . . . . . . 186, 187
apprentissage . 238, 242, 245, 254,
multiplicateurs . . . . . . . . . . . . . . . 187
261
crit . . . . . . 280, 293, 302, 312, 319 F
pratique . . . . . . . . . . . . 270, 272, 276 FAQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
ENSAE . . . . . . . . . . . . . . . . . . . . . . . 3, 280
Index 325
Fibonacci . . . . . . . . . . . . . . . . . . . 303, 304 binaire . . . . . . . . . . . . . . . . . . . . . . . 178

fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 CSV . . . . . . . . . . . . . . . . . . . . . . . . . 173
print. . . . . . . . . . . . . . . . . . . . . . . .171 texte. . . . . . . . . . . . . . . . . . . . . . . . .169
arborescence . . . . . . . . . . . . . . . . . 175 zip . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
binaire . . . . . . . . . . . . . . . . . . . . . . . 178 forum de discussion . . . . . . . . . . . . . . 194
buffer . . . . . . . . . . . . . . . . . . . . . . . . 171
chemin absolu . . . . . . . . . . . . . . . 176 G
copie . . . . . . . . . . . . . . . . . . . . . . . . 175 garbage collector . . 117, 148, 157, 159,
criture . . . . . . . . . . . . . . . . . . . . . . 170 164
criture, ajout . . . . . . . . . . . . . . . 171 gnrateurs . . . . . . . . . . . . . . . . . . . . . . . 83
fermeture . . . . . . . . . . . . . . . 170, 172 graphe . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
fin de ligne. . . . . . . . . . . . . . . . . . .173
H
lecture . . . . . . . . . . . . . . . . . . . . . . . 172
hritage . . . . . . . . . . . . . . . . . . . . . . . . . . 122
logs . . . . . . . . . . . . . . . . . . . . . . . . . . 172
multiple . . . . . . . . . . . . . . . . . . . . . 130
ouverture . . . . . . . . . . . . . . . 170, 172
sens . . . . . . . . . . . . . . . . . . . . . . . . . 129
srialisation . . . . . . . . . . . . . . . . . . 181
histogramme . . . . . . . . . . . . . . . . . . . . . 309
suppression . . . . . . . . . . . . . . . . . . 175
HTML . . . . . . . . . . . . . . . . . . . . . . . 25, 267
tampon . . . . . . . . . . . . . . . . . . . . . . 171
trace. . . . . . . . . . . . . . . . . . . . . . . . .172 I
zip . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 identificateur . . . . . . . . . . . . . . . . . . 31, 77
fil dexcution . . . . . . . . . . . . . . . 225, 226 immuable . . . . . . . . . . . . . . . . . . . . . . . . . 32
finance . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 indentation . . . . . 13, 21, 59, 63, 64, 85
focus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210 instance
fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 cration . . . . . . . . . . . . . . . . . . . . . . . 94
help . . . . . . . . . . . . . . . . . . . . . . . . . . 75 suppression . . . . . . . . . . . . . . . . . . 115
id . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 interface graphique . . . . . . . . . . . . . . . 194
len . . . . . . . . . . . . . . . . . . . . 37, 41, 50 interprt . . . . . . . . . . . . . . . . . . . . . . . . . 12
map . . . . . . . . . . . . . . . . . . . . . . . 86, 90 intersection . . . . . . . . . . . . . . . . . . . . . . . 56
max, min . . . . . . . . . . . . . . . . . . . . . . 88 itrateur . . . . . . . . . . . . . . . . . 66, 106, 146
max . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
min . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 J
range . . . . . . . . . . . . . . . . . . . . . . . . . 65 Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
raw_input . . . . . . . . . . . . . . . . . . . 61 jeu de caractres . . . . . . . . . . . . . . . . . 191
sum . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 accents. . . . . . . . . . . . . . . . . . . . . . . .22
type . . . . . . . . . . . . . . . . . . . . . . 33, 55 ascii . . . . . . . . . . . . . . . . . . . . . . . . . 192
xrange . . . . . . . . . . . . . . . . . . . . . . . 65 cp1252 . . . . . . . . . . . . . . . . . . . 23, 192
zip . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 latin-1 . . . . . . . . . . . . . . . . . . . 22, 192
aide . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 unicode . . . . . . . . . . . . . . . . . . . . . . 192
gnrateurs . . . . . . . . . . . . . . . . . . . 83 utf-8 . . . . . . . . . . . . . . . . 23, 192, 193
imbrique . . . . . . . . . . . . . . . . . . . . . 80 jeu de dames . . . . . . . . . . . . . . . . . . . . . 242
locale . . . . . . . . . . . . . . . . . . . . . . . . . 80
porte . . . . . . . . . . . . . . . . . . . . . . . . 80 L
rcursive . . . . . . . . . . . . . . . . . 78, 177 langage de programmation
spciale . . . . . . . . . . . . . . . . . . . . . . 137 C, C++ . . . . . . . . . . . . . . . . . .13, 158
surcharge . . . . . . . . . . . . . . . . . . . . . 75 Java . . . . . . . . . . . . . . . . . . . . . 13, 157
usuelle . . . . . . . . . . . . . . . . . . . . . . . . 86 R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
fonction de rpartition . . . . . . . . . . . 309 VBA. . . . . . . . . . . . . . . . . . . . . . . . .166
format Latex. . . . . . . . . . . . . . . . . . . .25, 263, 268
326 Index
ligne de commande . . . . . . . . . . . . . . . 182 pydot. . . . . . . . . . . . . . . . . . . . . . . .262

liste pyparsing . . . . . . . . . . . . . . . . . . . 262
chane . . . . . . . . . . . . . . . . . . . . . . . 42 reportlab . . . . . . . . . . . . . . . . . . . 169
collage . . . . . . . . . . . . . . . . . . . . . . . . 47 win32com . . . . . . . . . . . . . . . . . . . . 169
copie . . . . . . . . . . . . . . . . . . . . . . . . . . 47 wxPython . . . . . . . . . . . . . . . . . . . . 194
insertion . . . . . . . . . . . . . . . . . . . . . . 42 module interne
suppression . . . . . . . . . . . . . . . . . . . 42 calendar . . . . . . . . . . . . . . . . . . . . 191
tri . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 codecs . . . . . . . . . . . . . . . . . . . . . . 192
valeur par dfaut . . . . . . . . . . . . 318 copy . . 48, 52, 114, 116, 119, 121,
liste de listes . . . . . . . . . . . . . . . . . . . . . . 92 285, 301, 307, 318
logs . . . . . . . . . . . . . . . . . . . . . . . . . 166, 172 datetime . . . . . . . . . . . . . . . 167, 191
getopt . . . . . . . . . . . . . . . . . . . . . . 184
M glob . . . . . . . . . . . . . . . . . . . . 175, 182
machine learning . . . . . . . . . . . . . . . . . . 25 HTMLParser. . . . . . . . . . . . . . . . . .173
mail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 imp . . . . . . . . . . . . . . . . . . . . . . . . . . 165
matrice . . . . . . . . . . . . . . 89, 92, 130, 290 keyword . . . . . . . . . . . . . . . . . . . . . . 58
creuse . . . . . . . . . . . . . . . . . . . . . . . 244 os.path . . . . . . . . . . . . 153, 175, 176
criture . . . . . . . . . . . . . . . . . 170, 171 os . . . . . . . . . . . . . . . . . . 175177, 184
lecture . . . . . . . . . . . . . . . . . . . . . . . 173 pickle. . . . . . . . . . . . . . . . . .167, 181
reprsentation . . . . . . . . . . . . . . . 242 Queue. . . . . . . . . . . . . . . . . . . . . . . .234
Strassen . . . . . . . . . . . . . . . . . . . . . 135 random . . . . . . . . . . . . . . . . . . . . . . 297
maximum . . . . . . . . . . . . . . . . . . . . . . . . . 88 re . . . . . . . . . . . . . . . . . . . . . . 185, 239
mthode shutil . . . . . . . . . . . . . 175, 176, 182
ajout . . . . . . . . . . . . . . . . . . . . . . . . 111 string . . . . . . . . . . . . . . . . . . . . . . 238
commentaire . . . . . . . . . . . . . . . . . 101 struct. . . . . . . . . . . . . . . . . .178, 179
constructeur . . . . . . . . . . . . . . . . . . 98 sys . . . . . . . . . . . . . . . . . . . . . 154, 183
destructeur . . . . . . . . . . . . . . . . . . . 99 threading . . . . . . . . . . . . . . 226, 229
statique . . . . . . . . . . . . . . . . . . . . . . 108 time . . . . . . . . . . . . . . . . . . . . 227, 228
surcharge . . . . . . . . . . . . . . . . . . . . 126 Tix . . . . . . . . . . . . . . . . . . . . . 202, 218
minimum . . . . . . . . . . . . . . . . . . . . . . . . . 88 Tkinter . . . . . . . . . . . . . . . . . 26, 194
modifiable . . . . . . . . . . . . . . . . . . . . . 32, 41 urllib. . . . . . . . . . . . . . . . . .156, 246
module . . . . . . . . . . . . . . . . . . . . . . . . . . 150 xml.sax . . . . . . . . . . . . . . . . . . . . . . 173
import . . . . . . . . . . . . . . . . . . . . . . 150 zipfile . . . . . . . . . . . . . . . . . . . . . 174
__init__.py . . . . . . . . . . 155, 165 montant numrique, littral . . . . . . 238
arborescence . . . . . . . . . . . . . . . . . 155 Monte Carlo . . . . . . . . . . . . . . . . . . . . . 156
chemin relatif . . . . . . . . . . . . . . . . 153 MP3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
emplacement. . . . . . . . . . . . . . . . .153 multicurs . . . . . . . . . . . . . . . . . . . . . . . 225
externe . . . . . . . . . . . . . . . . . . . . . . 156
identificateur . . . . . . . . . . . . . . . . 151 N
nom . . . . . . . . . . . . . . . . . . . . 150, 152 nud . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
paquetage . . . . . . . . . . . . . . . . . . . 155 Newton . . . . . . . . . . . . . . . . . . . . . . . . . . 321
rpertoire . . . . . . . . . . . . . . . . . . . . 153 nombre
module externe entier . . . . . . . . . . . . . . . . . . . . . . . . . 33
GMPy . . . . . . . . . . . . . . . . . . . . . . . . . 293 premier . . . . . . . . . . . . . . . . . . . . . . . 68
matplotlib . . . . . . . . . . . . . 249, 269 rel . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
mdp . . . . . . . . . . . . . . . . . . . . . . . . . . 253
mutagen . . . . . . . . . . . . . . . . 175, 189 O
psyco . . . . . . . . . . . . . . . . . . . . . . . . . 27 objet . . . . . . . . . . . . . . . . . . . . . 12, 93, 195
obsolte . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Index 327
octet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 pointeur darrt . . . . . . . . . . . . . . . . . . 165

oprateur port . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
comparaison . . . . . . . . . . . . . . . . . . 35 portable . . . . . . . . . . . . . . . . . . . . . . . . . 158
priorit . . . . . . . . . . . . . . . . . . . . 34, 61 porte
ordinateur . . . . . . . . . . . . . . . . . . . . . . . . 10 fonctions . . . . . . . . . . . . . . . . . . . . . . 80
orient objet . . . . . . . . . . . . . . . . . . . . . . 12 variables . . . . . . . . . . . . . . . . . . . . . . 79
outil prcision des calculs . . . . 290, 315, 320
Adobe Reader . . . . . . . . . . . . . . . . 268 prdcesseur . . . . . . . . . . . . . . . . . . . . . 261
Boost Python . . . . . . . . . . . . . . . . 158 priorit des oprateurs . . . . . . . . . . . . 34
Boost . . . . . . . . . . . . . . . . . . . . . . . . 158 probabilit . . . . . . . . . . . . . . . . . . . . . . . 297
Excel . . . . . . . . . . . . . . . . . . . 170, 173 processeur . . . . . . . . . . . . . . . . . . . . . . . 225
Graphviz . . . . . . . . . . . . . . . . . . . . 262 programmation objet . . . . . . . . . . . . . . 93
Jython . . . . . . . . . . . . . . . . . . . . . . . 158 programmes, exemples
Latex . . . . . . . . . . . . . . . . . . . . . . . . 268 Button . . . . . . . . . . . . . . . . . . . . . . 196
Microsoft Visual Studio C++ 159 Canvas . . . . . . . . . . . . . . . . . . . . . . 203
Miktex . . . . . . . . . . . . . . . . . . . . . . . 268 CheckButton . . . . . . . . . . . . . . . . 199
Mozilla Firefox . . . . . . . . . . . . . . 267 compile . . . . . . . . . . . . . . . . . 85, 133
Standard Template Library copy. . . . . .284, 285, 306, 307, 318
(STL) . . . . . . . . . . . . . . . . . . . 158 DISABLED . . . . . . . . . . . . . . . . . . . . 196
TeXnicCenter . . . . . . . . . . . . . . . 269 Entry. . . . . . . . . . . . . . . . . . . . . . . .197
wiki . . . . . . . . . . . . . . . . . . . . . . . . . . 29 eval . . . . . . . . . . . . . . . . . . . . . . 54, 84
WinZip . . . . . . . . . . . . . . . . . . . . . . 174 Frame. . . . . . . . . . . . . . . . . . . . . . . .208
grid . . . . . . . . . . . . . . . . . . . . . . . . . 207
P id . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
paquetage . . . . . . . . . . . . . . . . . . . . . . . . 155 Label. . . . . . . . . . . . . . . . . . . . . . . .195
paralllisation . . . . . . . . . . . . . . . . . . . . 225 Listbox . . . . . . . . . . . . . . . . . . . . . 201
paramtre . . . . . . . . . . . . . . . . . . . . . . . . . 71 Listbox ragissant au curseur220
immuable . . . . . . . . . . . . . . . . . . . . . 76 mainloop . . . . . . . . . . . . . . . . . . . . 209
modifiable . . . . . . . . . . . . . . . . . . . . 76 map . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
nombre variable . . . . . . . . . . . . . . . 81 Menu . . . . . . . . . . . . . . . . . . . . . . . . . 214
ordre . . . . . . . . . . . . . . . . . . . . . . . . . 74 pack . . . . . . . . . . . . . . . . . . . . . . . . . 206
passage par rfrence . . . . . . . . . . 76 RadioButton . . . . . . . . . . . . . . . . 200
passage par valeur . . . . . . . . . . . . 76 reload . . . . . . . . . . . . . . . . . . . . . . 151
valeur par dfaut . . . . . . . . . . . . . . 73 set . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
valeur par dfaut, modifiable . 73, sys.path . . . . . . . . . . . . . . . . . . . . 153
318 Text . . . . . . . . . . . . . . . . . . . . . . . . . 198
patron de classe . . . . . . . . . . . . . . . . . . 158 yield . . . . . . . . . . . . . . . . . . . . 83, 107
PDF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 zip . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
permutations. . . . . . . . . . . . . . . . . . . . .259 __name__ . . . . . . . . . . . . . . . . . . 152
pice __slots__ . . . . . . . . . . . . . . . . 122
normale. . . . . . . . . . . . . . . . . . . . . .123 Boost Python . . . . . . . . . . . . . . . . 168
trs truque. . . . . . . . . . . . . . . . . .125 ACP . . . . . . . . . . . . . . . . . . . . . . . . . 253
truque . . . . . . . . . . . . . . . . . . . . . . 123 arrondi . . . . . . . . . . . . . . . . . . . . . . 302
pice jointe . . . . . . . . . . . . . . . . . . . . . . 175 attendre un thread . . . . . . . . . . . 228
pile dappels . . . . . . . . . . . . . . . . 139, 298 barre de dfilement . . . . . . . . . . 202
pixel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204 barycentre . . . . . . . . . . . . . . . . . . . 102
point dentre . . . . . . . . . . 150, 152, 194 boucle . . . . . . . . . . . . . . . . . . . . . . . 281
pointeur . . . . . . . . . . . . . . . . . . . . . . . . . 164 bouton image . . . . . . . . . . . . . . . . 197
328 Index
carr magique . . . . . . . . . . . 256258 interface . . . . . . . . . . . . . . . . . . . . . 195

carr magique et compteur . . . 259 itrateur . . . . . . . . . . . . 66, 106, 146
carr magique et permutations jeu de caractres . . . . . . . . 192, 193
259 joueurs asynchrones . . . . . . . . . . 234
cls croissantes . . . . . . . . . . . . . . . . 65 lancer un navigateur en ligne de
comparaison . . . . . . . . . . . . . . . . . 314 commande . . . . . . . . . . . . . . . 184
comptage . . . . . . . . . . . . . . . . 91, 296 lancer un programme Python en
compteur . . . . . . . . . . . . . . . . . . . . 303 ligne de commande . . . . . . 183
concatnation . . . . . . . . . . . . . . . . . 39 lecture dun fichier texte . . . . . 246
constructeur . . . . . . . . . . . . . . . . . 132 lecture dune page HTML . . . . 156
coordonnes polaires . . . . . . . . . . 72 ligne de commande . . . . . . 183, 184
copie48, 52, 74, 114, 117, 118, 120 liste ComboBox . . . . . . . . . . . . . . . 203
damier . . . . . . . . . . . . . . . . . . 243, 244 liste avec barre de dfilement.202
date de naissance . . . . . . . . . . . . 191 liste de fichiers . . . . . . . . . . 177, 182
dates . . . . . . . . . . . . . . . . . . . . . . . . 191 liste des modules . . . . . . . . . . . . . 154
dcomposition en base 3 . . . . . 299 logarithme . . . . . . . . . . . . . . . . . . . 321
destructeur . . . . . . . . . . . . . . . . . . 115 matrice 89, 92, 136, 170, 171, 173
deux threads secondaires . . . . . 227 matrice, lignes nulles . . . . . . . . . 298
dictionnaire . . . . . . . . . . . . . . . . . . . 51 maximum . . . . . . . . . . . . . . . . . 88, 89
criture condense . . . . . . . . . . . . 46 mthode paramtre dune
Eratosthne . . . . . . . . . . . . . . . . . . . 68 fonction . . . . . . . . . . . . . . . . . 135
exception . . . . . . 139141, 144146 mthode statique. . . . . . . .108, 109
exemple de module . . . . . . . . . . 150 module pickle et classes181, 182
exercice pour svaluer . . 271, 274, moyenne, variance . . . . . . . . . . . 287
277 oprateur . . . . . . . . . . . . . . . . . . . . 105
existence dun module . . . . . . . 154 oprateur addition . . . . . . 103, 104
expressions rgulires . . . . . . . . 189 partager des donnes . . . . . . . . . 229
extraction de liens Internet. . .251 pice . . . . . . . . . . . . . . . . . . . . 123, 125
factorielle . . . . . . . . . . . . . . . . . . . . . 78 plusieurs fentre Toplevel . . . 217
FDA . . . . . . . . . . . . . . . . . . . . . . . . . 254 premier thread . . . . . . . . . . . . . . . 226
Fibonacci . . . . . . . . . . 303, 304, 312 proprit. . . . . . . . . . . . . . . . . . . . .112
fichier . . . . . . . . . . . . . . . . . . . 171173 racine carre . . . . . . . . . . . . . . . . . 321
fichier ouvert et exception . . . . 148 recherche . . . . . . . . . . . . . . . . . . . . . 88
fichier zip . . . . . . . . . . . . . . . . . . . . 174 recherche dichotomique . . . . . . . 89
fichiers binaires . . . . . . . . . 179, 180 rcupration dun texte sur
fonction isinstance . . . . . . . . . 133 Internet . . . . . . . . . . . . . . . . . 246
formatage de chane de rfrencement dobjets . . . . . . . 115
caractres . . . . . . . . . . . . . . . . . 39 slection dun fichier . . . . . . . . . 218
graphe avec matplotlib . . . . . . . 249 squence alatoire . . . . . . . . . . . . . 99
grenouille . . . . . . . . . . . . . . . 282, 283 srialisation . . . . . . . . . . . . . . . . . . 181
hritage. . . . . . . . . . . . . . . . . . . . . .134 somme . . . . . . . . . . . . . 31, 45, 58, 90
hritage multiple . . . . . . . . . . . . . 131 sortie HTML . . . . . . . . . . . . . . . . 267
hypercube . . . . . . . . . . . . . . . 316318 sortie PDF. . . . . . . . . . . . . . . . . . .268
import dune DLL . . . . . . . . . . . 165 suppression . . . . . . . . . . . . . . . . . . . 70
import de module . . . . . . . 150152 suppression dans une liste . . . . 286
import dynamique de module 153 test . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
installation dun module . . . . . 157 thread et interface graphique . 232
intgrale de Monte Carlo . . . . . 156 Tkinter avec des classes . . . . . . 221
Index 329
Tkinter, bouton . . . . . . . . . . . . . . 210 dclaration dune mthode

Tkinter, compte rebours . . . 219 statique . . . . . . . . . . . . . . . . . 109
Tkinter, fonction bind . . . . . . . 212 dsactiver un vnement . . . . . 214
Tkinter, menu . . . . . . . . . . . . . . . 215 dictionnaire et cl de type tuple
Tkinter, squence dvnements ... . . . . . . . . . . . . . . . . . . . . . . . 244
... . . . . . . . . . . . . . . . . . . . . . . . 223 division entire . . . . . . . . . . . . . . . . 34
tombola . . . . . . . . . . . . . . . . . 310, 311 criture diffre . . . . . . . . . . . . . . 171
tri. . . . . . . . . . . . . . . . . . . . . . . . .43, 90 vnement associ une mthode
tri avec positions initiales . . . . . 91 ... . . . . . . . . . . . . . . . . . . . . . . . 210
tri dentiers . . . . . . . . . . . . . . . . . . 308 vnement spcifique . . . . . . . . . 214
tri rapide . . . . . . . . . . . . . . . 264, 265 fentre intempestive . . . . . . . . . . . 16
tri, position . . . . . . . . . . . . . . . . . . 319 fichier de traces . . . . . . . . . . . . . . 172
tri, position initiale . . . . . . . . . . . 91 fichiers ouverts et non ferms 170
utilisation de messages focus . . . . . . . . . . . . . . . . . . . . . . . . 213
personnaliss . . . . . . . . . . . . 224 hritage multiple et constructeur
vecteur . . . . . . . . . . . . . . . . . . . . . . . 92 ... . . . . . . . . . . . . . . . . . . . . . . . 131
version graphique de la fonction indentation . . . . . . . . . . . . . . . . . . . 59
raw_input . . . . . . . . . . . . . . . 62 instruction sur plusieurs lignes 32
proprit . . . . . . . . . . . . . . . . . . . . 112, 113 liste et barre de dfilement . . . 202
proprits croissantes . . . . . . . . . . . . 130 majuscules et minuscules. . . . .175
py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 matrice et dictionnaire . . . . . . . 244
pyc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 mauvais vnement . . . . . . . . . . 213
Method resolution order . . . . . 127
Q mthodes et fonctions . . . . . . . . . 96
quicksort . . . . . . . . . . . . . . . . . . . . . . . . . 261 modification dun dictionnaire
dans une boucle . . . . . . . . . . 52
R
nombres franais et anglais. . .173
racine carre . . . . . . . . . . . . . . . . . . . . . 321
Nommer des groupes . . . . . . . . . 190
rapport . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
paramtres contenant des espaces
recherche dichotomique . . . . . . . . . . 270
... . . . . . . . . . . . . . . . . . . . . . . . 184
rcurrence . . . . . . . . . . . . . . . . . . . . . . . 293
passage par adresse . . . . . . . . . . . 77
rcursivit . . . . . . . . . . 78, 281, 282, 312
plusieurs erreurs . . . . . . . . . . . . . 140
condition darrt . . . . . . . . . . . . . . 78
plusieurs Listbox. . . . . . . . . . . . .202
rfrence circulaire . . . . . . . . . . 121, 181
prfixe r, chane de caractres . 36
release . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
priorit des oprations . . . . . . . . 61
remarque
proprit et hritage . . . . . . . . . 113
affectation et copie . . . . . . . . . . . 117
recharger un module . . . . . . . . . 151
ambigut . . . . . . . . . . . . . . . . . . . . 110
rduction des accs quelques
associer un vnement tous les
threads . . . . . . . . . . . . . . . . . . 231
objets . . . . . . . . . . . . . . . . . . . 213
sortie texte et graphique . . . . . . 25
blocage dun programme . . . . . 231
suppression de variables associes
caractres spciaux et
la mme instance . . . . . . 115
expressions rgulires . . . . 186
surcharge dattributs . . . . . . . . . 128
code de fin de ligne . . . . . . . . . . 173
syntaxe et espaces . . . . . . . . . . . . 58
commentaires . . . . . . . . . . . . . . . . . 32
T-uple, oprateur [] . . . . . . . . . . . 41
constructeur et fonction . . . . . . . 98
template C++ . . . . . . . . . . . . . . . 162
conversion en nombre entier . . . 34
type dune instance . . . . . . . . . . . 94
cot dun algorithme . . . . . . . . . 287
330 Index
utilisation dun logiciel de suivi classe, appel dune mthode de

de source . . . . . . . . . . . . . . . . 159 lanctre . . . . . . . . . . . . . . . . . 128
valeurs par dfaut de type classe, attribut statique . . . . . . 110
modifiable . . . . . . . . . . . . . . . . 73 classe, attribut, dfinition . . . . . 96
rpertoire . . . . . . . . . . . . . . . . . . . . . . . . 175 classe, constructeur . . . . . . . . . . . 98
reprsentation des donnes . . . . . . . 242 classe, cration dune variable de
rsultat dune fonction . . . . . . . . . . . . 71 type objet . . . . . . . . . . . . . . . . 94
classe, dfinition . . . . . . . . . . . . . . 93
S classe, hritage. . . . . . . . . . . . . . .126
SciTe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 classe, instance. . . . . . . . . . . . . . . .98
srialisation . . . . . . . . . . . . . . . . . 121, 167 classe, mthode statique . . . . . 108
somme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 classe, mthode, appel . . . . . . . . 95
sortie graphique . . . . . . . . . . . . . . . . . . . 25 classe, mthode, dfinition . . . . 95
sous-programme . . . . . . . . . . . . . . . . . . . 71 classe, proprit. . . . . . . . . . . . . .112
Strassen . . . . . . . . . . . . . . . . . . . . . . . . . 135 constructeur . . . . . . . . . . . . . . . . . . 98
successeur. . . . . . . . . . . . . . . . . . . . . . . .261 destructeur . . . . . . . . . . . . . . . . . . . 99
surcharge . . . . . . . . . . . . . . . . 75, 105, 126 espace . . . . . . . . . . . . . . . . . . . . . . . . 58
attribut . . . . . . . . . . . . . . . . . . . . . . 128 exception . . . . . . . . . . . . . . . . . . . . 140
fonction . . . . . . . . . . . . . . . . . . . . . 126 exception dun type donn . . . 142
oprateur . . . . . . . . . . . . . . . . . . . . 105 exception, lancement . . . . . . . . . 143
synchronisation . . . . . . . . . 225, 227, 229 fonction, appel . . . . . . . . . . . . . . . . 72
syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 fonction, dfinition . . . . . . . . . . . . 71
copy . . . . . . . . . . . . . . . . . . . . . . . . . 114 fonction, nombre variable de
deepcopy . . . . . . . . . . . . . . . . . . . . 119 paramtres . . . . . . . . . . . . . . . 81
def . . . . . . . . . . . . . . . . . . . . 71, 73, 81 fonction, nombre variable de
for . . . . . . . . . . . . . . . . . . . . . . . 64, 65 paramtres (appel). . . . . . . .81
if elif else . . . . . . . . . . . . . . 59, 61 fonction, ordre des paramtres 74
if else . . . . . . . . . . . . . . . . . . . . . . . 59 fonction, valeur par dfaut . . . . 73
issubclass. . . . . . . . . . . . . . . . . .132 fonctions et chanes de caractres
lambda . . . . . . . . . . . . . . . . . . . . . . . 82 .... . . . . . . . . . . . . . . . . . . . . . . . .37
range . . . . . . . . . . . . . . . . . . . . . . . . . 45 formatage dune chane de
staticmethod . . . . . . . . . . . . . . . 108 caractres . . . . . . . . . . . . . . . . . 39
while . . . . . . . . . . . . . . . . . . . . . . . . . 63 formatage des nombres . . . . . . . . 40
__add__ . . . . . . . . . . . . . . . . . . . 103 hritage. . . . . . . . . . . . . . . . . . . . . .126
__copy__ . . . . . . . . . . . . . . . . . . 116 instance. . . . . . . . . . . . . . . . . . . . . . .98
__deepcopy__ . . . . . . . . . . . . . 119 mthode . . . . . . . . . . . . . . . . . . . . . . 37
__iadd__ . . . . . . . . . . . . . . . . . . 104 mthode statique . . . . . . . . . . . . 108
__init__ . . . . . . . . . . . . . . . . . . . 98 proprit. . . . . . . . . . . . . . . . . . . . .112
__str__ . . . . . . . . . . . . . . . . . . . 105 test . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
ajout de mthode . . . . . . . . . . . . 111 test condens . . . . . . . . . . . . . . . . . 61
appel une mthode de lanctre test enchan . . . . . . . . . . . . . . . . . . 59
... . . . . . . . . . . . . . . . . . . . . . . . 128
attribut fig. . . . . . . . . . . . . . . . . .122 T
attribut statique . . . . . . . . . . . . . 110 tabulations . . . . . . . . . . . . . . . . . . . . . . . . 21
chane de caractres, formatage39 taille mmoire . . . . . . . . . . . . . . . 179, 181
chane de caractres, formatage template . . . . . . . . . . . . . . . . . . . . . . . . . 158
des nombres . . . . . . . . . . . . . . 40 test . . . . . . . . . . . . . . . . . . . . . . . . . . . 59, 62
test de non-rgression . . . . . . . . . . . . . 29
Index 331
thread . . . . . . . . . . . . . . . . . . . . . . . . . . . 225 list . . . . . . . . . . . . . . . . . 42, 65, 118

fil dexcution. . . . . . . . . . . . . . . .226 long . . . . . . . . . . . . . . . . . . . . . . . . . . 56
verrou . . . . . . . . . . . . . . . . . . 229, 230 None . . . . . . . . . . . . . . . . . . . . . . 33, 71
Tkinter set . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
barre de dfilement . . . . . . . . . . 202 string . . . . . . . . . . . . . . . . . . . . . . . 36
boucle de message . . . . . . . . . . . 209 tuple . . . . . . . . . . . . . . . . . . . . . . . . . 40
bouton. . . . . . . . . . . . . . . . . . . . . . .196 chane de caractres . . . . . . . . . . . 36
bouton radio . . . . . . . . . . . . . . . . . 200 complexe . . . . . . . . . . . . . . . . . . . . . 41
canevas . . . . . . . . . . . . . . . . . . . . . . 203 dictionnaire . . . . . . . . . 49, 118, 242
case cocher . . . . . . . . . . . . . . . . 199 ensemble . . . . . . . . . . . . . . . . . . . . . . 56
case ronde . . . . . . . . . . . . . . . . . . . 200 entier . . . . . . . . . . . . . . . . . . . . . . . . . 33
compte rebours . . . . . . . . . . . . 219 fonction . . . . . . . . . . . . . . . . . . . . . . . 92
contrle . . . . . . . . . . . . . . . . . . . . . . 195 immuable . . . . . . . . . . . . . . . . . 32, 76
vnement, association . . . . . . . 211 immutable . . . . . . . . . . . . . . . . . . . . 32
vnement, dsactivation . . . . . 214 liste . . . . . . . . . . . . . 42, 65, 118, 242
fentre . . . . . . . . . . . . . . . . . . . . . . . 217 modifiable . . . . . . . . . 32, 42, 76, 93
focus . . . . . . . . . . . . . . . 206, 210, 213 mutable . . . . . . . . . . . . . . . . . . . . . . . 32
liste . . . . . . . . . . . . . . . . . . . . . . . . . 201 objet. . . . . . . . . . . . . . . . . . . . . . . . . .94
menu . . . . . . . . . . . . . . . . . . . . . . . . 214 rel . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
objets. . . . . . . . . . . . . . . . . . . . . . . .195 rien . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
positionnement dobjet. . . . . . .206 types fondamentaux . . . . . . . . . . . . . . . 31
ractivit . . . . . . . . . . . . . . . . . . . . 225
sous-fentre . . . . . . . . . . . . . . . . . . 208 U
tabulation . . . . . . . . . . . . . . . . . . . 210 unicode . . . . . . . . . . . . . . . . . . . . . . . . . . 192
thread . . . . . . . . . . . . . . . . . . 225, 231 union . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
touche tabulation . . . . . . . . . . . . 206 utf-8 . . . . . . . . . . . . . . . . . . . . . . . . . 23, 192
touches muettes. . . . . . . . . . . . . .211
V
widget . . . . . . . . . . . . . . . . . . . . . . . 195
valeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
zone de saisie . . . . . . . . . . . . . . . . 197
valeur par dfaut . . . . . . . . . . . . . . . . . . 73
zone de saisie plusieurs lignes
objet modifiable . . . . . . . . . . . . . 318
... . . . . . . . . . . . . . . . . . . . . . . . 198
valeur par dfaut modifiable . . . . . . 318
zone de texte . . . . . . . . . . . . . . . . 196
van Rossum, Guido . . . . . . . . . . . . . . . 12
traces . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
variable
tri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
globale . . . . . . . . . . . . . . . . 79, 95, 96
entiers . . . . . . . . . . . . . . . . . . . . . . . 308
identificateur . . . . . . . . . . . . . . 31, 79
liste . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
locale . . . . . . . . . . . . . . . . . . . . . . . . . 79
position initiale . . . . . . . . . . . . . . . 91
porte . . . . . . . . . . . . . . . . . . . . . . . . 79
quicksort . . . . . . . . . . . . . . . . . . . . 261
statique . . . . . . . . . . . . . . . . . 227, 229
typage dynamique . . . . . . . . . . . . . . . . . 13
type . . . . . . . . . . . . . . . . . . . . . . . . . . 31
type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
vecteur . . . . . . . . . . . . . . . . . . . 41, 92, 130
bool . . . . . . . . . . . . . . . . . . . . . . . . . . 35
version, debug, release . . . . . . . 165, 288
complex . . . . . . . . . . . . . . . . . . . . . . 41
vitesse dexcution . . . . . . . . . . . . . . . 157
dict . . . . . . . . . . . . . . . . 49, 118, 295
Exception . . . . . . . . . . . . . . . . . . . 140 W
False, True . . . . . . . . . . . . . . . . . . . 35 widget . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
float . . . . . . . . . . . . . . . . . . . . . . . . . 33 wiki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
frozenset . . . . . . . . . . . . . . . . . . . . 56
int . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

Initiation Via Python Ellipse Mai 2010 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Initiation Via Python Ellipse Mai 2010 PDF

Cargado por

Copyright:

Formatos disponibles

Langages Informatiques

Un outil commode au service de lingnieur

5. Concernant ce point, cet exemple tlchargeable permet de construire entirement un module

partie I Le langage Python 9

2. Types et variables du langage Python . . . . . . . . . . . . . . . . . . . . . 31

3. Syntaxe du langage Python (boucles, tests, fonctions) . . . . . . . . . . . . 57

7. Fichiers, expressions rgulires, dates . . . . . . . . . . . . . . . . . . . . . 169

8. Interface graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

partie II Enoncs pratiques, exercices 237

10. Exercices pratiques pour sentraner . . . . . . . . . . . . . . . . . . . . . . 238

11. Exercices pratiques pour svaluer . . . . . . . . . . . . . . . . . . . . . . . 270

12. Exercices crits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280

Les programmes informatiques sont souvent laboutissement dun raisonnement,

Ce chapitre sintresse tout dabord linstallation du langage Python et la ra-

1.1 Ordinateur et langages

1.1.2 Termes informatiques

Dfinition 1.1 : algorithme

Dfinition 1.2 : programme

Dfinition 1.3 : compilateur et compilation

Dfinition 1.4 : langage interprt

Dfinition 1.5 : mot-cl

Dfinition 1.6 : instruction

1.2 Prsentation du langage Python

1.2.2 Le langage en quelques points

regroupe un ensemble de donnes et un ensemble de fonctionnalits attaches ces

1.2.3 Avantages et inconvnients du langage Python

Si le langage C reste le langage de prdilection pour limplmentation dalgorithmes

1.3 Installation du langage Python

Figure 1.1 : Menu ajout Microsoft Windows.

Figure 1.2 : Ligne de commande, la premire ligne affecte la valeur 3 la variable x, la

1.3.2 Particularit de Mac OS X et Linux

1.3.3 Utilisation de lditeur de texte

Figure 1.3 : Fentre de commande fournie avec le langage Python.

Aprs lexcution de ces quelques lignes, les variables 13 x, y, z existent toujours. La

Figure 1.4 : Fentre

Figure 1.5 : Cliquer sur

1.4 Installation dun diteur de texte

Figure 1.6 : Configuration de

Il suffit de prciser le rpertoire o se trouve linterprteur qui devrait tre

Figure 1.7 : Excution dun

1.4.2 Python Scripter

Figure 1.8 : Copie dcran de lditeur Python Scripter.

1.4.3 Eclipse et PyDev

1.4.4 Ct Mac OS X : TextWrangler

Microsoft Windows 21 . Lenvironnement de dveloppement XCode est aussi une

1.4.5 Autres diteurs

1.5 Premier programme

1.5.1 Afficher le rsultat dun calcul

print "premier message"

Un programme ne barbouille pas lcran de texte indsirable, il naffiche que ce

print 3.141592 * 5*5

from math import * # permet dutiliser les extensions mathmatiques de Python

Remarque 1.8 : print Python 3.0

print (3.141592 * 5*5)

1.5.2 Les accents

Lerreur est la suivante :

1.6 Installation dextensions (ou modules externes)

Figure 1.9 : Image dun

1.6.2 Calculs scientifiques

1.6.4 Base de donnes

1.6.5 Interfaces graphiques

1.6.6 Microsoft Windows, Microsoft Excel, PDF

1.6.7 Acclration de Python