phy 1234 : introduction `a la physique num©rique - d©partement de

PHY 1234 : Introduction a la physique numerique

Normand Mousseau

Montreal, automne 2006

Table des matieres

1 Introduction 71.1 Choix de python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.2 Bonjour le monde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.2.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81.3 Un autre exemple : numerologie . . . . . . . . . . . . . . . . . . . . . . . . . . 91.4 Utiliser python sur un environnement Windows . . . . . . . . . . . . . . . . . 9

1.4.1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.4.2 Test de l’installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.4.3 Test de Maplotlib/pylab . . . . . . . . . . . . . . . . . . . . . . . . . . 10

1.5 Executer python sur un environnement Unix ou Linux . . . . . . . . . . . . . 101.5.1 Test de l’installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

1.6 Utiliser python sur un Macintosh . . . . . . . . . . . . . . . . . . . . . . . . . 121.7 Interface et editeur IDLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2 Commandes de base 152.1 Presentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.1.1 Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.1.2 Instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162.1.3 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.2 Aide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172.3 Noms de variables, objets et classes . . . . . . . . . . . . . . . . . . . . . . . . 182.4 Types pre-definis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

2.4.1 Variables entieres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192.4.2 Variables reelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192.4.3 Variables complexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.5 Assignation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.5.1 Regles arithmetiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.5.2 Transformation des types . . . . . . . . . . . . . . . . . . . . . . . . . 222.5.3 Operateurs d’assignation, d’incrementation et de decrementation . . . 22

2.6 Chaınes de caracteres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232.6.1 Chaınes accentuees - encodage UTF-8 . . . . . . . . . . . . . . . . . . 25

2.7 Transformer une chaıne en nombre et vice-versa . . . . . . . . . . . . . . . . . 272.7.1 Transformer une chaıne en nombre . . . . . . . . . . . . . . . . . . . . 272.7.2 Transformer un nombre en chaıne . . . . . . . . . . . . . . . . . . . . 272.7.3 Comparer des chaınes de caracteres . . . . . . . . . . . . . . . . . . . 28

3

4 TABLE DES MATIERES

2.7.4 Scinder les chaınes : la commande split . . . . . . . . . . . . . . . . . . 292.8 Entree et sortie standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

2.8.1 Sortie standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302.8.2 Entree standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

2.9 Operateurs logiques et relationnels . . . . . . . . . . . . . . . . . . . . . . . . 312.9.1 Operateurs relationnels . . . . . . . . . . . . . . . . . . . . . . . . . . 322.9.2 Operateurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

2.10 Structures de selection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332.10.1 La structure si/sinon (if/else/elif) . . . . . . . . . . . . . . . . . . 33

2.11 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342.11.1 La boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342.11.2 La boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

2.12 Lecture et ecriture de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . 362.12.1 Redirection des entree et sortie standards . . . . . . . . . . . . . . . . 362.12.2 Ecriture dans un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . 372.12.3 Lecture a partir d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . 382.12.4 Lecture d’un fichier quelconque . . . . . . . . . . . . . . . . . . . . . . 382.12.5 Lecture et ecriture de caracteres accentues . . . . . . . . . . . . . . . 39

2.13 Listes, tuples, dictionnaires et tableaux . . . . . . . . . . . . . . . . . . . . . . 402.13.1 Les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402.13.2 Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

2.14 Quitter le programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

3 Structure d’un programme en python 473.1 Methodes, variables et constantes de classe . . . . . . . . . . . . . . . . . . . 47

3.1.1 Bibliotheques de classes . . . . . . . . . . . . . . . . . . . . . . . . . . 483.1.2 Constantes et variables de la classe . . . . . . . . . . . . . . . . . . . . 483.1.3 Methodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493.1.4 Programme-type a une classe. . . . . . . . . . . . . . . . . . . . . . . . 493.1.5 Qualificatifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

3.2 Methodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513.2.1 La methode principale . . . . . . . . . . . . . . . . . . . . . . . . . . . 533.2.2 Utilisation d’arguments dans d’autres methodes . . . . . . . . . . . . . 533.2.3 Methodes recursives . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553.2.4 Liste d’arguments flexible . . . . . . . . . . . . . . . . . . . . . . . . . 55

3.3 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563.4 Les bibliotheques de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

4 La programmation orientee objet 594.1 La classe : l’objet de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594.2 Definir les classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

4.2.1 Exemple : un objet nomme Bloc . . . . . . . . . . . . . . . . . . . . . 604.3 Initialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624.4 Heritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634.5 Regles d’heritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 644.6 Comment les classes decrivent-elles les objets ? . . . . . . . . . . . . . . . . . 64

TABLE DES MATIERES 5

4.7 Un petit truc utile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

5 Numeric : une bibliotheque a l’usage des scientifiques 675.1 La bibliotheque mathematique . . . . . . . . . . . . . . . . . . . . . . . . . . 675.2 Numeric . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

5.2.1 Obtenir et installer Numeric . . . . . . . . . . . . . . . . . . . . . . . 685.2.2 Les objets de Numeric . . . . . . . . . . . . . . . . . . . . . . . . . . . 695.2.3 Creer un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 695.2.4 Extraire des elements . . . . . . . . . . . . . . . . . . . . . . . . . . . 725.2.5 Operations sur les tableaux . . . . . . . . . . . . . . . . . . . . . . . . 725.2.6 Fonctions universelles . . . . . . . . . . . . . . . . . . . . . . . . . . . 745.2.7 Operations matricielles . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

5.3 Extraire des colonnes ou des rangees d’un tableau . . . . . . . . . . . . . . . . 765.3.1 Algebre lineaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

5.4 Nombres pseudo-aleatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . 785.4.1 random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 785.4.2 RandomArray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

6 Pylab et matplotlib 816.1 Installation de matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

6.1.1 Premiere utilisation de matplotlib . . . . . . . . . . . . . . . . . . . . 816.1.2 Quelques exemples plus etendus . . . . . . . . . . . . . . . . . . . . . 826.1.3 Lecture et ecriture de donnees . . . . . . . . . . . . . . . . . . . . . . 846.1.4 Utilisation interactive . . . . . . . . . . . . . . . . . . . . . . . . . . . 866.1.5 Une presentation amelioree . . . . . . . . . . . . . . . . . . . . . . . . 87

6.2 Graphiques animes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 896.2.1 Un premier exemple : animation.py . . . . . . . . . . . . . . . . . . . . 896.2.2 Deux graphiques - deplacement sur un cercle . . . . . . . . . . . . . . 92

6.3 Interface interactive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 956.4 pylabgui (interface graphique) . . . . . . . . . . . . . . . . . . . . . . . . . . 99

7 Graphiques et interfaces graphiques 1077.1 Installation de gnuplot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

7.1.1 Test de Gnuplot sur Windows . . . . . . . . . . . . . . . . . . . . . . . 1087.2 Executer python sur un environnement Unix ou Linux . . . . . . . . . . . . . 1087.3 Gnuplot et gnuplot.py . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

7.3.1 Utilisation de gnuplot.py . . . . . . . . . . . . . . . . . . . . . . . . . 1097.4 Graphiques Tkinter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

7.4.1 Cadres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1127.4.2 Les elements essentiels . . . . . . . . . . . . . . . . . . . . . . . . . . 1137.4.3 Objet graphique Canvas . . . . . . . . . . . . . . . . . . . . . . . . . . 114

7.5 Principes de base d’une interface graphique (GUI) . . . . . . . . . . . . . . . 1177.5.1 Quelques composantes graphiques . . . . . . . . . . . . . . . . . . . . 117

7.6 Meler graphiques et interface graphiques . . . . . . . . . . . . . . . . . . . . . 1237.7 Presentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

7.7.1 pack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

6 TABLE DES MATIERES

7.7.2 grid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

A Les regles de la bonne programmation 129A.1 Quand on ecrit un programme . . . . . . . . . . . . . . . . . . . . . . . . . . 129A.2 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130A.3 Quelques elements de bon usage . . . . . . . . . . . . . . . . . . . . . . . . . 130

B Installer Python et Emacs sous Windows XXX 133B.1 Installer EMACS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133B.2 Installer Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

C Breve introduction a Linux/Unix 135C.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135C.2 Commandes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135C.3 Copier-coller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136C.4 Editeur de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136C.5 Pico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136C.6 Emacs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

C.6.1 Caracteres accentues . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137C.6.2 Formattage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

C.7 Imprimer a partir de ESIBAC . . . . . . . . . . . . . . . . . . . . . . . . . . . 137C.8 Imprimer un programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137C.9 Tuer une tache d’impression . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

D xmgrace et gracePlot.py 139D.0.1 Premiere utilisation de gracePlot.py . . . . . . . . . . . . . . . . . . . 139D.0.2 Quelques exemples plus etendus . . . . . . . . . . . . . . . . . . . . . 140

E GNU-EMACS - Presentation simplifiee 145

F Acces aux fichiers et ordinateurs de l’exterieur 151F.1 Acceder a esibac . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151

F.1.1 Branchement a partir d’un ordinateur roulant Linux ou Mac Os X . . 151F.1.2 Branchement a partir d’un ordinateur roulant Windows XXX . . . . . 151

F.2 Transferer vos fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152F.2.1 Copier/coller a partir de la fenetre telnet . . . . . . . . . . . . . . . . 152F.2.2 Envoi par courriel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152F.2.3 Transferer vos fichiers avec ftp . . . . . . . . . . . . . . . . . . . . . . 152

G Rapports de laboratoire 153

Index 154

Chapitre 1

Introduction

La programmation scientifique est differente de la programmation d’applications de bu-reautique. Parce que les utilisateurs de ces programmes doivent pouvoir comprendre ce quis’y passe dans les moindres details, il est primordial d’ecrire des programmes limpides, faci-lement modifiables. L’approche de la boıte noire, preferee par les programmeurs de logicielsd’utilisation courante, n’est donc pas ideale pour ce genre de projet.

L’emphase de ce cours est mise sur les techniques de simulation et les problemes physiquesqui leur sont associes. Nous ne traiterons donc que des elements du langage python quinous sont indispensables. Ceci devrait etre suffisant, toutefois, pour vous donner les outilsinformatiques necessaires a la resolution numerique de la plupart des problemes que vousrencontrerez au cours des 3 prochaines annees.

1.1 Choix de python

Dans la premiere partie de ce cours, nous couvrirons les bases de la programmationscientifique. Bien que nous utilisions python dans les exemples, les structures decrites sontsimilaires a celles que l’on retrouve dans la plupart des autres langages de programmation.

Python n’est pas, en general, le langage de programmation de choix pour la program-mation scientifique. La plupart des gros codes de recherche sont ecrits en Fortran, en C ouen C++. La structure des deux premiers langages est plutot lineaire et permet une optimi-sation plus poussee ; la rapidite d’execution est generalement primordiale dans ce genre deprogrammes.

Python gagne toutefois rapidement en popularite dans la communaute scientifique pourdes taches courantes, comme la gestion et la manipulation des donnees, les interfaces entreles programmes plus lourds ainsi que les interfaces graphiques (de concert avec tkinter).Successeur du langage ABC, python, cree par Guido van Rossum, a ete structure des ledebut pour servir a la fois le monde de l’education et la communaute informatique.

Afin d’executer correctement, les programmes ecrits en python se doivent d’etre bienstructures et indentes ; ils restent donc faciles a lire. De plus, le langage possede une structureorientee-objet, les variables n’ont pas a etre declarees, il peut etre utilise en mode interactifet il possede une grande variete de bibliotheques de methodes.

Finalement, l’interpreteur python est disponible gratuitement sur presque toutes lesplates-formes, avec le meme jeu de commandes graphiques, et les fichiers sont parfaitement

7

8 CHAPITRE 1. INTRODUCTION

transferables. Il vous sera donc possible d’installer ce logiciel sur votre ordinateur person-nel, qu’il roule Mac Os X, Linux ou Windows, de developper le code et de l’executer sansmodification sur n’importe quelle autre plate-forme.

Ces avantages font de python un language de programmation privilegie pour un premiercontact ainsi que pour le developpement d’applications simples a utilisation limitee.

1.2 Bonjour le monde

Tout livre de programmation qui se respecte commence avec un programme Bonjour lemonde. Nous n’y ferons pas exception. Malheureusement, comme vous le verrez, la syntaxede python est telle que ce programme est d’une trivialite embarrassante. Vous pourrez aumoins utiliser cet exemple pour vous assurer que python est installe correctement sur votremachine... (Pour plus de details, voyez la section d’installation.)

1.2.1 Exemple

Lancez python du terminal en tapant python a l’invite de commandes.

mousseau% pythonPython 2.4.3 (#1, Apr 7 2006, 10:54:33)Type "help", "copyright", "credits" or "license" for more information.>>> print ’Bonjour le monde’Bonjour le monde>>>

Pour quitter le mode interactif, il suffit de taper Controle-D (pressez simultanement latouche Ctrl et la touche D).

Note : Revoyons les lignes ci-dessus. Apres envoir lance python, la version de l’in-terpreteur s’affiche, suivie de diverses informations sur son utilisation. Les “>>>” represententl’invite pour l’utilisation en mode interactif. La commande print imprime ce qui suit al’ecran. C’est aussi simple que ca !

Si on veut eviter d’avoir a retaper cette commande chaque fois qu’on desire imprimerBonjour le monde a l’ecran. On peut mettre la commande dans un fichier, bonjour.py, parexemple, et le lancer a partir de l’invite

% python bonjour.py

Dans ce cas, il est utile de documenter le programme en detail. Ceci permet de comprendre cequ’un programme fait quelques heures apres qu’il eut ete ecrit. Nous pouvons donc re-ecrirele programme ci-haut avec des commentaires. Toutes les lignes ici doivent commencer dansla premiere colonne.

1 # Programme bonjour.py2 # Ce programme imprime la chaıne de caracteres "Bonjour le monde!" a l’ecran.3 #4 # Copyright N. Mousseau 200356 print ’Bonjour le monde’

1.3. UN AUTRE EXEMPLE : NUMEROLOGIE 9

1.3 Un autre exemple : numerologie

Voici un autre exemple qui demontre la simplicite de python :

1 print ’Quel est le numero de ce cours ?’2 cours1 = input()3 cours2 = input("Donnez le numero d’un autre cours: ")4 print ’La somme de ces deux cours est :’5 print cours1 + cours2

Retapez et executez ce programme. Repondez aux questions. Quel est le role des diversescommandes ?

1.4 Utiliser python sur un environnement Windows

1.4.1 Installation

Avant de commencer, on doit installer les suites de logiciels de developpement et d’executiondes programmes en python. Ceci inclut le programme python et l’environnement de developpementidle, qui contient une interface et un editeur puissant, ainsi que plusieurs autres programmesnecessaires pour manipuler les matrices et faire des graphiques. La liste des programmes estindiquee dans le tableau 1.1.

Il n’est pas necessaire d’installer separement idle, ipython, ni les bibliotheques Numeric,tkinter ou matplotlib car le paquetage de Enthought inclut deja celles-ci ainsi que beaucoupd’autres. L’installation de l’ensemble est automatisee et ne requiert qu’un seul clic. On peutdifficile faire plus simple.

1.4.2 Test de l’installation

Afin de vous assurer que tout fonctionne, lancez l’environnement de travail idle soit apartir du menu (dans windows) ou du terminal (sous les autres plateformes).

Si le programme est lance, vous avez bien installe python. Vous devriez voir une fenetreavec quelque chose comme :

Python 2.4.3 - Enthought Edition (#1, 03/31/04, 04:38:35)Type "copyright", "credits" or "license" for more information.IDLE 1.1.3 -- press F1 for help

Tapez ensuite la commande suivante :

>>> print "Bonjour le monde !"Bonjour le monde !>>>

Qui devrait vous retourner

Bonjour le monde !>>>


Tab. 1.1 – Programmes necessaires dans le cadre du cours. J’indique egalement la versionutilisee au cours afin d’eviter les conflits. Enthought python est un paquetage qui contientdeja Numeric et plusieurs autres bibliotheques utiles.

Programme Version AdressePython 2.4.x http ://www.python.orgNumeric 24 ou plus http ://numpy.sourceforge.netNumpy 0.9.8 http ://numeric.scipy.orgMatplolib 0.87.x http ://matplotlib.sourceforge.netIpython 1.7 http ://ipython.scipy.orgIdle 1.1.x http ://www.python.org/idle

Windowsenthought python 2.4.x http ://www.enthought.com/python

Mac Os XPython 2.4.x http ://pythonmac.org/packages/py24-fat/index.htmlMatplotlib 0.87.x idemNumeric 24.x idemNumpy 0.98.x idem

Verifiez maintenant que Numeric est installe :

>>> from Numeric import *>>> a = zeros([3])>>> print a[0 0 0]

Si Numeric ne fonctionne pas il faut reinstaller (ou venir me voir).

1.4.3 Test de Maplotlib/pylab

Il ne vous reste plus qu’a verifier que matplotlib est bien installe. Pour ce faire, vousn’avez qu’a essayer les commandes suivantes :

>>> from pylab import *>>> plot([1,2,3,4])>>> show()

Si une fenetre s’ouvre avec un graphique dedans, tout va bien !

1.5 Executer python sur un environnement Unix ou Linux

Une version compilee de python est disponible pour tous les systemes d’operation Unix/Linux.Ceci inclut les systemes d’operation de Sun, Silicon Graphics, IBM, Dec/Compaq et Linux.En fait, python est deja installe sur la plupart de ces machines. Vous pouvez vous assurez que

1.5. EXECUTER PYTHON SUR UN ENVIRONNEMENT UNIX OU LINUX 11

la version deja installee est au moins la version 2.3. Pour ce faire, entrez python a l’invite. Lapremiere ligne indique la version du language. Pour mettre a jour, suivez les instructions quevous trouverez sur le site www.python.org ; dans plusieurs cas, vous pourrez teledechargerune version deja compilee qui inclut egalement l’outil de developpement idle.

Si vous utilisez Linux, suivez les indications de votre distribution pour installer les pro-grammes et bibliotheques suivants :

1. Python 2.4 (ou plus)

2. Numeric

3. Tcl/tk et Tkinter

4. Matplotlib

5. Ipython (facultatif)

En general, python, idle, Numeric, Tcl/Tk et Tkinter sont deja installes ; il ne vous manqueraplus Matplotlib et, ca peut etre utile, ipython.

Pour les ordinateurs roulant sous Linux, vous pouvez soit teledecharger un rpm dejacompile ou le fichier source.tar.gz. Une fois le fichier recupere sur votre machine, ouvrezle fichier comprime avec la commande

tar xzf python*tar.gz

et suivez les instructions contenues dans les fichiers README.

Fichier de configuration Matplotlibrc

Pour Linux et Mac Os X, il est necessaire de definir l’interface graphique et la bibliothequenumerique utilisees avant la premiere utilisation de matplotlib. Pour ce faire, vous devezd’abord creer un sous-repertoire cache dans votre repertoire principal :

% cd ~% mkdir .matplotlib

Transportez-vous dans ce repertoire et creez un fichier appele matplotlibrc

% cd .matplotlib% pico matplotlibrc

qui contiendra les lignes suivantes (sans espace au debut de la ligne)

backend : TkAggnumerix : Numeric

Sauvegardez ce fichier et le tour est joue !


1.5.1 Test de l’installation

En mode terminal, suivez les instructions donnees dans la section Windows pour compileret executer un programme. Les outils d’edition de fichiers sont beaucoup plus nombreux surUnix. En plus d’idle, developpes expressement pour python, les plus traditionnels sont Emacset vi. Ceux-ci presentent toutefois un courbe d’apprentissage assez abrupte. Le programmepico, qui est egalement utilise par le programme de courriel pine, est plus facile a utiliserpour un debutant.

Si ces programmes ne peuvent etre lances sur votre machine, verifier que les cheminsd’acces sont definis correctement dans votre fichier .cshrc ou .bashrc.

1.6 Utiliser python sur un Macintosh

Si vous utilisez Mac Os X, tout va bien. Python version 2.4.x, de meme que Tcl/Tk, sontinstalles par defaut sur Tiger (Os X 10.4.x), il ne vous reste plus qu’a ajouter les outils dedeveloppement ainsi que quelques bibliotheques.

Les outils de developpement se trouvent sur le disque d’installation du systeme d’operation,dans le repertoire Xcode Tools. Il suffit d’installer le paquetage XcodeTools.mpkg et le tourest joue.

Il ne reste plus qu’a installer numeric, matplotlib et ipython. Vous trouverez des versionsen format universel sur le site http ://pythonmac.org/packages. Pour plus de simplicite,installez, dans l’ordre les paquetages suivants :

1. Numeric

2. Numpy

3. Matplotlib

4. ipython

Tous ces paquetages s’installent de la maniere habituelle. Une fois que vous aurez termine,il vous faut definir l’interface graphique. Suivez les directives de la section 1.5 (Matplotlibrc).

Suivez les directives de la section Windows pour tester votre installation. Pour ce faire,vous devrez lancer un terminal, qui se trouve dans le sous-repertoire Utilitaires d’Appli-cations.

1.7 Interface et editeur IDLE

Dans le cours, je recommande l’utilisation de l’editeur Emacs. Toutefois, sur les machinesWindows et Mac, il est souvent plus simple d’utiliser l’environnement de developpementIDLE. Vous pouvez y acceder sur Windows a partir du menu Enthought python et, sur Mac,a partir du sous-repertoire Applications/MacPython ou directement du terminal.

Lorsque vous lancez le logiciel, une fenetre de commandes s’ouvre, similaire a ce qu’onvoit lorsqu’on lance python en mode terminal.

Pour ouvrir un nouveau fichier, choisissez l’option New Window dans le menu File.Pour executer un nouveau programme, il vous suffit de frapper la touche F5.IDLE est un programme tres flexible. IL a deux limitations toutefois :

1. le programme n’assure pas un formattage du programme aussi efficacement qu’Emacs ;

1.7. INTERFACE ET EDITEUR IDLE 13

2. Afin de pouvoir utiliser des caracteres accentues dans les programme, il faut indiquerquel encodage est utilise pour ceux-ci (les ordinateurs ne fonctionnent souvent qu’enascii).Sur les machines Windows, l’encodage utilise est generalement iso8859-1 (isolatin).Toutefois, ce n’est plus l’encodage prefere, qui est appele Unicode, ou utf-8. Pours’assurer une meilleure compatibilite, je vous conseille donc d’ajouter (sans espace audebut)

# -*- coding: utf-8 -*-

au debut de votre fichier (pour isolatin, utilisez # -*- coding: iso8859-1 -*-)Comme Apple a adopte Unicode (utf-8) pour encoder ses caracteres, vous n’aurez pasde probleme non plus sur cette plateforme. Pour vous simplifier la vie, utilisez toujoursla ligne de definition d’encodage dans vos programmes.

Chapitre 2

Commandes de base

Python est un langage de programmation oriente objet. Ce concept est explique au cha-pitre 4. Pour l’instant nous nous concentrerons sur les structures les plus simples.

Les commandes de base de python sont plutot simples et ressemblent en gros a cellesde C, C++ et Fortran. Comme il s’agit d’un langage script et interactif, python presentesouvent une syntaxe simplifiee et protegee par rapport a des langages compiles. Langagede programmation orientee objet, python donne egalement acces a une floppee d’interfacesde programme d’application, qui composent un coffre d’outils (ou une boıte noire...) pou-vant etre utilises lors du developpement d’interfaces graphiques et autres. Nous utiliseronscertaines de ces interfaces en cours.

2.1 Presentation

2.1.1 Structures

Python requiert une presentation visuelle bien definie afin d’executer convenablement.Les instructions de chaque structure — classe, methode ou boucle – imbriquee dans une autredoivent etre indentees, c’est-a-dire decalees de quelques espaces vers la droite, par rapportaux autres lignes. On indique la fin d’une structure en revenant a l’alignement de la structureprecedente.

Ainsi, on ecrira :

1 class premiereClasse : # Superstructure de classe2 global variables # Variables34 def uneMethode(self) : # une methode imbriquee dans la classe5 x = 3.06 for i in range(4) : # Une boucle7 y = x * i # commandes dans la boucle8 z = 2 * x + i9

10 print x, y, z # On quitte la boucle1112 def autreMethode(self) : # Une autre methode

15

16 CHAPITRE 2. COMMANDES DE BASE

13 ...1415 class deuxiemeClasse : # On commence une autre classe16 ...

Tous les caracteres suivant le symbole diese (#) sont consideres comme des commentaires etsont ignores par l’interpreteur python.

L’annexe A explique en details les regles de la bonne programmation. Je vous encouragefortement a la lire puisque les programmes seront notes en partie sur leur lisibilite.

2.1.2 Instructions

On place une instruction par ligne. Le retour de chariot indique la fin de l’instruction.Si on desire placer plus d’une instruction par ligne, on peut le faire en separant chaqueinstruction par un point-virgule ( ;). Ceci n’est pas recommande, en general, car ca alourditla lecture du programme.Exemples :

chiffre = 21total = 34 + chiffreprint "Le total est ", totalnom = "Hugo"; prenom = ’Victor’

2.1.3 Commentaires

Il exist deux facons de commenter un programme ne python : le carre (#) ainsi que lestrois guillemets en paire : ”””. . .”””. Dans le premier cas, seulement les mots qui suiventle carre sur la meme ligne sont commentes ; dans le deuxieme cas, le commentaire peuts’etendre sur plusieurs lignes.

"""Ceci est un commentaire en bloc. Il permet de mettreplusieurs lignes de texte dans un commentaire.

"""

import sys # Ceci est un commentaire de ligne

# Le commentaire en bloc permet aussi de commenter plusieurs lignes# de code avec seulement quelques touches.

# Si on veut commenter les lignes suivantes:"""for i in range(5):

print ’cette ligne ainsi que la precedente est commentee’print ’cette partie du programme ne sera donc par interpretee’

"""# Fin de la partie commentee

2.2. AIDE 17

2.2 Aide

Il est possible d’obtenir un peu d’aide via l’interpreteur de commande de python. L’infor-mation fournie est souvent peuclaire, elle permet toutefois de trouver le nom des methodesassociees avec un objet particulier. Pour ce faire on peut proceder de deux facons :

(1) la commande help(classe) fournit une information construite automatiquement a par-tir des commentaires contenus dans la bibliotheque associee avec la classe.

>>> import Gnuplot # On doit d’abord importer seulement la classe>>> help(Gnuplot)

Help on package Gnuplot:

NAMEGnuplot - Gnuplot -- A pipe-based interface to the gnuplotplotting program.

FILE/System/Library/Frameworks/Python.framework/Versions/2.3/lib/python2.3/site-packages/Gnuplot/__init__.py

DESCRIPTIONThis is the main module of the Gnuplot package.

Written by "Michael Haggerty", mailto:[email protected]. Inspiredby and partly derived from an earlier version by "Konrad Hinsen",mailto:[email protected]. If you find a problem or have a suggestion,please "let me know", mailto:[email protected]. Other feedbackwould also be appreciated.

The Gnuplot.py home page is at...

Notez que si vous aviez importe toutes les methodes de la classe, avec la commande

>>> from Gnuplot import * # On importe toutes les methodes.>>> help (Gnuplot) # Dans ce cas-ci, la classe GnuplotTraceback (most recent call last): # n’est pas visible.

File "<stdin>", line 1, in ?NameError: name ’Gnuplot’ is not defined

(2) Il est egalement possible d’obtenir la liste des methodes associees avec n’importe quelobjet. La commande dir() nous permet de pallier a cette limite. Ainsi, si nous chargeons labibliotheque numerique, la commande dir() indique les nouvelles methodes disponbiles :

>>> dir()[’__builtins__’, ’__doc__’, ’__name__’, ’funcutils’, ’utils’]>>> from Numeric import *>>> dir()


[’ArrayType’, ’Character’, ’Complex’, ’Complex0’, ’Complex16’,’Complex32’, ’Complex64’, ’Complex8’, ’DumpArray’, ’Float’, ’Float0’,’Float16’, ’Float32’, ’Float64’, ’Float8’, ’Int’, ’Int0’, ’Int16’,’Int32’, ’Int8’, ’LittleEndian’, ’LoadArray’, ’NewAxis’, ’Pickler’,’PrecisionError’, ’PyObject’, ’StringIO’, ’UInt’, ’UInt16’, ’UInt32’,’UInt8’, ’Unpickler’,...

On peut aussi ne lister que les methodes associees avec un seul objet :

>>> a = "ceci est une chaıne">>> dir(a)

[’__add__’, ’__class__’, ’__contains__’, ’__delattr__’, ’__doc__’,’__eq__’, ’__ge__’, ’__getattribute__’, ’__getitem__’, ’__getnewargs__’,’__getslice__’, ’__gt__’, ’__hash__’, ’__init__’, ’__le__’, ’__len__’,’__lt__’, ’__mod__’, ’__mul__’, ’__ne__’, ’__new__’, ’__reduce__’,’__reduce_ex__’, ’__repr__’, ’__rmod__’, ’__rmul__’, ’__setattr__’,’__str__’, ’capitalize’, ’center’, ’count’, ’decode’, ’encode’,’endswith’, ’expandtabs’, ’find’, ’index’, ’isalnum’, ’isalpha’,...

N’hesitez surtout pas a faire usage de ces commandes des plus utiles !

2.3 Noms de variables, objets et classes

Avec python, un nom de variable, de methode ou de classe peut inclure toute combinaisonde lettres (sans accent), chiffre, et le soulignement ( ). Toutefois, le premier caractere de toutnom ne peut pas etre un chiffre. La longueur maximale de chaque nom est d’au moins 256caracteres ; les caracteres accentues sont egalement permis.Quelques noms valides :

Ceci est un nom valide A12345 ceciEstValideCeciEstEgalementValide

g G 12 P4 R2D2

Noms invalides :

Ceci n’est pas un nom valide ! 12345A Toujours$PasValide Ca non plus

Par convention, les noms de classes en python commencent avec une majuscule. Si plu-sieurs mots sont joints ensemble dans le nom, alors chaque mot commencera par une majus-cule. Par example, CeciEstUnNomDeClasseValide.

Toujours par convention, les noms de variable devraient commencer par une minuscule.Encore une fois, si plusieurs mots sont joints ensemble pour former le nom de la variable, oncommencera chaque mot par une majuscule. Par example, ceciEstUnNomDeVariableValide.

Python se reserve l’usage exclusif de certains mots-cles, dont :

2.4. TYPES PRE-DEFINIS 19

Tab. 2.1 – Objets pre-definis : Les objets les plus simples

Type d’objet Exemple

Entiers 4690 -2,147,483,648 a +2,147,483,648Entiers longs 4893774L aussi long que necessaireNombres reels 2.34, 1.034E-4, 5.67E32, 8.1e+232 jusqu’a ≈ 1e± 308Nombres complexes 3.0 + 4j, 5.23J + 17.67 pas d’espace entre chiffre et “j” ou “J”Hexadecimal 0x9ff commence par “Ox”Octal 0434 commence par “0”Chaıne de caracteres ’chaıne’, “L’autre”

and elif global orassert else if passbreak except import printclass exec in raisecontinue finally is returndef for lambda trydel from not while

2.4 Types pre-definis

2.4.1 Variables entieres

Les variables et constantes entieres doivent etre ecrites sans point et peuvent etre precedeesd’un signe plus (+) ou moins (-) ; l’ajout d’un L a un entier signifie un type entier long, quipeut alors avoir n’importe quelle longueur desiree. L’etendue de valeurs est indiquee autableau 2.1. Les representations suivantes sont des entiers valides :

12 0 -2345 9999999999L

Toutefois 1 234 ou 1,234 ne sont pas valides.Le type d’une variable est defini a la creation :

Exemple :

nombreGalaxies = -723344567623454432384485586Lnatomes = 2345

2.4.2 Variables reelles

Les memes regles s’appliquent aux variables reelles. Dans ce cas-ci, toutefois, l’espacealloue en memoire est divise en deux blocs, la mantisse et l’exposant, ce qui permet deconserver le meme nombre de chiffres significatifs independamment de la valeur de l’exposant.Une variable reelle doit toujours avoir un point decimal ou un exposant (la virgule, prescritepar le systeme metrique, n’ayant pas encore ete acceptee par nos voisins du sud). L’exposantest toujours precede d’un E ou e, suivi, si necessaire, par les signes + ou −.


Par defaut, toutes les variables ont une precision de 64 bits.Constantes reelles valides : 12. 12E4 12e-4 1.234On ne peut pas mettre de virgule ou omettre le point (et l’exposant). Ainsi, 1234 n’est

pas une variable reelle.On peut declarer des variables reelles :

pi = 3.1415vitesse = 35.3e27

2.4.3 Variables complexes

Les variables complexes sont formees d’une partie reelle et d’une partie imaginaire, ter-minee par un j ou un J. Un niveau interne, ces deux nombres sont traites comme des variablesreelles et possedent donc les limites et les proprietes decrites dans la section precedente.Toutefois, les operations numeriques appliquees aux nombres complexes suivent les reglesmathematiques complexes.

Constantes complexes valides : 12. + 3.0J 12E4 - 0.04j 21.887e+3J + 12e-4On peut declarer des variables complexes :

a = 27.4 + 32.17Jb = 3.0 - 41jprint a*b

2.5 Assignation

Contrairement aux langages de programmation traditionnels, comme C, C++, Fortranet Java, il n’est pas necessaire d’instancier les variables en python. Il suffit de leur assignerune valeur pour en definir le type.

Une instruction d’assignation copie la valeur du terme de droite sur le terme de gauche.

nom_de_variable = expression

Cette expression peut contenir des fonctions arithmetiques et autres. Par exemple :

i = +23b = -aplus10 = plus10 + 10 #plus10 n’etant pas defini, il y a un probleme

Il faut etre particulierement prudent car le type d’une variable peut changer avec lesassignations. Pour verifier le type d’une variable, il suffit d’utiliser la commande type(<variable>).

1 >>> i = 22 >>> x = 3.03 >>> x4 3.05 >>> x = i6 >>> x7 2

2.5. ASSIGNATION 21

Tab. 2.2 – Operateurs arithmetiques de base

Type Symbole Expression Ordre d’applicationAddition + a + b 2Soustraction − a− b 2Multiplication ∗ a ∗ b 1Division / a/b 1Reste (modulo) % a%b 1

8 >>> type(x)9 <type ’int’>

2.5.1 Regles arithmetiques

Les regles de priorite des operateurs suivies par python sont les regles conventionnelles.Les multiplications et divisions, par exemple, sont appliquees avant les operateurs d’additionet de soustraction (voir le tableau 2.2).

En depit de ces regles, c’est une bonne idee d’ajouter des parentheses afin d’indiquerclairement l’ordre des operations qui doivent etre faites. En plus de prevenir les erreurs,l’utilisation de parentheses rend l’algebre plus facile a suivre pour le programmeur.

Parce que les variables sont typees – int, float, etc., quelques regles dependant destypes de variables doivent etre ajoutees aux regles arithmetiques habituelles.

Arithmetique entiere : L’arithmetique entiere n’utilise que des entiers a droite et a gauchede l’operateur d’affectation. Ainsi, toute fraction d’entier obtenue par suite d’operationsarithmetiques est automatiquement eliminee :

3/4 = 0 4/4 = 1 5/4 = 1 6/4 = 17/4 = 1 8/4 = 2 9/4 = 2

Il faut donc etre particulierement vigilant lorsqu’on utilise des entiers dans le terme de droitede l’equation.Arithmetique reelle : Ce type d’arithmetique est assez similaire a l’arithmetique conven-tionnelle. Il faut seulement se rappeler que les nombres utilises par un ordinateur ontune precision finie et que les erreurs peuvent augmenter rapidement dans certains typesd’operations.Arithmetique mixte : Si deux nombres de type float sont multiplies or additionnesensemble, le resultat sera egalement un nombre de type float. Par contre si on additionneun nombre entier et un de type float, alors le resultat sera un nombre de type float.

Premiere variable Deuxieme variable Resultatcomplex complex complexfloat complex complexint float floatlong int long


L’ordre de conversion est le suivant : complex, float, long, int ; une serie d’operationde type mixte donnera toujours, a la sortie, un resultat dont le type correspond a celui utilisese trouvant le plus a gauche de cette liste. En d’autres mots, python s’assure de ne pas perdred’information lorsque les types sont melanges.

Cette promotion numerique peut toutefois etre un peu delicate. Considerons l’exemplesuivant :

Expression Resultat1 + 1/4 11. + 1/4 1.01 + 1.0/4 1.25

Pour eviter les problemes il est donc fortement conseiller de forcer le type en utilisant lescommandes ci-dessous.

2.5.2 Transformation des types

Comme nous l’avons tout juste mentionne, python effectue automatiquement la promo-tion numerique de variables. Parfois, toutefois, on veut imposer un certain type. Pour etrecertain d’avoir un entier, par exemple. Pour ce faire, on utilise l’operateur de transformationde types : Exemple :

1 >>> x = 3.72 >>> i = 23 >>> i = i + x4 >>> i5 5.7000000000000002 # Du a la precision limitee de l’ordinateur6 >>> int(i)7 5

Cette operation explicite est appelee conversion forcee. Dans ce cas, on dit que l’on ap-plique un moule sur la variable (en anglais, cast). L’operation de moulage est accomplieen appliquant l’operateur sur la variable ou l’expression a convertir, type( <variable ouoperation> ).

>>> int( 15.4 + 23.345 + 11.2212)49

La conversion vers d’autres types est accomplie avec complex, float(), long().Afin de rendre le code plus facile a deboguer, on recommande l’utilisation d’un operateur

de moulage peu importe la direction de la transformation.

2.5.3 Operateurs d’assignation, d’incrementation et de decrementation

Tout comme C et C++, python possede quelques operateurs binaires qu’on ne retrouvepas en algebre : + =, − =, etc. Voir le tableau 2.3.

2.6. CHAINES DE CARACTERES 23

Tab. 2.3 – Operateurs additionnels (on prend int a=3, i.e. un entier)

Operateur Expression Signification Resultat(au moment de l’operation)

+ = a+ = 3; a = a + 3; a = 6− = a− = 3; a = a− 3; a = 0∗ = a∗ = 2; a = a ∗ 2; a = 6/ = a/ = 2; a = a/2; a = 1%/ a% = 2; a = a%2; a = 1

2.6 Chaınes de caracteres

Les chaıne des caracteres en python sont un type pre-defini possedant plusieurs methodesde haut-niveau. Elle peuvent representer aussi bien un caractere que le contenu complet d’unfichier. Des sequences d’echappement doivent etre utilisees pour afficher les tabulateurs, lesretours de chariots, etc. Les plus courants sont decrits dans le tableau 2.6).

Les chaınes supportent plusieurs operations telles la concatenation (combinaison de deuxchaınes), le tranchage (extraction de sections de textes), l’indexage, le formattage, etc.

Le tableau (2.4) presente quelques-unes de ces operations.

Exemples

La maniere la plus simple de comprendre les proprietes des chaınes de caracteres est vial’exemple :

1 >>> ch1 = ’Le ’2 >>> ch2 = ’petit’3 >>> ch3 = ’prince’4 >>> titre = ch1 + ch2 + ch35 >>> titre6 ’Le petitprince’

La concatenation n’ajoute pas d’espace lorsque deux chaınes sont accolees. On continue.

7 >>> len(titre)8 149 >>> ch1*4

10 ’Le Le Le Le ’

Le signe de multiplication ici ne correspond a l’operation mathematique standard, appliqueea des chiffres. Cette redefinition d’un operation s’appelle “surdefinition d’un operateur”.

Utilisant le saucissonage, on peut extraire une partie seulement de la chaıne. En python,toutes les chaınes et series commencent avec l’element zero (’0’). Donc, l’element numero 2est le troisieme de la sequence. Lorsqu’on donne un couple de chiffres (ch[3:8]), la chaınecommence au troisieme caractere et se termine au 8e (avant la position ’8’ dans la chaıne).


Tab. 2.4 – Liste des operations permises sur les chaınes de caracteres.Operation Significationch1 = ’’ chaıne vide – ne contient riench2 = "spam’s" utilisation des guillemets – permet l’apostrophebloc = """...""" triple guillements – texte sur plusieurs lignesch3 + ch4 concatenationch2 * 3 repete la chaıne 3 foisch3[i] caractere a la position ich3[i:j] tranche allant de i a jlen[ch4] longeur de la chaıne (# total de caracteres)"un %s chien"%’beau’ formattage de chaınefor x in ch3 iterationch2 in ch1 vrai si ch1 contient ch2ch2 not in ch1 vrai si ch1 ne contient pas ch2min(ch2) valeur minimale (en ascii) dans la chaınech.capitalize() premier mot avec majuscule, tous les autres sont en minusculesch.lower() remplace toutes les majuscules par des minusculesch.upper() remplace toutes les minuscules par des majusculesch.rstrip([chars]) enleve les caracteres a la fin de la chaıne. Si on ne definit pas

de caracteres, les espaces blancs seront enleves.ch.lstrip([chars]) enleve les caracteres au debut de la chaıne. Si on ne definit

pas de caracteres, les espaces blancs seront enlevesch.replace(a,b,n) remplace la chaıne a par b un nombre maximal n de fois. Si

n est omis, on remplace tout.ch.isdigit() vraie si ch ne contient que des chiffresch.isalpha() vraie si ch ne contient de des lettresch.isalnum() vraie si ch ne contient que des chiffres et des lettresch.count(ch1,p1,p2) compte le nombre de fois que ch1 est repete dans l’intervalle

ch(p1 :p2). Si p1 et p2 sont omis, on compte sur toute lachaıne.

ch.find(ch1,p1,p2) retourne la position de la premere occurence de ch1 dansl’intervalle ch(p1 :p2). Si p1 et p2 sont omis, on cherche surtoute la chaıne.

2.6. CHAINES DE CARACTERES 25

1 >>> ch3[3]2 ’n’3 >>> ch3[2],ch3[-2]4 (’i’, ’c’)5 >>> ch2[2:4], ch2[2:], ch2[:-1]6 (’ti’, ’tit’, ’peti’)

Un chiffre precede du signe moins (’-’) indique que l’on compte a partir de la fin. Cetteoperation de saucissonage s’applique egalement a toutes les sequences, pas seulement leschaınes de caracteres.

Considerons maintenant les deux dernieres operations :

1 >>> for a in ch2 : print a,2 ...3 p e t i t4 >>> "e" in ch25 1 # 1 veut dire vrai6 >>> ’r’ in ch27 0 # 0 veut dire faux

2.6.1 Chaınes accentuees - encodage UTF-8

Les caracteres accentues sont acceptes sans probleme dans les chaınes de caracteres. Sion passe les chaınes a d’autres programmes, il peut etre necessaire de preciser que l’encodagedes chaınes de caracteres. Ceci peut etre fait avec les commandes suivantes.

Tout d’abord, on doit indiquer qu’un chaıne est en format unicode. On utilise la com-mande unicode(chaine,’encodage’) ou encodage est ici utf-8 (il pourrait aussi etreisolatin, par exemple).

>>> chaine = unicode("Chaıne de caracteres",’utf-8’)>>> print chaine.encode(’utf-8’)Chaıne de caracteres>>> chaineu’Cha\xeene de caract\xe8res’

Malheureusement, cette chaıne ne peut pas etre imprimee directement avec la commandeprint.

>>> print chaineTraceback (most recent call last):

File "<stdin>", line 1, in ?UnicodeEncodeError: ’ascii’ codec can’t encode character u’\xee’ ...

Pour cela, il faut indiquer le type d’encodage associe avec cette chaıne a l’aide de la methodeencode() associee avec l’objet de chaıne :

>>> print chaine.encode(’utf-8’)Chaıne de caracteres


Fig. 2.1 – Menu Options, onglet General - choisir l’option UTF-8.

Sur une machine windows, l’impression a l’ecran (en ligne) peut exiger un encodagereserve a ces machines, soit latin-1. Il faut alors utiliser

>>> print chaine.encode(’latin-1’)Chaıne de caracteres

Si on desire imprimer en forme encodee, il faut utiliser la commande repr().

>>> print repr(chaine)u’Cha\xeene de caract\xe8res’

En general, si les chaınes sont manipulees durant une seule session, sans appel a deslibraires graphiques extraordinaires, il n’y a pas de probleme. Pour eviter les erreurs dansles programmes, il est preferable de toujours definir le type d’encode tel que decrit dans lechapitre 1, en mettant, dans l’entete du programme :

#!/usr/bin/env python# -*- coding: utf-8 -*-

Vous pouvez egalement definir l’encodage par defaut dans idle. Il suffit d’aller dans lemenu Options puis de choisir l’onglet General (voir Fig. 2.1).

Pour la lecture et l’ecriture dans des fichiers, voir ci-dessous (Section 2.12.5).Une solution a tout ce gachis est d’ajouter les commandes suivantes au debut de votre

fichier :

import locale # bibliotheque d’information sur la machine

2.7. TRANSFORMER UNE CHAINE EN NOMBRE ET VICE-VERSA 27

# Va chercher l’encodage dans la liste de valeurs localescode = locale.getdefaultlocale()[1]

# Si la machine n’est pas windows (definie par cp1252), utilise utf-8if code != ’cp1252’ :

code = ’utf-8’

Il suffit alors d’utiliser la variable code

x = unicode("chaıne de caracteres",’utf-8’)print x.encode(code)

Le programme fonctionnera donc sur Windows, Linux et Mac Os X.

2.7 Transformer une chaıne en nombre et vice-versa

2.7.1 Transformer une chaıne en nombre

On a souvent besoin de transformer des chaınes de caracteres (lues d’un fichier ou duclavier) en nombre. L’operation est simple a realiser avec python. On n’a qu’a appliquer uneoperation de moulage, tel qu’on l’a vu precedemment :

ch = "45.5546"trois = int("3") # "3" indique la chaıne 3nombre = float(chn) # chn est aussi une chaıne

2.7.2 Transformer un nombre en chaıne

La transformation d’un nombre en chaıne de caracteres est legerement plus compliqueecar il y plusieurs facon d’introduire un nombre dans une chaıne. Ainsi, on peut vouloir negarder que quelques chiffres apres le point ou imprimer en format scientifique, etc.

Les codes de formattage sont toutefois les memes pour imprimer ou copier dans unechaıne de caracteres. De meme, ils sont similaires a ceux qu’on retrouve dans C/C++.

1 >>> pi = 3.1415292 >>> chaine = " La valeur de pi est %f" % pi # On imprime le chiffre tel3 >>> print chaine # que le veut python4 La valeur de pi est 3.14162956 >>> autreChaine = "pi : %6.2f" % pi # 6 espaces au total, 2 chiffres7 >>> print autreChaine # apres le point8 pi : 3.149

10 >>> entier = 4456338421211 >>> ch = "Un grand entier : %i" % entier12 >>> print ch13 Un grand entier : 4456338421214


Tab. 2.5 – Caracteres de formattage - semblables au C/C++

Description Definition% f Nombre reel en format standard (234.32)%8.2f Nombre reel – 8 caracteres dont 2 apres le point%e, %E Nombre reel en notation scientifique (2.3432e+002)%g, %G Nombre reel en notation optimise%d, %i Nombre entier en representation decimale%6d, %12i Nombre entier en representation decimale formattee%06.2f Nombre entier, avec des zero a gauche, si necessaire%x Nombre entier en representation hexadecimale%o Nombre entier en representation octale%c Caractere simple%s Chaıne de caracteres

Tab. 2.6 – Caracteres speciaux

Sequence de formation Definition\n Retour de chariot (nouvelle ligne)\t Tabulateur horizontal\r Retour de chariot au debut de la ligne actuelle\\ Barre oblique inverse\’ Apostrophe\" Guillemets\u#### Caractere unicode

15 # On peut formatter l’entier. Si le format est trop petit, il est ignore16 >>> print "Un grand entier : %6i" % entier17 Un grand entier : 4456338421218 # Sinon, des espaces sont ajoutes19 >>> print "Un grand entier : %20i" % entier20 Un grand entier : 44563384212

La liste complete des caracteres de formattage est donnee dans le tableau 2.5.

2.7.3 Comparer des chaınes de caracteres

Puisque les chaınes de caractere sont des objets, l’utilisation des operateurs de compa-raison doit etre faite avec soin. En effet, si l’operateur == compare bien le contenu de deuxchaınes, l’operateur is compare les adresses en memoire de deux chaınes. Il faut donc utiliserla bonne methode.

1 >>> s1 = "une chaıne"2 >>> s2 = "une chaıne"

2.7. TRANSFORMER UNE CHAINE EN NOMBRE ET VICE-VERSA 29

3 >>> s3 = "Une chaıne"4 >>> s4 = s1 # on pointe s4 vers la meme case-memoire que s156 >>> s2 == s1 # Retourne 1 - vrai, meme suite de caracteres7 >>> s2 is s1 # Retourne 0 - faux, deux adresses differentes8 >>> s4 is s1 # Retourne 1 - vrai, s4 et s1 pointent vers la meme adresse9

10 >>> ’c’ in s3 # Vrai, s3 contient la lettre ’c’11 >>> ’z’ not in s4 # Vrai aussi, z n’est pas dans s41213 >>> s3 == s1 # faux - le U majus. differe du u minuscule14 >>> s3.lower() == s1 # vrai, toutes les lettres sont minuscules15 >>> s3 == s1.capitalize() # vrai, la premiere lettre de s1 est maintenant16 # transformee en majuscule17 >>> s3.upper() == s2.upper() # vrai aussi, tout est en majuscules

2.7.4 Scinder les chaınes : la commande split

Les operations sur les chaınes de caracteres permettent de lire des donnees avec unmaximum de flexibilite, par comparaison avec ce que l’on peut faire en C ou Fortran.

La methode split permet de scinder les chaınes de caracteres en plusieurs mots ou uniteslexicales. Une unite lexicale est une sequence de caracteres separes par un delimiteur.

Ainsi, si on utilise le caractere “espace” comme delimiteur, la chaıne "Ceci est unechaıne" peut etre separee en mots "Ceci" "est" "une" "chaıne". Si on choisit la lettre ncomme delimiteur, on aura plutot les mots "Ceci est u" "e chaı" "e".

La methode split est une propriete de toute chaıne de caractere. Elle possede l’appelsuivant :

chaıne.split() # Separe la chaıne en utilisant les espaceschaıne.split("delim") # Utilise le delimiteur donnechaıne.split("delim",maxmots) # Genere un nombre maxmots+1 de mots

On obtiendra alors

1 >>> s = "ceci est un mouton"2 >>> s.split()3 [’ceci’, ’est’, ’un’, ’mouton’]4 >>> s.split(’e’)5 [’c’, ’ci ’, ’st un mouton’]6 >>> s.split(’est’)7 [’ceci ’, ’ un mouton’]8 >>> s.split(’ ’,1)9 [’ceci’, ’est un mouton’]

Par defaut, le split utilise l’espace comme delimiteur. Si on veut plus d’un delimiteur, ilfaut repasser chaque mot dans un deuxieme split.

Les delimiteurs peuvent etre n’importe caractere ; des points-virgules, par exemple :


1 >>> s = ’ceci;est;un;mouton’2 >>> s.split()3 [’ceci;est;un;mouton’]4 >>> mots = s.split(’;’)5 >>> print mots6 [’ceci’, ’est’, ’un’, ’mouton’]

Maintenant que nous avons separe la chaıne en mots, il nous faut y acceder. C’est facilecar la sortie de split est une liste de chaınes de caracteres. En utilisant mots = s.split()

len(mots) indique le nombre de mots generesmots[2] troisieme motfloat(mots[4]) transforme le 5e mot en reel.

En combinant avec l’exemple ci-dessus, nous avons :

1 chaine = "Exemple de chaıne de caracteres"2 mots = chaine.split()3 print len(mots)4 for ch in mots :5 print " ’", ch, "’ est le mot actuel"

2.8 Entree et sortie standards

L’entree et la sortie sont tres faciles en python. Nous avons deja vu plusieurs facons delire du clavier et d’ecrire a l’ecran. Nous allons reviser ces methodes en plus de discuter del’acces aux fichiers.

2.8.1 Sortie standard

La sortie standard est a l’ecran. La methode a utiliser est la methode print. Cettemethode accepte une chaıne de caracteres ou un melange de chaınes et de nombres, chaqueterme etant separe par une virgule. Dans ce dernier cas, un espace est ajoute entre chaqueterme :

1 >>> print "ceci", 3.14, "represente pi"2 ceci 3.14 represente pi3 >>> x = 14.56674 >>> y = 345.66785 >>> print x, y6 14.5667 345.6678

Lorsqu’on ajoute une virgule a la fin de la ligne, la commande print ne change pas deligne. La prochaine commande print continuera donc sur la meme ligne. (Essayez ce quisuit en mettant ces lignes dans un fichier et en executant celui-ci.)

1 print "ceci",2 print 3.14,3 print "represente"4 print

2.9. OPERATEURS LOGIQUES ET RELATIONNELS 31

Finalement, il est egalement possible de formatter la sortie en utilisant les commandesdecrites plus haut :

1 >>> pi = 3.14159265358979312 >>> euler = 2.71828182845904513 >>> print "Pi : %8.5f et nombre naturel : %5.3" % (pi, euler)4 Pi : 3.14159 et nombre naturel : 2.718

2.8.2 Entree standard

La lecture du clavier (entree standard) est aussi simple que l’ecriture a l’ecran.Toutefois, il faut savoir que python lit du clavier ligne par ligne. Il attend donc toujours

un retour de chariot ou un caractere de fin de fichier avant d’analyser le texte tape. Il y adeux commandes afin de lire du clavier. Si on sait que l’entree sera un chiffre (entier, long,reel ou complexe), on peut utiliser la commande input(). Si il peut y avoir du texte, on doitalors utiliser alors la commande raw input.

1 >>> a = input("Veuillez entrer un chiffre : ")2 Veuillez entrer un chiffre : 45.63 >>> print a4 45.65 >>> b = raw_input("Entrez une phrase :\n")6 Entrez une phrase : # Notez le retour de chariot (\n)7 Ceci est une phrase8 >>> print b9 Ceci est une phrase

Notez qu’il est egalement possible de lire une serie d’entrees avec la commande input(),en definissant une liste de variable a gauche :

1 >>> a,b = input ("entrez 2 chiffres :")2 entrez 2 chiffres :34.5, 17 #On doit absolument mettre les chiffres3 >>> print a, b # separes par une virgule sur la meme ligne4 34.5 17

2.9 Operateurs logiques et relationnels

L’utilisation des operateurs booleens convient a la plupart des comparaisons. Tout commeen C et C++, toutefois, on utilise les chiffres binaires 0 et 1 pour signifier faux et vrai, res-pectivement. Toute expression centree autour d’un operateur relationnel est de type booleen.

En fait, la situation est un peu plus compliquee. Seulement les valeurs suivantes sontconsiderees fausses :

NoneFalsezero sous toutes ses formes (0, 0, 0.0, 0.0 + 0.0j)

Toutes les autres valeurs sont considerees comme etant vraies.


Tab. 2.7 – Operateurs relationnels. (On prend x = 2, y = 4.)

Operateur Expression Signification Valeur== x == y Egal 0 (faux)! = x! = y Non egal 1 (vrai)> x > y Plus grand que 0< x < y Plus petit que 1

>= x >= y Plus grand ou egal a 0<= x <= y Plus petit ou egal a 1is x is y est le meme objet 0

is not x is not y n’est pas le meme objet 1

Tab. 2.8 – Operateurs logiques

a and b ET logique booleen si a est faux, retourne a, sinon ba or b OU logique booleen si a est faux, retourne b, sinon anot a NON logique si a est faux, retourne 1, sinon 0

2.9.1 Operateurs relationnels

Attention : Il ne faut pas confondre l’operateur relationnel “==” avec l’operateur d’affectation“=”. C’est une erreur tres commune qui peut causer une perte de temps considerable durantla mise au point.

Veuillez noter egalement que, tout comme pour l’assignation, on convertit le type d’unedes deux variables en suivant les regles de promotion decrites ci-dessus avant de faire unecomparaison.

Ainsi, avant de comparer une variable de type double a une de type int, python convertitla variable de type int a double, il est donc possible d’avoir des erreurs de conversion. Parexemple, 2.0/3 n’est pas egal a 0.6667.

De meme, dans une comparaison entre un char et un int, python convertit d’abordl’entier en caractere, ce qui peut parfois causer des resultats inattendus !

2.9.2 Operateurs logiques

Lorsque nous avons des expression booleennes, il est utile de les comparer a l’aided’operateurs logiques.

Python definit 3 operateurs logiques : Tous ces operateurs sauf le NON logique (not) sontbinaires.

Exemple :

(8 < 9) and (2 < 1) -> vrai et faux -> faux(8 < 9) or (2 < 1) -> vrai ou faux -> vrainot (2<1) -> non(faux) -> vrai

2.10. STRUCTURES DE SELECTION 33

Tab. 2.9 – Hierarchie des operateurs arithmetiques, relationnels et logiques. Plus unoperateur est haut dans la liste, plus sa priorite est forte.

Operateurs Ordre d’application Type( ) de gauche a droite parentheses+ - de gauche a droite singulier/ % de gauche a droite multiplicatif

+ − de gauche a droite additif< <= > >= de gauche a droite relationnel== != de gauche a droite egaliteand de gauche a droite ET logique booleenor de gauche a droite OU logique booleen exclusifnot NON logique= += -= *= /= %= de droite a gauche affectation

2.10 Structures de selection

Une structure de selection permet de decider ce que le programme doit faire en fonctionde la valeur de certaines variables. Python utilise la structure if/else/elif.

2.10.1 La structure si/sinon (if/else/elif)

Cette structure n’est executee que si et seulement si une expression booleenne est vraie.Tout comme C/C++, python assigne au chiffre zero (0, sous toutes ses formes) la valeurlogique faux et a tous les autres chiffres, la valeur logique vrai.

En general, on definit un expression logique et on applique les instructions approprieesselon que cette expression soit vraie ou fausse. Dans le cas de python, il n’est pas necessaired’entourer les expressions logiques de parentheses. Malgre tout, leur utilisation simplifieconsiderablement la lecture des programmes et elle est fortement recommendee.

if( a > b ) : # les deux points indique le debut d’une structureinstructions

on revient a colonne initiale a la fin de la structure if.

if a > b : # les parentheses ne sont pas necessairesinstructions

Dans les cas ou l’on a besoin d’une alternative (si ceci alors a et si cela alors b), onpeut utiliser la structure complete du si/sinon :

if ( a > b ) :instructions

elif ( a < b ) :instructions

else :


instructions

Il est egalement possible d’imbriquer ces structures les unes dans les autres (notez quel’utilisation des decalages visuels est requise par python afin d’obtenir le bon fonctionnementdu programme) :

if ( a >b && c < d) : #if( c*a ==b * d) :

instructionselse

instructionselse # On continue la structure du premier if

instructions

Exemple :

1 """2 Ce programme lit un nombre entre au clavier. Il imprime un commentaire3 indiquant si ce nombre est plus petit, plus grand ou equal a 10.4 """56 print "Veuillez entrer un nombre : "7 nombre = input()89 if nombre < 10 :

10 print "Ce nombre est plus petit que 10"11 elif nombre > 10 :12 print"Ce nombre est plus grand que 10"13 else :14 print "Ce nombre est egal a 10"

2.11 Boucles

On a souvent besoin de repeter une serie d’instructions plusieurs fois. Plutot que dereecrire cette serie d’instructions en file, on peut utiliser les boucles. Python possede deuxtypes de structures en boucles.

2.11.1 La boucle for

La boucle for est une boucle qui repete une serie d’instructions un nombre predeterminede fois, defini par la longueur d’une liste donnee. Souvent, on genere une liste sur le champ,a l’aide de la commande range() :

for i in range(5) : # range(5) == {0,1,2,3,4}instructions

ou encore, dans d’autres cas, on passe chaque element a la suite de l’autre

2.11. BOUCLES 35

>>> taille = [’long’, ’moyen’, ’court’]>>> for i in taille :... print "la taille est : ", i...la taille est : longla taille est : moyenla taille est : court

On peut donc executer la boucle sur n’importe quelle sequence, pas seulement une sequenced’entiers, comme en C ou Fortran.

1 """2 Test de la boucle for34 (on se rappelle que les variables dans range() doivent etre entieres)5 """6 from math import * # On importe les fonctions mathematiques78 # Une boucle standard, avec une somme de 0 a 99

10 for i in range(10) :11 x = sin( i * pi/10)12 print i, x1314 for i in range(2, 10, 3) : # de 2 a 10 (non inclus) par saut de 315 print i1617 # Et on le fait pour une liste18 y = [0.5, 3.4, 15.4, -32.9, 41.0]19 for i in y :20 print i, sin(i)

2.11.2 La boucle while

Considerons maintenant la boucle while. Celle-ci est plus simple que la boucle for bienque moins utilisee en programmation scientifique et ne demande qu’un seul test booleen. Sile resultat est vrai, on execute les instructions dans la boucle, sinon, on saute par-dessus laboucle et on continue l’execution du programme.

1 while ( x > 2) :2 x = 3*3*x % 43 print " x = ", x

Parce qu’il n’y a pas de nombre maximal d’executions, cette boucle peut se repeter al’infini si on n’a pas choisi correctement la condition d’execution. Il faut donc etre prudentlorsqu’on utilise cette boucle et s’assurer que l’on n’y restera pas piege.

La boucle while effectue un test avant d’aller voir les instructions dans la boucle. Danscertains cas, on veut etre certain d’executer ces instructions au moins une fois. On utilise


alors une boucle infinie (while 1 est toujours vrai) avec une commande if a la fin de laserie d’instructions. Si l’expression est fausse, alors on sort de la boucle grace a la commandebreak.

while 1 :instruction...if not (expression booleenne) :break

ou la commande break permet de sortir de toute structure. Dans ce cas-ci, le break permetde sortir de la structure while.

2.12 Lecture et ecriture de fichiers

Nous avons deja vu comment lire a l’entree et ecrire a la sortie standards. Nous allonsmaintenant discuter de la lecture et ecriture de fichiers. Ce sujet est normalement presqueignore des manuels de programmation en python, mais il est indispensable a la programma-tion scientifique.

2.12.1 Redirection des entree et sortie standards

La facon la plus simple d’acceder a un fichier en mode lecture ou ecriture est d’utiliserla redirection des entree et sortie standards . Ces commandes sont standards en Unix. Lesymbole < (plus petit que) sert a rediriger l’entree tandis que > (plus grand que) sert pourla sortie. Pour rediriger l’entree standard d’un programme appele redirection.py vers lefichier entree.dat et la sortie vers sortie.dat, on ecrit :

python redirection.py < entree.dat > sortie.dat

Ainsi, si un programme lit les donnees d’entree directement du clavier, on peut mettre toutesles reponses aux questions dans un fichier appele reponses.dat (une reponse par ligne) etrediriger l’entree standard vers ce fichier :

python ProgrammeQuestions.py < reponses.dat

Vous n’aurez donc pas a repondre aux questions chaque fois que vous roulez le programme ;ce truc est particulierement utilise lors de la mise au point d’un programme interactif.

De meme, si l’on veut sauver dans un fichier ce qui defile a l’ecran, on peut simplementrediriger la sortie vers un fichier :

python ProgrammeQuestions.py > resultats.dat

Dans ce cas-ci, aucune question ou commentaire n’apparaıtra a l’ecran. Si le programmeest interactif, il faudra peut-etre combiner la redirection de l’entree et de la sortie :

python ProgrammeQuestions.py < reponses.dat > resultats.dat

2.12. LECTURE ET ECRITURE DE FICHIERS 37

Tab. 2.10 – Les methodes des objets fichiersMethode Explicationf.read() Retourne la totalite du fichier dans une seule chaınef.readline() Retourne une ligne du fichier, incluant le caractere de fin de lignef.readlines() Retourne une liste contenant les lignes du fichier chacune

dans une chaıne separee. Equivalent a appeler readline() plu-sieurs fois.

f.read(n) Retourne au plus les n caracteres suivantsf.write(chaıne) Ecrit une chaıne de caracteres dans le fichier. Notez que write

n’ajoute pas de caractere de fin de ligne, il faut le mettre soi-meme.

f.writelines(liste) Ecrit toutes les chaınes de caracteres contenues dans la liste au fichier f.

Essayez ces commandes avec le programme suivant :

"""Programme test des redirections

"""

# On lit du clavierchaine = raw_input("Entrez quelques mots : ")print "Merci bien, voici ce que vous avez tape: ", chaine

Parce que la redirection ne permet qu’une seule entree et sortie, on ne peut pas l’utiliserpour les programmes scientifiques complexes qui generent souvent des dizaines de fichiers dedonnees.

2.12.2 Ecriture dans un fichier

En general, plutot que d’utiliser les redirections, il est beaucoup plus facile d’ecrire direc-tement dans un fichier. Avant d’ecrire dans un fichier ou de lire son contenu, on doit d’abordl’ouvrir (open) et dire si on veut le lire ou y ecrire. On opere ensuite sur le fichier puis,lorsque tout est termine, on le ferme (close).

1 ...2 # On ouvre d’abord un fichier dans lequel on veut ecrire (write)3 nouvFichier = open("fichier.dat","w") # w indique "write"45 # On ecrit ensuite dans le fichier - notez le "\n" qui indique un6 # retour de chariot - write ne l’ajoute pas automatiquement7 # contrairement a la commande print8 nouvFichier.write("Ceci est un test\n")9

10 # On peut aussi ecrire plusieurs lignes a la fois11 liste = [’Premiere ligne de texte\n’, # Notez l’utilisation des12 "Deuxieme ligne de texte\n"] # guillemets ou de l’apostrophe13


14 nouvFichier.writelines(liste)1516 # Finalement, on ferme le fichier17 nouvFichier.close()

2.12.3 Lecture a partir d’un fichier

De la meme facon, on peut lire un fichier a l’aide des instructions suivantes :

1 ...2 # On ouvre d’abord le fichier3 ancFichier = open("fichier.dat","r") # r indique "read"45 # On lit ensuite la premiere ligne. Notez que le "\n" qui indique6 # la fin de ligne est egalement lu ; il faudra l’enlever7 ligne = ancFichier.readline()89 # On enleve les espaces en debut et fin de ligne aini que

10 # les retours de chariot11 ligne = ligne.strip()1213 # Et on ferme le fichier14 ancFichier.close()

2.12.4 Lecture d’un fichier quelconque

On ne connaıt pas toujours le nombre de lignes contenues dans un fichier que l’on veutlire. Si, par exemple, on lit un fichier de donnees afin de tracer le tout, a priori, on ne saitpas combien de points ce fichier comprend. On peut utiliser la commande readlines afin delaisser python gerer ce probleme.

La structure presentee ci-dessous est tres utile pour un grand nombre de problemes.Assurez-vous de bien comprendre ce qu’elle fait !

1 # On ouvre d’abord un fichier2 fichier = open(’donnees.dat’,’r’)34 # Et puis, on initialise deux listes, x et y5 x = []6 y = []78 # Enfin, on passe sur chaque ligne a l’aide de la commande for9 for ligne in fichier.readlines() :

1011 # Puis, on scinde la ligne en mots - la commande split enleve les12 # espace et les retours de chariot13 donnees = ligne.split()14

2.12. LECTURE ET ECRITURE DE FICHIERS 39

15 # Puis on ajoute ce point a la fin du tableau16 x.append( float(donnees[0]) )17 y.append( int(donnees[1]) )1819 # Fin de la boucle, on peut fermer le fichier20 fichier.close()

On a maintenant deux tableaux, x et y, qui sont prets a etre utilises.

2.12.5 Lecture et ecriture de caracteres accentues

Comme je l’ai mentionne dans la Section 2.6.1, il faut parfois faire attention avec leschaınes de caracteres accentues, surtout si on passe d’une machine a l’autre.

Une facon de faire est d’utiliser la bibliotheque codecs, qui gere les encodages multiples.Les commandes sont simples, similaires a celles qu’on a vu plus haut.

Supposons que le fichier fichier.dat contienne la ligne

chaıne de caractere

sauvegardee en format utf-8.Pour lire ce fichier, on utilisera alors :

>>> import codecs # Importe la bibliotheque

>>> # Si on veut lire un fichier sauvegarde en encodage utf-8>>> f = codecs.open("fichier.dat", ’r’, ’utf-8’)

>>> lignes = f.readlines() # Lit les lignes comme d’habitude>>> f.close() # Ferme le fichier

>>> print lignes[0] # ou lignes[0].encode(code)chaıne de caracteres

Puisque idle sait comment afficher une ligne definie en format unicode, on n’est generalementpas oblige d’encoder a l’impression.

Pour ecrire dans un fichier, il faut d’abord preparer les chaınes, puis les sauvergarder dansle format voulu. Si l’encodage par defaut du programme est ’utf-8’, ces etapes supplementairesne devraient pas etre necessaires. Elles le seront sur une machine windows, toutefois.

>>> import codecs

# La variable code est supposee definie tel que ci-haut>>> x = unicode(’Chaıne de caracteres\n",code)

# Definit le type d’encodage du fichier>>> f = codecs.open(’fichier.dat’,’w’,’utf-8’)>>> f.write(x)>>> f.close()


2.13 Listes, tuples, dictionnaires et tableaux

A l’exception des chaınes de caracteres, tous les types que nous avons vus jusqu’a presentsont des types primaires – float, int, etc. – et les donnees sont gerees par leur valeur : c’estla valeur de la variable qui est passee en argument. Mais il est possible de creer des typesde donnees plus compliques en assemblant ces types primitifs. Ces assemblages se nommentdonnees par reference, i.e. que ces types sont geres par reference a leur position dans lamemoire de l’ordinateur plutot que par leur valeur.

Ceux qui sont familiers avec C/C++ penseront immediatement au concept de pointeurs :dans ces deux langages de programmation, les tableaux et autres objets sont manipulescomme pointeurs alors que les entiers et les nombres reels referent directement a leur valeur.En Fortran, par contre, tous les types de donnees sont des donnees par reference.

En python, on en peut pas parler de pointeur : python ne permet pas l’acces direct ala memoire a cause des problemes de securite qui pourraient se poser. On parle donc ici dereference et non de pointeur.

Le code de base de python definit trois structures de donnees de reference : les listes,les tuples et les dictionnaires. Comme ces structures ne sont pas toujours appropriees pourles besoins scientifiques, il est possible de charger une bibliotheque d’objets qui permet dedefinit des tableaux et des vecteurs.

Dans cette section, nous allons voir les structures de donnees definies par python. Nousverrons les tableaux et vecteurs dans le chapitre 5.

2.13.1 Les listes

En python, les listes forment une collection d’objets possiblement heteroclites organisessequentiellement, ce qui veut dire qu’on accede a un element en indiquant la distance dupremier element de la liste. Contrairement a C ou a Fortran, les listes peuvent contenir zeroelement et se forment par l’ajout d’un element (ou d’une liste) a la fois. Les listes sont doncdes objets tres flexibles qui permettent une gestion fine d’elements.

Operations de base

On peut creer une liste directement ou lui ajouter les elements un a un. Une fois la listecreee, on peut facilement lui ajouter des elements ou la dupliquer.

1 >>> li = [0, 2, ’mots’, 3.0 + 4j] # On cree une liste2 >>> len(li) # Sa longueur est de 4 elements3 445 >>> li + [4,5] # On peut ajouter des elements avec +6 [0, 2, ’mots’, (3+4j), 4, 5]78 >>> li.append(’un element’) # Ou, plus efficacement avec append9 >>> li

10 [0, 2, ’mots’, (3+4j), ’un element’]1112 >>> 2 * li # le * recopie la meme liste bout a bout

2.13. LISTES, TUPLES, DICTIONNAIRES ET TABLEAUX 41

Tab. 2.11 – Liste des operations possibles sur les listes.Operation Descriptionli = [] Cree une liste videli = [0, 1, 2, 3] Cree une liste de 4 elementsli = [16, ’mot’,[’3’,’ab’]] Cree une liste d’elements mixtesli[i] Retourne le ie element de la liste apres le 1er elementli[i][j] Retourne une element d’une liste multidimensionelleli[i:j] Retourne la tranche d’elements jusqu’au je elementlen(li) Retourne le nombre d’elements de la listeli + la Concatenation de deux listes3 *li Concatenation multiple de la meme listefor e in li Iteration sur tous les elements de la liste16 in li Operation logique retourne 1 si 16 est un element de la listeli.append(’mot’) ajoute l’element ’mot’ a la fin de la listeli.insert(i,’mot’) ajoute l’element ’mot’ a la position i

del li[j] Elimine l’element j de la listeli[i:j]=[] Elimine la tranche i :j de la listeli.sort() Ordonne les elements en ordre ascendantli.index(’ab’) Retourne la position du premier element de valeur ’ab’li.reverse() Reorganise les elements en commencant par la finli[i]=’ceci’ Assigne une valeur a l’element ili[i:j]=[2,3,7] Assigne une valeur a la tranche i :jrange(3) Cree une liste de trois elements [0,1,2]


13 [0, 2, ’mots’, (3+4j), ’un element’, 0, 2, ’mots’, (3+4j), ’un element’]1415 >>> a = [17, 3, 2, ’autre’]16 >>> for el in a : print el,a # tandis que for echantillone tous les17 ... # elements un a un18 17 3 2 autre

Comme on le mentionne dans les commentaires, append est la maniere la plus efficaced’ajouter des elements a une liste. La concatenation implique que la liste est recopiee enmemoire avant que les nouveaux elements soient ajoutes tandis que pour append, les elementssont ajoutes sur place (ce qui explique qu’on doive utiliser la commande print pour afficherla liste modifiee par append).

Operations sur quelques elements de la liste

On peut aussi appliquer des operations sur quelques elements de la liste a la fois. Notezque ces operations sont similaires a celles qu’on a vues pour les chaınes de caracteres.

1 # N’oubliez pas que les indices de cette liste vont de 0 a 42 >>> li = [3.1, 87.12, 2.3, 41, 9.65]3 >>> li[3] # On imprime le 3e element apres le 1er4 415 >>> li[-2] # Ou le deuxieme a partir de la fin6 417 >>> li[2:] # Tous les elements du 3e a la fin8 [2.2999999999999998, 41, 9.6500000000000004]

Ces memes operations sont valides pour des listes multidimensionnelles.

1 >>> la = [[3,2],[3,4,5],[3,6],[8,7,9,0]] # Une liste mixte2 >>> len(la) # Contient 4 elements3 44 >>> len(la[1]) # Le deuxieme element est une liste de 3 elements5 36 >>> la[-1][2:] # Une tranche des elements de la liste de l’avant-dernier7 [9, 0] # element

Assigner et effacer des elements d’une liste

Il est possible de modifier seulement quelques elements d’une liste ou de le faire toutd’un coup. Il faut surtout se rappeler que la position d’un element est toujours calculeepar rapport a la position du premier element dans la liste ; il s’agit donc d’une position dedecalage. Le premier element aura donc comme indice 0 (zero) et le ne eleement, l’indicen− 1.

1 >>> li = [3, 5, 8, 32, 85, 22, 90] # On cree une liste de 7 elements23 >>> li[1] = ’mot’ # Remplace 2e element par ’mot’4 >>> li

2.13. LISTES, TUPLES, DICTIONNAIRES ET TABLEAUX 43

5 [3, ’mot’, 8, 32, 85, 22, 90]67 >>> li[1:4] = [56, ’a’, ’b’, ’c’] # Remplace elements 1 a 3 par une liste8 >>> len(li) # de 4 elements. La liste a maintenant9 8 # 8 elements.

10 >>> li11 [3, 56, ’a’, ’b’, ’c’, 85, 22, 90]1213 >>> li[-3:] = ’fin’ # ’fin’ est ici considere comme une14 >>> li # liste (chaıne) de caracteres15 [3, 56, ’a’, ’b’, ’c’, ’f’, ’i’, ’n’]1617 >>> li[-3:] = [’fin’] # Avec les crochets, il s’agit s’un seul mot18 >>> li # On remplace donc les 3 elements de la fin19 [3, 56, ’a’, ’b’, ’c’, ’fin’] # par un seul mot.2021 >>> del li[2] # On efface le 3e element de la liste22 >>> li23 [3, 56, ’b’, ’c’, ’fin’]2425 >>> li[2:4] = [] # Puis les elements 2 et 326 >>> li27 [3, 56, ’fin’] # Il ne reste que 3 elements.

Autres operations

Les autres operations permettent des manipulations complexes pour lesquelles il fautsouvent ecrire des methodes dans d’autres langages de programmation. Ces operations sefont sur place ce qui augmente considerablement leur efficacite.

1 >>> li = [3, 5, 8, 32, 85, 22, 90]23 >>> li.sort() # Ordonne la liste dans un ordre ascendant4 >>> li5 [3, 5, 8, 22, 32, 85, 90]67 >>> li.reverse() # Intervertit la position des elements8 >>> print li9 [90, 85, 32, 22, 8, 5, 3]

10 >>> li.index(32) # Indique la position du premier element de valeur 3211 2

Comparison et attribution

La comparaison et l’attribution de donnees de type referentiel compare et attribue lesreferences elles-memes et non les donnees de type primaire qui les composent. Les commandes


de comparaison et d’attribution vues pour les chaınes de caracteres s’appliquent donc aussiaux listes.

1 >>> li = [90, 85, 32, 22, 8, 5, 32]2 >>> la = [90, 85, 32, 22, 8, 5, 32]3 >>> lc = la # lc et la occupent la meme place en memoire4 >>> li == la # les elements de li et la sont identiques5 True6 >>> li is la # mais les deux listes occupent chacune leur7 False # espace memoire89 >>> la is lc # on confirme que lc et la pointent a la meme place

10 True11 >>> la[3] = ’test’ # Ce qui fait que si on modifie la, on modifie12 >>> la # automatiquement lc13 [90, 85, 32, ’test’, 8, 5, 32]14 >>> lc15 [90, 85, 32, ’test’, 8, 5, 32]

Note : Les donnees de type referentiels, tels les tableaux, utilisent ”is” pour la comparai-son des references et non pour la valeur des donnees de type primaires qu’elles contiennent.Pour comparer la valeur des elements, on doit utiliser ”==”.

2.13.2 Dictionnaires

Les dictionnaires representent une structure de donnees extremement flexible. Alors queles listes places les donnees dans un ordre predefini, les dictionnaires sont des ensembles sansordre defini. Ils simplifient la vie lorsqu’on veut construire des collections d’objets relies entreeux.

Les dictionnaires partagent plusieurs des proprietes des listes. Ils different de celles-ci parla methode d’accession aux elements. Ainsi, alors qu’on accede aux elements d’un liste parson indice, chaque element d’un dictionnaire est associe a une clef. Ainsi, on pourra vouloiridentifier l’objet «Antoine de St-Exupery» par la clef «auteur», et «Le petit prince» par laclef «titre».

1 >>> dico = {} # On utilise les accolades plutot que les2 # crochets pour les dictionnaires3 >>> dico[’auteur’] = "Antoine de St-Exupery"4 >>> dico[’titre’] = "Le petit prince"5 >>> dico[’pages’] = 132 # les elements sont aussi mixes6 >>> len(dico) # dico contient 3 elements7 38 >>> dico[’titre’] # l’element ’titre’ correspond a9 ’Le petit prince’ # ’Le petit prince’

Avec une telle structure, il est impossible d’ordonner les elements d’un dictionnaire. Afinde retrouver les elements, on doit donc egalement pouvoir acceder a la liste des clefs et deselements.

2.14. QUITTER LE PROGRAMME 45

10 >>> dico.keys() # Liste des clefs de dico11 [’titre’, ’auteur’, ’pages’]1213 >>> dico.has_key(’pages’) # Retourne vrai si la clef existe14 True15 >>> dico.has_key(132) # ou faux, sinon.16 False1718 >>> dico.values() # Liste des elements19 [’Le petit prince’, ’Antoine de St-Exupery’, 132]2021 >>> dico # Liste des paires clef:element22 {’titre’: ’Le petit prince’, ’auteur’: ’Antoine de St-Exupery’, ’pages’: 132}

On peut egalement changer les elements du dictionnaire.

1 >>> physiciens = {’Newton’:’Gravitation’, ’Einstein’:’Relativite’, ’,2 ’Anderson’:’Localisation’}34 >>> decouvreur = ’Newton’5 >>> physiciens[decouvreur]6 ’Gravitation’78 >>> for decouv in physiciens : print decouv, " \t", physiciens[decouv]9 ...

10 Maxwell Electromagnetisme11 Anderson Localisation12 Newton Gravitation13 Einstein Relativite1415 >>> physiciens[’Galilee’] = "Mecanique" # Ajout d’un element16 >>> physiciens17 {’Maxwell’: ’Electromagnetisme’, ’Anderson’: ’Localisation’,18 ’Newton’: ’Optique’, ’Galilee’: ’Mecanique’, ’Einstein’: ’Relativite’}1920 >>> del physiciens["Maxwell"] # Deletion d’un element2122 >>> physiciens[’Newton’] = ["Optique","Gravitation"] # Modification23 >>> physiciens24 {’Anderson’: ’Localisation’, ’Newton’: [’Optique’, ’Gravitation’],25 ’Galilee’: ’Mecanique’, ’Einstein’: ’Relativite’}

2.14 Quitter le programme

Il est souvent necessaire de quitter le programme proprement avant la fin de l’executionlineaire. Durant la mise au point, par exemple, ou lorsqu’une erreur survient.


Tab. 2.12 – Liste des operations possibles sur les dictionnaires.Operation Descriptiondi = {} Cree dictionnaire videdi = {2:’deux’,’titre’:’Python’} Cree un dictionnaire de 3 elementsdi = {2:{’deux’="two",’trois’=3}} Cree un dictionnaire imbriquedi[’titre’] Retourne l’element correspondant a la cleflen(di) Retourne le nombre d’elements du dictionnairedi.keys() Retourne la liste des clefsdi.values() Retourne la liste des valeursdi.has_key(’clef’) Test l’existence d’une clefdi[’nouveau’]=’ceci’ Assigne une valeur a la clef ’nouveau’del di[’nouveau’] Efface l’element correspondant a la clef

La commande pour ce faire est sys.exit(int n) ou n est un entier quelconque quipermet d’indiquer ou le programme s’est interrompu. Cette commande est definie dans labibliotheque sys qu’il faut donc importer. Par exemple :

1 import sys # On doit importer la bibliotheque systeme (sys)23 # Nous comptons ici le nombre d’arguments passes au programme dans le4 # tableau argv. Si le nombre d’arguments est different de ce qui est5 # requis, on ecrit un message d’erreur et on arrete le programme.6 ...78 if len(sys.argv) != 2 : # Pas le bon nombre d’arguments9 print "Pour lancer le programme utilisez : "

10 print "python programme fichier1 fichier2"11 sys.exit(37) # Quitte le programme proprement12 ...

Chapitre 3

Structure d’un programme enpython

3.1 Methodes, variables et constantes de classe

La structure de base la plus simple d’un programme en python est formee d’une seuleclasse contenant des definitions et methodes. Ce programme sera place dans un seul fichieret appele avec la commande python fichier.py.

import <bibliotheques de classes>

# Les methodes doivent etre definies AVANT la methode principale<definitions d’une methode>

# les commandes, definitions et operations d’une methode# doivent etre indentees par rapport au corp du programme<definitions des constantes, operations>

<autre methode>

# Debut de la methode principale, pas besoin de nom<definitions des constantes et variables de la classe>

<structures de decision ou boucle><definition et commandes de la structure (indentee)>

# fin du programme - aucune commande particuliere

Chaque programme, peu importe son degre de complexite, doit contenir une methode prin-cipale, dont les commandes commencent dans la premiere colonne. Ces lignes sont executeesautomatiquement lorsque le programme est lance. Elles constituent donc la porte d’entreedu programme.

47

48 CHAPITRE 3. STRUCTURE D’UN PROGRAMME EN PYTHON

3.1.1 Bibliotheques de classes

Les bibliotheques de classes donnent acces a toute une serie de methodes etendant lescommandes de python. Ainsi, on peut importer la bibliotheque d’evenements graphiquesGnuplot ou la bibliotheque mathematique Numeric. On a le choix d’importer la classe, sansdefinir immediatement tous les objets. Dans ce cas, on doit obligatoirement faire referenceaux objets faisant partie de cette classe par leur nom complet, i.e., le nom de la classe-point-lenom de la methode.

import pylabpylab.plot([1,2,3,4])pylab.xlabel("Axe des ’x’")pylab.show()

Il est egalement d’importer toutes les methodes directement. Dans ce cas, on n’a plusbesoin d’utiliser le nom complet de la methode, celle-ci etant consideree comme autonome,faisant partie du programme.

from pylab import *plot([1,2,3,4])xlabel("Axe des ’x’")show()

Il faut utiliser cette option avec precaution, car si deux methodes appartenant a deux classeschargees ont le meme nom, il y aura un conflit qui peut produire des resultats inattendus.

Finalement, il est egalement possible de charger une methode particuliere d’une classe,plutot que la classe dans son entier.

from Gnuplot import Dataimport Gnuplotg = Gnuplot.Gnuplot() # On n’a pas importe la methode Gnuplot()d = Data() # mais on l’a fait pour Data

La commande d’importation peut se trouver a n’importe quel point dans le fichier. Elledoit toutefois subvenir avant l’utilisation d’une des methodes de la classe.

3.1.2 Constantes et variables de la classe

Lorsqu’on a plusieurs methodes ou plusieurs classes, on veut parfois que les variablesdefinies quelque part soient accessibles de partout. Dans d’autres cas, on voudra protegerleur valeur afin d’eviter des conflits. On definit donc deux types de variables :

Les variables locales. Ces variables ne sont visibles que dans la methode ou elles sontdefinies. Ceci se produit lorsqu’on cree une variable de la maniere habituelle.

Les variables globales. A l’interieur d’une seule classe, non instanciee, on doit indiquer,par la commande global les variables que l’on veut globales. Ainsi, dans l’exempleci-dessous, la variable z dans la methode somme est globale, tandis que x est recreedans cette methode et vaut donc 0.

3.1. METHODES, VARIABLES ET CONSTANTES DE CLASSE 49

Toutefois, python est particulierement sagace. Si une variable dans une methode n’estpas definie, alors python suppose que celle-ci est globale meme si on ne l’a pas indiqueainsi.Exemples : Ici, x n’est pas modifie par la methode modifie x car la variable x n’estpas globale.

1 x = 42 def modifie_x():3 x = 54 modifie_x()5 # x vaut toujours 4

Par contre, si on identifie x comme etant une variable globale,

1 x = 42 def modifie_x()3 global x4 x = 55 modifie_x()6 # x a ete modifie et vaut maintenant 5

Ceci s’applique dans le cas de methodes ou de classes.

3.1.3 Methodes

Une methode contient les instructions actives d’une classe ; c’est la que l’action se passe.Une methode est similaire a la fonction ou la sous-routine en C et Fortran. Contrairement acelles-ci, toutefois, elle n’est pas reduite a ne retourner qu’une seule variable. Les methodesde python peuvent retourner n’importe quel objet. Il suffit de separer chaque objet par unevirgule. Ainsi

1 # Cette methode cree deux listes, initialisees a zero, de longueur n2 def cree_deux_listes(n) :3 x = []4 y = []5 for i in range(n) :6 x.append(0.0)7 y.append(0.0)89 return x, y

1011 # Methode principale de la classe12 n = 2313 x, y = cree_deux_listes(n)

3.1.4 Programme-type a une classe.

Notre programme-type, exemple de simplicite, ressemblera donc a quelque chose commesuit.


1 import math # Importe la bibliotheque de fonctions mathematiques23 # La methode identifie_x montre l’utilite d’une variable globale4 def identifie_x() :5 global x6 x = 4.07 y = 1.0 # puis y n’est pas globale, ceci ne change pas8 # la valeur de y dans le reste du programme9

10 # La methode rayon calcule le rayon d’un cercle centre a11 # zero a partir de la position d’un point sur le perimetre.12 # Puisque x est global, on n’a pas a le passer.13 def rayon(y) :14 return math.sqrt(x*x + y*y) # Puisqu’on import seulement math,15 # on doit utiliser le nom complet1617 # La methode aire calcule l’aire d’un cercle de rayon donne18 def aire(y) :19 a = math.pi * rayon(y) # On peut appeler une methode20 return a # a partir d’une autre methode2122 #############################################################################23 # Methode principale2425 y = 3.0 # Premiere ligne a etre executee par python26 identifie_x()2728 # L’utilisation d’une virgule a la fin du print permet de ne pas29 # changer de ligne.30 print "L’aire d’une cercle de rayon", rayon(y),31 print " est %f " % aire(y)

Position de la methode principale : Puisque python peut etre utilise en mode interactif,il est essentiel que les methodes soient definies avant d’etre utilisees. On placera donc toujoursla methode principale a la fin du fichier.

Il est egalement preferable de scinder un long code en une serie de methodes bien definies,ceci permet de mieux s’y retrouver.

Note : Tout comme pour C/C++, une nouvelle copie de la methode est creee chaque fois quela methode est appelee. Ceci veut dire que toutes les variables a l’interieur d’une methodesont reinitialisees a chaque appel. On doit donc utiliser des variables globales si l’on desireconserver la valeur de certaines variables.

3.1.5 Qualificatifs

Jusqu’a present, tous les programmes avec lesquels nous avons travaille ne contenaientqu’une seule classe, statique et publique. Les methodes n’ont pas necessairement besoin de

3.2. METHODES 51

ces qualificatifs.

Publique ou privee ?

Comme nous l’avons ecrit plus haut, une methode publique peut etre appelee par desmethodes situees dans d’autres classes que la sienne. En general, et pour eviter qu’il y aitconfusion dans un programme avec plusieurs milliers de methodes, on conserve le nombre demethodes publiques au strict minimum.

Malheureusement, on ne peut pas limiter l’acces a une methode avec python. On repro-duit cette fonction a l’aide de la convention suivante : une methode commencant par deuxsoulignes ( ) est toujours consideree comme privee.

3.2 Methodes

Des qu’un programme doit effectuer plus que quelques operations, il est utile de separerle programme en un certain nombre de parties plus ou moins independantes qui effectueronsquelques operations formant un tout logique. Ces sous-unites sont generalement associeessous la forme de methodes ; elles representent l’equivalent python des sous-routines et fonc-tions en Fortran et C/C++.

Toute methode doit etre membre d’une classe et peut etre appelee soit directement dela methode principale soit par d’autres methodes. Nous avons deja discute brievement desmethodes et de leur definition. Cette section nous permettra d’aller un peu plus en details.

Comparons les deux programmes suivants, qui accomplissent la meme tache :

Scenario 1 (utilisant seulement un appel a une methode) :

1 """2 Ce programme calcule la factorielle pour les entiers de 0 a 103 """45 # Methode qui calcule la factorielle d’un entier k6 def factorielle( k ) :7 fac = 18 if (k == 0 ) :9 # La commande return renvoie directement a la methode ayant appele

10 # la methode factorielle11 return fac # 0! = 1 par definition1213 else :14 for i in range(1, (k+1) ) :15 fac *= i1617 # fin de la methode avec la ligne qui vient - on retourne a la18 # methode ayant appele factorielle19 return fac20


21 ##########################################################################22 # Methode principale2324 for i in range(11) :25 print "La factorielle de ", i, " est ", factorielle(i)

Scenario 2 (utilisant une structure orientee objet dont nous parlerons a la fin de ce chapitre) :

1 """2 Programme qui retourne la factorielle pour les chiffres de 0 a 10.3 Dans ce cas-ci, on utilise une classe factorielle.4 """56 # Class factorielle : calcule la factorielle d’un entier donne7 class factorielle :89 # Methode qui calcule la factorielle - notez le "self" qui est une

10 # reference a l’instance particuliere de la classe11 def calcule(self, k ) :12 fac = 113 if(k==0) :14 fac = 1 # 0! = 1 par definition15 else :16 for i in range(1,(k+1) ):17 # on appelle une methode dans la meme classe18 fac = self.multiplie(fac,i)1920 return fac2122 # Cette methode a aussi le "self" qui n’est pas indique dans l’appel de23 # la fonction. Python ajoute cette variable automatiquement afin qu’on24 # puisse identifier a quelle classe appartient cette methode.25 def multiplie(self,a,b):26 return a * b2728 #############################################################29 # Methode principale de la classe principale3031 # On cree d’abord une instance de la classe "factorielle"32 facto = factorielle()3334 for i in range(11) :35 # On appelle la methode calcule de la classe facto. Notez qu’on n’a pas36 # besoin d’ajouter la variable self - celle-ci est ajoutee37 # automatiquement.38 print "La factorielle de ", i, " est ", facto.calcule(i)

Dans le deuxieme cas, donc, nous utilisons une instantiation ; la methode calcule est

3.2. METHODES 53

definie dans la classe factorielle, ce qui fait que l’on doit creer une copie de la classe (qu’onappelle ici facto) et faire reference a ce nom quand on appelle factorielle.

3.2.1 La methode principale

Tel que nous l’avons dit precedemment, la methode principale dans python consiste entoutes les variables et boucles lancees a partir de la premiere colonne, c’est-a-dire de toutesles commandes qui ne sont pas integrees dans une methode ou une classe. Il est donc possiblede meler methodes et classes a la classe principale. Ce n’est pas recommande, toutefois, carune telle structure devient rapidement illisible.

Arguments

Bien que la methode principale ne porte pas de nom, il est possible d’y passer des ar-guments. Dans ce cas, evidemment, les arguments seront definis lors de l’execution du pro-gramme :

% python exemple_arguments.py 1.0 deuxieme_argument

Pour saisir ces arguments, il faut utiliser la bibliotheque de commande systeme (sys). Ilsuffira alors de lire la liste des arguments de sys.argv.

1 """2 Programme exemple_arguments. Ce programme lit les arguments3 et indique leur nombre avant de les imprimer un a un.4 """5 import sys67 nombre_d_arguments = len(sys.argv)89 for i in range( len(sys.argv) ) :

10 print "argument ", i, " : ", sys.argv[i]

Ce qui donne, comme sortie :

% python exemple_arguments.py 1.0 deuxieme_argument "Un mot"argument 0 : exemple_arguments.pyargument 1 : 1.0argument 2 : deuxieme_argumentargument 3 : Un mot

Comme on peut voir, la liste des arguments (mots separes par un espace) commence par lenom du programme, i.e., le premier mot apres la commande python.

3.2.2 Utilisation d’arguments dans d’autres methodes

Les arguments passes a une methode ne peuvent etre changes. A tout le moins, leschangements ne seront pas visibles par le reste du programme ; quand une methode estappelee, elle cree une copie d’elle-meme ainsi que de ses arguments – tout argument modifiedans la methode laisse donc l’original inchange.


Comme on vient de le mentionner, l’argument passe a un methode est une copie del’originale et on ne peut le modifier. Bien qui ceci puisse parfois causer un probleme lorsqu’onon veut passer une variable simple, cette propriete est utile lorsqu’on passe un tableau ouun objet.

Dans le premier cas, c’est la reference au tableau qui est passee, i.e., son adresse enmemoire ; les elements de ce tableau ne sont pas copies ni bouges et peuvent donc etremodifies de facon globale par la methode.

Finalement, on peut passer tout type d’objet en argument. Un objet est generalementune classe (aussi indiquee par la reference a sa position en memoire). Pour plus d’informationon peut voir le chapitre 4.

Exemple :

1 """2 On demontre ici comment les variables peuvent etre modifiees dans une3 methode.45 x est une liste passee en argument6 y est une chaıne de caracteres locale passee en argument7 z est une chaıne de caracteres definie globalement89 puisque y est definie localement, elle ne peut etre modifiee globalement

10 a partir de la methode change_variables1112 x, la liste, ne peut etre reinstanciee et modifiee globalement a partir13 de la methode. Toutefois, ses elements peuvent etre modifies, comme on14 le voit.1516 Finalement, z est une variable globale et peut donc etre modifiee dans la17 methode change_variables.18 """19 # Parce que x est passe en argument, on considere qu’il s’agit d’une20 # variable locale a moins de definition.21 def change_variables(x,y):22 global z23 x[0] = "change!"24 y = "aussi change"25 z = "aussi change"26 print "Dans change_variables : "27 print "x est ", x28 print "y est ", y29 print "z est ", z3031 ####################################################################32 # Methode principale33 x = ["defini pour la premiere fois"]34 y = "aussi defini pour la premiere fois"

3.2. METHODES 55

35 z = "aussi defini pour la premiere fois"3637 change_variables(x,y)3839 print "Dans methode principale : "40 print "x est ", x41 print "y est ", y42 print "z est ", z

3.2.3 Methodes recursives

Tout comme C ou C++, mais contrairement a Fortran, une nouvelle version de la methodeest creee chaque fois qu’elle est appelee. Il est donc possible pour une methode de s’appelerelle-meme, creant une structure recursive.

L’utilisation de methodes recursives represente une maniere particulierement elegante deresoudre plusieurs problemes. Une telle methode s’appelle elle-meme, soit directement ouindirectement, creant un genre tableau escherien virtuel.

1 # Cette nouvelle version de factorielle utilise une methode recusive2 def factorielle(k) :3 if(k==0) :4 fac = 1 # fin de la recursion5 else :6 fac = k * factorielle(k-1) # appel recursif78 return fac9

10 #################################################################11 # Methode principale12 k = 1013 print "factorielle de 10 : ", factorielle(10)

(Verifiez que cette methode soit bien equivalente a la methode factorielle presenteeprecedemment.)

Attention : Il facile de faire des erreurs de conception qui menent, dans la programmationde methodes recursives, a une serie infinie de niveaux de recursion. Soyez toujours prudentslorsque vous utilisez la recursion.

3.2.4 Liste d’arguments flexible

Un aspect particulierement interessant de python est la possibilite de passer un nombrevariable d’arguments a une methode. Pour qu’une variable soit facultative, il faut qu’ellerecoive une valeur de defaut dans l’entete de la methode.

Ainsi, supposons que l’on veuille calculer une fonction factorielle «tronquee», dont leproduit va de m a n avec 0 ≤ m ≤ n. On peut modifier notre programme Factorielle enintroduisant une variable supplementaire qui recevra la valeur 0 (zero) par defaut.

Nous aurons donc


1 """2 Ce programme demontre l’utilisation d’une liste d’arguments variable34 factorielle calcule la factorielle tronquee de maniere recursive.5 """67 # Si on ne passe qu’un argument, python le prend pour max et conserve min=08 # Si on passe deux arguments, alors min prend la valeur du second.9 def factorielle( max, min=0 ) :

10 if (min > max ) :11 fac = 012 elif (max == 0 ) :13 fac = 114 elif (max == min ) :15 fac = max16 else :17 fac = max * factorielle(max-1,min)1819 return fac2021 # Methode principale22 print " **** Ce programme calcule une factorielle tronquee ****"2324 # On peux aussi passer plusieurs arguments (separes par une virgule) a25 # print26 a, b = input("Entrez deux nombres entiers (min,max) : ")2728 print "La factorielle tronquee entre ", a,29 print " et ", b, " est ", factorielle(b,a) # On passe deux arguements3031 # Alors qu’on n’en passe qu’un dans les deux appels ci-dessous32 print "La factorielle non-tronquee de ", a, " est ", factorielle(a)33 print "La factorielle non-tronquee de ", b, " est ", factorielle(b)

Le programme factorielle.py contient donc une methode qui peut etre appellee dedeux facons, soit avec un argument (qui sera associe a max), soit avec deux (qui redefinirontalors min et max).

3.3 Classes

La classe est l’objet de base dans la structure de python. Une classe, comme objet, peutetre instanciee. Cette instance ou copie possede toutes les proprietes de la classe et possedeun espace memoire unique. Il est donc possible de creer plusieurs instances (copies) d’uneclasse et de les gerer en tableau, par exemple.

Si on veut faire une simulation d’un solide ou d’un liquide, il peut etre utile de creer uneclasse Atomes qui contiendra les proprietes de chaque atome dans le systeme.

3.3. CLASSES 57

1 # Cette classe definit les proprietes d’un atome2 class Atome :3 masse = 3.0 # On definit une variable masse4 global x, y, z # les positions sont globales (dans Atome)56 # La methode __init__ est appelee automatiquement par python lors de7 # l’instanciation de la classe Atome8 def __init__(self) :9 self.x = 0.0 # On donne une valeur initiale a x, y et z

10 self.y = 0.0 # Afin de savoir quelle copie de y on change, on11 self.z = 0.0 # doit lui ajouter "self" qui est l’etiquette de12 # cette instance de la classe1314 # Methode - doit toujours avoir self comme premier argument15 def force(self) :16 xforce = self.r() * self.x17 return xforce1819 def r(self) :20 return self.x**2 + self.y**2 + self.z**22122 ###############################################################23 # Classe principale (qui ne contient que la methode principale)2425 at = [] # On cree une liste vide qu’on remplira d’atomes26 for i in range (100) :27 at.append( Atome() ) # lorsqu’on cree une instance d’Atome,28 # automatiquement Atome.__init__() est29 # appelee - initialisant x, y et z3031 # On lit la masse de l’atome 17 ainsi que sa position32 print "Masse de l’atome 17 : ", at[17].masse33 print "Position de l’atome 17 : ", at[17].x, at[17].y, at[17].z3435 at[69].x = 1.78 # on accede aux variables sans ajouter de parentheses36 at[69].y = 6.1237 at[69].z = 2.413839 # Notez que pour appeler la methode force, on doit ajouter des40 # parentheses puisqu’il s’agit d’une methode.41 print "Force sur l’atome 69 : ", at[69].force()


3.4 Les bibliotheques de classes

Une fois que nous avons cree ces classes, il est possible de vouloir les reutiliser dansd’autres programmes. Pour ce faire, on peut placer les classes dans un fichier et importer lefichier de la meme facon qu’on le fait avec les bibliotheques standards.

Chapitre 4

La programmation orientee objet

Comme nous l’avons mentionne plusieurs fois, python est un langage de programmationoriente objet. Ce concept est une arme a deux tranchants. Bien utilisee, la programmationorientee objet permet de reutiliser tres facilement des fonctions ecrites dans d’autres cir-constances. Si on abuse de cette propriete, toutefois, on se retrouve rapidement avec desprogrammes impossibles a dechiffrer.

4.1 La classe : l’objet de base

En Python, la classe forme l’objet de base. Un objet peut etre cree, lors d’une instancia-tion, par des declarations similaires a celles utilisees pour instancier des types primaires. Onpeut generer des tableaux d’objets, en creer plusieurs copies, etc.

Un objet est toutefois plus qu’une variable de type entier ou reel. Un objet possede uncertain nombre de proprietes auxquelles il est possible d’acceder en utilisant une structurede type nomDeClasse.variable ou nomDeClasse.methode().

4.2 Definir les classes

Une classe de python est un type de donnees defini par le programmeur. Elle est definipar la forme :

class UneClasseParticuliereenonces...

def methode(self, premier_argument, deuxieme_argument...)contenu de la methode

ou les enonces peuvent prendre n’importe quelle forme habituelle de python : des variables,des fonctions, des methodes, etc.

Toute methode definie dans une classe doit avoir au moins 1 argument : self, qui estun pointeur donnant l’identite de la copie de la classe utilisee. Cet argument est ajouteautomatiquement par python lorsque cette methode est appelee, on ne doit donc pas l’ajouterlors de l’appel de cet methode. Il doit etre present dans sa definition, touefois.

59

60 CHAPITRE 4. LA PROGRAMMATION ORIENTEE OBJET

Une fois la classe definie, on peut creer un objet possedant ses proprietes par une instan-ciation, qui cree une copie de cette classe :

instanceDeClasse = UneClasseParticuliere()

# Et on appelle la methode, notez que self est automatiquement passe par python# et n’est donc pas dans la listeinstanceDeClasse.methode(premier_argument, deuxieme_argument...)

4.2.1 Exemple : un objet nomme Bloc

Afin d’illustrer cette discussion, considerons un objet representant un bloc sur un planincline. Comme cet objet peut etre utilise par d’autres classes, il ne contient pas de methodeprincipale. On le met quand meme dans un fichier appele Bloc.py, le nom par lequel cetteclasse sera appelee.

"""La classe Bloc calcule les positions, vitesse et energiepotentielle pour un temps donne, en fonction de l’angle et de lahauteur d’un plan incline donne. On suppose que les vitesses sontnulles au temps t=0

"""from Numeric import *

class Bloc :acceleration = 9.81 # Variable definie visible par tout le bloc

# Les variables suivantes sont fixees lorsque le bloc est cree.global masse # Masse du blocglobal hauteurInitiale # hauteur initialeglobal angle # angle du plan incline sur lequel le bloc glisseglobal x0, y0 # position initialeglobal vx, vy # composantes des vitessesglobal x, y # position

# On definit certaines variables a l’instanciationdef __init__(self, masse, hauteurInitiale, angle ) :

self.masse = masseself.hauteurInitiale = hauteurInitialeself.angle = angle

# Et on initialise le bloc comme teldef initialise(self) :

self.x0 = self.hauteurInitiale / tan(self.angle)self.y0 = self.hauteurInitialeself.x = self.x0self.y = self.y0

4.2. DEFINIR LES CLASSES 61

self.vx = 0.0self.vy = 0.0

# La methode miseAJour calcule la vitesse et position pour un# temps donnedef miseAJour(self,temps) :

self.x = self.x0 + 0.5 * self.acceleration* cos(self.angle) * temps**2self.y = self.y0 - 0.5 * self.acceleration* sin(self.angle) * temps**2

# Calcul des vitessesself.vx = -1.0 * self.acceleration*cos(self.angle) * tempsself.vy = self.acceleration* sin(self.angle) * temps

# La methode potentielle evalue et retourne l’energie potentielledef potentielle(self) :

energiePot = self.masse * self.acceleration * self.yreturn energiePot

L’objet Bloc peut maintenant etre utilise dans un programme. Dans le programmeTestBloc, on cree un bloc, avec certaines proprietes, puis on imprime la position et l’energie.

"""Ce programme, TestBloc.py, cree une instance de bloc et lui assignediverses proprietes.

"""from Numeric import *import Bloc # On importe le contenu du fichier Bloc.py

masse = 0.5 # En kghauteur = 25.3 # En mangle = 0.28 * pi # En radians

# On cree maintenant une instance de bloc et on lui assigne les# parametres de base. On instancie l’objet Bloc qui se trouve dans le# fichier Bloc.pybl = Bloc.Bloc(masse, hauteur, angle)

bl.initialise() # On initialise les valeurs a t=0

t = 1.3 # On definit un nouveau temps

# Et on applique la propriete a l’objetbl.miseAJour(t)

# Finalement, on imprime le toutprint "A la position ( %f, %f ) " % (bl.x, bl.y)print "l’energie potentielle vaut : %f" % bl.potentielle()


Pour executer l’exemple ci-dessus, on peut mettre chaque classe dans un fichier separe,Bloc.py et TestBloc.py, et executer le programme simplement avec simplement avec

>>> python TestBloc.py

Si on desire mettre les deux classes dans le meme fichier, il faudra alors placer la classeBloc au debut du fichier, suivi, a la fin, du contenu de TestBloc.py.

4.3 Initialisation

Lorsqu’une nouvelle instance d’une classe est generee, la methode __init__ est auto-matiquement appelee, avec les arguments passes lors de l’instanciation. Par defaut, pythonajoute un argument, appele self par convention, devant la liste passee. Cet element consti-tue la reference a la classe elle-meme. Il faut donc toujours rajouter l’argument self auxmethodes d’une classe instanciee.

class Immeubles :def __init__(self,style = None) :

self.style = styleself.murs = ’clabord’

maison = Immeubles()maison.nombreEtages = 4maison.portes = 3maison.rue = ’Edouard-Montpetit’

print maison.styleprint maison.mursprint maison.rue

autreMaison = Immeubles(style=’canadien’)print autreMaison.style

On peut utiliser cette inialisation, pour definir dynamique diverses variables :

class Immeubles :def __init__(self, **kw) : # kw indique keyword ou mot-clef

self.__dict__.update(kw)

maison = Immeubles(style=’canadien’,murs=’clabord’)

print maison.styleprint maison.mursprint maison.rue

Comme on peut le constater, style et murs sont definis, mais pas rue.

4.4. HERITAGE 63

4.4 Heritage

La classe Bloc definit un certain nombre de proprietes et de methodes. Parfois, on veutrajouter des proprietes a une classe sans vouloir la redefinir en entier. C’est souvent le cas,par exemple, lorsqu’on cree un graphique.

Python nous permet de faire ceci tres simplement par le concept d’heritage. La classeheritiere possede toutes les proprietes de la classe originale plus celles que l’on veut luirajouter.

Reprenons l’exemple ci-dessus. On veut ajouter a Bloc, le calcul de l’energie cinetique,qui n’est pas compris dans Bloc. On creera donc une nouvelle classe, Bloc1, que l’on definiracomme une sous-classe de Bloc.

"""La classe Bloc1 ajoute aux proprietes de Bloc. Pour indiquer safiliation, on indique le nom de la classe dans

"""

import Bloc # On importe les classes du fichier Bloc.py

class Bloc1(Bloc.Bloc) : # Sous-classe de la classe Bloc du fichier Bloc.py

# On ajoute la classe cinetique, qui calcule l’energie cinetique. Notez# que l’on fait reference a masse, vx et vy, definis dans Blocdef cinetique(self) :

energieCin = 0.5 * self.masse * (self.vx**2 + self.vy**2)return energieCin

Toutes les variables et methodes de Bloc sont des proprietes de la classe Bloc1Notons que ces modifications n’affectent en rien le fonctionnement de Bloc en tant qu’ob-

jet. Vous pouvez verifer en utilisant cette classe dans le programme TestBloc donne ci-haut.Pour lancer le tout, on n’a qu’a modifier les lignes suivantes dans TestBloc :

"""Pour tester Bloc1, on n’a qu’a changer quelques lignes de TestBloc

"""import Bloc1 # Si on a place la classe Bloc1 dans le fichier Bloc1.py...

# On instancie Bloc1 plutot que Blocbl = Bloc1.Bloc1(masse, hauteur, angle)...# On teste en imprimant l’energie cinetiqueprint "et l’energie cinetique vaut : %f" % bl.cinetique()


4.5 Regles d’heritage

Une sous-classe herite des variables et methodes de la super-classe et de tous ces ancetres.La sous-classe peut utiliser ces definitions (ou membres de la famille) telles quelles ou lessur-definir.

De quels membres de la super-classes la sous-classe herite-t’elle ?

Une sous-classe herite de tous les membres de la superclasse a moins que la sous-classene la sur-definisse.

Qu’est-ce que la sur-definition ?

Il est possible de changer les proprietes d’une methode ou d’une variable appartenant a lasuper-classe en creant une methode ou une variable du meme nom dans la sous-classe. Dansce cas, c’est cette derniere qui aura priorite. On parle alors de sur-definition d’une methodeou d’une variable.

Les sous-classes ne peuvent heriter d’un membre portant le meme nom qu’une methodeou variable de la sous-classe. Ce dernier cache le premier. Python a prevu le coup et permetd’acceder aux membres de la super-classe a partir de la sous-classe, en appelant directementla methode.

Example :

class Bloc :def hauteur(self, x, y ) :

return y

class Bloc1(Bloc) :def hauteur(self, x, y ) :

return x

def test(self) :x = 3.0y = 12.1print "Hauteur dans la sous-classe (x) : %f" % self.hauteur(x,y)print "Hauteur dans la super-classe (y) : %f" % Bloc.hauteur(self,x,y)

bl = Bloc1()bl.test()

4.6 Comment les classes decrivent-elles les objets ?

Une classe permet les objets suivants :– les attributs de l’objet (variables) ;– le comportement de l’objet (les methodes) ;– la relation avec le comportement herite d’autres classes (superclasses).

4.7. UN PETIT TRUC UTILE 65

Nous verrons le concept de classe surtout dans le chapitre sur les graphiques. Il est doncimportant de comprendre le fonctionnement de la programmation orientee objet.

4.7 Un petit truc utile

Une instance d’une classe particuliere peut etre utilisee tout comme une structure en C ouune classe en Java. Toutefois, contrairement a ces langages de programmation, les proprietesde la classe n’ont pas a etre pre-definies, il est possible de les creer de maniere dynamique,ce qui simplifie considerablement le passage de variables globales.

Ainsi, on peut ecrire :

class Immeubles :pass

maison = Immeubles()maison.nombreEtages = 4maison.murs = ’brique’maison.portes = 3maison.rue = ’Edouard-Montpetit’

print maison.murs

On a donc cree, a posteriori, des proprietes de cette classe bidon.

Chapitre 5

Numeric : une bibliotheque al’usage des scientifiques

Jusqu’a present, nous avons surtout utilise des variables scalaires ou des chaınes de ca-racteres. En programmation scientifique, toutefois, les vecteurs et les matrices jouent un roleimportant. Ainsi, supposons qu’on veuille integrer les equations du mouvement pour 1000particules. On ne va certainement pas commence a traiter chacune des particules avec unnom de variable different x1, x2, ..., x1000. Nous pouvons utiliser les listes telles quedefinies precedemment. Celles-ci posent certains problemes car elles ne peuvent etre creeestout d’un coup. De plus, elles n’ont pas a etre emmagasinees cote-a-cote en memoire, ce quiralentit considerablement leur temps d’acces.

Heureusement, plusieurs programmeurs se sont penches sur ce probleme et ont pro-pose une bibliotheque de classes et d’objets qui permet a Python de manipuler les vec-teurs et les matrices de maniere aussi naturelle qu’avec Matlab. Cette bibliotheque d’uti-litaires, developpee initialement par Jim Hugunin, alors au MIT, puis par Paul F. Du-bois et ses collaborateurs, s’appelle Numarray, elle est la deuxieme generation, suivant latres appreciee Numeric.. Recemment, une nouvelle bibliotheque a vu le jour, qui s’appellenumpyindexbibliotheque !numpy@Numpy. Pour le moment, la situation n’est pas claire en cequi concerne la meilleure solution.

Dans ce chapitre, nous verrons donc Numeric, de meme que la bibliotheque mathematiqueet celle de generation de nombres aleatoires. Avec ces outils, vous serez fin prets pour effectuertous les calculs scientifiques dont vous pourriez rever !

5.1 La bibliotheque mathematique

5.2 Numeric

Python numerique (Numerical Python) ou Numeric est une collection d’objets etendentconsiderablement les capacites de Python dans la manipulation de tableaux multidimen-tionnels. Les tableaux unidimensionnels ou vecteurs ressemblent aux listes de Python. Lestableaux bidimensionnels sont les matrices bien connues en algebre lineaire. Il faut faire at-tention, toutefois. Tous les elements des tableaux de Numeric doivent etre du meme type etles operations sur les tableaux ne respectent pas toujours les regles de l’algebre lineaire.

67

68CHAPITRE 5. NUMERIC : UNE BIBLIOTHEQUE A L’USAGE DES SCIENTIFIQUES

Comme nous l’avons dit plus haut, Numarray est une version amelioree de Numeric,developpee par les meme programmeurs. En general, cette nouvelle version est retrocompatibleet la plupart des programmes utilisent encore Numeric. Il se peut, toutefois, que certains pro-grammes requierent specifiquement Nummarray. Dans ce cas, vous serez obligez d’installerles deux bibliotheques sur votre machine.

Ceux qui connaissent un peu Matlab decouvrivront des ressemblances troublantes dansles operations. Ceci vous permettra de passer plus facilement d’un langage a l’autre.

5.2.1 Obtenir et installer Numeric

Numeric est inclus avec la distribution d’Enthought pour Windows. Si vous avez suivi lesdirectives du Chapitre 1, Numeric devrait aussi etre installe sur Mac Os X et Linux. Si vousdesirez la version la plus recente, vous pouvez vous la procurer sur le site de Sourceforge(http ://numeric.scipy.org).

Tester l’installation

Une fois que la bibliotheque Numeric est installee, vous pouvez verifier que celle-ci estvisible par Python en tappant :

>>> import NumericTraceback (innermost last):File "<stdin>", line 1, in ?ImportError: No module named Numeric

Si vous obtenez ce message, cela veut dire que Numeric n’a pas ete installe correctementtandis que

>>> import Numeric>>> Numeric.__version__’24.2’>>> dir(Numeric) # montre la liste des methodes de Numeric[’ArrayType’, ’Character’, ’Complex’, ’Complex0’, ’Complex16’, ’Complex32’,’Complex64’, ’Complex8’, ’DumpArray’, ’Float’, ’Float0’, ’Float16’,’Float32’, ’Float64’, ’Float8’, ’Int’, ’Int0’, ’Int16’, ’Int32’, ’Int8’,’LittleEndian’, ’LoadArray’, ’NewAxis’, ’Pickler’, ’PrecisionError’,’PyObject’, ’StringIO’, ’UInt’, ’UInt16’, ’UInt32’, ’UInt8’, ’Unpickler’,’UnsignedInt16’, ’UnsignedInt32’, ’UnsignedInt8’, ’UnsignedInteger’,’__builtins__’, ’__doc__’, ’__file__’, ’__name__’, ’__version__’, ’_numpy’,...’swapaxes’, ’take’, ’tan’, ’tanh’, ’trace’, ’transpose’, ’true_divide’,’typecodes’, ’types’, ’where’, ’zeros’]

indique que Numeric est pret a fonctionner.En general, puisque les commandes et objets de Numeric n’entrent pas en conflit avec les

commandes de base de python, nous allons plutot importer directement toute la bibliotheque :

>>> from Numeric import *

5.2. NUMERIC 69

5.2.2 Les objets de Numeric

Les tableaux de Numeric sont des collections homogenes qui peuvent compter un grandnombre de chiffres. Tous ces chiffres ont le meme type, soit entier, double precision oucomplexe. Les tableaux ont une taille immuable mais la valeur de leurs elements peut etremodifiee.

La forme d’une tableau indique le nombre de dimensions du tableau et sa taille danschacune de ces dimensions. La forme du tableau peut etre modifiee.

Toute operation mathematiques sur un tableau retourne un nouveau tableau contenantle resultat de cette operation appliquee sur chaque element un a un.

Voici comment un utilise Numeric :

>>> from Numeric import * # On importe d’abord la bibliotheque>>> vecteur = array((1,2,3,4,5))>>> print vecteur[1 2 3 4 5]>>> print vecteur.shape(5,)>>> print vecteur + 2* vecteur[3 6 9 12 15]>>> matrice = array(([0,1],[2,3]))>>> print matrice[[0 1][2 3]]>>> matrice.shape(2,2)>>> print matrice * matrice[[0 1] # Il s’agit d’une multiplication element par element[4 9]] # et non d’une operation matricielle

5.2.3 Creer un tableau

On cree un tableau avec la commande array. Le type du tableau est choisi en fonctiondes elements du tableau ou peut etre force avec la commande type=<type> ou <type> peutetre :

1. Bool : type booleen (vrai ou faux) ;

2. UInt8, UInt16 (defaut pour entier) : entier sans signe ;

3. Int8, Int16 ou Int32 (defaut pour entier) : entiers avec signe ;

4. Float32, Float64 (defaut pour nombre reel) ;

5. Complex32 ou Complex64 (defaut pour nombre complexe)

Quelques exemples de tableaux de divers types et dimensions.

>>> a = array([3.0,1,2.1]) # Cree un tableau de type Float64>>> a = array([1,2,3,5],Float32) # Force un type Float32>>> x, y, z = 3.1, 4.78, 9j>>> b = array([x,y,z]) # Tableau de type Complex64


# Et maintenant, une matrice 3x3 de type Complex64>>> deuxD = array( [ [x,y,z],[-y,x,y],[-z,-y,x] ])>>> print deuxD[[ 3.1 +0.j 4.78+0.j 0. +9.j][-4.78+0.j 3.1 +0.j 4.78+0.j][ 0. -9.j -4.78+0.j 3.1 +0.j]]

Notez qu’il faut toujours mettre la liste de chiffres a placer dans le tableau entre crochets.Si on n’est pas satisfait avec notre tableau, on peut toujours le remodeler a l’aide de la

commande reshape.

>>> a = array([1,2,3,4,5,6,7,8])>>> a.shape # Retourne la taille du tableau(8,)>>> b = reshape(a, (2,4) ) # On transforme en matrice 2x4>>> print b[[1 2 3 4][5 6 7 8]]>>> b.shape(2,4)>>> c = reshape(b, (-1,2) ) # Utiliser -1 afin de laisser python>>> print c # calculer la bonne taille[[1 2][3 4][5 6][7 8]]>>> reshape(a, (3,3) ) # Message d’erreur, on doit conserver le nombre d’elementsTraceback (most recent call last):

File "<stdin>", line 1, in ?ValueError: total size of new array must be unchanged

Dans certain cas, on veut forcer le tableau dans une nouvelle forme qui ne contient pasle meme nombre d’elements. On utilise alors la commande resize.

>>> a = array( arange(4), Float)>>> print a[ 0. 1. 2. 3.]>>> b = resize(a, (3,3)) # Nouveau tableau est plus grand, on>>> print b # recopie les elements plusieurs fois[[ 0. 1. 2.][ 3. 0. 1.][ 2. 3. 0.]]>>> c = resize(a,(3,)) # Nouveau tableau est plus petit, on tronque>>> print c # la liste initiale[0. 1. 2.]

5.2. NUMERIC 71

Creer des tableaux avec des valeurs predefinies

On a souvent besoin de creer des tableaux avec des valeurs predefinies. Numeric a prevule coup et propose un certain nombres de commandes utiles.

zeros(forme[, type ) ] Initialise tous les elements d’un tableau de forme forme et de typetype a zero. Le defaut est un tableau de type Int.

>>> a = zeros( (3,4), Float)>>> print a[[ 0. 0. 0. 0.][ 0. 0. 0. 0.][ 0. 0. 0. 0.]]

ones(forme[,type ) ] Meme chose que zeros() mais initialise a 1.Pour creer un tableau initialiser a une autre valeur, il suffit de l’ajouter a zero,

>>> a = zeros( (3,4), Float) + pi>>> print a[[ 3.14159265 3.14159265 3.14159265 3.14159265][ 3.14159265 3.14159265 3.14159265 3.14159265][ 3.14159265 3.14159265 3.14159265 3.14159265]]

arange( [initial, final[, pas]) ] Cree un tableau unidimensionel commencant a initial etallant jusqu’a mais sans inclure final par increment de pas. Si pas est omis, on supposeun increment de 1 ; initial est a 0 par defaut.

>>> a = arange(8) # Cree un tableau d’elements entiers>>> print a # allant de zero a 8 (non-inclus) par pas de 1[0 1 2 3 4 5 6 7]>>> a = arange(8.0) # Cree un tableau d’elements Float64>>> print a[0. 1. 2. 3. 4. 5. 6. 7.]>>> a = arange(-2, 5, 0.5) # Cree un tableau d’elements Float64>>> print a # allant de -2 a 5 par pas de 0.5[-2. -1.5 -1. -0.5 0. 0.5 1. 1.5 2. 2.5 3. 3.5 4. 4.5]

Pour former un tableau multidimensionel, il suffit de combiner arange avec reshape :

>>> a = reshape( arange(18.0), (3,6))>>> print a[[ 0. 1. 2. 3. 4. 5.][ 6. 7. 8. 9. 10. 11.][ 12. 13. 14. 15. 16. 17.]]

fromshape(fonction,forme) On peut aussi creer un tableau ou la valeur de chaqueelement est calculee en fonction des indices.

>>> def distance(x,y) :... return sqrt(x**2 + y**2)...


>>> a = fromfunction(distance,(2,3))>>> print a[[ 0. 1. 2. ][ 1. 1.41421356 2.23606798]]

identity(rang) Cree un matrice identite de rang rang.

>>> i = identity(4)>>> print i[[1 0 0 0][0 1 0 0][0 0 1 0][0 0 0 1]]

5.2.4 Extraire des elements

On peut cibler des elements particuliers des tableaux de la meme maniere que pour leslistes.

>>> a = reshape(array( arange(12.)), (2,6))>>> print a[[ 0. 1. 2. 3. 4. 5.][ 6. 7. 8. 9. 10. 11.]]>>> print a[0,3] # Imprime le 4e element de la 1e rangee3.0>>> print a[0:1,3] # Imprime un sous-tableau[[ 3. 4. 5.][ 9. 10. 11.]]>>> print a[0:2,3] # Imprime une colonne[ 3. 9.]>>> print a[1,:] # Imprime une rangee[ 6. 7. 8. 9. 10. 11.]>>> print a[:,5] # Imprime une colonne[ 5. 11.]>>> a[1] = [2, 4, 6, 3, 4, 12] # Redefinit une rangee>>> print a[[ 0. 1. 2. 3. 4. 5.][ 2. 4. 6. 3. 4. 12.]]>>> print a[0,-2] # 2e element de la fin sur la 1e rangee4.0

5.2.5 Operations sur les tableaux

Un des principaux avantages de Numeric est que, contraitement a C++ ou a Java, ilpermet les operations directement sur un tableau. Il n’est donc pas necessaire de manipulerles elements d’un tableau un a un.

Alors qu’en C++ ou Java on ecrirait :

5.2. NUMERIC 73

for(i=0; i< fin_i; i++) {for(j=0; j< fin_j; j++) {

a[i][j] += 3}

}

Python nous permet d’ecrire l’operation en une seule ligne :

>>> a = zeros([5,5],Float)>>> a += 3.0 # Cette ligne est equivalente a la structure ci-haut>>> print a[[ 3. 3. 3. 3. 3.][ 3. 3. 3. 3. 3.][ 3. 3. 3. 3. 3.][ 3. 3. 3. 3. 3.][ 3. 3. 3. 3. 3.]]

L’existence d’un grand nombre d’operations sur des tableaux rend Python aussi puissant queMatlab.

Les operateurs de base s’appliquent a chaque element du tableau de maniere identique,il ne s’agit pas d’operations matricielles :

>>> a = array([1.,2.,3.])>>> print 2.5 * a[ 2.5 5. 7.5]>>> print a + a[ 2. 4. 6.]

On peut aussi appliquer des fonctions mathematiques a ces tableaux

>>> print cos(a)[ 0.54030231 -0.41614684 -0.9899925 ]

Numeric comprend meme lors qu’on applique une operation entre deux tableaux de di-mension differentes

>>> b = ones([4,3],Float)>>> print a + b[[ 2. 3. 4.][ 2. 3. 4.][ 2. 3. 4.][ 2. 3. 4.]]

Si les tailles sont incompatibles (par exemple on ajoute un tableau de dimension 3 a un dedimension 4) python imprime un message d’erreur. Essayez !


Tab. 5.1 – Fonctions universelles. La premiere serie de ces fonctions transforme chaqueelement d’un tableau suivant une fonction mathematique standard. La deuxieme serie per-forme des operations mathematiques entre deux tableaux ou un tableau et un scalaire. Fi-nalement, la troisieme serie consiste en une serie d’operations non-homogenes sur le tableau.

Fonction unairearccos arccosh arcsin arcsinh arctanarctanh cos cosh tan tanhlog10 sin sinh sqrt absolutefabs floor ceil fmod explogFonctions arithmetiquesadd (+) subtract (-) multiply (*) divide (/) remainder (%)power (∗∗)Fonctions logiques et autresmaximum minimum greater (>) greater equal (>=)equal (==) less (<) less equal (<=) not equal ( !=) logical or (or)logical xor logical not (not) logical and (and) bitwise or (—) bitwise xor (^)bitwise not (÷) bitwise and (&)sum product

5.2.6 Fonctions universelles

Numeric surdefinit des fonctions mathematiques afin qu’elles puissent manipuler les ta-bleaux convenablement.

Les fonctions universelles sont des fonctions qui s’appliquent sur tous les tableaux. Onretrouve les fonctions trigonometriques et arithmetiques deja definies pour des variables.Celles-ci sont enumerees dans le tableau 5.2.6 et ne requierent pas d’explication. Un certainnombre d’autres operations peuvent etre utilses.

Quelques exemples :Dans ces exemples, on considere a et b comme des tableaux ou scalaires. c est le resultats

de l’operation.

multiply(a,b,c) Cette operation est equilavent a c = a*b. Toutefois, elle est preferablelorsqu’on desire reutiliser le tableau initial

a = a * b # Le deux operations sont formellement identiquesmultiply(a,a,b) # Toutefois la deuxieme est plus efficace

dans le premier cas, Python cree un tableau tepmoraire dans lequel il emmagasine leproduit a∗b avant de recopier le tout dans a. Avec multiply, les elements sont remplacesa mesure, ce qui rend la procedure beaucoup plus efficace dans le cas de gros tableaux.

less equal (<=) Les operations logiques sont appliquees egalement a chaque element et untableau contenant des 1 (lorsque que la conditions est vraie) et 0 (lorsque la conditionest fausse) est retourne.

>>> b = sin( array ( arange( 8.) ) )>>> print b

5.2. NUMERIC 75

[ 0. 0.84147098 0.90929743 0.14112001 -0.7568025 -0.95892427-0.2794155 0.6569866 ]

>>> print less_equal(b, -0.2)[0 0 0 0 1 1 1 0]

minimum(a,b), maximum(a,b) Le plus petit ou le plus gros deux de chaque elementdu tableau a ou b.

>>> a = array( arange(5.) )>>> b = 3.0 * sin ( a )>>> print b[ 0. 2.52441295 2.72789228 0.42336002 -2.27040749]>>> print maximum(a,b)[ 0. 2.52441295 2.72789228 3. 4. ]

sum(a),product(b) Calcule la somme de tous les elements (ou leur produit.

>>> sum(a) # Est equivalent a somme = a[0]+a[1]+a[2]+...+a[n-1]>>> product(a) # produit = a[0]*a[1]*...a[n-1]>>> sum(a[3:5]) # somme = a[3] + a[4]

5.2.7 Operations matricielles

Jusqu’a present les fonctions que nous avons vues s’appliquent sur chaque element un aun et remplacent des boucles for toutes betes. Numeric a egalement une serie d’operationsdefinies en algebre lineaire. Nous mentionnerons ici les plus courantes.

transpose(a) Transpose une matrice.

>>> a = reshape(array(arange(8)), (2,4))>>> print a[[0 1 2 3][4 5 6 7]]>>> print transpose(a)[[0 4][1 5][2 6][3 7]]

diagonal(a) Retourne dans un vecteur les elements sur la diagonale d’une matrice carree.trace(a) Calcule la trace d’une matrice (le produit des elements sur la diagonale

>>> print a[[ 0.2 0.80300042 -0.94763894][-0.91520736 0.45897275 -1.29718565][-1.29886393 0.45343436 -0.94038678]]

>>> print diagonal(a)[ 0.2 0.45897275 -0.94038678]>>> print trace(a)-0.281414032721


dot(a,b), matrixmultiply(a,b) Le deux operations correspondent a un produit matriciel.Soit entre deux matrices, soit entre une matrice et un vecteur. Les rangs doivent etrecompatibles.

>>> a = reshape( array(arange(12)), (4,3) )>>> b = array([0.3, 3.1, 4.0])>>> print dot(a,b)[ 11.1 33.3 55.5 77.7]>>> print dot(transpose(a),b)Traceback (most recent call last):

File "<stdin>", line 1, in ?File >>> "/sw/src/root-numeric-23.0-1/sw/lib/python2.3/site-packages/Numeric/dotblas

/__init__.py", line 53, in dotValueError: matrices are not aligned

innerproduct(a,b) Calcule le produit interieur, i.e., matrixmultiply(a,transpose(b)).

outerproduct(a,b) Calule le produit exterieur de deux vecteurs a et b : c[i,j] = a[i] * b[j]

sort(a,

5.3 Extraire des colonnes ou des rangees d’un tableau

Finalement, il est egalement possible d’extraire des colonnes ou des rangees d’un tableau.

take(a, indices, axis=0) Extrait une serie de rangees ou de colonnes telles que definit parla serie d’indice. Par defaut, on travaille avec des rangees (axis=0). Pour travailler avecdes colonnes, il suffit de definit axis=1.

>>> print a[[ 0 1 2 3][ 4 5 6 7][ 8 9 10 11][12 13 14 15]]>>> print take(a,(2,) ) # Extrait la troisieme rangee[ [ 8 9 10 11]]>>> print take(a,(3,), axis=1 ) #Extrait la 4e colonne[[ 3][ 7][11][15]]>>> print take(a, (2,1)) # Extrait la troisieme et le deuxieme rangee[[ 8 9 10 11][ 4 5 6 7]]

5.3.1 Algebre lineaire

Numeric offre egalement une interface avec la bibliotheque de routines d’algebre lineaireLAPACK. Cette bibliotheque est disponible en version optimisee sur la plupart des plate-formes.

5.3. EXTRAIRE DES COLONNES OU DES RANGEES D’UN TABLEAU 77

Afin d’utiliser le module d’algebre lineaire, il faut import Numeric et LinearAlgebra

from Numeric import *from LinearAlgebra import *

determinant(a) Calcule le determinant d’une matrice carree a.

eigenvalues(a) Retourne les valeurs propres d’une matrice carree a.

eigenvectors(a) Retourne les valeurs propres et les vecteurs propres d’une matrice carreea.

>>> print a[[ 0 4 10 14][ 4 10 15 20][10 15 20 25][14 20 25 30]]>>> print eigenvalues(a)[ 66.85631343 -7.32175806 0.7410995 -0.27565488]>>> valeur, vecteurs = eigenvectors(a) # retourne un vecteur et un tableau>>> print valeur[ 66.85631343 -7.32175806 0.7410995 -0.27565488]>>> print vecteurs[[-0.25024573 -0.40424972 -0.54941603 -0.68709626][-0.77186846 -0.43641588 0.11155444 0.44868237][-0.51492347 0.79776168 -0.31207046 -0.03228226][ 0.27649588 -0.09848681 -0.76701347 0.57056175]]>>> print dot(a,vecteurs[0])/valeur[0] # On verifie que Ax = ex[-0.25024573 -0.40424972 -0.54941603 -0.68709626]

Heigenvalues(a), Heigenvectors(a) Retourne les valeurs propres (reelles positives) et lesvecteurs propres (orthonormes) d’une matrice hermitienne.

inverse(a) Retourne la matrice inverse de a.

>>> print dot(a,inverse(a)) # Donne la matrice identite[[ 1.00000000e+00 5.55111512e-17 -4.44089210e-16 2.66453526e-15][ -1.11022302e-15 1.00000000e+00 -2.66453526e-15 1.77635684e-15][ -9.43689571e-16 4.16333634e-16 1.00000000e+00 5.77315973e-15][ -2.55351296e-15 1.38777878e-15 -4.44089210e-16 1.00000000e+00]]

solve linear equations(a,b) Resout un systeme d’equations lineaires ou a est une matricenon-singuliere et b est un vecteur : Ax = b.On peut donc resoudre le systeme d’equations suivant :

2x + 3y = 1 (5.1)1x + 2y = 2 (5.2)

>>> a = array([[2., 3.],[1.,2.]])>>> b = array([1.,2.])>>> solve_linear_equations(a,b)array([-4., 3.])


5.4 Nombres pseudo-aleatoires

Il est souvent utile lorsqu’on fait des simulations de pouvoir generer des nombres aleatoires.Sans entrer dans les details, les nombres aleatoires generes par les ordinateurs ne sont

pas vraiment aleatoires. Partant d’un nombre initial (le germe), l’algorithme produit unesequence de nombres qui sont independants les uns des autres, d’un point de vue statistique.Comme l’algorithme est lui-meme completement deterministique, un germe donne produittoujours la meme sequence pseudo-aleatoire.

Il existe plusieurs algorithmes mathematiques pour generer de telles sequences. On peuttrouver une description de ces algorithmes dans le livre Numerical Recipes, par exemple.En plus de la qualite de la statistique des nombres generes, on veut souvent avoir une treslongue sequence, particulierement si on a besoin de tirer des milliards de nombres aleatoires.Le generateur de Numeric permet de creer une sequence de longueur suffisante pour la plupartdes problemes.

On peut initialiser ce generateur a partir d’un germe que l’on definit, de maniere plusautomatique, a partir de l’horloge de l’ordinateur. La premiere methode est preferable lorsde la mise-au-point de votre programme. Comme la sequence est identique chaque fois qu’onlance le programme, il est possible de reproduire une erreur a tout coup. Lorsqu’on est finpret, il est utile de passer a une generation plus automatique des germes, ce qui nous permetde faire plusieurs simulations differentes sans avoir a se preoccuper de la valeur des germes.

En Python, il existe deux modules de generation de nombres aleatoires : random etRandomArray. Le premier genere des nombres aleatoires qu’on peut extraire un par un. Ilutilise une methode dite Mersenne Twister. La periode de ce generateur atteint 219937 − 1.Le deuxieme generateur est intimement relie a Numeric. Son principal avantage est qu’ilpermet de generer des tableaux entiers de nombres aleatoires, ce qui fait qu’on peut l’utiliserdirectement dans des operations sur des tableaux.

5.4.1 random

La methode random est utile quand on n,a basoin que d’un nombre aleatoire a la fois.Pour l’utiliser, on doit d’abord charger le module random :

>>> import random>>> dir(random)[’LOG4’, ’NV_MAGICCONST’, ’Random’, ’SG_MAGICCONST’, ’TWOPI’,’WichmannHill’, ’__all__’, ’__builtins__’, ’__doc__’, ’__file__’,’__name__’, ’_acos’, ’_cos’, ’_e’, ’_exp’, ’_floor’, ’_inst’, ’_log’,’_pi’, ’_random’, ’_sin’, ’_sqrt’, ’_test’, ’_test_generator’,’betavariate’, ’choice’, ’cunifvariate’, ’expovariate’, ’gammavariate’,’gauss’, ’getstate’, ’jumpahead’, ’lognormvariate’, ’normalvariate’,’paretovariate’, ’randint’, ’random’, ’randrange’, ’sample’, ’seed’,’setstate’, ’shuffle’, ’stdgamma’, ’uniform’, ’vonmisesvariate’,’weibullvariate’]

Comme on peut le constater, cette classe contient plusieurs methodes. Pour plus d’infor-mations, tapez help(random).

5.4. NOMBRES PSEUDO-ALEATOIRES 79

Lorsqu’on cree une instance de random, on doit assigner un germe, c’est-a-dire un nombrequi determine uniquement la sequence de nombres pseudo-aleatoires. Si on n’assigne pas degerme, la methode utilise l’horloge de l’ordinateur. L’utilisation d’un germe predefini esttres utile lors de la mise-au-point d’un programme, alors qu’on veut reproduire une erreurdonnee.

Nous ne mentionnons ici que les methodes les plus courantes :

>>> import random # On importe la bibliotheque>>> r = random.Random() # cree une copie du generateur de nombres

# pseudo-aleatoires

>>> r.seed(348) # facultatif - definit une sequence precise# de nombres pseudo-aleatoires

>>> r.random() # retourne un nombre reel dans l’intervalle [0,1)0.8721659803279822>>> r.randint(3,19) # retourne un entier dans l’intervalle [3,19)16>>> r.uniform(2,35.9) # retourne un reel dans l’intervalle [2,35.9)]8.2095387656891994

Note : En general, on ne cree qu’une seule sequence de nombres aleatoires dans un pro-gramme. On garde alors r comme une variable globale.

5.4.2 RandomArray

Les methodes associees avec RandomArray sont utiles lorsqu’on les utilises avec desoperations logiques, par exemple, lorsqu’on fait du Monte Carlo.

Pour ce faire, il faut charger le module RandomArray

from Numeric import *from RandomArray import *

seed(i,j) Cette fonction definit uniquement la sequence de nombres aleatoires a partir dedeux entiers, i et j. Si la methode est lancee sans argument, Python utilise l’heure etla date comme germe.On peut verifier la valeur du germe a n’importe quel moment avec la commandeget seed.

random(forme) Retourne un tableau de forme forme remplit de nombres pseudo-aleatoirestires d’une distribution uniforme dans l’intervalle ]0, 1[. Si on appele random() sansargument, la fonction retourne un scalaire dans le meme intervalle.

>>> from RandomArray import *>>> seed(342,3678)>>> get_seed()(342, 345)>>> m = random((3,4))>>> print m>>> print m


[[ 0.99983518 0.97251412 0.50104292 0.29999682][ 0.72291846 0.81839587 0.56071449 0.22406544][ 0.82726602 0.35186291 0.29924545 0.36688385]]>>> get_seed()(1098429226, 310552179)

uniform(a,b,forme) Meme chose que random() sauf que la distribution est tiree dans unintervalle ]a, b[.

randint(a,b,forme) Retourne un tableau de forme forme

>>> print randint(-2,26, (3,12))[[10 8 6 15 19 5 19 5 11 4 3 2][11 22 -2 3 23 4 20 5 18 5 5 22][20 0 0 25 10 0 0 1 22 2 4 23]]

Chapitre 6

Pylab et matplotlib

Lorsqu’on a affaire a un jeu de donnees complexes, il est souvent necessaire de les visuali-ser d’une facon ou d’une autre, notre cerveau etant programme pour utiliser la vision quandil s’agit de traiter de grandes quantites des donnees.

Interfacant avec plusieurs programmes graphiques, Python est particulierement riche ducote de la visualisation. Dans ces notes, vous trouverez la description d’interfaces avec quatrelibrairies graphiques : xmgrace et gnuplot, qui permettent de tracer des courbes, Tkinter, uneinterface de la libraire graphique tcl/tk et, dans ce chapitre, pylab et matplotlib, qui offrentune interface similaire a matlab. Dans le cours, nous utiliserons cette derniere interface, quiest tres flexible et devrait vous servir dans les laboratoires et cours du baccalaureat a venir.

Dans ce chapitre, je presente une breve introduction a cette bibliotheque particulierementinteressante. Vous trouverez toute la documentation a propos de matplotlib sur le site in-ternet http ://matplotlib.sourceforge.net/, vous permettant de completer les bribes d’infor-mation que je donne ici.

6.1 Installation de matplotlib

Le premier chapitre de ces notes offre une description detaillee de l’installation de labibliotheque matplotlib. Veuillez y jeter un coup d’oeil si matplolib ne fonctionne pas survotre ordinateur.

6.1.1 Premiere utilisation de matplotlib

Les graphiques avec matplotlib peuvent se faire en mode interactif ou via un script, avecune serie de commandes de ligne, dans le meme esprit que ce qu’on a vu jusqu’a present. Sicela peut sembler un peu lourd lorsqu’on n’a qu’un seul graphique a preparer, cette approchepermet l’automatisation de procedures pouvant etre appliquees a plusieurs jeux de donnees,de maniere automatique et repetitive.

Supposons, par exemple, que vous deviez recuperer des donnees meteorologiques dumonde entier 4 fois par jour et les tracer afin de suivre le mouvement des masses d’air. Unscript comme python vous donne la possibilite d’automatiser completement cette procedure,du repechage des donnees a leur visualisation.

Comme on va le voir, l’utilisation de matplotlib simplifie beaucoup la visualisation desdonnees.

81

82 CHAPITRE 6. PYLAB ET MATPLOTLIB

Fig. 6.1 – Sortie de premier graphique de matplotlib. De gauche a droite, les boutons du bassignifient : (1) retour aux parametres initiaux ; (2) et (3) : repeter les operations, vers l’avantou l’arriere ; (4) deplacer la courbe sur le graphique ; (5) zoom sur une partie du graphiquea definir avec la souris ; (6) ajuster le graphique sur le fond ; (7) imprimer le graphique.

Commencons par l’exemple le plus simple. En trois lignes, il est possible de tracer ungraphique ; c’est difficile de faire mieux !

On importe d’abord la bibliotheque pylab, puis on prepare les donnees avec la commandeplot avant de tracer le tout a l’ecran avec la commande show :

>>> from pylab import * # Permet les vecteurs et matrices>>> plot ([1,2,3,4])>>> show() # Essentiel pour lancer l’interface graphique

Le graphique ainsi cree peut etre imprime directement en utilisant les boutons qui appa-raissent au bas de l’interface graphique. De plus, il est modifiable avec la souris. Ainsi, vouspouvez changer les axes, la taille du graphique, etc. (Voir Fig. 6.1)

6.1.2 Quelques exemples plus etendus

En general, on desire mettre un peu plus d’information sur le graphique : une legende,des descriptions, un titre, etc. Voyons comment on s’y prend.

Deux courbes sur un graphique

Dans l’exemple ci-dessous, on trace un cosinus et un sinus. Pour ce faire, on creera quatretableaux.

1 # -*- coding: utf-8 -*-

from pylab import * # Importe l’interface

6.1. INSTALLATION DE MATPLOTLIB 83

5 # On cree d’abord des tableaux de 100 elements chacunx1 = arange(0.0,10.0,0.1)x2 = arange(0.0,5.0,0.05)

y1 = sin(x1)10 y2 = cos(x2)

# On prepare ensuite les jeux de donnees un a la suite de l’autreplot(x1,y1,label=’Serie 1’) # Trace une premiere courbeplot(x2,y2,label=’Serie 2’) # Trace une deuxieme courbe

15# Les limites du graphique sont definies avec la commande axis# dont l’argument est (xmin,xmax,ymin,ymax)axis([-0.5,10.5,-1.3,1.3])

20 # Les trois commandes ci-dessous definissent les etiquettesxlabel(’Abscisse’)ylabel(unicode(’Ordonnee’,’utf-8’))title(’Sinus et cosinus’)

25 legend()show()

Une fois prepare, ce graphique peut etre imprime directement. Il est possible d’imprimer enformat png et eps (postscript encapsule). Le programme se base sur l’extension pour deciderdu format. Pour PNG, donnez un nom qui se termine avec .png, par exemple.

Deux courbes dans deux graphiques

Creons maintenant deux graphiques sur la meme page, en utilisant les memes donneesque dans l’exemple precedent.

1 # -*- coding: utf-8 -*-

from Numeric import *from pylab import * # Importe l’interface

5# On cree d’abord des tableaux de 100 elements chacunx1 = arange(0.0,10.0,0.1)x2 = arange(0.0,5.0,0.05)

10 y1 = sin(x1)y2 = cos(x2)

# Definit ensuite l’existence d’une figurefigure(1)


15# Celle-ci compte deux sous-graphiquessubplot(211) # sublot(nbre rangees, nbre colonnes, position active)plot(x1,y1,’rs’,label=’Serie 1’) # Trace des carres rougestitle (’Titre d’en haut’) # Titre associe a la premiere figure

20# Et le deuxiemesubplot(212) # Deuxieme d’une colonne de deux rangeesplot(x2,y2,’bo’,label=’Serie 2’) # Trace des cercles bleustitle(’Titre d’en bas’)

25# Note: Puisque ces trois commandes apparaissent apres la figure 2,# elles ne s’appliquent qu’a celle-ci. Il faudrait repeter pour 1# si on veut les avoir la aussi.xlabel(’Abscisse’)

30 ylabel(unicode(’Ordonnee’,’utf-8’))legend()

savefig(’deuxpanneaux.png’) # On peut aussi imprimer directement

35 show()

6.1.3 Lecture et ecriture de donnees

Lorsqu’on fait de longues simulations ou des experiences compliquees. L’analyse desdonnees se fait souvent apres coup. On aura donc besoin de lire les donnees d’un fichieravant de les tracer.

On peut bien sur utiliser les outils standards de python, tels que readlines(), etc.Toutefois, lorsque les donnees sont placees en colonnes, il est encore plus simple d’utiliser lamethode fournie par pylab.

Considerons, par exemples, un jeu de donnees placees dans un fichier, avec le formatsuivant :

0.1 0.45 2.30.3 1.20 1.80.4 1.3 1.40.7 2.1 0.51.1 4.3 -0.31.3 2.7 0.1...

Si ces donnees sont dans le fichier donnees.dat, on peut lire :

donnees = load(’donnees.dat’)x = donnees[:,0] # Premiere colonney = donnees[:,1] # Deuxieme colonnez = donnees[:,2] # Troisieme colonne


Tab. 6.1 – Quelques commandes de pylab.Commande Descriptiontitle(’titre’) Definit le titre du graphiquexlabel(’x’[,options]) Definit l’etiquette de l’axe des x (opt : fontsize, etc.)ylabel(’y’[,options]) Definit l’etiquette de l’axe des yplot(x,y, options ) Trace un graphique a partir de deux vecteurs

fontsize=12 largeur des charactereslabel=’description’ description de la courbelinestyle=’ ;’ type de ligne : - – : -.linewidth=3 epaisseur des lignesmarker=’,’ type de symboles : +o,.sv<>ˆmarkeredgewidth=2 epaisseur du contour des symbolesmarkeredgecolor=’b’ couleur du contour des sympbolesmarkersize=12 taille des symbolescolor=’b’ definit la couleur (voir ci-bas)

loglog(x,y,option) Trace graphique log-logsemilogx(x,y,option) Trace graphique log-normalsemilogy(x,y,option) Trace graphique normal-logshow() Genere le graphique a l’ecranaxis([xmin,xmax,ymin,ymax] Taille physique du graphiqueaxis(’off’) Omet les echelles et les marques sur les axesaxis(’equal’) Force une echelle identique sur les deux axesaxes([xmin,xmax,ymin,ymax] limites du graphiquesavefig(’fichier.png’) Sauvegarder dans un fichierlegend(loc=’best’) location : best, upper left, center right, etc.figure(1) Prepare une figure a plusieurs sous-graphessubplot(235) Nbre de rangees, colonnes et numero du sous graphefontname=’Sans’ Police : Sans, Helvetica, Courier, Times, etc.fontweight= ’bold’ Choix : normal, bold, lightrc(’axes’,linewidth=3.0) Definit les proprietes generales du graphique

groupes axes, font, linesfont Pour le groupe ’font’ : family,weight, size

color Couleurs definies par matplotlibb bleug vertr rougec cyanm magentay jaunek noirw blanc

ioff()/ion() Arrete/relance le retracage automatiquedraw() Force le retracage


plot(x,y,label=’Courbe 1’)plot(x,z,label=’Courbe 2’)show()

En resume, on charge d’abord les donnees dans un tableau qui possede autant de colonnesque le fichier (donnees = load(’donnees.dat’)). Il suffit ensuite de traiter ces donneesdirectement dans matplotlib.

Une facon encore plus simple de tracer les donnees serait donc de travailler directementa partir du tableau :

donnees = load(’donnees.dat’)plot(donnees[:,0], donnees[:,1], label=’Courbe 1’)plot(donnees[:,0], donnees[:,2], label=’Courbe 2’)

ce qui nous sauve quand meme 3 lignes de code !De meme, si on a deux vecteurs x et y, on peut sauver ces donnees dans un fichier :

x = arange(0.0,5.0,0.3)y = x * cos(x)donnees = zeros( (len(x),2), FLoat)donnees[:,0] = xdonnees[:,1] = ysave(’sortie.dat’,donnees)

Avec ces commandes, il est tres facile de creer des graphiques a partir de donnees preexistantesvia python.

6.1.4 Utilisation interactive

On peut toutefois faire mieux dans certains cas. Un des avantages de matplotlib est qu’ilest possible d’utiliser le programme en interactif de maniere fort similaire a matlab. Pource faire, il faut utiliser ipython, qui permet de faire des graphiques sans avoir a entrer lacommande show() :

% ipython -pylabPython 2.4.3 (#1, Apr 7 2006, 10:54:33)Type "copyright", "credits" or "license" for more information.

IPython 0.7.2 -- An enhanced Interactive Python.? -> Introduction to IPython’s features.%magic -> Information about IPython’s ’magic’ % functions.help -> Python’s own help system.object? -> Details about ’object’. ?object also works, ?? prints more.

Welcome to pylab, a matplotlib-based Python environment.For more information, type ’help(pylab)’.

In [1]: d = load(’donnees.dat’)


Fig. 6.2 – Sortie du graphique ameliore. C’est un peu charge, mais cela vous donne une idee.

In [2]: plot(d[:,0],d[:,1])Out[2]: [<matplotlib.lines.Line2D instance at 0x2fed828>]

In [3]:

Voila, le graphique est fait. Les memes commandes utilisees ci-dessus s’appliquent. Pourles gens habitues a l’interface de matlab, vous pourrez constater que ipython s’approchebeaucoup de cette interface.

6.1.5 Une presentation amelioree

Les exemples presentes ci-dessus devraient vous permettre de faire la plupart des gra-phiques dont vous aurez besoin dans ce cours. Si vous voulez ameliorer la presentation d’ungraphique, il faudra aller un peu loin en modifiant le type de ligne et l’epaisseur du cadre,etc. Bien que les commandes pour le faire soient presentees dans le tableau ci-dessus, je vousdonne ci-dessous un exemple d’application de ces commandes. Ceci devrait etre suffisantpour les graphiques dont vous auriez besoin dans ce cours et les autres du baccalaureat.

La figure 6.2 montre la sortie du programme ci-dessous, qui inclut plusieurs des com-mandes decrites dans le Tableau 6.1.

1 #!/usr/bin/env python# -*- coding: utf-8 -*-

from Numeric import *5 from pylab import * # Importe l’interface

# On cree d’abord des tableaux de 100 elements chacunx1 = arange(0.0,10.0,0.1)


x2 = arange(0.0,5.0,0.05)10

y1 = sin(x1)y2 = cos(x2)

# Definit la largeur de la ligne de contour a 3 pixels15 rc(’axes’,linewidth=3)

# Couleur du fond du graphique - definie a jauneaxes(axisbg=’y’)

20 # Taille des caracteres pour les marqueursxticks(color = ’k’, size = 20)yticks(color = ’r’, size= 16)

# Definit les lignes, avec symboles egalement25 plot(x1,y1,’bo’,markersize=12,linestyle=’--’,color=’r’,linewidth=3.0)

# Titre - on voit comment traiter les accentstitle(unicode(’Graphique evolue’, ’utf-8’),color=’g’)

30 # Annotation des axesxlabel(’Axe des x’,fontsize=16)ylabel(’Axe des y’,fontsize=16,fontweight=’bold’)

# On ajoute un petit bout de texte en format mathematique.35 # matplotlib utilise le format TeX, un format standard.

text(1, -0.6, r’$\sum_{i=0}^\infty x_i$’, fontsize=20)

show()

Il y a deux points a souligner. La commande rc() et la capacite a ecrire des equations.

La commande rc()

La commande rc() permet de definir plusieurs des parametres du graphique. Elle estconstruite de la facon suivante :

rc(’groupe’,variable1=propriete, variable2=propriete)

ou le groupe peut etre les axes du graphique (axes), les fontes (font), les lignes tracees(lines) et les proprietes qui en dependent.

Pour plus d’information, tapez help(rc) apres avoir charge pylab.

Symboles mathematiques

Matplotlib integre un interpreteur TEX, un langage qui permet d’ecrire des documentscomplexes (comme celui que vous lisez presentement). Grace a cet interpreteur, vous pouvezecrire les formules mathematiques que vous desirez dans vos figures.

6.2. GRAPHIQUES ANIMES 89

Pour plus d’information a ce sujet, je vous conseille de jeter un coup d’oeil au sitehttp ://www.tuteurs.ens.fr/logiciels/latex/maths.html, qui vous donne la liste des commandesmathematiques de LATEX.

6.2 Graphiques animes

6.2.1 Un premier exemple : animation.py

Il est egalement possible d’animer pylab, c’est a dire de lui permettre d’evoluer et dechanger en reponse a un programme, par exemple ou a une touche.

Considerons le probleme suivant : on desire suivre l’evolution temporelle d’une courbe.

1 #!/usr/bin/env python# -*- coding: utf-8 -*-"""Ce programme demontre comment on peut utiliser pylab de maniere dynamique

5 """

import Tkinter as Tk # Bibliotheque graphiqueimport pylab # Bibliotheque matplotlibfrom Numeric import * # Bibliotheque numerique

10# On definit les variables globales, accessibles partout dans le programmeglobal t # Temps actuelglobal delta_t # Pas de tempsglobal retrace # Retrace le graphique a chaque retrace millisecondes

15 global temps, valeur # Vecteurs temps et valeur de fonction pour graphiqueglobal courbe, etiquette # Variables contenant les details des graphiques

############################################################################ Cette methode avance l’horloge, recalcule la fonction et retrace le tout

20 ###########################################################################def run() :

# Liste des variables globales actives dans cette methodeglobal t, retrace, etiquetteglobal valeur, temps, courbe, delta_t

25# On calcule le nouveau temps et la valeur de la fonction associeet = t + delta_tfonction = sin(t)

30 # Puis on place ces donnees dans deux tableauxtemps.append(t)valeur.append(fonction)

# Met a jour les donnees dans le tableau associe avec le graphique


35 courbe[0].set_data(temps,valeur)

# On fait de meme pour le texte et les axesetiquette.set_text(’Retrace au temps %f ’%( t ))

40 # Cette commande s’applique au graphique actuelpylab.axis([min(temps)-0.1,max(temps)+0.1,min(valeur)-0.1,max(valeur)+0.1])

# Redraws the figuremanager.canvas.draw()

45# Puis, on attend ’retrace’ ms avant de relancer runmanager.window.after(interval_temps,run)

######################################################################50 # Methode principale

######################################################################

interval_temps = 100 # Temps en millisecondes

55 # On definit les parametres du graphique; une seule figurefig = pylab.figure(1)manager = pylab.get_current_fig_manager()

# Initialise quelques variables variables60 t = 0.0

delta_t = 0.1fonction = sin(t)

# De meme que les tableaux65 temps = []

valeur = []

# Ajoute la premiere valeur a ces tableauxtemps.append(t)

70 valeur.append(fonction)

# On cree le graphiquecourbe = pylab.plot(temps,valeur)

75 # Definit le titre et xlabeltitre = pylab.title("Sinus en fonction du temps")etiquette = pylab.xlabel("Retrace %f " % (t) )

# On trace le tout80 manager.canvas.draw()


# Puis on lance la methode qui itererarun()

85 # Lancer le graphique avec show() et le maintenir actif avec mainloop.manager.show()Tk.mainloop() # Necessaire pour garder le programme actif

Explication du code

Dans la methode principale, on doit creer une premiere version de la figure

fig = pylab.figure(1)manager = pylab.get_current_fig_manager()

ainsi que le gestionnaire de la fenetre « physique », celle qui apparaıt a l’ecran. Ceci ce faitavec les commandes

manager.show()Tk.mainloop()

Ensuite, on cree des objets qui font reference aux proprietes du graphique, ce qui inclut letitre, les donnees et autres variables. C’est ce que l’on fait avec les lignes suivantes :

courbe = pylab.plot(temps,valeur)titre = pylab.title("Sinus en fonction du temps")etiquette = pylab.xlabel("Retrace %f " % (t) )

Executez ce code. Vous devriez obtenir quelque chose qui ressemble a la figure 6.3, dont lacourbe evolue dans le temps.

Plus en details, les objets courbe, titre et etiquette possedent des methodes predefiniesqui permettent de modifier leurs valeurs sans avoir a recreer un nouveau graphique. C’estcomme ca que la methode run procede.

Apres voir ajoute un element aux tableaux x et y, on met a jour les variables. Toutd’abord, les donnees :

courbe[0].set_data(temps,valeur)

L’objet courbe contient plusieurs elements. Dans ce cas-ci, on veut modifier les donnees, quise trouvent emmagasinees dans le premiere element (element zero) de la liste.

Ensuite, on change le texte de l’etiquette, afin d’afficher le temps actuel et on met a jourles limites du graphique en se basant sur les valeurs maximales et minimales en x et y.

etiquette.set_text(’Retrace au temps %f ’%( t ))pylab.axis([min(temps)-0.1,max(temps)+0.1,min(valeur)-0.1,max(valeur)+0.1])

Apres avoir mis a jour le graphique, on l’affiche puis on relance la procedure avec lacommande

manager.window.after(interval_temps,run)


Fig. 6.3 – Instantane de l’animation de la courbe de sinus realise par le programme anima-tion.py.

6.2.2 Deux graphiques - deplacement sur un cercle

Il est possible de faire mieux. On decrit le deplacement d’une particule sur un cercle etla valeur de la position en x au carre en fonction du temps.

Parce qu’on doit maintenant gerer deux graphiques dans une meme fenetre, il faut gererles differentes variables avec un peu plus de soin. Dans le cas precedent, il n’y avait pas dedanger de confusion pour python, ici oui.

Voyons d’abord le code. On en discutera les nouveautes apres.

1 #!/usr/bin/env python# -*- coding: utf-8 -*-"""Tracage de deux graphiques sur la meme fenetre

5 """


10# Variables globales, accessibles partout dans le programmeglobal t # Temps actuelglobal delta_t # Pas de tempsglobal retrace # Itere a chaque millisecondes

15 global x, y # Vecteurs positionglobal temps, cos_carre # Vecteurs temps et ’cos_carre’


# Variables qui contiennent tous les details des tracesglobal trajectoire, cinetique

20 global sousgraphe # Objets associes avec les sous-figures

########################################################################## Cette methode avance l’horloge, recalcule la fonction et retrace le tout#########################################################################

25 def run() :global t # Comme t apparaıt a gauche et a droite dans la meme equation

# on doit confirmer que

# On calcule le nouveau temps et la valeur de la fonction associee30 t = t + delta_t

x.append( cos(t) )y.append( sin(t) )temps.append(t)

35 cos_carre.append (cos(t) * cos(t))

# Met a jour les donnees dans le tableau associe avec le graphiquetrajectoire[0].set_data(x,y)cinetique[0].set_data(temps,cos_carre)

40# On fait de meme l’affichage du tempssousgraphe[1].set_xlabel(’Retrace au temps %f ’%( t ))

# et de la taille du graphique cos_carre vs temps45 sousgraphe[1].set_xlim((min(temps)-0.1,max(temps)+0.1))

sousgraphe[1].set_ylim((min(cos_carre)-0.1,max(cos_carre)+0.1))

# On force la mise a jour du graphique sur l’ecranmanager.canvas.draw()

50# Puis, on attend ’retrace’ ms avant de relancer runmanager.window.after(retrace,run)

######################################################################55 # Methode principale

######################################################################

retrace = 100 # Temps en millisecondes

60 # Initialise quelques variablest = 0.0delta_t = 0.1


fonction = sin(t)

65 # De meme que les tableauxx = []y = []temps = []cos_carre = []

70# Ajoute la premiere valeur a ces tableauxx.append( cos(t) )y.append( sin(t) )temps.append(t)


# On definit les parametres du graphique; une seule figurefig = pylab.figure(1,figsize=(4,8))manager = pylab.get_current_fig_manager()

80# On aura deux sous-graphessousgraphe = []

# On cree le premier graphique pour avoir un carre, on definit la taille85 # manuellement - on definit le fond en noir

sousgraphe.append(pylab.axes([0.1,0.55,0.8,0.4],axisbg=’k’))pylab.setp(sousgraphe[0],xticks=[],yticks=[])trajectoire = pylab.plot(x,y,’bo’,markersize=12)sousgraphe[0].set_xlim((-1.1,1.1))

90 sousgraphe[0].set_ylim((-1.1,1.1))

# On cree le deuxieme graphique, comme sa forme n’est pas critique, on peut# utiliser la commande subplotsousgraphe.append(pylab.subplot(212))

95 cinetique = pylab.plot(temps,cos_carre)

sousgraphe[0].set_title(unicode("Deplacement sur un cercle",’utf8’))sousgraphe[1].set_xlabel("Retrace %f " % (t) )

100 # On trace le toutmanager.canvas.draw()


105# Lance le graphique avec show() et maintient le tout actif avec mainloop.manager.show()Tk.mainloop()

6.3. INTERFACE INTERACTIVE 95

La structure est presque identique au programme pour un seul graphique. La principaledifference est qu’on doit gerer les deux graphiques separement. Ainsi plutot que d’utiliserla fonction pylab.axis(), qui ne peut pas etre exprimer comme objet, on doit utiliser lesmethodes set xlim et set ylim qui sont des methodes associees avec les graphiques.

6.3 Interface interactive

Pour avoir tous les outils dont on a besoin pour le cours, il ne reste plus qu’a ajouterun peu d’interactivite dans le programme. Dans cet exemple, nous utilisons une interactionlimitee : on arrete le programme en appuyant sur la touch a.

Pour ce faire, il faut introduire un moniteur, qui suit ce qui se passe au clavier et a lasouris et reagit en consequence.

On place tout d’abord la commande connect juste apres le premier trace du graphique

...# On trace le toutmanager.canvas.draw()

# On ajoute un moniteur qui attend l’evenement - lorsqu’une cle est pressee# le programme appelle ’action_clavier’pylab.connect(’key_press_event’,action_clavier)


# Lancer le graphique avec show() et maintient le tout actif avec mainloop.manager.show()Tk.mainloop()

Dans ce cas-ci, on veut permettre a tout moment l’arret des iterations sur le temps enappuyant sur la touche « s ». Pour ce faire, on doit ajouter une variable, qu’on appelle etatqui peut avoir deux valeurs marche ou arret.

Cette variable est initialisee dans la methode principale

...####################################################################### Methode principale######################################################################

etat = ’marche’interval_temps = 100 # Temps en millisecondes...

et utilisee pour relancer run

# Puis, on attend ’interval_temps’ ms avant de relancer runif etat is ’marche’ :



Puis on ajoute une methode qui s’appelle action_clavier et qui peut modifier la valeurde la variable etat si on presse la touche « a » :

######################################################################### Methode action_clavier - repond a l’activation d’une touche du clavier########################################################################def action_clavier(event) :

global etatif event.key is ’a’ : # On arrete la simulation

etat = ’arret’

C’est aussi simple que cela !Voici ce que ca donne au complet :

1 #!/usr/bin/env python# -*- coding: utf-8 -*-

"""5 Ce programme demontre comment on peut utiliser pylab de maniere dynamique

"""

import Tkinter as Tk # Bibliotheque graphique10 import pylab # Bibliotheque matplotlib

from Numeric import * # Bibliotheque numerique

# Variables globales, accessibles partout dans le programmeglobal t # Temps actuel

15 global delta_t # Pas de tempsglobal retrace # On retrace a chaque retrace millisecondesglobal x, y, temps, cos_carre # Vecteurs position, temps et ’energie’global trajectoire,cinetique, etiquette # Details des tracesglobal graphe,sousgraphe # Objet figure

20 global etat # Etat de la simulation - marche ou arret

########################################################################### Cette methode avance l’horloge, recalcule la fonction et retrace le tout##########################################################################

25 def run() :# Variables globales sont actives dans cette methodeglobal t, etat

# On calcule le nouveau temps et la valeur de la fonction associee30 t = t + delta_t

x.append( cos(t) )y.append( sin(t) )

6.3. INTERFACE INTERACTIVE 97

temps.append(t)35 cos_carre.append (cos(t) * cos(t))

# Met a jour les donnees dans le tableau associe avec le graphiquetrajectoire[0].set_data(x,y)cinetique[0].set_data(temps,cos_carre)

40# On fait de meme l’affichage du tempssousgraphe[1].set_xlabel(’Retrace au temps %f ’%( t ))

# et de la taille du graphique cos_carre vs temps45 sousgraphe[1].set_xlim((min(temps)-0.1,max(temps)+0.1))

sousgraphe[1].set_ylim((min(cos_carre)-0.1,max(cos_carre)+0.1))


50# Puis, on attend ’interval_temps’ ms avant de relancer runif etat is ’marche’ :


55 ######################################################################### Methode action_clavier - repond a l’activation d’une touche du clavier########################################################################def action_clavier(event) :

global etat60 if event.key is ’a’ : # On arrete la simulation

etat = ’arret’

####################################################################### Methode principale

65 ######################################################################

etat = ’marche’interval_temps = 100 # Temps en millisecondes

70 # Initialise quelques variablest = 0.0delta_t = 0.1fonction = sin(t)










# On cree le deuxieme graphique, comme sa forme n’est pas critique, on peut# utiliser la commande subplotsousgraphe.append(pylab.subplot(212))


sousgraphe[0].set_title(unicode("Deplacement sur un cercle",’utf-8’))sousgraphe[1].set_xlabel("Retrace %f " % (t) )


# On ajoute un moniteur qui attend l’evenement - lorsqu’une cle est pressee# le programme appelle ’action_clavier’

115 pylab.connect(’key_press_event’,action_clavier)


120 # Lance le graphique avec show() et maintient le tout actif avec mainloop.manager.show()Tk.mainloop()

On aurait pu utiliser le clic de la souris ou une autre lettre, par exemple. Par exemple,pour le clic de la souris, le moniteur enregistre la positon de la souris au moment du clic.

6.4. PYLABGUI (INTERFACE GRAPHIQUE) 99

Tab. 6.2 – Types d’evenements qui sont surveilles par le moniteur interactif dans matplotlib

Moniteur Declenche lorsqu’onbutton press event presse la sourisbutton release event relache le boutonmotion notify event deplace la souriskey press event presse le clavierkey release event relache la cle

Tab. 6.3 – Proprietes associees avec les declencheurs d’activite.

Propriete Description Valeurx Position en x nombre de pixels a partir de la gauchey Position en y nombre de pixels a partir du basbutton Le bouton de la souris active None, 1, 2 ou 3inaxes axes sous le curseur de la souris None ou axexdata coordonnee en x du graphique None si souris n’est pas sur axeydata coordonnee en y du graphique None si souris n’est pas sur axename Nom de l’evenement Chaıne de caracterescanvas Instance de la figure activee (si plusieurs) pointeurkey Cle activee lettre ainsi que majuscule et controle

Cette position peut etre utilisee pour manipuler le graphique, par exemple.

# Cette fonction est appelee a chaque clic de la sourisdef clic(evenement) :

print ’Vous avez clique a la position: ’, evenement.x, evenement.y

# Moniteur d’activitemoniteur = connect(’button_press_event’, clic)

Comme on le voit, le premier argument de connect() indique le type d’evenement asurveiller tandis que le second est le nom de la methode qui sera appelee lorsqu’un evenementdu bon type se produira. Les tableaux 6.2 et6.3 decrivent les divers parametres qui peuventetre utilises interactivement.

6.4 pylabgui (interface graphique)

Si la section precedente ouvre les portes a une interface graphique interactive, celle-cietait tres limitee et un peu obscure. Apres tout, il faut se rappeler la bonne touche afind’arreter le programme.

Heureusement, matplotlib possede une bibliotheque d’objets interactifs qui permettentde construire facilement une interface graphique relativement conviviale. Le programme qui


suit construit une interface graphique avec 3 boutons et une barre de defilement tel quemontre dans la Figure 6.4.

Jetez un coup d’oeil au programme. Nous le discuterons pas la suite.

1 #!/usr/bin/env python# -*- coding: utf-8 -*-"""Ce programme demontre comment on peut utiliser pylab de maniere dynamique

5 """


10 from matplotlib.widgets import Slider, Button, RadioButtons

# Variables globales, accessibles partout dans le programmeglobal t # Temps actuelglobal delta_t # Pas de temps

15 global retrace # On retrace le graphiqueglobal x, y, temps, cos_carre # Vecteurs position, temps et ’energie’global trajectoire,cinetique, etiquette # Variables des tracesglobal graphe,sousgraphe # Objet figureglobal etat # Etat de la simulation - marche ou arret

20########################################################################### Cette methode avance l’horloge, recalcule la fonction et retrace le tout##########################################################################def run() :

25 # Variables globales sont actives dans cette methodeglobal t, etat

# On calcule le nouveau temps et la valeur de la fonction associeet = t + delta_t

30x.append( cos(t) )y.append( sin(t) )temps.append(t)cos_carre.append (cos(t) * cos(t))

35# Met a jour les donnees dans le tableau associe avec le graphiquetrajectoire[0].set_data(x,y)cinetique[0].set_data(temps,cos_carre)

40 # On fait de meme l’affichage du tempssousgraphe[1].set_xlabel(’Retrace au temps %f ’%( t ))


Fig. 6.4 – Image de pylab avec une interface graphique qui inclut trois boutons et une barrede defilement.


# et de la taille du graphique cos_carre vs tempssousgraphe[1].set_xlim((min(temps)-0.1,max(temps)+0.1))

45 sousgraphe[1].set_ylim((min(cos_carre)-0.1,max(cos_carre)+0.1))


50 # Puis, on attend ’interval_temps’ ms avant de relancer runif etat is ’marche’ :


########################################################################55 # Methodes associees avec l’interface graphique

########################################################################

def mise_a_jour(val): # Mise a jour, on passe la position du curseurglobal delta_t

60 delta_t = val # Cette position redefinit le pas

def arreter(clic) : # On change l’etat afin d’arreter la simulationglobal etatetat = ’arret’

65def lancer(clic) : # On lance la simulation

global etatetat = ’marche’ # Redefinit l’etatrun() # Puis lance la simulation

70def initial(clic) : # Reinitialise les vecteurs ainsi que le temps

global t, x, y, temps, cos_carre, etat

t = 0.075 x = []

y = []temps = []cos_carre = []if etat == ’arret’ : # Puis on relance la simulation, si elle est arretee

80 etat = ’marche’run()

####################################################################### Methode principale

85 ######################################################################

etat = ’marche’interval_temps = 100 # Temps en millisecondes


90 # Initialise quelques variablest = 0.0delta_t = 0.1fonction = sin(t)









# On cree le deuxieme graphique, comme sa forme n’est pas critique, on peut# utiliser la commande subplotsousgraphe.append(pylab.axes([0.1,0.15,0.8,0.35]))


sousgraphe[0].set_title(unicode("Deplacement sur un cercle",’utf-8’))sousgraphe[1].set_xlabel("Retrace %f " % (t) )


############################################################################### Interface graphique


135# Ajoute une barre de defilement, qui permet d’ajuster la ’vitesse’

# (1) On definit la positionaxevitesse = pylab.axes([0.2,0.05,0.6,0.03],axisbg=’lightgoldenrodyellow’)

140# (2) On cree une barre de defilementsvit = Slider(axevitesse,’Vitesse’,0.1,30.0,valinit=2.0)

# (3) Puis on relie la barre a une action - une methode (ici: mise_a_jour)145 svit.on_changed(mise_a_jour)

# Meme chose pour 3 boutons, qui permettent de relancer, d’initialiser# et d’arreter la simulationaxebouton1 = pylab.axes([0.2,0.02,0.2,0.03])

150 blancer = Button(axebouton1,label=’Lancer’,color=’green’)blancer.on_clicked(lancer)

axebouton2 = pylab.axes([0.4,0.02,0.2,0.03])barreter = Button(axebouton2,label=’Arreter’,color=’red’)

155 barreter.on_clicked(arreter)

axebouton3 = pylab.axes([0.6,0.02,0.2,0.03])binitial = Button(axebouton3,label=’Initial’,color=’lightgoldenrodyellow’)binitial.on_clicked(initial)

160# fin de l’interface graphique##############################################################################

# Lancer le graphique avec show() et maintenir le tout actif avec mainloop.165 manager.show()

Tk.mainloop()

Ici, nous avons clarifie les interactions entre l’utilisateur et le graphique en ajoutant uneinterface d’utilisation graphique. L’utilisateur n’a donc pas besoin de se rappeler des lettresa taper, par exemple, il lui suffit de cliquer sur le bon bouton ou de faire glisser le curseurdans la barre de defilement. Cette approche simplifie enormement l’utilisation du programmepour un non-initie.

La liste des objets utiles pour la construction d’une interface graphique est donnee dansle Tableau 6.4. On y retrouve des boutons et des barres de defilement. Ne manque que lesgestionnaires de texte. Si vous en avez besoin, il faudra utiliser Tkinter qui est decrit dansle chapitre suivant.

Button(axes[gauche,bas,largeur,hauteur], label=’Titre’[, options]). Matplotlib laissetoute la liberte au programmeur pour placer son bouton. Il suffit donc de definir le rec-tangle dans lequel on placera le bouton, a l’aide de la meme commande que celle utiliseepour definir la taille des graphique.


Tab. 6.4 – Liste des objets d’interface graphique disponibles dans la bibliothequematplotlib.widgets.Objet DescriptionButton Genere un bouton qui appelle une methode lorsque active.CheckButtons Permet de creer une liste pre-definie.RadioButtons Offre un choix d’options.Slider Barre qui permet une selection d’une variable continue.SubplotTool Permet d’introduire un graphique dans un autre.

Les options sont les suivantes, elles doivent etre passees au moment de la creation.

color= ’black’ couleur du boutonhovercolor= ’red’ couleur du bouton lorsque la souris passe par-dessusimage= ’toto.jpg’ image sur le bouton

Une fois que le bouton est cree, il faut lui dire quelle methode appeler. Cela se fait avecla methode on clicked().

CheckButtons(axes[gauche,bas,largeur,hauteur], labels=[t1,t2],actives=[False,True]).Il s’agit ici de creer une liste d’options qui sont dans un de deux etats possible. Commepour Button, on doit ajouter une methode on clicked() qui contient le nom de lamethode qui doit etre activee lorsque la liste est modifiee.Il est important de se rappeler des options initiales car c’est le bouton dont l’etat estchange qui est passe et non son etat.Par exemple

ax = axes([0.1,0.1,0.2,0.3])b = CheckButtons(ax,labels=[’Positions’,’Vitesses’],actives=[True,False])b.on_clicked(choix_courbes)

On cree donc deux champs, Positions et Vitesses. Nous avons fixe au debut la premiereoption comme vraie et la deuxieme comme fausse. Si on change les selections, lamethode choix courbes().Cette methode pourrait avoir le contenu suivant :

etat_positions = True # On doit noter l’etat initial des selectionsetat_vitesses = False

def choix_courbes(choix)# Les deux lignes suivantes echangent True -> False et vice-versaif choix == ’Positions’ : etat_positions = not etat_positionselif choix == ’Vitesses’ : etat_vitesses = not etat_vitesses

On peut ainsi utiliser cette interface graphique pour indiquer quel jeu de donnees ontrace a l’ecran (tire des exemples du site de matplolib).

1 from pylab import *from matplotlib.widgets import CheckButtons

# Genere les donnees


5 t = arange(0.0, 2.0, 0.01)s0 = sin(2*pi*t)s1 = sin(4*pi*t)s2 = sin(6*pi*t)

10 # Prepare 3 jeux de donnees. Le premier est invisible, les deux autres sont traces.ax = subplot(111)l0, = ax.plot(t, s0, visible=False, lw=2)l1, = ax.plot(t, s1, lw=2)l2, = ax.plot(t, s2, lw=2)

15 subplots_adjust(left=0.2) # Laisse 20 % de l’image a droite libre

# On prepare les boutonsrax = axes([0.05, 0.4, 0.1, 0.15])check = CheckButtons(rax, (’2 Hz’, ’4 Hz’, ’6 Hz’), (False, True, True))

20# On cree la methodedef choix_courbe(label):

print labelif label==’2 Hz’: l0.set_visible(not l0.get_visible())

25 elif label==’4 Hz’: l1.set_visible(not l1.get_visible())elif label==’6 Hz’: l2.set_visible(not l2.get_visible())draw()

# Et on assigne une methode aux boutons.30 check.on_clicked(choix_courbe)

show()

RadioButtons(axes[g,b,l,h], labels=[t1,t2], active=0, activecolor=’blue’). Similara CheckButtons() sauf qu’ici il ne peux y avoir qu’une seule option active.On doit egalement utiliser on clicked() pour indiquer la methode a activer.

Slider(axes[g,b,l,h],label,valmin,valmax,valfmt,options) Cette option permet de creerune barre de defilement. Les options sont assez nombreuses. Les principales sont lessuivantes - pour plus d’information, voir help(Slider).

Option Descriptionlabel=’t1’ Nom de la variable associee avec la barrevalmin=2.0 Valeur minimal de la barrevalmax=5.0 Valeur maximal de la barrevalinit=2.5 Valeur initiale de la variablevalfmt=’%1.2f’ Format d’affichage de la valeur de la variable

L’activation des changements se fait, dans le programme, avec la commande on changed().Deux autres methodes sont egalement utiles :reset(self) Remet la valeur de la barre a la valeur a l’origine ;set val(self,valeur) Change la valeur de la variable dans le programme.

Chapitre 7

Graphiques et interfaces graphiques

Un des avantages de Python est du au fait qu’il existe des interfaces lui permettantd’acceder a des objets graphiques portables sur la plupart des plates-formes informatiques.Dans ce cas, les bibliotheques graphiques se charge de l’interface avec le systeme grpahiquelocal, permettant au programmeur d’ignorer completement les details de la gestion parti-culiere des graphiques. En C/C++ et Fortran, il existe bien des bibliotheques graphiquesmais celles-ci ne fonctionnent que sur des environnements bien definis. Les logiciels graphiquesecrits avec ces fonctions ne sont donc pas transferables.

Il existe plusieurs bibliotheques graphiques pour python. Celle que nous privilegions estappelee Tk et l’interface Tkinter. Elle est la plus utilisee presentement. Elle possede egalementl’avantage d’etre installee automatiquement avec python, ce qui simplifie la vie.

Avant de nous lancer dans la preparation d’interfaces graphiques, nous verrons commenttracer de simples courbes avec le programme gnuplot. Ce programme est utilise pour lapreparation de graphiques professionnelles et est disponible sur toutes les plateformes. Gracea une interface entre gnuplot et python, on peut appeler ce programme directement depython.

7.1 Installation de gnuplot

Il faut travailler un petit peu pour installer le programme Gnuplot et l’utilitaire gnu-plot.py. Teledechargez d’abord les deux paquetages et extrayez en le contenu.

La premiere etape consiste a installer Gnuplot.py. Pour ce faire, copiez d’abord le repertoiregnuplot-py-1.7 directement dans le repertoire principal de python (C:\Python23).

Lancez l’invite de commandes qui se trouve dans le repertoire Accessoires. Deplacez-vousjusque dans le repertoire ou se trouvent les fichiers de gnuplot.py

C:\utilisateur\mousseau> cd \C:\> cd Python23\gnuplot-py-1.7

puis tapez

C:\Python23\gnuplot-py-1.7> ..\python setup.py install

Une fois ceci fait, il ne reste plus qu’a installer le programme gnuplot comme tel. Ou-vrez d’abord le fichier gp400win32.zip a l’aide de l’utilitaire gzip, puis copiez les fichierspgnuplot.exe et wgnuplot.exe dans le repertoire C:\Python23.

107

108 CHAPITRE 7. GRAPHIQUES ET INTERFACES GRAPHIQUES

Tab. 7.1 – Liens vers gnuplot et gnuplot.py

Programme Version AdresseGnuplot 4.0 http://sourceforge.net/projects/gnuplotGnuplot.py 1.7 http://sourceforge.net/projects/gnuplot-py/

Vous etes maintenant fin pret(e) pour commencer le cours.

7.1.1 Test de Gnuplot sur Windows

Finalement, verifions que Gnuplot est bien installe.

>>> From Numeric import *>>> import Gnuplot>>> g = Gnuplot.Gnuplot()>>> g.title("Un essai de graphique")>>> x = arange(10,typecode=Float)>>> y = sin(x)>>> d = Gnuplot.Data(x,y)>>> g.plot(d)

Ouf. Avec ca, vous devriez avoir un graphique a l’ecran.

Felicitations ! python et tous ses outils sont maintenant installes !

7.2 Executer python sur un environnement Unix ou Linux

Une version compilee de python est disponible pour tous les systemes d’operation Unix/Linux.Ceci inclut les systemes d’operation de Sun, Silicon Graphics, IBM, Dec/Compaq et Linux.En fait, python est deja installe sur la plupart de ces machines. Vous pouvez vous assurez quela version deja installee est au moins la version 2.0. Pour ce faire, entrez python a l’invite. Lapremiere ligne indique la version du language. Pour mettre a jour, suivez les instructions quevous trouverez sur le site www.python.org ; dans plusieurs cas, vous pourrez teledechargerune version deja compilee qui inclut egalement l’outil de developpement idle.

Pour les ordinateurs roulant sous Linux, vous pouvez soit teledecharger un rpm dejacompile ou le fichier source.tar.gz. Une fois le fichier recupere sur votre machine, ouvrezle fichier comprime avec la commande

tar xzf python*tar.gz

et suivez les instructions contenues dans les fichiers README.Vous devrez egalement installer trois autres programmes : Numeric, Gnuplot et Gnuplot.py.

Ces programmes sont essentiels pour manipuler les tableaux et faire des graphiques. Ontrouve ces programmes a leur adresse indiquee ci-haut.

7.3. GNUPLOT ET GNUPLOT.PY 109

7.3 Gnuplot et gnuplot.py

Il est souvent plus facile de comprendre les donnees en les tracant plutot qu’en etudiantla liste de chiffres qui defilent a l’ecran. Pour la plupart de langages de programmation, il estnecessaire de sauver les donnees separement afin de les analyser dans un autre programme.

Python dispose d’une interface qui permet d’interagir directement avec un programme detracage tres puissant : gnuplot (www.gnuplot.info), Cette interface est deja installee sur lesordinateurs de esibac. Les programmes necessaires a l’installation sur les machines roulantWindows sont sur le disque distribue au debut du cours.

7.3.1 Utilisation de gnuplot.py

On import la bibliotheque avec la commande

>>> import Gnuplot

(N’oubliez pas la majuscule, qui est essentielle.)On doit ensuite lancer une session :

>>> g = Gnuplot.Gnuplot()>>> g.title(’Un titre’) # Optionnel

On peut meme passer toutes les commandes de gnuplot, a l’aide de la commande g().

>>> g(’set data style linespoints’) # trace points + ligne

La maniere la plus simple est de passer une serie de paires de coordonnees. Evidemment, onn’utilise jamais cette approche lorsqu’on a un grand nombre de points a tracer.

>>> g.plot([[0,1.1], [1,5.8], [2,3.3], [3,4.2]])>>> raw_input(’Tapez « Retour » pour continuer.’)

Si on veut recommencer, on n’a qu’a faire une remise a zero :

>>> g.reset() # On efface tout et on recommence

Comme on l’a mentionne ci-haut, la maniere la plus habituelle de tracer un graphique estd’envoyer deux vecteurs, un pour x et un pour y :

>>> from Numeric import * # on a besoin de Numeric>>> x = arange(10,typecode=Float)>>> x # On a cree un vecteur de type floatarray([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])>>> y1 = sin(x) # Et un vecteur de meme longueur pour y

# On peut tracer le graphique d’un coup>>> g.plot(Gnuplot.Data(x,y1, title=’Une legende dans le graphique’,... with= ’lines’))

# Ou en deux etapes>>> d= Gnuplot.Data(x,y1, title=’sinus’, with =’lines’)


Tab. 7.2 – Commandes de gnuplot.pyCommande Descriptiong= Gnuplot.Gnuplot() Cree un nouveau graphique, appele gg.reset() Efface tout et on recommenceg.replot() Met a jour le graphiqueg.title(’titre’) Definit le titre du graphiqueg.xlabel(’x’) Definit l’etiquette de l’axe des xg.ylabel(’y’) Definit l’etiquette de l’axe des yg.plot(Gnuplot.Data(...)) Trace un graphique a partir d’une structure de donneesd=Gnuplot.Data(x,y,opt.) Definit une structure de donnees

x,y vecteurs de type array de longueur ntitle=’xx’ legende associee avec la courbewith =’yyy’ type de graphique — points, line,linespointswith =’points pt 6 ps 2.0’ Symboles de type 6 et de taille 2.0with =’lines lw 2.0’ Lignes de largeur 2.0

g(’set ....’) Passe une commande generique a gnuplotset xrange [xmin :xmax] limits du graphique en xset yrange [ymin :ymax] limits du graphique en yset linewidth lw Definit la largeur du cadre (lw est un nombre)set logscale x|y|xy Echelle logarithmique

g.harcopy(’test.ps’,options) Imprime dans un fichier en format postscriptenhanced=1 Utilise un postscript plus modernecolor=1 Imprime en color

>>> g.plot(d)

# Ce qui peut etre tres utile lorsqu’on a plusieurs courbes a tracer>>> g.reset()>>> y2 = cos(x) # Genere une autre jeu de donnees et une autre courbe>>> f = Gnuplot.Data(x,y2,title=’cosinus’, with=’lines’)>>> g.plot(d,f) # On trace le tout

Ajoutons des etiquettes aux axes des x et des y

>>> g.xlabel(’axe des x’)>>> g.ylabel(’axe des y’)>>> g.replot() # Et on retrace le graphique

Pour imprimer, rien de plus facile. D’abord, on sauve le graphique dans un fichier post-script. L’option enhanced permet d’imprimer des lettres grecques, des indices et des expo-sants, tandis que color=1 permet la couleur.

>>> g.hardcopy(’test.ps’,enhanced=1,color=1)

Voila, notre premier graphique est pret a etre envoye a l’impression.Voici un exemple d’un fichier graphique

7.3. GNUPLOT ET GNUPLOT.PY 111

1 # Ce programme trace un graphique via l’interface Gnuplot et du2 # programme gnuplot34 from Numeric import *5 import Gnuplot # Necessaire pour le graphique67 # On cree d’abord les tableaux de donnees89 x = zeros([100],Float)

1011 for i in range(100) :12 x[i] = i * pi / 30.01314 y1 = sin(x) # Operations vectorielles15 y2 = cos(x)1617 # On instancie maintenant un objet graphique g18 g = Gnuplot.Gnuplot()1920 g.xlabel("x")21 g.ylabel("Amplitude")22 g.title("Graphique de sin(x) et cos(x)")2324 # On definit les jeux de donnees25 d1 = Gnuplot.Data(x,y1,with="lines", title="sin(x)")26 d2 = Gnuplot.Data(x,y2,with="linespoints", title="cos(x)")2728 # Et on ajoute les graphiques29 g.plot(d1)30 g.replot(d2)3132 # On aurait egalement pu utiliser une seule commande33 # g.plot(d1,d2)3435 print(’Graphique initial’)36 raw_input(’Tapez « Retour » pour continuer.’)3738 # On modifie maitenant les limites du graphique39 # la commande min(x) retourne la valeur minimal du vecteur x,40 # max retourne la valeur maximale, bien entendu...41 g(’set xrange [%f:%f]’ % (min(x),max(x)))42 g.replot() # Et on retrace la figure4344 # Finalement, on sauve le graphique en format postscript45 # Les deux commandes suivantes ne sont pas indispensables46 g("set term postscript portrait") # graphique en orientation portrait


47 g("set size square") # graphique est carre48 g.hardcopy(’premgraph.eps’,enhanced=1,color=1)4950 print("Re-trace avec de nouvelles limites le long de l’axe des x")51 raw_input(’Tapez « Retour » pour continuer.’)

7.4 Graphiques Tkinter

Python ne dispose pas comme tel d’outils graphiques. Les programmeurs ont toutefoisdeveloppe des interfaces avec plusieurs bibliotheques graphiques telles que Tk, Java et Win...pour ce langage.

Afin de ne pas compliquer inutilement votre tache, nous nous concentrerons sur une seuleinterface, Tkinter, qui est l’outil graphique le plus utilise dans la communaute.

La preparation de graphiques impose une utilisation d’objets graphiques et, partant, uneprogrammation orientee objet, telle que decrite au chapitre precedent.

7.4.1 Cadres

Tkinter gere les graphiques de la maniere suivante : un cadre est cree, ce cadre a unebordure, il peut etre rapetisse ou agrandi, etc. C’est l’objet que vous voyez sur votre ecran.Le cadre peut etre vide ou rempli de contenants. Chacun de ces contenants peut, a son tour,contenir des objets graphiques tels que des rectangles, ellipses, lignes, listes, menus, boutonsou simplement du textes.

On peut donc changer le contenu du cadre sans affecter le cadre.L’exemple ci-dessous donne un idee de comment on peut creer un objet graphique et l’af-

ficher a l’ecran. Dans PremGraph, le programme gnuplot gere lui-meme l’interface graphique.Ici, nous construisons nous-meme tous les objets graphiques.

Note : L’origine du cadre (0, 0) est situee dans le coin gauche superieur !

1 """2 testTkinter.py :34 Ce programme cree un nouveau cadre et le remplit avec une ellipse5 rouge et quelques autres objets graphiques a l’aide de Tkinter.67 Cree le 13 mai 20038 Normand Mousseau9 """

10 from Tkinter import *1112 # La classe dessin est une sous-classe de Canvas. Elle possede donc13 # toutes les proprietes de Canvas en plus de celles definies ci-dessous14 class Dessin(Canvas):15 # La classe dessin construit les objets graphiques et les ajoute16 # au cadre

7.4. GRAPHIQUES TKINTER 113

1718 def trace(self) :19 self.delete("all") # Efface le contenu precedent du canevas20 # Ajoute une ellipse rouge avec une bordure noire21 # Les coordonnees sont x0,y0,x1,y122 self.create_oval(100,50,350,275, fill=’red’)2324 # Ajoute une ellipse orange sans bordure (width=largeurDeLaBordure)25 self.create_oval(200,150,275,375, fill=’orange’,width=0)2627 # Ajoute un carre avec seulement une bordure bleue28 self.create_rectangle(25,275,125,375,outline=’blue’,width=10.0)2930 # Et une ligne verte, de largeur 5 pixels (x0,y0,x1,y1,x2,y2)31 self.create_line(10,10, 150,390,395,200, width=5.0,fill="green")3233 # Finalement, on ajoute un peu de texte34 self.create_text(20,235, # Position35 font=("Geneva",21), # Type de fonte36 text="La terre est bleue comme une orange",37 anchor="w") # On debut le texte en 20,235 ("west")3839 #######################################################################40 # Debut de la classe principale41 #######################################################################42 fenetre = Tk() # Instancie un objet Tk4344 # Definition du canevas - largeur, hauteur (en pixels) et couleur du45 # fond - qui definit aussi la fenetre4647 # dessin est une sous-classe de Canvas, definit par Tkinter48 canevas = Dessin(fenetre, width=400, height=400, background=’yellow’)49 canevas.trace()5051 canevas.pack(expand=YES,fill=BOTH) # On place le tout dans le canevas5253 fenetre.mainloop() # Cette commande garde la figure a l’ecran

7.4.2 Les elements essentiels

Avec Tkinter, on peut ecrire un programme graphique en 4 lignes seulement.

from Tkinter import *

racine = Tk()racine.etiquette = Label(text="Ceci est un exemple tres simple")racine.etiquette.pack()


racine.mainloop()

Regardons de plus pres ces commandes. On importe d’abord les objets definis par Tkinte :

from Tkinter import *

puis on cree une instance d’un objet graphique Tk :

racine = Tk()

On cree ensuite un objet graphique. Label est un objet, une classe. Elle possede pluseursproprietes. Nous n’en definissons qu’une ici, son contenu.

racine.etiquette = Label(text="Ceci est un exemple tres simple")

Il s’agit maitenant de placer le tout dans la fenetre. Pack est une commande qui place l’objetdans une cadre de dimension appropriee.

racine.etiquette.pack()

Il ne reste plus qu’a conserver la fenetre ouverte, avec la commande

racine.mainloop()

7.4.3 Objet graphique Canvas

Une des superclasses de Tkinter les plus utiles est Canvas. Cet objet graphique sert detoile de fond sur laquelle on peut placer toutes sortes d’objets geometriques tels que deslignes, des cercles, des rectangles, etc.

Lignes

On peut facilement creer une ligne avec Tkinter.

create_line(x0,y0,x1,y1,...,xn,yn, *options)

ou les options sont les suivantes :arrow=NONE—FIRST—LAST—BOTH Place une fleche a un des deux bouts (ou les

deux) de la ligne (defaut=NONE).arrowshape=forme Definit la forme de la fleche par un uplet de trois elements donnant

la longueur du corps de la fleche, la longueur des branches et la largeur [defaut =(8,10,3)].

fill=couleur Couleur de la ligne (defaut=”black”).witdh=largeur Largeur de la ligne en pixels.tags=etiquettes Etiquettes assignees a chaque segment.smooth=booleen Indique si la ligne devrait etre tracee comme une courbe, en utilisant

une methode de spline (defaut=FALSE)splinesteps=entier Definit le degree de lissge desire pour les courbes. Cet option est

ignoree a moins que smooth=true (defaut=12).

create_line(30, 90, 150, 345,arrow=FIRST,fill="blue",tags="ligne1")

Plusieurs couleurs sont deja definies par Python. On en mentionne quelques-unes autableau 7.4.3.

7.4. GRAPHIQUES TKINTER 115

Tab. 7.3 – Quelques-unes des couleurs pre-definies par python

black green pink orangeblue lightGray red darkGraycyan magenta white yellow

Autres formes geometriques

La classe Canvas definit aussi plusieurs formes geometriques qui partagent toutes lesmemes options.

Rectangles : On positionne le rectangle a partir du coin en haut a droit.

create_rectangle(x0,y0,x1,y1,*options)

Les options ci-dessous sont valides pour les rectangles, les ellipses et les arcs de cercleou d’ellipse.

fill=couleur Couleur de l’interieur du polygone (defaut=transparent)

outline=couleur Couleur du pourtour du polygone (defaut=”black”)

witdh=largeur Largeur de la ligne en pixels.

tags=etiquettes Etiquettes assignees a chaque segment.

Ellipses : La position de l’ellipse est definie a partir d’un rectangle entourant celle-ci.

create_ellipse(x0,y0,x1,y1,*options)

Arcs d’ellipse : Les arcs sont des portion d’ellipse. Pour une ellipse de hauteur et largeurdonnee, on doit egalement fournir l’angle de depart start (mesure a partir de l’abcisse,dans le sens anti-horaire) et l’etendue angulaire de l’arc extent. Contrairement a laplupart des autres classes python, les angles sont mesures ici en degres.

create_arc(x0,y0,x1,y1,start=45,extent=30,style=chord, *options)

La variable style indique la fermeture de l’arc et peut prendre deux valeurs : PIESLICE(defaut - complete en “V”) ou CHORD (trace un trait entre les deux bouts).

Polygones : Cette commande vous permet de tracer n’importe quel forme. Le premier et ledernier points peuvent etre les memes ou non, quoiqu’il en soit, Tk fermera le polygone.

create_polygone(x0,y0,x1,y1,...,xn,yn, *options)

ou les options sont les suivantes :

fill=couleur Couleur de l’interieur du polygone (defaut=transparent)

outline=couleur Couleur du pourtour du polygone (defaut=”black”)

witdh=largeur Largeur de la ligne en pixels.


smooth=booleen Indique si la ligne devrait etre tracee comme une courbe, en utili-sant une methode de spline (defaut=FALSE)


splinesteps=entier Definit le degree de lissge desire pour les courbes. Cet option estignoree a moins que smooth=true (defaut=12).

Contrairement aux lignes, toutefois, ces formes ont a la fois un contour et un interieur.Par defaut, l’interieur est transparent et le contour est de couleur noire, avec une largeurd’un pixel.

Texte

Il est facile de placer du texte dans un contenant graphique. On utilise le meme type decommande que ci-dessus.

create_text(x,y,text=’Le texte du message’,*options)

ou (x, y) indique la position du texte dependamment de l’option d’anchrage anchor.

anchor=position Position d’anchrage. Par defaut, le centre de la boıte de texte. Autresoptions, basees sur les points cardinaux, ”west”,”south”,”north”,”east”,”northeast”,etc.

fill=couleur Couleur du texte (defaut=”black”)

font=fonte Fonte utilisee pour le texte (defaut=( (’MS’,Sans’,’Serif’),8) ou le contenu de laparenthese decrit la police utilise et le chiffre, la taille de la police. Quelques exemple :font=(”times”,12,”bold”) Fonte de 12 points, en caracteres grasfont=(”geneva”,22) Fonte de 22 points, en caracteres normauxfont=(”helvetica”,9,”italic”) Fonte de 9 points, en italiquefont=(”courier”,59) Fonte de 59 points, en caracteres normaux


justify=position Position du texte par rapport a la boıte (si le texte est sur plusieurs lignes(defaut=”LEFT”). Option : LEFT, CENTER, RIGHT.

Role des etiquettes

Il est possible d’identifier un objet par son etiquette ou l’identite retournee lors de sacreation

# On cree un cercle bleu de largeur 8 pixels et on attrape son identiteidentite = canevas.create_oval(x,y,(x+8),(y+8), fill=’blue’)

# On cree un rectanble identifie par son etiquette "rectangle_vert"canevas.create_rectangle(x,y,(x+8),(y+8), fill=’vert’,

tag=’rectangle_vert’)

# On change la couleur du rectangle vertcanevas.itemconfigure("rectangle_vert",fill="red")

# Puis on efface cet objet avec l’identite ou l’etiquettecanevas.delete(identite)

Les etiquettes sont tres utiles lorsqu’on veut deplacer ou effacer des objets.

7.5. PRINCIPES DE BASE D’UNE INTERFACE GRAPHIQUE (GUI) 117

7.5 Principes de base d’une interface graphique (GUI)

Maintenant que nous avons defini les objets graphiques de base, il nous faut encoreinteragir avec le programme. Nous avons vu comment accomplir ceci de la ligne de commande.On peut rendre le programme beaucoup plus facile d’utilisation si, au lieu, on utilise uninterface graphique.

L’utilisation d’une interface graphique rend toutefois les programmes compliques a ecrire,ce qui n’est pas souhaitable dans le cadre d’un cours comme celui-ci. Nous ne presenteronsdonc que les commandes de base. Pour plus d’information, veuillez consulter les referencesmentionnees dans le syllabus.

7.5.1 Quelques composantes graphiques

Avant de donner des exemples d’utilisation, nous allons d’abord definir les composantesd’interfaces graphiques.

Etiquettes

Les etiquettes servent a ajouter de l’information, textuelle ou graphique. Elles ont lastructure suivante :

Label(text=’texte’)Label(text=’texte’,anchor="west")Label(text=’texte’,justify="center",font=("times",24,"bold"))Label(text=’texte’,*options)

ou les options sont les suivantes :

anchor=position Position d’anchrage de la boıte - ”center”,”left”,”right”background=couleur couleur du fondforeground=couleur couleur du textfont=fonte meme utilisation de la fonte que dans create_textpadx = nombre espace laisse autour du texte (le long de x), en pixelspady = nombre meme chose que padx, le long de yuddnderline= booleen souligne (defaut = -1, mettre 1 pour souligne)wraplength=nombre longueur maximale de la ligne, utilise justifyjustify=position Justification du texte - ”left”,”center”,”right”

Il est toujours possible de changer le texte ou d’autres options a l’aide de la commandeconfigure, sur l’etiquette.

etiquette = Label(fenetre,text="Un peu de texte",font=("Geneva",20))# Et on change le texte de l’etiquetteetiquette.configure(text="Changement de programme")

Le programme exempleEtiquette.py demontre comment on utilise cet objet.

1 """2 Programme ExempleEtiquette.py3


4 Ce programme cree un cadre avec quelques etiquettes56 Copyright Normand Mousseau 15 mai 20037 """8 from Tkinter import *9

10 """11 Programme principal dans lequel on cree une fenetre et on y place12 des etiquettes13 """14 fenetre = Tk() # On cree une instance de Tk15 cadre = Frame(fenetre) # On cree un cadre16 cadre.pack() # que l’on place dans le fenetre1718 # Cree et ajoute un message au cadre19 message1 = Label(cadre,text="Le petit prince",font=("Geneva",18))20 message1.pack(pady=10) # Laisse 10 pixels entre cette etiquette et la bordure2122 # Cree une instance de la classe gaucheDroite et lui passe la reference de23 # l’objet message afin qu’on puisse le modifier24 Label(cadre, text="J’ai longtemps vecu seul, sans personne avec qui "25 "parler veritablement, jusqu’a une panne dans le desert du Sahara, "26 "il y a 6 ans.", wraplength=100,justify="right", bg = "blue",27 fg="yellow").pack()2829 message2 = Label(cadre,text="Antoine de St-Exupery",30 font=("baskerville",30,"italic"),31 fg="orange")32 message2.pack(padx=100,pady=20) # Laisse 100 pixels a gauche et a droite33 # et 10 verticalement3435 # On s’assure que la fenetre reste ouverte36 fenetre.mainloop()

Boutons

Alors que les etiquettes sont des objets statiques, les boutons doivent generer un action duprogramme en reponse a un clic de l’utilisateur. On doit donc mettre en place un ecouteu,un processus separe qui verifie regulierement l’etat du bouton et prend note si il a etepousse. Si c’est le cas, l’ecouteur arrete le programme et execute, a la place, les instructionscorrespondant a l’action posee. Evidemment, tout cela doit etre inclut dans le programme.

Les structures de base d’un bouton sont :

button(gui,text="Bouton",command=lancer_application)

ou gui est la reference a la fenetre dans laquelle le bouton est place et command indique lacommande que doit lancer python lorsqu’on appuit sur le bouton.


Button possede egalement les memes methodes que Label.Le programme ExempleBouton illustre les instructions de creation d’un bouton et de sa

gestion.

1 """2 Programme exempleBouton.py34 Ce programme cree un cadre avec deux boutons - un gauche et un droit.5 Si vous appuyez sur ces boutons, un message apparaıtra indiquant le6 bouton active.78 Copyright Normand Mousseau 15 mai 20039 """

10 from Tkinter import *1112 class droiteGauche :13 # Classe droiteGauche : definit l’action a prendre lorsqu’on14 # appuie sur un bouton15 global cadre,message1617 # Methode __init__ est appelee automatiquement lors de18 # l’instanciation de la classe19 def __init__(self,message):20 self.message = message2122 # Methode appelee si on appuie sur le bouton de gauche23 def gauche(self):24 self.message.configure(text="Vous avez appuye sur le bouton de gauche")2526 # Methode appelee si on appuie sur le bouton de droite27 def droite(self):28 self.message.configure(text="Vous avez appuye sur le bouton de droite")2930 """31 Programme principal dans lequel on cree une fenetre et on y place32 une etiquette ainsi que deux boutons.33 """34 fenetre = Tk() # On cree une instance de Tk35 fenetre.geometry("500x200") # On force la taille de la fenetre a etre 500x200 pixels36 cadre = Frame(fenetre) # On cree un cadre37 cadre.pack() # que l’on place dans le fenetre3839 # Cree et ajoute un message au cadre40 message = Label(cadre,text="Appuyez sur un bouton",font=("Geneva",18))41 message.pack(pady=10)42


43 # Cree une instance de la classe gaucheDroite et lui passe la reference de44 # l’objet message afin qu’on puisse le modifier45 action = droiteGauche(message)4647 # Cree deux boutons, avec un texte et une commande a executer lorsque active.48 bGauche = Button(cadre,text="Gauche",command=action.gauche)49 bDroite = Button(cadre,text="Droite",command=action.droite)5051 # On place nos deux boutons dans le cadre52 bGauche.pack(side=LEFT)53 bDroite.pack(side=RIGHT)5455 # On s’assure que la fenetre reste ouverte56 fenetre.mainloop()

Champs textuels

Un champ textuel est un objet qui peut lire ou montrer un ligne de texte simple. Lorsquela touche <retour> est activee, une commande pre-definie est executee.

On peut soit montre le texte entre (methode habituelle) ou le cacher, pour proteger unmot de passe, par exemple.

Ces composantes peuvent etre instancies avec l’une ou l’autre de ces constructions :

# On met d’abord une etiquetteLabel(cadre,text="Reponse : ").pack(side=LEFT,padx=5,pady=10)

# Puis on definit la chaıne textuelle initiale (nulle)reponse=StringVar()

# On cree un champ textuel de 60 caracteres et on lui assigne la# variable reponsechampTextuel = Entry(cadre,textvariable=reponse,fg="blue",width=60)champTextuel.pack(side=LEFT) # On ajoute le champ textuel

# Puis on definit une action a prendre apres que la touche# <retour> ait ete pousseechampTextuel.bind(’<Key-Return>’, action_sur_texte)

# On modifie la reponsereponse.set("C’etait une question difficile")

On peut faire la meme chose pour un mot de passe

# On met d’abord une etiquetteLabel(cadre,text="Mot de passe : ").pack(side=LEFT,padx=5,pady=10)

# Puis on definit la chaıne textuelle initiale (nulle)mdp=StringVar()


# On cree un champ textuel de 60 caracteres et on lui assigne la# variable reponseEntry(cadre,textvariable=mdp,width=20,show=’*’).pack(side=LEFT)

anchor=position Position d’anchrage de la boıte - ”center”,”left”,”right”textvariable=variable variable attachee au texte. On peut donc le mettre

a jour ou le lire separement (option valide pour lesautres objets).

background=couleur couleur du fondforeground=couleur couleur du textfont=fonte meme utilisation de la fonte que dans create_textpadx = nombre espace laisse autour du texte (le long de x), en pixelspady = nombre meme chose que padx, le long de ywraplength=nombre longueur maximale de la ligne, utilise justifyjustify=position Justification du texte - ”left”,”center”,”right”show=chaıne utilise cette chaıne de caracteres afin de cacher

les caracteres tapes, utile pour des mots de passe(show=’*’, par exemple)

Le programme ExempleChampTextuel.py donne un exemple de l’utilisation de champstextuels.

1 """2 Ce programme presente un exemple simple d’application du champ3 textuel.45 Normand Mousseau6 Cree le 28 mai 20037 """8 from Tkinter import *9

10 # Methode action_sur_le_texte11 def action_sur_texte(self) :12 texte = champTextuel.get()13 print "Le texte du champ est : " + texte14 reponse.set("Essayez encore une fois");1516 # Debut de la methode principale17 global champTextuel, reponse # On definit deux variables globales1819 fenetre = Tk()20 cadre = Frame(fenetre)21 cadre.pack()2223 # On met d’abord une etiquette24 Label(cadre,text="Reponse : ").pack(side=LEFT,padx=5,pady=10)


2526 # Puis on definit la chaıne textuelle initiale (nulle)27 reponse=StringVar()2829 # On cree un champ textuel de 60 caracteres et on lui assigne la30 # variable reponse31 champTextuel = Entry(cadre,textvariable=reponse,fg="blue",width=60)32 champTextuel.pack(side=LEFT) # On ajoute le champ textuel3334 # On modifie la reponse35 reponse.set("<Entrez le texte desire>")3637 # Puis on definit une action a prendre apres que la touche38 # <retour> ait ete poussee39 champTextuel.bind(’<Key-Return>’, action_sur_texte)4041 # Boucle afin de garder la fenetre ouverte42 fenetre.mainloop()

1 """2 Programme conversionTemperature.py34 Ce programme offre une conversion de Celsius a Farenheit et vice-versa5 a l’aide des commandes de champ textuel.67 Ce code est base sur l’exemple cree par Stephen Chapman89 Copyright Normand Mousseau 15 mai 2003

10 """11 from Tkinter import *1213 # La classe conversion contient toutes les methodes necessaires pour14 # convertir de Celsius a Fahrenheit et vice-versa15 class ConversionTemperature :1617 # Methode appelee si on appuie sur le bouton de gauche18 def versCelsius(self,tm):19 tFahr = float( cadre.champFahr.get())20 tCelsius = (tFahr - 32) * 5.0/9.021 cadre.champCelsius.insert(0,"%8.3f " %tCelsius)2223 # Methode appelee si on appuie sur le bouton de droite24 def versFahrenheit(self,tm):25 tCelsius = float( cadre.champCelsius.get())26 tFahr = (9.0 * tCelsius / 5.0) + 32.027 cadre.champFahr.insert(0,"%8.3f " %tFahr)

7.6. MELER GRAPHIQUES ET INTERFACE GRAPHIQUES 123

2829 """30 Programme principal dans lequel on cree une fenetre et on y place31 une etiquette ainsi que deux boutons.32 """33 global cadre3435 fenetre = Tk() # On cree une instance de Tk3637 # On cree un cadre avec un titre38 cadre = Frame(fenetre)39 cadre.pack() # que l’on place dans le fenetre4041 tempCelsius = DoubleVar()42 tempFahrenheit = DoubleVar()4344 conversion = ConversionTemperature()4546 # On ajoute l’etiquette et le champ textuel relie a la temperature Celsius47 cadre.etiqCelsius = Label(cadre,text="Temperature en degres Celsius")48 cadre.etiqCelsius.grid(row=0,sticky=W)4950 cadre.champCelsius = Entry(cadre,width=10,textvariable=tempCelsius)51 cadre.champCelsius.bind(’<Key-Return>’,conversion.versFahrenheit)52 cadre.champCelsius.grid(row=0,column=1,sticky=W)5354 cadre.etiqFahrenheit = Label(cadre,text="Temperature en degres Fahrenheit")55 cadre.etiqFahrenheit.grid(row=1,sticky=W)5657 cadre.champFahr = Entry(cadre,width=10,textvariable=tempFahrenheit)58 cadre.champFahr.bind(’<Key-Return>’,conversion.versCelsius)59 cadre.champFahr.grid(row=1,column=1,sticky=W)606162 # On s’assure que la fenetre reste ouverte63 fenetre.mainloop()

7.6 Meler graphiques et interface graphiques

Il est relativement facile de meler graphiques et interfaces dans un seul cadre. Parce queles contenant graphiques peuvent toujours etre inseres dans d’autres contenants, on peutpreparer graphiques et interfaces dans des cadres (Frame) separes et les ajouter ensuite dansun contenant principal. Vous trouverez un exemple de cette approche dans la section surBoxLayout (Sect. 7.7.2).


7.7 Presentation

Tkinter peut prendre en charge la disposition des composantes graphiques que l’on ajoutea un contenant a l’aide de la commande pack. Cette disposition ne correspond pas toujoursa ce que l’on veut et plus de controle est necessaire. Nous verrons dans cette section deuxdes quatre gestionnaire de disposition (layout managers).

7.7.1 pack

Le gestionnaire pack place les elements graphiques l’un a la suite de l’autre dans lecontenant. Il commence dans le coin gauche superieur et ajoute les nouveaux objets sur lameme ligne, a la droite de l’objet precedent, jusqu’a ce qu’il n’y ait plus de place sur cetteligne ; pack commence alors une nouvelle ligne.

Les commandes de pack sont donc simples mais limitees.

pack()pack(side=LEFT) # acceptable: LEFT, RIGHT, CENTER, TOP, BOTTOMpack(side=CENTER, padx=3, pady=12)

Les espaces vertical et horizontal (padx et pady) definissent l’espace laisse entre les elementsgraphiques.

Si on change la taille du cadre, pack deplace les objets afin de respecter ses regles, ce quipeut produire des resultats un peu etrange. (A l’aide d’une souris, changez la taille du cadredes programmes ci-haut et vous verrez que les etiquettes et les champs textuels ne restentpas alignes correctement.)

7.7.2 grid

Le gestionnaire de disposition grid assure un bien meilleur controle de la presentation.Il s’assure, autant que possible, que la position respective des objets ne change pas quandon change la taille de la fenetre, par exemple.

grid place les composantes graphiques en lignes ou en colonnes, avec un espacement etun alignement ajustables entre ces colonnes et ces lignes.

Une disposition de grid est definie par la position de depart de la grille (definit en positioncardinle : N, NE, NW, S, SW, etc. ou N signifie North et ainsi de suite). On construit lagrille element par element

grid(row=0,column=2,sticky=N)

indique que l’on place l’element dans la troisieme colonne de la premiere rangee et que lagrille est placee en haut de la fenetre.

Puisqu’on peut toujours placer un objet grid dans une autre grille, cet objet donne toutela flexibilite necessaire pour organiser un presentation precise.

Exemple :

1 """2 Programme Dispositioni134 Ce programme presente un exemple d’utilisation de grid

7.7. PRESENTATION 125

Tab. 7.4 – Parametres de la classe grid.

Methode DescriptionBox.createRigidArea(Dimension d) Cree une region rigide, mesuree en pixels,

entre deux composantes. Dimension est unvecteur de dimension 2 : d.largeur andd.hauteur.

Box.createHorizontalGlue() Cree une composante virtuel qui peut absor-ber les espaces horizontaux quand le cadrechange de taille.

Box.createVerticalGlue() Cree une composante virtuel qui peut ab-sorber les espaces verticaux quand le cadrechange de taille.

56 Normand Mousseau7 28 mai 20038 """9 from Tkinter import *

1011 fenetre = Tk()1213 fenetre.title("Mot de passe")1415 # On cree les etiquettes et on les place sur la grille. Si column ou row16 # n’est pas indique, la valeur de defaut est 017 #18 # Notez que sticky=E justifie le texte a droite plutot qu’a gauche (W) ou19 # au centre (defaut)20 Label(fenetre,text=’Mot de passe actuel :’).grid(row=0,sticky=E)21 Label(fenetre,text=’Nouveau mot de passe :’).grid(row=1,sticky=E)2223 # On peut aussi definir l’etiquette d’abord, puis la placer sur la grille24 etiq3 = Label(fenetre,text=’Verification :’)25 etiq3.grid(row=2, column=0)2627 # On fait de meme pour les champs textuel - on cree d’abords28 mdp_actuel = Entry(fenetre,width=16, show=’*’)29 mdp_nouveau = Entry(fenetre,width=16, show=’*’)30 mdp_verification = Entry(fenetre,width=16, show=’*’)3132 # puis on place33 mdp_actuel.grid(row=0,column=1,sticky=W)34 mdp_nouveau.grid(row=1,column=1,sticky=W)


35 mdp_verification.grid(row=2,column=1,sticky=W)3637 fenetre.mainloop()

1 """2 Programme Disposition234 Ce programme presente un exemple d’utilisation de grid ou on a de5 multiples niveaux.67 Notez que les colonnes ou les rangees n’ont pas a avoir la meme taille.89 Normand Mousseau

10 28 mai 200311 """12 from Tkinter import *1314 # La classe Dessin trace des cercles de diverses couleurs15 class Dessin(Canvas) :1617 def jaune(self) :18 self.delete("all")19 self.create_oval(10,10,290,290,fill="yellow")2021 def bleu(self) :22 self.delete("all")23 self.create_oval(10,10,290,290,fill="blue")2425 ###############################################################26 # Classe principale27 ###############################################################28 fenetre = Tk()29 fenetre.title("Exemple de disposition")3031 # On cree d’abord un canevas de fond rouge qu’on place dans la32 # premiere rangee, premiere colonne33 canevas = Dessin(fenetre, width=300, height=300, background=’red’)34 canevas.grid(row=0,column=0)3536 # Puis, un cadre (cadreDuBas), qu’on place dans la deuxieme rangee,37 # colonne zero38 cadreDuBas = Frame(fenetre)39 cadreDuBas.grid(row=1,column=0)4041 # Finalement, on place deux boutons dans le cadre du bas.42 bJaune = Button(cadreDuBas,text=’Jaune’,command=canevas.jaune)

7.7. PRESENTATION 127

43 bBleu = Button(cadreDuBas,text=’Bleu’,command=canevas.bleu)4445 # On cree une deuxieme grille a l’interieur de ce cadre et on y place46 # les boutons47 bJaune.grid(row=0,column=0)48 bBleu.grid(row=0,column=1)4950 fenetre.mainloop()

Annexe A

Les regles de la bonneprogrammation

A.1 Quand on ecrit un programme

1. Ne pas placer plus d’une instruction par ligne ;2. Inclure des commentaires ;3. Structurer le programme visuellement ; chaque fois qu’une nouvelle structure est creee,

rentrer le texte a droite de quelques espaces ;

class Alinea : # Creation d’une nouvelle structure

def uneMethode(self, y) : # Et d’une autre

x = 3.0if y > x : # Encore une sous-structure

instructions...else :

print "Dans la sous-structure else"# fin de la methode

def uneAutreMethode(self, arg) :instructions..# fin d’ uneAutreMethode

# fin de la classe alinea

############################################################## Structure principale

al = Alinea() # On cree une instance de la classe Alinea

al.uneMethode(17.0) # On appelle une methode

129

130 ANNEXE A. LES REGLES DE LA BONNE PROGRAMMATION

# Boucle sur i et j, on somme kk = 0for i in range(10) :

for j in range(i) :k += 1print "k = ", k

4. Utiliser des noms de variable qui soient informatifs : «masse» au lieu de «m» ou «nom-breDAtomes» au lieu de «n».

5. Commencer chaque nom de classe par une MAJUSCULE ;

6. Commencer chaque variable ou methode par une minuscule ; si le nom la variablecontient plusieurs mots, commencer les mots suivants par une majuscule ;

7. Nommer les constantes par des noms completement en majuscules.

8. Utiliser des lignes vides – elles ne coutent rien – afin d’aerer le programme et desimplifier la lecture du code.

9. Toujours verifier separement chaque piece de code afin de s’assurer qu’il n’y ait pasd’erreur logique ou autre. Toujours tester les programmes dans des conditions ou l’onconnaisse d’avance les reponses avant de se lancer dans des vraies simulations.

A.2 Commentaires

Python permet deux types de commentaires :

1. Commentaires de fin de ligne : #

Tout texte apparaissant sur la meme ligne a droite de # est considere comme uncommentaire et est ignore par python.

2. Commentaires de bloc : """ ... """

Tout texte se trouvant entre """ et """, que ce soit sur une ligne ou plusieurs lignesest considere comme un commentaire et est ignore par python.

Notes : Si l’on s’en tient au commentaire de fin de ligne pour les vrais commentaires,on peut alors utiliser les commentaires de bloc pour inhiber un ensemble d’instructions lorsde la mise au point du programme.

A.3 Quelques elements de bon usage

Sauvegarde : Vos fichiers sont sauvegardes sur le systeme de l’universite. C’est toutefoisune bonne idee de toujours faire une copie de votre programme avant d’y faire desmodifications majeures. Comme ca, si plus rien ne marche, vous aurez toujours laversion originale.

Repertoire : Ce n’est pas une bonne idee de placer tous vos fichiers dans le meme repertoire ;tres vite, le nombre de fichiers augmente et vous ne pourrez plus vous y retrouver.Creez des maintenant un organisation de repertoires et sous-repertoires. (Par exemple,un repertoire par laboratoire).

A.3. QUELQUES ELEMENTS DE BON USAGE 131

Espace disque : Bien que l’espace disque soit peu dispendieux, vous avez quand meme deslimites. Effacez les fichiers dont vous n’aurez plus besoin (les fichiers intermediaires,par exemple). Et comprimez les fichiers que vous voulez garder mais ne voulez pasutiliser pour le moment.

132 ANNEXE A. LES REGLES DE LA BONNE PROGRAMMATION

Annexe B

Installer Python et Emacs sousWindows XXX

B.1 Installer EMACS

La derniere version d’Emacs se trouve a l’adresse suivante :ftp ://ftp.gnu.org/gnu/windows/emacs/latest

1. Decharger emacs...i386.tar.gz ou les trois points seront remplaces par la versiondechargee (21.2, par exemple).Extraire les fichiers avec, par exemple, l’utilitaire winzip.

2. Placez le fichier emacs-21.2 (ou autre version) dans un repertoire d’applications.

3. Allez dans le sous-repertoire emacs-21.x/bin et cliquez sur le programme addpm. Celui-ci generera un lien que vous pourrez mettre sur votre bureau.

Voila, vous y etes !

Maintenant, il s’agit d’optimiser un peu votre fichier .emacs afin de donner de la couleura vos codes. Placez ce qui suit dans le fichier C:\.emacs

(global-font-lock-mode t)(setq scroll-step 1)(setq text-mode-hook ’turn-on-auto-fill)(setq fill-column 60)(standard-display-european t)(setq next-line-add-newlines nil)

(setq auto-mode-alist(cons ’("\\.py$" . python-mode) auto-mode-alist))

(setq interpreter-mode-alist(cons ’("python" . python-mode)

interpreter-mode-alist))

(autoload ’python-mode "python-mode" "Python editing mode." t)(global-set-key "\M-g" ’goto-line) ; Esc-G runs the goto-line

133

134 ANNEXE B. INSTALLER PYTHON ET EMACS SOUS WINDOWS XXX

; function.

Pour plus d’informations, lisez le documenthttp ://www.gnu.org/software/emacs/windows/

B.2 Installer Python

1. Allez sur le site de Python http ://www.python.org et teledechargez la version 2.2.3 (http ://www.python.org/2.2.3.

2. Avant d’installer cette version de Python, enlevez les versions precedentes. Pour cefaire, utilisez l’utilitaire Ajout/suppression des programmes dans le panneau de confi-guration.

3. Executez le fichier teledecharge puis effacez le (afin d’economiser un peu d’espace....)

4. Voila. Vous y etes !

Annexe C

Breve introduction a Linux/Unix

C.1 Introduction

Ce document presente une breve introduction au systeme d’operation Linux/Unix. Cer-tains des appareils que vous utiliserez dans ce cours fonctionnent sous un systeme d’operationappartenant a cette grande famille.

C.2 Commandes

Unix est, historiquement, un systeme d’operation de commande de ligne. Dans la plupartdes cas, l’utilisation de commandes de ligne est beaucoup plus efficace que le clic et le clac dela souris. Vous trouverez ci-dessous les commandes les plus courantes. N’hesitez pas a faireappel a la commande d’aide man.

ls liste les fichiers contenus dans le repertoire actuells -l liste plus informative des fichiersls -a liste aussi les fichiers «caches»cd repertoire va au repertoire «repertoire»cd va au repertoire principalemkdir nouv rep cree un repertoire «nouv rep»rm fichier elimine le fichier «fichier»rmdir repertoire elimine le repertoire (vide) «repertoire»lp fichier imprime le fichier «fichier»cp fichier1 fichier2 copie «fichier1» dans «fichier2»cp fichier1 repertoire/ copie «fichier1» au repertoire «repertoire»mv fichier1 fichier2 renomme «fichier1» en «fichier2»man commande «manuel», commande d’aidetop liste des processus actifs sur la machinekill -8 #proc tue le processus #procpico fichier edite «fichier» avec l’editeur picomore fichier liste le contenu de «fichier»tabulateur en mode tcsh, complete les commandesfleches haut/bas se deplace a travers les commandes deja tapees

135

136 ANNEXE C. BREVE INTRODUCTION A LINUX/UNIX

C.3 Copier-coller

Pour copier-coller sur un terminal roulant sous Unix/X11 :

1. saisissez en surbrillance (highhlight) le texte que vous voulez copier en utilisant lebouton de gauche de votre souris, ceci met ce bout de texte en memoire ;

2. cliquez sur la fenetre ou vous voulez coller le texte ;

3. cliquez sur le deuxieme bouton de la souris, le texte est copie ; c’est aussi simple quecela !

C.4 Editeur de texte

Un editeur de texte est different d’un logiciel de traitement de texte. Dans le cas dusecond, le logiciel sert a preparer et a mettre en page des documents alors que le premier sertessentiellement a rediger des textes, programmes ou autres, sans fonction de mise-en-pageou de formattage. Les fichiers generes par des editeurs de textes sont lisibles directement,sans conversion.

Les editeurs de textes les plus courants sont ceux utilises par les logiciels de courriel.Un editeur de texte est un logiciel concu specifiquement pour la manipulation de texte etl’edition de fichier. Le but n’est donc pas necessairement de faire une belle presentation maisplutot de simplifier le processus d’ecriture.

A cause de leur origine, les systemes Unix/Linux disposent d’une vaste gamme d’editeursde texte dont les plus connus sont vi, emacs et pico. Le premier presente une courbe d’ap-prentissage marquee et n’est generalement utilise que par des usagers reguliers. Le second,bien que complet et complexe dispose d’un menu permettant d’effectuer des operations plusrares sans avoir a se rappeler des commandes. pico, qui fait partie du logiciel de courriel pineest plus facile a utiliser mais souffre de limites importantes dans la manipulation speficiquede code informatique.

C.5 Pico

A partir de la maison, avec telnet, il est possible d’utiliser les caracteres accentues.

Usage : Pour ouvrir un fichier (ou le creer), tapez :pico toto.dat

Commandes : Les commandes sont affichees au bas de l’ecran.Quelques commandes utiles de pico :

^x (controle-x) ecrit le fichier et quitte^k (controle-k) elimine la ligne sous le curseur^u (controle-u) place le texte elimine a la position du curseur^w (controle-w) recherche^c (controle-c) annule la commande active

C.6. EMACS 137

C.6 Emacs

A partir des terminaux de l’universite, on peut aussi utiliser emacs pour entrer descaracteres accentues et reformatter le texte. Il est egalement possible de l’installer a la maison.Voir l’annexe suivante pour plus de details quant a l’utilisation d’EMACS.

C.6.1 Caracteres accentues

Pour permettre l’entree de caracteres accentues, il faut taper <esc> - x (la touch d’echappementPUIS la touche « x ». Une ligne apparaıtra au bas de l’ecran emacs avec le textes M-x,

tapez ensuite la commande iso-accents-mode

Vous pourrez alors composer utiliser la composition habituelle des caracteres accentues.

C.6.2 Formattage

Programme Pour formatter le texte d’un programme, il suffit d’utiliser le tabulateur surchaque ligne. Le texte s’organise alors automatiquement.

Texte standard Pour replier les lignes et formatter un paragraphe de texte (un labora-toire, par exemple), il suffit de taper ESC-q (la touche escape suivie de la lettre q). C’esttout.

C.7 Imprimer a partir de ESIBAC

Les departements de l’universite ne se parlant pas trop, il n’est pas possible d’imprimerailleurs qu’au E-408.

Cette imprimante n’accepte que deux format de fichier : ASCII (texte simple) etPostscript.

NE JAMAIS TENTER D’IMPRIMER UN AUTRE FORMAT ! !Pour imprimer un fichier entrez la commande

> lp -dsim -opr=ppe408 <nom de fichier>

C.8 Imprimer un programme

La meilleure facon d’imprimer un programme a partir d’ESIBAC est d’utiliser toutd’abord l’utilitaire a2ps, qui reformatte le programme et donne une presentation plus li-sible de deux pages par page.

Pour imprimer le programme BonjourLeMonde.java, tapez les commandes ci-dessous :

> a2ps Wolfram.java -o wolfram.ps[Wolfram.java (Java): 6 pages on 3 sheets][Total: 6 pages on 3 sheets] saved into the file ‘wolfram.ps’[7 lines wrapped]

> lp -dsim -opr=ppe408 wolfram.ps

138 ANNEXE C. BREVE INTRODUCTION A LINUX/UNIX

C.9 Tuer une tache d’impression

1. Tapez d’abord lpstat et identifiez le numero de votre tache d’impression.

2. Tapez ensuite :

> cancel -dsim -opr=ppe408 Numero_de_tache

3. Si la tache n’est pas en queue, il faut contacter la DGTIC. Je vous donnerai le numeroen classe.

Annexe D

xmgrace et gracePlot.py

Nous avons vu en cours l’interface de python avec gnuplot. Python dispose egalementd’une interface qui permet d’interagir directement avec un programme de tracage inter-actif tres puissant : xmgrace (http ://plasma-gate.weizmann.ac.il/Grace/). Ce pro-gramme est deja installe sur les ordinateurs de esibac. Grace peut etre facilement ins-talle sur toute machine unix ou Linux, de meme que sous tout Mac roulant Os X (viafink). Ce programme est toutefois difficile a installer sous Windows. m Bien qu’on ne l’uti-lisera pas dans le cours, Grace est tres utile pour des publications de qualite. La ver-sion originale de l’interface avec ce programme, gracePlot.py, fut ecrite par Nathan Gray(http ://www.idyll.org/ n8gray/code/index.html). Je lui ai ajoute quelques commandesqui permettent un meilleur controle de ce programme. On peut trouver cette version sur mapage python (www.esi.umontreal.ca/ mousseau/python). Cette interface est egalementinstallee sur les ordinateurs de esibac.

L’avantage de ce programme est qu’une fois les donnees transferrees a xmgrace, il estpossible d’utiliser la souris et de modifier directement le programme.

Graceplot se retrouve maintenant sur sourceforge. L’interface a evolue, mais dans unedirection que je n’aime pas trop. Je me suis donc contente de modifier la version originalede Nathan Gray en lui ajoutant certaines fonctionnalites qui manquaient.

D.0.1 Premiere utilisation de gracePlot.py

On importe d’abord la bibliotheque avec la commande

>>> from Numeric import * # Permet les vecteurs et matrices>>> import gracePlot

(N’oubliez pas la majuscule, qui est essentielle.)On doit ensuite lancer une session :

>>> g = gracePlot.gracePlot()>>> g.title(’Un titre’) # Optionnel

Creons ensuite deux tableaux avant de tracer la courbe

139

140 ANNEXE D. XMGRACE ET GRACEPLOT.PY

>>> x = array([0.7, 1.5, 3.4])>>> y = x**2>>> g.plot(x,y) # Trace une premiere courbe

et d’y ajouter des etiquettes definissant l’abscisse et l’ordonnee

>>> g.xlabel(’Axe des x’)>>> g.ylabel(’Axe des y’)

Il ne nous reste plus qu’a imprimer le tout, sous format postscript, afin de pouvoirimprimer sur une machine unix, et a quitter le programme.

>>> g.save(’test.ps’,’ps’)>>> g.exit()

Si on veut imprimer a partir de la maison, on peut sauver en format pdf, par example.

>>> g.save(’test.pdf’,’pdf’)>>> g.exit()

D.0.2 Quelques exemples plus etendus

Dans l’exemple ci-dessous, on suppose que les vecteurs x1, y1, x2 et y2 ont deja etedefinis.

import gracePlot # Importe l’interface

# Cree une instance xmgrace avec un cadre trace avec des# lignes d’une epaisseur de 2 pixels. On peut aussi changer# cette largeur par la commande g.linewidth(x) ou x est# mesure en pixelsg = gracePlot.gracePlot(linewidth=2)

# Definit une forme precise pour le cadre du graphique# les unites sont en fraction de la taille de la fenetre# (de 0 a 1) et les chiffres, dans l’ordre representent# xmin, xmax, ymin, ymaxg.setsize(0.15,0.85,0.4,0.8)

g.xlabel(’Abcisse’)g.ylabel(’Ordonnee’)

# En definissant "hold=1", on ajoute les courbes une a une# au graphique - pour reecrire par dessus un graphique,# utiliser "g.hold(0)"g.hold(1)

# Plusieurs options sont possible lors du tracage des courbes.# On peut definir la largeur de la ligne, son style et sa

141

# couleur. Ces options ne sont pas necessaires.g.plot(x1, y1, linewidth=2, style=1, color=1)g.plot(x2, y2, style=4, color=3)

g.ylimit(0.1,10.0) # limites pour l’abcisse - ymin, ymax

# Ajoute une legende pour chaque courbe (notez l’utilisation# d’une liste de deux chaınes de caracteres) et positionne# celle-ci en unite de la fenetre (positionnement optionnel)g.legend([’Premiere courbe’,’Deuxieme courbe’],0.28,0.94)

# Finalement, on imprime et on quitteg.save(’test.eps’,’eps’)g.exit()

Notons qu’il est egalement possible de tracer plusieurs graphiques sur une meme page,une propriete particulierement utile dans plusieurs cas. Encore une fois, on suppose que lesvecteurs de donnees ont deja ete definis.

import gracePlotg = gracePlot.gracePlot()

# Cree une matrice de graphique, chacun separe par un espace# horizontal de 0.3 (mesure en termes de la largeur d’un des# graphiques) et vertical de 0.1g.multi(2,3,hgap=0.3, vgap=0.1)

# On travaille d’abord sur le premiere graphique, en haut# a gauche - notez qu’on commence a 0,0g.focus(0,0 )

g.xlabel(’x - 1er graph’)g.ylabel(’y - 1er graph’)

g.plot(x1,y1,color=4)

# On cible sur le dernier graphique en bas a droiteg.focus(1,2)g.plot(x2,y2)

# Et finalement, sur le deuxieme, en basg.focus(1,1)g.linewidth(2) # cadre avec ligne de largeur 2 pixels

g.plot(x3,y3, linewidth=2)g.ylimit(-3.0,9.3)g.xlabel(’x - 3e graph’)


g.ylabel(’y - 3e graph’)

g.save(’multiple.jpeg’,’jpeg’)g.exit()

143

Commande Descriptiong= gracePlot.gracePlot() Cree un nouveau graphique, appele gg.title(’titre’) Definit le titre du graphiqueg.xlabel(’x’) Definit l’etiquette de l’axe des xg.ylabel(’y’) Definit l’etiquette de l’axe des yg.fontsize(2.1) Definit la taille de la fonte des etiquettes des axes des x et y

(defaut 1.0)g.label(texte,x,y, options ) Place un bout de texte sur le graphiqueg.boxstyle(xtick,ytick,xtick label,ytick label) Marques de graduation et etiquettes sur les axes (defauts,

tous a 1). Pour enlever ytick, par exemple, il suffit d’indiquerg.boxstyle(ytick=0)

x, y positions de du texte (en bas, a gauche)color couleurs (nombres entier 1=noir, etc.)size taille de la police (1.0 est celle definie)rotation rotation en degres, sens anti-horaire

g.plot(x,y, options ) Trace un graphique a partir de deux vecteurslinewidth largeur de la ligne en pixelssymbols si egal a 1, trace des symbolesstyles si egal a 1, utilise differents styles pour chaque courbestyle definit style de chaque ligne (0=aucune, 1=ligne continue,

2=ligne pointilee, 3=ligne tiretee, 4=points et tirets)color definit couleur de la ligne (1=noir, 2=rouge, 3=...)

g.hold(1) maintient le graphique, afin de pouvoir ajouter des courbesg.setsize(xmin,xmax,ymin,ymax) taille du graphique (en coordonnees de page)g.linewidth(x) largeur des traitsg.save(fichier,’type’) sauvegarder les images dans un fichierg.legende([’l1’,’l2’],options) Ajoute une legende avec les titres correspondants aux donnees

l1, l2, etc.xpos=x, ypos=y Position de la legendefontsize = 12 Taille de la fontebox =0 Trace ou non une boıte autour de la legende (def : 1 - oui)

g.xscale(echelle) echelle est soit linear (lin) ou logarithmic (log)g.yscale(echelle) echelle est soit linear (lin) ou logarithmic (log)g.xlimit(min,max) definit les limites de l’abcisseg.ylimit(min,max) definit les limites de l’ordonneeg.multi(nrangs,ncols, options) genere une page avec nrangs×ncols graphiques

offset=0.1 (def.) degagement general entre 2 graphiqueshgap=0.1 (def.) Espace verticalvgap = 0.15 (def.) Espace horizontal

g.focus(rang,col) definit le graphique sur lequel on travaille dans un environ-nement multigraphique

g.histoPlot(x,y,options) trace un histrogramme

Annexe E

GNU-EMACS - Presentationsimplifiee

Section basee sur le texte prepare par le Professeur Guy Lapalme, Departement d’infor-matique et de recherche operationnelle, Universite de Montreal.

EMACS est un editeur de texte tres sophistique. En realite, c’est un interprete Lisp quiexecute un editeur programme en Lisp. Or avant d’en apprecier toutes les subtilites, il estimportant d’en apprendre les rudiments comme tout autre editeur. Ces quelques pages de-vraient vous permettre d’utiliser EMACS comme n’importe quel autre editeur simple. Emacsest un editeur qui fonctionne aussi bien dans le mode caractere ; ceci est particulierementutile lorsqu’on accede a l’ordinateur via un modem a basse vitesse que dans une fenetre X.Ce petit texte vous introduit aux deux modes. meme si plusieurs operations se font avecla souris et les choix dans les menus, il est pratique et rapide de se familiariser avec lescommandes au clavier.

Il est difficile d’expliquer ”en mots” ce qui se passe sur l’ecran. C’est pourquoi nousrecommandons de faire cette lecture en meme temps que vous essayez les commandes surl’ecran.

Pour appeler EMACS, il suffit de faire :

emacs

Apres un certain temps, l’ecran se videra et apparaıtra au bas de l’ecran

Emacs: *scratch* (Lisp Interaction)

indiquant le nom du tampon (”*scratch*” par defaut) ; le curseur sera en haut a gauche.Nous sommes alors au debut d’un document vierge et tout ce qu’on y tape y apparaıt amesure. Essayez ! ! ! Dans le systeme de fenetrage X, ”emacs” fait apparaıtre une nouvellefenetre dans laquelle travailler.

Lorsqu’un caractere errone a ete tape, on tape DEL et le dernier caractere avant le DELdisparaıt de l’ecran et le curseur recule.

Comme chaque caractere tape s’ajoute au texte, il faut un autre moyen pour donnerdes commandes a EMACS lorsque nous desirons effectuer autre chose qu’entrer du nouveautexte. Pour differencier les commandes des caracteres il faut appuyer sur la touche ”control”en meme temps qu’une lettre indiquant la commande. Ainsi en appuyant en meme temps

145

146 ANNEXE E. GNU-EMACS - PRESENTATION SIMPLIFIEE

sur les touches controle et b, le curseur reculera d’une position sans rien changer au texte ;dans ce qui suit nous noterons par ^<lettre> cette touche simultanee de controle et d’unelettre.

Pour se deplacer dans le texte, les commandes suivantes ont ete definies :

^f (Forward) avancer d’un caractere^b (Backward) reculer d’un caractere.^n (Next) aller a la meme position de la

ligne suivante^p (Previous) aller a la meme position de la

ligne precedente^a (Au debut !) aller au debut de la lignes^e (End) aller a la fin de la ligne

Au lieu de ^f, ^b, ^n et ^p, on peut habituellement utiliser les fleches presentes sur leclavier pour le deplacement du curseur. Essayez-les. Si ca ne marche pas, demandez a un”expert” de vous configurer Emacs pour que ca fonctionne. Lorsqu’on travaille sur un ecrangraphique, la facon la plus pratique de se deplacer rapidement dans un texte est d’utiliser lasouris. Il suffit d’indiquer l’endroit dans le fichier ou on desirer se positionner et d’appuyersur le bouton gauche de la souris.

Avec ces commandes, il est donc possible de placer le curseur dans le texte et d’y ajouterde nouveaux caracteres en les tapant tout simplement. Essayez ! ! !

Pour detruire un caractere, on a vu DEL qui detruisait le caractere precedant le curseur.

^d (Delete)

detruit le caractere vis-a-vis le curseur ; remarquez que lors de la destruction d’un caractere,tout le reste de la ligne est decale immediatement. Pour detruire toute ligne, il existe

^k (Kill)

qui detruit les caracteres suivant le curseur jusqu’a la fin de la ligne courante ; si le curseurest en fin de ligne, il enleve le CR final et la ligne suivante vient se fusionner avec celle-ci.Pour detruire des groupes de lignes, on en indique le debut en placant une marque avec

^@ (At)

Les mots ”Mark set” devraient apparaıtre au bas de l’ecran, si ca ne fonctionne pasessayez soit la touche ”BREAK” ou ^<espace>. On positionne ensuite le curseur a la fin dece qu’on veut detruire ;

^w (Wipe)

fait disparaıtre tout le texte entre la marque et le curseur. On peut aussi utiliser la sourispour delimiter cette region du texte en pointeur avec le bouton gauche et en glissant jusqu’ala fin. Le texte marque est alors souligne ; ce souligne disparaıt aussitot mais la marque estmaintenant repositionnee.

Apres un ”^k” ou un ”^w”, le texte detruit peut etre recupere avec

^y (Yank)

147

On peut deplacer du texte en le ”Yank”ant a un autre endroit que celui dont on vient del’enlever.

Une autre facon de positionner le curseur est la recherche d’une chaıne :

^s (Search)

imprime dans le bas de l’ecran ”I-search :” et place le curseur dans un espace appele ”mini-buffer” ou on tape la chaıne desiree terminee par la touche RET. Le curseur se placera a lafin de la premiere occurrence de la chaıne cherchee. La recherche se fait en avancant dans ledocument. Pour chercher en ”remontant”, il faut faire

^r (Reverse)

qui place le curseur AVANT la premiere occurrence detectee. Lorsqu’un texte n’entre pas aucomplet sur l’ecran (c’est habituellement le cas), et que le curseur devrait sortir de l’ecran,EMACS reorganise le contenu de l’ecran de facon a ce que le curseur soit a peu pres aumilieu. Ceci permet de voir le contexte. Lorsqu’on lit un texte, on aimerait souvent avoir unepage neuve lorsque le curseur arrive en bas et non pas seulement la moitie.

^v (View)

effectue ceci et ne garde que la derniere ligne de l’ecran precedent qui se retrouve maintenanten haut ; le curseur est place en haut a gauche.

Pour effectuer un remplacement de chaıne, il faut taper

ESC %

EMACS demande alors la chaıne a changer terminee par un ”RETURN” et ensuite lachaıne de remplacement ; il positionne ensuite le curseur a la prochaıne occurrence de lachaıne et attendra une reponse avant de faire le remplacement. En tapant un espace, leremplacement sera effectue et le curseur se positionnera a la prochaıne occurrence ou il at-tendra encore une reponse. Si on ne veut pas le remplacement de cette occurrence mais qu’ondesire quand meme continuer pour voir les autres, il faut repondre avec DEL. Finalement,en reponse a un ! EMACS effectuera toutes les substitutions restantes sans demander deconfirmation.

EMACS permet de revenir en arriere et de defaire l’effet de commandes a l’aide de

^x u (Undo)

souvent ^_ fait aussi l’affaire, Essayez. En appuyant de nouveau sur cette cle, on peut defaireautant de commandes que l’on veut jusqu’a retrouver l’etat initial du tampon. Toute autrecommande brise la sequence de ”undo” qui peut elle-meme etre defaite par la suite. En par-ticulier, pour refaire une commande defaite il suffit d’effectuer une commande ”inoffensive”^f par exemple et de reexecuter undo. Ca semble complique mais c’est tres facile a utiliserune fois qu’on l’a experimente. Essayez. C’est surtout difficile de s’en passer une fois que l’ony est habitue.

Sur un ecran graphique, il n’est pas necessaire de se rappeler toutes ces commandes carplusieurs d’entre elles sont disponibles a partir du menu deroulant qui apparaıt en appuyantsur un bouton de la souris sur un des mots en gras en haut de l’ecran. On y voit la commande


et la suite de cles a appuyer pour lancer cette commande. Au debut, il est plus facile d’utiliserles menus mais rapidement on apprecie la commodite des combinaisons de cles.

Maintenant que nous avons vu comment creer et modifier un fichier, il est interessant dele conserver. Pour eviter de faire des modifications par erreur, les commandes ”dangereuses”,c’est-a-dire qui modifient des etats de fichiers commencent par ”^x” avant le code de controle(on retrouve aussi ces commandes sous le menu deroulant ”File”) :

^x^f (Find) place un fichier sur l’ecran^x^s (Save) sauve le fichier sous le nom d’entree^x^w (Write) ecrit le fichier ;Emacs demande le nom^x^c quitter EMACS^z suspendre EMACS pour pouvoir y revenir plus tard

On peut interrompre toute commande en cours avec

^g (Grrr!)

Pour obtenir de l’aide : en tout temps il est possible de taper

^h (Help)

Le plus simple est de repondre ? qui donne la liste de toutes les aides disponibles. Lesplus utilisees sont

c suivi d’un caractere qui decrit la fonction associee a ce caracterea suivi d’un mot qui donne la liste des commandes qui y ont rapport

Ces messages d’aide apparaıssent dans une autre fenetre et ne modifient pas le texte.Pour la faire disparaıtre,il suffit de taper ce qui est suggere au bas de l’ecran. On a aussiacces a cette aide en utilisant le menu deroulant ”Help”.

Ceci complete notre bref expose des principales commandes de EMACS. Il en existeune foule d’autres et il est meme possible de programmer soi-meme des extensions qui sontregroupees en modes.

Principaux Modes EMACS

Un texte peut-etre mis dans un «mode» qui en facilite l’edition en definissant des com-mandes supplementaires appropriees au mode. Par exemple, si on edite un texte ”humain”,on aura des commandes pour manipuler des mots, des phrases et des paragraphes. On peutmettre un tampon dans le mode «text» en tapant

ESC x text-mode

Le nom du mode apparaıt alors dans la ligne d’information sous la fenetre ou on ajoutele texte. On peut obtenir de l’information sur le mode courant, en particulier les commandesspeciales a ce mode, en tapant

^h m

Voici quelques exemples de modes groupes en grandes categories. Le mieux est de consul-ter la documentation en ligne disponible par la commande

149

^h i

qui affiche son information dans un tampon EMACS (evidemment) dans un mode specialINFO qui donne les possibilites de navigation a la maniere d’un hypertexte.

Pour des textes humains, en plus du mode TEXT, on a les modes NROFF, TEX, LATEXet BIBTEX. Il y a aussi un mode pour lire son courrier RMAIL et un autre pour rediger descourriels.

Pour la programmation, on retrouve un mode pour presque tous les langages les plus cou-rants (C, FORTRAN, PASCAL, ADA, SIMULA ...) qui facilite en particulier l’indentationdes programmes. Il suffit de taper un TAB au debut d’une ligne pour obtenir l’indentationcorrecte. On obtient le meme effet en terminant une ligne par ^j qui placera le curseur dela prochaıne ligne a l’indentation correcte.

Il est de plus facile de lancer une compilation depuis EMACS en faisant

ESC x compile

et on tape la commande de lancement de la compilation. Si la compilation a produit deserreurs, il suffit de faire

^x ‘ (accent grave...)

et EMACS positionnera le curseur sur la ligne en erreur.Pour les langages «interactifs» tels LISP ou PROLOG, on fait en general demarrer l’in-

terprete dans un autre tampon d’EMACS qu’on appelle INFERIOR-LISP ou INFERIOR-PROLOG ce qui nous permet de garder trace de nos essais, de relancer d’anciennes com-mandes possiblement modifiees.

On peut egalement faire demarrer un «shell» dans un tampon EMACS qui s’occupe alorsde garder la trace de notre interaction. Comme dans le cas des modes ”inferieurs” associesau langages interactifs, on peut reexecuter d’anciennes commandes.

Lorsqu’on demande a editer un fichier qui est un repertoire, EMACS nous place alorsdans le mode DIRED qui nous permet de gerer efficacement et visuellement le contenu durepertoire.

Copyright Guy Lapalme (12 juin 1995)


DEPLACEMENT DU CURSEUR^a debut de la ligne ESC a debut de la phrase^b recule d’un car ESC b recule d’un mot^e fin de la ligne ESC e fin de la phrase^f avance d’un car ESC f avance d’un mot^n avance d’une ligne^p recule d’une ligne^r recherche vers l’arriere^s recherche vers l’avant

esc < debut du tamponesc > fin du tampon

DESTRUCTION ET RECOUVREMENTdel detruit le car precedent ESC DEL detruit le mot precedent^d detruit le car sous le curseur ESC d detruit un mot en avant^k detruit jqa la fin de ligne ESC k detruit jqa la fin de phrase^y recouvre la derniere destruction^t transpose les 2 derniers cars ESC t transpose les 2 derniers mots

ESC % remplacement selectifblanc=ok, DEL=refuse

ESC x remplacement ^_ defaire la derniere commandereplace-stringAFFICHAGE

^l reaffiche en centrant le curseur^v ecran suivant ESC v ecran precedent

REGION CONTROLE DE L’EDITION^@ marque au curseur ^g avorter la commande en cours^< marque au debut du tampon ^x^c fin de l’edition^> marque a la fin du tampon^w detruit la region

ESC w copie la region ^j terminer la ligne courante et^x^x echange la marque avec curseur et indenter la prochaıne

FICHIERS TAMPONS^x^f trouver un fichier ^x^b lister les tampons^x^s sauver un fichier ^xb choisir un tampon^x^w ecrire ^xk tuer un tampon

^xa ajouter a la fin d’un tampon^xi inserer un fichier ESC inserer un tampon

ins-tamponCOMPILATION fenetresESC x compile compiler dans tampon ^x1 1 fenetre

^x‘ analyser la prochaıne erreur ^x2 2 fenetresESC x run-lisp Lisp dans tampon ^xo passe a l’autre fenetreESC x run-prolog Prolog dans tampon ESC ^v avance l’autre fenetre

MACROS DOCUMENTATION^x( debut de macro ^h a aide sur sujet^x) fin de macro ^h c aide sur une cle^xe executer le dernier macro ^h m aide sur le mode courant

ESC x name nommer le dernier macro ^h ? aide sur l’aide

Annexe F

Acces aux fichiers et ordinateurs del’exterieur

Il y a plusieurs facons d’acceder a vos fichiers et aux ordinateurs esibac de l’exterieur.Dans cet annexe vous trouverez de l’information sur comment vous brancher sur esibac ettravailler de la maison de meme que pour transferer des fichiers entre votre ordinateur etesibac.

F.1 Acceder a esibac

On peut acceder a esibac a l’aide du programme de branchement telnet. Ce programmeest disponible sur toutes les machines roulant Linux, Mac Os X et Windows XXX. Ceuxutilisant Mac Os 9.2 et moins devraient installer l’application niftytelnet.

F.1.1 Branchement a partir d’un ordinateur roulant Linux ou Mac Os X

1. Branchez-vous sur internet ;

2. ouvrez une application terminal ou xterm ;

3. tapez

telnet esibac.esi.umontreal.ca

4. entrez votre code d’utilisateur (login) et votre mot de passe (password) ;

5. vous y etes ! Vous ne pouvez pas utiliser Emacs a distance mais pico fonctionne par-faitement. Il est aussi possible d’editer des fichiers directement sur ESIBAC, a partirde la maison, si Emacs is installe sur votre ordinateur personnel. Pour plus de details,venez me voir.

F.1.2 Branchement a partir d’un ordinateur roulant Windows XXX

1. Branchez vous sur internet ;

2. demarrez Netscape ou Internet Explorer ;

3. entrez, comme adresse WWW, la ligne suivante :

telnet://esibac.esi.umontreal.ca

151

152 ANNEXE F. ACCES AUX FICHIERS ET ORDINATEURS DE L’EXTERIEUR

(Ne rajoutez rien a cette commande, pas de http ou autres.]

4. Le navigateur lancera automatiquement l’application telnet ; entrez votre code d’uti-lisateur (login) et votre mot de passe (password) ;

5. vous y etes ! Vous ne pouvez pas utiliser XEmacs a distance mais pico fonctionneparfaitement.

F.2 Transferer vos fichiers

F.2.1 Copier/coller a partir de la fenetre telnet

Si les donnees ou programmes a transferer ne sont pas trop longs, vous pouvez simplementutiliser la fonction copier/coller de votre ordinateur.

F.2.2 Envoi par courriel

Vous pouvez aussi transferer les programmes et les donnees via votre compte courriel.Si le fichier a transferer porte le nom donnees.dat, tapez a partir d’un des ordinateurs

d’esibac :

Mail [email protected] < donnees.dat

C’est aussi simple que ca.

F.2.3 Transferer vos fichiers avec ftp

Le protocole de transfert de fichiers ou ftp(file transfer protocol fournit un maniere plusflexible de transferer les fichiers d’un ordinateur a un autre.

Le mode d’emploi suivant s’applique aux systemes d’operation Linux ainsi que WindowsXXX.

1. Branchez vous sur internet ;

2. demarrez Netscape ou Internet Explorer ;

3. entrez, comme adresse WWW, la ligne suivante :

ftp://nom_d’[email protected]

ou votre nom d’utilisateur commence par p0... (Ne rajoutez rien a cette commande,pas de http ou autres.]

4. Le navigateur lancera automatiquement l’application ftp ; entrez votre mot de passe(password) ;

5. vous y etes ! Pour transferer les fichiers, les faire glisser de votre ordinateur (ou decliquer sur le fichier avec le bouton du milieu de votre souris). Vous pouvez egalementtelecharger des fichiers de votre ordinateur a esibac en les faisant glisser sur la page dunavigateur.

Annexe G

Rapports de laboratoire

Les rapports de laboratoire ne sont pas notes sur la qualite de la presentation mais surleur contenu. Ils peuvent donc etre simplement tapes dans un editeur de texte avec les figuresajoutees a la fin et les equations ecrites a la main.

Lorsque vous ajoutez des sorties et des figures en annexe, toujours indiquer le numerodu problemes auxquelles elles se rapportent en plus d’identifier clairement les axes ou lescolonnes.

Le rapport devra avoir la structure suivante :

1. Introduction — Courte description du probleme et des objectifs ;

2. Methodologie — Description de la methode de simulation utilisee et du programme ;

3. Verification du programme — — Comment verifiez-vous le bon fonctionnement duprogramme, de l’algorithme ? Decrivez les tests faits pour verifier le bon fonctionnementdu programme (inclure les sorties de programme) ;

4. Problemes — Repondre a chaque probleme separement en incluant les sorties et/ougraphiques, s’il y a lieu.

5. Conclusion – Qu’avez-vous appris ? Quelles autres questions pourrait-on poursuivre ?

6. Code-source – Annexez votre code-source au laboratoire. Indiquez au surlignez lesparties que vous avez modifiees.

153

Index

+, 74-, 74<, 74<=, 74==, 74>, 74>=, 74

absolute, 74accents, 25accents, problemes avec, 13aide, 17

dir(), 17help, 17

append, 42arccos, 74arccosh, 74arcsin, 74arcsinh, 74arctan, 74arctanh, 74arguments, 53

liste flexible, 55arithmetique

operateurs, 21regles de priorite, 21

assignation, 20, 22

bibliothequealgebre lineaire, 76Gnuplot, 109gracePlot, 139LinearAlgebra, 76mathematique, 67Numarray, 67Numeric, 67random, 78RandomArray, 78Tkinter, 112

bibliotheque de classe, 58bibliotheques de classe, 48boucle, 34

for, 34while, 35

break, 36

caracteres accentues, 25caracteres speciaux, 28ceil, 74chaınes de caracteres, 23

comparer les, 28operations, 24scinder les, 29transfomer en, 27transformer en reels, 27

classes, 51, 56clavier, lecture du, 31close, 37codes de formattage, 27, 28commentaires, 16complexes

types d’objets, 20conversion, 22

forcee, 22copier-coller, 136cos, 74cosh, 74

decrementation, 22delimiteur, 29determinant, 77diagonal, 75dictionnaires, 44dictionnnaires

operations sur, 46dir(), 17dot, 76Dubois, Paul F., 67

154

INDEX 155

ecrire a l’ecran, 30editeur

idle, 12eigenvalues, 77eigenvectors, 77encodage

lecture/ecriture de fichiers, 39encodage des caracteres, 25entree standard, 31entree standard

redirecion, 36exit, 46exp, 74

fabs, 74fichiers

close, 37ecriture, 37encodage utf-8, 39lecture, 38methodes associees, 37open, 37readlines, 38redirection, 36

floor, 74fmod, 74for, 34formattage, 27, 28from ... import, 48

germe (seed), 78Gnuplot

test de l’installation, 108gnuplot, 109

commandes, 110exemple, 110

gracePlot, 139commandes, 143

graphiquesgnuplot, 109gracePlot, 139

GUI, 117

Heigenvalues, 77Heigenvectors, 77help, 17

idle, 12if/else/elif, 33import, 48

from ..., 48impression

imprimer un fichier, 137tuer une tache d’impression, 138

incrementation, 22innerproduct, 76input, 31interface d’utilisateur graphique, 95interface graphique, 117

disposition des elements, 123inverse, 77ipython, 86

lecture du clavier, 31Linux

compilation d’un programme, 12execution d’un programme, 12installation, 10, 108

listes, 40assigner et effacer des elements, 42operations sur, 41ordonnement, 43sort, 43

log, 74log10, 74

MacIntoshexecution d’un programme, 12installation, 12

matplolibinteractif, 86

Matplotlibmatplotlibrc, fichier de configuration, 11test de l’installation, 10

matplotlibcommandes, 85ecriture de donnees, 84interface d’utilisateur, 95ipython, 86lecture de donnees, 84rc(), 88Symboles mathematiques, 88Type d’evenements interactifs, 99

156 INDEX

matricealgebre lineaire, 77diagonale, 75extraction de colonnes ou rangees, 76multiplication, 76produit exterieur, 76produit interieur, 76systeme d’equations lineaires, 77trace, 75transposition, 75

matrixmultiply, 76maximum, 74, 75methodes

principale, 53methodes

arguments, 53recursives, 55

methodes, 49privees/publiques, 51

minimum, 74, 75moulage, 22MS Windows, 9

installation, 9multiply, 74

nombres aleatoires et preudo-aleatoires, 78nombres complexes

conversion, 22noms de variables, 18not, 74Numarray, 67Numeric

arange, 71array, 69extraire elements, 72fromshape, 71identity, 72installation, 68ones, 71reshape, 70, 71resize, 70zeroes, 71

Numeric, 67Numpy, 67

operateurs

arithmetiques, 21d’affection (==), 32hierarchie, 33logiques, 32relationnels, 32

open, 37or, 74outerproduct, 76

print, 30print

formattage, 31priorite, 21product, 74produit

scalaire, 74tous les elements, 75

programme-type, 49promotion numerique, 22pylab, voir matplotlib, 85Python

test de l’installation, 9

Quitter le programme, 45

reelsconversion, 22transformer en, 27transformer en chaıne, 27types d’objets, 19

randint, 80random, 79random(), 78raw input, 31readlines, 38recursion, 55redirection, 36repr(), encodage, 26

seed, 79sin, 74sinh, 74solve linear equations, 77somme, 75sort, 43sortie standard

redirection, 36

INDEX 157

sortie standard, 30formattage, 31

sortir d’une boucle avec break, 36sqrt, 74structure

de selection (voir if), 33sum, 74

take, 76tan, 74tanh, 74Tkinter

Button, 118Canvas, 114champs textuel, 120create arc, 115create ellipse, 115create line, 114create polygone, 115create rectangle, 115create text, 116elements essentiels, 113Entry, 120etiquettes, 116, 117graphique et interface, 123grid, 124Label, 117mot de passe (texte cache), 120pack, 124

trace, 75transpose, 75types d’objets

entiers, 19nombres complexes, 20pre-definis, 19reels, 19

uniform, 80Unix, voir Linux, voir Linux

variablesglobales, 48locales, 48

while, 35

xmgrace, 139xor, 74

phy 1234 : introduction `a la physique num©rique - d©partement de

Documents