cours python 3

Bob CORDEAU & Laurent POINTAL

Une introduction Python 3version 1.6

Bob CORDEAU

Laurent POINTAL

UNE INTRODUCTION

PYTHON 3version 1.6

En se partageant le savoir ne se divise pas, il se multiplie.

Remerciements

Merci Tarek Z pour les emprunts ses publications, en particulier nous remer-cions les ditions Eyrolles pour leur aimable autorisation de publier le dialogue de lapage 88 et les ditions Dunod pour leur aimable autorisation de publier les exemples despages 80, 81 et 84.

Grand merci Hlne C pour ses illustrations ; les aventures de Steeven lePython enchantent les ttes de paragraphe.

Merci Ccile T pour son aide la traduction du Zen de Python.

Une pense spciale pour Stphane B : son enseignement didactique auprsdes tudiants et son engagement envers ses collgues ne seront pas oublis.

Enn il faudrait saluer tous les auteurs butins sur Internet

Table des matires

1 Introduction 11.1 Principales caractristiques du langage Python . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Matriel et logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

1.2.1 Lordinateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.2.2 Deux sortes de programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

1.3 Les langages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3.1 Des langages de dirents niveaux . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3.2 Bref historique des langages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.4 Production des programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.4.1 Deux techniques de production des programmes . . . . . . . . . . . . . . . . . . . 31.4.2 Technique de production de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.4.3 La construction des programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.5 Algorithme et programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.5.1 Dnitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.5.2 La prsentation des programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.6 Les implmentations de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 La calculatrice Python 5

2.1 Les modes dexcution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.1.1 Les deux modes dexcution dun code Python . . . . . . . . . . . . . . . . . . . . . 5

2.2 Identicateurs et mots cls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.2.1 Identicateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.2.2 Style de nommage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.2.3 Les mots rservs de Python 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.3 Notion dexpression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62.4 Les types de donnes entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.4.1 Le type int . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.4.2 Le type bool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.5 Les types de donnes oants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.5.1 Le type float . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.5.2 Le type complex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2.6 Variables et aectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.6.1 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.6.2 Laectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.6.3 Aecter nest pas comparer ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.6.4 Les variantes de laectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102.6.5 Les aectations (explications graphiques) . . . . . . . . . . . . . . . . . . . . . . . 10

2.7 Les chanes de caractres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.7.1 Les chanes de caractres : prsentation . . . . . . . . . . . . . . . . . . . . . . . . 112.7.2 Les chanes de caractres : oprations . . . . . . . . . . . . . . . . . . . . . . . . . . 112.7.3 Les chanes de caractres : fonctions vs mthodes . . . . . . . . . . . . . . . . . . . 122.7.4 Mthodes de test de ltat dune chane . . . . . . . . . . . . . . . . . . . . . . . . . 122.7.5 Mthodes retournant une nouvelle chane . . . . . . . . . . . . . . . . . . . . . . . 132.7.6 Les chanes de caractres : indexation simple . . . . . . . . . . . . . . . . . . . . . 132.7.7 Extraction de sous-chanes (ou tranches ) . . . . . . . . . . . . . . . . . . . . . . 14

2.8 Les donnes binaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142.9 Les entres-sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

v

vi TABLE DES MATIRES

2.9.1 Les entres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.9.2 Les sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.9.3 Les squences dchappement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3 Le contrle du ux dinstructions 173.1 Les instructions composes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.2 Choisir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

3.2.1 Choisir : if - [elif] - [else] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183.2.2 Syntaxe compacte dune alternative . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

3.3 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193.3.1 Rpter : while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193.3.2 Parcourir : for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

3.4 Ruptures de squences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203.4.1 Interrompre une boucle : break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203.4.2 Court-circuiter une boucle : continue . . . . . . . . . . . . . . . . . . . . . . . . . . 203.4.3 Utilisation avance des boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203.4.4 Traitement des erreurs les exceptions . . . . . . . . . . . . . . . . . . . . . . . . 21

4 Les conteneurs standard 234.1 Les squences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

4.1.1 est-ce quune squence ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234.2 Les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

4.2.1 Dnition, syntaxe et exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234.2.2 Initialisations et tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244.2.3 Mthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244.2.4 Manipulation des tranches (ou sous-chanes) . . . . . . . . . . . . . . . . . . . 244.2.5 Des squences de squences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

4.3 Les tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.4 Retour sur les rfrences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

4.4.1 Complment graphique sur lassignation . . . . . . . . . . . . . . . . . . . . . . . . 264.5 Les tableaux associatifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

4.5.1 Les types tableaux associatifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274.5.2 Les dictionnaires (dict) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

4.6 Les ensembles (set) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284.7 Les chiers textuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.7.1 Les chiers : introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294.7.2 Gestion des chiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.8 Itrer sur les conteneurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304.9 Lachage format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

5 Fonctions et espaces de noms 335.1 Dnition et syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335.2 Passage des arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

5.2.1 Mcanisme gnral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355.2.2 Un ou plusieurs paramtres, pas de retour . . . . . . . . . . . . . . . . . . . . . . . 355.2.3 Un ou plusieurs paramtres, utilisation du retour . . . . . . . . . . . . . . . . . . . 355.2.4 Passage dune fonction en paramtre . . . . . . . . . . . . . . . . . . . . . . . . . . 365.2.5 Paramtres avec valeur par dfaut . . . . . . . . . . . . . . . . . . . . . . . . . . . 365.2.6 Nombre darguments arbitraire passage dun tuple de valeurs . . . . . . . . . . . . 375.2.7 Nombre darguments arbitraire : passage dun dictionnaire . . . . . . . . . . . . . . 37

5.3 Espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375.3.1 Porte des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375.3.2 Rsolution des noms : rgle LGI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

TABLE DES MATIRES vii

6 Modules et paages 396.1 Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

6.1.1 Import . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396.1.2 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

6.2 Bibliothque standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416.2.1 La bibliothque standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

6.3 Bibliothques tierces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446.3.1 Une grande diversit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446.3.2 Un exemple : la bibliothque Unum . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

6.4 Paquets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457 La programmation Oriente Objet 47

7.1 Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477.1.1 Notations UML de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

7.2 Classes et instanciation dobjets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487.2.1 Linstruction class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487.2.2 Linstanciation et ses aributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487.2.3 Retour sur les espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

7.3 Mthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507.4 Mthodes spciales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

7.4.1 Linitialisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507.4.2 Surcharge des oprateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507.4.3 Exemple de surcharge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

7.5 Hritage et polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517.5.1 Hritage et polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517.5.2 Exemple dhritage et de polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . 52

7.6 Notion de conception oriente objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527.6.1 Association . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527.6.2 Drivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

7.7 Un exemple complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548 La programmation oriente objet graphique 57

8.1 Programmes pilots par des vnements . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578.2 La bibliothque tkinter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

8.2.1 Prsentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588.2.2 Les widgets de tkinter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588.2.3 Le positionnement des widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

8.3 Deux exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598.3.1 tkPhone, un exemple sans menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598.3.2 IDLE, un exemple avec menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

9 Teniques avances 659.1 Techniques procdurales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

9.1.1 Le pouvoir de lintrospection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659.1.2 Gestionnaire de contexte (ou bloc gard) : . . . . . . . . . . . . . . . . . . . . . . . 679.1.3 Utiliser un dictionnaire pour lancer des fonctions ou des mthodes . . . . . . . . . 679.1.4 Les fonctions rcursives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 689.1.5 Les listes dnies en comprhension . . . . . . . . . . . . . . . . . . . . . . . . . . 699.1.6 Les dictionnaires dnis en comprhension . . . . . . . . . . . . . . . . . . . . . . 709.1.7 Les ensembles dnis en comprhension . . . . . . . . . . . . . . . . . . . . . . . . 709.1.8 Les gnrateurs et les expressions gnratrices . . . . . . . . . . . . . . . . . . . . 709.1.9 Les fonctions incluses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719.1.10 Les dcorateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

9.2 Techniques objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 739.2.1 Functor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 739.2.2 Les accesseurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 739.2.3 Le duck typing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

9.3 Techniques fonctionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 779.3.1 Directive lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

viii TABLE DES MATIRES

9.3.2 Les fonctions map, filter et reduce . . . . . . . . . . . . . . . . . . . . . . . . . . . 789.3.3 Les applications partielles de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . 78

9.4 Les tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 799.4.1 Tests unitaires et tests fonctionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . 799.4.2 Module unittest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

9.5 La documentation des sources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 819.5.1 Le format reST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 819.5.2 Le module doctest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 829.5.3 Le dveloppement dirig par la documentation . . . . . . . . . . . . . . . . . . . . 84

A Interlude 87B Passer du problme au programme 91C Jeux de caractres et encodage 93D Les bases arithmtiques 95E Exercices corrigs 97F Glossaire 107

Webographie 115Bibliographie 116Memento Python 3 118Index 120

Avant-propos

qui sadresse ce cours ?Utilis lorigine par les tudiants de Mesures Physiques de lIUT dOrsay, ce cours sadresse plus

gnralement toute personne dsireuse dapprendre Python en tant que premier langage de program-mation.

Cette introduction reposent sur quelques partis pris : le choix du langage Python version 3. La version actuelle abolit la compatibilit descendante 1 dansle but dliminer les faiblesses originelles du langage ;

le choix de logiciels libres ou gratuits : des diteurs spcialiss comme ipython, spyder ou Wingware, des outils open source de production de documents : LATEX 2, Inkscape.

et sur labondance des ressources et de la documentation sur le Web !

Version 1.6 ?Suivant lexemple de Donald K, linventeur du logiciel de composition TEX, le numro de version

de ce document, au lieu dtre 1 , est la 1re dcimale dun nombre clbre 3.

Pour joindre les auteurs :k [email protected] [email protected]

Sauf mention contraire, le contenu de cet ouvrage est publi sous la licence :Creative Commons BY-NC-SA-3.0

La copie de cet ouvrage est autorise sous rserve du respect des conditions de la licencecreativecommons.org/licenses/by/3.0/fr/

1. Cest une grave dcision, mrement rchie : Un langage qui bouge peu permet une industrie qui bouge beaucoup (Ber-trand M). avec la srie des versions 2.x

2. dans la distribution TEXLive associ lditeur Kile pour GNU/Linux et la distributionMikTEX associ lditeur TEXnicCenterpour Windows.

3. ' = 1+p5

2, le nombre dor.

C 1

Introduction linformatique

Ce premier chapitre introduit les grandes caractristiques du langage Python, replace Py-thon dans lhistoire des langages informatiques, donne les particularits de production desprogrammes, dni la notion si importante dalgorithme et conclut sur les divers implmen-tations disponibles.

1.1 Principales caractristiques du langage Python Historique 1991 : Guido van R travaille aux Pays-Bas au CWI 1 sur le projet AMOEBA (un systme

dexploitation distribu). Il conoit Python ( partir du langage ABC) et publie la version 0.9.0 surun forum Usenet

1996 : sortie de Numerical Python 2001 : naissance de la PSF (Python Soware 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 2013 : versions en cours : v2.7.3 et v3.3.0

Langage Open Source Licence Open Source CNRI, compatible GPL, mais sans la restriction copyle. Python est libre et

gratuit mme pour les usages commerciaux GvR (Guido van R) est le BDFL (dictateur bnvole vie !) Importante communaut de dveloppeurs Nombreux outils standard disponibles : Baeries included

Travail interactif Nombreux interprteurs interactifs disponibles Importantes documentations en ligne Dveloppement rapide et incrmentiel Tests et dbogage outills Analyse interactive de donnes

Langage interprt rapide Interprtation du bytecode compil De nombreux modules sont disponibles partir de bibliothques optimises (souvent crites en

C ou C++) Simplicit du langage (cf. Zen of Python, annexe A, p. 87) : Syntaxe claire et cohrente Indentation signicative Gestion automatique de la mmoire (garbage collector) Typage dynamique fort : pas de dclaration

1. Centrum voor Wiskunde en Iinformatica.

2 Introduction

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

Remarque3 Point fort de Python : la lisibilit. Python est un langage algorithmique excutable .

1.2 Environnements matriel et logiciel1.2.1 Lordinateur

On peut simplier la dnition de lordinateur de la faon suivante :

Dnitionb Ordinateur : 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 8bits (octets) ;

des priphriques : entres/sorties, mmoires permanentes (dites mortes : disque dur, cl USB, CD-ROM. . .), rseau. . .

1.2.2 Deux sortes de programmesOn distingue, pour faire rapide : Le systme dexploitation : ensemble des programmes qui grent les ressources matrielles et logi-cielles. Il propose une aide au dialogue entre lutilisateur et lordinateur : linterface textuelle (inter-prteur de commande) ou graphique (gestionnaire de fentres). Il est souvent multitche et parfoismultiutilisateur ;

les programmes applicatifs sont ddis des tches particulires. Ils sont forms dune srie de com-mandes contenues dans un programme source qui est transform pour tre excut par lordinateur.

1.3 Les langages1.3.1 Des langages de dirents niveaux

Chaque processeur possde un langage propre, directement excutable : le langage machine. Il estform 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 quele langage machine, mais nest toujours pas portable. On le traduit en langage machine par unassembleur ;

les langages de haut niveau. Souvent normaliss, ils permeent le portage dune machine lautre.Ils sont traduits en langage machine par un compilateur ou un interprteur .

1.4 Production des programmes 3

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 programmes1.4.1 Deux teniques 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 compilationest contraignante mais ore au nal une grande vitesse dexcution.

F 1.1 Chane de compilation

Dans la technique de linterprtation chaque ligne du source analys est traduite au fur et mesure eninstructions directement excutes. Aucun programme objet nest gnr. Cee technique est trs souplemais les codes gnrs sont peu performants : linterprteur doit tre utilis chaque excution. . .

F 1.2 Technique de linterprtation

1.4.2 Tenique de production de Python Technique mixte : linterprtation du bytecode compil. Bon compromis entre la facilit de dve-loppement et la rapidit dexcution ;

le bytecode (forme intermdiaire) est portable sur tout ordinateur muni de la machine virtuelle Py-thon.

F 1.3 Interprtation du bytecode compil

Pour excuter un programme, Python charge le chier source .py (ou .pyw) en mmoire vive, en faitlanalyse (lexicale, syntaxique et smantique), produit le bytecode et enn lexcute.

An de ne pas refaire inutilement toute la phase danalyse et de production, Python sauvegarde lebytecode produit (dans un chier .pyo ou .pyc) et recharge simplement le chier bytecode sil est plusrcent que le chier source dont il est issu.

En pratique, il nest pas ncessaire de compiler explicitement un module, Python gre ce mcanismede faon transparente.

4 Introduction

1.4.3 La construction des programmesLe gnie logiciel tudie les mthodes de construction des programmes. Plusieurs modles sont envisa-

geables, entre autres : la mthodologie procdurale. On emploie lanalyse descendante (division des problmes) et remon-tante (rutilisation dun maximum de sous algorithmes). On seorce ainsi de dcomposer un pro-blme complexe en sous-programmes plus simples. Ce modle structure dabord les actions ;

la mthodologie objet. Centre sur les donnes, elle est considre plus stable dans le temps etmeilleure dans sa conception. On conoit des fabriques (classes) qui servent produire des compo-sants (objets) qui contiennent des donnes (aributs) 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 programme1.5.1 DnitionsDnitionb Algorithme : ensemble des tapes permeant daeindre un but en rptant un nombre ni de foisun nombre ni dinstructions.Un algorithme se termine en un temps ni.Dnitionb Programme : un programme est la traduction dun algorithme en un langage compilable ou interpr-table 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 programmesUn 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 commen-taire. En Python, 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, implmentation 1 portable sur dirents systmes Jython : cibl pour la JVM (utilise le bytecode de JAVA) IronPython : Python.NET, crit en C#, utilise le MSIL (MicroSo Intermediate Language) Staless Python : limine lutilisation de la pile du langage C (permet de rcurser tant que lonveut)

Pypy : projet de recherche europen dun interprteur Python crit en Python

1. Une implmentation signie une mise en uvre .

C 2

La calculatrice Python

Comme tout langage, Python permet de manipuler des donnes grce un vocabulaire demots rservs et grce des types de donnes approximation des ensembles de dnitionutiliss en mathmatique.

Ce chapitre prsente les rgles de construction des identicateurs, les types de donnes simples(les conteneurs seront examins au chapitre 4) ainsi que les types chane de caractres (Unicodeet binaires).

Enn, last but not least, ce chapitre stend sur les notions non triviales de variables, de rf-rences dobjet et daectation.

2.1 Les modes dexcution2.1.1 Les deux modes dexcution dun code Python

Soit on enregistre un ensemble dinstructions Python dans un chier grce un diteur (on parlealors dun script Python) que lon excute par une commande ou par une touche dumenu de lditeur ;

soit on utilise linterprteur Python embarqu qui excute la boucle dvaluation (+ Fig. 2.1).

F 2.1 La boucle dvaluation de linterprteur Python

2.2 Identicateurs et mots cls2.2.1 Identicateurs

Comme tout langage, Python utilise des identicateurs pour nommer ses objets.Dnitionb Un identicateur Python est une suite non vide de caractres, de longueur quelconque, forme duncaractre de dbut et de zro ou plusieurs caractres de continuation.

6 La calculatrice Python

Sachant que : un caractre de dbut peut tre nimporte quelle lere Unicode (cf. annexe C, p. 93), ainsi que lecaractre soulign (_) ;

un caractre de continuation est un caractre de dbut, un chire ou un point.Attentionj Les identicateurs sont sensibles la casse et ne doivent pas tre un mot rserv de Python 3.2.2.2 Style de nommage

Il est important dutiliser une politique cohrente de nommage des identicateurs. Voici le style utilisdans ce document 1 :

UPPERCASE ou UPPER_CASE pour les constantes ; TitleCase pour les classes ; UneExceptionError pour les exceptions ; camelCase pour les fonctions et les mthodes ; unmodule_m pour les modules ; lowercase ou lower_case pour tous les autres identicateurs.Exemples :NB_ITEMS = 12 # UPPER_CASEclass MaClasse: pass # TitleCasedef maFonction(): pass # camelCasemon_id = 5 # lower_case

Pour ne pas prter confusion, viter dutiliser les caractres l (minuscule), O et I (majuscules) seuls.Enn, on vitera dutiliser les notations suivantes :_xxx # usage interne__xxx # attribut de classe__xxx__ # nom spcial rserv

2.2.3 Les mots rservs de Python 3La version 3.3.0 de Python compte 33 mots cls :

and del from None Trueas elif global nonlocal tryassert else if not whilebreak except import or withclass False in pass yieldcontinue finally is raisedef for lambda return

2.3 Notion dexpressionDnitionb Une expression est une portion de code que linterprteur Python peut valuer pour obtenir unevaleur.Les expressions peuvent tre simples ou complexes. Elles sont formes dune combinaison de lirauxreprsentant directement des valeurs, didenticateurs 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

1. Voir les dtails dans la PEP 8 : Style Guide for Python , Guido van R et Barry W

2.4 Les types de donnes entiers 7

2.4 Les types de donnes entiersPython 3 ore deux types entiers standard : int et bool.

2.4.1 Le type intLe type int nest limit en taille que par la mmoire de la machine 1.Les entiers liraux sont dcimaux par dfaut, mais on peut aussi utiliser les bases suivantes (cf. an-

nexe D, p. 95) :

>>> 2013 # dcimal2013>>> 0b11111011101 # binaire2013>>> 0o3735 # octal2013>>> 0x7dd # hexadecimal2013

Oprations arithmtiquesLes principales oprations :>>> 20 + 323>>> 20 - 317>>> 20 * 360>>> 20 ** 38000>>> 20 / 36.666666666666667>>> 20 // 36 (division entire)>>> 20 % 3 # modulo2>>> abs(3 - 20) # valeur absolue17

Bien remarquer le rle des deux oprateurs de division :/ : produit une division oante, mme entre deux entiers ;// : produit une division entire.

Bases usuellesUn entier crit en base 10 (par exemple 179) peut se reprsenter en binaire, octal et hexadcimal en

utilisant les syntaxes suivantes :>>> 0b10110011 # binaire179>>> bin(179)'0b10110011'>>> 0o263 # octal179>>> oct(179)'0o263'>>> 0xB3 # hexadcimal179>>> hex(179)'0xb3'

1. Dans la plupart des autres langages les entiers sont cods sur un nombre xe de bits et ont un domaine de dnition limitauquel il convient de faire aention.


2.4.2 Le type boolPrincipales caractristiques du type bool 1 : Deux valeurs possibles : False, True. Oprateurs de comparaison entre deux valeurs comparables, produisant un rsultat de type bool :

==,!=, >, >=, < et >> 2 > 8False>>> 2 >> (3 == 3) or (9 > 24)True>>> (9 > 24) and (3 == 3)False

Les oprateurs boolens de baseEn Python les valeurs des variables boolennes sont notes False et True. Lesoprateurs sont nots respectivement not, and et or.

Oprateur unaire nota not(a)

False TrueTrue False

Oprateurs binaires or et and

a b a or b a and bFalse False False FalseFalse True True FalseTrue False True FalseTrue True True True

Attentionj Pour tre sr davoir un rsultat boolen avec une expression reposant sur des valeurs transtypes,appliquez bool() sur lexpression.

2.5 Les types de donnes ottantsRemarque3 La notion mathmatique de rel est une notion idale impossible mere en uvre en informatique.On utilise une reprsentation interne permeant de dplacer la virgule grce une valeur dexposantvariable. On nommera ces nombres des oants.

2.5.1 Le type float Un float est not avec un point dcimal (jamais avec une virgule) ou en notation exponentielle avecun e symbolisant le 10 puissance suivi des chires de lexposant :2.718.02-1.6e-196.023e23

1. Daprs George B, logicien et mathmaticien du 19esicle.

2.6 Variables et aectation 9

Les oants supportent les mmes oprations que les entiers. Ils ont une prcision nie limit. Limport du module math autorise toutes les oprations mathmatiques usuelles. Par exemple :

>>> import math>>> print(math.sin(math.pi/4))0.707106781187>>>> 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 oants. 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))) # module5.0

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.707106781187j)

2.6 Variables et aectation2.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 lobjetnest pas modiable (comme les entiers, les oants, les chanes etc.), il ny a pas de dirence notableentre les deux notions. On verra que la situation change dans le cas des objets modiables. . .

Dnitionb Une variable est un identicateur associ une valeur. En Python, cest une rfrence dobjet.

2.6.2 LaectationDnitionb On aecte une variable par une valeur en utilisant le signe = (qui na rien voir avec lgalit enmath !). Dans une aectation, le membre de gauche reoit le membre de droite ce qui ncessite dvaluerla valeur correspondant au membre de droite avant de laecter au membre de gauche.

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


Remarque3 loral, au lieu de dire a gal 2 , dites a reoit 2 .

La valeur dune variable, comme son nom lindique, peut voluer au cours du temps (la valeur ant-rieure est perdue) :

>>> a = 3 * 7>>> a21>>> b = 2 * 2>>> b4>>> a = b + 5>>> a9

Lemembre de droite dune aectation tant valu avant de raliser laectation elle-mme, la variableaecte peut se trouver en partie droite et cest sa valeur avant laectation qui est utilise dans le calcul :

>>> a = 2>>> a = a + 1 # incrmentation>>> a3>>> a = a - 1 # dcrmentation>>> a2

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) :>>> c = True>>> s = (c = True) and True

File "", line 1s = (c = True) and True

^SyntaxError: invalid syntax

La comparaison a une valeur (de type bool) utilisable dans une expression mais na pas deet :>>> c = "a">>> s = (c == "a") and True>>> sTrue

2.6.4 Les variantes de laectationOutre laectation simple, on peut aussi utiliser les formes suivantes :>>> v = 4 # affectation simple>>> # affectation augmente>>> v += 2 # idem : v = v + 2 si v est dj rfrenc>>> c = d = 8 # affectation de droite gauche>>> # affectations parallles d'une squence>>> e, f = 2.7, 5.1 # tuple>>> g, h, i = ['G', 'H', 'I'] # liste>>> x, y = coordonneesSouris() # retour multiple d'une 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-miees (garbage collector) de Python la supprime automatiquement :

2.7 Les chanes de caractres 11

(a) Trois aectations (b) La donne 'c' est supprime lorsque z rfrencela donne 'b'

(c) La donne 'a' est supprime lorsque x rfrencela nouvelle donne 'd'

F 2.2 Laectation illustre.

2.7 Les anes de caractres2.7.1 Les anes de caractres : prsentationDnitionb Les chanes de caractres : le type de donnes non modiable str reprsente une squence de carac-tres Unicode.Non modiable signie quune donne, une fois cre en mmoire, ne pourra plus tre change, toutetransformation rsultera en la cration dune nouvelle valeur distincte.

Trois syntaxes de chane 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 = r"Deuxime forme sans retour la ligne \n">>> s = """... Troisime forme multi-lignes... """>>>>>> print(s)

Troisime forme multi-lignes

>>> guillemets = "L'eau vive">>> apostrophes = 'Il a dit "gre !"'

2.7.2 Les anes de caractres : oprations Longueur :

>>> s = "abcde">>> len(s)5

Concatnation :


>>> s1 = "abc">>> s2 = "defg">>> s3 = s1 + s2>>> s3'abcdefg'

Rptition :>>> s4 = "Fi! ">>> s5 = s4 * 3>>> s5'Fi! Fi! Fi! '

2.7.3 Les anes de caractres : fonctions vs mthodesOn peut agir sur une chane en utilisant des fonctions (notion procdurale) communes tous les types

squences ou conteneurs, ou bien des mthodes (notion objet) spciques aux chanes. Exemple dutilisation de la fonction len() :

>>> lng = len("abc")>>> lng3

Exemple dutilisation de la mthode upper(). Remarquez la dirence de syntaxe : les mthodesutilisent la notation pointe :

>>> "abracadabra".upper()"ABRACADABRA"

2.7.4 Mthodes de test de ltat dune aneLes mthodes suivantes sont valeur boolenne, cest--dire quelles retournent la valeur True ouFalse.Remarque3 La notation [xxx] indique un lment optionnel que lon peut donc omere lors de lutilisation de lamthode.

La chane s = cHAise basSe nous servira de test pour toutes les mthodes de cee section.

isupper() et islower() : retournent True si la chane ne contient respectivement que des majuscu-les/minuscules :

>>> s.isupper()False

istitle() : retourne True si seule la premire lere de chaque mot de la chane est en majuscule :>>> s.istitle()False

isalnum(), isalpha(), isdigit() et isspace() : retournent True si la chane ne contient respective-ment que des caractres alphanumriques, alphabtiques, numriques ou des espaces :>>> s.isalpha()True>>> s.isdigit()False

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 :>>> s.startswith('cH')True>>> s.endswith('aSSe')False

2.7 Les chanes de caractres 13

2.7.5 Mthodes retournant une nouvelle ane lower(), upper(), capitalize() et swapcase() : retournent respectivement une chane en minuscule,en majuscule, en minuscule commenant par une majuscule, ou en casse inverse :

>>> s.lower()chaise basse>>> s.upper()CHAISE BASSE>>> s.capitalize()Chaise basse>>> 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) :

>>> s.center(20, '-')----cHAise basSe---->>> s.rjust(20, '@')@@@@@@@@cHAise basSe

zfill(width) : complte ch gauche avec des 0 jusqu une longueur maximale de width :>>> 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 :>>> 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 :

>>> s.find('se b')4

replace(old[, new[, count]]) : remplace count instances (toutes par dfaut) de old par new :>>> s.replace('HA', 'ha')chaise basSe

split(seps[, maxsplit]) : dcoupe la chane en maxsplit morceaux (tous par dfaut). rsplit() ef-fectue lamme chose en commenant par la n et striplines() eectue ce travail avec les caractresde n de ligne :>>> s.split()['cHAise', 'basSe']

join(seq) : concatne les chanes du conteneur seq en intercalant la chane sur laquelle la mthodeest applique :>>> "**".join(['cHAise', 'basSe'])cHAise**basSe

2.7.6 Les anes de caractres : indexation simplePour 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>>> s[0]'R'>>> s[2]'y'>>> s[-1]'X'>>> s[-3]'n'


F 2.3 Lindexation dune chane.

2.7.7 Extraction de sous-anes (ou tranes )Dnitionb Extraction de sous-chanes : loprateur [] avec 2 ou 3 index spars par le caractre : permetdextraire des sous-chanes (ou tranches) dune chane.

F 2.4 Extraction de sous-chanes.Par exemple :>>> s = "Rayon X" # len(s) ==> 7>>> s[1:4] # de l'index 1 compris 4 non compris'ayo'>>> s[-2:] # de l'index -2 compris la fin' X'>>> s[:3] # du dbut l'index 3 non compris'Ray'>>> s[3:] # de l'index 3 compris la fin'on X'>>> s[::2] # du dbut la fin, de 2 en 2'RynX'

2.8 Les donnes binairesLes types binaires

Python 3 propose deux types de donnes binaires : bytes (non modiable) et bytearray (modiable).

>>> mot = 'Animal' # type str>>> b_mot = b"Animal" # type bytes>>> bMot = bytearray(b_mot) # type bytearray

Une donne binaire contient une suite de zro ou plusieurs octets, cest--dire dentiers non signs sur8 bits (compris dans lintervalle [0255]). Ces types la C sont bien adapts pour stocker de grandesquantits 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 typemodiable bytearray possde des mthodes communes au type list.

2.9 Les entres-sorties 15

2.9 Les entres-sortiesLutilisateur a besoin dinteragir avec le programme (+ Fig. 2.5). En mode console (on verra les

interfaces graphiques ultrieurement), on doit pouvoir saisir ou entrer des informations, ce qui est gnra-lement fait depuis une lecture au clavier. Inversement, on doit pouvoir acher ou sortir des informations,ce qui correspond gnralement une criture sur lcran.

(a) Entre (b) Sortie

F 2.5 Les entres-sorties.

2.9.1 Les entresIl sagit de raliser une saisie au clavier : la fonction standard input() interrompt le programme, ache

une ventuelle invite lcran et aend que lutilisateur entre une donne au clavier (ache lcran)et la valide par

Entre .La fonction standard input() eectue toujours une saisie en mode texte (la valeur retourne est une

chane) dont on peut ensuite changer le type (on dit aussi transtyper) :

>>> f1 = input("Entrez un flottant : ")Entrez un flottant : 12.345>>> type(f1)

>>> f2 = input("Entrez un autre flottant : ")Entrez un autre flottant : 12.345>>> type(f2)

2.9.2 Les sortiesEnmode calculatrice , Python lit-value-ache (+ Fig. 2.1), mais la fonction print() reste indispen-

sable aux achages dans les scripts. Elle se charge dacher la reprsentation textuelle des informationsqui lui sont donnes en paramtre, en plaant un blanc sparateur entre deux informations, et en faisantun retour la ligne la n de lachage (le sparateur et la n de ligne peuvent tre modis) :

>>> 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()

>>> print("On a cas !", sep="###")On a cas !>>> # pour afficher autre chose qu'un espace en fin de ligne :>>> print(a, end="@"); print(b)2@3


2.9.3 Les squences dappement lintrieur dune chane, le caractre antislash (\) permet de donner une signication spciale

certaines squences de caractres :Squence Signication\saut_ligne saut de ligne ignor\\ ache un antislash\' apostrophe\" guillemet\a sonnerie (bip)\b retour arrire\f saut de page\n saut de ligne\r retour en dbut de ligne\t tabulation horizontale\v tabulation verticale\N{nom} caractre sous forme de code Unicode nomm\uhhhh caractre sous forme de code Unicode 16 bits\Uhhhhhhhh caractre sous forme de code Unicode 32 bits\ooo caractre sous forme de code octal\xhh caractre sous forme de code hexadcimal

Exemples :>>> print("\N{pound sign} \u00A \U000000A3") 2 5>>> print("d \144 \x64")d d d>>> print(r"d \144 \x64")s \144 \x64

C 3

Le contrle du ux dinstructions

Un script Python est form dune suite dinstructions excutes en squence de haut en bas a.

Chaque ligne dinstructions est forme dune ou plusieurs lignes physiques qui peuvent trecontinues par un antislash \ ou un caractre ouvrant [({ pas encore ferm.

Cee excution en squence peut tre modie pour choisir ou rpter des portions de code,ce que lon appelle instructions composes.

a. On peut mere plusieurs instructions sur la mme ligne en les sparant avec un ; mais, parsoucis de lisibilit, cest dconseill.

3.1 Les instructions composesPour identier les instructions composes, Python utilise la notion dindentation signicative, cest--

dire visuelle. Cee syntaxe lgre met en lumire un bloc dinstructions et permet damliorer grandementla prsentation des programmes sources.Syntaxe. Une instruction compose se compose : dune ligne den-tte termine par deux-points ;

dun bloc dinstructions indent par rapport la ligne den-tte.

Attentionj Toutes les instructions au mme niveau dindentation appartiennent au mme bloc (+ Fig. 3.1).

Exemple :>>> # ......>>> n = -3>>> if n < 0:... print("Votre nombre est ngatif.")...Votre nombre est ngatif.>>> # ... suite du programme

On a souvent besoin dimbriquer les instructions composes :>>> # ......>>> n = 3

18 Le contrle du ux dinstructions

>>> if n 2:... print("Il est suprieur 2.")...Votre nombre est positif.Il est suprieur 2.>>> # ... suite du programme

(a) simple (b) imbrique

F 3.1 Instruction compose.

3.2 Choisir3.2.1 Choisir : if - [elif] - [else]

Contrler une alternative :>>> x = 5>>> if x < 0:... print("x est ngatif. Pour sa valeur absolue, on prend l'oppos")... elif x % 2:... print("x est positif et impair")... else:... print("x n'est pas ngatif et est pair")...x est positif et impair

Test dune valeur boolenne :>>> if estPair: # mieux que if estPair == True:... print("La condition est vraie")

3.2.2 Syntaxe compacte dune alternativePour trouver, par exemple, le minimum de deux nombres, on peut utiliser loprateur ternaire :>>> x, y = 4, 3>>> if x < y: # criture classique... plus_petit = x... else:... plus_petit = y...>>> print("Plus petit : ", plus_petit)Plus petit : 3>>> plus_petit = x if x < y else y # utilisation de l'oprateur ternaire>>> print("Plus petit : ", plus_petit)Plus petit : 3

3.3 Boucles 19

Remarque3 Loprateur ternaire est une expression, laquelle correspond une valeur que lon peut utiliser dansune aectation ou un calcul.

3.3 Boucles

Notions de conteneur et ditrableDe faon gnrale, nous parlerons de conteneur pour dsigner un type dedonnes permeant de stocker un ensemble dautres donnes, en ayantou non, suivant les types, une notion dordre entre ces donnes.Nous parlerons aussi ditrable pour dsigner un conteneur que lon peutparcourir lment par lment.Pour parcourir ces conteneurs, nous nous servirons parfois de range()qui fournit un moyen commode pour gnrer une liste de valeurs.Par exemple :>>> uneListe = list(range(6))>>> uneListe[0, 1, 2, 3, 4, 5]

Ces notions seront tudies plus en dtail au chapitre 4, p. 23.

Python propose deux boucles.

3.3.1 Rpter : whileRpter une portion de code tant quune expression boolenne est vraie :>>> x, cpt = 257, 0>>> sauve = x>>> while x > 1:... x //= 2 # division avec troncature... cpt += 1 # incrmentation...>>> print("Approximation de log2 de", sauve, "est :", cpt)Approximation de log2 de 257 est : 8

Utilisation classique : la saisie ltre dune valeur numrique (on doit prciser le type car on se rappelleque input() saisit une chane) :

n = int(input('Entrez un entier [1 .. 10] : '))while not(1 > for lettre in "ciao":... print(lettre)...ciao>>> for x in [2, 'a', 3.14]:... print(x)...2a3.14>>> for i in range(5):


... print(i)

...01234>>>>>> nb_voyelles = 0>>> for lettre in "Python est un langage tres sympa":... if lettre in "aeiouy":... nb_voyelles = nb_voyelles + 1...>>> nb_voyelles10

3.4 Ruptures de squences3.4.1 Interrompre une boucle : break

Sort immdiatement de la boucle for ou while en cours contenant linstruction :>>> for x in range(1, 11):... if x == 5:... break... print(x, end=" ")...1 2 3 4>>> print("Boucle interrompue pour x =", x)Boucle interrompue pour x = 5

3.4.2 Court-circuiter une boucle : continuePasse 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):... if x == 5:... continue... print(x, end=" ")...1 2 3 4 6 7 8 9 10>>> # la boucle a saut la valeur 5

3.4.3 Utilisation avance des bouclesLa syntaxe complte des boucles autorise des utilisations plus rares.

while - else

Les boucles while et for peuvent possder une clause else qui ne sexcute que si la boucle se terminenormalement, 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. : '))

x = y // 2while x > 1:

if y % x == 0:print(x, "a pour facteur", y)break # voici l'interruption !x -= 1else:

print(y, "est premier.")

3.4 Ruptures de squences 21

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 = ibreak # voici l'interruption !else:

print(cible, "n'est pas dans", une_sequence)sauve = None

# sauve vaut donc cible ou None :print("On obtient sauve =", sauve)

3.4.4 Traitement des erreurs les exceptionsAn 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 mcanisme 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 gestionnairedexception).

from math import sin

for x in range(-4, 5): # -4, -3, -2, -1, 0, 1, 2, 3, 4try:

print('{:.3f}'.format(sin(x)/x), end=" ")except ZeroDivisionError: # toujours fournir une exception

print(1.0, end=" ") # gre l'exception 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 appartiennent un ensemble dexceptions nomm Exception.Cee famille ore une vingtaine dexceptions standard 1.

Syntaxe complte dune exception :

try:... # squence normale d'excutionexcept as e1:

... # traitement de l'exception 1except as e2:

... # traitement de l'exception 2...else:

... # clause excute en l'absence d'erreurfinally:

... # clause toujours excute

1. Citons quelques exemplaires : AritmeticError, ZeroDivisionError, IndexError, KeyError, AttributeError, IOError, ImportEr-ror, NameError, SyntaxError, TypeError. . .


Linstruction raise permet de lever volontairement une exception :x = 2if not(0

C 4Les conteneurs standard

Le chapitre 2 a prsent les types de donnes simples, mais Python ore beaucoup plus : lesconteneurs .De faon gnrale, un conteneur est un objet composite destin contenir dautres objets. Cechapitre dtaille les squences, les tableaux associatifs, les ensembles et les chiers textuels.

4.1 Les squences4.1.1 est-ce quune squence ?Dnitionb Une squence est un conteneur ordonn dlments indexs par des entiers indiquant leur positiondans le conteneur.

Python dispose de trois types prdnis de squences : les chanes (vues prcdemment) ; les listes ; les tuples 1.

4.2 Les listes4.2.1 Dnition, syntaxe et exemplesDnitionb Une liste est une collection ordonne et modiable dlments ventuellement htrognes.Syntaxe. lments spars par des virgules, et entours de crochets.couleurs = ['trfle', 'carreau', 'coeur', 'pique']print(couleurs) # ['trfle', 'carreau', 'coeur', 'pique']couleurs[1] = 14print(couleurs) # ['trfle', 14, 'coeur', 'pique']list1 = ['a', 'b']list2 = [4, 2.718]list3 = [list1, list2] # liste de listesprint(list3) # [['a', 'b'], [4, 2.718]]

1. tuple nest pas vraiment un anglicisme, mais plutt un nologisme informatique.

24 Les conteneurs standard

4.2.2 Initialisations et testsUtilisation de la rptition, de litrateur dentiers range() et de loprateur dappartenance (in) :>>> truc = []>>> machin = [0.0] * 3>>> truc[]>>> machin[0.0, 0.0, 0.0]>>>>>> liste_1 = list(range(4))>>> liste_1[0, 1, 2, 3]>>> liste_2 = list(range(4, 8))>>> liste_2[4, 5, 6, 7]>>> liste_3 = list(range(2, 9, 2))>>> liste_3[2, 4, 6, 8]>>>>>> 2 in liste_1, 8 in liste_2, 6 in liste_3(True, False, True)

4.2.3 Mthodeselques mthodes de modication des listes :>>> nombres = [17, 38, 10, 25, 72]>>> nombres.sort()>>> nombres[10, 17, 25, 38, 72]>>> nombres.append(12)>>> nombres.reverse()>>> nombres.remove(38)>>> nombres[12, 72, 25, 17, 10]>>> nombres.index(17)3>>> nombres[0] = 11>>> nombres[1:3] = [14, 17, 2]>>> nombres.pop()10>>> nombres[11, 14, 17, 2, 17]>>> nombres.count(17)2>>> nombres.extend([1, 2, 3])>>> nombres[11, 14, 17, 2, 17, 1, 2, 3]

4.2.4 Manipulation des tranes (ou sous-anes)Syntaxe. Si on veut supprimer, remplacer ou insrer plusieurs lments dune liste, il faut indiquer une tranche(cf. 2.7.7, p. 14) 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 d'une liste vide>>> mots['jambon', 'sel', 'beurre']>>> mots[1:3] = ['salade']>>> mots['jambon', 'salade']>>> mots[1:] = ['mayonnaise', 'poulet', 'tomate']>>> mots['jambon', 'mayonnaise', 'poulet', 'tomate']>>> mots[2:2] = ['miel'] # insertion en 3 position>>> mots['jambon', 'mayonnaise', 'miel', 'poulet', 'tomate']

4.3 Les tuples 25

4.2.5 Des squences de squencesLes squences, comme du reste les autres conteneurs, peuvent tre imbriqus.

Par exemple :>>> liste_1 = [1, 2, 3]>>> listes = [liste_1, [4, 5], "abcd"]>>>>>> for liste in listes:... for elem in liste:... print(elem)... print()...123

45

abcd

4.3 Les tuplesDnitionb Un tuple est une collection ordonne et non modiable dlments ventuellement htrognes.Syntaxe. lments spars par des virgules, et entours de parenthses.

mon_tuple = ('a', 2, [1, 3])

Lindexage des tuples sutilisent comme celui des listes ; le parcours des tuples est plus rapide que celui des listes ; ils sont utiles pour dnir des constantes.

Attentionj Comme les chanes de caractres, les tuples ne sont pas modiables !

4.4 Retour sur les rfrencesNous avons dj vu que lopration daectation, apparemment innocente, est une relle dicult de

Python.

i = 1msg = "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 plusieurs variables, toutchangement de lobjet via une variable sera visible par lautre variable :


fable = ["Je", "plie", "mais", "ne", "romps", "point"]phrase = fable

phrase[4] = "casse"

print(fable) # ['Je', 'plie', 'mais', 'ne', 'casse', 'point']

Si on veut pouvoir eectuer des modications spares, il faut aecter lautre variable par une copiedistincte de lobjet, soit en crant une tranche complte des squences dans les cas simples, soit en utilisantle module copy dans les cas les plus gnraux (autres conteneurs). Dans les rares occasions o lon veutaussi que chaque lment et aribut de lobjet soit copi sparment et de faon rcursive, on emploie lafonction copy.deepcopy() :>>> import copy>>> a = [1, 2, 3]>>> b = a # une rfrence>>> b.append(4)>>> a[1, 2, 3, 4]>>> c = a[:] # une copie simple>>> c.append(5)>>> c[1, 2, 3, 4, 5]>>> d = copy.copy(a) # une copie de "surface">>> d.append(6)>>> d[1, 2, 3, 4, 6]>>> a[1, 2, 3, 4]>>> d1 = {'a' : [1, 2], 'b' : [3, 4]}>>> d2 = {'c' : (1, 2, 3), 'c' : (4, 5, 6)}>>> liste_de_dicos = [d1, d2]>>> nouvelle_liste_de_dicos = copy.deepcopy(liste_de_dicos) # copie "profonde" (ou "rcursive")>>> nouvelle_liste_de_dicos[{'a': [1, 2], 'b': [3, 4]}, {'c': (4, 5, 6)}]

4.4.1 Complment graphique sur lassignationAssignation augmente dun objet nonmodiable (cas dun entier :+ Fig. 4.1). On a reprsent ltape

de laddition intermdiaire.

(a) Assignation dun entier (b) Addition intermdiaire

(c) Assignation augmente

F 4.1 Assignation augmente dun objet non modiable.

Assignation augmente dun objet modiable (cas dune liste :+ Fig. 4.2). On a reprsent ltape dela cration de la liste intermdiaire.

4.5 Les tableaux associatifs 27

(a) Assignation dune liste (b) Cration intermdiaire en m-moire

(c) Assignation augmente

F 4.2 Assignation augmente dun objet modiable.

4.5 Les tableaux associatifs4.5.1 Les types tableaux associatifsDnitionb Un tableau associatif est un type de donnes permeant de stocker des couples cle : valeur, avecun accs trs rapide la valeur partir de la cl, la cl ne pouvant tre prsente quune seule fois dans letableau.

Il possde les caractristiques suivantes : loprateur dappartenance dune cl (in) ; la fonction taille (len()) donnant le nombre de couples stocks ; il est itrable (on peut le parcourir) mais nest pas ordonn.

Python propose le type standard dict.

4.5.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.Une cl pourra tre alphabtique, numrique. . . en fait de tout type hachable (donc liste et dictionnaire

exclus). Les valeurs pourront tre de tout type sans exclusion.

Exemples de cration

>>> d1 = {} # dictionnaire vide>>> d1["nom"] = 3>>> d1["taille"] = 176>>> d1{'nom': 3, 'taille': 176}>>>>>> d2 = {"nom": 3, "taille": 176} # dfinition en extension>>> d2{'nom': 3, 'taille': 176}>>>>>> d3 = {x: x**2 for x in (2, 4, 6)} # dfinition en intension>>> d3{2: 4, 4: 16, 6: 36}>>>>>> d4 = dict(nom=3, taille=176) # utilisation de paramtres nomms>>> d4


{'taille': 176, 'nom': 3}>>>>>> d5 = dict([("nom", 3), ("taille", 176)]) # utilisation d'une liste de couples cls/valeurs>>> d5{'nom': 3, 'taille': 176}

Mthodeselques mthodes applicables aux dictionnaires :>>> tel = {'jack': 4098, 'sape': 4139}>>> tel['guido'] = 4127>>> tel{'sape': 4139, 'jack': 4098, 'guido': 4127}>>> tel['jack']4098>>> del tel['sape']>>> tel['irv'] = 4127>>> tel{'jack': 4098, 'irv': 4127, 'guido': 4127}>>>>>> tel.keys()['jack', 'irv', 'guido']>>> sorted(tel.keys())['guido', 'irv', 'jack']>>> sorted(tel.values())[4098, 4127, 4127]>>> 'guido' in tel, 'jack' not in tel(True, False)

4.6 Les ensembles (set)Dnitionb Un ensemble est une collection itrable non ordonne dlments hachables uniques.

Donc un set est la transposition informatique de la notion densemble mathmatique.

En Python, il existe deux types densemble, les ensembles modiables : set et les ensembles non mo-diables : frozenset. On retrouve ici les mmes dirences quentre les listes et les tuples.

F 4.3 Oprations sur les ensembles

>>> X = set('abcd')>>> Y = set('sbds')>>> Xset(['a', 'c', 'b', 'd'])>>> Yset(['s', 'b', 'd'])>>> 'c' in XTrue>>> 'a' in YFalse>>> X - Yset(['a', 'c'])>>> Y - Xset(['s'])

4.7 Les chiers textuels 29

>>> X | Yset(['a', 'c', 'b', 'd', 's'])>>> X & Yset(['b', 'd'])

4.7 Les iers textuels4.7.1 Les iers : introduction

On rappelle que lordinateur nexcute que les programmes prsents dans sa mmoire volatile (laRAM). Pour conserver durablement des informations, il faut utiliser une mmoire permanente commepar exemple le disque dur, la cl USB, le DVD,. . . sur lesquels le systme dexploitation organise les don-nes sous la forme de chiers.

Comme la plupart des langages, Python utilise classiquement la notion de chier.

Nous limiterons nos exemples aux chiers textuels (lisibles par un diteur), mais signalons que leschiers stocks en codage binaire sont plus compacts et plus rapides grer (utiles pour les grands volumesde donnes).

4.7.2 Gestion des iersOuverture et fermeture des iers

Principaux modes douverture des chiers textuels :

f1 = open("monFichier_1", "r", encoding='utf-8') # "r" mode lecturef2 = open("monFichier_2", "w", encoding='utf-8') # "w" mode crituref3 = open("monFichier_3", "a", encoding='utf-8') # "a" mode ajout

Python utilise les chiers en mode texte par dfaut (not t). Pour les chiers binaires, il faut prciserle mode b.

Le paramtre optionnel encoding assure les conversions entre les types byte , stock dans le chier surle disque, et le type str, manipul lors des lectures et critures.

Les encodages les plus frquents sont 'utf-8' (cest lencodage privilgier en Python 3), 'latin1','ascii'. . .

Tant que le chier nest pas ferm 1, son contenu nest pas garanti sur le disque.

Une seule mthode de fermeture :

f1.close()

criture squentielleLe chier sur disque est considr comme une squence de caractres qui sont ajouts la suite, au

fur et mesure que lon crit dans le chier.Mthodes dcriture :

f = open("truc.txt", "w")s = 'toto\n'f.write(s) # crit la chane s dans fl = ['a', 'b', 'c']f.writelines(l) # crit les chanes de la liste l dans ff.close()

f2 = open("truc2.txt", "w")print("abcd", file=f2) # utilisation de l'option filef2.close()

1. ou bien ush par un appel la mthode flush().


Lecture squentielleEn lecture, la squence de caractres qui constitue le chier est parcourue en commenant au dbut

du chier et en avanant au fur et mesure des lectures.Mthodes de lecture :f = open("truc.txt", "r")s = f.read() # lit tout le fichier --> chanes = f.read(3) # lit au plus n octets --> chanes = f.readline() # lit la ligne suivante --> chanes = f.readlines() # lit tout le fichier --> liste de chanesf.close()

# Affichage des lignes d'un fichier une unef = open("truc.txt") # mode "r" par dfautfor ligne in f:

print(ligne)f.close()

4.8 Itrer sur les conteneursLes 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 indice et item 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.

Obtenir une squence inverse (la squence initiale est inchange) :for i in reversed(range(1, 10, 2)):

print(i, end=" ") # 9 7 5 3 1

Obtenir une squence trie lments uniques (la squence initiale est inchange) :basket = ["apple", "orange", "apple", "pear", "orange", "banana"]for f in sorted(set(basket)):

print(f, end=" ") # apple banana orange pear

4.9 Laage formatLa mthode format() permet de contrler nement la cration de chanes formates. On lutilisera

pour un achage via print(), pour un enregistrement via f.write(), ou dans dautres cas.Remplacements simples :print("{} {} {}".format("zro", "un", "deux")) # zro un deux

# formatage d'une chane pour usages ultrieurschain = "{2} {0} {1}".format("zro", "un", "deux")

print(chain) # affichage : deux zro un

4.9 Lachage format 31

with open("test.txt", "w", encoding="utf8") as f:f.write(chain) # enregistrement dans un fichier

print("Je m'appelle {}".format("Bob")) # Je m'appelle Bobprint("Je m'appelle {{{}}}".format("Bob")) # Je m'appelle {Bob}print("{}".format("-"*10)) # ----------

Remplacements avec champs nomms :a, b = 5, 3print("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 l'encre 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(poids = 12000, animal = 'lphant')print("L'{0[animal]} pse {0[poids]} kg\n".format(d)) # L'lphant pse 12000 kg

Remplacement avec aributs nomms :import mathimport 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() 1 :>>> print("{0!s} {0!r}".format("texte\n"))texte

'texte\n'

Formatages numriques :s = "int :{0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42)print(s) # int :42; hex: 2a; oct: 52; bin: 101010s = "int :{0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42)print(s) # int :42; hex: 0x2a; oct: 0o52; bin: 0b101010

n = 100pi = 3.1415926535897931k = -54

print("{:.4e}".format(pi)) # 3.1416e+00print("{:g}".format(pi)) # 3.14159print("{:.2%}".format(n/(47*pi))) # 67.73%

msg = "Rsultat sur {:d} chantillons : {:.2f}".format(n, pi)print(msg) # Rsultat sur 100 chantillons : 3.14

msg = "{0.real} et {0.imag} sont les composantes du complexe {0}".format(3-5j)print(msg) # 3.0 et -5.0 sont les composantes du complexe (3-5j)

print("{:+d} {:+d}".format(n, k)) # +100 -54 (on force l'affichage du signe)

print("{:,}".format(1234567890.123)) # 1,234,567,890.12

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("[{:.


long = 12print("[{}]".format(s[:long])) # [The sword of]m = 123456789print("{:0=12}".format(m)) # 000123456789print("{:#=12}".format(m)) # ###123456789

C 5

Fonctions et espaces de noms

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 te complexe en tes plus simples : conception de lapplication.

Ces avantages sont illustrs sur la gure 5.1 qui utilise entre autres la notion dimport, m-canisme trs simple qui permet de rutiliser des chiers de fonctions, souvent appels biblio-thques.

5.1 Dnition et syntaxeDnitionb Une fonction est un ensemble dinstructions regroupes sous un nom et sexcutant la demande.

On doit dnir une fonction chaque fois quun bloc dinstructions se trouve plusieurs reprises dansle code ; il sagit dune mise en facteur commun .Syntaxe. La dnition dune fonction est compose : du mot cl def suivi de lidenticateur de la fonction, de parenthses entourant les paramtres de la

fonction spars par des virgules, et du caractre deux points qui termine toujours une instruc-tion compose ;

dune chane de documentation indente comme le corps de la fonction ; du bloc dinstructions indent par rapport la ligne de dnition, et qui constitue le corps de la

fonction.Le bloc dinstructions est obligatoire. Sil est vide, on emploie linstruction pass. La documentation

(facultative) est fortement conseille.def afficheAddMul(a, b):

"""Calcule et affiche la somme et le produit de a et b."""somme = a + bproduit = a * bprint("La somme de", a, " et", b, " est", somme, " et le produit, produit)

34 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.

F 5.1 Les avantages de lutilisation des fonctions

5.2 Passage des arguments 35

5.2 Passage des arguments5.2.1 Mcanisme gnralRemarque3 Passage par aectation : chaque argument de la dnition de la fonction correspond, dans lordre, unparamtre de lappel. La correspondance se fait par aectation des paramtres aux arguments.

F 5.2 Passage des arguments par aectation des paramtres aux arguments.

5.2.2 Un ou plusieurs paramtres, pas de retourExemple sans linstruction return, ce quon appelle souvent une procdure 1. Dans ce cas la fonction

renvoie implicitement la valeur None :def table(base, debut, fin):

"""Affiche la table de multiplication des de ."""n = debutwhile n


Exemple avec utilisation dun return multiple :import math

def surfaceVolumeSphere(r):surf = 4.0 * math.pi * r**2vol = surf * r/3return surf, vol

# programme principalrayon = 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 paramtrePuisque en Python une variable peut rfrencer une fonction, on peut transmere une fonction comme

paramtre :>>> def f(x):... return 2*x+1...>>> def g(x):... return x//2...>>> def h(fonc, x):... return fonc(x)...>>>>>> h(f, 3)7>>> h(g, 4)2

5.2.5 Paramtres avec valeur par dfautIl est possible de spcier, lors de la dclaration, des valeurs par dfaut utiliser pour les arguments.

Cela permet, lors de lappel, de ne pas avoir spcier les paramtres correspondants.Il est possible, en combinant les valeurs par dfaut et le nommage des paramtres, de nindiquer

lappel que les paramtres dont on dsire modier la valeur de largument. Il est par contre ncessaire deregrouper tous les paramtres optionnels la n de la liste des paramtres.>>> def accueil(nom, prenom, depart="MP", semestre="S2"):... print(prenom, nom, "Dpartement", depart, "semestre", semestre)...>>> accueil("Student", "Joe")Joe Student Dpartement MP semestre S2>>> accueil("Student", "Eve", "Info")Eve Student Dpartement Info semestre S2>>> accueil("Student", "Steph", semestre="S3")Steph Student Dpartement MP semestre S3

Attentionj On utilise de prfrence des valeurs par dfaut non modiables (int, float, str, bool, tuple) car lamodication dun paramtre par un premier appel est visible les fois suivantes.

Si on a besoin dune valeur par dfaut qui soit modiable (list, dict), on utilise la valeur prdnieNone et on fait un test au dbut de la fonction :

def maFonction(liste=None):if liste is None:

liste = [1, 3]

5.3 Espaces de noms 37

5.2.6 Nombre darguments arbitraire passage dun tuple de valeursIl est possible dautoriser le passage dun nombre arbitraire darguments en utilisant la notation dun

argument nal *nom. Les paramtres surnumraires sont alors transmis sous la forme dun tuple aect cet argument (que lon appelle gnralement args).

def somme(*args):"""Renvoie la somme du tuple ."""resultat = 0for nombre in args:

resultat += nombrereturn resultat

# Exemples d'appel :print(somme(23)) # 23print(somme(23, 42, 13)) # 78

Attentionj Si la fonction possde plusieurs arguments, le tuple est en dernire position.

Rciproquement il est aussi possible de passer un tuple (en fait une squence) lappel qui sera d-compress en une liste de paramtres dune fonction classique :

def somme(a, b, c):return a+b+c

# Exemple d'appel :elements = (2, 4, 6)print(somme(*elements)) # 12

5.2.7 Nombre darguments arbitraire : passage dun dictionnaireDe lamme faon, il est possible dautoriser le passage dun nombre arbitraire darguments nomms en

plus de ceux prvus lors de la dnition en utilisant la notation dun argument nal **nom. Les paramtressurnumraires nomms sont alors transmis sous la forme dun dictionnaire aect cet argument (quelon appelle gnralement kwargs pour keyword args).

Rciproquement il est aussi possible de passer un dictionnaire lappel dune fonction, qui sera d-compress et associ aux paramtres nomms de la fonction.

def unDict(**kwargs):return kwargs

# Exemples d'appels## 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}

Attentionj Si la fonction possde plusieurs arguments, le dictionnaire est en toute dernire position (aprs unventuel tuple).

5.3 Espaces de noms5.3.1 Porte des objetsRemarque3 Porte : les noms des objets sont crs lors de leur premire aectation, mais ne sont visibles que danscertaines rgions de la mmoire.

On distingue :La porte globale : celle du module ou du chier script en cours. Un dictionnaire gre les objets globaux :

linstruction globals() fournit les couples variable :valeur ;La porte locale : les objets internes aux fonctions 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 LGILa recherche des noms est dabord locale (L), puis globale (G), enn interne (I) (+ Fig. 5.3) :

F 5.3 Rgle LGI

Exemples de portePar dfaut, toute variable utilise dans le corps dune fonction est locale celle-ci. Si une fonction a

besoin de modier certaines variables globales, la premire instruction de cee fonction doit tre :global

Par exemple :# x et fonc sont affects dans le module : globaux

def fonc(y): # y et z sont affects dans fonc : locauxglobal x # permet de modifier x ligne suivantex += 2z = x + yreturn z

x = 99print(fonc(1)) # 102print(x) # 101

# x et fonc sont affects dans le module : globaux

def fonc(y): # y et z sont affects dans fonc : locaux# dans fonc : porte localez = x + yreturn z


# x et fonc sont affects dans le module : globaux

def fonc(y): # y, x et z sont affects dans fonc : locauxx = 3 # ce nouvel x est local et masque le x globalz = x + yreturn z


C 6

Modules et paages

Un programme Python est gnralement compos de plusieurs chiers sources, appelsmodules. Leur nom est sux .py a.Sils sont correctement cods les modules doivent tre indpendants les uns des autres pourtre 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.

a. On trouve aussi occasionnellement des modules .pyw sous Windows.

6.1 ModulesDnitionb Module : chier script Python permeant de dnir des lements de programme rutilisables. Cemcanisme 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 ImportLinstruction import charge et excute le module indiqu sil nest pas dj charg. Lensemble des

dnitions contenues dans ce module deviennent alors disponibles : variables globales, fonctions, classes.Suivant la syntaxe utilise, on accde aux aux dnitions du module de direntes faons :

linstruction import donne accs lensemble des dnitions du module import enutilisant le nom du module comme espace de nom.>>> import tkinter>>> print("Version de l'interface graphique tkinter :", tkinter.TkVersion)Version de l'interface graphique tkinter : 8.5

linstruction from import nom1, nom2. . . donne accs directement une slectionchoisie de noms dnis dans le module.

40 Modules et packages

>>> from math import pi, sin>>> print("Valeur de Pi :", pi, "sinus(pi/4) :", sin(pi/4))Valeur de Pi : 3.14159265359 sinus(pi/4) : 0.707106781187

Dans les deux cas, le module et ses dnitions existent dans leur espacemmoire propre, et on dupliquesimplement dans le module courant les noms que lon a choisi, comme si on avait fait les aectations :>>> sin = math.sin>>> pi = math.pi

Remarque3 Il est conseill dimporter dans lordre :

les modules de la bibliothque standard ; les modules des bibliothques tierces ; Les modules personnels.

Attentionj Pour tout ce qui est fonction et classe, ainsi que pour les constantes (variables globales dnies etaecte une fois pour toute une valeur), limport direct du nom ne pose pas de problme.

Par contre, pour les variables globales que lon dsire pouvoir modier, il est prconis de de passersystmatiquement par lespace de nom du module an de sassurer de lexistence de cee variable en ununique exemplaire ayant la mme valeur dans tout le programme.

6.1.2 ExemplesNotion d auto-test

Le module principal est celui qui est donn en argument sur la ligne de commande ou qui est lancen premier lors de lexcution dun script. Son nom est contenu dans la variable globale variable globale__name__. Sa valeur dpend du contexte de lexcution.

Soit le module :# je_me_nomme.pyprint("Je me nomme :", __name__)

Premier contexte excution sur la ligne de commande (ou dans un EDI), on obtient la valeur prdnie__main__ :$ python3 je_me_nomme.pyJe me nomme : __main__

Second contexte import de ce module (ce nest donc plus le module principal ), on obtient lidenticateurdu module :>>> import je_me_nommeJe me nomme : je_me_nomme

Grce un test, on peut donc facilement savoir si le code est excut en tant que script principal :

on crit un script de fonctions ou de classes (souvent appel bibliothque) et on termine le chierpar un test, l auto-test , pour vrier que lon est dans le module principal. On en prote pourvrier tous les lments de la bibliothque ;

quand on importe le script, le test inclus est faux et on se borne utiliser la bibliothque.

# cube_m.py

def cube(x):"""retourne le cube de ."""return x**3

# auto-test ===================================================================if __name__ == "__main__": # vrai car module principal

print("OK!") if cube(9) == 729 else "KO!"

6.2 Bibliothque standard 41

Utilisation de ce module :import cube_m

# programme principal =========================================================for i in range(1, 4):

print("cube de", i, "=", cube_m.cube(i))

"""cube de 1 = 1cube de 2 = 8cube de 3 = 27"""

Autre exemple :def ok(message) :

"""Retourne True si on saisie , , , ou ,False dans tous les autres cas."""s = raw_input(message + " (O/n) ? ")return True if s == "" or s[0] in "OoYy" else False

# auto-test ===================================================================if __name__ == '__main__' :

import sys

while True:if ok("Encore"):

print("Je continue")else:

sys.exit("Je m'arrte")

"""Encore (O/n) ?Je continueEncore (O/n) ? oJe continueEncore (O/n) ? nJe m'arrte"""

6.2 Bibliothque standard6.2.1 La bibliothque standard

On dit souvent que Python est livr piles comprises (baeries included) tant sa bibliothque stan-dard, riche de plus de 200 packages et modules, rpond aux problmes courants les plus varis.

Ce survol prsente quelques fonctionnalits utiles.

La gestion des anesLe 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.Lemodule 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 1.1. Cest tout un monde. . .

42 Modules et packages

Le module io.StringIOCe 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 dans les deux cas :def scanner(objet_fichier, gestionnaire_ligne):

for ligne in objet_fichier:gestionnaire_ligne(ligne)

def premierMot(ligne): print(ligne.split()[0])

fic = open("data.dat")scanner(fic, premierMot)

import iochaine = io.StringIO("un\ndeux xxx\ntrois\n")scanner(chaine, premierMot)

La gestion de la ligne de commandePour grer la ligne de commande, Python propose linstruction sys.argv. Il sagit simplement dune

liste contenant les arguments de la ligne de commande : argv[1], argv[2]. . . sachant que argv[0] est lenom du script lui-mme.

De plus, Python propose le module optparse :from optparse import OptionParserparser = 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="don't print status messages to stdout")

(options, args) = parser.parse_args()

Les lignes de commande :python 6_025.py -h

oupython 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 don't print status messages to stdout

Bibliothques mathmatiques et types numriquesOn rappelle que Python possde la bibliothque math :>>> import math>>> math.pi / math.e1.1557273497909217>>> exp(1e-5) - 11.0000050000069649e-05>>> math.log(10)2.302585092994046>>> math.log2(1024)10>>> math.cos(math.pi/4)0.7071067811865476>>> math.atan(4.1/9.02)

6.2 Bibliothque standard 43

0.4266274931268761>>> math.hypot(3, 4)5.0>>> math.degrees(1)57.29577951308232

Par ailleurs, Python propose en standard les modules fraction et decimal :from fractions import Fractionimport decimal as d

print(Fraction(16, -10)) # -8/5print(Fraction(123)) # 123print(Fraction(' -3/7 ')) # -3/7print(Fraction('-.125')) # -1/8print(Fraction('7e-6')) # 7/1000000

d.getcontext().prec = 6print(d.Decimal(1) / d.Decimal(7)) # 0.142857d.getcontext().prec = 18print(d.Decimal(1) / d.Decimal(7)) # 0.142857142857142857

En plus des bibliothques math et cmath dj vues, la bibliothque random propose plusieurs fonctionsde nombres alatoires.

La gestion du temps et des datesLes modules calendar, time et datetime fournissent les fonctions courantes de gestion du temps et des

dures :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_jourprint(vendredi_precedent.strftime("%A, %d-%b-%Y"))# Friday, 09-Oct-2009

Algorithmes et types de donnes collectionLe module bisect fournit des fonctions de recherche de squences tries. Le module array propose un

type semblable la liste, mais

cours python 3

Documents