Cours Python 3

download Cours Python 3

of 155

Transcript of Cours Python 3

  • 5/26/2018 Cours Python 3

    1/155

    Bob CORDEAU

    Introduction Python 3version 2.71828

    [email protected]

    mailto:[email protected]:[email protected]:[email protected]:[email protected]
  • 5/26/2018 Cours Python 3

    2/155

  • 5/26/2018 Cours Python 3

    3/155

    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 bnfici des correctionsimpitoyablesde Laurent Pointal (LIMSI), des lec-tures attentives de Michelle Kessous, de Michelle Cordeau et de Georges Vincents (IUTdOrsay, dpartement Mesures Physiques).

    Grand merci ma fille Hlne pour ses illustrations ; les aventures deStevenle Python en-chantent les ttes de paragraphe.

    Merci Tarek Ziad pour les emprunts ses publications, en particulier je remercie les di-tionsEyrollespour leur aimable autorisation de publier le dialogue de la page102, ainsi queles ditionsDunodpour leur aimable autorisation de publier les exemples des pages88,90,96et98.

    Enfin il me faudrait saluer tous les auteurs que jai butins sur Internet... Quau moins, jenoublie pas ceux qui jai fait les plus grands emprunts dans les annexes : Sebsauvage etChristian Schindelhauer.

  • 5/26/2018 Cours Python 3

    4/155

    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 conduitedu projet tait de rduire la redondance dans le fonctionnement de Python par la suppressiondes mthodes obsoltes .

    qui sadresse ce cours ?

    Ce cours prend la suite des Notes de cours Python 2 destin aux tudiants de MesuresPhysiques de lIUT dOrsay.

    Bien qu ce jour loffre des bibliothques tierces ne soit pas pas encore riche (entre autresla bibliothquenumpynest pas disponible), il semble utile de disposer dun cours gnraliste

    en franais consacr la version 3 de Python.Nous en avons profit pour toffer le texte de trois chapitres et pour proposer une forme pluspratique pour un texte suceptible dtre imprim, tout en restant agrable consulter lcran.

    Outre ce cadre universitaire assez rduit, ce cours sadresse toute personne dsireusedapprendre 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. des outilsopen source : gnuplot, XLATEX 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 lignecreativecommons.org/licenses/by/2.0/fr/ou par courrier postal Creative Commons, 171Second Street, Suite 300, San Francisco, California 94105, USA.

    1. Cest une grave dcision, mrement rflchie : 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.

    http://creativecommons.org/licenses/by/2.0/fr/
  • 5/26/2018 Cours Python 3

    5/155

    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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.3.1 Des langages de diffrents niveaux . . . . . . . . . . . . . . . . . 31.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. . . . . . . . . . . . . . . . . 41.4.3 La construction des programmes . . . . . . . . . . . . . . . . . . 4

    1.5 Algorithme et programme . . . . . . . . . . . . . . . . . . . . . . . . . . 41.5.1 Dfinitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.5.2 La prsentation des programmes . . . . . . . . . . . . . . . . . . 5

    1.6 Les implmentations de Python . . . . . . . . . . . . . . . . . . . . . . . 5

    2 La calculatrice Python 72.1 Les modes dexcution. . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

    2.1.1 Les deux modes dexcution dun code Python . . . . . . . . . . . 72.2 Identifiants et mots cls . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

    2.2.1 Identifiants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82.2.2 Style de nommage. . . . . . . . . . . . . . . . . . . . . . . . . . 82.2.3 Les mots rservs de Python 3 . . . . . . . . . . . . . . . . . . . 9

    2.3 Notion dexpression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

    2.4 Les types de donnes entiers. . . . . . . . . . . . . . . . . . . . . . . . . 92.4.1 Le typeint . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92.4.2 Le typebool . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

    2.5 Les types de donnes flottants . . . . . . . . . . . . . . . . . . . . . . . . 112.5.1 Le typefloat . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.5.2 Le typecomplex . . . . . . . . . . . . . . . . . . . . . . . . . 11

    2.6 Variables et affectation. . . . . . . . . . . . . . . . . . . . . . . . . . . . 122.6.1 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122.6.2 Laffectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122.6.3 Affecter nest pas comparer ! . . . . . . . . . . . . . . . . . . . . 12

    2.6.4 Les variantes de laffectation . . . . . . . . . . . . . . . . . . . . 132.6.5 Les affectations (explications graphiques). . . . . . . . . . . . . . 132.7 Les chanes de caractres . . . . . . . . . . . . . . . . . . . . . . . . . . 13

    iii

  • 5/26/2018 Cours Python 3

    6/155

    iv TABLE DES MATIRES

    2.7.1 Les chanes de caractres : prsentation. . . . . . . . . . . . . . . 132.7.2 Les chanes de caractres : oprations. . . . . . . . . . . . . . . . 142.7.3 Les chanes de caractres : fonctionsvsmthodes . . . . . . . . . 142.7.4 Mthodes de test de ltat dune chanech . . . . . . . . . . . . . 142.7.5 Mthodes retournant une nouvelle chane. . . . . . . . . . . . . . 152.7.6 Les chanes de caractres : indexation simple . . . . . . . . . . . . 162.7.7 Extraction de sous-chanes . . . . . . . . . . . . . . . . . . . . . 16

    2.8 Les donnes binaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172.9 Les entres-sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

    2.9.1 Les entres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182.9.2 Les sorties. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192.9.3 Les squences dchappement. . . . . . . . . . . . . . . . . . . . 19

    3 Le contrle du flux dinstructions 213.1 Les instructions composes . . . . . . . . . . . . . . . . . . . . . . . . . 213.2 Choisir. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

    3.2.1 Choisir :if - [elif] - [else] . . . . . . . . . . . . . . 223.2.2 Syntaxe compacte dune alternative . . . . . . . . . . . . . . . . . 23

    3.3 Boucler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.3.1 Boucler :while . . . . . . . . . . . . . . . . . . . . . . . . . . 233.3.2 Parcourir :for . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

    3.4 Ruptures de squences. . . . . . . . . . . . . . . . . . . . . . . . . . . . 243.4.1 Interrompre une boucle :break . . . . . . . . . . . . . . . . . . 243.4.2 Court-circuiter une boucle :continue . . . . . . . . . . . . . . 24

    3.4.3 Syntaxe complte des boucles. . . . . . . . . . . . . . . . . . . . 243.4.4 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

    4 Les conteneurs standard 274.1 Les squences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

    4.1.1 Quest-ce quune squence? . . . . . . . . . . . . . . . . . . . . . 274.2 Les listes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

    4.2.1 Dfinition, syntaxe et exemples . . . . . . . . . . . . . . . . . . . 274.2.2 Initialisations et tests . . . . . . . . . . . . . . . . . . . . . . . . 284.2.3 Mthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284.2.4 Manipulation des tranches . . . . . . . . . . . . . . . . . . . . 28

    4.3 Les listes en intension . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294.4 Les tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304.5 Retour sur les rfrences. . . . . . . . . . . . . . . . . . . . . . . . . . . 304.6 Les tableaux associatifs . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

    4.6.1 Les types tableaux associatifs . . . . . . . . . . . . . . . . . . . . 314.6.2 Les dictionnaires (dict) . . . . . . . . . . . . . . . . . . . . . . 32

    4.7 Les ensembles (set) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.8 Les fichiers textuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

    4.8.1 Les fichiers : introduction . . . . . . . . . . . . . . . . . . . . . . 33

    4.8.2 Gestion des fichiers . . . . . . . . . . . . . . . . . . . . . . . . . 344.9 Itrer sur les conteneurs . . . . . . . . . . . . . . . . . . . . . . . . . . . 354.10 Laffichage format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

  • 5/26/2018 Cours Python 3

    7/155

    TABLE DES MATIRES v

    5 Fonctions et espaces de noms 395.1 Dfinition et syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395.2 Passage des arguments. . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

    5.2.1 Mcanisme gnral . . . . . . . . . . . . . . . . . . . . . . . . . 415.2.2 Un ou plusieurs paramtres, pas de retour. . . . . . . . . . . . . . 415.2.3 Un ou plusieurs paramtres, utilisation du retour . . . . . . . . . . 415.2.4 Passage dune fonction en paramtre . . . . . . . . . . . . . . . . 425.2.5 Paramtres avec valeur par dfaut. . . . . . . . . . . . . . . . . . 425.2.6 Nombre darguments arbitraire : passage dun tuple . . . . . . . . . 435.2.7 Nombre darguments arbitraire : passage dun dictionnaire . . . . . 43

    5.3 Espaces de noms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445.3.1 Porte des objets . . . . . . . . . . . . . . . . . . . . . . . . . . 445.3.2 Rsolution des noms : rgleLGI . . . . . . . . . . . . . . . . . . 44

    6 Modules et packages 476.1 Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

    6.1.1 Import dun module . . . . . . . . . . . . . . . . . . . . . . . . . 476.1.2 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

    6.2 Bibliothque standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496.2.1 La bibliothque standard . . . . . . . . . . . . . . . . . . . . . . 49

    6.3 Bibliothques tierces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526.3.1 Une grande diversit . . . . . . . . . . . . . . . . . . . . . . . . 526.3.2 Un exemple : la bibliothqueUnum . . . . . . . . . . . . . . . . . 52

    6.4 Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

    7 La programmation Oriente Objet 557.1 Insuffisance de lapproche procdurale. . . . . . . . . . . . . . . . . . . . 557.2 Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567.3 Classes et instanciation dobjets . . . . . . . . . . . . . . . . . . . . . . . 57

    7.3.1 Linstructionclass . . . . . . . . . . . . . . . . . . . . . . . . 577.3.2 Linstanciation et ses attributs . . . . . . . . . . . . . . . . . . . . 577.3.3 Retour sur les espaces de noms . . . . . . . . . . . . . . . . . . . 57

    7.4 Mthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587.5 Mthodes spciales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

    7.5.1 Les mthodes spciales . . . . . . . . . . . . . . . . . . . . . . . 587.5.2 Linitialisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597.5.3 Surcharge des oprateurs . . . . . . . . . . . . . . . . . . . . . . 597.5.4 Exemple de surcharge . . . . . . . . . . . . . . . . . . . . . . . . 59

    7.6 Hritage et polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . 607.6.1 Hritage et polymorphisme . . . . . . . . . . . . . . . . . . . . . 607.6.2 Exemple dhritage et de polymorphisme . . . . . . . . . . . . . . 60

    7.7 Retour sur lexemple initial . . . . . . . . . . . . . . . . . . . . . . . . . 607.7.1 La classeCercle: conception. . . . . . . . . . . . . . . . . . . 607.7.2 La classeCercle . . . . . . . . . . . . . . . . . . . . . . . . . 60

    7.8 Notion de Conception Oriente Objet . . . . . . . . . . . . . . . . . . . . 627.8.1 Composition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 627.8.2 Drivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

  • 5/26/2018 Cours Python 3

    8/155

    vi TABLE DES MATIRES

    8 Techniques avances 658.1 Techniques procdurales. . . . . . . . . . . . . . . . . . . . . . . . . . . 65

    8.1.1 Amliorer la documentation. . . . . . . . . . . . . . . . . . . . . 658.1.2 Faire des menus avec un dictionnaire . . . . . . . . . . . . . . . . 668.1.3 Les fonctions rcursives. . . . . . . . . . . . . . . . . . . . . . . 678.1.4 Les gnrateurs et les expressions gnratrices . . . . . . . . . . . 698.1.5 Les fonctions incluses . . . . . . . . . . . . . . . . . . . . . . . . 708.1.6 Les dcorateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

    8.2 Techniques objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 728.2.1 __slots__et__dict__ . . . . . . . . . . . . . . . . . . . . 728.2.2 Functor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 728.2.3 Les accesseurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

    8.3 Techniques fonctionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . 758.3.1 Directivelambda . . . . . . . . . . . . . . . . . . . . . . . . . 758.3.2 Les fonctionsmap,filteretreduce. . . . . . . . . . . . . . 758.3.3 Les applications partielles de fonctions . . . . . . . . . . . . . . . 76

    9 La programmation OO graphique 799.1 Programmes pilots par des vnements. . . . . . . . . . . . . . . . . . . 799.2 La bibliothquetkinter . . . . . . . . . . . . . . . . . . . . . . . . . 80

    9.2.1 Prsentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 809.2.2 Les widgets detkinter . . . . . . . . . . . . . . . . . . . . . 809.2.3 Le positionnement des widgets . . . . . . . . . . . . . . . . . . . 81

    9.3 Deux exemples. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 819.3.1 tkPhone, un exemple sans menu . . . . . . . . . . . . . . . . . 81

    9.3.2 IDLE, un exemple avec menu . . . . . . . . . . . . . . . . . . . 85

    10 Notion de dveloppement agile 8710.1 Les tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

    10.1.1 Tests unitaires et tests fonctionnels . . . . . . . . . . . . . . . . . 8710.1.2 Le dveloppement dirig par les tests . . . . . . . . . . . . . . . . 88

    10.2 La documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8910.2.1 Le format reST . . . . . . . . . . . . . . . . . . . . . . . . . . . 8910.2.2 Le moduledoctest. . . . . . . . . . . . . . . . . . . . . . . . 9310.2.3 Le dveloppement dirig par la documentation . . . . . . . . . . . 96

    A Interlude 101

    B Jeux de caractres et encodage 105

    C Les fonctions logiques 109

    D Les bases arithmtiques 111

    E Les fonctions de hachage 113

    F Exercices corrigs 115

    G Ressources 129

  • 5/26/2018 Cours Python 3

    9/155

    TABLE DES MATIRES vii

    H Glossaire 133

    Colophon 143

  • 5/26/2018 Cours Python 3

    10/155

    viii TABLE DES MATIRES

  • 5/26/2018 Cours Python 3

    11/155

    Table des figures

    1.1 Chane de compilation. . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2 Technique de linterprtation . . . . . . . . . . . . . . . . . . . . . . . . 41.3 Interprtation du bytecode compil . . . . . . . . . . . . . . . . . . . . . 4

    2.1 La boucle dvaluation de IDLE . . . . . . . . . . . . . . . . . . . . . . . 7

    2.2 Laffectation illustre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.3 Lindexation dune chane. . . . . . . . . . . . . . . . . . . . . . . . . . . 162.4 Extraction de sous-chanes. . . . . . . . . . . . . . . . . . . . . . . . . . 172.5 Codes, glyphes, caractres et octets. . . . . . . . . . . . . . . . . . . . . . 182.6 Les entres-sorties. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182.7 Utilisation des squences dchappement . . . . . . . . . . . . . . . . . . 20

    3.1 Les instructions composes. . . . . . . . . . . . . . . . . . . . . . . . . . 22

    4.1 Assignation augmente dun objet non modifiable.. . . . . . . . . . . . . . 314.2 Assignation augmente dun objet modifiable. . . . . . . . . . . . . . . . . 32

    4.3 Oprations sur les ensempbles . . . . . . . . . . . . . . . . . . . . . . . . 33

    5.1 Les avantages de lutilisation des fonctions . . . . . . . . . . . . . . . . . 405.2 Passage des arguments par affectation.. . . . . . . . . . . . . . . . . . . . 415.3 Rgle LGI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

    7.1 Conception UML de la classeCercle.. . . . . . . . . . . . . . . . . . . 61

    8.1 Empilage/dpilage de 4 !. . . . . . . . . . . . . . . . . . . . . . . . . . . 688.2 Application partielle dun widget. . . . . . . . . . . . . . . . . . . . . . . 77

    9.1 Deux styles de programmation. . . . . . . . . . . . . . . . . . . . . . . . 799.2 Un exemple simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 809.3 tkPhone. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 829.4 IDLE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

    10.1 exemple de sortie au format HTML.. . . . . . . . . . . . . . . . . . . . . 9210.2 Excution du scriptdoctest1.py. . . . . . . . . . . . . . . . . . . . . 9410.3 Excution du scriptdoctest2.py. . . . . . . . . . . . . . . . . . . . . 9510.4 Excution du scriptexample.py. . . . . . . . . . . . . . . . . . . . . . 9710.5 Documentation du scriptdoctest2.py. . . . . . . . . . . . . . . . . . 9810.6 Documentation du scriptexample.py. . . . . . . . . . . . . . . . . . . 99

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

    ix

  • 5/26/2018 Cours Python 3

    12/155

    x TABLE DES FIGURES

    B.3 Le jeu de caractres cp1252. . . . . . . . . . . . . . . . . . . . . . . . . 108

    E.1 Le principe du hachage . . . . . . . . . . . . . . . . . . . . . . . . . . . 113E.2 Hachage des cls dun dictionnaire. . . . . . . . . . . . . . . . . . . . . . 114

  • 5/26/2018 Cours Python 3

    13/155

    Chapitre 1

    Introduction linformatique

    Ce premier chapitre introduit les grandes caractristiques du langage Python, re-place Python dans lhistoire des langages, donne les particularits de productiondes scripts, dfini la notion si importante dalgorithme et conclut sur les diversimplmentations 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 deNumerical 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 utilisen 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 restrictioncopyleft. Py-

    thon 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 dubytecodecompil

    1. en octobre.

  • 5/26/2018 Cours Python 3

    14/155

    2 CHAPITRE 1. INTRODUCTION

    De nombreux modules sont disponibles partir de bibliothques optimises critesen C, C++ ou FORTRAN

    Simplicit du langage(cf. Zen of Python p.101) : Syntaxe claire et cohrente Indentation significative

    Gestion automatique de la mmoire (garbage collector) Typage dynamique fort : pas de dclaration

    Orientation objet Modle objet puissant mais pas obligatoire Structuration multifichier trs facile des applications : facilite les modifications 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 affecter, les passer enparamtre)

    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 simplifier la dfinition de lordinateur de la faon suivante :

    Dfinition

    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 (diteviveou 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 (ditesmortes: disque dur,cl USB, CD-ROM...), rseau...

    1.2.2 Deux sortes de programmes

    On distingue, pour faire rapide :

    Lesystme dexploitation: ensemble des programmes qui grent les ressources mat-

    rielles et logicielles. Il propose une aide au dialogue entre lutilisateur et lordinateur :linterface textuelle (interprteur de commande) ou graphique (gestionnaire de fe-ntres). Il est souvent multitche et parfois multiutilisateur ;

  • 5/26/2018 Cours Python 3

    15/155

    1.3. LES LANGAGES 3

    lesprogrammes applicatifssont ddis des tches particulires. Ils sont forms dunesrie de commandes contenues dans un programme source qui est transform pour treexcut par lordinateur.

    1.3 Les langages1.3.1 Des langages de diffrents niveaux

    Chaque processeur possde un langage propre, directement excutable : le langagemachine. Il est form de 0 et de 1 et nest pas portable, mais cest le seul que lordinateurpuisse utiliser ;

    lelangage dassemblageest un codage alphanumrique du langage machine. Il est pluslisible que le langage machine, mais nest toujours pas portable. On le traduit en langagemachine par unassembleur;

    leslangages de haut niveau. Souvent normaliss, ils permettent le portage dune ma-chine lautre. Ils sont traduits en langage machine par uncompilateurou uninterpr-teur.

    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, Eiffel, 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

    Lacompilationest la traduction du source en langage objet. Elle comprend au moinsquatre 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 par-ticulire : ldition de liens. La compilation est contraignante mais offre au final une grandevitesse dexcution.

    Figure 1.1 Chane de compilation

    Dans la technique de linterprtationchaque 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 doittre utilis chaque excution...

  • 5/26/2018 Cours Python 3

    16/155

    4 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 fa-

    cilit de dveloppement et la rapidit dexcution; lebytecode(forme intermdiaire) est portable sur tout ordinateur muni de lamachine

    virtuelle Python.

    Figure 1.3 Interprtation du bytecode compil

    Pourexcuter un programme, Python charge le fichier source .py (ou .pyw) en m-moire vive, en fait lanalyse syntaxique, produit le bytecode et enfin lexcute. Pour chaquemodule import par le programme, Python vrifie dabord sil existe une version prcompi-le du bytecode (dans un fichier .pyo ou .pyc) dont la date correspond au fichier .py. Sily en a un, Python lutilise, sinon il fait une analyse syntaxique du module.py, et utilise lebytecode quil vient de gnrer.

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

    1.4.3 La construction des programmes

    Le gnie logiciel tudie les mthodes de construction des programmes. Plusieurs modlessont envisageables, entre autres :

    la mthodologieprocdurale. On emploie lanalyse descendante (division des pro-blmes) et remontante (rutilisation dun maximum de sous algorithmes). On sefforceainsi de dcomposer un problme complexe en sous-programmes plus simples. Ce mo-dle structure dabord les actions ;

    la mthodologieobjet. On conoit des fabriques (classes) qui servent produire des

    composants (objets) qui contiennent des donnes (attributs) et des actions (mthodes).Les classes drivent (hritageetpolymorphisme) de classes de base dans une construc-tion hirarchique.

    Python offre lesdeuxtechniques.

    1.5 Algorithme et programme

    1.5.1 Dfinitions

    Dfinition Algorithme : ensemble des tapes permettant datteindre un but en rptant un nombrefini de fois un nombre fini dinstructions.

  • 5/26/2018 Cours Python 3

    17/155

    1.6. LES IMPLMENTATIONS DE PYTHON 5

    Un algorithme se termine en untemps fini.

    Dfinition

    Programme : un programme est latraduction dun algorithmeen un langage compilableou interprtable par un ordinateur.

    Il est souvent crit en plusieurs parties dont une quipilote les autres : le programme principal.

    1.5.2 La prsentation des programmes

    Un programmesourceest destin ltre humain. Pour en faciliter la lecture, il doit trejudicieusementcomment.

    La signification de parties non triviales (et uniquement celles-ci) doit tre explique paruncommentaire.Un commentaire commence par le caractre#et stend jusqu la fin 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 diffrents 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 Lan-

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

  • 5/26/2018 Cours Python 3

    18/155

    6 CHAPITRE 1. INTRODUCTION

  • 5/26/2018 Cours Python 3

    19/155

    Chapitre 2

    La calculatrice Python

    Comme tout langage, Python permet de manipuler des donnes grce un vo-cabulairede mots rservs et grce des types de donnes approximation desensembles de dfinition utiliss en mathmatique.

    Ce chapitre prsente les rgles de construction des identifiants, les types de don-nes simples (les conteneurs seront examins au chapitre 4) ainsi que les typeschane de caractres (Unicode et binaires).

    Enfin,last but not least, ce chapitre stend sur les notions non triviales de va-riables, de rfrences dobjet et daffectation.

    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 fichier grce un di-teur (on parle alors dun script Python) que lon excute par une commande ou parune touche du menu de lditeur ;

    soit on utilise un interprteur (par exemple IDLE) pour obtenir un rsultat immdiatgrce linterprteur Python embarqu dans IDLE qui excute la boucle dvaluation(cf. Fig.2.1)

    Figure 2.1 La boucle dvaluation de IDLE

  • 5/26/2018 Cours Python 3

    20/155

    8 CHAPITRE 2. LA CALCULATRICE PYTHON

    2.2 Identifiants et mots cls

    2.2.1 Identifiants

    Comme tout langage, Python utilise desidentifiantspour nommer ses objets.

    Dfinition

    Un identifiant Python est une suite non vide de caractres, de longueur quelconque,forme duncaractre de dbutet dezro ou plusieurscaractres de continuation.

    Sachant que : uncaractre de dbutpeut tre nimporte quelle lettre Unicode (cf. annexeBp.105),

    ainsi que le caractre soulign (_) ; uncaractre de continuationest un caractre de dbut, un chiffre ou un point.

    Attention

    Les identifiants 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 identifiants. Voici lestyle utilis dans ce document 1 :

    UPPERCASEouUPPER_CASEpour les constantes ; TitleCasepour les classes ; UneExceptionErrorpour les exceptions ; camelCasepour les fonctions, les mthodes et les interfaces graphiques ; unmodule_mpour les modules ; lowercaseoulower_casepour tous les autres identifiants.

    viter dutiliserl,OetIseuls (lminuscule,oetimajuscules).

    Enfin, on rservera les notations suivantes :

    _xxx # usage interne__xxx # attribut de classe

    __xxx__ # nom spcial rserv

    Exemples :

    NB_ITEMS = 12 # UPPER_CASE

    class MaClasse: pass # TitleCase

    def maFonction(): pass # camelCase

    mon_id = 5 # lower_case

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

  • 5/26/2018 Cours Python 3

    21/155

    2.3. NOTION DEXPRESSION 9

    2.2.3 Les mots rservs de Python 3

    La version 3.1.2 de Python compte 33 mots cls :

    and del from None True

    as elif global nonlocal tryassert else if not while

    break except import or with

    class False in pass yield

    continue finally is raise

    def for lambda return

    2.3 Notion dexpression

    Dfinition

    Une expression est une portion de code que linterprteur Python peut valuer pourobtenir une valeur.Les expressions peuvent tre simples ou complexes. Elles sont formes dune combinaisonde littraux, didentifiants 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 offre deux types entiers standard : intetbool.

    2.4.1 Le typeint

    Le typeintnest limit en taille que par la mmoire de la machine.

    Les entiers littraux sont dcimaux par dfaut, mais on peut aussi utiliser les bases sui-vantes (cf. p.111) :

    >>> 2009 # dcimal

    2009

    >>> 0b11111011001 # binaire

    2009

    >>> 0o3731 # octal

    2009

    >>> 0x7d9 # hexadecimal

    2009

  • 5/26/2018 Cours Python 3

    22/155

    10 CHAPITRE 2. LA CALCULATRICE PYTHON

    Oprations arithmtiques

    Les principales oprations :

    2 0 + 3 # 23

    2 0 - 3 # 17

    2 0 * 3 # 602 0 * * 3 # 8000

    2 0 / 3 # 6.666666666666667

    2 0 / / 3 # 6 (division entire)

    2 0 % 3 # 2 (modulo)

    abs(3 - 20) # valeur absolue

    Bien remarquer le rle des deux oprateurs de division :

    / : produit une division flottante ;

    //: produit une division entire.

    Bases usuelles

    Un entier crit en base 10 (par exemple 179) peut se reprsenter en binaire, octal ethexadcimal en utilisant les syntaxes suivantes :

    >>> 0b10110011 # binaire

    179

    >>> 0o263 # octal

    179

    >>> 0xB3 # hexadcimal

    179

    2.4.2 Le typebool

    Deux valeurs possibles :False,True. Oprateurs de comparaison :==, !=,>,>=, 24) # True (ds le premier membre)

    (9 > 24) and (3 == 3) # False (ds le premier membre)

    Les oprations logiques et de comparaisons sont values afin de donner des rsultatsboolens dansFalse,True.

  • 5/26/2018 Cours Python 3

    23/155

    2.5. LES TYPES DE DONNES FLOTTANTS 11

    Les expressions boolennes

    Une expression boolenne (cf. p.109) a deux valeurs possibles : FalseouTrue.

    Python attribue une expression boolenne la valeur Falsesi cest :

    la constanteFalse ; la constanteNone ; une squence ou une collection vide ; une donne numrique de valeur 0.

    Tout le reste vaut True.

    2.5 Les types de donnes flottants

    2.5.1 Le typefloat Unfloatest not avec un point dcimal ou en notation exponentielle :

    2.718

    .02

    3e8

    6.023e23

    Les flottants supportent les mmes oprations que les entiers. Lesfloatont une prcision finie indique dans sys.float_info.epsilon. Limport du modulemathautorise 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 typecomplex

    Les complexes sont crits en notation cartsienne forme de deux flottants.

    La partie imaginaire est suffixe parj: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 spcifique (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)

  • 5/26/2018 Cours Python 3

    24/155

    12 CHAPITRE 2. LA CALCULATRICE PYTHON

    2.6 Variables et affectation

    2.6.1 Les variables

    Ds que lon possde des types de donnes, on a besoin desvariablespour stocker les

    donnes.En ralit, Python noffre pas la notion de variable, mais plutt celle derfrence dobjet. Tantque lobjet nest pas modifiable (comme les entiers, les flottants, etc.), il ny a pas de diffrencenotable. On verra que la situation change dans le cas des objets modifiables...

    Dfinition

    Une variable est unidentifiantassoci une valeur.Informatiquement, cest unerfrence dobjetsitue une adresse mmoire.

    2.6.2 LaffectationDfinition

    Onaffecteune variable par une valeur en utilisant le signe=(quina rien voiraveclgalit en math !). Dans une affectation, le membre de gauchereoitle membre de droitece qui ncessite dvaluer la valeur correspondant au membre de droite avant de laffecter aumembre 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 (lavaleur antrieure est perdue) :

    a = a + 1 # 3 (incrmentation)

    a = a - 1 # 2 (dcrmentation)

    2.6.3 Affecter nest pas comparer !Laffectation a un effet (elle modifie 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 deffet (lautomateinterne reprsentant lvolution du programme nest pas modifi) :

    > > > x = ( a = = 3 ) + 2

    >>> x

    2

  • 5/26/2018 Cours Python 3

    25/155

    2.7. LES CHANES DE CARACTRES 13

    (a) Trois affectations (b) La donnecest supprime

    (c) La donneaest supprime

    Figure 2.2 Laffectation illustre.

    2.6.4 Les variantes de laffectation

    Outre laffectation 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 affectations (explications graphiques)

    Dans les schmas de la figure2.2, les cercles reprsentent les identificateurs alors que lesrectangles reprsentent les donnes.

    Les affectationsrelientles identificateurs aux donnes : si une donne en mmoire nestplus 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

    Dfinition

    Le type de donnesnon modifiable str reprsente une squence de caractres Uni-

  • 5/26/2018 Cours Python 3

    26/155

    14 CHAPITRE 2. LA CALCULATRICE PYTHON

    code.Non modifiablesignifie quune donne, une fois cre en mmoire, ne pourra plus tre chan-ge.

    Trois syntaxes de chanes sont disponibles.

    Remarquez que lon peut aussi utiliser le la place de , ce qui permet dinclure une notationdans 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

    s 3 = s 1 + s 2 # abcdefg

    Rptition :s4 = Fi!

    s 5 = s 4 * 3 # Fi! Fi! Fi!

    print(s5)

    2.7.3 Les chanes de caractres : fonctions vsmthodes

    On peut agir sur une chane (et plus gnralement sur une squence) en utilisant desfonctions (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 lanotation pointeentre 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 chanech

    Les mthodes suivantes sont valeur boolenne, cest--dire quelles retournent la valeurTrueouFalse.

  • 5/26/2018 Cours Python 3

    27/155

    2.7. LES CHANES DE CARACTRES 15

    La notation[xxx] indique un lment optionnel que lon peut donc omettre lors de lutilisationde la mthode.

    isupper()et islower(): retournent Truesi chne contient respectivementque des majuscules/minuscules :

    print(cHAise basSe.isupper()) # False

    istitle(): retourneTruesi seule la premire lettre de chaque mot de chest enmajuscule :

    print(Chaise Basse.istitle()) # True

    isalnum(), isalpha(), isdigit() et isspace() : retournent True sich 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 dfinie par startet stopcom-mence respectivement parprefixou finit 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 respecti-vement une chane en minuscule, en majuscule, en minuscule commenant par unemajuscule, 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 tabsizeespaces (8par dfaut).

    center(width[, fillchar]),ljust(width[, fillchar])etrjust(width[, fillchar]): retournent respectivement une chane centre,justifie gauche ou droite, complte par le caractrefillchar(ou par lespacepar dfaut) :

    print(s.center(20, -)) # ----cHAise basSe----

    print(s.rjust(20, @)) # @@@@@@@@cHAise basSe

    zfill(width) : complte ch gauche avec des 0jusqu une longueur maximaledewidth:

    print(s.zfill(20)) # 00000000cHAise basSe

    strip([chars]), lstrip([chars]) et rstrip([chars]) : supprimenttoutes les combinaisons de chars(ou lespace par dfaut) respectivement au dbutet en fin, au dbut, ou en fin dune chane :

  • 5/26/2018 Cours Python 3

    28/155

    16 CHAPITRE 2. LA CALCULATRICE PYTHON

    print(s.strip(ce)) # HAise basS

    find(sub[, start[, stop]]): renvoie lindex de la chane subdans lasous-chane start stop, sinon renvoie -1. rfind() effectue le mme travail encommenant par la fin.index()etrindex()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 countinstances (toutes pardfaut) deoldparnew:

    print(s.replace(HA, ha)) # chaise basSe

    split(seps[, maxsplit]): dcoupe la chane en maxsplit morceaux(tous par dfaut). rsplit()effectue la mme chose en commenant par la fin etstriplines()effectue ce travail avec les caractres de fin de ligne :

    print(s.split()) # [cHAise, basSe]

    join(seq): concatne les chanes du conteneur seqen intercalant la chane surlaquelle 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 signqui commence 0indique la position dun caractre :

    s = Rayon X # len(s) ==> 7

    print(s[0]) # Rprint(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 sous-chanes (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)

  • 5/26/2018 Cours Python 3

    29/155

    2.8. LES DONNES BINAIRES 17

    Figure 2.4 Extraction de sous-chanes.

    s[:3] # Ray (du dbut lindex 3 non compris)

    s[3:] # on X (de lindex 3 compris la fin)

    s[::2] # 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 modifiable) et byte-array(modifiable).

    Une donne binaire contient une suite de zro ou plusieurs octets, cest--dire dentiersnon signs sur 8 bits (compris dans lintervalle [0...255]). Ces types la C sont bienadapts pour stocker de grandes quantits de donnes. De plus Python fournit des moyens

    de manipulation efficaces de ces types.Les deux types sont assez semblables au type stret possdent la plupart de ses m-

    thodes. Le type modifiablebytearraypossde 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 diffrencier 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 saisirouentrerdes in-

  • 5/26/2018 Cours Python 3

    30/155

    18 CHAPITRE 2. LA CALCULATRICE PYTHON

    Figure 2.5 Codes, glyphes, caractres et octets.

    formations, ce qui est gnralement fait depuis une lectureau clavier. Inversement, on doitpouvoirafficherousortirdes informations, ce qui correspond gnralement une crituresur lcran.

    Figure 2.6 Les entres-sorties.

    2.9.1 Les entres

    Il sagit de raliser une saisie lcran : la fonction standard input() interrompt leprogramme, afficher une ventuelle invite et attend que lutilisateur entre une donne et lavalide par Entre.

    La fonction standard input()effectue toujours une saisie enmode texte(la saisie estune chane) dont on peut ensuite changer le type (on dit aussitranstyper) :

    nb_etudiant = input(Entrez le nombre dtudiants : )

    print(type(nb_etudiant)) # (cest une chane)

  • 5/26/2018 Cours Python 3

    31/155

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

    2.9.2 Les sorties

    En mode calculatrice , Python lit-value-affiche, mais la fonctionprint()reste in-dispensable aux affichages 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 diffrenceprint(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 cas !, sep=###)

    # On a cas !

    2.9.3 Les squences dchappement

    lintrieur dune chane, le caractre antislash (\) permet de donner une significationspciale certaines squences :

    Squence Signification

    \saut_ligne saut de ligne ignor\\ affiche 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 :

  • 5/26/2018 Cours Python 3

    32/155

    20 CHAPITRE 2. LA CALCULATRICE PYTHON

    Figure 2.7 Utilisation des squences dchappement

  • 5/26/2018 Cours Python 3

    33/155

    Chapitre 3

    Le contrle du flux dinstructions

    Un script Python est form dune suite dinstructions excutes en squence dehaut en bas.

    Chaque ligne dinstructions est forme dune ou plusieurs lignes physiques quipeuvent tre continues par un antislash \ ou un caractre ouvrant [({ pas encoreferm.

    Cette excution en squence peut tre modifie pour choisirourpterdes por-tions de code. Cest lobjet principal de ce chapitre.

    3.1 Les instructions composes

    Syntaxe

    Une instruction compose se compose : dune ligne den-tte termine pardeux-points ; dun bloc dinstructions indentpar rapport la ligne den-tte.

    Attention

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

  • 5/26/2018 Cours Python 3

    34/155

    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)

  • 5/26/2018 Cours Python 3

    35/155

    3.3. BOUCLER 23

    elif x % 2 :

    print(x est positif et impair)

    else:

    print(x nest pas ngatif et est pair)

    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 loprateurternaire (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 : lasaisie filtredune valeur numrique (on doitprciser le typecarinput()saisit une chane) :

    n = int(input(Entrez un entier [1 .. 10] : ))

    while not(1

  • 5/26/2018 Cours Python 3

    36/155

    24 CHAPITRE 3. LE CONTRLE DU FLUX DINSTRUCTIONS

    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 boucleforouwhileen 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 conte-nant 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 boucleswhileet forpeuvent possder une clause elsequi ne sexcute que sila 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. : ))

  • 5/26/2018 Cours Python 3

    37/155

    3.4. RUPTURES DE SQUENCES 25

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

    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 ExceptionsAfin de rendre les applications plus robustes, il est ncessaire de grer leserreurs dexcution

    des parties sensibles du code.

    Le mcanisme desexceptionsspare dun ct la squence dinstructions excuterlorsque tout se passe bien et, dun autre ct, une ou plusieurs squences dinstructions excuter en cas derreur.

    Lorsquune erreur survient, unobjet exceptionest pass au mnanisme de propagationdes exceptions, et lexcution est transfre la squence de traitementad hoc.

    Le mcanisme seffectue en deux phases : lalevedexception lors de la dtection derreur ; letraitementappropri.

    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

  • 5/26/2018 Cours Python 3

    38/155

    26 CHAPITRE 3. LE CONTRLE DU FLUX DINSTRUCTIONS

    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 classeException. La hirarchie des sous-classes offre une vingtaine dexceptions standard 1.

    Syntaxe complte dune exception :

    try:

    ... # squence normale dexcution

    except as e1:

    ... # traitement de lexception 1

    except as e2:

    ... # traitement de lexception 2

    ...

    else:

    ... # clause excute en labsence derreur

    finally:

    ... # clause toujours excute

    Linstruction raisepermet de levervolontairementune exception :

    x = 2

    if not(0

  • 5/26/2018 Cours Python 3

    39/155

    Chapitre 4

    Les conteneurs standard

    Le chapitre 2 a prsent les types de donnes simples, mais Python offre beaucoupplus : les conteneurs.De faon gnrale, un conteneur est un objet composite destin contenir dautresobjets. Ce chapitre dtaille les squences, les tableaux associatifs, les ensembleset les fichiers textuels.

    4.1 Les squences

    4.1.1 Quest-ce quune squence ?

    Dfinition

    Une squence est un conteneurordonndlmentsindexs par des entiers.

    Python dispose de trois types prdfinis de squences : les chanes (vues prcdemment) ; les listes ;

    les tuples1

    .

    4.2 Les listes

    4.2.1 Dfinition, syntaxe et exemples

    Dfinition

    Collection ordonne et modifiable 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.

  • 5/26/2018 Cours Python 3

    40/155

    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 modification des listes :

    nombres = [17, 38, 10, 25, 72]

    nombres.sort()

    print(nombres) # [10, 17, 25, 38, 72]

    nombres.append(12)

    nombres.reverse()

    nombres.remove(38)

    print(nombres) # [12, 72, 25, 17, 10]print(nombres.index(17)) # 3

    nombres[0] = 11

    nombres[1:3] = [14, 17, 2]

    print(nombres.pop()) # 10

    print(nombres) # [11, 14, 17, 2, 17]

    print(nombres.count(17)) # 2

    nombres.extend([1, 2, 3])

    print(nombres) # [11, 14, 17, 2, 17, 1, 2, 3]

    4.2.4 Manipulation des tranches

    Syntaxe

    Si on veut supprimer, remplacer ou insrerplusieurs lments dune liste, il faut indiquer

  • 5/26/2018 Cours Python 3

    41/155

    4.3. LES LISTES EN INTENSION 29

    une tranche dans le membre de gauche dune affectation et fournir une liste dans le membrede 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

    Uneliste en intensionest une expression qui permet de gnrer une liste de manire trscompacte. Cette notation reprend la dfinition mathmatique dunensemble en intension:

    {x2|x [2, 10]} [x**2 for x in range(2, 11)]

    Dfinition

    Une liste en intension est quivalente une boucle forqui construirait la mme listeen utilisant la mthodeappend().

    Les listes en intension sont utilisables sous trois formes.

    Premire formeexpression 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 formeexpression dune liste de valeurs avec filtrage :

    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 formeexpression 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 trspythoniques:

    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]

  • 5/26/2018 Cours Python 3

    42/155

    30 CHAPITRE 4. LES CONTENEURS STANDARD

    # 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

    Dfinition

    Collection ordonne et non modifiable 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 dfinir des constantes.

    Attention

    Comme les chanes de caractres, les tuples ne sont pas modifiables !

    4.5 Retour sur les rfrences

    Nous avons dj vu que lopration daffectation, apparemment innocente, est une relledifficult de Python.

    i = 1

    msg = Quoi de neuf ?

    e = 2.718

    Dans lexemple ci-dessus, les affectations ralisent plusieurs oprations :

    cre en mmoire un objet du typead 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 modifiable est affect, tout chan-

    gement sur un objet modifiera lautre :

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

    phrase = fable

    phrase[4] = casse

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

  • 5/26/2018 Cours Python 3

    43/155

    4.6. LES TABLEAUX ASSOCIATIFS 31

    (a) Assignation dun entier (b) Addition intermdiaire

    (c) Assignation augmente

    Figure 4.1 Assignation augmente dun objet non modifiable.

    Si lon dsire raliser unevraiecopie 1 dun objet, on doit utiliser le modulecopy:

    import copy

    a = [1, 2, 3]

    b = a # une rfrence

    b.append(4)

    print(a) # [1, 2, 3, 4]

    c = copy.copy(a) # une copie de surface

    c.append(5)

    print(c) # [1, 2, 3, 4, 5]

    print(a) # [1, 2, 3, 4]

    Dans les rares occasions o lon veut aussi que chaque lment et attribut de lobjet soitcopi sparment et de faon rcursive, on emploie la fonction copy.deepcopy().

    Complment graphique sur lassignation

    Assignation augmente dun objet non modifiable (cas dun entier : Fig.4.1).On a reprsent ltape de laddition intermdiaire :Assignation augmente dun objet modifiable (cas dune liste : Fig.4.2) :On a reprsent ltape de la cration de la liste intermdiaire :

    4.6 Les tableaux associatifs4.6.1 Les types tableaux associatifs

    Dfinition

    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 prsentequune 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 crirel2 = l[ :]

  • 5/26/2018 Cours Python 3

    44/155

    32 CHAPITRE 4. LES CONTENEURS STANDARD

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

    (c) Assignation augmente

    Figure 4.2 Assignation augmente dun objet modifiable.

    il estitrable(on peut le parcourir) maisnest pas ordonn.

    Python propose le type standarddict.

    4.6.2 Les dictionnaires (dict)

    Syntaxe

    Collection de couplescle : valeurentoure daccolades.

    Les dictionnaires constituent un type composite mais ils nappartiennent pas aux s-quences.

    Comme les listes, les dictionnaires sont modifiables, mais lescouples enregistrs noccupentpas un ordre immuable, leur emplacement est gr par un algorithme spcifique (Cf. les fonc-tions de hachage p.113).

    Uneclpourra tre alphabtique, numrique... en fait tout type hachable. Les valeurspourront tre des valeurs numriques, des squences, des dictionnaires, mais aussi des fonc-tions, des classes ou des instances.

    Exemples de cration

    # insertion de cls/valeurs une une

    d1 = {} # dictionnaire vided1[nom] = 3

    d1[taille] = 176

    print(d1) # {nom: 3, taille: 176}

    # dfinition en extension

    d 2 = {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}

  • 5/26/2018 Cours Python 3

    45/155

    4.7. LES ENSEMBLES (SET) 33

    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

    4.7 Les ensembles (set)

    Dfinition

    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 in X) # True

    print(a in Y) # False

    print(X - Y) # {a, c}

    print(Y - X) # {s}

    print(X | Y) # {a, c, b, d, s}

    print(X & Y) # {b, d}

    4.8 Les fichiers textuels

    4.8.1 Les fichiers : introduction

    On rappelle que lordinateur nexcute que les programmes prsents dans sa mmoirevolatile (la RAM).

  • 5/26/2018 Cours Python 3

    46/155

    34 CHAPITRE 4. LES CONTENEURS STANDARD

    Mais, pour conserver durablement des informations, il faut utiliser une mmoire perma-nente comme par exemple le dique dur, la cl USB, le DVD,...

    Comme la plupart des langages, Python utilise classiquement la notion defichier. Cestun type pr-dfini en Python, qui ne nesscite donc pas dimporter de module externe.

    Nous nous limiterons aux fichierstextuels(portables, lisible par un diteur), mais signa-lons que les fichiers stocks en codage binairesont plus compacts et plus rapides grer.

    4.8.2 Gestion des fichiers

    Ouverture et fermeture des fichiers

    Principauxmodesdouverture des fichiers 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 fichiers en modetextepar dfaut (nott) (pour les fichiersbinaires, ilfaut prciser le modeb).

    Le paramtre optionnel encoding assure les conversions entre les types byte etstr 1. Les encodages les plus frqents sont utf-8 (cest lencodage privilgier enPython 3),latin1,ascii...

    Tant que le fichier 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 printf2 = open(truc2.txt, w)

    print(abcd, file=f2)

    f2.close()

    Lecture squentielle

    Mthodes de lecture :

    f = open(truc.txt, r)

    s = f.read() # lit tout le fichier --> string

    s = f.read(3) # lit au plus n octets --> string

    s = f.readline() # lit la ligne suivante --> string

    1. Cf. lannexeB

  • 5/26/2018 Cours Python 3

    47/155

    4.9. ITRER SUR LES CONTENEURS 35

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

    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 Laffichage format

    La mthodeformat()permet de contrler finement toutes sortes daffichages.

    Remplacements simples :

    print({} {} {}.format(zro, un, deux)) # zro un deux

    print({2} {0} {1}.format(zro, un, deux)) # deux zro un

  • 5/26/2018 Cours Python 3

    48/155

    36 CHAPITRE 4. LES CONTENEURS STANDARD

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

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

  • 5/26/2018 Cours Python 3

    49/155

    4.10. LAFFICHAGE FORMAT 37

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

  • 5/26/2018 Cours Python 3

    50/155

    38 CHAPITRE 4. LES CONTENEURS STANDARD

  • 5/26/2018 Cours Python 3

    51/155

    Chapitre 5

    Fonctions et espaces de noms

    Remarque

    Les fonctions sont les lments structurants de base de tout langage proc-dural.

    Elles offrent diffrents avantages :

    vite la rptition : on peut factoriser une portion de code qui se rpte lorsde 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 : conception delapplication.

    Ces avantages sont illustrs sur la figure5.1.

    5.1 Dfinition et syntaxe

    Dfinition Ensemble dinstructions regroupes sous unnomet sexcutant la demande.

    On doit dfinir une fonction chaque fois quun bloc dinstructions se trouve plusieursreprises dans le code ; il sagit dune mise en facteur commun .

    Syntaxe

    Cest une instruction compose :

    def nomFonction(paramtres):

    Documentation de la fonction.

    Le bloc dinstructions estobligatoire. Sil est vide, on emploie linstruction pass. Ladocumentation (facultative) estfortementconseille.

  • 5/26/2018 Cours Python 3

    52/155

    40 CHAPITRE 5. FONCTIONS ET ESPACES DE NOMS

    (a) vite la duplication de code.

    (b) Met en reliefentresetsorties.

    (c) Limportpermet la rutilisation.

    (d) Amliore la conception.

    Figure 5.1 Les avantages de lutilisation des fonctions

  • 5/26/2018 Cours Python 3

    53/155

    5.2. PASSAGE DES ARGUMENTS 41

    5.2 Passage des arguments

    5.2.1 Mcanisme gnral

    Remarque

    Passage par affectation : chaque argument de la dfinition de la fonction correspond, danslordre, un paramtre de lappel. La correspondance se fait paraffectation.

    Figure 5.2 Passage des arguments par affectation.

    5.2.2 Un ou plusieurs paramtres, pas de retourExemple sans linstructionreturn, ce quon appelle souvent une procdure. Dans

    ce cas la fonction renvoie implicitement la valeurNone:

    def table(base, debut, fin):

    Affiche la table des de .

    n = debut

    while n

  • 5/26/2018 Cours Python 3

    54/155

    42 CHAPITRE 5. FONCTIONS ET ESPACES DE NOMS

    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 returnmultiple :

    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 .

    On doit avoir (borneInf < borneSup) et (nbPas > 0)

    h, x = (borneSup - borneInf) / float(nbPas), borneInf

    while x

  • 5/26/2018 Cours Python 3

    55/155

    5.2. PASSAGE DES ARGUMENTS 43

    initPort(2400, paire, 7, 2)

    # Init. 2400 bits/s parit : paire

    # 7 bits de donnes 2 bits darrt

    5.2.6 Nombre darguments arbitraire : passage dun tupledef somme(*args):

    Renvoie la somme de .

    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 dernireposition.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 dictionnairedef 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 dernireposition (aprs un ventuel tuple).

  • 5/26/2018 Cours Python 3

    56/155

    44 CHAPITRE 5. FONCTIONS ET ESPACES DE NOMS

    5.3 Espaces de noms

    5.3.1 Porte des objets

    Remarque

    Porte : les noms des objets sont crs lors de leur premire affectation, mais ne sontvisibles que dans certaines rgions de la mmoire.

    On distingue :

    La porte globale : celle du module __main__. Un dictionnaire gre les objets globaux :linstructionglobals()fournit les couplesvariable :valeur ;

    La porte locale : les objets internes aux fonctions (et aux classes) sont locaux. Les objetsglobaux ne sont pas modifiablesdans les portes locales. Linstruction locals()fournit les couplesvariable :valeur.

    5.3.2 Rsolution des noms : rgle LGILa recherche des noms est dabord locale (L), puis globale (G), enfin 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 = 9 9

  • 5/26/2018 Cours Python 3

    57/155

    5.3. ESPACES DE NOMS 45

    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 = 9 9

    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 = 9 9

    print(fonc(1)) # 4

  • 5/26/2018 Cours Python 3

    58/155

    46 CHAPITRE 5. FONCTIONS ET ESPACES DE NOMS

  • 5/26/2018 Cours Python 3

    59/155

    Chapitre 6

    Modules et packages

    Un programme Python est gnralement compos de plusieurs fichiers sources,appelsmodules. Leur nom est suffix .py.

    Sils sont correctement cods les modules doivent tre indpendants les uns desautres 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 depackagequi permet de grouper plusieursmodules.

    6.1 Modules

    Dfinition

    Module : fichierindpendantpermettant de scinder un programme en plusieurs scripts.Ce mcanisme permet dlaborer efficacement 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 commandeimport importe la totalit des objets du module :

    import tkinter

    la commande from import obj1, obj2...nimporteque les objetsobj1, obj2...du module :

    from math import pi, sin, log

  • 5/26/2018 Cours Python 3

    60/155

    48 CHAPITRE 6. MODULES ET PACKAGES

    Il est conseill dimporter dans lordre : les modules de la bibliothque standard ; les modules des bibliothques tierces ; Les modules personnels.

    6.1.2 Exemples

    Notion d auto-test

    Un modulecube_m.py. Remarquez lutilisation de lauto-test qui permet de testerle module seul :

    def cube(y):

    Calcule le cube du paramtre .

    return y**3

    # Auto-test ----------------------------------------------------

    if __name__ == __main__: # False lors dun import ==> ignorhelp(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 fichier 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 dafficher des courbes. La fonction suivante est uneinterface dappel qui permet dafficher des donnes issues de fichiers :

    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

  • 5/26/2018 Cours Python 3

    61/155

    6.2. BIBLIOTHQUE STANDARD 49

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

    6.2 Bibliothque standard

    6.2.1 La bibliothque standard

    On dit souvent que Python est livr piles comprises (batteries included) tant sa biblio-thque standard, riche de plus de 200 packages et modules, rpond aux problmes courantsles plus varis.

    Ce survol prsente quelques fonctionnalits utiles.

    La gestion des chanes

    Le modulestringfournit des constantes comme ascii_lowercase,digits...et la classe Formatter qui peut tre spcialise en sous-classes spcialises deformateursde chanes.

    Le module textwrapest utilis pour formater un texte : longueur de chaque ligne,contrle de lindentation.

    Le module structpermet de convertir des nombres, boolens et des chanes en leurreprsentation binaire afin de communiquer avec des bibliothques de bas-niveau (souventen C).

    Le module difflib permet la comparaison de squences et fournit des sorties au for-mat standard diff ou en HTML.

    Enfin on ne peut oublier le module re qui offre Python la puissance des expressionsrgulires.

    Exemple : le moduleio.StringIO

    Ce module fournit des objets compatibles avec linterface des objets fichiers.

    Exemple de gestion ligne ligne dun fichier 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)

  • 5/26/2018 Cours Python 3

    62/155

    50 CHAPITRE 6. MODULES ET PACKAGES

    La gestion de la ligne de commande

    La gestion est assure par deux modules : getopt, le module historique hrit du C etoptparse, 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=verbos