Cours Python 3

Bob CORDEAU
Introduction Python 3
version 2.71828
bcordeau@numericable.fr
Informatique : Rencontre de la logique formelle et du fer souder.

Maurice Nivat
Remerciements : Sans les encouragements de Grard Swinnen, jamais je naurais os me lancer dans laventure de lenseignement de Python. Quil en soit remerci. Ce document a bnci des corrections impitoyables de Laurent Pointal (LIMSI), des lectures attentives de Michelle Kessous, de Michelle Cordeau et de Georges Vincents (IUT dOrsay, dpartement Mesures Physiques). Grand merci ma lle Hlne pour ses illustrations ; les aventures de Steven le Python enchantent les ttes de paragraphe. Merci Tarek Ziad pour les emprunts ses publications, en particulier je remercie les ditions Eyrolles pour leur aimable autorisation de publier le dialogue de la page 102, ainsi que les ditions Dunod pour leur aimable autorisation de publier les exemples des pages 88, 90, 96 et 98. Enn il me faudrait saluer tous les auteurs que jai butins sur Internet... Quau moins, je noublie pas ceux qui jai fait les plus grands emprunts dans les annexes : Sebsauvage et Christian Schindelhauer.
Avant-propos
La version 3 actuelle de Python abolit la compatibilit descendante avec la srie des versions 2.x 1 , dans le but dliminer les faiblesses originelles du langage. La ligne de conduite du projet tait de rduire la redondance dans le fonctionnement de Python par la suppression des mthodes obsoltes . qui sadresse ce cours ? Ce cours prend la suite des Notes de cours Python 2 destin aux tudiants de Mesures Physiques de lIUT dOrsay. Bien qu ce jour lore des bibliothques tierces ne soit pas pas encore riche (entre autres la bibliothque numpy nest pas disponible), il semble utile de disposer dun cours gnraliste en franais consacr la version 3 de Python. Nous en avons prot pour toer le texte de trois chapitres et pour proposer une forme plus pratique pour un texte suceptible dtre imprim, tout en restant agrable consulter lcran. Outre ce cadre universitaire assez rduit, ce cours sadresse toute personne dsireuse dapprendre Python en tant que premier langage de programmation. Ces notes de programmation reposent sur quelques partis pris : le choix du langage Python version 3 ; le choix de logiciels libres ou gratuits : des diteurs spcialiss comme Wingware 3 . A des outils open source : gnuplot, XLTEX dans sa distribution TEXLive, lditeur Kile... et sur labondance des ressources et de la documentation sur le Web. Licence : Ce cours est mis disposition selon le Contrat Paternit 2.0 France disponible en ligne creativecommons.org/licenses/by/2.0/fr/ ou par courrier postal Creative Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA.
1. Cest une grave dcision, mrement rchie : Un langage qui bouge peu permet une industrie qui bouge beaucoup (Bertrand Meyer) 2. disponibles ladresse http ://www.iut-orsay.fr/dptmphy/Pedagogie/coursPython.pdf. 3. spcialement sa version Wing IDE 101, gratuite pour toutes les plateformes.
Table des matires

1 Introduction 1.1 Principales caractristiques du langage Python . . . . . 1.2 Matriel et logiciel . . . . . . . . . . . . . . . . . . . . 1.2.1 Lordinateur . . . . . . . . . . . . . . . . . . . 1.2.2 Deux sortes de programmes . . . . . . . . . . . 1.3 Les langages . . . . . . . . . . . . . . . . . . . . . . . 1.3.1 Des langages de dirents niveaux . . . . . . . 1.3.2 Bref historique des langages . . . . . . . . . . . 1.4 Production des programmes . . . . . . . . . . . . . . . 1.4.1 Deux techniques de production des programmes 1.4.2 Technique de production de Python . . . . . . . 1.4.3 La construction des programmes . . . . . . . . 1.5 Algorithme et programme . . . . . . . . . . . . . . . . 1.5.1 Dnitions . . . . . . . . . . . . . . . . . . . 1.5.2 La prsentation des programmes . . . . . . . . 1.6 Les implmentations de Python . . . . . . . . . . . . . 2 La calculatrice Python 2.1 Les modes dexcution . . . . . . . . . . . . . . . . . 2.1.1 Les deux modes dexcution dun code Python 2.2 Identiants et mots cls . . . . . . . . . . . . . . . . 2.2.1 Identiants . . . . . . . . . . . . . . . . . . 2.2.2 Style de nommage . . . . . . . . . . . . . . . 2.2.3 Les mots rservs de Python 3 . . . . . . . . 2.3 Notion dexpression . . . . . . . . . . . . . . . . . . 2.4 Les types de donnes entiers . . . . . . . . . . . . . . 2.4.1 Le type int . . . . . . . . . . . . . . . . . 2.4.2 Le type bool . . . . . . . . . . . . . . . . . 2.5 Les types de donnes ottants . . . . . . . . . . . . . 2.5.1 Le type float . . . . . . . . . . . . . . . . 2.5.2 Le type complex . . . . . . . . . . . . . . 2.6 Variables et aectation . . . . . . . . . . . . . . . . . 2.6.1 Les variables . . . . . . . . . . . . . . . . . 2.6.2 Laectation . . . . . . . . . . . . . . . . . . 2.6.3 Aecter nest pas comparer ! . . . . . . . . . 2.6.4 Les variantes de laectation . . . . . . . . . 2.6.5 Les aectations (explications graphiques) . . . 2.7 Les chanes de caractres . . . . . . . . . . . . . . . iii . . . . . . . . . . . . . . . . . . . . 1 1 2 2 2 3 3 3 3 3 4 4 4 4 5 5 7 7 7 8 8 8 9 9 9 9 10 11 11 11 12 12 12 12 13 13 13
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
iv
TABLE DES MATIRES 2.7.1 Les chanes de caractres : prsentation . . . . . . 2.7.2 Les chanes de caractres : oprations . . . . . . . 2.7.3 Les chanes de caractres : fonctions vs mthodes 2.7.4 Mthodes de test de ltat dune chane ch . . . . 2.7.5 Mthodes retournant une nouvelle chane . . . . . 2.7.6 Les chanes de caractres : indexation simple . . . 2.7.7 Extraction de sous-chanes . . . . . . . . . . . . Les donnes binaires . . . . . . . . . . . . . . . . . . . . Les entres-sorties . . . . . . . . . . . . . . . . . . . . . 2.9.1 Les entres . . . . . . . . . . . . . . . . . . . . 2.9.2 Les sorties . . . . . . . . . . . . . . . . . . . . . 2.9.3 Les squences dchappement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 14 14 14 15 16 16 17 17 18 19 19 21 21 22 22 23 23 23 23 24 24 24 24 25 27 27 27 27 27 28 28 28 29 30 30 31 31 32 33 33 33 34 35 35
2.8 2.9
3 Le contrle du ux dinstructions 3.1 Les instructions composes . . . . . . . . . . . 3.2 Choisir . . . . . . . . . . . . . . . . . . . . . . 3.2.1 Choisir : if - [elif] - [else] 3.2.2 Syntaxe compacte dune alternative . . . 3.3 Boucler . . . . . . . . . . . . . . . . . . . . . 3.3.1 Boucler : while . . . . . . . . . . . . 3.3.2 Parcourir : for . . . . . . . . . . . . . 3.4 Ruptures de squences . . . . . . . . . . . . . . 3.4.1 Interrompre une boucle : break . . . . 3.4.2 Court-circuiter une boucle : continue 3.4.3 Syntaxe complte des boucles . . . . . . 3.4.4 Exceptions . . . . . . . . . . . . . . . 4 Les conteneurs standard 4.1 Les squences . . . . . . . . . . . . . 4.1.1 Quest-ce quune squence ? . . 4.2 Les listes . . . . . . . . . . . . . . . . 4.2.1 Dnition, syntaxe et exemples 4.2.2 Initialisations et tests . . . . . 4.2.3 Mthodes . . . . . . . . . . . 4.2.4 Manipulation des tranches . 4.3 Les listes en intension . . . . . . . . . 4.4 Les tuples . . . . . . . . . . . . . . . 4.5 Retour sur les rfrences . . . . . . . . 4.6 Les tableaux associatifs . . . . . . . . 4.6.1 Les types tableaux associatifs . 4.6.2 Les dictionnaires (dict) . . . 4.7 Les ensembles (set) . . . . . . . . . 4.8 Les chiers textuels . . . . . . . . . . 4.8.1 Les chiers : introduction . . . 4.8.2 Gestion des chiers . . . . . . 4.9 Itrer sur les conteneurs . . . . . . . . 4.10 Lachage format . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . .
TABLE DES MATIRES 5 Fonctions et espaces de noms 5.1 Dnition et syntaxe . . . . . . . . . . . . . . . . . . . . . . . . 5.2 Passage des arguments . . . . . . . . . . . . . . . . . . . . . . . 5.2.1 Mcanisme gnral . . . . . . . . . . . . . . . . . . . . 5.2.2 Un ou plusieurs paramtres, pas de retour . . . . . . . . . 5.2.3 Un ou plusieurs paramtres, utilisation du retour . . . . . 5.2.4 Passage dune fonction en paramtre . . . . . . . . . . . 5.2.5 Paramtres avec valeur par dfaut . . . . . . . . . . . . . 5.2.6 Nombre darguments arbitraire : passage dun tuple . . . . 5.2.7 Nombre darguments arbitraire : passage dun dictionnaire 5.3 Espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3.1 Porte des objets . . . . . . . . . . . . . . . . . . . . . 5.3.2 Rsolution des noms : rgle LGI . . . . . . . . . . . . . 6 Modules et packages 6.1 Modules . . . . . . . . . . . . . . . . . . 6.1.1 Import dun module . . . . . . . . 6.1.2 Exemples . . . . . . . . . . . . . 6.2 Bibliothque standard . . . . . . . . . . . 6.2.1 La bibliothque standard . . . . . 6.3 Bibliothques tierces . . . . . . . . . . . . 6.3.1 Une grande diversit . . . . . . . 6.3.2 Un exemple : la bibliothque Unum 6.4 Packages . . . . . . . . . . . . . . . . . .
v 39 39 41 41 41 41 42 42 43 43 44 44 44 47 47 47 48 49 49 52 52 52 53 55 55 56 57 57 57 57 58 58 58 59 59 59 60 60 60 60 60 60 62 62 63
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
7 La programmation Oriente Objet 7.1 Insusance de lapproche procdurale . . . . . . 7.2 Terminologie . . . . . . . . . . . . . . . . . . 7.3 Classes et instanciation dobjets . . . . . . . . . 7.3.1 Linstruction class . . . . . . . . . . 7.3.2 Linstanciation et ses attributs . . . . . . 7.3.3 Retour sur les espaces de noms . . . . . 7.4 Mthodes . . . . . . . . . . . . . . . . . . . . 7.5 Mthodes spciales . . . . . . . . . . . . . . . 7.5.1 Les mthodes spciales . . . . . . . . . 7.5.2 Linitialisateur . . . . . . . . . . . . . . 7.5.3 Surcharge des oprateurs . . . . . . . . 7.5.4 Exemple de surcharge . . . . . . . . . . 7.6 Hritage et polymorphisme . . . . . . . . . . . 7.6.1 Hritage et polymorphisme . . . . . . . 7.6.2 Exemple dhritage et de polymorphisme 7.7 Retour sur lexemple initial . . . . . . . . . . . 7.7.1 La classe Cercle : conception . . . . . 7.7.2 La classe Cercle . . . . . . . . . . . 7.8 Notion de Conception Oriente Objet . . . . . . 7.8.1 Composition . . . . . . . . . . . . . . . 7.8.2 Drivation . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . .
vi 8 Techniques avances 8.1 Techniques procdurales . . . . . . . . . . . . . . . . 8.1.1 Amliorer la documentation . . . . . . . . . . 8.1.2 Faire des menus avec un dictionnaire . . . . . 8.1.3 Les fonctions rcursives . . . . . . . . . . . . 8.1.4 Les gnrateurs et les expressions gnratrices 8.1.5 Les fonctions incluses . . . . . . . . . . . . . 8.1.6 Les dcorateurs . . . . . . . . . . . . . . . . 8.2 Techniques objets . . . . . . . . . . . . . . . . . . . 8.2.1 __slots__ et __dict__ . . . . . . . . . 8.2.2 Functor . . . . . . . . . . . . . . . . . . . . 8.2.3 Les accesseurs . . . . . . . . . . . . . . . . . 8.3 Techniques fonctionnelles . . . . . . . . . . . . . . . 8.3.1 Directive lambda . . . . . . . . . . . . . . 8.3.2 Les fonctions map, filter et reduce . . . 8.3.3 Les applications partielles de fonctions . . . . 9 La programmation OO graphique 9.1 Programmes pilots par des vnements . . 9.2 La bibliothque tkinter . . . . . . . . 9.2.1 Prsentation . . . . . . . . . . . . 9.2.2 Les widgets de tkinter . . . . 9.2.3 Le positionnement des widgets . . 9.3 Deux exemples . . . . . . . . . . . . . . . 9.3.1 tkPhone, un exemple sans menu 9.3.2 IDLE, un exemple avec menu . .
TABLE DES MATIRES 65 65 65 66 67 69 70 71 72 72 72 73 75 75 75 76 79 79 80 80 80 81 81 81 85 87 87 87 88 89 89 93 96 101 105 109 111 113 115 129
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
10 Notion de dveloppement agile 10.1 Les tests . . . . . . . . . . . . . . . . . . . . . . . . 10.1.1 Tests unitaires et tests fonctionnels . . . . . . 10.1.2 Le dveloppement dirig par les tests . . . . . 10.2 La documentation . . . . . . . . . . . . . . . . . . . 10.2.1 Le format reST . . . . . . . . . . . . . . . . 10.2.2 Le module doctest . . . . . . . . . . . . . 10.2.3 Le dveloppement dirig par la documentation A Interlude B Jeux de caractres et encodage C Les fonctions logiques D Les bases arithmtiques E Les fonctions de hachage F Exercices corrigs G Ressources
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
TABLE DES MATIRES H Glossaire Colophon
vii 133 143
viii
TABLE DES MATIRES
Table des gures

1.1 1.2 1.3 2.1 2.2 2.3 2.4 2.5 2.6 2.7 3.1 4.1 4.2 4.3 5.1 5.2 5.3 7.1 8.1 8.2 9.1 9.2 9.3 9.4 10.1 10.2 10.3 10.4 10.5 10.6 Chane de compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . Technique de linterprtation . . . . . . . . . . . . . . . . . . . . . . . . Interprtation du bytecode compil . . . . . . . . . . . . . . . . . . . . . La boucle dvaluation de IDLE . . . . . Laectation illustre. . . . . . . . . . . Lindexation dune chane. . . . . . . . . Extraction de sous-chanes. . . . . . . . Codes, glyphes, caractres et octets. . . . Les entres-sorties. . . . . . . . . . . . Utilisation des squences dchappement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 4 4 7 13 16 17 18 18 20 22 31 32 33 40 41 44 61 68 77 79 80 82 86 92 94 95 97 98 99
Les instructions composes. . . . . . . . . . . . . . . . . . . . . . . . . . Assignation augmente dun objet non modiable. . . . . . . . . . . . . . . Assignation augmente dun objet modiable. . . . . . . . . . . . . . . . . Oprations sur les ensempbles . . . . . . . . . . . . . . . . . . . . . . . . Les avantages de lutilisation des fonctions . . . . . . . . . . . . . . . . . Passage des arguments par aectation. . . . . . . . . . . . . . . . . . . . . Rgle LGI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conception UML de la classe Cercle. . . . . . . . . . . . . . . . . . . . Empilage/dpilage de 4 ! . . . . . . . . . . . . . . . . . . . . . . . . . . . Application partielle dun widget . . . . . . . . . . . . . . . . . . . . . . . Deux styles de programmation. Un exemple simple . . . . . . tkPhone. . . . . . . . . . . . . IDLE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
exemple de sortie au format HTML. . . . . Excution du script doctest1.py. . . . Excution du script doctest2.py. . . . Excution du script example.py. . . . . Documentation du script doctest2.py. Documentation du script example.py. .
B.1 Table ASCII. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 B.2 Extrait de la table Unicode. . . . . . . . . . . . . . . . . . . . . . . . . . 106 ix
TABLE DES FIGURES B.3 Le jeu de caractres cp1252. . . . . . . . . . . . . . . . . . . . . . . . . 108 E.1 Le principe du hachage . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 E.2 Hachage des cls dun dictionnaire. . . . . . . . . . . . . . . . . . . . . . 114
Chapitre 1
Introduction linformatique
Ce premier chapitre introduit les grandes caractristiques du langage Python, replace Python dans lhistoire des langages, donne les particularits de production des scripts, dni la notion si importante dalgorithme et conclut sur les divers implmentations disponibles.
1.1
Principales caractristiques du langage Python
Historique 1991 : Guido van Rossum publie Python au CWI (Pays-Bas) partir du langage ABC et du projet AMOEBA (systme dexploitation distribu) 1996 : sortie de Numerical Python 2001 : naissance de de la PSF (Python Software Fundation) Les versions se succdent... Un grand choix de modules disponibles, des colloques annuels sont organiss, Python est enseign dans plusieurs universits et est utilis en entreprise... Fin 2008 : sorties simultanes de Python 2.6 et de Python 3.0 2010 : versions en cours 1 : v2.7 et v3.1.2 Langage Open Source Licence Open Source CNRI, compatible GPL, mais sans la restriction copyleft. Python est libre et gratuit mme pour les usages commerciaux GvR (Guido van Rossum) est le BDFL (dictateur bnvole vie !) Importante communaut de dveloppeurs Nombreux outils standard disponibles : Batteries included Travail interactif Nombreux interprteurs interactifs disponibles Importantes documentations en ligne Dveloppement rapide et incrmentiel Tests et dbogage faciles Analyse interactive de donnes Langage interprt rapide Interprtation du bytecode compil
1. en octobre.
CHAPITRE 1. INTRODUCTION De nombreux modules sont disponibles partir de bibliothques optimises crites en C, C++ ou FORTRAN Simplicit du langage (cf. Zen of Python p. 101) : Syntaxe claire et cohrente Indentation signicative Gestion automatique de la mmoire (garbage collector) Typage dynamique fort : pas de dclaration Orientation objet Modle objet puissant mais pas obligatoire Structuration multichier trs facile des applications : facilite les modications et les extensions Les classes, les fonctions et les mthodes sont des objets dits de premire classe. Ces objets sont traits comme tous les autres (on peut les aecter, les passer en paramtre) Ouverture au monde Interfaable avec C/C++/FORTRAN Langage de script de plusieurs applications importantes Excellente portabilit Disponibilit de bibliothques Plusieurs milliers de packages sont disponibles dans tous les domaines
1.2 Environnements matriel et logiciel

1.2.1 Lordinateur
On peut simplier la dnition de lordinateur de la faon suivante : Dnition Automate dterministe composants lectroniques.
Lordinateur comprend entre autres : un microprocesseur avec une UC (Unit de Contrle), une UAL (Unit Arithmtique et Logique), une horloge, une mmoire cache rapide ; de la mmoire volatile (dite vive ou RAM), contenant les instructions et les donnes ncessaires lexcution des programmes. La RAM est forme de cellules binaires (bits) organises en mots de 8 bits (octets) ; des priphriques : entres/sorties, mmoires permanentes (dites mortes : disque dur, cl USB, CD-ROM...), rseau...
1.2.2 Deux sortes de programmes

On distingue, pour faire rapide : Le systme dexploitation : ensemble des programmes qui grent les ressources matrielles et logicielles. Il propose une aide au dialogue entre lutilisateur et lordinateur : linterface textuelle (interprteur de commande) ou graphique (gestionnaire de fentres). Il est souvent multitche et parfois multiutilisateur ;
1.3. LES LANGAGES
les programmes applicatifs sont ddis des tches particulires. Ils sont forms dune srie de commandes contenues dans un programme source qui est transform pour tre excut par lordinateur.
1.3
Les langages
1.3.1 Des langages de dirents niveaux

Chaque processeur possde un langage propre, directement excutable : le langage machine. Il est form de 0 et de 1 et nest pas portable, mais cest le seul que lordinateur puisse utiliser ; le langage dassemblage est un codage alphanumrique du langage machine. Il est plus lisible que le langage machine, mais nest toujours pas portable. On le traduit en langage machine par un assembleur ; les langages de haut niveau. Souvent normaliss, ils permettent le portage dune machine lautre. Ils sont traduits en langage machine par un compilateur ou un interprteur.
1.3.2 Bref historique des langages

Annes 50 (approches exprimentales) : FORTRAN, LISP, COBOL, ALGOL... Annes 60 (langages universels) : PL/1, Simula, Smalltalk, Basic... Annes 70 (gnie logiciel) : C, PASCAL, ADA, MODULA-2... Annes 80 (programmation objet) : C++, LabView, Eiel, Perl, VisualBasic... Annes 90 (langages interprts objet) : Java, tcl/Tk, Ruby, Python... Annes 2000 (langages commerciaux propritaires) : C#, VB.NET...
Des centaines de langages ont t crs, mais lindustrie nen utilise quune minorit.
1.4
Production des programmes
1.4.1 Deux techniques de production des programmes

La compilation est la traduction du source en langage objet. Elle comprend au moins quatre phases (trois phases danalyse lexicale, syntaxique et smantique et une phase de production de code objet). Pour gnrer le langage machine il faut encore une phase particulire : ldition de liens. La compilation est contraignante mais ore au nal une grande vitesse dexcution.
Figure 1.1 Chane de compilation Dans la technique de linterprtation chaque ligne du source analys est traduite au fur et mesure en instructions directement excutes. Aucun programme objet nest gnr. Cette technique est trs souple mais les codes gnrs sont peu performants : linterprteur doit tre utilis chaque excution...
CHAPITRE 1. INTRODUCTION
Figure 1.2 Technique de linterprtation
1.4.2 Technique de production de Python

Technique mixte : linterprtation du bytecode compil. Bon compromis entre la facilit de dveloppement et la rapidit dexcution ; le bytecode (forme intermdiaire) est portable sur tout ordinateur muni de la machine virtuelle Python.
Figure 1.3 Interprtation du bytecode compil Pour excuter un programme, Python charge le chier source .py (ou .pyw) en mmoire vive, en fait lanalyse syntaxique, produit le bytecode et enn lexcute. Pour chaque module import par le programme, Python vrie dabord sil existe une version prcompile du bytecode (dans un chier .pyo ou .pyc) dont la date correspond au chier .py. Sil y en a un, Python lutilise, sinon il fait une analyse syntaxique du module .py, et utilise le bytecode quil vient de gnrer. En pratique, il nest pas ncessaire de compiler explicitement un module, Python gre ce mcanisme de faon transparente.
1.4.3 La construction des programmes

Le gnie logiciel tudie les mthodes de construction des programmes. Plusieurs modles sont envisageables, entre autres : la mthodologie procdurale. On emploie lanalyse descendante (division des problmes) et remontante (rutilisation dun maximum de sous algorithmes). On seorce ainsi de dcomposer un problme complexe en sous-programmes plus simples. Ce modle structure dabord les actions ; la mthodologie objet. On conoit des fabriques (classes) qui servent produire des composants (objets) qui contiennent des donnes (attributs) et des actions (mthodes). Les classes drivent (hritage et polymorphisme) de classes de base dans une construction hirarchique. Python ore les deux techniques.
1.5 Algorithme et programme

1.5.1 Dnitions
Dnition Algorithme : ensemble des tapes permettant datteindre un but en rptant un nombre ni de fois un nombre ni dinstructions.
1.6. LES IMPLMENTATIONS DE PYTHON Un algorithme se termine en un temps ni.
Dnition Programme : un programme est la traduction dun algorithme en un langage compilable ou interprtable par un ordinateur.
Il est souvent crit en plusieurs parties dont une qui pilote les autres : le programme principal.
1.5.2 La prsentation des programmes

Un programme source est destin ltre humain. Pour en faciliter la lecture, il doit tre judicieusement comment. La signication de parties non triviales (et uniquement celles-ci) doit tre explique par un commentaire. Un commentaire commence par le caractre # et stend jusqu la n de la ligne :
#--------------------# Voici un commentaire #--------------------9 + 2 # En voici un autre
1.6

Les implmentations de Python
CPython : Classic Python, cod en C, portable sur dirents systmes Python3000 : Python 3, la nouvelle implmentation de CPython Jython : cibl pour la JVM (utilise le bytecode de JAVA) IronPython : Python.NET, crit en C#, utilise le MSIL (MicroSoft Intermediate Language) Stackless Python : limine lutilisation de la pile du langage C (permet de rcurser tant que lon veut) Pypy : projet de recherche europen dun interprteur Python crit en Python
CHAPITRE 1. INTRODUCTION
Chapitre 2
La calculatrice Python
Comme tout langage, Python permet de manipuler des donnes grce un vocabulaire de mots rservs et grce des types de donnes approximation des ensembles de dnition utiliss en mathmatique. Ce chapitre prsente les rgles de construction des identiants, les types de donnes simples (les conteneurs seront examins au chapitre 4) ainsi que les types chane de caractres (Unicode et binaires). Enn, last but not least, ce chapitre stend sur les notions non triviales de variables, de rfrences dobjet et daectation.
2.1
Les modes dexcution
2.1.1 Les deux modes dexcution dun code Python

Soit on enregistre un ensemble de commandes Python dans un chier grce un diteur (on parle alors dun script Python) que lon excute par une commande ou par une touche du menu de lditeur ; soit on utilise un interprteur (par exemple IDLE) pour obtenir un rsultat immdiat grce linterprteur Python embarqu dans IDLE qui excute la boucle dvaluation (cf. Fig. 2.1)
Figure 2.1 La boucle dvaluation de IDLE
CHAPITRE 2. LA CALCULATRICE PYTHON
2.2 Identiants et mots cls

2.2.1 Identiants
Comme tout langage, Python utilise des identiants pour nommer ses objets. Dnition Un identiant Python est une suite non vide de caractres, de longueur quelconque, forme dun caractre de dbut et de zro ou plusieurs caractres de continuation.
Sachant que : un caractre de dbut peut tre nimporte quelle lettre Unicode (cf. annexe B p. 105), ainsi que le caractre soulign (_) ; un caractre de continuation est un caractre de dbut, un chire ou un point. Attention Les identiants sont sensibles la casse et ne doivent pas tre un mot cl.
2.2.2 Style de nommage

Il est important dutiliser une politique cohrente de nommage des identiants. Voici le style utilis dans ce document 1 : UPPERCASE ou UPPER_CASE pour les constantes ; TitleCase pour les classes ; UneExceptionError pour les exceptions ; camelCase pour les fonctions, les mthodes et les interfaces graphiques ; unmodule_m pour les modules ; lowercase ou lower_case pour tous les autres identiants.
viter dutiliser l, O et I seuls (l minuscule, o et i majuscules). Enn, on rservera les notations suivantes :
_xxx # usage interne __xxx # attribut de classe __xxx__ # nom spcial rserv
Exemples :
NB_ITEMS = 12 # class MaClasse: pass # def maFonction(): pass mon_id = 5 # UPPER_CASE TitleCase # camelCase lower_case
1. Voir les dtails dans la PEP 8 : Style Guide for Python .
2.3. NOTION DEXPRESSION
2.2.3 Les mots rservs de Python 3

La version 3.1.2 de Python compte 33 mots cls : and as assert break class continue def del elif else except False finally for from global if import in is lambda None nonlocal not or pass raise return True try while with yield
2.3
Notion dexpression
Dnition Une expression est une portion de code que linterprteur Python peut valuer pour obtenir une valeur. Les expressions peuvent tre simples ou complexes. Elles sont formes dune combinaison de littraux, didentiants et doprateurs.
Exemples de deux expressions simples et dune expression complexe :

id1 = 15.3 id2 = maFonction(id1) if id2 > 0: id3 = math.sqrt(id2) else: id4 = id1 - 5.5*id2
2.4
Les types de donnes entiers
Python 3 ore deux types entiers standard : int et bool.
2.4.1 Le type int

Le type int nest limit en taille que par la mmoire de la machine. Les entiers littraux sont dcimaux par dfaut, mais on peut aussi utiliser les bases suivantes (cf. p. 111) :
>>> 2009 # dcimal 2009 >>> 0b11111011001 # binaire 2009 >>> 0o3731 # octal 2009 >>> 0x7d9 # hexadecimal 2009
10 Oprations arithmtiques Les principales oprations :

20 + 3 # 23 20 - 3 # 17 20 * 3 # 60 20 ** 3 # 8000 20 / 3 # 6.666666666666667 20 // 3 # 6 (division entire) 20 % 3 # 2 (modulo) abs(3 - 20) # valeur absolue
Bien remarquer le rle des deux oprateurs de division : / : produit une division ottante ; // : produit une division entire. Bases usuelles Un entier crit en base 10 (par exemple 179) peut se reprsenter en binaire, octal et hexadcimal en utilisant les syntaxes suivantes :
>>> 0b10110011 # binaire 179 >>> 0o263 # octal 179 >>> 0xB3 # hexadcimal 179
2.4.2 Le type bool

Deux valeurs possibles : False, True. Oprateurs de comparaison : ==, !=, >, >=, < et <= :
2 > 8 # False 2 <= 8 < 15 # True
Oprateurs logiques (concept de shortcut) : not, or et and. En observant les tables de vrit des oprateurs and et or (cf. p. 109), on remarque que : ds quun premier membre a la valeur False, lexpression False and expression2 vaudra False. On na donc pas besoin de lvaluer ; de mme ds quun premier membre a la valeur True, lexpression True or expression2 vaudra True. Cette optimisation est appele principe du shortcut :
(3 == 3) or (9 > 24) # True (ds le premier membre) (9 > 24) and (3 == 3) # False (ds le premier membre)
Les oprations logiques et de comparaisons sont values an de donner des rsultats boolens dans False, True.
2.5. LES TYPES DE DONNES FLOTTANTS Les expressions boolennes Une expression boolenne (cf. p. 109) a deux valeurs possibles : False ou True. Python attribue une expression boolenne la valeur False si cest : la constante False ; la constante None ; une squence ou une collection vide ; une donne numrique de valeur 0. Tout le reste vaut True.
11
2.5
Les types de donnes ottants
2.5.1 Le type float

Un float est not avec un point dcimal ou en notation exponentielle :
2.718 .02 3e8 6.023e23
Les ottants supportent les mmes oprations que les entiers. Les float ont une prcision nie indique dans sys.float_info.epsilon. Limport du module math autorise toutes les oprations mathmatiques usuelles :
import math print(math.sin(math.pi/4)) # 0.7071067811865475 print(math.degrees(math.pi)) # 180.0 print(math.factorial(9)) # 362880 print(math.log(1024, 2)) # 10.0
2.5.2 Le type complex

Les complexes sont crits en notation cartsienne forme de deux ottants. La partie imaginaire est suxe par j :
print(1j) # 1j print((2+3j) + (4-7j)) # (6-4j) print((9+5j).real) # 9.0 print((9+5j).imag) # 5.0 print((abs(3+4j))) # 5.0 : module
Un module mathmatique spcique (cmath) leur est rserv :

import cmath print(cmath.phase(-1 + 0j)) # 3.14159265359 print(cmath.polar(3 + 4j)) # (5.0, 0.9272952180016122) print(cmath.rect(1., cmath.pi/4)) # (0.707106781187+0.707106781187 j)
12
2.6 Variables et aectation

2.6.1 Les variables
Ds que lon possde des types de donnes, on a besoin des variables pour stocker les donnes. En ralit, Python nore pas la notion de variable, mais plutt celle de rfrence dobjet. Tant que lobjet nest pas modiable (comme les entiers, les ottants, etc.), il ny a pas de dirence notable. On verra que la situation change dans le cas des objets modiables... Dnition Une variable est un identiant associ une valeur. Informatiquement, cest une rfrence dobjet situe une adresse mmoire.
2.6.2 Laectation
Dnition On aecte une variable par une valeur en utilisant le signe = (qui na rien voir avec lgalit en math !). Dans une aectation, le membre de gauche reoit le membre de droite ce qui ncessite dvaluer la valeur correspondant au membre de droite avant de laecter au membre de gauche.
a = 2 # prononcez : a reoit 2 b = 7.2 * math.log(math.e / 45.12) - 2*math.pi c = b ** a
La valeur dune variable, comme son nom lindique, peut voluer au cours du temps (la valeur antrieure est perdue) :
a = a + 1 # 3 (incrmentation) a = a - 1 # 2 (dcrmentation)
2.6.3 Aecter nest pas comparer !

Laectation a un eet (elle modie ltat interne du programme en cours dexcution) mais na pas de valeur (on ne peut pas lutiliser dans une expression) :
>>> a = 2 >>> x = (a = 3) + 2 SyntaxError: invalid syntax
La comparaison a une valeur utilisable dans une expression mais na pas deet (lautomate interne reprsentant lvolution du programme nest pas modi) :
>>> x = (a == 3) + 2 >>> x 2
2.7. LES CHANES DE CARACTRES
13
(a) Trois aectations
(b) La donne c est supprime
(c) La donne a est supprime
Figure 2.2 Laectation illustre.
2.6.4 Les variantes de laectation

Outre laectation simple, on peut aussi utiliser les formes suivantes :
# affectation simple v = 4 # affectation augmente v += 2 # idem : v = v + 2 si v est dj rfrenc # affectation de droite gauche c = d = 8 # cibles multiples # affectations parallles dune squence e, f = 2.7, 5.1 # tuple g, h, i = [G, H, I] # liste x, y = coordonneesSouris() # retour multiple dune fonction
2.6.5 Les aectations (explications graphiques)

Dans les schmas de la gure 2.2, les cercles reprsentent les identicateurs alors que les rectangles reprsentent les donnes. Les aectations relient les identicateurs aux donnes : si une donne en mmoire nest plus relie, le ramasse-miettes (garbage collector) de Python la supprime automatiquement :
2.7
Les chanes de caractres
2.7.1 Les chanes de caractres : prsentation

Dnition Le type de donnes non modiable str reprsente une squence de caractres Uni-
14
code. Non modiable signie quune donne, une fois cre en mmoire, ne pourra plus tre change. Trois syntaxes de chanes sont disponibles. Remarquez que lon peut aussi utiliser le la place de , ce qui permet dinclure une notation dans lautre :
syntaxe1 = Premire forme avec un retour la ligne \n syntaxe2 = rDeuxime forme sans retour la ligne \n syntaxe3 = Troisime forme multi-ligne guillemets = Leau vive apostrophes = Forme avec des apostrophes
2.7.2 Les chanes de caractres : oprations

Longueur :
s = abcde len(s) # 5
Concatnation :
s1 = abc s2 = defg s3 = s1 + s2 # abcdefg
Rptition :
s4 = Fi! s5 = s4 * 3 # Fi! Fi! Fi! print(s5)
2.7.3 Les chanes de caractres : fonctions vs mthodes

On peut agir sur une chane (et plus gnralement sur une squence) en utilisant des fonctions (notion procdurale) ou des mthodes (notion objet). Pour appliquer une fonction, on utilise loprateur () appliqu la fonction :
ch1 = abc long = len(ch1) # 3
On applique une mthode un objet en utilisant la notation pointe entre la donne/variable laquelle on applique la mthode, et le nom de la mthode suivi de loprateur () appliqu la mthode :
ch2 = abracadabra ch3 = ch2.upper() # ABRACADABRA
2.7.4 Mthodes de test de ltat dune chane ch

Les mthodes suivantes sont valeur boolenne, cest--dire quelles retournent la valeur True ou False.
2.7. LES CHANES DE CARACTRES
15
La notation [xxx] indique un lment optionnel que lon peut donc omettre lors de lutilisation de la mthode. isupper() et islower() : retournent True si ch ne contient respectivement que des majuscules/minuscules :
print(cHAise basSe.isupper()) # False
istitle() : retourne True si seule la premire lettre de chaque mot de ch est en majuscule :
print(Chaise Basse.istitle()) # True
isalnum(), isalpha(), isdigit() et isspace() : retournent True si ch ne contient respectivement que des caractres alphanumriques, alphabtiques, numriques ou des espaces :
print(3 chaises basses.isalpha()) # False print(54762.isdigit()) # True
startswith(prefix[, start[, stop]]) et endswith(suffix[, start[, stop]]) : testent si la sous-chane dnie par start et stop commence respectivement par prefix ou nit par suffix :
print(abracadabra.startswith(ab)) # True print(abracadabra.endswith(ara)) # False
2.7.5 Mthodes retournant une nouvelle chane

lower(), upper(), capitalize() et swapcase() : retournent respectivement une chane en minuscule, en majuscule, en minuscule commenant par une majuscule, ou en casse inverse :
# s sera notre chane de test pour toutes les mthodes s = cHAise basSe print(s.lower()) # chaise basse print(s.upper()) # CHAISE BASSE print(s.capitalize()) # Chaise basse print(s.swapcase()) # ChaISE BASsE
expandtabs([tabsize]) : remplace les tabulations par tabsize espaces (8 par dfaut). center(width[, fillchar]), ljust(width[, fillchar]) et rjust(width[, fillchar]) : retournent respectivement une chane centre, justie gauche ou droite, complte par le caractre fillchar (ou par lespace par dfaut) :
print(s.center(20, -)) # ----cHAise basSe---print(s.rjust(20, @)) # @@@@@@@@cHAise basSe
zfill(width) : complte ch gauche avec des 0 jusqu une longueur maximale de width :
print(s.zfill(20)) # 00000000cHAise basSe
strip([chars]), lstrip([chars]) et rstrip([chars]) : suppriment toutes les combinaisons de chars (ou lespace par dfaut) respectivement au dbut et en n, au dbut, ou en n dune chane :
16

print(s.strip(ce)) # HAise basS
find(sub[, start[, stop]]) : renvoie lindex de la chane sub dans la sous-chane start stop, sinon renvoie -1. rfind() eectue le mme travail en commenant par la n. index() et rindex() font de mme mais produisent une erreur (exception) si la chane nest pas trouve :
print(s.find(se b)) # 4
replace(old[, new[, count]]) : remplace count instances (toutes par dfaut) de old par new :
print(s.replace(HA, ha)) # chaise basSe
split(seps[, maxsplit]) : dcoupe la chane en maxsplit morceaux (tous par dfaut). rsplit() eectue la mme chose en commenant par la n et striplines() eectue ce travail avec les caractres de n de ligne :
print(s.split()) # [cHAise, basSe]
join(seq) : concatne les chanes du conteneur seq en intercalant la chane sur laquelle la mthode est applique :
print(**.join([cHAise, basSe])) # cHAise**basSe
2.7.6 Les chanes de caractres : indexation simple

Pour indexer une chane, on utilise loprateur [ ] dans lequel lindex, un entier sign qui commence 0 indique la position dun caractre :
s = Rayon X # len(s) ==> 7 print(s[0]) # R print(s[2]) # y print(s[-1]) # X print(s[-3]) # n
Figure 2.3 Lindexation dune chane.
2.7.7 Extraction de sous-chanes

Loprateur [ ] avec 2 ou 3 index spars par le caractre : permet dextraire des souschanes (ou tranches) dune chane :
s = Rayon X # len(s) ==> 7 s[1:4] # ayo (de lindex 1 compris 4 non compris) s[-2:] # X (de lindex -2 compris la fin)
2.8. LES DONNES BINAIRES
17
Figure 2.4 Extraction de sous-chanes.

s[:3] s[3:] s[::2] # Ray (du dbut lindex 3 non compris) # on X (de lindex 3 compris la fin) # RynX (du dbut la fin, de 2 en 2)
2.8
Les donnes binaires
Les types binaires Python 3 propose deux types de donnes binaires : byte (non modiable) et bytearray (modiable). Une donne binaire contient une suite de zro ou plusieurs octets, cest--dire dentiers non signs sur 8 bits (compris dans lintervalle [0...255]). Ces types la C sont bien adapts pour stocker de grandes quantits de donnes. De plus Python fournit des moyens de manipulation ecaces de ces types. Les deux types sont assez semblables au type str et possdent la plupart de ses mthodes. Le type modiable bytearray possde des mthodes communes au type list. Exemples de donnes binaires et de mthodes :
# donnes binaires b_mot = bAnimal # chane prfixe par b : type byte print(b_mot) # bAnimal for b in b_mot: print(b, end= ) # 65 110 105 109 97 108 (cf. table ASCII) print() bMot = bytearray(b_mot) # retourne un nouveau tableau de bytes... bMot.pop() # ...qui possde les mthodes usuelles print() print(bMot, \n) # bytearray(bAnima) data = b5 Hills \x35\x20\x48\x69\x6C\x6C\x73 print(data.upper()) # b5 HILLS 5 HILLS print(data.replace(bill, bat)) # b5 Hats 5 Hats
Bien direncier les codes, glyphes, caractres et octets ! (Cf. Fig. 2.5)
2.9
Les entres-sorties
Lutilisateur a besoin dinteragir avec le programme (cf. Fig. 2.6). En mode console (on verra les interfaces graphiques ultrieurement), on doit pouvoir saisir ou entrer des in-
18
Figure 2.5 Codes, glyphes, caractres et octets. formations, ce qui est gnralement fait depuis une lecture au clavier. Inversement, on doit pouvoir acher ou sortir des informations, ce qui correspond gnralement une criture sur lcran.
Figure 2.6 Les entres-sorties.
2.9.1 Les entres

Il sagit de raliser une saisie lcran : la fonction standard input() interrompt le programme, acher une ventuelle invite et attend que lutilisateur entre une donne et la valide par Entre . La fonction standard input() eectue toujours une saisie en mode texte (la saisie est une chane) dont on peut ensuite changer le type (on dit aussi transtyper) :
nb_etudiant = input(Entrez le nombre dtudiants : ) print(type(nb_etudiant)) # <class str> (cest une chane)
2.9. LES ENTRES-SORTIES
19
f1 = input(\nEntrez un flottant : ) f1 = float(f1) # transtypage en flottant # ou plus brivement : f2 = float(input(Entrez un autre flottant : )) print(type(f2)) # <class float>
2.9.2 Les sorties

En mode calculatrice , Python lit-value-ache, mais la fonction print() reste indispensable aux achages dans les scripts :
import sys a, b = 2, 5 print(a, b) # 2 5 print(Somme :, a + b) # Somme : 7 print(a - b, est la diffrence) # -3 est la diffrence print(Le produit de, a, par, b, vaut :, a * b) # Le produit de 2 par 5 vaut : 10 print() # affiche une nouvelle ligne # pour afficher un espace la place de la nouvelle ligne: print(a, end= ) # 2 (et ne va pas la ligne) print(\nErreur fatale !, file=sys.stderr) # dans un fichier print(On a <, 2**32, > cas !, sep=###) # On a <###4294967296###> cas !
2.9.3 Les squences dchappement

lintrieur dune chane, le caractre antislash (\) permet de donner une signication spciale certaines squences : Squence \saut_ligne \\ \ \ \a \b \f \n \r \t \v \N{nom} \uhhhh \Uhhhhhhhh \ooo \xhh Exemples : Signication saut de ligne ignor ache un antislash apostrophe guillemet sonnerie (bip) retour arrire saut de page saut de ligne retour en dbut de ligne tabulation horizontale tabulation verticale caractre sous forme de code Unicode nomm caractre sous forme de code Unicode 16 bits caractre sous forme de code Unicode 32 bits caractre sous forme de code octal caractre sous forme de code hexadcimal
20
Figure 2.7 Utilisation des squences dchappement
Chapitre 3
Le contrle du ux dinstructions
Un script Python est form dune suite dinstructions excutes en squence de haut en bas. Chaque ligne dinstructions est forme dune ou plusieurs lignes physiques qui peuvent tre continues par un antislash \ ou un caractre ouvrant [({ pas encore ferm. Cette excution en squence peut tre modie pour choisir ou rpter des portions de code. Cest lobjet principal de ce chapitre.
3.1
Les instructions composes
Syntaxe Une instruction compose se compose : dune ligne den-tte termine par deux-points ; dun bloc dinstructions indent par rapport la ligne den-tte.
Attention Toutes les instructions au mme niveau dindentation appartiennent au mme bloc (cf. Fig. 3.1).
22
CHAPITRE 3. LE CONTRLE DU FLUX DINSTRUCTIONS
Figure 3.1 Les instructions composes. Exemple :

somme = 0.0 nb_valeurs = 0 for v in valeurs: nb_valeurs = nb_valeurs + 1 somme = somme + valeurs moyenne = somme / nb_valeurs
On a souvent besoin dimbriquer les instructions composes :

if a == 0: if b != 0: print(\nx = {:.2f}.format(-c/b)) else: print(\nPas de solution.) else: delta = b**2 - 4*a*c if delta > 0.0: rac_delta = sqrt(delta) print(\nx1 = {:.2f} \t x2 = {:.2f} .format((-b-rac_delta)/(2*a), (-b+rac_delta)/(2*a))) elif delta < 0.0: print(\nPas de racine relle.) else: print(\nx = {:.2f}.format(-b/(2*a)))
3.2 Choisir
3.2.1 Choisir : if - [elif] - [else]
Contrler une alternative :
if x < 0: print(x est ngatif)
3.3. BOUCLER
elif x % 2: print(x est positif et impair) else: print(x nest pas ngatif et est pair)
23
Test dune valeur boolenne :

if x: # mieux que (if x is True:) ou que (if x == True:) pass
3.2.2 Syntaxe compacte dune alternative

Pour trouver, par exemple, le minimum de deux nombres, on peut utiliser loprateur ternaire (repris du C) :
x, y = 4, 3 # Ecriture classique : if x < y: plus_petit = x else: plus_petit = y # Utilisation de loprateur ternaire : plus_petit = x if x < y else y print(Plus petit : , plus_petit) # 3
3.3
Boucler
3.3.1 Boucler : while

Rpter une portion de code :
x, cpt = 257, 0 print(Lapproximation de log2 de, x, est, end= ) while x > 1: x //= 2 # division avec troncature cpt += 1 # incrmentation print(cpt, \n) # 8
Utilisation classique : la saisie ltre dune valeur numrique (on doit prciser le type car input() saisit une chane) :
n = int(input(Entrez un entier [1 .. 10] : )) while not(1 <= n <= 10): n = int(input(Entrez un entier [1 .. 10], S.V.P. : ))
3.3.2 Parcourir : for

Parcourir un itrable (tout conteneur que lon peut parcourir lment par lment, dans lordre ou non, suivant son type) :
24
for lettre in ciao: print(lettre, end= ) # c i a o for x in [2, a, 3.14]: print(x, end= ) # 2 a 3.14 for i in range(5): print(i, end= )
# 0 1 2 3 4
3.4 Ruptures de squences

3.4.1 Interrompre une boucle : break
Sort immdiatement de la boucle for ou while en cours contenant linstruction :
for x in range(1, 11): # 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 if x == 5: break print(x, end= ) print(\nBoucle interrompue pour x =, x) # affiche : # 1 2 3 4 # Boucle interrompue pour x = 5
3.4.2 Court-circuiter une boucle : continue

Passe immdiatement litration suivante de la boucle for ou while en cours contenant linstruction ; reprend la ligne de len-tte de la boucle :
for x in range(1, 11): # 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 if x == 5: continue print(x, end= ) print(\nLa boucle a saut la valeur 5) # affiche : # 1 2 3 4 6 7 8 9 10 # La boucle a saut la valeur 5
3.4.3 Syntaxe complte des boucles

while - else Les boucles while et for peuvent possder une clause else qui ne sexcute que si la boucle se termine normalement, cest--dire sans interruption :
y = int(input(Entrez un entier positif : )) while not(y > 0): y = int(input(Entrez un entier positif, S.V.P. : ))
3.4. RUPTURES DE SQUENCES

x = y // 2 while x > 1: if y % x == 0: print({} a pour facteur {}.format(y, x)) break # voici linterruption ! x -= 1 else: print(y, est premier.)
25
for - else Un exemple avec le parcours dune liste :

une_sequence = [2, 5, 9, 7, 11] cible = int(input(Entrez un entier : )) for i in une_sequence: if i == cible: sauve = i break # voici linterruption ! else: print(cible, nest pas dans, une_sequence) sauve = None # sauve vaut donc cible ou None : print(On obtient sauve =, sauve)
3.4.4 Exceptions
An de rendre les applications plus robustes, il est ncessaire de grer les erreurs dexcution des parties sensibles du code. Le mcanisme des exceptions spare dun ct la squence dinstructions excuter lorsque tout se passe bien et, dun autre ct, une ou plusieurs squences dinstructions excuter en cas derreur. Lorsquune erreur survient, un objet exception est pass au mnanisme de propagation des exceptions, et lexcution est transfre la squence de traitement ad hoc. Le mcanisme seectue en deux phases : la leve dexception lors de la dtection derreur ; le traitement appropri. Syntaxe La squence normale dinstructions est place dans un bloc try. Si une erreur est dtecte (leve dexception), elle est traite dans le bloc except appropri (le gestionnaire dexception).
from math import sin for x in range(-4, 5): # -4, -3, -2, -1, 0, 1, 2, 3, 4 try: print({:.3f}.format(sin(x)/x), end= ) except ZeroDivisionError: # toujours fournir une exception
26
print(1.0, end= ) # gre lexception en 0 # -0.189 0.047 0.455 0.841 1.0 0.841 0.455 0.047 -0.189
Toutes les exceptions leves par Python sont des instances de sous-classe de la classe Exception. La hirarchie des sous-classes ore une vingtaine dexceptions standard 1 . Syntaxe complte dune exception :
try: ... # squence normale dexcution except <exception_1> as e1: ... # traitement de lexception 1 except <exception_2> as e2: ... # traitement de lexception 2 ... else: ... # clause excute en labsence derreur finally: ... # clause toujours excute
Linstruction raise permet de lever volontairement une exception :

x = 2 if not(0 <= x <= 1): raise ValueError(x nest pas dans [0 .. 1])
Remarque raise, sans valeur, dans un bloc except, permet de ne pas bloquer une exception, de la propager. Bloc gard (ou gestionnaire de contexte) : Cette syntaxe simplie le code en assurant que certaines oprations sont excutes avant et aprs un bloc dinstructions donn. Illustrons ce mcanisme sur un exemple classique ou il importe de fermer le chier utilis :
# au lieu de ce code : fh = None try: fh = open(filename) for line in fh: process(line) except EnvironmentError as err: print(err) finally: if fh is not None: fh.close() # il est plus simple dcrire : try: with open(filename) as fh: for line in fh: process(line) except EnvironmentError as err: print(err) 1. Citons quelques classes : AritmeticError, ZeroDivisionError, IndexError, KeyError, AttributeError, IOError, ImportError, NameError, SyntaxError, TypeError...
Chapitre 4
Les conteneurs standard
Le chapitre 2 a prsent les types de donnes simples, mais Python ore beaucoup plus : les conteneurs. De faon gnrale, un conteneur est un objet composite destin contenir dautres objets. Ce chapitre dtaille les squences, les tableaux associatifs, les ensembles et les chiers textuels.
4.1
Les squences
4.1.1 Quest-ce quune squence ?

Dnition Une squence est un conteneur ordonn dlments indexs par des entiers.
Python dispose de trois types prdnis de squences : les chanes (vues prcdemment) ; les listes ; les tuples 1 .
4.2
Les listes
4.2.1 Dnition, syntaxe et exemples

Dnition Collection ordonne et modiable dlments ventuellement htrognes.
Syntaxe lments spars par des virgules, et entours de crochets.

1. tuple nest pas vraiment un anglicisme, mais plutt un nologisme informatique.
28
CHAPITRE 4. LES CONTENEURS STANDARD
couleurs = [trfle, carreau, coeur, pique] print(couleurs) # [trfle, carreau, coeur, pique] couleurs[1] = 14 print(couleurs) # [trfle, 14, coeur, pique] list1 = [a, b] list2 = [4, 2.718] list3 = [list1, list2] # liste de listes print(list3) # [[a, b], [4, 2.718]]
4.2.2 Initialisations et tests

Utilisation de la rptition, de loprateur dappartenance (in) et de litrateur range() :
truc, machin = [], [0.0] * 3 print(truc) # [] (liste vide) print(machin) # [0.0, 0.0, 0.0] l1 = list(range(4)) print(l1 =, l1) # l1 = [0, 1, 2, 3] l2 = list(range(4, 8)) print(l2 =, l2) # l2 = [4, 5, 6, 7] l3 = list(range(2, 9, 2)) print(l3 =, l3) # l3 = [2, 4, 6, 8] print(2 in l1, 8 in l2, 6 in l3) # True False True for i in range(len(l3)): print(i, l3[i], sep=-, end= ) # 0-2 1-4 2-6 3-8
4.2.3 Mthodes
Quelques mthodes de modication des listes :
nombres = [17, 38, 10, 25, 72] nombres.sort() print(nombres) # [10, 17, nombres.append(12) nombres.reverse() nombres.remove(38) print(nombres) # [12, 72, print(nombres.index(17)) # 3 nombres[0] = 11 nombres[1:3] = [14, 17, 2] print(nombres.pop()) # 10 print(nombres) # [11, 14, print(nombres.count(17)) # 2 nombres.extend([1, 2, 3]) print(nombres) # [11, 14,
25, 38, 72]
25, 17, 10]
17, 2, 17]
17, 2, 17, 1, 2, 3]
4.2.4 Manipulation des tranches

Syntaxe Si on veut supprimer, remplacer ou insrer plusieurs lments dune liste, il faut indiquer
4.3. LES LISTES EN INTENSION
29
une tranche dans le membre de gauche dune aectation et fournir une liste dans le membre de droite.
mots = [jambon, sel, miel, confiture, beurre] mots[2:4] = [] # effacement par affectation dune liste vide print(mots) # [jambon, sel, beurre] mots[1:3] = [salade] print(mots) # [jambon, salade] mots[1:] = [mayonnaise, poulet, tomate] print(mots) # [jambon, mayonnaise, poulet, tomate] mots[2:2] = [miel] # insertion en 3 position print(mots) # [jambon, mayonnaise, miel, poulet, tomate]
4.3
Les listes en intension
Une liste en intension est une expression qui permet de gnrer une liste de manire trs compacte. Cette notation reprend la dnition mathmatique dun ensemble en intension : {x2 |x [2, 10]} [x**2 for x in range(2, 11)] Dnition Une liste en intension est quivalente une boucle for qui construirait la mme liste en utilisant la mthode append().
Les listes en intension sont utilisables sous trois formes. Premire forme expression dune liste simple de valeurs :
result1 = [x+1 for x in une_seq] # a le mme effet que : result2 = [] for x in une_seq: result2.append(x+1)
Deuxime forme expression dune liste de valeurs avec ltrage :

result3 = [x+1 for x in une_seq if x > 23] # a le mme effet que : result4 = [] for x in une_seq: if x > 23: result4.append(x+1)
Troisime forme expression dune combinaison de listes de valeurs :

result5 = [x+y for x in une_seq for y in une_autre] # a le mme effet que : result6 = [] for x in une_seq: for y in une_autre: result6.append(x+y)
Des utilisations trs pythoniques :

valeurs_s = [12, 78, 671] # conversion dune liste de chanes en liste dentier valeurs_i = [int(i) for i in valeurs_s] # [12, 78, 671]
30
# calcul de la somme de la liste avec la fonction intgre sum print(sum([int(i) for i in valeurs_s])) # 761 # a le mme effet que : s = 0 for i in valeurs_s: s = s + int(i) print(s)
# 761
# Initialisation dune liste 2D multi_liste = [[0]*2 for ligne in range(3)] print(multi_liste) # [[0, 0], [0, 0], [0, 0]]
4.4 Les tuples

Dnition Collection ordonne et non modiable dlments ventuellement htrognes.
Syntaxe lments spars par des virgules, et entours de parenthses.

mon_tuple = (a, 2, [1, 3])
Les tuples sutilisent comme les listes mais leur parcours est plus rapide ; Ils sont utiles pour dnir des constantes. Attention Comme les chanes de caractres, les tuples ne sont pas modiables !
4.5 Retour sur les rfrences

Nous avons dj vu que lopration daectation, apparemment innocente, est une relle dicult de Python.
i = 1 msg = Quoi de neuf ? e = 2.718
Dans lexemple ci-dessus, les aectations ralisent plusieurs oprations : cre en mmoire un objet du type ad hoc (membre de droite) ; stocke la donne dans lobjet cr ; cre un nom de variable (membre de gauche) ; associe ce nom de variable lobjet contenant la valeur. Une consquence de ce mcanisme est que, si un objet modiable est aect, tout changement sur un objet modiera lautre :
fable = [Je, plie, mais, ne, romps, point] phrase = fable phrase[4] = casse print(fable) # [Je, plie, mais, ne, casse, point]
4.6. LES TABLEAUX ASSOCIATIFS
31
(a) Assignation dun entier
(b) Addition intermdiaire
(c) Assignation augmente
Figure 4.1 Assignation augmente dun objet non modiable. Si lon dsire raliser une vraie copie 1 dun objet, on doit utiliser le module copy :
import copy a = [1, 2, 3] b = a # b.append(4) print(a) # c = copy.copy(a) c.append(5) print(c) # print(a) #
une rfrence [1, 2, 3, 4] # une copie de surface [1, 2, 3, 4, 5] [1, 2, 3, 4]
Dans les rares occasions o lon veut aussi que chaque lment et attribut de lobjet soit copi sparment et de faon rcursive, on emploie la fonction copy.deepcopy(). Complment graphique sur lassignation Assignation augmente dun objet non modiable (cas dun entier : Fig. 4.1). On a reprsent ltape de laddition intermdiaire : Assignation augmente dun objet modiable (cas dune liste : Fig. 4.2) : On a reprsent ltape de la cration de la liste intermdiaire :
4.6
Les tableaux associatifs
4.6.1 Les types tableaux associatifs

Dnition Un tableau associatif est un type de donnes permettant de stocker des couples cle : valeur, avec un accs trs rapide la valeur partir de la cl, la cl ne pouvant tre prsente quune seule fois dans le tableau. Il possde les caractristiques suivantes : loprateur dappartenance dune cl (in) ; la fonction taille (len()) donnant le nombre de couples stocks ;
1. Dans le cas gnral. Pour copier une squence simple, par exemple une liste l, on peut toujours crire l2 = l[ :]
32
(a) Assignation dune liste
(b) Cration intermdiaire en mmoire
(c) Assignation augmente
Figure 4.2 Assignation augmente dun objet modiable. il est itrable (on peut le parcourir) mais nest pas ordonn. Python propose le type standard dict.
4.6.2 Les dictionnaires (dict)

Syntaxe Collection de couples cle : valeur entoure daccolades.
Les dictionnaires constituent un type composite mais ils nappartiennent pas aux squences. Comme les listes, les dictionnaires sont modiables, mais les couples enregistrs noccupent pas un ordre immuable, leur emplacement est gr par un algorithme spcique (Cf. les fonctions de hachage p. 113). Une cl pourra tre alphabtique, numrique. . . en fait tout type hachable. Les valeurs pourront tre des valeurs numriques, des squences, des dictionnaires, mais aussi des fonctions, des classes ou des instances. Exemples de cration
# insertion de cls/valeurs une une d1 = {} # dictionnaire vide d1[nom] = 3 d1[taille] = 176 print(d1) # {nom: 3, taille: 176} # dfinition en extension d2 = {nom: 3, taille: 176} print(d2) # {nom: 3, taille: 176} # dfinition en intension d3 = {x: x**2 for x in (2, 4, 6)} print(d3) # {2: 4, 4: 16, 6: 36} # utilisation de paramtres nomms d4 = dict(nom=3, taille=176) print(d4) # {taille: 176, nom: 3} # utilisation dune liste de couples cls/valeurs d5 = dict([(nom, 3), (taille, 176)]) print(d5) # {nom: 3, taille: 176}
4.7. LES ENSEMBLES (SET) Mthodes Quelques mthodes applicables aux dictionnaires :
tel = {jack: 4098, sape: 4139} tel[guido] = 4127 print(tel) # {sape: 4139, jack: 4098, guido: 4127} print(tel[jack]) # 4098 del tel[sape] tel[irv] = 4127 print(tel) # {jack: 4098, irv: 4127, guido: 4127} print(list(tel.keys())) # [jack, irv, guido] print(sorted(tel.keys())) # [guido, irv, jack] print(sorted(tel.values())) # [4098, 4127, 4127] print(guido in tel, jack not in tel) # True False
33
4.7
Les ensembles (set)
Dnition Collection itrable non ordonne dlments hachables distincts.
Figure 4.3 Oprations sur les ensempbles

X, Y = set(abcd), set(sbds) print(X =, X) # X = {a, c, b, d} print(Y =, Y) # Y = {s, b, d} : un seul lment s print(c print(a print(X print(Y print(X | print(X & in X) # True in Y) # False Y) # {a, c} X) # {s} Y) # {a, c, b, d, s} Y) # {b, d}
4.8
Les chiers textuels
4.8.1 Les chiers : introduction

On rappelle que lordinateur nexcute que les programmes prsents dans sa mmoire volatile (la RAM).
34
Mais, pour conserver durablement des informations, il faut utiliser une mmoire permanente comme par exemple le dique dur, la cl USB, le DVD,. . . Comme la plupart des langages, Python utilise classiquement la notion de chier. Cest un type pr-dni en Python, qui ne nesscite donc pas dimporter de module externe. Nous nous limiterons aux chiers textuels (portables, lisible par un diteur), mais signalons que les chiers stocks en codage binaire sont plus compacts et plus rapides grer.
4.8.2 Gestion des chiers

Ouverture et fermeture des chiers Principaux modes douverture des chiers textuels :
f1 = open(monFichier_1, r, encoding=utf-8) # en lecture f2 = open(monFichier_2, w, encoding=utf-8) # en criture f3 = open(monFichier_3, a, encoding=utf-8) # en ajout
Python utilise les chiers en mode texte par dfaut (not t) (pour les chiers binaires, il faut prciser le mode b). Le paramtre optionnel encoding assure les conversions entre les types byte et str 1 . Les encodages les plus frqents sont utf-8 (cest lencodage privilgier en Python 3), latin1, ascii... Tant que le chier nest pas ferm, son contenu nest pas garanti sur le disque. Une seule mthode de fermeture :
f1.close()
criture squentielle Mthodes dcriture :

f = open(truc.txt, w) s = toto\n f.write(s) # crit la chane s dans f l = [a, b, c] f.writelines(l) # crit les chanes de la liste l dans f f.close() # utilisation de loption file de print f2 = open(truc2.txt, w) print(abcd, file=f2) f2.close()
Lecture squentielle Mthodes de lecture :

f s s s = = = = open(truc.txt, r) f.read() # lit tout le fichier --> string f.read(3) # lit au plus n octets --> string f.readline() # lit la ligne suivante --> string
1. Cf. lannexe B
4.9. ITRER SUR LES CONTENEURS

s = f.readlines() # lit tout le fichier --> liste de strings f.close() # Affichage des lignes dun fichier une une f = open(truc.txt) # mode r par dfaut for ligne in f: print(ligne[:-1]) # pour sauter le retour la ligne f.close()
35
4.9
Itrer sur les conteneurs
Les techniques suivantes sont classiques et trs utiles. Obtenir cls et valeurs en bouclant sur un dictionnaire :
knights = {Gallahad: the pure, Robin: the brave} for k, v in knights.items(): print(k, v) # Gallahad the pure # Robin the brave
Obtenir cls et valeurs en bouclant sur une liste :

for i, v in enumerate([tic, tac, toe]): print(i, v, end= , sep=->) # 0->tic 1->tac 2->toe
Boucler sur deux squences (ou plus) apparies :

question = [name, quest, favorite color] answers = [Lancelot, the Holy Grail, blue] for q, a in zip(question, answers): print(What is your {}? It is {}..format(q, a)) # What is your name? It is Lancelot. # What is your quest? It is the Holy Grail. # What is your favorite color? It is blue.
Boucler sur une squence inverse (la squence initiale est inchange) :
print() for i in reversed(range(1, 10, 2)): print(i, end= ) # 9 7 5 3 1
Boucler sur une squence trie lments uniques (la squence initiale est inchange) :
print() basket = [apple, orange, apple, pear, orange, banana] for f in sorted(set(basket)): print(f, end= ) # apple banana orange pear
4.10
Lachage format
La mthode format() permet de contrler nement toutes sortes dachages. Remplacements simples :
print({} {} {}.format(zro, un, deux)) # zro un deux print({2} {0} {1}.format(zro, un, deux)) # deux zro un
36
print(Je mappelle {}.format(Bob)) # Je mappelle Bob print(Je mappelle {{{}}}.format(Bob)) # Je mappelle {Bob} print({}.format(-*10)) # ----------
Remplacements avec champs nomms :

a, b = 5, 3 print(The story of {c} and {d}.format(c=a+b, d=a-b)) # The story of 8 and 2
Formatages laide de liste :

stock = [papier, enveloppe, chemise, encre, buvard] print(Nous avons de l{0[3]} et du {0[0]} en stock\n.format(stock)) # Nous avons de lencre et du papier en stock
Formatages laide de dictionnaire :

print(My name is {0[name]}.format(dict(name=Fred))) # My name is Fred d = dict(animal = lphant, poids = 12000) print(L{0[animal]} pse {0[poids]} kg\n.format(d)) # Llphant pse 12000 kg
Remplacement avec attributs nomms :

import math import sys print(math.pi = {.pi}, epsilon = {.float_info.epsilon} .format(math, sys)) # math.pi = 3.14159265359, epsilon = 2.22044604925e-16
Conversions textuelles, str() et repr() :

>>> print({0!s} {0!r}.format(texte\n)) texte texte\n
Formatages numriques :
print({0} {0:b} {0:o} {0:x}.format(179)) # 179 10110011 263 b3 n = 100 pi = 3.1415926535897931 print({}, et {}.format(n, pi)) # 100, et 3.14159265359 print({}, et {}.format(n, pi)) # 100, et 3.14159265359 print({0}, {1} et {0}.format(n, pi)) # 100, 3.14159265359 et 100 print({:.4e}.format(pi)) # 3.1416e+00 print({:g}.format(pi)) # 3.14159 msg = Rsultat sur {:d} chantillons : {:.2f}.format(n, pi) print(msg) # Rsultat sur 100 chantillons : 3.14
4.10. LAFFICHAGE FORMAT Formatages divers :

s = The sword of truth print([{}].format(s)) # [The sword of truth] print([{:25}].format(s)) # [The sword of truth ] print([{:>25}].format(s)) # [ The sword of truth] print([{:^25}].format(s)) # [ The sword of truth ] print([{:-^25}].format(s)) # [---The sword of truth----] print([{:.<25}].format(s)) # [The sword of truth.......] long = 12 print([{}].format(s[:long])) # [The sword of] m = 123456789 print({:0=12}.format(m)) # 000123456789 print({:#=12}.format(m)) # ###123456789
37
38
Chapitre 5
Fonctions et espaces de noms
Remarque Les fonctions sont les lments structurants de base de tout langage procdural. Elles orent dirents avantages : vite la rptition : on peut factoriser une portion de code qui se rpte lors de lexcution en squence dun script ; Met en relief les donnes et les rsultats : entres et sorties de la fonction ; Permet la rutilisation : mcanisme de limport ; Dcompose une tche complexe en tches plus simples : lapplication. Ces avantages sont illustrs sur la gure 5.1. conception de
5.1
Dnition et syntaxe
Dnition Ensemble dinstructions regroupes sous un nom et sexcutant la demande.
On doit dnir une fonction chaque fois quun bloc dinstructions se trouve plusieurs reprises dans le code ; il sagit dune mise en facteur commun . Syntaxe Cest une instruction compose :
def nomFonction(paramtres): Documentation de la fonction. <bloc_instructions>
Le bloc dinstructions est obligatoire. Sil est vide, on emploie linstruction pass. La documentation (facultative) est fortement conseille.
40
CHAPITRE 5. FONCTIONS ET ESPACES DE NOMS
(a) vite la duplication de code.
(b) Met en relief entres et sorties.
(c) Limport permet la rutilisation.
(d) Amliore la conception.
Figure 5.1 Les avantages de lutilisation des fonctions
5.2. PASSAGE DES ARGUMENTS
41
5.2
Passage des arguments
5.2.1 Mcanisme gnral

Remarque Passage par aectation : chaque argument de la dnition de la fonction correspond, dans lordre, un paramtre de lappel. La correspondance se fait par aectation.
Figure 5.2 Passage des arguments par aectation.
5.2.2 Un ou plusieurs paramtres, pas de retour

Exemple sans linstruction return, ce quon appelle souvent une procdure. Dans ce cas la fonction renvoie implicitement la valeur None :
def table(base, debut, fin): Affiche la table des <base> de <debut> <fin>. n = debut while n <= fin: print(n, x, base, =, n * base, end= ) n += 1 # exemple dappel : table(7, 2, 11) # 2 x 7 = 14 3 x 7 = 21 4 x 7 = 28 5 x 7 = 35 6 x 7 = 42 # 7 x 7 = 49 8 x 7 = 56 9 x 7 = 63 10 x 7 = 70 11 x 7 = 77
5.2.3 Un ou plusieurs paramtres, utilisation du retour

Exemple avec utilisation dun return unique :
from math import pi def cube(x): return x**3
42
def volumeSphere(r): return 4.0 * pi * cube(r) / 3.0 # Saisie du rayon et affichage du volume rayon = float(input(Rayon : )) print(Volume de la sphre =, volumeSphere(rayon))
Exemple avec utilisation dun return multiple :

import math def surfaceVolumeSphere(r): surf = 4.0 * math.pi * r**2 vol = surf * r/3 return surf, vol # programme principal rayon = float(input(Rayon : )) s, v = surfaceVolumeSphere(rayon) print(Sphre de surface {:g} et de volume {:g}.format(s, v))
5.2.4 Passage dune fonction en paramtre

def tabuler(fonction, borneInf, borneSup, nbPas): Affichage des valeurs de <fonction>. On doit avoir (borneInf < borneSup) et (nbPas > 0) h, x = (borneSup - borneInf) / float(nbPas), borneInf while x <= borneSup: y = fonction(x) print(f({:.2f}) = {:.2f}.format(x, y)) x += h def maFonction(x): return 2*x**3 + x - 5 tabuler(maFonction, -5, 5, 10) # f(-5.00) = -260.00 # f(-4.00) = -137.00 # ... # f(5.00) = 250.00
5.2.5 Paramtres avec valeur par dfaut

On utilise de prfrence des valeurs par dfaut non modiables car la modication dun paramtre par un premier appel est visible les fois suivantes :
def initPort(speed=9600, parity=paire, data=8, stops=1): print(Init. , speed, bits/s, parit :, parity) print(data, bits de donnes, stops, bits darrt) # Appels possibles : initPort() # Init. 9600 bits/s parit : paire # 8 bits de donnes 1 bits darrt initPort(parity=nulle) # Init. 9600 bits/s parit : nulle # 8 bits de donnes 1 bits darrt
5.2. PASSAGE DES ARGUMENTS

initPort(2400, paire, 7, 2) # Init. 2400 bits/s parit : paire # 7 bits de donnes 2 bits darrt
43
5.2.6 Nombre darguments arbitraire : passage dun tuple

def somme(*args): Renvoie la somme de <tuple>. resultat = 0 for nombre in args: resultat += nombre return resultat # Exemples dappel : print(somme(23)) # 23 print(somme(23, 42, 13)) # 78
Note : Si la fonction possde plusieurs arguments, le tuple est en dernire position. Il est aussi possible de passer un tuple (en fait une squence) lappel qui sera dcompress en une liste de paramtres dune fonction classique :
def somme(a, b, c): return a+b+c # Exemple dappel : elements = (2, 4, 6) print(somme(*elements)) # 12
5.2.7 Nombre darguments arbitraire : passage dun dictionnaire

def unDict(**kargs): return kargs # Exemples dappels ## par des paramtres nomms : print(unDict(a=23, b=42)) # {a: 23, b: 42} ## en fournissant un dictionnaire : mots = {d: 85, e: 14, f:9} print(unDict(**mots)) # {e: 14, d: 85, f: 9}
Note : Si la fonction possde plusieurs arguments, le dictionnaire est en toute dernire position (aprs un ventuel tuple).
44
5.3 Espaces de noms

5.3.1 Porte des objets
Remarque Porte : les noms des objets sont crs lors de leur premire aectation, mais ne sont visibles que dans certaines rgions de la mmoire. On distingue : La porte globale : celle du module __main__. Un dictionnaire gre les objets globaux : linstruction globals() fournit les couples variable :valeur ; La porte locale : les objets internes aux fonctions (et aux classes) sont locaux. Les objets globaux ne sont pas modiables dans les portes locales. Linstruction locals() fournit les couples variable :valeur.
5.3.2 Rsolution des noms : rgle LGI

La recherche des noms est dabord locale (L), puis globale (G), enn interne (I) (cf. Fig. 5.3) :
Figure 5.3 Rgle LGI
Exemples de porte
# x et fonc sont affects dans le module : globaux def fonc(y): # y et z sont affects dans fonc : locaux global x # permet de modifier x ligne suivante x += 2 z = x + y return z x = 99
5.3. ESPACES DE NOMS

print(fonc(1)) # 102 # x et fonc sont affects dans le module : globaux def fonc(y): # y et z sont affects dans fonc : locaux # dans fonc : porte locale z = x + y return z x = 99 print(fonc(1)) # 100 # x et fonc sont affects dans le module : globaux def fonc(y): # y, x et z sont affects dans fonc : locaux x = 3 # ce nouvel x est local et masque le x global z = x + y return z x = 99 print(fonc(1)) # 4
45
46
Chapitre 6
Modules et packages
Un programme Python est gnralement compos de plusieurs chiers sources, appels modules. Leur nom est sux .py. Sils sont correctement cods les modules doivent tre indpendants les uns des autres pour tre rutiliss la demande dans dautres programmes. Ce chapitre explique comment coder et importer des modules dans un autre. Nous verrons galement la notion de package qui permet de grouper plusieurs modules.
6.1
Modules
Dnition Module : chier indpendant permettant de scinder un programme en plusieurs scripts. Ce mcanisme permet dlaborer ecacement des bibliothques de fonctions ou de classes.
Avantages des modules : rutilisation du code ; la documentation et les tests peuvent tre intgrs au module ; ralisation de services ou de donnes partags ; partition de lespace de noms du systme.
6.1.1 Import dun module

Deux syntaxes possibles : la commande import <nom_module> importe la totalit des objets du module :
import tkinter
la commande from <nom_module> import obj1, obj2... nimporte que les objets obj1, obj2... du module :
from math import pi, sin, log
48 Il est conseill dimporter dans lordre : les modules de la bibliothque standard ; les modules des bibliothques tierces ; Les modules personnels.
CHAPITRE 6. MODULES ET PACKAGES
6.1.2 Exemples
Notion d auto-test Un module cube_m.py. Remarquez lutilisation de lauto-test qui permet de tester le module seul :
def cube(y): Calcule le cube du paramtre <y>. return y**3 # Auto-test ---------------------------------------------------if __name__ == __main__: # False lors dun import ==> ignor help(cube) # affiche le docstring de la fonction print(cube de 9 :, cube(9)) # cube de 9 : 729
Utilisation de ce module. On importe la fonction cube() incluse dans le chier cube_m.py :

from cube_m import cube for i in range(1, 4): print(cube de, i, =, cube(i), end= ) # cube de 1 = 1 cube de 2 = 8 cube de 3 = 27
Une interface gnuplot Lapplication libre gnuplot permet dacher des courbes. La fonction suivante est une interface dappel qui permet dacher des donnes issues de chiers :
import os def plotFic(courbes): dem = open(_.dem, w) # fichier rutilis chaque trac dem.write(set grid\n) plot_data = [%s with %s % (c[0], c[1]) for c in courbes] dem.write(plot + ,.join(plot_data)) dem.write(\npause -1 \Entre\ pour continuer\n) dem.write(reset) dem.close() os.system(wgnuplot _.dem)
Lauto-test suivant illustre son utilisation :

if __name__ == __main__: f, g, h = open(d1.dat, w), open(d2.dat, w), open(d3.dat, w) for i in range(201): x = 0.1*i - 5.0 y = x**3 - 20*x**2 f.write(%g %g\n %(x, y)) y = x**3 - 30*x**2 g.write(%g %g\n %(x, y)) y = x**3 - 40*x**2
6.2. BIBLIOTHQUE STANDARD

h.write(%g %g\n %(x, y)) h.close(); g.close(); f.close() plotFic([(d1.dat, points)]) plotFic([(d1.dat, lines), (d2.dat, points), (d3.dat, lines)])
49
6.2
Bibliothque standard
6.2.1 La bibliothque standard

On dit souvent que Python est livr piles comprises (batteries included) tant sa bibliothque standard, riche de plus de 200 packages et modules, rpond aux problmes courants les plus varis. Ce survol prsente quelques fonctionnalits utiles. La gestion des chanes Le module string fournit des constantes comme ascii_lowercase, digits... et la classe Formatter qui peut tre spcialise en sous-classes spcialises de formateurs de chanes. Le module textwrap est utilis pour formater un texte : longueur de chaque ligne, contrle de lindentation. Le module struct permet de convertir des nombres, boolens et des chanes en leur reprsentation binaire an de communiquer avec des bibliothques de bas-niveau (souvent en C). Le module difflib permet la comparaison de squences et fournit des sorties au format standard di ou en HTML. Enn on ne peut oublier le module re qui ore Python la puissance des expressions rgulires. Exemple : le module io.StringIO Ce module fournit des objets compatibles avec linterface des objets chiers. Exemple de gestion ligne ligne dun chier ou dune chane avec la mme fonction scanner() utilisant le mme traitement :
def scanner(objet_fichier, gestionnaire_ligne): for ligne in objet_fichier: gestionnaire_ligne(ligne) if __name__==__main__: def premierMot(ligne): print(ligne.split()[0]) fic = open(data.dat) scanner(fic, premierMot) import io chaine = io.StringIO(un\ndeux xxx\ntrois\n) scanner(chaine, premierMot)
50 La gestion de la ligne de commande
La gestion est assure par deux modules : getopt, le module historique hrit du C et optparse, un module rcent beaucoup plus puissant :
from optparse import OptionParser parser = OptionParser() parser.add_option(-f, --file, dest=filename, help=write report to FILE, metavar=FILE) parser.add_option(-q, --quiet, action=store_false, dest=verbose, default=True, help=dont print status messages to stdout) (options, args) = parser.parse_args()
Les lignes de commande :

python 6_025.py -h
ou
python 6_025.py --help
produisent la mme documentation :

Usage: 6_025.py [options] Options: -h, --help show this help message and exit -f FILE, --file=FILE write report to FILE -q, --quiet dont print status messages to stdout
Bibliothques mathmatiques et types numriques En standard, Python propose les modules fraction et decimal :
from fractions import Fraction import decimal as d print(Fraction(16, -10)) # -8/5 print(Fraction(123)) # 123 print(Fraction( -3/7 )) # -3/7 print(Fraction(-.125)) # -1/8 print(Fraction(7e-6)) # 7/1000000 d.getcontext().prec = 6 print(d.Decimal(1) / d.Decimal(7)) # 0.142857 d.getcontext().prec = 18 print(d.Decimal(1) / d.Decimal(7)) # 0.142857142857142857
En plus des bibliothques math et cmath dj vues, la bibliothque random propose plusieurs fonctions de nombres alatoires. La gestion du temps et des dates Les modules calendar, time et datetime fournissent les fonctions courantes de gestion du temps et des dures :
6.2. BIBLIOTHQUE STANDARD

import calendar, datetime, time moon_apollo11 = datetime.datetime(1969, 7, 20, 20, 17, 40) print(moon_apollo11) print(time.asctime(time.gmtime(0))) # Thu Jan 01 00:00:00 1970 (epoch UNIX) vendredi_precedent = datetime.date.today() un_jour = datetime.timedelta(days=1) while vendredi_precedent.weekday() != calendar.FRIDAY: vendredi_precedent -= un_jour print(vendredi_precedent.strftime(%A, %d-%b-%Y)) # Friday, 09-Oct-2009
51
Algorithmes et types de donnes collection Le module bisect fournit des fonctions de recherche de squences tries. Le module array propose un type semblable la liste, mais plus rapide car de contenu homogne. Le module heapq gre des tas dans lesquels llment dindex 0 est toujours le plus petit :
import heapq import random heap = [] for i in range(10): heapq.heappush(heap, random.randint(2, 9)) print(heap) # [2, 3, 5, 4, 6, 6, 7, 8, 7, 8]
linstar des structures C, Python propose dsormais, via le module collections, la notion de type tuple nomm :
import collections # description du type : Point = collections.namedtuple(Point, x y z) # on instancie un point : point = Point(1.2, 2.3, 3.4) # on laffiche : print(point : [{}, {}, {}] .format(point.x, point.y, point.z)) # point : [1.2, 2.3, 3.4]
Il est bien sr possible davoir des tuples nomms embots. Le type defaultdict permet des utilisations avances :
from collections import defaultdict s = [(y, 1), (b, 2), (y, 3), (b, 4), (r, 1)] d = defaultdict(list) for k, v in s: d[k].append(v) print(d.items()) # dict_items([(y, [1, 3]), (r, [1]), (b, [2, 4])]) s = mississippi
52
d = defaultdict(int) for k in s: d[k] += 1 print(d.items()) # dict_items([(i, 4), (p, 2), (s, 4), (m, 1)])
Et tant dautres domaines... Beaucoup dautres domaines pourraient tre explors : accs au systme ; utilitaires chiers ; programmation rseau ; persistance ; les chiers XML ; la compression ; ...
6.3 Bibliothques tierces

6.3.1 Une grande diversit
Outre les modules intgrs la distribution standard de Python, on trouve des bibliothques dans tous les domaines : scientique ; bases de donnes ; tests fonctionnels et contrle de qualit ; 3D ; ... Le site pypi.python.org/pypi (The Python Package Index) recense des milliers de modules et de packages !
6.3.2 Un exemple : la bibliothque Unum

Elle permet de calculer en tenant compte des units du systme S.I. Voici un exemple de session interactive :
-- Welcome in Unum Calculator (ver 04.00) ->>> d = 1609 * M >>> t = 11.7 * S >>> v = d/t >>> v 137.521367521 [m/s] >>> a = v/t >>> a 11.753963036 [m/s2] >>>
6.4. PACKAGES
53
6.4
Packages
Dnition Un package est un module contenant dautres modules. Les modules dun package peuvent tre des sous-packages, ce qui donne une structure arborescente.
En rsum, un package est simplement un rpertoire qui contient des modules et un chier __init__.py dcrivant larborescence du package.
54
Chapitre 7
La programmation Oriente Objet
La Programmation Oriente Objet : la POO permet de mieux modliser la ralit en concevant des ensembles dobjets, les classes. Ces classes permettent de construire des objets interactifs entre eux et avec le monde extrieur. Les objets sont crs indpendamment les uns des autres, grce lencapsulation, mcanisme qui permet dembarquer leurs proprits. Les classes permettent dviter au maximum lemploi des variables globales. Enn les classes orent un moyen conomique et puissant de construire de nouveaux objets partir dobjets prexistants.
7.1
Insusance de lapproche procdurale
Un exemple On veut reprsenter un cercle, ce qui ncessite au minimum trois informations, les coordonnes du centre et le rayon :
cercle = (11, 60, 8)
Mais comment interprter ces trois donnes ?

cercle = (x, y, rayon) # ou bien cercle = (rayon, x, y)
Pour rsoudre ce problme et amliorer la lisibilit, on peut utiliser des tuples nomms :
from collection import namedtuple Cercle = namedtuple(Cercle, x y rayon) cercle = Cercle(11, 60, 8) # exemple dutilisation : distance = distance_origine(cercle.x, cercle.y)
56
CHAPITRE 7. LA PROGRAMMATION ORIENTE OBJET
Par contre, il reste le problme des donnes invalides, ici un rayon ngatif :
cercle = Cercle(11, 60, -8)
Si les cercles doivent changer de caractristiques, il faut opter pour un type modiable, liste ou dictionnaire ce qui ne rgle toujours pas le problme des donnes invalides... On a donc besoin dun mcanisme pour empaqueter les donnes ncessaires pour reprsenter un cercle et pour empaqueter les mthodes applicables ce nouveau type de donnes (la classe), de telle sorte que seules les oprations valides soient utilisables.
7.2 Terminologie
Le vocabulaire de la POO Une classe est donc quivalente un nouveau type de donnes. On connat dj par exemple int ou str. Un objet ou une instance est un exemplaire particulier dune classe. Par exemple truc est une instance de la classe str. La plupart des classes encapsulent la fois les donnes et les mthodes applicables aux objets. Par exemple un objet str contient une chane de caractres Unicode (les donnes) et de nombreuses mthodes comme upper(). On pourrait dnir un objet comme une capsule, savoir un paquet contenant des attributs et des mthodes : objet = [attributs + mthodes] Beaucoup de classes orent des caractristiques supplmentaires comme par exemple la concatnation des chanes en utilisant simplement loprateur +. Ceci est obtenu grce aux mthodes spciales. Par exemple loprateur + est utilisable car on a redni la mthode __add()__. Les objets ont gnralement deux sortes dattributs : les donnes nommes simplement attributs et les fonctions applicables appeles mthodes. Par exemple un objet de la classe complex possde : .imag et .real, ses attributs ; beaucoup de mthodes, comme conjugate() ; des mthodes spciales : +, -, /... Les attributs sont normalement implments comme des variables dinstance, particulires chaque instance dobjet. Le mcanisme de property permet un accs contrl aux donnes, ce qui permet de les valider et de les scuriser. Un avantage dcisif de la POO est quune classe Python peut toujours tre spcialise en une classe lle qui hrite alors de tous les attributs (donnes et mthodes) de sa supper classe. Comme tous les attributs peuvent tre rednis, une mthode de la classe lle et de la classe mre peut possder le mme nom mais eectuer des traitements dirents (surcharge) et Python sadaptera dynamiquement, ds laectation. En proposant dutiliser un mme nom de mthode pour plusieurs types dobjets dirents, le polymorphisme permet une programmation beaucoup plus gnrique. Le dveloppeur na pas savoir, lorsquil programme une mthode, le type prcis de lobjet sur lequel la mthode va sappliquer. Il lui sut de savoir que cet objet implmentera la mthode.
7.3. CLASSES ET INSTANCIATION DOBJETS
57
Enn Python supporte galement le duck typing : sil marche comme un canard et cancane comme un canard, alors cest un canard ! . Ce qui signie que Python ne sintresse quau comportement des objets. Par exemple un objet chier peut tre cr par open() ou par une instance de io.StringIO. Les deux approches orent la mme API (interface de programmation), cest--dire les mmes mthodes.
7.3
Classes et instanciation dobjets
7.3.1 Linstruction class

Syntaxe Instruction compose : en-tte (avec docstring) + corps indent :
class C: Documentation de la classe. x = 23
Dans cet exemple, C est le nom de la classe (qui commence conventionnellement par une majuscule), et x est un attribut de classe, local C.
7.3.2 Linstanciation et ses attributs

Les classes sont des fabriques dobjets : on construit dabord lusine avant de produire des objets ! On instancie un objet (i.e. cration, production depuis lusine) en appelant le nom de sa classe :
a = C() # print(dir(a)) print(a.x) # a.x = 12 # print(C.x) # a.y = 44 # b = C() print(b.x) print(b.y) a est un objet de la classe C # affiche les attributs de lobjet a affiche 23. x est un attribut de classe modifie lattribut dinstance (attention...) 23, lattribut de classe est inchang nouvel attribut dinstance
# b est un autre objet de la classe C # 23. b connat son attribut de classe, mais... # AttributeError: C instance has no attribute y
7.3.3 Retour sur les espaces de noms

Tout comme les fonctions, les classes possdent leurs espaces de noms : Chaque classe possde son propre espace de noms. Les variables qui en font partie sont appeles attributs de classe. Chaque objet instance (cr partir dune classe) obtient son propre espace de noms. Les variables qui en font partie sont appeles attributs dinstance. Les classes peuvent utiliser (mais pas modier) les variables dnies au niveau principal. Les instances peuvent utiliser (mais pas modier) les variables dnies au niveau de la classe et les variables dnies au niveau principal. Les espaces de noms sont implments par des dictionnaires pour les modules, les classes et les instances.
58
Noms non qualis (exemple dimension) laectation cre ou change le nom dans la porte locale courante. Ils sont cherchs suivant la rgle LGI. Noms qualis (exemple dimension.hauteur) laectation cre ou modie lattribut dans lespace de noms de lobjet. Un attribut est cherch dans lobjet, puis dans toutes les classes dont lobjet dpend (mais pas dans les modules). Lexemple suivant ache le dictionnaire li la classe C puis la liste des attributs lis une instance de C :
class C: x = 20 print(C.__dict__) # {__dict__: <attribute __dict__ of C objects>, x: 20, __module__: __main__, __weakref__: <attribute __weakref__ of C objects>, __doc__: None} a = C() print(dir(a)) # [__class__, __delattr__, __dict__, __doc__, __getattribute__, __hash__, __init__, __module__, __new__, __reduce__, __reduce_ex__, __repr__, __setattr__, __str__ , __weakref__, x]
7.4 Mthodes
Syntaxe Une mthode scrit comme une fonction du corps de la classe avec un premier paramtre self obligatoire, o self reprsente lobjet sur lequel la mthode sera applique. Autrement dit self est la rfrence dinstance.
class C: x = 23 # x et y : attributs de classe y = x + 5 def affiche(self): # mthode affiche() self.z = 42 # attribut dinstance print(C.y) # dans une mthode, on qualifie un attribut de classe , print(self.z) # mais pas un attribut dinstance ob = C() # instanciation de lobjet ob ob.affiche() # 28 42 ( lappel, ob affecte self)
7.5 Mthodes spciales

7.5.1 Les mthodes spciales
Ces mthodes portent des noms pr-dnis, prcds et suivis de deux caractres de soulignement. Elles servent : initialiser lobjet instanci ; modier son achage ; surcharger ses oprateurs ; ...
7.5. MTHODES SPCIALES
59
7.5.2 Linitialisateur
Lors de linstanciation dun objet, la mthode __init__ est automatiquement invoque. Elle permet deectuer toutes les initialisations ncessaires :
class C: def __init__(self, n): self.x = n # initialisation de lattribut dinstance x une_instance = C(42) # paramtre obligatoire, affect n print(une_instance.x) # 42
Cest une procdure automatiquement invoque lors de linstanciation : elle ne contient jamais linstruction return.
7.5.3 Surcharge des oprateurs

La surcharge permet un oprateur de possder un sens dirent suivant le type de leurs oprandes. Par exemple, loprateur + permet :
x = 7 + 9 # addition entire s = ab + cd # concatnation
Python possde des mthodes de surcharge pour : tous les types (__call__, __str__, ...) ; les nombres (__add__, __div__, ...) ; les squences (__len__, __iter__, ...). Soient deux instances, obj1 et obj2, les mthodes spciales suivantes permettent deectuer les oprations arithmtiques courantes : Nom Mthode spciale Utilisation oppos __neg__ -obj1 addition __add__ obj1 + obj2 soustraction __sub__ obj1 - obj2 multiplication __mul__ obj1 * obj2 division __div__ obj1 / obj2 division entire __floordiv__ obj1 // obj2
7.5.4 Exemple de surcharge

class Vecteur2D: def __init__(self, x, y): self.x = x self.y = y def __add__(self, autre): # addition vectorielle return Vecteur2D(self.x + autre.x, self.y + autre.y) def __str__(self): # affichage dun Vecteur2D return Vecteur({:g}, {:g}) % (self.x, self.y) v1 = Vecteur2D(1.2, 2.3) v2 = Vecteur2D(3.4, 4.5)
60
print(v1 + v2)
# Vecteur(4.6, 6.8)
7.6 Hritage et polymorphisme

7.6.1 Hritage et polymorphisme
Dnition Lhritage est le mcanisme qui permet de se servir dune classe prexistante pour en crer une nouvelle qui possdera des fonctionnalits direntes ou supplmentaires.
Dnition Le polymorphisme est la facult pour une mthode portant le mme nom mais appartenant des classes distinctes hrites deectuer un travail dirent. Cette proprit est acquise par la technique de la surcharge.
7.6.2 Exemple dhritage et de polymorphisme

Dans lexemple suivant, la classe Carre hrite de la classe Rectangle, et la mthode __init__ est polymorphe :
class Rectangle: def __init__(self, longueur=30, largeur=15): self.L, self.l, self.nom = longueur, largeur, rectangle class Carre(Rectangle): def __init__(self, cote=10): Rectangle.__init__(self, cote, cote) self.nom = carr r = Rectangle() print(r.nom) # rectangle c = Carre() print(c.nom) # carr
7.7 Retour sur lexemple initial

7.7.1 La classe Cercle : conception
Nous allons tout dabord concevoir une classe Point hritant de la classe mre object. Puis nous pourrons lutiliser comme classe de base de la classe Cercle. Dans les schmas UML 1 ci-dessous, les attributs en italiques sont hrits, ceux en casse normale sont nouveaux et ceux en gras sont rednis (surchargs).
7.7.2 La classe Cercle

Voici le code de la classe Point :
class Point: def __init__(self, x=0, y=0): 1. Unied Modeling Language : notation graphique de conception objet.
7.7. RETOUR SUR LEXEMPLE INITIAL
61
Figure 7.1 Conception UML de la classe Cercle.

self.x, self.y = x, y @property def distance_origine(self): return math.hypot(self.x, self.y) def __eq__(self, other): return self.x == other.x and self.y == other.y def __str__(self): return ({0.x!s}, {0.y!s}).format(self)
Lutilisation du dcorateur property permet un accs en lecture seule au rsultat de la mthode distance_origine() considre alors comme un simple attribut (car il ny a pas de parenthse) :
if __name__ == __main__: p1, p2 = Point(), Point(3, 4) print(p1 == p2) # False print(p2, p2.distance_origine) # (3, 4) 5.0
De nouveau, les mthodes renvoyant un simple ottant seront utilises comme des attributs grce property :
class Cercle(Point): def __init__(self, rayon, x=0, y=0): super().__init__(x, y) self.rayon = rayon @property def aire(self): return math.pi * (self.rayon ** 2) @property def circonference(self): return 2 * math.pi * self.rayon @property def distance_bord_origine(self):
62

return abs(self.distance_origine - self.rayon)
Voici la syntaxe permettant dutiliser la mthode rayon comme un attribut en lecturecriture. Remarquez que la mthode rayon() retourne lattribut protg : __rayon qui sera modi par le setter (la mthode modicatrice) :
@property def rayon(self): return self.__rayon @rayon.setter def rayon(self, rayon): assert rayon > 0, rayon strictement positif self.__rayon = rayon
Exemple dutilisation des instances de Cercle :

def __eq__(self, other): return (self.rayon == other.rayon and super().__eq__(other)) def __str__(self): return ({0.__class__.__name__}({0.rayon!s}, {0.x!s}, {0.y!s}).format(self)) if __name__ == __main__: c1 = Cercle(2, 3, 4) print(c1, c1.aire, c1.circonference) # Cercle(2, 3, 4) 12.5663706144 12.5663706144 print(c1.distance_bord_origine, c1.rayon) # 3.0 2 c1.rayon = 1 # modification du rayon print(c1.distance_bord_origine, c1.rayon) # 4.0 1
7.8 Notion de Conception Oriente Objet

Suivant les relations que lon va tablir entre les objets de notre application, on peut concevoir nos classes de deux faons possibles : la composition qui repose sur la relation a-un ou sur la relation utilise-un ; la drivation qui repose sur la relation est-un. Bien sr, ces deux conceptions peuvent cohabiter, et cest souvent le cas !
7.8.1 Composition
Dnition La composition est la collaboration de plusieurs classes distinctes via une association (utilise-un) ou une agrgation (a-un).
La classe composite bncie de lajout de fonctionnalits dautres classes qui nont rien en commun. Limplmentation Python utilise est gnralement linstanciation de classes dans le constructeur de la classe composite.
7.8. NOTION DE CONCEPTION ORIENTE OBJET Exemple

class Point: def __init__(self, x, y): self.px, self.py = x, y class Segment: Classe composite utilisant la classe distincte Point. def __init__(self, x1, y1, x2, y2): self.orig = Point(x1, y1) # Segment a-un Point origine, self.extrem = Point(x2, y2) # et a-un Point extrmit def __str__(self): return (Segment : [({:g}, {:g}), ({:g}, {:g})] .format(self.orig.px, self.orig.py, self.extrem.px, self.extrem.py)) s = Segment(1.0, 2.0, 3.0, 4.0) print(s) # Segment : [(1, 2), (3, 4)]
63
7.8.2 Drivation
Dnition La drivation dcrit la cration de sous-classes par spcialisation.
On utilise dans ce cas le mcanisme de lhritage. Limplmentation Python utilise est gnralement lappel dans le constructeur de la classe drive du constructeur de la classe parente, soit nommment, soit grce linstruction super. Exemple
class Rectangle: def __init__(self, longueur=30, largeur=15): self.L, self.l, self.nom = longueur, largeur, rectangle class Carre(Rectangle): # hritage simple Sous-classe spcialise de la super-classe Rectangle. def __init__(self, cote=20): # appel au constructeur de la super-classe de Carre : super().__init__(cote, cote) self.nom = carr # surcharge dattribut
64
Chapitre 8
Quelques Techniques avances de programmation
Ce chapitre prsente quelques exemples de techniques avances dans les trois paradigmes que supporte Python, les programmations procdurale, objet et fonctionnelle.
8.1
Techniques procdurales
8.1.1 Amliorer la documentation

La fonction utilitaire printApi() 1 ltre les mthodes disponibles de element, et ache les docstrings associs sous une forme plus lisible que help() :
def printApi(element): methods = [el for el in dir(element) if not el.startswith(_)] for meth in methods: print(getattr(element, meth).__doc__) if __name__ == __main__: printApi([]) L.append(object) -- append object to end L.count(value) -> integer -- return number of occurrences of value L.extend(iterable) -- extend list by appending elements from the iterable L.index(value, [start, [stop]]) -> integer -- return first index of value. Raises ValueError if the value is not present. L.insert(index, object) -- insert object before index L.pop([index]) -> item -- remove and return item at index (default last ). Raises IndexError if list is empty or index is out of range. L.remove(value) -- remove first occurrence of value. Raises ValueError if the value is not present. 1. Cf. [B6] p. 131
66
CHAPITRE 8. TECHNIQUES AVANCES
L.reverse() -- reverse *IN PLACE* L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*; cmp(x, y) -> -1, 0, 1
8.1.2 Faire des menus avec un dictionnaire

On peut utiliser le couple cl : valeur dun dictionnaire pour implmenter un menu, de la faon suivante : on donne cle le nom dun lment du menu ; la valeur correspondante est une rfrence : lappel une procdure sans argument. Lexemple propos est la programmation dune queue FIFO, une structure de donnes illustre par la le dattente un guichet : le premier arriv est le premier servi. Source du module de fonctions :
Module de gestion dune queue FIFO. queue = [] # initialisation def enQueue(): queue.append(int(input(Entrez un entier : ))) def deQueue(): if len(queue) == 0: print(\nImpossible : la queue est vide !) else: print(\nElment %d supprim % queue.pop(0)) def afficheQueue(): print(\nqueue :, queue)
Source du menu de gestion :

Implmentation dune queue FIFO avec une liste. Un menu (utilisant un dictionnaire) appelle des procdures sans argument. # import from queue_FIFO_menu_m import enQueue, deQueue, afficheQueue # programme principal ----------------------------------------------afficheQueue() CMDs = {a:enQueue, v:afficheQueue, s:deQueue} menu = (A)jouter (V)oir (S)upprimer (Q)uitter Votre choix ? while True:
8.1. TECHNIQUES PROCDURALES

while True: try: choix = input(menu).strip()[0].lower() except: choix = q if choix not in avsq: print(Option invalide ! Ressayez) else: break if choix == q: print(\nAu revoir !) break CMDs[choix]()
67
8.1.3 Les fonctions rcursives

Dnition Une fonction rcursive peut sappeler elle-mme.
Par exemple, trier un tableau de N lments par ordre croissant cest extraire le plus petit lment puis trier le tableau restant N 1 lments. Bien que cette mthode soit souvent plus dicile comprendre et coder que la mthode classique dite itrative, elle est, dans certains cas, lapplication la plus directe de sa dnition mathmatique. Voici lexemple classique de dnition par rcurrence de la fonction factorielle 1 : { 1 si n = 0 n! = n (n 1)! si n 1 Remarque Son code est trs exactement calqu sur sa dnition mathmatique :
def factorielle(n): if n == 0: # cas de base : condition terminale return 1 else # cas rcursif return n*factorielle(n-1)
Dans cette dnition, la valeur de n! nest pas connue tant que lon na pas atteint la condition terminale (ici n == 0). Le programme empile les appels rcursifs jusqu atteindre la condition terminale puis dpile les valeurs. Ce mcanisme est illustr par la gure 8.1.
1. Par opposition sa dnition itrative : n! = n (n 1) (n 2) . . . 2 1.
68
Figure 8.1 Empilage/dpilage de 4 !
69
8.1.4 Les gnrateurs et les expressions gnratrices

Les gnrateurs Les gnrateurs fournissent un moyen de gnrer des excutions paresseuses, ce qui signie quelles ne calculent que les valeurs rellement demandes. Ceci peut savrer beaucoup plus ecace (en termes de mmoire) que le calcul, par exemple, dune norme liste en une seule fois. Voici un exemple de gnrateur qui fournit autant de valeurs que demandes :
def quarters(next_quarter=0.0): while True: yield next_quarter next_quarter += 0.25 if __name__ == __main__: result = [] for x in quarters(): result.append(x) if x == 1.0: break print(Liste rsultante : , result) # Liste rsultante : [0.0, 0.25, 0.5, 0.75, 1.0]
Il est aussi possible de passer une initialisation au gnrateur :

# import import sys def quarters(next_quarter=0.0): while True: received = (yield next_quarter) if received is None: next_quarter += 0.25 else: next_quarter += received if __name__ == __main__: result = [] generator = quarters() while len(result) < 5: x = next(generator) if abs(x - 0.5) < sys.float_info.epsilon: x = generator.send(1.0) # rinitialise le gnrarteur result.append(x) print(Liste rsultante : , result) # Liste rsultante : [0.0, 0.25, 1.5, 1.75, 2.0]
Les expressions gnratrices Syntaxe Une expression gnratrice possde une syntaxe presque identique celle des listes en intension ; la dirence est quune expression gnratrice est entoure de parenthses.
70 Utilisation
Les expressions gnratrices sont aux gnrateurs ce que les listes en intension sont aux fonctions.
8.1.5 Les fonctions incluses

La syntaxe de dnition des fonctions en Python permet tout fait demboter leur dnition. Distinguons deux cas demploi : Idiome de la fonction fabrique renvoyant une fermeture :
def creer_plus(ajout): Fonction fabrique. def plus(increment): Fonction fermeture : utilise des noms locaux creer_plus(). return increment + ajout return plus # Programme principal ----------------------------------------------## cration de deux fabriques distinctes p = creer_plus(23) q = creer_plus(42) ## utilisation print(p(100) =, p(100)) print(q(100) =, q(100))
Fonction fabrique renvoyant une classe :

# classes class CasNormal(object): def uneMethode(self): print(normal)
class CasSpecial(object): def uneMethode(self): print(spcial) # fonction def casQuiConvient(estNormal=True): Fonction fabrique renvoyant une classe. return CasNormal() if estNormal else CasSpecial() # Programme principal ----------------------------------------------une_instance = casQuiConvient() une_instance.uneMethode() # normal autre_instance = casQuiConvient(False) autre_instance.uneMethode() # spcial
71
8.1.6 Les dcorateurs

Les dcorateurs Python sont des fonctions qui permettent deectuer des prtraitements lors de lappel dune fonction, dune mthode ou dune classe. Syntaxe Soit deco() un dcorateur. Pour dcorer une fonction on crit :
@deco def fonction(arg1, arg2, ...): pass
Cette criture est quivalente la composition de fonction :

def fonction(arg1, arg2, ...): pass fonction = deco(fonction) #---------------------------------------------------------# Exemple dune fonction g multi-dcore @f1 @f2 @f3 def g(): pass # Notation quivalente : g = f1(f2(f3(g)))
Voici un exemple simple :

#!/usr/bin/python3 # -*- coding: utf-8 -*# fonctions def unDecorateur(f): def _interne(*args, **kwargs): print(Fonction decore !) return f(*args, **kwargs) return _interne @unDecorateur def uneFonction(a, b): return a + b def autreFonction(a, b): return a + b
# programme principal =============================================== ## utilisation dun dcorateur print(uneFonction(1, 2)) ## utilisation de la composition de fonction autreFonction = unDecorateur(autreFonction) print(autreFonction(1, 2)) Fonction decore ! 3 Fonction decore ! 3
72
8.2 Techniques objets

Comme nous lavons vu lors du chapitre prcdent, Python est un langage compltement objet. Tous les types de base ou drivs sont en ralit des types abstraits de donnes implments sous forme de classe. Toutes ces classes drivent dune unique classe de base, anctre de toutes les autres : la classe object.
8.2.1 __slots__ et __dict__

Examinons le code suivant :
class Point: __slot__ = (x, y) def __init__(self, x=0, y=0): self.x = x self.y = y
Quand une classe est cre sans utiliser linstruction __slot__, ce que nous avons fait jusqu maintenant, Python cre de manire transparente un dictionnaire priv appel __dict__ pour chaque instance de la classe, et ce dictionnaire contient les attributs de linstance. Voici pourquoi il est possible dajouter ou de retirer des attributs dun objet. Mais si lon se contente dobjets sur lesquels nous accdons aux attributs sans en ajouter ou en ter, nous pouvons crer des classes sans dictionnaire priv, ce qui conomisera de la mmoire chaque instanciation. Cest ce qui est ralis dans lexemple ci-dessus en dnissant un attribut de classe __slot__ dont la valeur est un tuple form des noms des attributs.
8.2.2 Functor
En Python un objet fonction ou fonctor est une rfrence tout objet appelable 1 : fonction, fonction lambda, mthode, classe. La fonction prdnie callable() permet de tester cette proprit :
>>> def maFonction(): print(Ceci est appelable) >>> callable(maFonction) True >>> chaine = Ceci est appelable >>> callable(chaine) False
Il est possible de transformer les instances dune classe en functor si la mthode spciale __call__() est dnie dans la la classe :
>>> class A: def __call__(self, un , deux): return un + deux >>> a = A() >>> callable(a) True >>> a(1, 6) 7 1. callable en anglais.
8.2. TECHNIQUES OBJETS
73
8.2.3 Les accesseurs

Le problme de lencapsulation Dans le paradigme objet, ltat dun objet est priv, les autres objets nont pas le droit de le consulter ou de le modier. Classiquement, on distingue les visibilits suivantes : publique ; protge ; prive. En Python, tous les attributs (donnes, mthodes) sont publics ! On peut nanmoins amliorer cet tat de fait. Une simple convention courante est dutiliser des noms commenant par un soulign (_) pour signier attribut protg. Par exemple _attrib. Mais Python noblige rien, cest au dveloppeur de respecter la convention ! Python propose un mcanisme pour muler les attribut privs (le name mangling) : les identiants de la classe commencent par deux souligns (__). Par exemple __ident. Cette protection reste dclarative et nore pas une scurit absolue. La solution property Le principe de lencapsulation est mis en uvre par la notion de proprit. Dnition Une proprit (property) est un attribut dinstance possdant des fonctionnalits spciales.
Deux syntaxes implmentent cette solution. La premire dnit explicitement la proprit x et ses quatre paramtres (dans lordre) :
#!/usr/bin/python3 #-*- coding: utf-8 -*# fichier : property.py class C: def __init__(self): self._ma_propriete = None def getx(self): getter. return self._x def setx(self, value): setter. self._x = value def delx(self): deleter. del self._x x = property(getx, setx, delx, Je suis la proprit x.)
74
# auto-test ========================================================= if __name__ == __main__: test = C() test.x = 10 print(test.x) # setter # getter
print(C.x.__doc__) # documentation 10 Je suis la proprit x.
La seconde, plus simple, utilise la syntaxe des dcorateurs. On remarque que la chane de documentation de la property est ici la docstring de la dnition de la proprit x :
#!/usr/bin/python3 #-*- coding: utf-8 -*# fichier : property2.py class C: def __init__(self): self._x = None @property def x(self): Je suis la proprit x. return self._x @x.setter def x(self, value): self._x = value @x.deleter def x(self): del self._x
# auto-test ========================================================= if __name__ == __main__: test = C() test.x = 10 print(test.x) # setter # getter
print(C.x.__doc__) # documentation 10 Je suis la proprit x.
8.3. TECHNIQUES FONCTIONNELLES
75
8.3
Techniques fonctionnelles
8.3.1 Directive lambda

Issue de langages fonctionnels (comme Lisp), la directive lambda permet de dnir un objet fonction anonyme dont le retour est limit une expression. Syntaxe lambda [parameters]:expression
Par exemple cette fonction retourne s si son argument est dirent de 1, une chane vide sinon :
s = lambda x: if x == 1 else s
Autres exemples :
>>> def makeIncrementor(n): return lambda x: x+n >>> >>> >>> 5 9 >>> >>> >>> f2 = makeIncrementor(2) f6 = makeIncrementor(6) print(f2(3), f6(3))
L = [lambda x: x**2, lambda x: x**3, lambda x: x**4] for f in L: print(f(2), end= )
4 8 16
8.3.2 Les fonctions map, filter et reduce

La programmation fonctionnelle est un paradigme de programmation qui considre le calcul en tant quvaluation de fonctions mathmatiques et rejette le changement dtat et la mutation des donnes. Elle souligne lapplication des fonctions, contrairement au modle de programmation imprative qui met en avant les changements dtat 1 . Le paradigme fonctionnel nutilise pas de machine dtats pour dcrire un programme, mais un embotement de fonctions que lon peut voir comme des botes noires que lon peut imbriquer les unes dans les autres. Chaque bote possdant plusieurs paramtres en entre mais une seule sortie, elle ne peut sortir quune seule valeur possible pour chaque nuplet de valeurs prsentes en entre. Ainsi, les fonctions nintroduisent pas deets de bord. Un programme est donc une application, au sens mathmatique, qui ne donne quun seul rsultat pour chaque ensemble de valeurs en entre 2 . La programmation fonctionnelle repose sur trois concepts : mapping, ltering et reducing qui sont implments en Python par trois fonctions : map(), filter() et reduce(). La fonction map() : map() applique une fonction chaque lment dune squence et retourne un itrateur :
1. Cf. Wikipedia 2. Idem
76
>>> def renvoiTitres(element): return element.title()
>>> map(renvoiTitres, [fiat lux, lord of the fly]) [Fiat Lux, Lord Of The Fly] >>> >>> [element.title() for element in [fiat lux, lord of the fly]] [Fiat Lux, Lord Of The Fly]
On remarque que map() peut tre remplace par une liste en intension. La fonction filter() : filter() construit et renvoie un itrateur sur une liste qui contient tous les lments de la squence initiale rpondant au critre : function(element) == True :
>>> [1, >>> >>> [1, filter(lambda x: x > 0, [1, -2, 3, -4]) 3] [x for x in [1, -2, 3, -4] if x > 0] 3]
On remarque que filter() peut tre remplace par une liste en intension avec un test. La fonction reduce() : reduce() est une fonction du module functools. Elle applique de faon cumulative une fonction de deux arguments aux lments dune squence, de gauche droite, de faon rduire cette squence une seule valeur quelle renvoie :
>>> def somme(x, y): print x, +, y return x + y >>> 1 + 3 + 6 + 10 >>> >>> 10 reduce(somme, [1, 2, 3, 4]) 2 3 4
sum([1, 2, 3, 4])
On remarque que reduce() peut tre remplace par une des fonctions suivantes : all(), any(), max(), min() ou sum().
8.3.3 Les applications partielles de fonctions

Issue de la programmation fonctionnelle, une PFA (application partielle de fonction) de n paramtres prend le premier argument comme paramtre xe et retourne un objet fonction (ou instance) utilisant les n-1 arguments restants. Exemple simple :
>>> from functools import partial >>> baseTwo = partial(int, base=2) >>> baseTwo(10010) 18
8.3. TECHNIQUES FONCTIONNELLES
77
Les PFA sont trs utiles pour fournir des modles partiels de widgets, qui ont souvent de nombreux paramtres. Dans lexemple suivant, on rednit la classe Button en xant certains de ses attributs (qui peuvent toujours tre surchargs) :
from functools import partial import tkinter as tk root = tk.Tk() # instanciation partielle de classe : MonBouton = partial(tk.Button, root, fg=purple, bg=green) MonBouton(text=Bouton 1).pack() MonBouton(text=Bouton 2).pack() MonBouton(text=QUITTER, bg=red, fg=black, command=root.quit).pack(fill=tk.X, expand=True) root.title(PFA !) root.mainloop()
Ce rsultat est illustr par la gure 8.2.
Figure 8.2 Application partielle dun widget
78
Chapitre 9
La programmation OO graphique
Trs utilise dans les systmes dexploitation et dans les applications, les interfaces graphiques sont programmables en Python. Parmi les direntes bibliothques graphiques utilisables dans Python (GTK+, wxPython, Qt...), la bibliothque tkinter, issue du langage tcl/Tk est trs employe, car elle est installe de base dans toute les distributions Python. tkinter facilite la construction dinterfaces graphiques simples. Aprs avoir import la bibliothque, la mthode consiste crer, congurer et positionner les widgets utiliss, coder les fonctions/mthodes associes aux widgets, puis dentrer dans la boucle principale de gestion des vnements.
9.1
Programmes pilots par des vnements
En programmation graphique objet, on remplace le droulement squentiel du script par une boucle dvnements (cf. Fig. 9.1)
(a) Programmation squentielle
(b) Boucle dvnements
Figure 9.1 Deux styles de programmation.
80
CHAPITRE 9. LA PROGRAMMATION OO GRAPHIQUE
9.2 La bibliothque tkinter

9.2.1 Prsentation
Cest une bibliothque assez simple qui provient de lextention graphique, Tk, du langage Tcl dvelopp en 1988 par John K. Ousterhout de lUniversit de Berkeley. Cette extention a largement essaim hors de Tcl/Tk et on peut lutiliser en Perl, Python, Ruby, etc. Dans le cas de Python, lexension a t renomme tkinter. Paralllement Tk, des extensions ont t dveloppes dont certaines sont utilises en Python. Par exemple le module standard Tix met une quarantaine de widgets la disposition du dveloppeur. De son ct, le langage Tcl/Tk a largement volu. La version 8.5 actuelle ore une bibliothque appele Ttk qui permet d habiller les widgets avec dirents thmes ou styles. Ce module est galement disponible en Python 3.1.1. Un exemple tkinter simple (cf. Fig. 9.2)
import tkinter widget = tkinter.Label(None, text=Bonjour monde graphique !) widget.pack() # positionnement du label widget.mainloop() # lancement de la boucle dvnements
Figure 9.2 Un exemple simple
9.2.2 Les widgets de tkinter

Dnition On appelle widget, mot valise, contraction de window et gadget, les composants graphiques de base dune bibliothque.
Liste des principaux widgets de tkinter : Tk fentre de plus haut niveau Frame contenant pour organiser dautres widgets Label zone de message Button bouton avec texte ou image Message zone dachage multi-lignes Entry zone de saisie Checkbutton bouton deux tats Radiobutton bouton deux tats exclusifs Scale glissire plusieurs positions PhotoImage sert placer des images sur des widgets
9.3. DEUX EXEMPLES BitmapImage sert placer des bitmaps sur des widgets Menu associ un Menubutton Menubutton bouton ouvrant un menu doptions Scrollbar ascenseur Listbox liste de noms slectionner Text dition de texte multi-lignes Canvas zone de dessins graphiques ou de photos OptionMenu liste droulante ScrolledText widget Text avec ascenseur PanedWindow interface onglets LabelFrame contenant avec un cadre et un titre Spinbox un widget de slection multiple
81
9.2.3 Le positionnement des widgets

tkinter possde trois gestionnaires de positionnement : Le packer : dimensionne et place chaque widget dans un widget conteneur selon lespace requis par chacun deux. Le gridder : dimensionne et positionne chaque widget dans les cellules dun tableau dun widget conteneur. Le placer : dimensionne et place chaque widget w dans un widget conteneur exactement selon ce que demande w. Cest un placement absolu (usage peu frquent).
9.3
9.3.1
Deux exemples
tkPhone, un exemple sans menu
Il sagit de crer un script de gestion dun carnet tlphonique. Laspect de lapplication est illustr Fig. 9.3 Conception graphique La conception graphique va nous aider choisir les bons widgets. Tout dabord, il est naturel de distinguer trois zones : 1. la zone suprieure, ddie lachage ; 2. la zone mdiane est une liste alphabtique ordonne ; 3. la zone infrieure est forme de boutons de gestion de la liste ci-dessus. Chacune de ces zones est code par une instance de Frame(), positionne lune sous lautre grce au packer, et toutes trois incluses dans une instance de Tk() (cf. conception Fig. 9.3).
82
(a) Linterface graphique.
(b) La conception graphique.
Figure 9.3 tkPhone. Le code de linterface graphique An de ne pas mlanger les problmes, on se propose la mthodologie suivante : Remarque Sparer le codage de linterface graphique et celui des callbacks. Voici dans un premier temps le code de linterface graphique. Linitialisateur cre un attribut phoneList, une liste quil remplit avec le contenu du chier contenant les donnes (si le chier nexiste pas il est cr), cre la fentre de base root et appelle la mthode makeWidgets(). Cette mthode, suit la conception graphique et remplit chacun des trois frames. Les callbacks sont vides (instruction pass minimale). Comme tout bon module, un auto-test permet de vrier le bon fonctionnement (ici le bon aspect) de linterface :
import tkinter as tk # class class Allo_IHM(object): IHM de lapplication rpertoire tlphonique. def __init__(self, fic): Initialisateur/lanceur de la fentre de base self.phoneList = [] self.fic = fic f = open(fic) try: for line in f: self.phoneList.append(line[: -1].split(*)) except: # cration du fichier de rpertoire f = open(self.fic, w) finally: f.close() self.phoneList.sort()
9.3. DEUX EXEMPLES

self.root = tk.Tk() self.root.title(Allo !) self.root.config(relief=tk.RAISED, bd=3) self.makeWidgets() self.root.mainloop() def makeWidgets(self): Configure et positionne les widgets # frame saisie (en haut avec bouton deffacement) frameH = tk.Frame(self.root, relief=tk.GROOVE, bd=2) frameH.pack()
83
tk.Label(frameH, text=Nom :).grid(row=0, column=0, sticky=tk.W) self.nameEnt = tk.Entry(frameH) self.nameEnt.grid(row=0, column=1, sticky=tk.W, padx=5, pady=10) tk.Label(frameH, text=Tel :).grid(row=1, column=0, sticky=tk.W) self.phoneEnt = tk.Entry(frameH) self.phoneEnt.grid(row=1, column=1, sticky=tk.W, padx=5, pady=2) b = tk.Button(frameH, text=Effacer , command=self.clear) b.grid(row=2, column=0, columnspan=2, pady=3) # frame liste (au milieu) frameM = tk.Frame(self.root) frameM.pack() self.scroll = tk.Scrollbar(frameM) self.select = tk.Listbox(frameM, yscrollcommand=self.scroll.set, height=6) self.scroll.config(command=self.select.yview) self.scroll.pack(side=tk.RIGHT, fill=tk.Y, pady=5) self.select.pack(side=tk.LEFT, fill=tk.BOTH, expand=1, pady=5) ## remplissage de la Listbox for i in self.phoneList: self.select.insert(tk.END, i[0]) self.select.bind(<Double-Button-1>, lambda event: self.afficher (event)) # frame boutons (en bas) frameB = tk.Frame(self.root, relief=tk.GROOVE, bd=3) frameB.pack(pady=3) b1 = tk.Button(frameB, text=Ajouter , command=self.ajouter) b2 = tk.Button(frameB, text=Supprimer, command=self.supprimer) b3 = tk.Button(frameB, text=Afficher , command=self.afficher) b1.pack(side=tk.LEFT, pady=2) b2.pack(side=tk.LEFT, pady=2) b3.pack(side=tk.LEFT, pady=2) def ajouter(self): pass def supprimer(self): pass def afficher(self, event=None): pass
84
def clear(self): pass # auto-test --------------------------------------------------------if __name__ == __main__: app = Allo_IHM(phones.txt) # instancie lIHM
Le code de lapplication On va maintenant utiliser le module de la faon suivante : On importe la classe Allo_IHM depuis le module prcdent ; on cre une classe Allo qui en drive ; son initialisateur appelle linitialisateur de la classe de base pour hriter de toutes ses caractristiques ; il reste surcharger les callbacks. Enn, le script instancie lapplication.
# imports import tkinter as tk from tkPhone_IHM import Allo_IHM # classes class Allo(Allo_IHM): Rpertoire tlphonique. def __init__(self, fic=phones.txt): Constructeur de lIHM. Allo_IHM.__init__(self, fic) def ajouter(self): # maj de la liste ajout = [, ] ajout[0] = self.nameEnt.get() ajout[1] = self.phoneEnt.get() if (ajout[0] == ) or (ajout[1] == ): return self.phoneList.append(ajout) self.phoneList.sort() # maj de la listebox self.select.delete(0, tk.END) for i in self.phoneList: self.select.insert(tk.END, i[0]) self.clear() self.nameEnt.focus() # maj du fichier f = open(self.fic, a) f.write(%s*%s\n % (ajout[0], ajout[1])) f.close() def supprimer(self): self.clear() # maj de la liste retrait = [, ] retrait[0], retrait[1] = self.phoneList[int(self.select. curselection()[0])]
9.3. DEUX EXEMPLES

self.phoneList.remove(retrait) # maj de la listebox self.select.delete(0, tk.END) for i in self.phoneList: self.select.insert(tk.END, i[0]) # maj du fichier f = open(self.fic, w) for i in self.phoneList: f.write(%s*%s\n % (i[0], i[1])) f.close()
85
def afficher(self, event=None): self.clear() name, phone = self.phoneList[int(self.select.curselection()[0])] self.nameEnt.insert(0, name) self.phoneEnt.insert(0, phone) def clear(self): self.nameEnt.delete(0, tk.END) self.phoneEnt.delete(0, tk.END) # programme principal ---------------------------------------------------app = Allo() # instancie lapplication
9.3.2
IDLE, un exemple avec menu
Toutes les distributions Python comporte lapplication IDLE, linterprteur/diteur crit en Python 1 . Cette application se prsente sous laspect dune interface graphique complte (cf Fig. 9.4), avec menu. Cest un source Python dont le code est disponible 2 et constitue lui seul un cours complet tkinter.
1. Dans certaines distributions linux, IDLE est un package particulier. 2. Mais il est trop volumineux pour tre reproduit dans ces notes...
86
(a) Linterprteur dIDLE
(b) Lditeur dIDLE
Figure 9.4 IDLE.
Chapitre 10
Notion de dveloppement agile
Le dveloppement agile est un style de dveloppement logiciel itratif, davantage centr sur les personnes que sur les mthodes, et qui met laccent sur la satisfaction du client travers lintgration continue dun logiciel entirement fonctionnel. Le Manifeste Agile est un texte rdig en 2001 par 17 experts reconnus pour leurs apports respectifs au dveloppement dapplications informatiques sous la forme de plusieurs mthodes dont les plus connues sont leXtreme Programming et Scrum. Cette philosophie couvre lensemble du cycle de dveloppement du projet, mais nous nous limiterons ici aux problmes de la documentation et des tests.
10.1
Les tests
Ds lors quun programme dpasse le stade du petit script, le problme des erreurs et donc des tests se pose invitablement. Dnition Un test consiste appeler la fonctionnalit spcie dans la documentation, avec un scnario qui correspond un cas dutilisation, et vrier que cette fonctionnalit se comporte comme prvu.
Mthode Dans la philosophie du dveloppement agile , les tests sont crits en mme temps que le code, voire juste avant. On parle de DDT, Dveloppement Dirig par les Tests (ou TDD, Test Driven Developpement).
10.1.1 Tests unitaires et tests fonctionnels

On distingue deux familles de test :
88
CHAPITRE 10. NOTION DE DVELOPPEMENT AGILE
Tests unitaires : validations isoles du fonctionnement dune classe, dune mthode ou dune fonction. Par convention, chaque module est associ un module de tests unitaires, plac dans un rpertoire tests du paquet. Par exemple, un module nomm calculs.py aura un module de tests nomm tests/test_calculs.py Tests fonctionnels : prennent lapplication complte comme une bote noire et la manipulent comme le ferait lutilisateur nal. Ces tests doivent passer par les mmes interfaces que celles fournies aux utilisateurs, cest pourquoi ils sont spciques la nature de lapplication et plus dlicats mettre en uvre. On peut citer les projets : Mechanize : fournit des objets Python sans IHM qui bouchonnent un navigateur Web ; Selenium : tests fonctionnels pour les applications Web dans un vritable navigateur ; guitest : teste les applications GTK ; FunkLoad ore un systme de benchmark et de reporting tendu.
10.1.2 Le dveloppement dirig par les tests

Le module Python unittest fournit loutil PyUnit, outil que lon retrouve dans dautres langages : JUnit (Java), NUnit (.Net), JSUnit (Javascript), tous drivs dun outil initialement dvelopp pour le langage SmallTalk : SUnit. PyUnit propose une classe de base, TestCase. Chaque mthode implmente dans une classe drive de TestCase, et prxe de test_, sera considre comme un test unitaire 1 :
Module de calculs. # fonctions def moyenne(*args): Renvoie la moyenne. length = len (args) sum = 0 for arg in args: sum += arg return sum/length def division(a, b): Renvoie la division. return a/b Module de test du module de calculs. # imports import unittest import os import sys dirName = os.path.dirname(__file__) if dirName == : 1. Cf. [B6] p. 131
10.2. LA DOCUMENTATION
dirName = . dirName = os.path.realpath(dirName) upDir = os.path.split(dirName)[0] if upDir not in sys.path: sys.path.append(upDir) from calculs import moyenne, division # classes class CalculTest(unittest.TestCase): def test_moyenne(self): self.assertEquals(moyenne(1, 2, 3), 2) self.assertEquals(moyenne(2, 4, 6), 4) def test_division(self): self.assertEquals(division(10, 5), 2) self.assertRaises(ZeroDivisionError, division, 10, 0) def test_suite(): tests = [unittest.makeSuite(CalculTest)] return unittest.TestSuite(tests) if __name__ == __main__: unittest.main()
89
Pour eectuer une campagne de tests , il reste crer un script qui : recherche tous les modules de test : leurs noms commencent par test_ et ils sont contenus dans un rpertoire tests ; rcupre la suite, renvoye par la fonction globale test_suite ; cre une suite de suites et lance la campagne.
10.2
La documentation
Durant la vie dun projet, on distingue plusieurs types de documentation : les documents de spcication (upstream documentation) ; les documents techniques attachs au code (mainstream documentation) ; les manuels dutilisation et autres documents de haut niveau (downstream documentation). Les documents mainstream voluent au rythme du code et doivent donc tre traits comme lui : ils doivent pouvoir tre lus et manipuls avec un simple diteur de texte. Il existe deux outils majeurs pour concevoir des documents pour les applications Python : le reStructuredText (ou reST) : un format enrichi ; les doctests : compatibles avec le format reST. Ils permettent de combiner les textes applicatifs avec les tests.
10.2.1 Le format reST

Le format reStructuredText, communment appel reST est un systme de balises utilis pour formater des textes.
90
A la dirence de LTEX il enrichit le document de manire non intrusive , cest--dire que les chiers restent directement lisibles.
Le projet docutils, qui inclut linterprteur reST, fournit un jeu dutilitaires : rst2html gnre un rendu html avec une css intgre ;
A rst2latex cre un chier LTEX quivalent ;
rst2s5 construit une prsentation au format s5, qui permet de crer des prsentations interactives en HTML. Voici un exemple simple 1 de cier texte au format reST. On remarque entre autres que : la principale balise est la ligne blanche qui spare les direntes structures du texte ; la structuration se fait en soulignant les titres des sections de dirents niveaux avec des caractres de ponctuation (= - _ : , etc.). chaque fois quil rencontre un texte ainsi soulign, linterprteur associe le caractre utilis un niveau de section ; un titre est gnralement soulign et surlign avec le mme caractre, comme dans lexemple suivant :
====================== Fichier au format reST ====================== Section 1 ========= On est dans la section 1. Sous-section :::::::::::: Ceci est une sous-section. Sous-sous-section ................. Ceci est une sous-sous-section. .. et ceci un commentaire Section 2 ========= La section 2 est beaucoup plus **intressante** que la section 1. Section 3 ========= La section 2 est un peu vantarde : la section 1 est *trs bien*. --------------Un tableau de trois images au format png :::::::::::::::::::::::::::::::::::::::::: 1. Cf. [B6] p. 131
91
======= Image 1 ======= |shamr| =======
======= Image 2 ======= |elysT| =======
======= Image 3 ======= |helen| =======
.. |shamr| image:: shamr.png .. |elysT| image:: elysT.png .. |helen| image:: helen.png
Lutilitaire rst2html, appliqu ce chier, produit le chier de mme nom mais avec lextention .html (cf. Fig. 10.1).
92
Figure 10.1 exemple de sortie au format HTML.
93
10.2.2 Le module doctest

A Le principe du literate programming de Donald Knuth, le crateur de LTEX, a t repris en Python pour documenter les API via les chanes de documentation. Des programmes comme Epydoc peuvent alors les extraire des modules pour composer une documentation.
Il est possible daller plus loin et dinclure dans les chanes de documentation des exemples dutilisation, crits sous la forme de session interactive. Examinons trois exemples. Pour chacun, nous donnerons dune part le source muni de sa chane de documentation dans lequel le module standard doctest permet dextraire puis de lancer ces sessions pour vrier quelles fonctionnent et, dautre part une capture dcran de lexcution. Premier exemple : doctest1.py
Module dessai de doctest. # import import doctest # fonctions def somme(a, b): Renvoie a + b. >>> somme(2, 2) 4 >>> somme(2, 4) 6 return a+b if __name__ == __main__: print({:-^40}.format( Mode silencieux )) doctest.testmod() print(Si tout va bien, on a rien vu !) input() print({:-^40}.format( Mode dtaill )) doctest.testmod(verbose=True)
Lexcution de ce chier est illustr Fig. 10.2. Deuxime exemple : doctest2.py

Module dessai de doctest. # fonctions def accentEtrange(texte): Ajoute un accent trange un texte. Les r sont Tripls, les e suivi dun u Exemple : >>> texte = Est-ce que tu as regard la tl hier soir ? Il y avait un thma sur les ramasseurs descargots en Laponie, ils en bavent...
94
Figure 10.2 Excution du script doctest1.py.

>>> accentEtrange(texte) Est-ceu queu tu as rRreugarRrd la tl hieurRr soirRr ? Il y avait un thma surRr leus rRramasseuurRrs deuscarRrgots eun Laponieu, ils eun baveunt... Cette technique permet dinternationnaliser les applications pour les rendre compatibles avec certaines rgions franaises. texte = texte.replace(r, rRr) print(texte.replace(e, eu)) def _test(): import doctest doctest.testmod(verbose=True) if __name__ == __main__: _test()
Lexcution de ce chier est illustr Fig. 10.3. Troisime exemple : example.py

This is the example module. The example module supplies one function, factorial(). For example, >>> factorial(5) 120 def factorial(n): Return the factorial of n, an exact integer >= 0.
95
Figure 10.3 Excution du script doctest2.py.
If the result is small enough to fit in an int, return an int. Else return a long. >>> [factorial(n) for n in range(6)] [1, 1, 2, 6, 24, 120] >>> factorial(30) 265252859812191058636308480000000 >>> factorial(-1) Traceback (most recent call last): ... ValueError: n must be >= 0 Factorials of floats are OK, but the float must be an exact integer: >>> factorial(30.1) Traceback (most recent call last): ... ValueError: n must be exact integer >>> factorial(30.0) 265252859812191058636308480000000 It must also not be ridiculously large: >>> factorial(1e100) Traceback (most recent call last): ... OverflowError: n too large import math if not n >= 0: raise ValueError(n must be >= 0) if math.floor(n) != n: raise ValueError(n must be exact integer) if n+1 == n: # catch a value like 1e300 raise OverflowError(n too large) result = 1 factor = 2 while factor <= n: result *= factor
96
factor += 1 return result
def _test(): import doctest doctest.testmod(verbose=True) if __name__ == __main__: _test() print(OK)
Lexcution de ce chier est illustr Fig. 10.4.
10.2.3 Le dveloppement dirig par la documentation

Comme on peut le voir, la documentation intgre prsente nanmoins un dfaut : quand la documentation augmente, on ne voit plus le code ! La solution est de dporter cette documentation : la fonction doctest.testfile() permet dindiquer le nom du chier de documentation. Qui plus est, on peut crire ce chier au format reST, ce qui permet de faire coup double. Dune part, on dispose des tests intgrs la fonction (ou la mthode) et, dautre part, le mme chier fournit une documentation jour. Exemple : doctest2.py Source du module 1 .
Le module accent ==================== Test de la fonction accentEtrange ------------------------------------Ce module fournit une fonction accentEtrange qui permet dajouter un accent un texte : >>> from doctest2 import accentEtrange >>> texte = Est-ce que tu as regard la tl hier soir ? Il y avait un thma sur les ramasseurs descargots en Laponie, ils en bavent... >>> accentEtrange(texte) Est-ceu queu tu as rRreugarRrd la tl hieurRr soirRr ? Il y avait un thma surRr leus rRramasseuurRrs deuscarRrgots eun Laponieu, ils eun baveunt... Les r sont tripls et les e pauls par des u. Cette technique permet de se passer de systmes de traductions complexes pour faire fonctionner les logiciels dans certaines rgions. 1. Cf. [B6] p. 131
97
Figure 10.4 Excution du script example.py.
98
Module dessai de doctest2. import doctest doctest.testfile(doctest2.txt, verbose=True)
La documentation de ce chier est illustre Fig. 10.5.
Figure 10.5 Documentation du script doctest2.py.
Exemple de calcul des factorielles Source du module 1 .

The example module ====================== Using factorial ------------------This is an example text file in reStructuredText format. First import factorial from the example module: >>> from example import factorial Now use it: >>> factorial(6) 720 import doctest doctest.testfile(example.txt, verbose=True)
La documentation de ce chier est illustre Fig. 10.6.
1. Cf. [B6] p. 131
99
Figure 10.6 Documentation du script example.py.
100
Annexe A
Interlude Le Zen de Python 1

Prfre : la beaut la laideur, lexplicite limplicite, le simple au complexe et le complexe au compliqu, le droul limbriqu, lar au compact. Prends en compte la lisibilit. Les cas particuliers ne le sont jamais assez pour violer les rgles. Mais, la puret, privilgie laspect pratique. Ne passe pas les erreurs sous silence, ... ou billonne-les explicitement. Face lambigut, deviner ne te laisse pas aller. Sache quil ne devrait avoir quune et une seule faon de procder, mme si, de prime abord, elle nest pas vidente, moins dtre Nerlandais. Mieux vaut maintenant que jamais. Cependant jamais est souvent mieux quimmdiatement. Si limplmentation sexplique dicilement, cest une mauvaise ide. Si limplmentation sexplique aisment, cest peut-tre une bonne ide. Les espaces de nommage ! Sacre bonne ide ! Faisons plus de trucs comme a.
1. Tim Peters (PEP no 20), traduction Ccile Trevian et Bob Cordeau. Retour chap.1 historique, p. 2
102
ANNEXE A. INTERLUDE
Le Graal de Python 1 !
arthur: Lancelot ! Lancelot ! Lancelot ! [mgaphone de police] Lancelooooooooot ! lancelot: Bloody hell, mais que se passe-t-il donc, mon Roi ? arthur: Bevedere, explique-lui ! bevedere: Nous devons te parler dun nouveau langage de programmation : Python lancelot: Nouveau ? Cela fait bien dix ans quil existe, et je ne vois pas en quoi cela va nous aider rcuprer le Saint-Graal ! bevedere: Saint-Graal, Saint-Graal... [soupir] Tu ne peux pas penser des activits plus saines que cette qute stupide de temps en temps ? arthur: [sort une massue et assomme Bevedere avec] Son explication tait mal partie de toute manire. gardes franais: Est-ce que ces messieurs les Anglais peuvent aller sentretuer plus loin ? Ne voyez-vous pas que nous sommes concentrs sur notre jeu en ligne ? arthur: Ce tunnel sous la Manche, quelle hrsie ! [racle sa gorge] Lancelot, assieds-toi, et coute-moi. (et ferme ce laptop, bloody hell !)
1. Cf. [B5] p. 131
103 lancelot: [rabat lcran de son laptop] arthur: La qute a chang. Tu dois maintenant apprendre le langage Python, et dcouvrir pourquoi il est de plus en plus pris par mes sujets. lancelot: Mais... arthur: Il ny a pas de mais ! [menace Lancelot avec sa massue] Je suis ton Roi. dot slash. Prends ce livre, et au travail ! gardes franais: Oui, au travail, et en silence !
104
ANNEXE A. INTERLUDE
Annexe B
Jeux de caractres et encodage
Position du problme
Nous avons vu que lordinateur code toutes les informations quil manipule en binaire. Pour coder les nombres entiers un changement de base sut, pour les ottants, on utilise une norme (IEEE 754), mais la situation est plus complexe pour reprsenter les caractres. En eet, la grande diversit des langues humaines et de leur reprsentation ncessite un codage adapt. La premire ide est de constuire une table qui associe les symboles reprsenter un nombre (gnralement cod sur un octet) : Symbole Nombre La plus clbre est la table ASCII 1 (cf. Fig.B.1), code sur 7 bits (soit 128 codes), mais bien dautres tables ont t cres (EBCDIC, ISO-8852-1...).
Figure B.1 Table ASCII.
La table Unicode
En Python 3, les chanes de caractres (le type str()) sont des chanes Unicode, norme dans laquelle les identiants numriques de leurs caractres sont uniques et universels.
1. American Standard Code for Information Interchange
106
ANNEXE B. JEUX DE CARACTRES ET ENCODAGE
Comme il sagit de direncier plusieurs centaines de milliers de caractres (on compte environ 6000 langues dans le monde) ils ne pourront videmment pas tre encods sur un seul octet. En fait, la norme Unicode ne xe aucune rgle concernant le nombre doctets ou de bits rserver pour lencodage, mais spcie seulement la valeur numrique de lidentiant associ chaque caractre (cf. Fig.B.2).
Figure B.2 Extrait de la table Unicode.
Encodage
Aprs avoir collect tous les symboles et y avoir associ un nombre, il reste leur trouver une reprsentation binaire. Pour lASCII un seul octet susait mais pour reprsenter les millions de possibilits de lUnicode, plusieurs octets par caractre sont ncessaires. Comme la plupart des textes nutilisent que la table ASCII ce qui correspond justement la partie basse de la table Unicode, lencodage le plus conomique est lUTF-8. Pour les codes 0 127, lUTF-8 utilise loctet de la table ASCII. Pour les caractres spciaux (codes 128 2047), lUTF-8 utilise 2 octets. Pour les caractres spciaux encore moins courants (codes 2048 65535), lUTF-8 utilise 3 octets, et ainsi de suite 1 . Symbole Nombre Bits Exemple de lencodage UTF-8 du caractre Unicode : 233 C3 A9
Applications pratiques
Les entres/sorties Il est important de pouvoir prciser sous quelle forme exacte les donnes sont attendues par nos programmes, que ces donnes soient fournies par lintermdiaire de frappes au clavier
1. Retour chap. 2 identiants, p. 8
107 ou par importation depuis une source quelconque. De mme, nous devons pouvoir choisir le format des donnes que nous exportons vers nimporte quel dispositif priphrique, quil sagisse dune imprimante, dun disque dur, dun cran... Pour toutes ces entres ou sorties de chanes de caractres, nous devrons donc toujours considrer quil sagit concrtement de squences doctets, et utiliser divers mcanismes pour convertir ces squences doctets en chanes de caractres, ou vice-versa. Python met dsormais votre disposition le nouveau type de donnes bytes, spciquement conu pour traiter les squences (ou chanes) doctets. Les caractres peuvent bien entendu tre encods en octets, et les octets dcods en caractres (en particulier avec lencodage UTF-8 que nous venons de voir) :
>>> chaine = Une dille\n >>> of = open(test.txt, w) # une chaine de caractres, type str() >>> of.write(chaine) 12 >>> of.close() >>> of = open(test.txt, rb) # une chaine doctets, type bytes() >>> octets = of.read() >>> type(chaine) <class str> >>> print(chaine) Une dille >>> len(chaine) 12 >>> type(octets) <class bytes> >>> print(octets) bUn \xe7\xe9ille\r\b >>> len(octets) 13
Cas des scripts Python Puisque les scripts Python que lon produit avec un diteur sont eux-mmes des textes, ils risquent dtre encods suivant direntes normes. An que Python puisse les interprter correctement, il est est utile de prcisez le jeu de caractres (obligatoirement en 1re ou 2e ligne des sources). Il faut au pralable connatre le jeu de caractres utilis par votre systme (cf. Fig.B.3).
import sys print(sys.stdout.encoding) # cp1252 (Windows XP/SciTE)
Alors on le prcise dans les scripts :

# -*- coding: cp1252 -*-
Ou bien (ce qui est le dfaut pour la version 3 de Python) :

# -*- coding: UTF-8 -*-
Pour viter les erreurs Unicode Pour viter les erreurs Unicode, la technique consiste indiquer lencodage au moment des entres-sorties. Par exemple :
108
ANNEXE B. JEUX DE CARACTRES ET ENCODAGE
Figure B.3 Le jeu de caractres cp1252.

>>> chaine = Une dille\n >>> of = open(test.txt, w, encoding=Latin-1) >>> of.write(chaine) 12 >>> of.close() >>> of = open(test.txt, r, encoding=Latin-1) >>> ch_lue = of.read() >>> of.close() >>> ch_lue Une dille\n
Annexe C
Les fonctions logiques
La logique de Boole
Au 19 sicle, le logicien et mathmaticien George Boole restructura compltement la logique en un systme formel. Aujourdhui, lalgbre de Boole trouve de nombreuses applications en informatique et dans la conception des circuits lectroniques. Cest une logique deux valeurs. Soit B = {0, 1}, lensemble de dnition, sur lequel on dnit les oprateurs NON, ET et OU. Les valeurs des variables sont parfois notes False et True. Les oprateurs sont parfois nots respectivement a, a.b et a + b.
Les tables de vrit

Table de vrit des oprateurs boolens de base : Oprateur unaire NON a 0 1 Oprateurs binaires OU et ET a 0 0 1 1 b 0 1 0 1 a OU b a ET b 0 0 1 0 1 0 1 1 N ON (a) 1 0
Table de vrit des oprateurs composs 1 : Oprateurs ou exclusif, quivalence et implication a 0 0 1 1 b 0 1 0 1 a XOR b a b a = b 0 1 1 1 0 1 1 0 0 0 1 1
1. Retour chap. 2 expressions boolennes, p. 11
110
ANNEXE C. LES FONCTIONS LOGIQUES
Annexe D
Les bases arithmtiques
Dnition
Dnition En arithmtique, une base n dsigne la valeur dont les puissances successives interviennent dans lcriture des nombres, ces puissances dnissant lordre de grandeur de chacune des positions occupes par les chires composant tout nombre. Par exemple : 57n = (5 n1 ) + (7 n0 )
Certaines bases sont couramment employes : la base 2 (systme binaire), en lectronique numrique et informatique ; la base 8 (systme octal), en informatique ; la base 16 (systme hexadcimal), frquente en informatique ; la base 60 (systme sexagsimal), dans la mesure du temps et des angles.
Conversion
Dnition Les changements de base : un nombre dans une base n donne scrit sous la forme daddition des puissances successives de cette base 1 .
Exemples
5716 = (5 161 ) + (7 160 ) = 8710 578 = (5 81 ) + (7 80 ) = 4710
1. Retour chap.2 type int, p. 9
112
ANNEXE D. LES BASES ARITHMTIQUES
Annexe E
Les fonctions de hachage
Principe
Cest une application f qui prend en entre des chiers de longueur dirente, les condense, et fournit en sortie une squence binaire de longueur xe (cf. Fig.E.1) : f : {0, 1} {0, 1}k o f applique lensemble des squences binaires : {0, 1} = {, 0, 1, 10, 11, 100, 101, ...} sur lensemble des squences binaires de k bits : {0, 1}k = {0...00, 0..01, 0...10, ..., 1...11}. Cette application doit permettre didentier les chiers en entre : f (x) = f (y) sera vrai si et seulement si x = y. Par contre, cause de la longueur nie de k, on ne peut pas reconstituer les chiers : il existe deux valeurs x et y direntes (chiers distincts), telles que f (x) = f (y) (mme squence binaire). On parle alors de collision.
Figure E.1 Le principe du hachage
Ralisation pratique
Il faut rsoudre deux problmes : diminuer le nombre de collisions en choisissant une squence binaire assez longue. Avec, par exemple, k = 512, on obtient 2512 soit environ 10154 cellules disponibles. grer les collisions restantes par un algorithmes appropri. Application aux dictionnaires On dispose dun espace mmoire S pour stocker m donnes. On peut accder chaque donne par une notation associative o linformation entre crochets sappelle la cl : S[0], S[1], ..., S[m 1].
114
ANNEXE E. LES FONCTIONS DE HACHAGE
(a) Stockage sans collision
(b) Gestion des collisions par sondage linaire
Figure E.2 Hachage des cls dun dictionnaire. Par exemple avec des cls de caractres, on utilisera une fonction de hachage ainsi dnie : f : {a, b, c, ..., z} {0, 1, 2, ..., m 1}
1
Soit stocker les informations suivantes dans un dictionnaire (cf. Fig.E.2) : lapin renard hrisson ours 12 2 4 1
1. Retour chap.4 type dict, p. 32
Annexe F
Exercices corrigs noncs des exercices

Remarque Les exercices suivants sont fournis titre dexemples et de modles. Ils sont soit simples, soit moins simples (nots dans la marge) soit plus diciles (nots ). 1. crire un programme qui, partir de la saisie dun rayon et dune hauteur, calcule le volume dun cne droit. 2. Une boucle while : entrez un prix HT (entrez 0 pour terminer) et achez sa valeur TTC. 3. Une autre boucle while : calculez la somme dune suite de nombres positifs ou nuls. Comptez combien il y avait de donnes et combien taient suprieures 100. Un nombre infrieur ou gal 0 indique la n de la suite. 4. Lutilisateur donne un entier positif n et le programme ache PAIR sil est divisible par 2 et IMPAIR sinon. 5. Lutilisateur donne un entier positif et le programme annonce combien de fois de suite cet entier est divisible par 2. 6. Lutilisateur donne un entier suprieur 1 et le programme ache, sil y en a, tous ses diviseurs propres sans rptition ainsi que leur nombre. Sil ny en a pas, il indique quil est premier. Par exemple :
Entrez un entier strictement positif : 12 Diviseurs propres sans rptition de 12 : 2 3 4 6 (soit 4 diviseurs propres) Entrez un entier strictement positif : 13 Diviseurs propres sans rptition de 13 : aucun ! Il est premier
7. crire un programme qui estime la valeur de la constante mathmatique e en utilisant la formule : n 1 e= i! i=0 Pour cela, dnissez la fonction factorielle et, dans votre programme principal, saisissez lordre n et achez lapproximation correspondante de e. 8. Un gardien de phare va aux toilettes cinq fois par jour or les WC sont au rez-dechausse. . . crire une procdure (donc sans retour) hauteurparcourue qui reoit deux paramtres le nombre de marches du phare et la hauteur de chaque marche (en cm), et qui ache :
116
ANNEXE F. EXERCICES CORRIGS

Pour x marches de y cm, il parcourt z.zz m par semaine.
On noubliera pas : quune semaine comporte 7 jours ; quune fois en bas, le gardien doit remonter ; que le rsultat est exprimer en m. 9. Un permis de chasse points remplace dsormais le permis de chasse traditionnel. Chaque chasseur possde au dpart un capital de 100 points. Sil tue une poule il perd 1 point, 3 points pour un chien, 5 points pour une vache et 10 points pour un ami. Le permis cote 200 . crire une fonction amende qui reoit le nombre de victimes du chasseur et qui renvoie la somme due. Utilisez cette fonction dans un programme principal qui saisit le nombre de victimes et qui ache la somme que le chasseur doit dbourser. 10. Je suis ligot sur les rails en gare dArras. crire un programme qui ache un tableau me permettant de connatre lheure laquelle je serai dchiquet par le train parti de la gare du Nord 9h (il y a 170 km entre la gare du Nord et Arras). Le tableau prdira les direntes heures possibles pour toutes les vitesses de 100 km/h 300 km/h, par pas de 10 km/h, les rsultats tant arrondis la minute infrieure. crire une procdure tchacatchac qui reoit la vitesse du train et qui ache lheure du drame ; crire le programme principal qui ache le tableau demand. 11. Un programme principal saisit une chane dADN valide et une squence dADN valide ( valide signie quelles ne sont pas vides et sont formes exclusivement dune combinaison arbitraire de a, t, g ou c). crire une fonction valide qui renvoie vrai si la saisie est valide, faux sinon. crire une fonction saisie qui eectue une saisie valide et renvoie la valeur saisie sous forme dune chane de caractres. crire une fonction proportion qui reoit deux arguments, la chane et la squence et qui retourne la proportion de squence dans la chane (cest--dire son nombre doccurrences). Le programme principal appelle la fonction saisie pour la chane et pour la squence et ache le rsultat. Exemple dachage : Il y a 13.33 % de ca dans votre chane. 12. Il sagit dcrire, dune part, un programme principal et, dautre part, une fonction utilise dans le programme principal. La fonction listAleaInt(n, a, b) retourne une liste de n entiers alatoires dans [a .. b] en utilisant la fonction randint(a, b) du module random. Dans le programme principal : construire la liste en appelant la fonction listAleaInt() ; calculer lindex de la case qui contient le minimum ; changez le premier lment du tableau avec son minimum.
117 13. Comme prcdemment, il sagit dcrire, dune part, un programme principal et, dautre part, une fonction utilise dans le programme principal. La fonction listAleaFloat(n) retourne une liste de n ottants alatoires en utilisant la fonction random() du module random. Dans le programme principal : Saisir un entier n dans lintervalle : [2 .. 100] ; construire la liste en appelant la fonction listAleaFloat() ; acher lamplitude du tabeau (cart entre sa plus grande et sa plus petite valeur) ; acher la moyenne du tableau. 14. Fonction renvoyant plusieurs valeurs sous forme dun tuple. crire une fonction minMaxMoy qui reoit une liste dentiers et qui renvoie le minimum, le maximum et la moyenne de cette liste. Le programme principal appellera cette fonction avec la liste : [10, 18, 14, 20, 12, 16]. 15. Saisir un entier entre 1 et 3999 (pourquoi cette limitation ?). Lacher en nombre romain. 16. Amliorer le script prcdent en utilisant la fonction zip().
17. Un tableau contient n entiers (2 < n < 100) alatoires tous compris entre 0 et 500. Vrier quils sont tous dirents. 18. Lutilisateur donne un entier n entre 2 et 12, le programme donne le nombre de faons de faire n en lanant deux ds. 19. Mme problme que le prcdent mais avec n entre 3 et 18 et trois ds. 20. Gnralisation des deux questions prcdentes. Lutilisateur saisit deux entres, dune part le nombre de ds, nbd (que lon limitera pratiquement 10) et, dautre part la somme, s, comprise entre nbd et 6.nbd. Le programme calcule et ache le nombre de faons de faire s avec les nbd ds. 21. Mme problme que le prcdent mais cod rcursivement. 22. Nombres parfaits et nombres chanceux. On appelle nombre premier tout entier naturel suprieur 1 qui possde exactement deux diviseurs, lui-mme et lunit. On appelle diviseur propre de n, un diviseur quelconque de n, n exclu. Un entier naturel est dit parfait sil est gal la somme de tous ses diviseurs propres. Les nombres a tels que : (a+n+n2 ) est premier pour tout n tel que 0 n < (a1), sont appels nombres chanceux. crire un module (parfait_chanceux_m.py) dnissant quatre fonctions : somDiv, estParfait, estPremier, estChanceux et un auto-test : la fonction somDiv retourne la somme des diviseurs propres de son argument ; les trois autres fonctions vrient la proprit donne par leur dnition et retourne un boolen. Plus prcisment, si par exemple la fonction estPremier vrie que son argument est premier, elle retourne True, sinon elle retourne False. La partie de test doit comporter quatre appels la fonction verif permettant de tester somDiv(12), estParfait(6), estPremier(31) et estChanceux(11). Puis crire le programme principal (parfait_chanceux.py) qui comporte :
118
ANNEXE F. EXERCICES CORRIGS linitialisation de deux listes : parfaits et chanceux ; une boucle de parcours de lintervalle [2, 1000] incluant les tests ncessaires pour remplir ces listes ; enn lachage de ces listes.
Solutions des exercices

# -*- coding: utf-8 -*Volume dun cne droit. # imports from math import pi # programme principal ----------------------------------------------rayon = float(input(Rayon du cne (m) : )) hauteur = float(input(Hauteur du cne (m) : )) volume = (pi*rayon*rayon*hauteur)/3.0 print(Volume du cne =, volume, m3) # -*- coding: utf-8 -*Calcul dun prix TTC. # programme principal ----------------------------------------------prixHT = float(input(Prix HT (0 pour terminer)? )) while prixHT > 0: print(Prix TTC : {:.2f}\n.format(prixHT * 1.196)) prixHT = float(input(Prix HT (0 pour terminer)? )) print(Au revoir !) # -*- coding: utf-8 -*Somme dentiers et nombre dentiers suprieur 100. # programme principal ----------------------------------------------somme, nombreTotal, nombreGrands = 0, 0, 0 x = int(input(x (0 pour terminer) ? )) while x > 0: somme += x nombreTotal += 1 if x > 100: nombreGrands += 1 x = int(input(x (0 pour terminer) ? )) print(\nSomme :, somme) print(nombreTotal, valeur(s) en tout, dont, nombreGrands, suprieure (s) 100) # -*- coding: utf-8 -*Parit. # programme principal ----------------------------------------------n = int(input(Entrez un entier strictement positif : )) while n < 1: n = int(input(Entrez un entier STRICTEMENT POSITIF, s.v.p. : ))
119
if n%2 == 0: print(n, est pair.) else: print(n, est impair.) # -*- coding: utf-8 -*Nombre de fois quun entier est divisible par 2. # programme principal ----------------------------------------------n = int(input(Entrez un entier strictement positif : )) while n < 1: n = int(input(Entrez un entier STRICTEMENT POSITIF, s.v.p. : )) save = n cpt = 0 while n%2 == 0: n /= 2 cpt += 1 print(save, est, cpt, fois divisible par 2.) # -*- coding: utf-8 -*Diviseurs propres dun entier. # programme principal ----------------------------------------------n = int(input(Entrez un entier strictement positif : )) while n < 1: n = int(input(Entrez un entier STRICTEMENT POSITIF, s.v.p. : )) i = 2 cpt = 0 p = n/2 # plus petit diviseur possible de n # initialise le compteur de divisions # calcul une fois dans la boucle
print(Diviseurs propres sans rptition de , n, :, end= ) while i <= p: if n%i == 0: cpt += 1 print(i, end= ) i += 1 if not cpt: print(aucun ! Il est premier.) else: print((soit, cpt, diviseurs propres)) # -*- coding: utf-8 -*Approximation de e. # fonction def fact(n): r = 1 for i in range(1, n+1): r *= i return r # programme principal ----------------------------------------------n = int(input(n ? ))
120
exp = 0.0 for i in range(n): exp = exp + 1.0/fact(i)
print(Approximation de e : {:.3f}.format(exp)) # -*- coding: utf-8 -*Gardien de phare. # fonction def hauteurParcourue(nb, h): print(Pour {:d} marches de {:d} cm, il parcourt {:.2f} m par semaine..format(nb, h, nb*h*2*5*7/100.0)) # programme principal ----------------------------------------------nbMarches = int(input(Combien de marches ? )) hauteurMarche = int(input(Hauteur dune marche (cm) ? )) hauteurParcourue(nbMarches, hauteurMarche) # -*- coding: utf-8 -*Permis de chasse. # fonction def permisSup(p, c, v, a): pointsPerdus = p + 3*c + 5*v + 10*a nbrePermis = pointsPerdus/100.0 return 200*nbrePermis # programme principal ----------------------------------------------poules = int(input(Combien de poules ? )) chiens = int(input(Combien de chiens ? )) vaches = int(input(Combien de vaches ? )) amis = int(input(Combien damis ? )) payer = permisSup(poules, chiens, vaches, amis) print(\nA payer :, end= ) if payer == 0: print(rien payer) else: print(payer, euros) # -*- coding: utf-8 -*Histoire de train. # fonction def tchacatchac(v): Affiche lheure du drame. heure = 9 + int(170/v) minute = (60 * 170 / v) % 60 print(A, v, km/h, je me fais dchiqueter , heure, h, minute, min.) # programme principal ----------------------------------------------i = 100 while i <= 300: tchacatchac(i) i += 10
121
# -*- coding: utf-8 -*Proportion dune squence dans une chane dADN. # fonctions def valide(seq): Retourne vrai si la squence est valide, faux sinon. ret = any(seq) for c in seq: ret = ret and c in atgc return ret def proportion(a, s): Retourne la proportion de la squence <s> dans la chane <a>. return 100*a.count(s)/len(a) def saisie(ch): s = input({:s} : .format(ch)) while not valide(s): print({:s} ne peut contenir que les chanons a, t, g et c et ne doit pas tre vide.format(ch)) s = input({:s} : .format(ch)) return s # programme principal ----------------------------------------------adn = saisie(chane) seq = saisie(squence) print(Il y a {:.2f} % de {:s} dans votre chane. .format(proportion(adn, seq), seq)) # -*- coding: utf-8 -*Echanges. # imports from random import seed, randint # fonction def listAleaInt(n, a, b): Retourne une liste de <n> entiers alatoires dans [<a> .. <b>]. return [randint(a, b) for i in range(n)] # programme principal ----------------------------------------------seed() # initialise le gnrateur de nombres alatoires t = listAleaInt(100, 2, 125) # construction de la liste # calcul de lindex du minimum de la liste iMin = t.index(min(t)) print(Avant change :) print(\tt[0] =, t[0], \tt[iMin] =, t[iMin]) t[0], t[iMin] = t[iMin], t[0] # change print(Apres change :) print(\tt[0] =, t[0], \tt[iMin] =, t[iMin]) # -*- coding: utf-8 -*-
122
Amplitude et moyenne dune liste de flottants. # imports from random import seed, random # fonctions def listAleaFloat(n): Retourne une liste de <n> flottants alatoires return [random() for i in range(n)] # programme principal ----------------------------------------------n = int(input(Entrez un entier [2 .. 100] : )) while not(n >= 2 and n <= 100): n = int(input(Entrez un entier [2 .. 100], s.v.p. : )) seed() # initialise le gnrateur de nombres alatoires t = listAleaFloat(n) # construction de la liste print(Amplitude : {:.2f}.format(max(t) - min(t))) print(Moyenne : {:.2f}.format(sum(t)/n)) # -*- coding: utf-8 -*Min, max et moyenne dune liste dentiers. # fonction def minMaxMoy(liste): Renvoie le min, le max et la moyenne de la liste. min, max, som = liste[0], liste[0], float(liste[0]) for i in liste[1:]: if i < min: min = i if i > max: max = i som += i return (min, max, som/len(liste)) # programme principal ----------------------------------------------lp = [10, 18, 14, 20, 12, 16] print(liste =, lp) l = minMaxMoy(lp) print(min : {0[0]}, max : {0[1]}, moy : {0[2]}.format(l)) # -*- coding: utf-8 -*Nombres romains (version 1). # programme principal ----------------------------------------------n = int(input(Entrez un entier [1 .. 4000[ : )) while not(n >= 1 and n < 4000): n = int(input(Entrez un entier [1 .. 4000[, s.v.p. : )) s = # Chane rsultante while n >= 1000: s += M n -= 1000 if n >= 900: s += CM
123
n -= 900 if n >= 500: s += D n -= 500 if n >= 400: s += CD n -= 400 while n >= 100: s += C n -= 100 if n >= 90: s += XC n -= 90 if n >= 50: s += L n -= 50 if n >= 40: s += XL n -= 40 while n >= 10: s += X n -= 10 if n >= 9: s += IX n -= 9 if n >= 5: s += V n -= 5 if n >= 4: s += IV n -= 4 while n >= 1: s += I n -= 1 print(En romain :, s) # -*- coding: utf-8 -*Nombres romains (version 2). # globales code = zip( [1000,900 ,500,400 ,100,90 ,50 ,40 ,10 ,9 ,5 ,4 ,1], [M ,CM,D,CD,C,XC,L,XL,X,IX,V,IV,I] ) # fonction
124
def decToRoman(num): res = [] for d, r in code: while num >= d: res.append(r) num -= d return .join(res)
# programme principal ----------------------------------------------for i in range(1, 4000): print(i, decToRoman(i)) # -*- coding: utf-8 -*Liste dentiers diffrents. # imports from random import seed, randint # fonction def listAleaInt(n, a, b): Retourne une liste de <n> entiers alatoires entre <a> et <b>. return [randint(a, b) for i in range(n)] # programme principal ----------------------------------------------n = int(input(Entrez un entier [1 .. 100] : )) while not(n >= 1 and n <= 100): n = int(input(Entrez un entier [1 .. 100], s.v.p. : )) # construction de la liste seed() # initialise le gnrateur de nombres alatoires t = listAleaInt(n, 0, 500) # Sont-ils diffrents ? tousDiff = True i = 0 while tousDiff and i < (n-1): j = i + 1 while tousDiff and j < n: if t[i] == t[j]: tousDiff = False else: j += 1 i += 1 print(\n, t, end= ) if tousDiff: print(: tous les lments sont distincts.) else: print(: au moins une valeur est rpte.) # -*- coding: utf-8 -*Jeu de ds (1). # programme principal ----------------------------------------------n = int(input(Entrez un entier [2 .. 12] : )) while not(n >= 2 and n <= 12): n = int(input(Entrez un entier [2 .. 12], s.v.p. : )) s = 0
125
for i in range(1, 7): for j in range(1, 7): if i+j == n: s += 1 print(Il y a {:d} faon(s) de faire {:d} avec deux ds..format(s, n)) # -*- coding: utf-8 -*Jeu de ds (2). # programme principal ----------------------------------------------n = int(input(Entrez un entier [3 .. 18] : )) while not(n >= 3 and n <= 18): n = int(input(Entrez un entier [3 .. 18], s.v.p. : )) s = 0 for i in range(1, 7): for j in range(1, 7): for k in range(1, 7): if i+j+k == n: s += 1 print(Il y a {:d} faon(s) de faire {:d} avec trois ds..format(s, n) ) # -*- coding: utf-8 -*Jeu de ds (3). # globale MAX = 8 # programme principal ----------------------------------------------nbd = int(input(Nombre de ds [2 .. {:d}] : .format(MAX))) while not(nbd >= 2and nbd <= MAX): nbd = int(input(Nombre de ds [2 .. {:d}], s.v.p. : .format(MAX))) s = int(input(Entrez un entier [{:d} .. {:d}] : .format(nbd, 6*nbd))) while not(s >= nbd and s <= 6*nbd): s = int(input(Entrez un entier [{:d} .. {:d}], s.v.p. : .format( nbd, 6*nbd))) if s == nbd or s == 6*nbd: cpt = 1 # 1 seule solution else: I = [1]*nbd # initialise une liste de <nbd> ds cpt, j = 0, 0 while j < nbd: som = sum([I[k] for k in range(nbd)]) if som == s: cpt += 1 # compteur de bonnes solutions if som == 6*nbd: break j = 0 if I[j] < 6: I[j] += 1 else: while I[j] == 6:
126
I[j] = 1 j += 1 I[j] += 1
print(Il y a {:d} faons de faire {:d} avec {:d} ds..format(cpt, s, nbd)) # -*- coding: utf-8 -*Jeu de ds (rcursif). # globale MAX = 8 # fonction def calcul(d, n): Calcul rcursif du nombre de faons de faire <n> avec <d> ds. resultat, debut = 0, 1 if (d == 1) or (n == d) or (n == 6*d): # conditions terminales return 1 else: # sinon appels rcursifs if n > 6*(d-1): # optimisation importante debut = n - 6*(d-1) for i in range(debut, 7): if n == i: break resultat += calcul(d-1, n-i) return resultat # programme principal ----------------------------------------------d = int(input(Nombre de ds [2 .. {:d}] : .format(MAX))) while not(d >= 2and d <= MAX): d = int(input(Nombre de ds [2 .. {:d}], s.v.p. : .format(MAX))) n = int(input(Entrez un entier [{:d} .. {:d}] : .format(d, 6*d))) while not(n >= d and n <= 6*d): n = int(input(Entrez un entier [{:d} .. {:d}], s.v.p. : .format(d, 6*d))) print(Il y a {:d} faon(s) de faire {:d} avec {:d} ds..format(calcul (d, n), n, d)) # -*- coding: utf-8 -*module dexemple de polymorphisme. # classes class Rectangle: classe des rectangles. def __init__(self, longueur=30, largeur=15): Constructeur avec valeurs par dfaut. self.lon = longueur self.lar = largeur self.nom = rectangle def surface(self): Calcule la surface dun rectangle. return self.lon*self.lar def __str__(self):
127
Affichage des caractristiques dun rectangle. return \nLe {:s} de cts {:s} et {:s} a une surface de {:s} .format(self.nom, self.lon, self.lar, self.surface()) class Carre(Rectangle): classe des carrs (hrite de Rectangle). def __init__(self, cote=10): Constructeur avec valeur par dfaut Rectangle.__init__(self, cote, cote) self.nom = carr # surchage dattribut dinstance # Auto-test --------------------------------------------------------if __name__ == __main__: r = Rectangle(12, 8) print r c = Carre() print c
128
Annexe G
Ressources
Webographie
Les sites gnraux : www.python.org pypi.python.org/pypi www.pythonxy.com/download.php rgruet.free.fr Les EDI spcialiss : www.wingware.com/downloads/wingide-101 eric-ide.python-projects.org/eric4-download.html www.eclipse.org/downloads/ www.scintilla.org/SciTEDownload.html Les outils : sourceforge.net/projects/gnuplot/les/ Labrg Python 3.1 en un recto/verso : perso.limsi.fr/pointal/python :abrege Le lien des liens : perso.limsi.fr/pointal/liens :langage_python
130
ANNEXE G. RESSOURCES
Bibliographie
[B1] Swinnen, Grard, Apprendre programmer avec Python 3, Eyrolles, 2010. [B2] Summereld, Mark, Programming in Python 3, Addison-Wesley, 2e dition, 2009. [B3] Martelli, Alex, Python en concentr, OReilly, 2004. [B4] Lutz, Mark et Bailly, Yves, Python prcis et concis, OReilly, 2e dition, 2005. [B5] Ziad, Tarek, Programmation Python. Conception et optimisation, Eyrolles, 2e dition, 2009. [B6] Ziad, Tarek, Python : Petit guide lusage du dveloppeur agile, Dunod, 2007. [B7] Ziad, Tarek, Expert Python Programming, Packt Publishing, 2008. [B8] Younker, Je, Foundations of Agile Python Development, Apress, 2008.
A [B9] Chevalier Cline et collectif, LT X pour limpatient, H & K, 3e dition, 2009. E A [B10] Carella, David, Rgles typographiques et normes. Mise en pratique avec LT X, Vuibert, E 2006.
131
132
BIBLIOGRAPHIE
Annexe H
Glossaire
Lexique bilingue
>>> Invite Python par dfaut dans un shell interactif. Souvent utilise dans les exemples de code extraits de sessions de linterprteur Python. ... Invite Python par dfaut dans un shell interactif, utilise lorsquil faut entrer le code dun bloc indent ou lintrieur dune paire de parenthses, crochets ou accolades. 2to3 Un outil qui essaye de convertir le code Python 2.x en code Python 3.x en grant la plupart des incompatibilits quil peut dtecter. 2to3 est disponible dans la bibliothque standard lib2to2 ; un point dentre autonome est Tool/scipts/2to3. Voir 2to3 Automated Python 2 to 3 code translation. abstract base class ABC (classe de base abstraite) Complte le duck-typing en fournissant un moyen de dnir des interfaces alors que dautres techniques (comme hasattt()) sont plus lourdes. Python fournit de base plusieurs ABC pour les structures de donnes (module collections), les nombres (module numbers) et les ux (module io). Vous pouvez crer votre propre ABC en utilisant le module abc. argument (argument) Valeur passe une fonction ou une mthode, aecte une variable nomme locale au corps de la fonction. Une fonction ou une mthode peut avoir la fois des arguments par position et avec des valeurs par dfaut. Ces arguments peuvent tre de multiplicit variable : * accepte ou fournit plusieurs arguments par position dans une liste, tandis que ** joue le mme rle en utilisant les valeurs par dfaut dans un dictionnaire. On peut passer toute expression dans la liste darguments, et la valeur value est transmise la variable locale. attribute (attribut) Valeur associe un objet rfrenc par un nom et une expression pointe. Par exemple, lattribut a dun objet o peut tre rfrenc o.a. BDFL Benevolent Dictator For Life, cest--dire Guido van Rossum, le crateur de Python. bytecode (bytecode ou langage intermdiaire) Le code source Python est compil en bytecode, reprsentation interne dun programme Python dans linterprteur. Le bytecode est galement rang dans des chiers .pyc et .pyo, ainsi lexcution dun mme chier est plus rapide les fois ultrieures (la compilation du source en bytecode peut tre vite). On dit que le bytecode tourne sur une machine virtuelle qui, essentiellement, se rduit une collection dappels des routines correspondant chaque code du bytecode. class (classe) Modle permettant de crer ses propres objets. Les dnitions de classes contiennent normalement des dnitions de mthodes qui oprent sur les instances de classes.
134
ANNEXE H. GLOSSAIRE
coercion (coercition ou transtypage) Conversion implicite dune instance dun type dans un autre type dans une opration concernant deux arguments de types compatibles. Par exemple, int(3.15) convertit le nombre ottant 3.15 en lentier 3, mais dans 3+4.5, chaque argument est dun type dirent (lun int et lautre float) et tous deux doivent tre convertis dans le mme type avant dtre additionns, sinon une exception TypeError sera lance. Sans coercition, tous les arguments, mme de types compatibles, doivent tre normaliss la mme valeur par le programmeur, par exemple, float(3)+4.5 au lieu de simplement 3+4.5. complex number (nombre complexe) Une extension du systme familier des nombres rels dans laquelle tous les nombres sont exprims comme la somme dune partie relle et une partie imaginaire. Les nombres imaginaires sont des multiples rels de lunit imaginaire (la racine carre de -1), souvent crite i par les mathmaticiens et j par les ingnieurs. Python a un traitement incorpor des nombres complexes, qui sont crits avec cette deuxime notation ; la partie imaginaire est crite avec un suxe j, par exemple 3+1j. Pour avoir accs aux quivalents complexes des lments du module math utilisez le module cmath. Lutilisation des nombres complexes est une possibilit mathmatique assez avance. Si vous ntes pas certain den avoir besoin vous pouvez les ignorer sans risque. context manager (gestionnaire de contexte) Objet qui contrle lenvironnement indiqu par linstruction with et qui dnit les mthodes __enter__() et __exit__(). Voir la PEP 343. CPython (Python classique) Implmentation canonique du langage de programmation Python. Le terme CPython est utilis dans les cas o il est ncessaire de distinguer cette implmentation dautres comme Jython ou IronPython. decorator (dcorateur) Fonction retournant une autre fonction habituellement applique comme une transformation utilisant la syntaxe @wrapper. classmethod() et staticmethod() sont des exemples classiques de dcorateurs. Les deux dnitions de fonctions suivantes sont smantiquement quivalentes :
def f(...): ... f = staticmethod(f) @staticmethod def f(...): ...
Un concept identique existe pour les classes mais est moins utilis. Voir la documentation function denition et class denition pour plus de dtails sur les dcorateurs. descriptor (descripteur) Tout objet qui dnit les mthodes __get__(), __set__() ou __delete__(). Lorsquun attribut dune classe est un descripteur, un comportement spcique est dclench lors de la consultation de lattribut. Normalement, crire a.b consulte lobjet b dans le dictionnaire de la classe de a, mais si b est un descripteur, la mthode __get__() est appele. Comprendre les descripteurs est fondamental pour la comprhension profonde de Python, car ils sont la base de nombreuses caractristiques, comme les fonctions, les mthodes, les proprits, les mthodes de classe, les mthodes statiques et les rfrences aux super-classes. Pour plus dinformations sur les mthodes des descripteurs, voir Implementing Descriptors.
135 dictionary (dictionnaire) Une table associative, dans laquelle des cls arbitraires sont associes des valeurs. Lutilisation des objets dict ressemble beaucoup celle des objets list, mais les cls peuvent tre nimporte quels objets ayant une fonction __hash__(), non seulement des entiers. Ces tables sont appeles hash en Perl. docstring (chane de documentation) Chane littrale apparaissant comme premire expression dune classe, dune fonction ou dun module. Bien quignore lexcution, elle est reconnue par le compilateur et incluse dans lattribut __doc__ de la classe, de la fonction ou du module qui la contient. Depuis quelle est disponible via linstrospection, cest lendroit canonique pour documenter un objet. duck-typing (typage comme un canard ) Style de programmation pythonique dans lequel on dtermine le type dun objet par inspection de ses mthodes et attributs plutt que par des relations explicites des types ( sil ressemble un canard et fait coin-coin comme un canard alors ce doit tre un canard ). En mettant laccent sur des interfaces plutt que sur des types spciques on amliore la exibilit du code en permettant la substitution polymorphe. Le duck-typing vite les tests qui utilisent type() ou isinstance() (notez cependant que le duck-typing doit tre complt par lemploi des classes de base abstraites). la place, il emploie des tests comme hasattr() et le style de programmation EAFP. EAFP (Easier to ask for forgiveness than permission, ou plus facile de demander pardon que la permission ). Ce style courant de programmation en Python consiste supposer lexistence des cls et des attributs ncessaires lexcution dun code et attraper les exceptions qui se produisent lorsque de telles hypothses se rvlent fausses. Cest un style propre et rapide, caractris par la prsence de nombreuses instructions try et except. Cette technique contraste avec le style LBYL, courant dans dautres langages comme le C. expression (expression) Fragment de syntaxe qui peut tre valu. Autrement dit, une expression est une accumulation dlments dexpression comme des littraux, des noms, des accs aux attributs, des oprateurs ou des appels des fonctions retournant une valeur. linverse de beaucoup dautres langages, toutes les constructions de Python ne sont pas des expressions. Les instructions ne peuvent pas tre utilises comme des expressions (par exemple if). Les aectations sont aussi des instructions, pas des expressions. extension module (module dextention) Module crit en C ou en C++, utilisant lAPI C de Python, qui interagit avec le cur du langage et avec le code de lutilisateur. nder Objet qui essaye de trouver le loader (chargeur) dun module. Il doit implmenter une mthode nomme find_module(). Voir la PEP 302 pour des dtails et importlib.abc.Finder pour une classe de base abstraite. oor division (division entire) Division mathmatique qui laisse tomber le reste. Loprateur de division entire est //. Par exemple, lexpression 11//4 est value 2, par opposition la division ottante qui retourne 2.75. function (fonction) Suite dinstructions qui retourne une valeur lappelant. On peut lui passer zro ou plusieurs arguments qui peuvent tre utiliss dans le corps de la fonction. Voir aussi argument et method. __future__ Un pseudo-module que les programmeurs peuvent utiliser pour permettre les nouvelles fonctionnalits du langage qui ne sont pas compatibles avec linterprteur couramment employ.
136
ANNEXE H. GLOSSAIRE En important __future__ et en valuant ses variables, vous pouvez voir quel moment une caractristique nouvelle a t ajoute au langage et quand est-elle devenue la fonctionnalit par dfaut :
>>> import __future__ >>> __future__.division _Feature((2, 2, 0, alpha, 2), (3, 0, 0, alpha, 0), 8192)
garbage collection (gestion automatique de la mmoire) Processus de libration de la mmoire quand elle nest plus utilise. Python excute cette gestion en comptant les rfrences et en dtectant et en cassant les rfrences cycliques. generator (fonction gnrateur) Une fonction qui renvoie un itrateur. Elle ressemble une fonction normale, except que la valeur de la fonction est rendue lappelant en utilisant une instruction yield au lieu dune instruction return. Les fonctions gnrateurs contiennent souvent une ou plusieurs boucles for ou while qui cdent des lments lappelant. Lexcution de la fonction est stoppe au niveau du mot-cl yield, en renvoyant un rsultat, et elle est reprise lorsque llment suivant est requis par un appel de la mthode next() de litrateur. generator expression (expression gnrateur) Une expression qui renvoie un gnrateur. Elle ressemble une expression normale suivie dune expression for dnissant une variable de contrle, un intervalle et une expression if facultative. Toute cette expression combine produit des valeurs pour une fonction englobante :
>>> sum(i*i for i in range(10)) # somme des carrs 0, 1, 4, ... 81 285
GIL Voir global interpreter lock. global interpreter lock (verrou global de linterprteur) Le verrou utilis par les threads Python pour assurer quun seul thread tourne dans la machine virtuelle CPython un instant donn. Il simplie Python en garantissant que deux processus ne peuvent pas accder en mme temps une mme mmoire. Bloquer linterprteur tout entier lui permet dtre multi-thread aux frais du paralllisme du systme environnant. Des eorts ont t faits par le pass pour crer un interprteur free-threaded (o les donnes partages sont verrouilles avec une granularit ne), mais les performances des programmes en souraient considrablement, y compris dans le cas des programmes mono-thread. hashable (hachable) Un objet est hachable sil a une valeur de hachage constante au cours de sa vie (il a besoin dune mthode __hash__()) et sil peut tre compar dautres objets (il a besoin dune mthode __eq__()). Les objets hachables compars gaux doivent avoir la mme valeur de hachage. Lhachabilit rend un objet propre tre utilis en tant que cl dun dictionnaire ou membre dun ensemble (set), car ces structures de donnes utilisent la valeur de hachahge de faon interne. Tous les objets de base Python non modiables (immutable) sont hachables, alors que certains conteneurs comme les listes ou les dictionnaires sont modiables. Les objets instances des classes dnies par lutilisateur sont hachables par dfaut ; ils sont tous ingaux (dirents) et leur valeur de hachage est leur id(). IDLE Un environnement de dveloppement intgr pour Python. IDLE est un diteur basique et un environnement dinterprtation ; il est donn avec la distribution standard
137 de Python. Excellent pour les dbutants, il peut aussi servir dexemple pas trop sophistiqu pour tous ceux qui doivent implmenter une application avec interface utilisateur graphique multi-plate-forme. immutable (immuable) Un objet avec une valeur xe. Par exemple, les nombres, les chanes, les tuples. De tels objets ne peuvent pas tre altrs ; pour changer de valeur un nouvel objet doit tre cr. Les objets immuables jouent un rle important aux endroits o une valeurs de hash constantes est requise, par exemple pour les cls des dictionnaires. importer Objet qui la fois trouve et charge un module. Cest la fois un objet nder et un objet loader. interactive (interactif) Python possde un interprteur interactif, ce qui signie que vous pouvez essayer vos ides et voir immdiatement les rsultats. Il sut de lancer python sans argument (ventuellement en le slectionnant dans un certain menu principal de votre ordinateur). Cest vraiment un moyen puissant pour tester les ides nouvelles ou pour inspecter les modules et les paquetages (pensez help(x)). interpreted (interprt) Python est un langage interprt, par opposition aux langages compils, bien que cette distinction puisse tre oue cause de la prsence du compilateur de bytecode. Cela signie que les chiers source peuvent tre directement excuts sans avoir besoin de crer pralablement un chier binaire excut ensuite. Typiquement, les langages interprts ont un cycle de dveloppement et de mise au point plus court que les langages compils mais leurs programmes sexcutent plus lentement. Voir aussi interactive. iterable Un objet conteneur capable de renvoyer ses membres un par un. Des exemples diterable sont les types squences (comme les list, les str, et les tuple) et quelques types qui ne sont pas des squences, comme les objets dict, les objets file et les objets de nimporte quelle classe que vous dnissez avec une mthode __iter__() ou une mthode __getitem__(). Les iterables peuvent tre utiliss dans les boucles for et dans beaucoup dautres endroits o une squence est requise (zip(), map(), ...). Lorsquun objet iterable est pass comme argument la fonction incorpore iter() il renvoie un itrateur. Cet itrateur est un bon moyen pour eectuer un parcours dun ensemble de valeurs. Lorsquon utilise des iterables, il nest gnralement pas ncesaire dappeler la fonction iter() ni de manipuler directement les valeurs en question. Linstruction for fait cela automatiquement pour vous, en crant une variable temporaire sans nom pour grer litrateur pendant la dure de litration. Voir aussi iterator, sequence, et generator. iterator (itrateur) Un objet reprsentant un ot de donnes. Des appels rpts la mthode __next__() de litrateur (ou la fonction de base next()) renvoient des lments successifs du ot. Lorsquil ny a plus de donnes disponibles dans le ot, une exception StopIteration est lance. ce moment-l, lobjet itrateur est puis et tout appel ultrieur de la mthode next() ne fait que lancer encore une exception StopIteration. Les itrateurs doivent avoir une mthode __iter__() qui renvoie lobjet itrateur lui-mme. Ainsi un itrateur est itratif et peut tre utilis dans beaucoup dendroits o les iterables sont accepts ; une exception notable est un code qui tenterait des itrations multiples. Un objet conteneur (comme un objet list) produit un nouvel itrateur chaque fois quil est pass la fonction iter() ou bien utilis dans une boucle for. Si on fait cela avec un itrateur on ne rcuprera que le mme itrateur puis utilis dans le parcours prcdent, ce qui fera apparatre le conteneur comme sil tait vide.
138
ANNEXE H. GLOSSAIRE
keyword argument (argument avec valeur par dfaut) Argument prcd par variable_name= dans lappel. Le nom de la variable dsigne le nom local dans la fonction auquel la valeur est aecte. ** est utilis pour accepter ou passer un dictionnaire darguments avec ses valeurs. Voir argument. lambda Fonction anonyme en ligne ne comprenant quune unique expression value lappel. Syntaxe de cration dune fonction lambda :
lambda[arguments]: expression
LBYL (Look before you leap ou regarder avant dy aller ). Ce style de code teste explicitement les pr-conditions avant deectuer un appel ou une recherche. Ce style soppose lapproche EAFP et est caractris par la prsence de nombreuses instructions if. list (liste) Squence Python de base. En dpit de son nom, elle ressemble plus au tableau dautres langages qu une liste chane puisque laccs ses lments est en O(1). list comprehension (liste en intention) Une manire compacte deectuer un traitement sur un sous-ensemble dlments dune squence en renvoyant une liste avec les rsultats. Par exemple :
result = [0x%02x % x for x in range(256) if x % 2 == 0]
engendre une liste de chanes contenant les critures hexadcimales des nombres impairs de lintervalle de 0 255. La clause if est facultative. Si elle est omise, tous les lments de lintervalle range(256) seront traits. loader (chargeur) Objet qui charge un module. Il doit possder une mthode load_module(). un loader est typiquement fournit par un nder. Voir la PEP 302 pour les dtails et voir importlib.abc.Loader pour une classe de base abstraite. mapping (liste associative) Un objet conteneur (comme dict) qui supporte les recherches par des cls arbitraires en utilisant la mthode spciale __getitem__(). metaclass La classe dune classe. La dnition dune classe cre un nom de classe, un dictionnaire et une liste de classes de base. La mtaclasse est responsable de la cration de la classe partir de ces trois lments. Beaucoup de langages de programmation orients objets fournissent une implmentation par dfaut. Une originalit de Python est quil est possible de crer des mtaclasses personnalises. Beaucoup dutilisateurs nauront jamais besoin de cela mais, lorsque le besoin apparat, les mtaclasses fournissent des solutions puissantes et lgantes. Elles sont utilises pour enregistrer les accs aux attributs, pour ajouter des treads scuriss, pour dtecter la cration dobjet, pour implmenter des singletons et pour bien dautres tches. Plus dinformations peuvent tre trouves dans Customizing class creation. method (mthode) Fonction dnie dans le corps dune classe. Appele comme un attribut dune instance de classe, la mthode prend linstance dobjet en tant que premier argument (habituellement nomm self). Voir function et nested scope. mutable (modiable) Les objets modiables peuvent changer leur valeur tout en conservant leur id(). Voir aussi immutable. named tuple (tuple nomm) Toute classe de pseudo-tuples dont les lments indexables sont galement accessibles par des attributs nomms (par exemple time.localtime() retourne un objet pseudo-tuple o lanne est accessible soit par un index comme t[0] soit par un attribut nomm comme t.tm_year. Un tuple nomm peut tre un type de base comme time.struct_time ou il peut
139 tre cr par une dnition de classe ordinaire. Un tuple nomm peut aussi tre cr par la fonction fabrique collections.nametuple(). Cette dernire approche fournit automatiquement des caractristiques supplmentaires comme une reprsentation auto-documente, par exemple :
>>> Employee(name=jones, title=programmer)
namespace (espace de noms) Lendroit o une variable est conserve. Les espaces de noms sont implments comme des dictionnaires. Il y a des espace de noms locaux, globaux et intgrs et galement imbriqus dans les objets. Les espaces de noms contribuent la modularit en prvenant les conits de noms. Par exemple, les fonctions __builtin__.open() et os.open() se distinguent par leurs espaces de noms. Les espaces de noms contribuent aussi la lisibilit et la maintenablit en clariant quel module implmente une fonction. Par exemple, en crivant random.seed() ou itertools.izip() on rend vident que ces fonctions sont implmentes dans les modules random et itertools respectivement. nested scope (porte imbrique) La possibilit de faire rfrence une variable dune dnition englobante. Par exemple, une fonction dnie lintrieur dune autre fonction peut faire rfrence une variable de la fonction extrieure. Notez que le portes imbriques fonctionnent uniquement pour la rfrence aux variables et non pour leur aectation, qui concerne toujours la porte imbrique. Les variables locales sont lues et crites dans la porte la plus intrieure ; les variables globales sont lues et crites dans lespace de noms global. Linstruction nonlocal permet dcrire dans la porte globale. new-style class (style de classe nouveau) Vieille dnomination pour le style de programmation de classe actuellement utilis. Dans les versions prcdentes de Python, seul le style de classe nouveau pouvait bncier des nouvelles caractristiques de Python, comme __slots__, les descripteurs, les proprits, __getattribute__(), les mthodes de classe et les mthodes statiques. object (objet) Toute donne comprenant un tat (attribut ou valeur) et un comportement dni (mthodes). galement la classe de base ultime du new-style class. positional argument (argument de position) Arguments aects aux noms locaux internes une fonction ou une mthode, determins par lordre donn dans lappel. La syntaxe * accepte plusieurs arguments de position ou fournit une liste de plusieurs arguments une fonction. Voir argument. property (proprit) Attribut dinstance permettant dimplmenter les principes de lencapsulation. Python3000 Surnom de la version 3 de Python (forg il y a longtemps, quand la version 3 tait un projet lointain). Aussi abrg Py3k . Pythonic (pythonique) Ide ou fragment de code plus proche des idiomes du langage Python que des concepts frquemment utliss dans dautres langages. par exemple, un idiome frquent en Python est de boucler sur les lments dun iterable en utilisant linstruction for. Beaucoup dautres langages nont pas ce type de construction et donc les utilisateurs non familiers avec Python utilisent parfois un compteur numrique :
for i in range(len(food)): print(food[i])
140 Au lieu dutiliser la mthode claire et pythonique :

for piece in food: print(piece)
ANNEXE H. GLOSSAIRE
reference count (nombre de rfrences) Nombre de rfrences dun objet. Quand le nombre de rfrences dun objet tombe zro, lobjet est dsallou. Le comptage de rfrences nest gnralement pas visible dans le code Python, mais cest un lment cl de limplmentation de CPython. Le module sys dnit la fonction getrefcount() que les programmeurs peuvent appeler pour rcuprer le nombre de rfrences dun objet donn. __slots__ Une dclaration lintrieur dune classe de style nouveau qui conomise la mmoire en pr-dclarant lespace pour les attributs et en liminant en consquence les dictionnaires dinstance. Bien que populaire, cette technique est quelque peu dicile mettre en place et doit tre rserve aux rares cas o il y a un nombre important dinstances dans une application o la mmoire est rduite. sequence (squence) Un iterable qui ore un accs ecace aux lments en utilisant des index entiers et les mthodes spciales __getitem__() et __len__(). Des types squences incorpors sont list, str, tuple et unicode. Notez que le type dict comporte aussi les mthodes __getitem__() et __len__(), mais est considr comme une table associative plutt que comme une squence car la recherche se fait laide de cls arbitraires immuables au lieu dindex. slice (tranche) Objet contenant normalement une partie dune squence. Une tranche est cre par une notation indexe utilisant des : entre les index quand plusieurs sont donns, comme dans variable_name[1:3:5]. La notation crochet utilise les objets slice de faon interne. special method (mthode spciale) mthode appele implicitement par Python pour excuter une certaine opration sur un type, par exemple une addition. Ces mthodes ont des noms commenant et nissant par deux caractres souligns. Les mthodes spciales sont documentes dans Special method names. statement (instruction) Une instruction est une partie dune suite, dun bloc de code. Une instruction est soit une expression soit une ou plusieurs constructions utilisant un mot cl comme if, while ou for. triple-quoted string (chane multi-ligne) Une chane dlimite par trois guillemets () ou trois apostrophes (). Bien quelles ne fournissent pas de fonctionnalits direntes de celles des chanes simplement dlimites, elles sont utiles pour nombre de raisons. Elles permettent dinclure des guillemets ou des apostrophes non protgs et elles peuvent stendre sur plusieurs lignes sans utiliser de caractre de continuation, et sont donc spcialement utiles pour rdiger des chanes de documentation. type (type) Le type dun objet Python dtermine de quelle sorte dobjet il sagit ; chaque objet possde un type. Le type dun objet est accessible grce son attribut __class__ ou peut tre retourn par la fonction type(obj). view (vue) Les objets retourns par dict.keys(), dict.values() et dict.items() sont appels des dictionary views. ce sont des squences paresseuses 1 qui laisseront voir les modications du dictionnaire sous-jacent. Pour forcer le dictionary view tre une liste complte, utiliser list(dictview). Voir Dictionary wiew objects.
1. Lvaluation paresseuse est une technique de programmation o le programme nexcute pas de code avant que les rsultats de ce code ne soient rellement ncessaires. Le terme paresseux (en anglais lazzy evaluation) tant connot ngativement en franais on parle aussi dvaluation retarde.
141 virtual machine (machine virtuelle) Ordinateur entirement dni par un programme. la machine virtuelle Python excute le bytecode gnr par le compilateur. Zen of Python Une liste de principes mthodologiques et philosophiques utiles pour la comprhension et lutilisation du langage Python. Cette liste peut tre obtenue en tapant import this dans linterprteur Python.
142
ANNEXE H. GLOSSAIRE
Colophon
Ce texte a t crit grce au logiciel de composition A XLTEX de la distribution TEXLive. Nous avons utilis les composants libres suivants du monde Linux : A lditeur Kile, environnement intgr LTEX ; les polices Free Font de GNU ; lditeur de graphisme vectoriel Inkscape.

Cours Python 3

Transféré par

Droits d'auteur :

Formats disponibles

Cours Python 3

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Python 3

Transféré par

Droits d'auteur :

Formats disponibles

Bob CORDEAU

Informatique : Rencontre de la logique formelle et du fer souder.

Table des matires

TABLE DES MATIRES H Glossaire Colophon

vii 133 143

TABLE DES MATIRES

Table des gures

B.1 Table ASCII. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 B.2 Extrait de la table Unicode. . . . . . . . . . . . . . . . . . . . . . . . . . 106 ix

Principales caractristiques du langage Python

1.2 Environnements matriel et logiciel

1.2.2 Deux sortes de programmes

1.3. LES LANGAGES

1.3.1 Des langages de dirents niveaux

1.3.2 Bref historique des langages

Production des programmes

1.4.1 Deux techniques de production des programmes

Figure 1.2 Technique de linterprtation

1.4.2 Technique de production de Python

1.4.3 La construction des programmes

1.5 Algorithme et programme

1.6. LES IMPLMENTATIONS DE PYTHON Un algorithme se termine en un temps ni.

1.5.2 La prsentation des programmes

Les implmentations de Python

Les modes dexcution

2.1.1 Les deux modes dexcution dun code Python

Figure 2.1 La boucle dvaluation de IDLE

CHAPITRE 2. LA CALCULATRICE PYTHON

2.2 Identiants et mots cls

2.2.2 Style de nommage

1. Voir les dtails dans la PEP 8 : Style Guide for Python .

2.3. NOTION DEXPRESSION

2.2.3 Les mots rservs de Python 3

Exemples de deux expressions simples et dune expression complexe :

Les types de donnes entiers

Python 3 ore deux types entiers standard : int et bool.

2.4.1 Le type int

10 Oprations arithmtiques Les principales oprations :

CHAPITRE 2. LA CALCULATRICE PYTHON

2.4.2 Le type bool

Les types de donnes ottants

2.5.1 Le type float

2.5.2 Le type complex

Un module mathmatique spcique (cmath) leur est rserv :

CHAPITRE 2. LA CALCULATRICE PYTHON

2.6 Variables et aectation

a = 2 # prononcez : a reoit 2 b = 7.2 * math.log(math.e / 45.12) - 2*math.pi c = b ** a

2.6.3 Aecter nest pas comparer !

2.7. LES CHANES DE CARACTRES

(a) Trois aectations

(b) La donne c est supprime

(c) La donne a est supprime

Figure 2.2 Laectation illustre.

2.6.4 Les variantes de laectation

2.6.5 Les aectations (explications graphiques)

Les chanes de caractres

2.7.1 Les chanes de caractres : prsentation

CHAPITRE 2. LA CALCULATRICE PYTHON

2.7.2 Les chanes de caractres : oprations

2.7.3 Les chanes de caractres : fonctions vs mthodes