initiation python

Initiation ` Python par lexemple [email protected] 7 mars 2007 Version 1.2.1

2

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

c 2003-2007, Raphal Marvie e

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

3

4


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

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

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

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

2.3

2.4

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

Mme si un tel cas semblerait un peu bizarre. e

9

10

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

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


Chapitre 1 Premiers pas1.1 Utilisation de Python

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

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

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

11

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

Premiers pas

1.21.2.1

Structures de baseCommentaires

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

1.2.2

Typage en Python

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


1.2 Structures de base

13

1.2.3

Arithmtique e

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

= 12.0 / 3

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

1.2.4

Cha nes de caract`res e

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


14 1.2.4.1 Concatnation e

Premiers pas

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

1.2.4.2

Achage

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

1.2.4.3

Manipulations

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

>>> x [ -3:] ld !


1.2 Structures de base>>> x [3:] lo world ! >>> x [:] hello world ! >>> x [1: -1] ello world

15

1.2.5

Listes

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

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

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

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

16

Premiers pas

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

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

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

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


17

1.2.6

Listes et cha nes de caract`res e

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

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

1.2.7

Tuples

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

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

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

18

Premiers pas

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

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

1.2.8

Dictionnaires

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

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



19

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

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

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

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


20

Premiers pas

1.31.3.1

ConstructionsStructuration et indentation

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

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

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

1.3.2

Tests

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

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


1.3 Constructions

21

1.3.3

Boucles

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

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

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

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


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

Premiers pas

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

1.3.3.2

Boucles while

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

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

1.3.4

Fonctions

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

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


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

23

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

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

1.3.5

Documenter

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

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


24

Premiers pas

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

1.41.4.1

Autres lments sur les squences ee eFonctions de manipulation de squences e

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

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

Mme si la documentation tient sur une seule. e


1.4 Autres lments sur les squences ee e>>> def iseven ( x ): ... return x % 2 ... >>> filter ( iseven , [1 , 2 , 3 , 4 , 5 , 6]) [1 , 3 , 5]

25

1.4.1.2

map

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

1.4.1.3

reduce

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

1.4.2

Listes en comprhension e

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


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

Premiers pas

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

1.4.3

Itrateurs et gnrateurs e e e

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

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

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


1.4 Autres lments sur les squences ee e>>> ... 2 4 >>> [2 , for i in g : print i , 6 8 list ( elt * 2 for elt in foo ) 4 , 6 , 8]

27

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

1.4.4

Boucles for problmatiques e

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

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

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


28

Premiers pas

1.51.5.1

ExercicesManipulations de donnes e

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


Chapitre 2 Quelques modules et built-in2.12.1.1

Dnition et utilisation de modules eDnition e

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

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

29

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

Quelques modules et built-in

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

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


2.1 Dnition et utilisation de modules e

31

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

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

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

32


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

2.2

Quelques modules standards et utiles

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

2.2.1

Le module sys

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

platform Nom du syst`me dexploitation. e>>> sys . platform darwin

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

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

33

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

2.2.2

Le module string

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

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

2.2.2.2

Les fonctions principales

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

world ! )

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

34

Quelques modules et built-in>>> string . strip ( hello world ! \ n ) # [2 nd arg ] hello world ! >>> string . expandtabs ( \ thello world ! , 4) hello world !

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

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

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

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


2.2 Quelques modules standards et utiles

35

2.2.3

Le module re

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

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

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

2.2.3.2

Oprations de manipulation e

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

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


36 2.2.3.3 Utilisation dexpressions compiles e


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

2.2.4

Le module os

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

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

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


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

37

2.2.5

Le module os.path

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

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

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

2.2.6

Les modules glob et fnmatch

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


38


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

2.2.7

Le module getpass

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

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

2.3

Built-in en Python

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

2.3.12.3.1.1

Les chiersLes objets chiers

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


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

39

2.3.1.2

Lecture dans un chier

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

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

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

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

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


2.3.1.3

Ecriture dans un chier

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

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

2.3.2

Conversions de type

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


2.3 Built-in en Python Mais Attention aux arrondis>>> float ( 12.3 ) 12.3 00 00 00 00000 00 1

41

2.3.3

Evaluation dynamique

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

eval() value une expression (compile ou non) pass en param`tre. e e e e>>> x = 2 >>> eval ( x + 1 ) 3 >>> eval ( obj ) 3

2.3.4

Assertions

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


42


2.42.4.1

ExercicesUtilitaire de sauvegarde

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

2.4.2

Extraction de donnes e

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


Chapitre 3 Plongeon dans les objets3.13.1.1

Des objets, que des objetsRappels des principes de base de POO

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

3.1.2

Objets et rfrences ee

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

44 (les mthodes). e

Plongeon dans les objets

3.1.33.1.3.1

ClassesDnition et instanciation e

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

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

3.1.3.2

Dnition dattributs et du constructeur e

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

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

3.1 Des objets, que des objets

45

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

3.1.4

Hritage e

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

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


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


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

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

an X

an Y

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


3.2 Structures des objets

47

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

3.1.5

Classes vs modules

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

3.23.2.1

Structures des objetsIntrospection simple

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

La fonction type() donne le type dune rfrence. ee>>> type ( c ) < type instance > >>> type ([1 , 2]) < type list >2

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


48


3.2.2

Classes et attributs

Une classe ne contient que des attributs. Elle peut tre vue comme un simple dictione naire contenant des associations nom / rfrence. Une fonction de la classe (ou mthode) ee e est en fait un attribut qui est

initiation python

Documents

se e e e passe

donnes e

e rfrence

complter e

ce support sont e e

ce e e support nest

noeuds dom e

squences ee e