Courspython3 1-6 PDF

Bob CORDEAU &
Laurent POINTAL

Une introduction Python 3
version 1.6
Bob CORDEAU
Laurent POINTAL
UNE INTRODUCTION

PYTHON 3
version 1.6
En se partageant le savoir ne se divise pas,
il se multiplie.
Remerciements
Meici Taiek Zi~u poui les empiunts ses publications, en paiticuliei nous iemei-
cions les ditions Eyrolles poui leui aimable autoiisation de publiei le dialogue de la
page 88 et les ditions Dunod poui leui aimable autoiisation de publiei les exemples des
pages 80, 81 et 84.
Giand meici Hlene Covur~U poui ses illustiations , les aventuies de Steeven le
Python enchantent les ttes de paiagiaphe.
Meici Ccile Tvrvi~N poui son aide la tiaduction du Zen de Python.
Une pense spciale poui Stphane B~v1uo1 son enseignement didactique aupies des
tudiants et son engagement enveis ses collegues ne seiont pas oublis.
Enn il faudiait saluei tous les auteuis butins sui lnteinet
Table des matires
1 Introduction 1
1.1 Piincipales caiactiistiques du langage Python . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Matiiel et logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2.1 Loidinateui . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2.2 Deux soites de piogiammes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 Les langages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3.1 Des langages de diients niveaux . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3.2 Bief histoiique des langages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Pioduction des piogiammes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4.1 Deux techniques de pioduction des piogiammes . . . . . . . . . . . . . . . . . . . 3
1.4.2 Technique de pioduction de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4.3 La constiuction des piogiammes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1. Algoiithme et piogiamme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1..1 Dnitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1..2 La pisentation des piogiammes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1. Les implmentations de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2 La calculatrice Python 5
2.1 Les modes dexcution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.1.1 Les deux modes dexcution dun code Python . . . . . . . . . . . . . . . . . . . . .
2.2 ldenticateuis et mots cls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.1 ldenticateuis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.2 Style de nommage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.3 Les mots iseivs de Python 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3 Notion dexpiession . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.4 Les types de donnes entieis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.4.1 Le type int . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.4.2 Le type bool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2. Les types de donnes ouants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2..1 Le type float . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2..2 Le type complex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2. Vaiiables et aectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2..1 Les vaiiables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2..2 Laectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2..3 Aectei nest pas compaiei ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2..4 Les vaiiantes de laectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.. Les aectations (explications giaphiques) . . . . . . . . . . . . . . . . . . . . . . . 10
2. Les chaines de caiacteies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2..1 Les chaines de caiacteies pisentation . . . . . . . . . . . . . . . . . . . . . . . . 11
2..2 Les chaines de caiacteies opiations . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2..3 Les chaines de caiacteies fonctions vs mthodes . . . . . . . . . . . . . . . . . . . 12
2..4 Mthodes de test de ltat dune chaine . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.. Mthodes ietouinant une nouvelle chaine . . . . . . . . . . . . . . . . . . . . . . . 13
2.. Les chaines de caiacteies indexation simple . . . . . . . . . . . . . . . . . . . . . 13
2.. Extiaction de sous-chaines (ou tianches ) . . . . . . . . . . . . . . . . . . . . . . 14
2.8 Les donnes binaiies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.9 Les enties-soities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
v
vi TABLE DES MATIRES
2.9.1 Les enties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
2.9.2 Les soities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
2.9.3 Les squences dchappement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
3 Le contrle du ux dinstructions 17
3.1 Les instiuctions composes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
3.2 Choisii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2.1 Choisii if - [elif] - [else] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2.2 Syntaxe compacte dune alteinative . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.3 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.3.1 Rptei while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.3.2 Paicouiii for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.4 Ruptuies de squences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.4.1 lnteiiompie une boucle break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.4.2 Couit-ciicuitei une boucle continue . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.4.3 Utilisation avance des boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.4.4 Tiaitement des eiieuis les exceptions . . . . . . . . . . . . . . . . . . . . . . . . 21
4 Les conteneurs standard 23
4.1 Les squences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.1.1 Qest-ce quune squence ` . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.2 Les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.2.1 Dnition, syntaxe et exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.2.2 lnitialisations et tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.2.3 Mthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.2.4 Manipulation des tianches (ou sous-chaines) . . . . . . . . . . . . . . . . . . . 24
4.2. Des squences de squences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
4.3 Les tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
4.4 Retoui sui les ifiences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
4.4.1 Complment giaphique sui lassignation . . . . . . . . . . . . . . . . . . . . . . . . 2
4. Les tableaux associatifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
4..1 Les types tableaux associatifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
4..2 Les dictionnaiies (dict) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
4. Les ensembles (set) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4. Les chieis textuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4..1 Les chieis intioduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4..2 Gestion des chieis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.8 ltiei sui les conteneuis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.9 Lachage foimat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5 Fonctions et espaces de noms 33
.1 Dnition et syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
.2 Passage des aiguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
.2.1 Mcanisme gnial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
.2.2 Un ou plusieuis paiameties, pas de ietoui . . . . . . . . . . . . . . . . . . . . . . . 3
.2.3 Un ou plusieuis paiameties, utilisation du ietoui . . . . . . . . . . . . . . . . . . . 3
.2.4 Passage dune fonction en paiametie . . . . . . . . . . . . . . . . . . . . . . . . . . 3
.2. Paiameties avec valeui pai dfaut . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
.2. Nombie daiguments aibitiaiie passage dun tuple de valeuis . . . . . . . . . . . . 3
.2. Nombie daiguments aibitiaiie passage dun dictionnaiie . . . . . . . . . . . . . . 3
.3 Espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
.3.1 Poite des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
.3.2 Rsolution des noms iegle LGI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
TABLE DES MATIRES vii
6 Modules et paages 39
.1 Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
.1.1 lmpoit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
.1.2 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
.2 Bibliotheque standaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
.2.1 La bibliotheque standaid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
.3 Bibliotheques tieices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
.3.1 Une giande diveisit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
.3.2 Un exemple la bibliotheque Unum . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
.4 Paquets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
7 La programmation Oriente Objet 47
.1 Teiminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
.1.1 Notations UML de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
.2 Classes et instanciation dobjets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
.2.1 Linstiuction class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
.2.2 Linstanciation et ses auiibuts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
.2.3 Retoui sui les espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
.3 Mthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0
.4 Mthodes spciales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0
.4.1 Linitialisateui . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0
.4.2 Suichaige des opiateuis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 0
.4.3 Exemple de suichaige . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
. Hiitage et polymoiphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
..1 Hiitage et polymoiphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
..2 Exemple dhiitage et de polymoiphisme . . . . . . . . . . . . . . . . . . . . . . . . 2
. Notion de conception oiiente objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
..1 Association . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
..2 Diivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
. Un exemple complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
8 La programmation oriente objet graphique 57
8.1 Piogiammes pilots pai des vnements . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.2 La bibliotheque tkinter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
8.2.1 Pisentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
8.2.2 Les widgets de tkinter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
8.2.3 Le positionnement des widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
8.3 Deux exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
8.3.1 tkPhone, un exemple sans menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
8.3.2 IDLE, un exemple avec menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
9 Teniques avances 65
9.1 Techniques piocduiales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1.1 Le pouvoii de lintiospection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1.2 Gestionnaiie de contexte (ou bloc gaid) . . . . . . . . . . . . . . . . . . . . . . .
9.1.3 Utilisei un dictionnaiie poui lancei des fonctions ou des mthodes . . . . . . . . .
9.1.4 Les fonctions icuisives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
9.1. Les listes dnies en compihension . . . . . . . . . . . . . . . . . . . . . . . . . . 9
9.1. Les dictionnaiies dnis en compihension . . . . . . . . . . . . . . . . . . . . . . 0
9.1. Les ensembles dnis en compihension . . . . . . . . . . . . . . . . . . . . . . . . 0
9.1.8 Les gniateuis et les expiessions gniatiices . . . . . . . . . . . . . . . . . . . . 0
9.1.9 Les fonctions incluses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
9.1.10 Les dcoiateuis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
9.2 Techniques objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
9.2.1 lunctoi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
9.2.2 Les accesseuis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
9.2.3 Le duck typing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.3 Techniques fonctionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.3.1 Diiective lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
viii TABLE DES MATIRES
9.3.2 Les fonctions map, filter et reduce . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
9.3.3 Les applications paitielles de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . 8
9.4 Les tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
9.4.1 Tests unitaiies et tests fonctionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
9.4.2 Module unittest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
9. La documentation des souices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
9..1 Le foimat ieST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
9..2 Le module doctest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
9..3 Le dveloppement diiig pai la documentation . . . . . . . . . . . . . . . . . . . . 84
A Interlude 87
B Passer du problme au programme 91
C Jeux de caractres et encodage 93
D Les bases arithmtiques 95
E Exercices corrigs 97
F Glossaire 107
Webographie 115
Bibliographie 116
Memento Python 3 118
Index 120
Avant-propos
qui sadresse ce cours ?
Utilis loiigine pai les tudiants de Mesuies Physiques de llUT dOisay, ce couis sadiesse plus
gnialement toute peisonne dsiieuse dappiendie Python en tant que piemiei langage de piogiam-
mation.
Cette introduction reposent sur quelques partis pris :
le choix du langage Python veision 3. La veision actuelle abolit la compatibilit descendante
1
dans
le but dliminei les faiblesses oiiginelles du langage ,
le choix de logiciels libies ou giatuits
des diteuis spcialiss comme ipython, spydei ou Wingwaie,
des outils open source de pioduction de documents L
A
T
E
X
2
, lnkscape.
et sui labondance des iessouices et de la documentation sui le Web '
Version 1.6 ?
Suivant lexemple de Donald KNU1u, linventeui du logiciel de composition T
E
X, le numio de veision
de ce document, au lieu dtie 1 , est la 1
ie
dcimale dun nombie clebie
3
.
Pour joindre les auteurs :
k bob.cordeau@laposte.net
k laurent.pointal@limsi.fr
Sauf mention contiaiie, le contenu de cet ouviage est publi sous la licence
Cieative Commons BY-NC-SA-3.0
La copie de cet ouviage est autoiise sous iseive du iespect des conditions de la licence
creativecommons.org/licenses/by/3.0/fr/
1. Cest une giave dcision, muiement ichie Un langage qui bouge peu peimet une industiie qui bouge beaucoup (Bei-
tiand Mrvrv). avec la siie des veisions 2.x
2. dans la distiibution T
E
XLive associ lditeui Kile poui GNU/Linux et la distiibution MikT
E
Xassoci lditeui T
E
XnicCentei
poui Windows.
3. =
1+
5
2
, le nombie doi.
Cu~vi1vr 1
Introduction linformatique
Ce piemiei chapitie intioduit les giandes caiactiistiques du langage Python, ieplace Py-
thon dans lhistoiie des langages infoimatiques, donne les paiticulaiits de pioduction des
piogiammes, dni la notion si impoitante dalgoiithme et conclut sui les diveis implmen-
tations disponibles.
1.1 Principales caractristiques du langage Python
Historique
1991 Guido van RossUx tiavaille aux Pays-Bas au CWl
1
sui le piojet AMOEBA (un systeme
dexploitation distiibu). ll conoit Python ( paitii du langage ABC) et publie la veision 0.9.0 sui
un foium Usenet
199 soitie de Numerical Python
2001 naissance de la PSl (Python Sofwaie lundation)
Les veisions se succedent. . . Un giand choix de modules disponibles, des colloques annuels sont
oiganiss, Python est enseign dans plusieuis univeisits et est utilis en entiepiise. . .
lin 2008 soities simultanes de Python 2. et de Python 3.0
2013 veisions en couis v2..3 et v3.3.0
Langage Open Source
Licence Open Souice CNRl, compatible GPL, mais sans la iestiiction copyle. Python est libie et
giatuit mme poui les usages commeiciaux
GvR (Guido van RossUx) est le BDlL (dictateui bnvole vie ')
lmpoitante communaut de dveloppeuis
Nombieux outils standaid disponibles Baeries included
Travail interactif
Nombieux inteipiteuis inteiactifs disponibles
lmpoitantes documentations en ligne
Dveloppement iapide et incimentiel
Tests et dbogage outills
Analyse inteiactive de donnes
Langage interprt rapide
lnteipitation du bytecode compil
De nombieux modules sont disponibles paitii de bibliotheques optimises (souvent ciites en
C ou C)
Simplicit du langage (cf. Zen of Python, annexe A, p. 8)
Syntaxe claiie et cohiente
lndentation signicative
Gestion automatique de la mmoiie (garbage collector)
Typage dynamique foit pas de dclaiation
1. Centium vooi Wiskunde en linfoimatica.
2 Introduction
Orientation objet
Modele objet puissant mais pas obligatoiie
Stiuctuiation multichiei ties 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
tiaits comme tous les auties (on peut les aectei, les passei en paiametie)
Ouverture au monde
lnteifaable avec C/C/lORTRAN
Langage de sciipt de plusieuis applications impoitantes
Excellente poitabilit
Disponibilit de bibliothques
Plusieuis millieis de packages sont disponibles dans tous les domaines
Remarque
Point foit de Python la lisibilit. Python est un langage algoiithmique excutable .

1.2 Environnements matriel et logiciel
1.2.1 Lordinateur
On peut simpliei la dnition de loidinateui de la faon suivante
Dnition
b
Oidinateui automate dteiministe composants lectioniques.
Loidinateui compiend entie auties
un miciopiocesseui avec une UC (Unit de Contiole), une UAL (Unit Aiithmtique et Logique),
une hoiloge, une mmoiie cache iapide ,
de la mmoiie volatile (dite vive ou RAM), contenant les instiuctions et les donnes ncessaiies
lexcution des piogiammes. La RAM est foime de cellules binaiies (bits) oiganises en mots de 8
bits (octets) ,
des piiphiiques enties/soities, mmoiies peimanentes (dites mortes disque dui, cl USB, CD-
ROM. . .), iseau. . .
1.2.2 Deux sortes de programmes
On distingue, poui faiie iapide
Le systeme dexploitation ensemble des piogiammes qui geient les iessouices matiielles et logi-
cielles. ll piopose une aide au dialogue entie lutilisateui et loidinateui linteiface textuelle (intei-
piteui de commande) ou giaphique (gestionnaiie de fenties). ll est souvent multitache et paifois
multiutilisateui ,
les piogiammes applicatifs sont ddis des taches paiticulieies. lls sont foims dune siie de com-
mandes contenues dans un piogiamme source qui est tiansfoim poui tie excut pai loidinateui.
1.3 Les langages
1.3.1 Des langages de dirents niveaux
Chaque piocesseui possede un langage piopie, diiectement excutable le langage machine. ll est
foim de 0 et de 1 et nest pas poitable, mais cest le seul que loidinateui puisse utilisei ,
le langage dassemblage est un codage alphanumiique du langage machine. ll est plus lisible que
le langage machine, mais nest toujouis pas poitable. On le tiaduit en langage machine pai un
assembleur ,
les langages de haut niveau. Souvent noimaliss, ils peimeuent le poitage dune machine lautie.
lls sont tiaduits en langage machine pai un compilateur ou un interprteur.
1.4 Production des programmes 3
1.3.2 Bref historique des langages
Annes 0 (appioches expiimentales) lORTRAN, LlSP, COBOL, ALGOL. . .
Annes 0 (langages univeisels) PL/1, Simula, Smalltalk, Basic. . .
Annes 0 (gnie logiciel) C, PASCAL, ADA, MODULA-2. . .
Annes 80 (piogiammation objet) C, LabView, Eiel, Peil, VisualBasic. . .
Annes 90 (langages inteipits objet) Java, tcl/Tk, Ruby, Python. . .
Annes 2000 (langages commeiciaux piopiitaiies) C-, VB.NET. . .
Des centaines de langages ont t cis, mais lindustiie nen utilise quune minoiit.
1.4 Production des programmes
1.4.1 Deux teniques de production des programmes
La compilation est la tiaduction du souice en langage objet. Elle compiend au moins quatie phases
(tiois phases danalyse lexicale, syntaxique et smantique et une phase de pioduction de code objet).
Poui gniei le langage machine il faut encoie une phase paiticulieie ldition de liens. La compilation
est contiaignante mais oie au nal une giande vitesse dexcution.
licUvr 1.1 Chaine de compilation
Dans la technique de linteipitation chaque ligne du souice analys est tiaduite au fui et mesuie en
instiuctions diiectement excutes. Aucun piogiamme objet nest gni. Ceue technique est ties souple
mais les codes gnis sont peu peifoimants linteipiteui doit tie utilis chaque excution. . .
licUvr 1.2 Technique de linteipitation
1.4.2 Tenique de production de Python
Technique mixte linteipitation du bytecode compil. Bon compiomis entie la facilit de dve-
loppement et la iapidit dexcution ,
le bytecode (foime inteimdiaiie) est poitable sui tout oidinateui muni de la machine viituelle Py-
thon.
licUvr 1.3 lnteipitation du bytecode compil
Poui excuter un programme, Python chaige le chiei souice .py (ou .pyw) en mmoiie vive, en fait
lanalyse (lexicale, syntaxique et smantique), pioduit le bytecode et enn lexcute.
An de ne pas iefaiie inutilement toute la phase danalyse et de pioduction, Python sauvegaide le
bytecode pioduit (dans un chiei .pyo ou .pyc) et iechaige simplement le chiei bytecode sil est plus
icent que le chiei souice dont il est issu.
En piatique, il nest pas ncessaiie de compilei explicitement un module, Python geie ce mcanisme
de faon tianspaiente.
4 Introduction
1.4.3 La construction des programmes
Le gnie logiciel tudie les mthodes de constiuction des piogiammes. Plusieuis modeles sont envisa-
geables, entie auties
la mthodologie piocduiale. On emploie lanalyse descendante (division des pioblemes) et iemon-
tante (iutilisation dun maximum de sous algoiithmes). On seoice ainsi de dcomposei un pio-
bleme complexe en sous-piogiammes plus simples. Ce modele stiuctuie daboid les actions ,
la mthodologie objet. Centie sui les donnes, elle est considie plus stable dans le temps et
meilleuie dans sa conception. On conoit des fabiiques (classes) qui seivent pioduiie des compo-
sants (objets) qui contiennent des donnes (aributs) et des actions (mthodes). Les classes diivent
(hritage et polymorphisme) de classes de base dans une constiuction hiiaichique.
Python oie les deux techniques.
1.5 Algorithme et programme
1.5.1 Dnitions
Dnition
b
Algoiithme ensemble des tapes peimeuant daueindie un but en iptant un nombie ni de fois
un nombie ni dinstiuctions.
Un algoiithme se teimine en un temps ni.
Dnition
b
Piogiamme un piogiamme est la tiaduction dun algoiithme en un langage compilable ou inteipi-
table pai un oidinateui.
ll est souvent ciit en plusieuis paities dont une qui pilote les auties le piogiamme piincipal.
1.5.2 La prsentation des programmes
Un piogiamme source est destin ltie humain. Poui en facilitei la lectuie, il doit tie judicieusement
comment.
La signication de paities non tiiviales (et uniquement celles-ci) doit tie explique pai un commen-
taiie. En Python, un commentaiie commence pai le caiacteie - 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
poitable sui diients systemes
Jython cibl poui la JVM (utilise le bytecode de JAVA)
IronPython Python.NET, ciit en C-, utilise le MSlL (MicroSo Intermediate Language)
Staless Python limine lutilisation de la pile du langage C (peimet de icuisei tant que lon
veut)
Pypy piojet de iecheiche euiopen dun inteipiteui Python ciit en Python
1. Une implmentation signie une mise en uvie .
Cu~vi1vr 2
La calculatrice Python
Comme tout langage, Python peimet de manipulei des donnes giace un vocabulaire de
mots iseivs et giace des types de donnes appioximation des ensembles de dnition
utiliss en mathmatique.
Ce chapitie pisente les iegles de constiuction des identicateuis, les types de donnes simples
(les conteneuis seiont examins au chapitie 4) ainsi que les types chaine de caiacteies (Unicode
et binaiies).
Enn, last but not least, ce chapitie stend sui les notions non tiiviales de vaiiables, de if-
iences dobjet et daectation.
2.1 Les modes dexcution
2.1.1 Les deux modes dexcution dun code Python
Soit on eniegistie un ensemble dinstiuctions Python dans un chiei giace un diteui (on paile
alois dun script Python) que lon excute pai une commande ou pai une touche du menu de lditeui ,
soit on utilise linteipiteui Python embaiqu qui excute la boucle dvaluation (lig. 2.1).
licUvr 2.1 La boucle dvaluation de linteipiteui Python
2.2 Identicateurs et mots cls
2.2.1 Identicateurs
Comme tout langage, Python utilise des identicateurs poui nommei ses objets.
Dnition
b
Un identicateui Python est une suite non vide de caiacteies, de longueui quelconque, foime dun
caractre de dbut et de zro ou plusieurs caractres de continuation.
La calculatrice Python
Sachant que
un caractre de dbut peut tie nimpoite quelle leuie Unicode (cf. annexe C, p. 93), ainsi que le
caiacteie soulign (_) ,
un caractre de continuation est un caiacteie de dbut, un chiie ou un point.
Attention
j
Les identicateuis sont sensibles la casse et ne doivent pas tie un mot iseiv de Python 3.
2.2.2 Style de nommage
ll est impoitant dutilisei une politique cohiente de nommage des identicateuis. Voici le style utilis
dans ce document
1
UPPERCASE ou UPPER_CASE poui les constantes ,

TitleCase poui les classes ,
UneExceptionError poui les exceptions ,
camelCase poui les fonctions et les mthodes ,
unmodule_m poui les modules ,
lowercase ou lower_case poui tous les auties identicateuis.
Exemples
NB_ITEMS = 12 # UPPER_CASE
class MaClasse: pass # TitleCase
def maFonction(): pass # camelCase
mon_id = 5 # lower_case
Poui ne pas pitei confusion, vitei dutilisei les caiacteies l (minuscule), O et I (majuscules) seuls.
Enn, on viteia dutilisei les notations suivantes
_xxx # usage interne
__xxx # attribut de classe
__xxx__ # nom spcial rserv
2.2.3 Les mots rservs de Python 3
La veision 3.3.0 de Python compte 33 mots cls
and del from None True
as elif global nonlocal try
assert 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
Dnition
b
Une expiession est une poition de code que linteipiteui Python peut valuei poui obtenii une
valeui.
Les expiessions peuvent tie simples ou complexes. Elles sont foimes dune combinaison de liuiaux
iepisentant diiectement des valeuis, didenticateuis et dopiateuis.
Exemples de deux expiessions simples et dune expiession complexe
>>> id1 = 15.3
>>>
>>> id2 = maFonction(id1)
>>>
>>> if id2 > 0:
... id3 = math.sqrt(id2)
... else:
... id4 = id1 - 5.5*id2
1. Voii les dtails dans la PEP 8 Style Guide foi Python , Guido van RossUx et Baiiy W~vs~v
2.4 Les types de donnes entiers
2.4 Les types de donnes entiers
Python 3 oie deux types entieis standaid int et bool.
2.4.1 Le type int
Le type int nest limit en taille que pai la mmoiie de la machine
1
.
Les entieis liuiaux sont dcimaux pai dfaut, mais on peut aussi utilisei les bases suivantes (cf. an-
nexe D, p. 9)
>>> 2013 # dcimal
2013
>>> 0b11111011101 # binaire
2013
>>> 0o3735 # octal
2013
>>> 0x7dd # hexadecimal
2013
Oprations arithmtiques
Les piincipales opiations
>>> 20 + 3
23
>>> 20 - 3
17
>>> 20 * 3
60
>>> 20 ** 3
8000
>>> 20 / 3
6.666666666666667
>>> 20 // 3
6 (division entire)
>>> 20 % 3 # modulo
2
>>> abs(3 - 20) # valeur absolue
17
Bien iemaiquei le iole des deux opiateuis de division
/ pioduit une division ouante, mme entie deux entieis ,
// pioduit une division entieie.
Bases usuelles
Un entiei ciit en base 10 (pai exemple 179) peut se iepisentei en binaiie, octal et hexadcimal en
utilisant les syntaxes suivantes
>>> 0b10110011 # binaire
179
>>> bin(179)
'0b10110011'
>>> 0o263 # octal
179
>>> oct(179)
'0o263'
>>> 0xB3 # hexadcimal
179
>>> hex(179)
'0xb3'
1. Dans la plupait des auties langages les entieis sont cods sui un nombie xe de bits et ont un domaine de dnition limit
auquel il convient de faiie auention.
8 La calculatrice Python
2.4.2 Le type bool
Piincipales caiactiistiques du type bool
1
Deux valeuis possibles False, True.

Opiateuis de compaiaison entie deux valeuis compaiables, pioduisant un isultat de type bool
==, !=, >, >=, < et <=
>>> 2 > 8
False
>>> 2 <= 8 < 15
True
Opiateuis logiques not, or et and.
En obseivant les tables de viit des opiateuis and et or, on iemaique que
des quun piemiei membie a la valeui False, lexpiession False and expression2 vaudia False.
On na donc pas besoin de lvaluei ,
de mme des quun piemiei membie a la valeui True, lexpiession True or expression2 vaudia
True.
Ceue optimisation est appele piincipe du shortcut ou valuation au plus couit
>>> (3 == 3) or (9 > 24)
True
>>> (9 > 24) and (3 == 3)
False
Les oprateurs boolens de base
En Python les valeuis des vaiiables boolennes sont notes False et True. Les
opiateuis sont nots iespectivement not, and et or.
Oprateur unaire not
a not(a)
lalse Tiue
Tiue lalse
Oprateurs binaires or et and
a b a or b a and b
lalse lalse lalse lalse
lalse Tiue Tiue lalse
Tiue lalse Tiue lalse
Tiue Tiue Tiue Tiue
Attention
j
Poui tie sui davoii un isultat boolen avec une expiession ieposant sui des valeuis tianstypes,
appliquez bool() sui lexpiession.
2.5 Les types de donnes ottants
Remarque
La notion mathmatique de rel est une notion idale impossible meuie en uvie en infoimatique.
On utilise une iepisentation inteine peimeuant de dplacei la viigule giace une valeui dexposant
vaiiable. On nommeia ces nombies des oants.
2.5.1 Le type float
Un float est not avec un point dcimal (jamais avec une viigule) ou en notation exponentielle avec
un e symbolisant le 10 puissance suivi des chiies de lexposant
2.718
.02
-1.6e-19
6.023e23
1. Dapies Geoige Booir, logicien et mathmaticien du 19
e
siecle.
2.6 Variables et aectation 9
Les ouants suppoitent les mmes opiations que les entieis.
lls ont une picision nie limit.
Limpoit du module math autoiise toutes les opiations mathmatiques usuelles. Pai 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 ciits en notation caitsienne foime de deux ouants.
La paitie imaginaiie est suxe pai 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))) # module
5.0
Un module mathmatique spcique (cmath) leui est iseiv
>>> 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 aectation
2.6.1 Les variables
Des que lon possede des types de donnes, on a besoin des variables poui stockei les donnes.
En ialit, Python noie pas la notion de vaiiable, mais plutot celle de rfrence dobjet. Tant que lobjet
nest pas modiable (comme les entieis, les ouants, les chaines etc.), il ny a pas de diience notable
entie les deux notions. On veiia que la situation change dans le cas des objets modiables. . .
Dnition
b
Une vaiiable est un identicateui associ une valeui. En Python, cest une ifience dobjet.
2.6.2 Laectation
Dnition
b
On aecte une vaiiable pai une valeui en utilisant le signe (qui na rien voir avec lgalit en
math '). Dans une aectation, le membie de gauche ieoit le membie de dioite ce qui ncessite dvaluei
la valeui coiiespondant au membie de dioite avant de laectei au membie de gauche.
a = 2 # prononcez : a "reoit" 2
b = 7.2 * math.log(math.e / 45.12) - 2*math.pi
c = b ** a
Remarque
A loial, au lieu de diie a gal 2 , dites a reoit 2 .

La valeui dune vaiiable, comme son nom lindique, peut voluei au couis du temps (la valeui ant-
iieuie est peidue)
>>> a = 3 * 7
>>> a
21
>>> b = 2 * 2
>>> b
4
>>> a = b + 5
>>> a
9
Le membie de dioite dune aectation tant valu avant de ialisei laectation elle-mme, la vaiiable
aecte peut se tiouvei en paitie dioite et cest sa valeui avant laectation qui est utilise dans le calcul
>>> a = 2
>>> a = a + 1 # incrmentation
>>> a
3
>>> a = a - 1 # dcrmentation
>>> a
2
2.6.3 Aecter nest pas comparer !
Laectation a un eet (elle modie ltat inteine du piogiamme en couis dexcution) mais na pas de
valeui (on ne peut pas lutilisei dans une expiession)
>>> c = True
>>> s = (c = True) and True
File "<stdin>", line 1
s = (c = True) and True
^
SyntaxError: invalid syntax
La comparaison a une valeur (de type bool) utilisable dans une expiession mais na pas deet
>>> c = "a"
>>> s = (c == "a") and True
>>> s
True
2.6.4 Les variantes de laectation
Outie laectation simple, on peut aussi utilisei les foimes 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 guie 2.2, les ceicles iepisentent les identicateuis alois que les iectangles
iepisentent les donnes.
Les aectations relient les identicateuis aux donnes si une donne en mmoiie nest plus ielie, le
iamasse-mieues (garbage collector) de Python la suppiime automatiquement
2.7 Les chanes de caractres 11
(a) Tiois aectations (b) La donne 'c' est suppiime loisque z ifience
la donne 'b'
(c) La donne 'a' est suppiime loisque x ifience
la nouvelle donne 'd'
licUvr 2.2 Laectation illustie.
2.7 Les anes de caractres
2.7.1 Les anes de caractres : prsentation
Dnition
b
Les chaines de caiacteies le type de donnes non modiable str iepisente une squence de caiac-
teies Unicode.
Non modiable signie quune donne, une fois cie en mmoiie, ne pouiia plus tie change, toute
tiansfoimation isulteia en la ciation dune nouvelle valeui distincte.
Tiois syntaxes de chaine sont disponibles.
Remaiquez que lon peut aussi utilisei le la place de , ce qui peimet dincluie une notation dans lautie
>>> 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
Longueui
>>> 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 mthodes
On peut agii sui une chaine en utilisant des fonctions (notion piocduiale) communes tous les types
squences ou conteneuis, ou bien des mthodes (notion objet) spciques aux chaines.
Exemple dutilisation de la fonction len()
>>> lng = len("abc")
>>> lng
3
Exemple dutilisation de la mthode upper(). Remaiquez la diience de syntaxe les mthodes
utilisent la notation pointe
>>> "abracadabra".upper()
"ABRACADABRA"
2.7.4 Mthodes de test de ltat dune ane
Les mthodes suivantes sont valeui boolenne, cest--diie quelles ietouinent la valeui True ou
False.
Remarque
La notation [xxx] indique un lment optionnel que lon peut donc omeuie lois de lutilisation de la
mthode.
La chaine s = cHAise basSe nous seiviia de test poui toutes les mthodes de ceue section.
isupper() et islower() ietouinent True si la chaine ne contient iespectivement que des majuscu-
les/minuscules
>>> s.isupper()
False
istitle() ietouine True si seule la piemieie leuie de chaque mot de la chaine est en majuscule
>>> s.istitle()
False
isalnum(), isalpha(), isdigit() et isspace() ietouinent True si la chaine ne contient iespective-
ment que des caiacteies alphanumiiques, alphabtiques, numiiques ou des espaces
>>> s.isalpha()
True
>>> s.isdigit()
False
startswith(prefix[, start[, stop]]) et endswith(suffix[, start[, stop]]) testent si la sous-
chaine dnie pai start et stop commence iespectivement pai prefix ou nit pai 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() ietouinent iespectivement une chaine en minuscule,
en majuscule, en minuscule commenant pai une majuscule, ou en casse inveise
>>> s.lower()
chaise basse
>>> s.upper()
CHAISE BASSE
>>> s.capitalize()
Chaise basse
>>> s.swapcase()
ChaISE BASsE
expandtabs([tabsize]) iemplace les tabulations pai tabsize espaces (8 pai dfaut).
center(width[, fillchar]), ljust(width[, fillchar]) et
rjust(width[, fillchar]) ietouinent iespectivement une chaine centie, justie gauche ou
dioite, complte pai le caiacteie fillchar (ou pai lespace pai dfaut)
>>> s.center(20, '-')
----cHAise basSe----
>>> s.rjust(20, '@')
@@@@@@@@cHAise basSe
zfill(width) complete ch gauche avec des 0 jusqu une longueui maximale de width
>>> s.zfill(20)
00000000cHAise basSe
strip([chars]), lstrip([chars]) et rstrip([chars]) suppiiment toutes les combinaisons de chars
(ou lespace pai dfaut) iespectivement au dbut et en n, au dbut, ou en n dune chaine
>>> s.strip('ce')
HAise basS
find(sub[, start[, stop]]) ienvoie lindex de la chaine sub dans la sous-chaine start stop,
sinon ienvoie -1. rfind() eectue le mme tiavail en commenant pai la n. index() et rindex()
font de mme mais pioduisent une eiieui (exception) si la chaine nest pas tiouve
>>> s.find('se b')
4
replace(old[, new[, count]]) iemplace count instances (toutes pai dfaut) de old pai new
>>> s.replace('HA', 'ha')
chaise basSe
split(seps[, maxsplit]) dcoupe la chaine en maxsplit moiceaux (tous pai dfaut). rsplit() ef-
fectue la mme chose en commenant pai la n et striplines() eectue ce tiavail avec les caiacteies
de n de ligne
>>> s.split()
['cHAise', 'basSe']
join(seq) concatene les chaines du conteneui seq en inteicalant la chaine sui laquelle la mthode
est applique
>>> "**".join(['cHAise', 'basSe'])
cHAise**basSe
2.7.6 Les anes de caractres : indexation simple
Poui indexei une chaine, on utilise lopiateui [] dans lequel lindex, un entiei sign qui commence
0 indique la position dun caiacteie
>>> s = "Rayon X" # len(s) ==> 7
>>> s[0]
'R'
>>> s[2]
'y'
>>> s[-1]
'X'
>>> s[-3]
'n'
licUvr 2.3 Lindexation dune chaine.
2.7.7 Extraction de sous-anes (ou tranes )
Dnition
b
Extiaction de sous-chaines lopiateui [] avec 2 ou 3 index spais pai le caiacteie : peimet
dextiaiie des sous-chaines (ou tianches) dune chaine.
licUvr 2.4 Extiaction de sous-chaines.
Pai 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 binaires
Les types binaires
Python 3 piopose deux types de donnes binaiies bytes (non modiable) et bytearray (modiable).
>>> mot = 'Animal' # type str
>>> b_mot = b"Animal" # type bytes
>>> bMot = bytearray(b_mot) # type bytearray
Une donne binaiie contient une suite de zio ou plusieuis octets, cest--diie dentieis non signs sui
8 bits (compiis dans linteivalle [02]). Ces types la C sont bien adapts poui stockei de giandes
quantits de donnes. De plus Python fouinit des moyens de manipulation ecaces de ces types.
Les deux types sont assez semblables au type str et possedent la plupait de ses mthodes. Le type
modiable bytearray possede des mthodes communes au type list.
2.9 Les entres-sorties 1
2.9 Les entres-sorties
Lutilisateui a besoin dinteiagii avec le piogiamme ( lig. 2.). En mode console (on veiia les
inteifaces giaphiques ultiieuiement), on doit pouvoii saisir ou entrer des infoimations, ce qui est gnia-
lement fait depuis une lecture au claviei. lnveisement, on doit pouvoii acher ou sortir des infoimations,
ce qui coiiespond gnialement une criture sui lcian.
(a) Entie (b) Soitie
licUvr 2. Les enties-soities.
2.9.1 Les entres
ll sagit de ialisei une saisie au claviei la fonction standaid input() inteiiompt le piogiamme, ache
une ventuelle invite lcian et auend que lutilisateui entie une donne au claviei (ache lcian)
et la valide pai
Entre .
La fonction standaid input() eectue toujouis une saisie en mode texte (la valeui ietouine est une
chaine) dont on peut ensuite changei le type (on dit aussi transtyper)
>>> f1 = input("Entrez un flottant : ")
Entrez un flottant : 12.345
>>> type(f1)
<class 'str'>
>>> f2 = input("Entrez un autre flottant : ")
Entrez un autre flottant : 12.345
>>> type(f2)
<class 'float'>
2.9.2 Les sorties
En mode calculatiice , Python lit-value-ache (lig. 2.1), mais la fonction print() ieste indispen-
sable aux achages dans les sciipts. Elle se chaige dachei la iepisentation textuelle des infoimations
qui lui sont donnes en paiametie, en plaant un blanc spaiateui entie deux infoimations, et en faisant
un ietoui la ligne la n de lachage (le spaiateui et la n de ligne peuvent tie 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 <", 2**32, "> cas !", sep="###")
On a <###4294967296###> 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
A lintiieui dune chaine, le caiacteie antislash (\) peimet de donnei une signication spciale
ceitaines squences de caiacteies
Squence Signication
\saut_ligne saut de ligne ignoi
\\ ache un antislash
\' apostiophe
\" guillemet
\a sonneiie (bip)
\b ietoui aiiieie
\f saut de page
\n saut de ligne
\r ietoui en dbut de ligne
\t tabulation hoiizontale
\v tabulation veiticale
\N{nom} caiacteie sous foime de code Unicode nomm
\uhhhh caiacteie sous foime de code Unicode 1 bits
\Uhhhhhhhh caiacteie sous foime de code Unicode 32 bits
\ooo caiacteie sous foime de code octal
\xhh caiacteie sous foime 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
Cu~vi1vr 3
Le contrle du ux dinstructions
Un sciipt Python est foim dune suite dinstiuctions excutes en squence de haut en bas
a
.
Chaque ligne dinstiuctions est foime dune ou plusieuis lignes physiques qui peuvent tie
continues pai un antislash \ ou un caiacteie ouviant [({ pas encoie feim.
Ceue excution en squence peut tie modie poui choisir ou rpter des poitions de code,
ce que lon appelle instiuctions composes.
a. On peut meuie plusieuis instiuctions sui la mme ligne en les spaiant avec un ; mais, pai
soucis de lisibilit, cest dconseill.
3.1 Les instructions composes
Poui identiei les instiuctions composes, Python utilise la notion dindentation signicative, cest--
diie visuelle. Ceue syntaxe lgeie met en lumieie un bloc dinstiuctions et peimet damlioiei giandement
la pisentation des piogiammes souices.
Syntaxe
Une instiuction compose se compose

dune ligne den-tte teimine pai deux-points ,
dun bloc dinstiuctions indent par rapport la ligne den-tte.
Attention
j
Toutes les instiuctions au mme niveau dindentation appaitiennent au mme bloc (lig. 3.1).
Exemple
>>> # ...
...
>>> n = -3
>>> if n < 0:
... print("Votre nombre est ngatif.")
...
Votre nombre est ngatif.
>>> # ... suite du programme
On a souvent besoin dimbiiquei les instiuctions composes
>>> # ...
...
>>> n = 3
18 Le contrle du ux dinstructions
>>> if n <= 0:
... print("Votre nombre est ngatif ou nul.")
... else:
... print("Votre nombre est positif.")
... if n > 2:
... print("Il est suprieur 2.")
...
Votre nombre est positif.
Il est suprieur 2.
>>> # ... suite du programme
(a) simple (b) imbiique
licUvr 3.1 lnstiuction compose.
3.2 Choisir
3.2.1 Choisir : if - [elif] - [else]
Contiolei une alteinative
>>> 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 valeui boolenne
>>> if estPair: # mieux que if estPair == True:
... print("La condition est vraie")
3.2.2 Syntaxe compacte dune alternative
Poui tiouvei, pai exemple, le minimum de deux nombies, on peut utilisei lopiateui 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
Remarque
Lopiateui teinaiie est une expression, laquelle coiiespond une valeui que lon peut utilisei dans
une aectation ou un calcul.
3.3 Boucles
Notions de conteneur et ditrable
De faon gniale, nous paileions de conteneur poui dsignei un type de
donnes peimeuant de stockei un ensemble dauties donnes, en ayant
ou non, suivant les types, une notion doidie entie ces donnes.
Nous paileions aussi ditrable poui dsignei un conteneui que lon peut
paicouiii lment pai lment.
Poui paicouiii ces conteneuis, nous nous seiviions paifois de range()
qui fouinit un moyen commode poui gniei une liste de valeuis.
Pai exemple
>>> uneListe = list(range(6))
>>> uneListe
[0, 1, 2, 3, 4, 5]
Ces notions seiont tudies plus en dtail au chapitie 4, p. 23.
Python piopose deux boucles.
3.3.1 Rpter : while
Rptei une poition de code tant quune expiession boolenne est viaie
>>> 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 valeui numiique (on doit prciser le type cai on se iappelle
que input() saisit une chaine)
n = int(input('Entrez un entier [1 .. 10] : '))
while not(1 <= n <= 10):
n = int(input('Entrez un entier [1 .. 10], S.V.P. : '))
3.3.2 Parcourir : for
Paicouiii un itiable
>>> for lettre in "ciao":
... print(lettre)
...
c
i
a
o
>>> for x in [2, 'a', 3.14]:
... print(x)
...
2
a
3.14
>>> for i in range(5):
... print(i)
...
0
1
2
3
4
>>>
>>> nb_voyelles = 0
>>> for lettre in "Python est un langage tres sympa":
... if lettre in "aeiouy":
... nb_voyelles = nb_voyelles + 1
...
>>> nb_voyelles
10
3.4 Ruptures de squences
3.4.1 Interrompre une boucle : break
Soit immdiatement de la boucle for ou while en couis contenant linstiuction
>>> 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 : continue
Passe immdiatement litiation suivante de la boucle for ou while en couis contenant linstiuction ,
iepiend 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 boucles
La syntaxe complete des boucles autoiise des utilisations plus iaies.
while - else
Les boucles while et for peuvent possdei une clause else qui ne sexcute que si la boucle se termine
normalement, cest--diie sans inteiiuption
y = int(input("Entrez un entier positif : "))
while not(y > 0):
y = int(input('Entrez un entier positif, S.V.P. : '))
x = y // 2
while x > 1:
if y % x == 0:
print(x, "a pour facteur", y)
break # voici l'interruption !
x -= 1
else:
print(y, "est premier.")
3.4 Ruptures de squences 21
for - else
Un exemple avec le paicouis 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 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 exceptions
An de iendie les applications plus iobustes, il est ncessaiie de giei les eiieuis dexcution des
paities sensibles du code.
Le mcanisme des exceptions spaie dun cot la squence dinstiuctions excutei loisque tout se
passe bien et, dun autie cot, une ou plusieuis squences dinstiuctions excutei en cas deiieui.
Loisquune eiieui suivient, un objet exception est pass au mcanisme de piopagation des exceptions,
et lexcution est tiansfie la squence de tiaitement ad hoc.
Le mcanisme seectue en deux phases
la leve dexception lois de la dtection deiieui ,
le traitement appiopii.
Syntaxe
La squence noimale dinstiuctions est place dans un bloc try.

Si une eiieui est dtecte (leve dexception), elle est tiaite dans le bloc except appiopii (le gestionnaiie
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
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 pai Python appaitiennent un ensemble dexceptions nomm Exception.
Ceue famille oie une vingtaine dexceptions standaid
1
.
Syntaxe complte dune exception :
try:
... # squence normale d'excution
except <exception_1> as e1:
... # traitement de l'exception 1
except <exception_2> as e2:
... # traitement de l'exception 2
...
else:
... # clause excute en l'absence d'erreur
finally:
... # clause toujours excute
1. Citons quelques exemplaiies AritmeticError, ZeroDivisionError, IndexError, KeyError, AttributeError, IOError, ImportEr-
ror, NameError, SyntaxError, TypeError. . .
Linstiuction raise peimet de levei volontairement une exception
x = 2
if not(0 <= x <= 1):
raise ValueError("x n'est pas dans [0 .. 1]")
Remarque
raise, sans valeui, dans un bloc except, peimet de ne pas bloquei une exception, de la piopagei.
Cu~vi1vr 4
Les conteneurs standard
Le chapitie 2 a pisent les types de donnes simples, mais Python oie beaucoup plus les
conteneuis .
De faon gniale, un conteneui est un objet composite destin contenii dauties objets. Ce
chapitie dtaille les squences, les tableaux associatifs, les ensembles et les chieis textuels.
4.1 Les squences
4.1.1 est-ce quune squence ?
Dnition
b
Une squence est un conteneui oidonn dlments indexs pai des entieis indiquant leui position
dans le conteneui.
Python dispose de tiois types pidnis de squences
les chaines (vues picdemment) ,
les listes ,
les tuples
1
.
4.2 Les listes
4.2.1 Dnition, syntaxe et exemples
Dnition
b
Une liste est une collection oidonne et modiable dlments ventuellement htiogenes.
Syntaxe
Elments spais pai des viigules, et entouis de ciochets.

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]]
1. tuple nest pas viaiment un anglicisme, mais plutot un nologisme infoimatique.
24 Les conteneurs standard
4.2.2 Initialisations et tests
Utilisation de la iptition, de litiateui dentieis range() et de lopiateui dappaitenance (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 Mthodes
Qelques 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 suppiimei, iemplacei ou insiei plusieurs lments dune liste, il faut indiquei une tianche
(cf. 2.., p. 14) dans le membie de gauche dune aectation et fouinii une liste dans le membie de dioite.
>>> 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 2
4.2.5 Des squences de squences
Les squences, comme du ieste les auties conteneuis, peuvent tie imbiiqus.
Pai exemple
>>> liste_1 = [1, 2, 3]
>>> listes = [liste_1, [4, 5], "abcd"]
>>>
>>> for liste in listes:
... for elem in liste:
... print(elem)
... print()
...
1
2
3
4
5
a
b
c
d
4.3 Les tuples
Dnition
b
Un tuple est une collection oidonne et non modiable dlments ventuellement htiogenes.
Syntaxe
Elments spais pai des viigules, et entouis de paientheses.

mon_tuple = ('a', 2, [1, 3])
Lindexage des tuples sutilisent comme celui des listes ,
le paicouis des tuples est plus iapide que celui des listes ,
ils sont utiles poui dnii des constantes.
Attention
j
Comme les chaines de caiacteies, les tuples ne sont pas modiables '
4.4 Retour sur les rfrences
Nous avons dj vu que lopiation daectation, appaiemment innocente, est une ielle dicult de
Python.
i = 1
msg = "Quoi de neuf ?"
e = 2.718
Dans lexemple ci-dessus, les aectations ialisent plusieuis opiations
cie en mmoiie un objet du type ad hoc (membie de dioite) ,
stocke la donne dans lobjet ci ,
cie un nom de vaiiable (membie de gauche) ,
associe ce nom de vaiiable lobjet contenant la valeui.
Une consquence de ce mcanisme est que, si un objet modiable est aect plusieuis vaiiables, tout
changement de lobjet via une vaiiable seia visible pai lautie vaiiable
fable = ["Je", "plie", "mais", "ne", "romps", "point"]
phrase = fable
phrase[4] = "casse"
print(fable) # ['Je', 'plie', 'mais', 'ne', 'casse', 'point']
Si on veut pouvoii eectuei des modications spaies, il faut aectei lautie vaiiable pai une copie
distincte de lobjet, soit en ciant une tianche complete des squences dans les cas simples, soit en utilisant
le module copy dans les cas les plus gniaux (auties conteneuis). Dans les iaies occasions o lon veut
aussi que chaque lment et auiibut de lobjet soit copi spaiment et de faon icuisive, on emploie la
fonction 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 lassignation
Assignation augmente dun objet non modiable (cas dun entiei lig. 4.1). On a iepisent ltape
de laddition inteimdiaiie.
(a) Assignation dun entiei (b) Addition inteimdiaiie
(c) Assignation augmente
licUvr 4.1 Assignation augmente dun objet non modiable.
Assignation augmente dun objet modiable (cas dune liste lig. 4.2). On a iepisent ltape de
la ciation de la liste inteimdiaiie.
4.5 Les tableaux associatifs 2
(a) Assignation dune liste (b) Ciation inteimdiaiie en m-
moiie
(c) Assignation augmente
licUvr 4.2 Assignation augmente dun objet modiable.
4.5 Les tableaux associatifs
4.5.1 Les types tableaux associatifs
Dnition
b
Un tableau associatif est un type de donnes peimeuant de stockei des couples cle : valeur, avec
un acces ties iapide la valeui paitii de la cl, la cl ne pouvant tie pisente quune seule fois dans le
tableau.
ll possede les caiactiistiques suivantes
lopiateui dappaitenance dune cl (in) ,
la fonction taille (len()) donnant le nombie de couples stocks ,
il est itrable (on peut le paicouiii) mais nest pas ordonn.
Python piopose le type standaid dict.
4.5.2 Les dictionnaires (dict)
Syntaxe
Collection de couples cle : valeur entouie daccolades.

Les dictionnaiies constituent un type composite mais ils nappaitiennent pas aux squences.
Comme les listes, les dictionnaiies sont modiables, mais les couples eniegistis noccupent pas un
oidie immuable, leui emplacement est gi pai un algoiithme spcique.
Une cl pouiia tie alphabtique, numiique. . . en fait de tout type hachable (donc liste et dictionnaiie
exclus). Les valeurs pouiiont tie 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}
Mthodes
Qelques mthodes applicables aux dictionnaiies
>>> 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)
Dnition
b
Un ensemble est une collection itiable non oidonne dlments hachables uniques.
Donc un set est la tiansposition infoimatique de la notion densemble mathmatique.
En Python, il existe deux types densemble, les ensembles modiables set et les ensembles non mo-
diables frozenset. On ietiouve ici les mmes diiences quentie les listes et les tuples.
licUvr 4.3 Opiations sui les ensembles
>>> X = set('abcd')
>>> Y = set('sbds')
>>> X
set(['a', 'c', 'b', 'd'])
>>> Y
set(['s', 'b', 'd'])
>>> 'c' in X
True
>>> 'a' in Y
False
>>> X - Y
set(['a', 'c'])
>>> Y - X
set(['s'])
4.7 Les chiers textuels 29
>>> X | Y
set(['a', 'c', 'b', 'd', 's'])
>>> X & Y
set(['b', 'd'])
4.7 Les iers textuels
4.7.1 Les iers : introduction
On iappelle que loidinateui nexcute que les piogiammes pisents dans sa mmoiie volatile (la
RAM). Poui conseivei duiablement des infoimations, il faut utilisei une mmoiie peimanente comme
pai exemple le disque dui, la cl USB, le DVD,. . . sui lesquels le systeme dexploitation oiganise les don-
nes sous la foime de chieis.
Comme la plupait des langages, Python utilise classiquement la notion de chiei.
Nous limiteions nos exemples aux chieis textuels (lisibles pai un diteui), mais signalons que les
chieis stocks en codage binaire sont plus compacts et plus iapides giei (utiles poui les giands volumes
de donnes).
4.7.2 Gestion des iers
Ouverture et fermeture des iers
Piincipaux modes douveituie des chieis textuels
f1 = open("monFichier_1", "r", encoding='utf-8') # "r" mode lecture
f2 = open("monFichier_2", "w", encoding='utf-8') # "w" mode criture
f3 = open("monFichier_3", "a", encoding='utf-8') # "a" mode ajout
Python utilise les chieis en mode texte pai dfaut (not t). Poui les chieis binaires, il faut picisei
le mode b.
Le paiametie optionnel encoding assuie les conveisions entie les types byte , stock dans le chiei sui
le disque, et le type str, manipul lois des lectuies et ciituies.
Les encodages les plus fiquents sont 'utf-8' (cest lencodage piivilgiei en Python 3), 'latin1',
'ascii'. . .
Tant que le chiei nest pas feim
1
, son contenu nest pas gaianti sui le disque.
Une seule mthode de feimetuie
f1.close()
criture squentielle
Le chiei sui disque est considi comme une squence de caiacteies qui sont ajouts la suite, au
fui et mesuie que lon ciit dans le chiei.
Mthodes dciituie
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()
f2 = open("truc2.txt", "w")
print("abcd", file=f2) # utilisation de l'option file
f2.close()
1. ou bien ush pai un appel la mthode flush().
Lecture squentielle
En lectuie, la squence de caiacteies qui constitue le chiei est paicouiue en commenant au dbut
du chiei et en avanant au fui et mesuie des lectuies.
Mthodes de lectuie
f = open("truc.txt", "r")
s = f.read() # lit tout le fichier --> chane
s = f.read(3) # lit au plus n octets --> chane
s = f.readline() # lit la ligne suivante --> chane
s = f.readlines() # lit tout le fichier --> liste de chanes
f.close()
# Affichage des lignes d'un fichier une une
f = open("truc.txt") # mode "r" par dfaut
for ligne in f:
print(ligne)
f.close()
4.8 Itrer sur les conteneurs
Les techniques suivantes sont classiques et ties utiles.
Obtenii cls et valeuis en bouclant sui un dictionnaiie
knights = {"Gallahad": "the pure", "Robin": "the brave"}
for k, v in knights.items():
print(k, v)
# Gallahad the pure
# Robin the brave
Obtenii indice et item en bouclant sui une liste
for i, v in enumerate(["tic", "tac", "toe"]):
print(i, v, end=" ", sep="->") # 0->tic 1->tac 2->toe
Bouclei sui deux squences (ou plus) appaiies
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.
Obtenii une squence inveise (la squence initiale est inchange)
for i in reversed(range(1, 10, 2)):
print(i, end=" ") # 9 7 5 3 1
Obtenii une squence tiie 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 format
La mthode format() peimet de contiolei nement la ciation de chaines foimates. On lutiliseia
poui un achage via print(), poui un eniegistiement via f.write(), ou dans dauties cas.
Remplacements simples
print("{} {} {}".format("zro", "un", "deux")) # zro un deux
# formatage d'une chane pour usages ultrieurs
chain = "{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 Bob
print("Je m'appelle {{{}}}".format("Bob")) # Je m'appelle {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
loimatages 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
loimatages laide de dictionnaiie
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 auiibuts nomms
import math
import sys
print("math.pi = {.pi}, epsilon = {.float_info.epsilon}".format(math, sys))
# math.pi = 3.14159265359, epsilon = 2.22044604925e-16
Conveisions textuelles, str() et repr()
1
>>> print("{0!s} {0!r}".format("texte\n"))

texte
'texte\n'
loimatages numiiques
s = "int :{0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42)
print(s) # int :42; hex: 2a; oct: 52; bin: 101010
s = "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 = 100
pi = 3.1415926535897931
k = -54
print("{:.4e}".format(pi)) # 3.1416e+00
print("{:g}".format(pi)) # 3.14159
print("{:.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
loimatages diveis
s = "The sword of truth"
print("[{}]".format(s)) # [The sword of truth]
print("[{:25}]".format(s)) # [The sword of truth ]
print("[{:>25}]".format(s)) # [ The sword of truth]
print("[{:^25}]".format(s)) # [ The sword of truth ]
print("[{:-^25}]".format(s)) # [---The sword of truth----]
print("[{:.<25}]".format(s)) # [The sword of truth.......]
1. str() est un achage oiient utilisateui alois que repr() est une iepisentation liuiale.
long = 12
print("[{}]".format(s[:long])) # [The sword of]
m = 123456789
print("{:0=12}".format(m)) # 000123456789
print("{:#=12}".format(m)) # ###123456789
Cu~vi1vr
Fonctions et espaces de noms
Les fonctions sont les lments stiuctuiants de base de tout langage piocduial.
Elles oient diients avantages
vite la rptition on peut factoiisei une poition de code qui se ipete lois de lexcution
en squence dun sciipt ,
Met en relief les donnes et les rsultats enties et soities de la fonction ,
Permet la rutilisation mcanisme de limpoit ,
Dcompose une te complexe en tes plus simples conception de lapplication.
Ces avantages sont illustis sui la guie .1 qui utilise entie auties la notion dimport, m-
canisme ties simple qui peimet de iutilisei des chieis de fonctions, souvent appels biblio-
thques.
5.1 Dnition et syntaxe
Dnition
b
Une fonction est un ensemble dinstiuctions iegioupes sous un nom et sexcutant la demande.
On doit dnii une fonction chaque fois quun bloc dinstiuctions se tiouve plusieuis iepiises dans
le code , il sagit dune mise en facteui commun .
Syntaxe
La dnition dune fonction est compose

du mot cl def suivi de lidenticateui de la fonction, de paientheses entouiant les paiameties de la
fonction spais pai des viigules, et du caiacteie deux points qui teimine toujouis une instiuc-
tion compose ,
dune chaine de documentation indente comme le coips de la fonction ,
du bloc dinstiuctions indent pai iappoit la ligne de dnition, et qui constitue le coips de la
fonction.
Le bloc dinstiuctions est obligatoiie. Sil est vide, on emploie linstiuction 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 + b
produit = a * b
print("La somme de", a, " et", b, " est", somme, " et le produit, produit)
34 Fonctions et espaces de noms
(a) Evite la duplication de code.
(b) Met en ielief enties et soities.
(c) Limpoit peimet la iutilisation.
(d) Amlioie la conception.
licUvr .1 Les avantages de lutilisation des fonctions
5.2 Passage des arguments 3
5.2 Passage des arguments
5.2.1 Mcanisme gnral
Remarque
Passage pai aectation chaque aigument de la dnition de la fonction coiiespond, dans lordre, un
paiametie de lappel. La coiiespondance se fait pai aectation des paiameties aux aiguments.
licUvr .2 Passage des aiguments pai aectation des paiameties aux aiguments.
5.2.2 Un ou plusieurs paramtres, pas de retour
Exemple sans linstiuction return, ce quon appelle souvent une procdure
1
. Dans ce cas la fonction
ienvoie implicitement la valeui None
def table(base, debut, fin):
"""Affiche la table de multiplication des <base> de <debut> <fin>."""
n = debut
while n <= fin:
print(n, 'x', base, '=', n * base)
n += 1
# exemple d'appel :
table(7, 2, 8)
# 2 x 7 = 14 3 x 7 = 21 4 x 7 = 28 5 x 7 = 35 6 x 7 = 42 7 x 7 = 49 8 x 7 = 56
# autre exemple du mme appel, mais en nommant les paramtres ;
table(base=7, debut=2, fin=8)
5.2.3 Un ou plusieurs paramtres, utilisation du retour
Exemple avec utilisation dun return unique
from math import pi
def cube(x):
"""Retourne le cube de largument."""
return x**3
def volumeSphere(r):
"""Retourne le volume d'une sphre de rayon <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))
1. Une fonction vaut quelque chose, une piocduie fait quelque chose.
Exemple avec utilisation dun return multiple
import math
def surfaceVolumeSphere(r):
surf = 4.0 * math.pi * r**2
vol = surf * r/3
return surf, vol
# programme principal
rayon = float(input('Rayon : '))
s, v = surfaceVolumeSphere(rayon)
print("Sphre de surface {:g} et de volume {:g}".format(s, v))
5.2.4 Passage dune fonction en paramtre
Puisque en Python une vaiiable peut ifiencei une fonction, on peut tiansmeuie une fonction comme
paiametie
>>> 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 dfaut
ll est possible de spciei, lois de la dclaiation, des valeuis pai dfaut utilisei poui les aiguments.
Cela peimet, lois de lappel, de ne pas avoii spciei les paiameties coiiespondants.
ll est possible, en combinant les valeuis pai dfaut et le nommage des paiameties, de nindiquei
lappel que les paiameties dont on dsiie modiei la valeui de laigument. ll est pai contie ncessaiie de
iegioupei tous les paiameties optionnels la n de la liste des paiameties.
>>> 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
Attention
j
On utilise de pifience des valeuis pai dfaut non modiables (int, float, str, bool, tuple) cai la
modication dun paiametie pai un piemiei appel est visible les fois suivantes.
Si on a besoin dune valeui pai dfaut qui soit modiable (list, dict), on utilise la valeui pidnie
None 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 3
5.2.6 Nombre darguments arbitraire passage dun tuple de valeurs
ll est possible dautoiisei le passage dun nombie aibitiaiie daiguments en utilisant la notation dun
aigument nal *nom. Les paiameties suinumiaiies sont alois tiansmis sous la foime dun tuple aect
cet aigument (que lon appelle gnialement args).
def somme(*args):
"""Renvoie la somme du tuple <args>."""
resultat = 0
for nombre in args:
resultat += nombre
return resultat
# Exemples d'appel :
print(somme(23)) # 23
print(somme(23, 42, 13)) # 78
Attention
j
Si la fonction possede plusieuis aiguments, le tuple est en dernire position.
Rcipioquement il est aussi possible de passei un tuple (en fait une squence) lappel qui seia d-
compress en une liste de paiameties 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 dictionnaire
De la mme faon, il est possible dautoiisei le passage dun nombie aibitiaiie daiguments nomms en
plus de ceux pivus lois de la dnition en utilisant la notation dun aigument nal **nom. Les paiameties
suinumiaiies nomms sont alois tiansmis sous la foime dun dictionnaiie aect cet aigument (que
lon appelle gnialement kwargs poui keyword args).
Rcipioquement il est aussi possible de passei un dictionnaiie lappel dune fonction, qui seia d-
compiess et associ aux paiameties 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}
Attention
j
Si la fonction possede plusieuis aiguments, le dictionnaiie est en toute dernire position (apies un
ventuel tuple).
5.3 Espaces de noms
5.3.1 Porte des objets
Remarque
Poite les noms des objets sont cis lois de leui premire aectation, mais ne sont visibles que dans
ceitaines igions de la mmoiie.
On distingue
La porte globale celle du module ou du chiei sciipt en couis. Un dictionnaiie geie les objets globaux
linstiuction globals() fouinit les couples variable :valeur ,
La porte locale les objets inteines aux fonctions sont locaux. Les objets globaux ne sont pas modiables
dans les poites locales. Linstiuction locals() fouinit les couples variable :valeur.
5.3.2 Rsolution des noms : rgle LGI
La iecheiche des noms est daboid locale (L), puis globale (G), enn inteine (l) (lig. .3)
licUvr .3 Regle LGl
Exemples de porte
Pai dfaut, toute vaiiable utilise dans le coips dune fonction est locale celle-ci. Si une fonction a
besoin de modiei ceitaines vaiiables globales, la piemieie instiuction de ceue fonction doit tie
global <identificateurs>
Pai exemple
# x et fonc sont affects dans le module : globaux
def fonc(y): # y et z sont affects dans fonc : locaux
global x # permet de modifier x ligne suivante
x += 2
z = x + y
return z
x = 99
print(fonc(1)) # 102
print(x) # 101
def fonc(y): # y et z sont affects dans fonc : locaux
# dans fonc : porte locale
z = x + y
return z
x = 99
print(fonc(1)) # 100
print(x) # 99
def fonc(y): # y, x et z sont affects dans fonc : locaux
x = 3 # ce nouvel x est local et masque le x global
z = x + y
return z
x = 99
print(fonc(1)) # 4
print(x) # 99
Cu~vi1vr
Modules et paages
Un piogiamme Python est gnialement compos de plusieuis chieis souices, appels
modules. Leui nom est sux .py
a
.
Sils sont coiiectement cods les modules doivent tie indpendants les uns des auties poui
tie iutiliss la demande dans dauties piogiammes.
Ce chapitie explique comment codei et impoitei des modules dans un autie.
Nous veiions galement la notion de package qui peimet de gioupei plusieuis modules.
a. On tiouve aussi occasionnellement des modules .pyw sous Windows.
6.1 Modules
Dnition
b
Module chiei sciipt Python peimeuant de dnii des lements de piogiamme iutilisables. Ce
mcanisme peimet dlaboiei ecacement des bibliotheques de fonctions ou de classes.
Avantages des modules
iutilisation du code ,
la documentation et les tests peuvent tie intgis au module ,
ialisation de seivices ou de donnes paitags ,
paitition de lespace de noms du systeme.
6.1.1 Import
Linstiuction import chaige et excute le module indiqu sil nest pas dj chaig. Lensemble des
dnitions contenues dans ce module deviennent alois disponibles vaiiables globales, fonctions, classes.
Suivant la syntaxe utilise, on accede aux aux dnitions du module de diientes faons
linstiuction import <nom_module> donne acces lensemble des dnitions du module impoit en
utilisant 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
linstiuction from <nom_module> import nom1, nom2. . . donne acces diiectement une slection
choisie 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 leui espace mmoiie piopie, et on duplique
simplement dans le module couiant les noms que lon a choisi, comme si on avait fait les aectations
>>> sin = math.sin
>>> pi = math.pi
Remarque
ll est conseill dimpoitei dans lordre

les modules de la bibliotheque standaid ,
les modules des bibliotheques tieices ,
Les modules peisonnels.
Attention
j
Poui tout ce qui est fonction et classe, ainsi que poui les constantes (vaiiables globales dnies et
aecte une fois poui toute une valeui), limpoit diiect du nom ne pose pas de piobleme.
Pai contie, poui les vaiiables globales que lon dsiie pouvoii modiei, il est piconis de de passei
systmatiquement pai lespace de nom du module an de sassuiei de lexistence de ceue vaiiable en un
unique exemplaiie ayant la mme valeui dans tout le piogiamme.
6.1.2 Exemples
Notion d auto-test
Le module principal est celui qui est donn en aigument sui la ligne de commande ou qui est lanc
en piemiei lois de lexcution dun sciipt. Son nom est contenu dans la vaiiable globale vaiiable globale
__name__. Sa valeui dpend du contexte de lexcution.
Soit le module
# je_me_nomme.py
print("Je me nomme :", __name__)
Premier contexte excution sui la ligne de commande (ou dans un EDl), on obtient la valeui pidnie
__main__
$ python3 je_me_nomme.py
Je me nomme : __main__
Second contexte impoit de ce module (ce nest donc plus le module piincipal ), on obtient lidenticateui
du module
>>> import je_me_nomme
Je me nomme : je_me_nomme
Giace un test, on peut donc facilement savoii si le code est excut en tant que sciipt piincipal
on ciit un sciipt de fonctions ou de classes (souvent appel bibliothque) et on teimine le chiei
pai un test, l auto-test , poui viiei que lon est dans le module piincipal. On en piote poui
viiei tous les lments de la bibliotheque ,
quand on impoite le sciipt, le test inclus est faux et on se boine utilisei la bibliotheque.
# cube_m.py
def cube(x):
"""retourne le cube de <x>."""
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 = 1
cube de 2 = 8
cube de 3 = 27
"""
Autie exemple
def ok(message) :
"""
Retourne True si on saisie <Entre>, <O>, <o>, <Y> ou <y>,
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 continue
Encore (O/n) ? o
Je continue
Encore (O/n) ? n
Je m'arrte
"""
6.2 Bibliothque standard
6.2.1 La bibliothque standard
On dit souvent que Python est livi piles compiises (baeries included) tant sa bibliotheque stan-
daid, iiche de plus de 200 packages et modules, ipond aux pioblemes couiants les plus vaiis.
Ce suivol pisente quelques fonctionnalits utiles.
La gestion des anes
Le module string fouinit des constantes comme ascii_lowercase, digits. . . et la classe Formatter qui
peut tie spcialise en sous-classes spcialises de formateurs de chaines.
Le module textwrap est utilis poui foimatei un texte longueui de chaque ligne, contiole de lindentation.
Le module struct peimet de conveitii des nombies, boolens et des chaines en leui iepisentation
binaiie an de communiquei avec des bibliotheques de bas-niveau (souvent en C).
Le module difflib peimet la compaiaison de squences et fouinit des soities au foimat standaid
di ou en HTML.
Enn on ne peut oubliei le module re qui oie Python la puissance des expiessions igulieies
1
.
1. Cest tout un monde. . .
Le module io.StringIO
Ce module fouinit des objets compatibles avec linteiface des objets chieis.
Exemple de gestion ligne ligne dun chiei ou dune chaine avec la mme fonction scanner() utilisant
le mme tiaitement 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 io
chaine = io.StringIO("un\ndeux xxx\ntrois\n")
scanner(chaine, premierMot)
La gestion de la ligne de commande
Poui giei la ligne de commande, Python piopose linstiuction sys.argv. ll sagit simplement dune
liste contenant les aiguments de la ligne de commande argv[1], argv[2]. . . sachant que argv[0] est le
nom du sciipt lui-mme.
De plus, Python piopose le module optparse
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-f", "--file", dest="filename",
help="write report to FILE", metavar="FILE")
parser.add_option("-q", "--quiet",
action="store_false", dest="verbose", default=True,
help="don't print status messages to stdout")
(options, args) = parser.parse_args()
Les lignes de commande
python 6_025.py -h
ou
python 6_025.py --help
pioduisent 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 numriques
On iappelle que Python possede la bibliotheque math
>>> import math
>>> math.pi / math.e
1.1557273497909217
>>> exp(1e-5) - 1
1.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
Pai ailleuis, Python piopose en standaid les modules fraction et decimal
from fractions import Fraction
import decimal as d
print(Fraction(16, -10)) # -8/5
print(Fraction(123)) # 123
print(Fraction(' -3/7 ')) # -3/7
print(Fraction('-.125')) # -1/8
print(Fraction('7e-6')) # 7/1000000
d.getcontext().prec = 6
print(d.Decimal(1) / d.Decimal(7)) # 0.142857
d.getcontext().prec = 18
print(d.Decimal(1) / d.Decimal(7)) # 0.142857142857142857
En plus des bibliotheques math et cmath dj vues, la bibliotheque random piopose plusieuis fonctions
de nombies alatoiies.
La gestion du temps et des dates
Les modules calendar, time et datetime fouinissent les fonctions couiantes de gestion du temps et des
duies
import calendar, datetime, time
moon_apollo11 = datetime.datetime(1969, 7, 20, 20, 17, 40)
print(moon_apollo11)
print(time.asctime(time.gmtime(0)))
# Thu Jan 01 00:00:00 1970 ("epoch" UNIX)
vendredi_precedent = datetime.date.today()
un_jour = datetime.timedelta(days=1)
while vendredi_precedent.weekday() != calendar.FRIDAY:
vendredi_precedent -= un_jour
print(vendredi_precedent.strftime("%A, %d-%b-%Y"))
# Friday, 09-Oct-2009
Algorithmes et types de donnes collection
Le module bisect fouinit des fonctions de iecheiche de squences tiies. Le module array piopose un
type semblable la liste, mais plus iapide cai de contenu homogene.
Le module heapq geie des tas dans lesquels llment dindex 0 est toujouis le plus petit
import heapq
import random
heap = []
for i in range(10):
heapq.heappush(heap, random.randint(2, 9))
print(heap) # [2, 3, 5, 4, 6, 6, 7, 8, 7, 8]
A linstai des stiuctuies C, Python piopose dsoimais, via le module collections, la notion de type
tuple nomm
import collections
# description du type :
Point = collections.namedtuple("Point", "x y z")
# on instancie un point :
point = Point(1.2, 2.3, 3.4)
# on l'affiche :
print("point : [{}, {}, {}]"
.format(point.x, point.y, point.z)) # point : [1.2, 2.3, 3.4]
ll est bien sui possible davoii des tuples nomms emboits.
Le type defaultdict peimet des utilisations avances
from collections import defaultdict
s = [('y', 1), ('b', 2), ('y', 3), ('b', 4), ('r', 1)]
d = defaultdict(list)
for k, v in s:
d[k].append(v)
print(d.items())
# dict_items([('y', [1, 3]), ('r', [1]), ('b', [2, 4])])
s = 'mississippi'
d = defaultdict(int)
for k in s:
d[k] += 1
print(d.items())
# dict_items([('i', 4), ('p', 2), ('s', 4), ('m', 1)])
Et tant dautres domaines. . .
Beaucoup dauties domaines pouiiaient tie explois
acces au systeme ,
utilitaiies chieis ,
piogiammation iseau ,
peisistance ,
les chieis XML ,
la compiession ,
. . .
6.3 Bibliothques tierces
6.3.1 Une grande diversit
Outie les modules intgis la distiibution standaid de Python, on tiouve des bibliotheques dans tous
les domaines
scientique ,
bases de donnes ,
tests fonctionnels et contiole de qualit ,
3D,
. . .
Le site pypi.python.oig/pypi (e Python Package Index) iecense des millieis de modules et de pa-
ckages '
6.3.2 Un exemple : la bibliothque Unum
Elle peimet de calculei en tenant compte des units du systeme Sl (Systeme lnteinational dunits).
Voici un exemple de session inteiactive
>>> from unum.units import *
>>> distance = 100*m
>>> temps = 9.683*s
>>> vitesse = distance / temps
>>> vitesse
10.327377878756584 [m/s]
>>> vitesse.asUnit(mile/h)
23.1017437978 [mile/h]
>>> acceleration = vitesse/temps
>>> acceleration
1.0665473385063085 [m/s2]
6.4 Paquets 4
6.4 Paquets
Outie le module, un deuxieme niveau doiganisation peimet de stiuctuiei le code les chieis Python
peuvent tie oiganiss en une aiboiescence de ipeitoiies appele paquet, en anglais package.
Dnition
b
Un package est un module contenant dauties modules. Les modules dun package peuvent tie des
sous-packages, ce qui donne une stiuctuie aiboiescente.
Chaque ipeitoiie du paquet doit possdei un chiei __init__ qui peut soit tie vide soit contenii du
code dinitialisation.
Cu~vi1vr
La programmation Oriente Objet
La Programmation Oriente Objet
la POO peimet de mieux modlisei la ialit en concevant des modeles dobjets, les classes.
Ces classes peimeuent de constiuiie des objets inteiactifs entie eux et avec le monde ext-
iieui.
Les objets sont cis indpendamment les uns des auties, giace lencapsulation, mcanisme
qui peimet dembaiquei leuis piopiits.
Les classes peimeuent dvitei au maximum lemploi des vaiiables globales.
Enn les classes oient un moyen conomique et puissant de constiuiie de nouveaux objets
paitii dobjets piexistants.
7.1 Terminologie
Le vocabulaire de base de la POO
Une classe est quivalente un nouveau type de donnes. On connait dj pai exemple les classes list
ou str et de nombieuses mthodes poui les manipulei, pai exemple
[3, 5, 1].sort()
"casse".upper()
Un objet ou une instance est un exemplaiie paiticuliei dune classe. Pai exemple [3, 5, 1] est une
instance de la classe list et "casse" est une instance de la classe str.
Les objets ont gnialement deux soites dauiibuts les donnes nommes simplement auiibuts et les
fonctions applicables appeles mthodes.
Pai exemple un objet de la classe complex possede
deux auiibuts imag et real ,
beaucoup de mthodes, comme conjugate(), abs(). . .
La plupait des classes encapsulent la fois les donnes et les mthodes applicables aux objets. Pai
exemple un objet str contient une chaine de caiacteies Unicode (les donnes) et de nombieuses mthodes.
On peut dnii un objet comme une capsule contenant des auiibuts et des mthodes
objet = attributs + mthodes

48 La programmation Oriente Objet
7.1.1 Notations UML de base
Remarque
LUML (Unied Modeling Language) est un langage giaphique ties ipandu de conception des systemes
dinfoimation.
UML piopose une giande vaiit de diagiammes (classes, objets, tats, activits etc.). En piemieie
appioche, le diagiamme de classes est le plus utile poui concevoii les classes et leuis ielations.
(a) Une classe et une note (b) Un hiitage
licUvr .1 Diagiammes de classe.
7.2 Classes et instanciation dobjets
7.2.1 Linstruction class
Ceue instiuction peimet dintioduiie la dnition dune nouvelle classe (cest--diie dun nouveau
type de donnes).
Syntaxe
class est une instiuction compose. Elle compiend un en-tte (avec docstring) coips indent
>>> class C:
... """Documentation de la clesse C."""
... x = 23
Dans cet exemple, C est le nom de la classe (qui commence conventionnellement pai une majuscule),
et x est un aribut de classe, local C.
7.2.2 Linstanciation et ses attributs
Les classes sont des fabriques dobjets on constiuit daboid lusine avant de pioduiie des objets '
On instancie un objet (cest--diie quon le pioduit paitii de lusine) en appelant le nom de sa
classe comme sil sagissait dune fonction
>>> class C:
... """Documentation de la clesse C."""
... x = 23 # attibut de classe
...
>>> a = C() # a est un objet de la classe C (ou une instance)
>>> a.x # affiche la valeur de l'attribut de l'instance a
23
>>> a.x = 12 # modifie son attribut d'instance (attention...)
>>> a.x
12
>>> C.x # mais l'attribut de classe est inchang
23
>>> C.z = 6 # z : nouvel attribut de classe
>>> a.y = 44 # y : nouvel attribut de l'instance a
>>> b = C() # b est un autre objet de la classe C (une autre instance)
>>> b.x # b connat bien son attribut de classe, mais...
23
>>> b.y # ... b n'a pas d'attribut y !
7.2 Classes et instanciation dobjets 49
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: C instance has no attribute 'y'
Remarque
En Python (cai cest un langage dynamique comme Ruby, mais contiaiiement C ou Java) il est
possible dajoutei de nouveaux auiibuts dinstance (ici le a.y = 44) ou mme de nouveaux auiibuts de
classe (ici C.z = 6).
Dnition
b
Une vaiiable dnie au niveau dune classe (comme x dans la classe C) est appel auiibut de classe et
est paitage pai tous les objets instances de ceue classe.
Dnition
b
Une vaiiable dnie au niveau dun objet (comme y dans lobjet a) est appele auiibut dinstance et
est lie uniquement lobjet poui lequel elle est dnie.
7.2.3 Retour sur les espaces de noms
On a dj vu les espaces de noms
1
locaux (lois de lappel dune fonction), globaux (lis aux modules) et
inteines (fonctions standaids), ainsi que la iegle Local Global lnteine (cf. section .3, p. 38) qui dnit
dans quel oidie ces espaces sont paicouius poui isoudie un nom.
Les classes ainsi que les objets instances dnissent de nouveaux espaces de noms, et il y a l aussi des
iegles poui isoudie les noms
les classes peuvent utilisei les vaiiables dnies au niveau piincipal mais elles ne peuvent pas les
modiei ,
les instances peuvent utilisei les vaiiables dnies au niveau de la classe mais elles ne peuvent pas
les modiei (poui cela elles sont obliges de passei pai lespace de noms de la classe, e.g. C.x = 3).
Reere des noms
Noms non qualis (exemple dimension) laectation cie ou change le nom dans la porte locale
couiante. lls sont cheichs suivant la iegle LGl.
Noms qualis (exemple dimension.hauteur) laectation cie ou modie lauiibut dans lespace de
noms de lobjet. Un auiibut est cheich dans lobjet, puis dans toutes les classes dont lobjet dpend
(mais pas dans les modules).
Lexemple suivant ache le dictionnaiie li la classe C puis la liste des auiibuts lis une instance
de C
>>> v = 5
>>> class C:
... x = v + 3 # utilisation d'une variable globale dans la dfinition de classe
... y = x + 1 # recherche dans l'espace de noms de la classe lors de la dfinition
...
>>> a = C()
>>> a.x # utilisation sans modification de la variable de classe en passant par l'objet
8
>>> a.x = 2 # cration d'une variable d'instance pour l'objet a
>>> a.x
2
>>> C.x # la variable de classe n'est pas modifie
8
>>> C.x = -1 # on modifie la variable de classe en passant par l'espace de noms de la classe
>>> C.x
-1
>>> class C:
... x = 20
...
>>> C.__dict__
{'x': 20, '__module__': '__main__', '__doc__': None}
1. Les espaces de noms sont implments pai des dictionnaiies.
>>> a = C()
>>> dir(a)
['__doc__', '__module__', 'x']
7.3 Mthodes
Syntaxe
Une mthode sciit comme une fonction du corps de la classe avec un piemiei paiametie self obli-
gatoiie, o self iepisente lobjet sui lequel la mthode seia applique.
Autiement dit self est la rfrence dinstance.
>>> class C: # x et y : attributs de classe
... x = 23
... y = x + 5
... def affiche(self): # mthode affiche()
... self.z = 42 # attribut d'instance
... print(C.y) # dans une mthode, on qualifie un attribut de classe,
... print(self.z) # mais pas un attribut d'instance
...
>>> obj = C() # instanciation de l'objet ob
>>> obj.affiche()
28
42
7.4 Mthodes spciales
Beaucoup de classes oient des caiactiistiques supplmentaiies comme pai exemple la concatna-
tion des chaines en utilisant simplement lopiateui +. Ceci est obtenu giace aux mthodes spciales. Pai
exemple lopiateui + est utilisable cai la classe des chaines a iedni la mthode spciale __add__().
Syntaxe
Ces mthodes poitent des noms pi-dnis, picds et suivis de deux caiacteies de soulignement.
Elles seivent
initialisei lobjet instanci ,
modiei son achage ,
suichaigei ses opiateuis ,
. . .
7.4.1 Linitialisateur
Lois de linstanciation dun objet, la stiuctuie de base de lobjet est cie en mmoiie, et la mthode
__init__ est automatiquement appele poui initialisei lobjet. Cest typiquement dans ceue mthode sp-
ciale que sont cis les auiibuts dinstance avec leui valeui initiale.
>>> class C:
... def __init__(self, n):
... self.x = n # initialisation de l'attribut d'instance x
...
>>> une_instance = C(42) # paramtre obligatoire, affect n
>>> une_instance.x
42
Cest une procdure automatiquement invoque lois de linstanciation elle ne ietouine aucune valeui.
7.4.2 Surarge des oprateurs
La surcharge peimet un opiateui de possdei un sens diient suivant le type de ses opiandes. Pai
exemple, lopiateui peimet
x = 7 + 9 # addition entire
s = 'ab' + 'cd' # concatnation
7.5 Hritage et polymorphisme 1
Python possede des mthodes de suichaige poui
tous les types (__call__, __str__, . . .) ,
les nombies (__add__, __div__, . . .) ,
les squences (__len__, __iter__, . . .).
Soient deux instances, obj1 et obj2, les mthodes spciales suivantes peimeuent deectuei les opia-
tions aiithmtiques couiantes
1
Nom Mthode spciale Utilisation

oppos __neg__ -obj1
addition __add__ obj1 + obj2
soustiaction __sub__ obj1 - obj2
multiplication __mul__ obj1 * obj2
division __div__ obj1 / obj2
division entieie __floordiv__ obj1 // obj2
7.4.3 Exemple de surarge
Dans lexemple nous suichaigeons lopiateui daddition poui le type Vecteur2D.
Nous suichaigeons galement la mthode spciale __str__ utilis poui lachage
2
pai print().
>>> class Vecteur2D:
... def __init__(self, x0, y0):
... self.x = x0
... self.y = y0
... def __add__(self, second): # addition vectorielle
... return Vecteur2D(self.x + second.x, self.y + second.y)
... def __str__(self): # affichage d'un Vecteur2D
... return "Vecteur({:g}, {:g})".format(self.x, self.y)
...
>>>
>>> v1 = Vecteur2D(1.2, 2.3)
>>> v2 = Vecteur2D(3.4, 4.5)
>>>
>>> print(v1 + v2)
Vecteur(4.6, 6.8)
7.5 Hritage et polymorphisme
Un avantage dcisif de la POOest quune classe Python peut toujouis tie spcialise en une classe lle
qui hiite alois de tous les auiibuts (donnes et mthodes) de sa supei classe. Comme tous les auiibuts
peuvent tie iednis, une mthode de la classe lle et de la classe meie peut possdei le mme nom mais
eectuei des tiaitements diients (suichaige) et lobjet sadapteia dynamiquement, des linstanciation.
En pioposant dutilisei un mme nom de mthode poui plusieuis types dobjets diients, le polymoi-
phisme peimet une piogiammation beaucoup plus gniique. Le dveloppeui na pas savoii, loisquil
piogiamme une mthode, le type picis de lobjet sui lequel la mthode va sappliquei. ll lui sut de
savoii que cet objet implmenteia la mthode.
7.5.1 Hritage et polymorphisme
Dnition
b
Lhritage est le mcanisme qui peimet de se seivii dune classe piexistante poui en ciei une nou-
velle qui possdeia des fonctionnalits supplmentaiies ou diientes.
Dnition
b
Le polymorphisme par drivation est la facult poui deux mthodes (ou plus) poitant le mme nom
mais appaitenant des classes hiites distinctes deectuei un tiavail diient. Ceue piopiit est ac-
quise pai la technique de la suichaige.
1. Poui plus de dtails, consultei la documentation de ifience du langage Python (e Python language reference) section 3,
Data model, sous-section 3.3, Special method names.
2. Rappelons quil existe deux faons dachei un isultat, repr() et str(). La piemieie est poui la machine , la seconde
poui lutilisateui .
7.5.2 Exemple dhritage et de polymorphisme
Dans lexemple suivant, la classe QuadrupedeDebout hiite de la classe Quadrupede, et la mthode pied-
sAuContactDuSol() est polymoiphe
>>> class Quadrupede:
... def piedsAuContactDuSol(self):
... return 4
...
>>> class QuadrupedeDebout(Quadrupede):
... def piedsAuContactDuSol(self):
... return 2
...
>>> q1 = Quadrupede()
>>> q1.piedsAuContactDuSol()
4
>>> q2 = QuadrupedeDebout()
>>> q2.piedsAuContactDuSol()
2
7.6 Notion de conception oriente objet
Suivant les ielations que lon va tablii entie les objets de notie application, on peut concevoii nos
classes de deux faons possibles en utilisant lassociation ou la diivation.
Bien sui, ces deux conceptions peuvent cohabitei, et cest souvent le cas '
7.6.1 Association
Dnition
b
Une association iepisente un lien unissant les instances de classe. Elle iepose sui la ielation a-un
ou utilise-un .
licUvr .2 Une association peut tie tiquete et avoii des multiplicits.
Limplmentation Python utilise est gnialement lintgiation dauties objets dans le constiucteui
de la classe conteneui.
class Point:
def __init__(self, x, y):
self.px, self.py = x, y
class Segment:
"""Classe conteneur utilisant la classe Point."""
def __init__(self, x1, y1, x2, y2):
self.orig = Point(x1, y1)
self.extrem = Point(x2, y2)
def __str__(self):
return ("Segment : [({:g}, {:g}), ({:g}, {:g})]"
.format(self.orig.px, self.orig.py,
self.extrem.px, self.extrem.py))
s = Segment(1.0, 2.0, 3.0, 4.0)
print(s) # Segment : [(1, 2), (3, 4)]
7.6 Notion de conception oriente objet 3
Agrgation
Dnition
b
Une agigation est une association non symtiique entie deux classes (lagrgat et le composant).
licUvr .3 Une voituie est un tout qui contient un moteui.
Composition
Dnition
b
Une composition est un type paiticuliei dagigation dans laquelle la vie des composants est lie
celle de lagigat.
licUvr .4 On peut mlei les deux types dassociation.
La dispaiition de lagigat Commune entiaine le dispaiition des composants Services et Conseil_Municipal
alois que Village nen dpend pas.
7.6.2 Drivation
Dnition
b
La diivation dciit la ciation de sous-classes pai spcialisation. Elle iepose sui la ielation est-un.
On utilise dans ce cas le mcanisme de lhritage.
Limplmentation Python utilise est gnialement lappel linitialisateui de la classe paiente dans
linitialisateui de la classe diive (utilisation de la fonction super()).
Dans lexemple suivant, un Carre est-un Rectangle paiticuliei poui lequel on appelle linitialisateui
de la classe meie avec les paiameties longueur=cote et largeur=cote.
>>> class Rectangle:
... def __init__(self, longueur=30, largeur=15):
... self.L, self.l = longueur, largeur
... self.nom = "rectangle"
... def __str__(self):
... return "nom : {}".format(self.nom)
...
>>>
>>> class Carre(Rectangle): # hritage simple
... """Sous-classe spcialise de la super-classe Rectangle."""
... def __init__(self, cote=20):
... # appel au constructeur de la super-classe de Carre :
... super().__init__(cote, cote)
... self.nom = "carr" # surcharge d'attribut
...
>>>
>>> r = Rectangle()
>>> c = Carre()
>>> print(r)
nom : rectangle
>>> print(c)
nom : carr
7.7 Un exemple complet
Le sciipt suivant
1
piopose un modele simpli datome et dion.
La vaiiable de classe table liste les 10 piemieis lments du tableau de MrNurirrv.
licUvr . Un Ion est-un Atome.
class Atome:
"""atomes simplifis (les 10 premiers lments)."""
table = [None, ('hydrogne',0), ('helium',2), ('lithium',4), ('beryllium',5),
('bore',6), ('carbone',6), ('azote',7), ('oxygne',8),
('fluor',10), ('neon',10)]
def __init__(self, nat):
"le numro atomique dtermine le nombre de protons, d'lectrons et de neutrons"
self.np, self.ne = nat, nat # nat = numro atomique
self.nn = Atome.table[nat][1]
def affiche(self):
print()
print("Nom de l'lment :", Atome.table[self.np][0])
print("%s protons, %s lectrons, %s neutrons" % (self.np, self.ne, self.nn))
class Ion(Atome): # Ion hrite d'Atome
"""Les ions sont des atomes qui ont gagn ou perdu des lectrons"""
def __init__(self, nat, charge):
"le numro atomique et la charge lectrique dterminent l'ion"
super().__init__(nat)
self.ne = self.ne - charge # surcharge
self.charge = charge
1. adapt de [1], p. 11.
7.7 Un exemple complet
def affiche(self): # surcharge
Atome.affiche(self)
print("Particule lectrise. Charge =", self.charge)
# Programme principal =========================================================
a1 = Atome(5)
a2 = Ion(3, 1)
a3 = Ion(8, -2)
a1.affiche()
a2.affiche()
a3.affiche()
"""
Nom de l'lment : bore
5 protons, 5 lectrons, 6 neutrons
Nom de l'lment : lithium
Particule lectrise. Charge = 1
Nom de l'lment : oxygne
Particule lectrise. Charge = -2
"""
Cu~vi1vr 8
La programmation oriente objet graphique
Ties utilise dans les systemes dexploitation et dans les applications, les interfaces gra-
phiques sont piogiammables en Python.
Paimi les diientes bibliotheques giaphiques utilisables dans Python (GTK+, wxPython, Qt. . .), la
bibliotheque tkinter, issue du langage tcl/Tk est installe de base dans toutes les distiibutions
Python.
tkinter facilite la constiuction dinteifaces giaphiques simples.
Apies avoii impoit la bibliotheque, la dmaiche consiste ciei, conguiei et positionnei les
lments giaphiques (widgets) utiliss, codei les fonctions/mthodes associes aux widgets,
puis dentiei dans une boucle chaige de icupiei et tiaitei les diients vnements pouvant
se pioduiie au niveau de linteiface giaphique inteiactions de lutilisateui, besoins de mises
joui giaphiques, etc.
8.1 Programmes pilots par des vnements
En piogiammation giaphique objet, on iemplace le dioulement squentiel du sciipt pai une boucle
dvnements (lig. 8.1)
(a) Piogiammation squentielle (b) Boucle dvnements
licUvr 8.1 Deux styles de piogiammation.
8 La programmation oriente objet graphique
8.2 La bibliothque tkinter
8.2.1 Prsentation
Cest une bibliotheque assez simple qui piovient de lextention giaphique, Tk, du langage Tcl dvelopp
en 1988 pai John K. OUs1rvuoU1 de lUniveisit de Beikeley. Ceue extention a laigement essaim hois de
Tcl/Tk et on peut lutilisei en Peil, Python, Ruby, etc. Dans le cas de Python, lextension a t ienomme
tkinter.
Paiallelement Tk, des extensions ont t dveloppes dont ceitaines sont utilises en Python. Pai
exemple le module standaid Tix met une quaiantaine de widgets la disposition du dveloppeui.
De son cot, le langage Tcl/Tk a laigement volu. La veision 8. actuelle oie une bibliotheque ap-
pele Ttk qui peimet d habillei les widgets avec diients themes ou styles. Ce module est galement
disponible paitii de Python 3.1.1.
Un exemple tkinter simple (Fig. 8.2)
import tkinter
# cration d'un widget affichant un simple message textuel
widget = tkinter.Label(None, text='Bonjour monde graphique !')
widget.pack() # positionnement du label
widget.mainloop() # lancement de la boucle d'vnements
licUvr 8.2 Un exemple simple lachage dun Label
8.2.2 Les widgets de tkinter
Dnition
b
On appelle widget (mot valise, contiaction de window et gadget) les composants giaphiques de base
dune bibliotheque.
Liste des piincipaux widgets de tkintei
Tk fentie de plus haut niveau
Frame contenant poui oiganisei dauties widgets
Label zone de message
Button bouton daction avec texte ou image
Message zone dachage multi-lignes
Entry zone de saisie
Chebutton bouton deux tats
Radiobutton bouton deux tats exclusifs pai gioupe de boutons
Scale glissieie plusieuis positions
PhotoImage seit placei des images (Gll et PPM/PGM) sui des widgets
BitmapImage seit placei des bitmaps (X11 bitmap data) sui des widgets
Menu menu dioulant associ un Menubutton
Menubutton bouton ouviant un menu doptions
Scrollbar ascenseui
Listbox liste slection poui des textes
Text dition de texte simple ou multi-lignes
Canvas zone de dessins giaphiques ou de photos
8.3 Deux exemples 9
OptionMenu liste dioulante
ScrolledText widget Text avec ascenseui
PanedWindow inteiface onglets
LabelFrame contenant poui oiganisei dauties widgets, avec un cadie et un titie
Spinbox un widget de slection multiple
8.2.3 Le positionnement des widgets
tkinter possede tiois gestionnaiies de positionnement
Le paer dimensionne et place chaque widget dans un widget conteneui selon lespace iequis pai cha-
cun deux.
Le gridder dimensionne et positionne chaque widget dans les cellules dun tableau dun widget conte-
neui.
Le placer dimensionne et place chaque widget dans un widget conteneui selon lespace explicitement
demand. Cest un placement absolu (usage peu fiquent).
8.3 Deux exemples
8.3.1 tkPhone, un exemple sans menu
ll sagit de ciei un sciipt de gestion dun cainet tlphonique. Laspect de lapplication est illusti
lig. 8.3
Notion de callba
Nous avons vu que la piogiammation dinteiface giaphique passe pai une boucle piincipale chaige
de tiaitei les diients venements qui se pioduisent.
Ceue boucle est gnialement gie diiectement pai la bibliotheque dinteiface giaphique utilise, il
faut donc pouvoii spciei ceue bibliotheque quelles fonctions doivent tie appeles dans quels cas.
Ces fonctions sont nommes des callbacks ou iappels cai elles sont appeles diiectement pai la
bibliotheque dinteiface giaphique loisque des venements spciques se pioduisent.
Conception graphique
La conception giaphique va nous aidei choisii les bons widgets.
En piemiei lieu, il est piudent de commencei pai une conception manuelle ' En eet iien ne vaut un
papiei, un ciayon et une gomme poui se faiie une ide de laspect que lon veut obtenii.
On peut concevoii tiois zones
1. une zone supiieuie, ddie lachage ,
2. une zone mdiane est une liste alphabtique oidonne ,
3. une zone infiieuie est foime de boutons de gestion de la liste ci-dessus.
Chacune de ces zones est code pai une instance de Frame(), positionne lune sous lautie giace au
packer, et toutes tiois incluses dans une instance de Tk() (cf. conception lig. 8.3).
Le code de linterface graphique
Mthodologie on se piopose de spaiei le codage de linteiface giaphique de celui des callbacks. Poui
cela on piopose dutilisei lhiitage entie une classe paiente chaige de giei laspect giaphique et une
classe enfant chaige de giei laspect fonctionnel de lapplication contenu dans les callbacks. Comme
nous lavons vu picdemment (cf. section ., p. 2), cest un cas de polymoiphisme de diivation.
Voici donc dans un piemiei temps le code de linteiface giaphique. Linitialisateui cie lauiibut pho-
neList, une liste quil iemplit avec le contenu du chiei contenant les donnes (si le chiei nexiste pas il
est ci), cie la fentie de base root et appelle la mthode makeWidgets().
Ceue mthode, suit la conception giaphique et iemplit chacun des tiois frames.
(a) Conception gniale (b) Dtails des Frame
(c) Linteiface giaphique.
licUvr 8.3 tkPhone.
Les callbacks sont vides (instiuction pass minimale).
Comme tout bon module, un auto-test peimet de viiei le bon fonctionnement (ici le bon aspect) de
linteiface
import tkinter as tk
# class
class Allo_IHM(object):
"""IHM de l'application 'rpertoire tlphonique'."""
def __init__(self, fic):
"""Initialisateur/lanceur de la fentre de base"""
self.phoneList = []
self.fic = fic
f = open(fic)
try:
for line in f:
self.phoneList.append(line[: -1].split('*'))
except: # cration du fichier de rpertoire
f = open(self.fic, "w")
finally:
f.close()
self.phoneList.sort()
self.root = tk.Tk()
self.root.title("Allo !")
self.root.config(relief=tk.RAISED, bd=3)
self.makeWidgets()
self.root.mainloop()
def makeWidgets(self):
"Configure et positionne les widgets"
# frame "saisie" (en haut avec bouton d'effacement)
frameH = tk.Frame(self.root, relief=tk.GROOVE, bd=2)
frameH.pack()
tk.Label(frameH, text="Nom :").grid(row=0, column=0, sticky=tk.W)
8.3 Deux exemples 1
self.nameEnt = tk.Entry(frameH)
self.nameEnt.grid(row=0, column=1, sticky=tk.W, padx=5, pady=10)
tk.Label(frameH, text="Tel :").grid(row=1, column=0, sticky=tk.W)
self.phoneEnt = tk.Entry(frameH)
self.phoneEnt.grid(row=1, column=1, sticky=tk.W, padx=5, pady=2)
b = tk.Button(frameH, text="Effacer ", command=self.clear)
b.grid(row=2, column=0, columnspan=2, pady=3)
# frame "liste" (au milieu)
frameM = tk.Frame(self.root)
frameM.pack()
self.scroll = tk.Scrollbar(frameM)
self.select = tk.Listbox(frameM, yscrollcommand=self.scroll.set, height=6)
self.scroll.config(command=self.select.yview)
self.scroll.pack(side=tk.RIGHT, fill=tk.Y, pady=5)
self.select.pack(side=tk.LEFT, fill=tk.BOTH, expand=1, pady=5)
## remplissage de la Listbox
for i in self.phoneList:
self.select.insert(tk.END, i[0])
self.select.bind("<Double-Button-1>", lambda event: self.afficher(event))
# frame "boutons" (en bas)
frameB = tk.Frame(self.root, relief=tk.GROOVE, bd=3)
frameB.pack(pady=3)
b1 = tk.Button(frameB, text="Ajouter ", command=self.ajouter)
b2 = tk.Button(frameB, text="Supprimer", command=self.supprimer)
b3 = tk.Button(frameB, text="Afficher ", command=self.afficher)
b1.pack(side=tk.LEFT, pady=2)
def ajouter(self):
pass
def supprimer(self):
pass
def afficher(self, event=None):
pass
def clear(self):
pass
# auto-test ---------------------------------------------------------
if __name__ == '__main__':
app = Allo_IHM('phones.txt') # instancie l'IHM
Le code de lapplication
On va maintenant utilisei le module de la faon suivante
On impoite la classe Allo_IHM depuis le module picdent ,
on cie une classe Allo qui en diive ,
son initialisateui appelle linitialisateui de la classe de base poui hiitei de toutes ses caiactiis-
tiques ,
il ieste suichaigei les callbacks.
Enn, le sciipt instancie lapplication.
# imports
from tkPhone_IHM import Allo_IHM
# classes
class Allo(Allo_IHM):
"""Rpertoire tlphonique."""
def __init__(self, fic='phones.txt'):
"Constructeur de l'IHM."
Allo_IHM.__init__(self, fic)
def ajouter(self):
# maj de la liste
ajout = ["", ""]
ajout[0] = self.nameEnt.get()
ajout[1] = self.phoneEnt.get()
if (ajout[0] == "") or (ajout[1] == ""):
return
self.phoneList.append(ajout)
self.phoneList.sort()
# maj de la listebox
self.select.delete(0, tk.END)
self.clear()
self.nameEnt.focus()
# maj du fichier
f = open(self.fic, "a")
f.write("%s*%s\n" % (ajout[0], ajout[1]))
f.close()
def supprimer(self):
self.clear()
# maj de la liste
retrait = ["", ""]
retrait[0], retrait[1] = self.phoneList[int(self.select.curselection()[0])]
self.phoneList.remove(retrait)
# maj de la listebox
self.select.delete(0, tk.END)
# maj du fichier
f = open(self.fic, "w")
f.write("%s*%s\n" % (i[0], i[1]))
f.close()
def afficher(self, event=None):
self.clear()
name, phone = self.phoneList[int(self.select.curselection()[0])]
self.nameEnt.insert(0, name)
self.phoneEnt.insert(0, phone)
def clear(self):
self.nameEnt.delete(0, tk.END)
self.phoneEnt.delete(0, tk.END)
# programme principal ----------------------------------------------------
app = Allo() # instancie l'application
8.3.2 IDLE, un exemple avec menu
Toutes les distiibutions Python compoite lapplication IDLE, linteipiteui/diteui ciit en Python
pai Guido van RossUx
1
. Ceue application se pisente sous laspect dune inteiface giaphique complete
(lig. 8.4), avec menu.
Cest un souice Python dont le code est disponible
2
et constitue lui seul un couis complet tkinter.
1. Dans ceitaines distiibutions GNU/Linux, IDLE est un package paiticuliei.
2. Mais il est tiop volumineux poui tie iepioduit dans ces notes. . .
8.3 Deux exemples 3
(a) Linteipiteui dlDLE
(b) Lditeui dlDLE
licUvr 8.4 lDLE.
Cu~vi1vr 9
elques teniques avances de programmation
Ce chapitie pisente quelques exemples de techniques avances dans les tiois paiadigmes
que suppoite Python, les piogiammations piocduiale, objet et fonctionnelle.
9.1 Teniques procdurales
9.1.1 Le pouvoir de lintrospection
Lintiospection est un des atouts de Python. On entend pai l la possibilit dobtenii des infoimations
sui les objets manipuls pai le langage.
La fonction help()
On peut tout daboid utilisei la fonction pidnie help().
Ceue fonction est auto-document
>>> help()
Welcome to Python 2.7! This is the online help utility.
If this is your first time using Python, you should definitely check out
the tutorial on the Internet at http://docs.python.org/tutorial/.
Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules. To quit this help utility and
return to the interpreter, just type "quit".
To get a list of available modules, keywords, or topics, type "modules",
"keywords", or "topics". Each module also comes with a one-line summary
of what it does; to list the modules whose summaries contain a given word
such as "spam", type "modules spam".
help> []
no Python documentation found for '[]'
help> quit
You are now leaving help and returning to the Python interpreter.
If you want to ask for help on a particular object directly from the
interpreter, you can type "help(object)". Executing "help('string')"
has the same effect as typing a particular string at the help> prompt.
>>>
Si on lappelle pai exemple sui lobjet liste, on obtient (vue paitielle)
Techniques avances
>>> help([])
Help on list object:
class list(object)
| list() -> new empty list
| list(iterable) -> new list initialized from iterable`s items
|
| Methods defined here:
|
| __add__(...)
| x.__add__(y) <==> x+y
|
| __contains__(...)
| x.__contains__(y) <==> y in x
|
...
|
| reverse(...)
| L.reverse() -- reverse *IN PLACE*
|
| sort(...)
| L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
| cmp(x, y) -> -1, 0, 1
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
|
| __new__ = <built-in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T
La fonction utilitaiie printInfo() ltie les mthodes disponibles de son aigument ne commenant pas
pai _, et ache les docstrings associs sous une foime plus lisible que help()
def printInfo(object):
"""Filtre les mthodes disponibles de <object>."""
methods = [method for method in dir(object)
if callable(getattr(object, method)) and not method.startswith('_')]
for method in methods:
print(getattr(object, method).__doc__)
Pai exemple, lappel
printInfo([])
ache la documentation
L.append(object) -- append object to end
L.count(value) -> integer -- return number of occurrences of value
L.extend(iterable) -- extend list by appending elements from the iterable
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
L.insert(index, object) -- insert object before index
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.
L.reverse() -- reverse *IN PLACE*
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1
Les fonctions type(), dir() et id()
Elle fouinissent iespectivement le type, les mthodes et la localisation mmoiie (unique) dun objet
>>> li = [1, 2, 3]
>>>
>>> type(li)
<type 'list'>
>>>
>>> dir(li)
9.1 Techniques procdurales
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__',
'__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
'__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__',
'__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__',
'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__',
'__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__',
'__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop',
'remove', 'reverse', 'sort']
>>>
>>> id(li)
66850208
Le module sys
Ce module fouinit nombie dinfoimations gniales, entie auties
>>> import sys
>>>
>>> sys.executable
'/usr/bin/python3'
>>>
>>> sys.platform
'linux2'
>>>
>>> sys.version
'3.2.3 (default, Oct 19 2012, 20:13:42) \n[GCC 4.6.3]'
>>>
>>> sys.argv
['/usr/bin/ipython3']
>>>
>>> sys.path
['',
'C:\\Python27\\lib\\site-packages\\spyderlib\\utils\\external',
'C:\\Python27\\lib\\site-packages\\docopt-0.5.0-py2.7.egg',
...
'C:\\Python27\\lib\\site-packages\\Pythonwin',
'C:\\Python27\\lib\\site-packages\\wx-2.8-msw-unicode']
>>>
>>> sys.modules
{'matplotlib._tri': <module 'matplotlib._tri' from 'C:\Python27\lib\site-packages\matplotlib\_tri.pyd'>,
'numpy.core.info': <module 'numpy.core.info' from 'C:\Python27\lib\site-packages\numpy\core\info.pyc'>,
'matplotlib.artist': <module 'matplotlib.artist' from 'C:\Python27\lib\site-packages\matplotlib\artist.pyc'>,
...
9.1.2 Gestionnaire de contexte (ou bloc gard) :
Ceue syntaxe simplie le code en assuiant que ceitaines opiations sont excutes avant et apies un
bloc dinstiuctions donn. lllustions ce mcanisme sui un exemple classique ou il impoite de feimei le
chiei utilis
# au lieu de ce code :
fh = None
try:
fh = open(filename)
for line in fh:
process(line)
finally:
if fh is not None:
fh.close()
# il est plus simple d'crire :
with open(filename) as fh:
for line in fh:
process(line)
9.1.3 Utiliser un dictionnaire pour lancer des fonctions ou des mthodes
Lide est dexcutei diientes paities de code en fonction de la valeui dune vaiiable de contiole.
On peui se seivii de ceue technique poui implmentei un menu textuel.
8 Techniques avances
animaux = []
nombre_de_felins = 0
def gererChat():
global nombre_de_felins
print("Miaou")
animaux.append("flin")
nombre_de_felins += 1
def gererChien():
print("Ouah")
animaux.append("canid")
def gererOurs():
print("Attention au *OUILLE* !")
animaux.append("plantigrade")
# =============================================================================
dico = {
"chat" : gererChat,
"chien" : gererChien,
"ours" : gererOurs
}
betes = ["chat", "ours", "chat", "chien"] # une liste d'animaux rencontrs
for bete in betes:
dico[bete]() # appel de la fonction correspondante
nf = nombre_de_felins
print("nous avons rencontr {} flin(s)".format(nf))
print("Les animaux rencontrs sont : {}".format(', '.join(animaux), end=" ")
"""
Miaou
Attention au *OUILLE* !
Miaou
Ouah
nous avons rencontr 2 flin(s)
Les animaux rencontrs sont : flin, plantigrade, flin, canid
"""
9.1.4 Les fonctions rcursives
Dnition
b
Une fonction icuisive peut sappelei elle-mme.
Pai exemple, tiiei un tableau de N lments pai oidie cioissant cest extiaiie le plus petit lment puis
tiiei le tableau iestant N 1 lments.
Les fonction icuisives sont souvent utilises poui tiaitei les stiuctuies aiboiescentes comme les i-
peitoiies dans les systemes de chieis des disques duis. Voici lexemple dune fonction qui ache icui-
sivement les chieis dun ipeitoiie fouini en paiametie
>>> from os import listdir
>>> from os.path import isdir, join
>>>
>>> def listeFichiersPython(repertoire):
... noms = listdir(repertoire)
... for nom in noms:
... if nom in (".", ".."):
... continue
... if isdir(nom):
... listeFichiersPython(join(repertoire, nom))
... elif nom.endswith(".py") or nom.endswith(".pyw"):
... print("Fichiers Python :", join(repertoire, nom))
...
>>>
>>> listeFichiersPython(r"D:\pythutil")
9.1 Techniques procdurales 9
('Fichiers Python :', 'D:\\pythutil\\easygui\\easygui.py')
('Fichiers Python :', 'D:\\pythutil\\easygui\\setup.py')
('Fichiers Python :', 'D:\\pythutil\\float_m.py')
('Fichiers Python :', 'D:\\pythutil\\Morse\\geneSon.py')
('Fichiers Python :', 'D:\\pythutil\\Morse\\morse.py')
('Fichiers Python :', 'D:\\pythutil\\Morse\\morse_m.py')
('Fichiers Python :', 'D:\\pythutil\\ok_m.py')
('Fichiers Python :', 'D:\\pythutil\\plot_m.py')
('Fichiers Python :', 'D:\\pythutil\\startup.py')
('Fichiers Python :', 'D:\\pythutil\\verif_m.py')
Dans ceue dnition, on commence pai constituei dans la vaiiable noms la liste des chieis et ipei-
toiies du ipeitoiie donn en paiametie. Puis, dans une boucle for, tant que llment examin est un
ipeitoiie, on i-appelle la fonction sui lui poui descendie dans laiboiescence de chieis tant que la
condition terminale (if nom in (".", "..") :) est fausse.
9.1.5 Les listes dnies en comprhension
Les listes dnies en compihension , souvent appeles compihension de listes , peimeuent de
gniei ou de modiei des collections de donnes pai une ciituie lisible, simple et peifoimante.
Ceue constiuction syntaxique se iappioche de la notation utilise en mathmatiques
{x
2
|x [2, 11[} [x**2 for x in range(2, 11)] [4, 9, 16, 25, 36, 49, 64, 81, 100]
Dnition
b
Une liste en compihension est quivalente une boucle for qui constiuiiait la mme liste en utilisant
la mthode append().
Les listes en compihension sont utilisables sous tiois foimes.
Premire forme expiession dune liste simple de valeuis
result1 = [x+1 for x in une_seq]
# a le mme effet que :
result2 = []
for x in une_seq:
result2.append(x+1)
Deuxime forme expiession dune liste de valeuis avec ltiage
result3 = [x+1 for x in une_seq if x > 23]
result4 = []
for x in une_seq:
if x > 23:
result4.append(x+1)
Troisime forme expiession dune combinaison de listes de valeuis
result5 = [x+y for x in une_seq for y in une_autre]
result6 = []
for x in une_seq:
for y in une_autre:
result6.append(x+y)
Des utilisations ties pythoniques
valeurs_s = ["12", "78", "671"]
# conversion d'une liste de chanes en liste d'entier
valeurs_i = [int(i) for i in valeurs_s] # [12, 78, 671]
# calcul de la somme de la liste avec la fonction intgre sum
print(sum([int(i) for i in valeurs_s])) # 761
s = 0
for i in valeurs_s:
s = s + int(i)
print(s) # 761
# Initialisation d'une liste 2D
multi_liste = [[0]*2 for ligne in range(3)]
print(multi_liste) # [[0, 0], [0, 0], [0, 0]]
Autie exemple
>>> C_deg = range(-20, 41, 5)
>>> F_deg = [(9.0/5)*c + 32 for c in C_deg]
>>> table = [C_deg, F_deg]
>>> for i in range(len(table[0])):
... print(table[0][i], "=>", table[1][i])
...
-20 => -4.0
-15 => 5.0
-10 => 14.0
-5 => 23.0
0 => 32.0
5 => 41.0
10 => 50.0
15 => 59.0
20 => 68.0
25 => 77.0
30 => 86.0
35 => 95.0
40 => 104.0
9.1.6 Les dictionnaires dnis en comprhension
Comme poui les listes, on peut dnii des dictionnaiies en compihension
>>> {n : x**2 for n, x in enumerate(range(5))}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
On note dutilisation des accolades et du double point caiactiistiques de la syntaxe du dictionnaiie.
9.1.7 Les ensembles dnis en comprhension
De mme, on peut dnii des ensembles en compihension
>>> {n for n in range(5)}
set([0, 1, 2, 3, 4])
Dans ce cas les accolades sont caiactiistiques de la syntaxe de lensemble.
9.1.8 Les gnrateurs et les expressions gnratrices
Les gnrateurs
Dnition
b
Un gniateui est une fonction qui mmoiise son tat au moment de ietouinei une valeui.
La tiansmission dune valeui seectue en utilisant le mot cl yield.
Les gniateuis fouinissent un moyen de gniei des excutions paresseuses, ce qui signie quelles ne
calculent que les valeuis iellement demandes. Ceci peut saviei beaucoup plus ecace (en teimes de
mmoiie) que le calcul, pai exemple, dune noime liste en une seule fois.
Voici un exemple de gniateui qui fouinit un compteui dentieis (initialis 0) infiieuis ou gaux
laigument du gniateui
def counter(maximum):
"""gnre des entiers infrieurs ou gaux <maximum>."""
i = 0
while True:
yield i
if i == maximum: # arrt de gnrateur
return
i = i + 1
for val in counter(5):
print(val, end=" ")
9.1 Techniques procdurales 1
Ce qui pioduit
0 1 2 3 4 5
Les expressions gnratrices
Syntaxe
Une expiession gniatiice possede une syntaxe piesque identique celle des listes en compihen-
sion , la diience est quune expiession gniatiice est entouie de paientheses.
Utilisation
Les expiessions gniatiices sont aux gniateuis ce que les listes en compihension sont aux fonc-
tions.
Pai exemple lexpiession suivante gneie la ciation dun million de valeuis en mmoiie avant de
commencei la boucle
for i in [x**2 for x in range(1000000)]:
Alois que dans lexpiession suivante, la boucle commence immdiatement et gneie le million de va-
leuis au fui et mesuie des demandes
for i in (x**2 for x in range(1000000)):
9.1.9 Les fonctions incluses
La syntaxe de dnition des fonctions en Python peimet tout fait demboter leui dnition. Distin-
guons deux cas demploi
ldiome de la fonction fabiique ienvoyant une feimetuie
>>> def creer_plus(ajout):
... """Fonction 'fabrique'."""
... def plus(increment):
... """Fonction 'fermeture' : utilise des noms locaux creer_plus()."""
... return increment + ajout
... return plus
...
>>>
>>> p = creer_plus(23)
>>> q = creer_plus(42)
>>>
>>> print("p(100) =", p(100))
('p(100) =', 123)
>>> print("q(100) =", q(100))
('q(100) =', 142)
lonction fabiique ienvoyant une classe
>>> class CasNormal:
... def uneMethode(self):
... print("normal")
...
>>>
>>> class CasSpecial:
... def uneMethode(self):
... print("spcial")
...
>>>
>>> def casQuiConvient(estNormal=True):
... """Fonction fabrique renvoyant une classe."""
... if estNormal:
... return CasNormal()
... else:
... return CasSpecial()
...
>>>
>>> une_instance = casQuiConvient()
>>> une_instance.uneMethode()
normal
>>> une_instance = casQuiConvient(False)
>>> une_instance.uneMethode()
spcial
9.1.10 Les dcorateurs
Les dcoiateuis Python sont des fonctions qui peimeuent deectuei des pitiaitements lois de lappel
dune fonction, dune mthode ou dune classe.
Syntaxe
Soit deco() un dcoiateui. Poui dcoiei une fonction on ciit

def deco():
...
@deco
def fonction(arg1, arg2, ...):
pass
Une fonction peut tie multi-dcoie
def f1():
...
def f2():
...
def f3():
...
@f1 @f2 @f3
def g():
pass
Voici un exemple simple
def unDecorateur(f):
cptr = 0
def _interne(*args, **kwargs):
nonlocal cptr
cptr = cptr + 1
print("Fonction decore :", f.__name__, ". Appel numro :", cptr)
return f(*args, **kwargs)
return _interne
@unDecorateur
def uneFonction(a, b):
return a + b
def autreFonction(a, b):
return a + b
# programme principal ===============================================
## utilisation d'un dcorateur
print(uneFonction(1, 2))
## utilisation de la composition de fonction
autreFonction = unDecorateur(autreFonction)
print(autreFonction(1, 2))
print(uneFonction(3, 4))
print(autreFonction(6, 7))
"""
Fonction decore : uneFonction. Appel numro : 1
3
Fonction decore : autreFonction. Appel numro : 1
3
Fonction decore : uneFonction. Appel numro : 2
9.2 Techniques objets 3
7
Fonction decore : autreFonction. Appel numro : 2
13
"""
9.2 Teniques objets
Comme nous lavons vu lois du chapitie picdent, Python est un langage completement objet. Tous
les types de base ou diivs sont en ialit des types abstiaits de donnes implments sous foime de
classe. Toutes ces classes diivent dune unique classe de base, anctie de toutes les auties la classe
object.
9.2.1 Functor
En Python un objet fonction ou functor est une ifience tout objet appelable
1
fonction, fonction
anonyme lambda
2
, mthode, classe. La fonction pidnie callable() peimet de testei ceue piopiit
>>> def maFonction():
... print('Ceci est "appelable"')
...
>>> callable(maFonction)
True
>>> chaine = 'Ceci est "appelable"'
>>> callable(chaine)
False
ll est possible de tiansfoimei les instances dune classe en functoi si la mthode spciale __call__()
est dnie dans la la classe
>>> class A:
... def __init__(self):
... self.historique = []
... def __call__(self, a, b):
... self.historique.append((a, b))
... return a + b
...
>>> a = A()
>>> a(1, 2)
3
>>> a(3, 4)
7
>>> a(5, 6)
11
>>> a.historique
[(1, 2), (3, 4), (5, 6)]
9.2.2 Les accesseurs
Le problme de lencapsulation
Dans le paiadigme objet, ltat dun objet est priv, les auties objets nont pas le dioit de le consultei
ou de le modiei.
Classiquement, on distingue les visibilits suivantes
publique ,
piotge ,
piive.
En Python, tous les auiibuts (donnes, mthodes) sont publics '
On peut nanmoins amlioiei cet tat de fait.
Une simple convention couiante est dutilisei des noms commenant pai un soulign (_) poui signiei
auiibut piotg. Pai exemple _attrib. Ceue solution est avant tout destine vitei les collisions de noms
dans le cas o lauiibut seiait iedni dans une classe diive.
1. callable en anglais.
2. Ceue notion seia dveloppe section 9.3.1, p. .
Mais Python noblige iien, cest au dveloppeui de iespectei la convention '
Python piopose un mcanisme
1
poui mulei les auiibut piivs les identicateuis de la classe com-
mencent pai deux souligns. Pai exemple __ident. Mais ceue piotection ieste dclaiative et noie pas
une scuiit absolue.
La solution property
Le piincipe de lencapsulation est mis en uvie pai la notion de piopiit.
Dnition
b
Une piopiit (property) est un auiibut dinstance possdant des fonctionnalits spciales.
Deux syntaxes implmentent ceue solution.
La piemieie dnit explicitement la piopiit x et ses quatie paiameties (dans loidie mthode de
lectuie, mthode de modication, mthode de suppiession, chaine de documentation)
#!/usr/bin/python3
#-*- coding: utf-8 -*-
# fichier : property.py
class C:
def __init__(self):
self._ma_propriete = None
def getx(self):
"""getter."""
return self._x
def setx(self, value):
"""setter."""
self._x = value
def delx(self):
"""deleter."""
del self._x
x = property(getx, setx, delx, "Je suis la proprit 'x'.")
# auto-test =========================================================
if __name__ == '__main__':
test = C()
test.x = 10 # setter
print(test.x) # getter
print(C.x.__doc__) # documentation
"""
10
Je suis la proprit 'x'.
"""
La seconde, plus simple, utilise la syntaxe des dcoiateuis. On iemaique que la chaine de documenta-
tion de la property est ici la docstring de la dnition de la piopiit x
#!/usr/bin/python3
#-*- coding: utf-8 -*-
# fichier : property2.py
class C:
def __init__(self):
self._x = None
@property
1. le name mangling.
9.2 Techniques objets
def x(self):
"""Je suis la proprit 'x'."""
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
# auto-test =========================================================
if __name__ == '__main__':
test = C()
test.x = 10 # setter
print(test.x) # getter
print(C.x.__doc__) # documentation
"""
10
Je suis la proprit 'x'.
"""
Un autre exemple : la classe Cercle
Schma de conception nous allons tout daboid dnii une classe Point que nous utiliseions comme
classe de base de la classe Cercle.
licUvr 9.1 Conception UML de la classe Cercle.
Voici le code de la classe Point
class Point:
def __init__(self, x=0, y=0):
self.x, self.y = x, y
@property
def distance_origine(self):
return math.hypot(self.x, self.y)
def __eq__(self, other):
return self.x == other.x and self.y == other.y
def __str__(self):
Techniques avances
return "({0.x!s}, {0.y!s})".format(self)
Lutilisation de property peimet un acces en lecture seule au isultat de la mthode distance_origine()
considie alois comme un simple auiibut (cai on lutilise sans paienthese)
p1, p2 = Point(), Point(3, 4)
print(p1 == p2) # False
print(p2, p2.distance_origine) # (3, 4) 5.0
De nouveau, les mthodes ienvoyant un simple ouant seiont utilises comme des auiibuts giace
property
class Cercle(Point):
def __init__(self, rayon, x=0, y=0):
super().__init__(x, y)
self.rayon = rayon
@property
def aire(self): return math.pi * (self.rayon ** 2)
@property
def circonference(self): return 2 * math.pi * self.rayon
@property
def distance_bord_origine(self):
return abs(self.distance_origine - self.rayon)
Voici la syntaxe peimeuant dutilisei la mthode iayon comme un auiibut en lecture-criture. Remai-
quez que la mthode rayon() ietouine lauiibut piotg __rayon qui seia modi pai le seer (la mthode
modicatiice)
@property
def rayon(self):
return self.__rayon
@rayon.setter
def rayon(self, rayon):
assert rayon > 0, "rayon strictement positif"
self.__rayon = rayon
Exemple dutilisation des instances de Cercle
def __eq__(self, other):
return (self.rayon == other.rayon
and super().__eq__(other))
def __str__(self):
return ("{0.__class__.__name__}({0.rayon!s}, {0.x!s}, "
"{0.y!s})".format(self))
if __name__ == "__main__":
c1 = Cercle(2, 3, 4)
print(c1, c1.aire, c1.circonference)
# Cercle(2, 3, 4) 12.5663706144 12.5663706144
print(c1.distance_bord_origine, c1.rayon) # 3.0 2
c1.rayon = 1 # modification du rayon
print(c1.distance_bord_origine, c1.rayon) # 4.0 1
9.2.3 Le du typing
ll existe un style de piogiammation ties pythonique appel duck typing
Sil mare comme un canard et cancane comme un canard, alors cest un canard ! .
Cela signie que Python ne sintiesse quau comportement des objets. Pai exemple un objet chiei
peut tie ci pai open() ou pai une instance de io.StringIO. Les deux appioches oient la mme APl
(inteiface de piogiammation), cest--diie les mmes mthodes et lutilisateui lutilise de la mme faon.
Autie exemple
class Duck:
def quack(self):
print("Quaaaaaack !")
9.3 Techniques fonctionnelles
def feathers(self):
print("The duck has white and gray feathers.")
class Person:
def quack(self):
print("The person imitates a duck.")
def feathers(self):
print("The person takes a feather from the ground and shows it.")
def in_the_forest(duck):
duck.quack()
duck.feathers()
def game():
donald = Duck()
john = Person()
in_the_forest(donald)
in_the_forest(john)
if __name__ == '__main__':
game()
"""
Quaaaaaack !
The duck has white and gray feathers.
The person imitates a duck.
The person takes a feather from the ground and shows it.
"""
9.3 Teniques fonctionnelles
9.3.1 Directive lambda
lssue de langages fonctionnels (comme Lisp), la diiective lambda peimet de dnii un objet fonction
anonyme dont le bloc dinstiuctions est limit une expiession dont lvaluation fouinit la valeui de ietoui
de la fonction.
Syntaxe
lambda [parameters]:expression
Pai exemple ceue fonction ietouine s si son aigument est diient de 1, une chaine vide sinon
>>> s = lambda x: "" if x == 1 else "s"
>>>
>>> s(3)
's'
>>> s(1)
''
Auties exemples illustiant les diiences de syntaxe fonction/lambda
>>> def f(x):
... return x**2
...
>>> print(f(8))
64
>>>
>>> g = lambda x : x**2
>>> print(g(8))
64
9.3.2 Les fonctions map, filter et reduce
La piogiammation fonctionnelle est un paiadigme de piogiammation qui consideie le calcul en tant
quvaluation de fonctions mathmatiques. Elle souligne lapplication des fonctions, contiaiiement au
modele de piogiammation impiative qui met en avant les changements dtat
1
. Elle iepose sui tiois
concepts mapping, ltering et reducing qui sont implments en Python pai tiois fonctions map(), fil-
ter() et reduce().
La fonction map() :
map() applique une fonction chaque lment dune squence et ietouine un itiateui
>>> map(lambda x:x, range(10))
<map object at 0x7f3a80104f50>
>>>
>>> list(map(lambda x:x, range(10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
On iemaique que map() peut tie iemplace pai un gniateui en compihension.
La fonction filter() :
filter() constiuit et ienvoie un itiateui sui une liste qui contient tous les lments de la squence
initiale ipondant au ciiteie
function(element) == True
>>> filter(lambda x: x>0, range(10))
<filter object at 0x7f3a801105d0>
De mme filter() peut tie iemplace pai un gniateui en compihension.
La fonction reduce() :
reduce() est une fonction du module functools. Elle applique de faon cumulative une fonction de
deux aiguments aux lments dune squence, de gauche dioite, de faon iduiie ceue squence une
seule valeui quelle ienvoie
>>> def somme(x, y):
... print x, '+', y
... return x + y
...
>>> reduce(somme, [1, 2, 3, 4])
1 + 2
3 + 3
6 + 4
10
>>>
>>> sum([1, 2, 3, 4])
10
On iemaique que reduce() peut tie iemplace pai une des fonctions suivantes all(), any(), max(),
min() ou sum().
9.3.3 Les applications partielles de fonctions
lssue de la piogiammation fonctionnelle, une PlA (application paitielle de fonction) de n paiameties
piend le piemiei aigument comme paiametie xe et ietouine un objet fonction (ou instance) utilisant les
n-1 aiguments iestants.
Les PlA sont ties utiles dans les fonctions de calcul compoitant de nombieux paiameties. On peut en
xei ceitains et ne faiie vaiiei que ceux sui lesquels on veut agii.
1. cf. Wikipedia
9.4 Les tests 9
>>> from functools import partial
>>>
>>> def f(m, c, d, u):
... return 1000*m + 100*c + 10*d + u
...
>>>
>>> f(1, 2, 3, 4)
1234
>>>
>>> g = partial(f, 1, 2, 3)
>>> g(4)
1234
>>> h = partial(f, 1, 2)
>>> h(3, 4)
1234
Elles sont aussi utiles poui fouinii des modeles paitiels de widgets, qui ont souvent de nombieux
paiameties. Dans lexemple suivant, on iednit la classe Button en xant ceitains de ses auiibuts (qui
peuvent toujouis tie suichaigs)
from functools import partial
root = tk.Tk()
# instanciation partielle de classe :
MonBouton = partial(tk.Button, root, fg='purple', bg='green')
MonBouton(text="Bouton 1").pack()
MonBouton(text="Bouton 2").pack()
MonBouton(text="QUITTER", bg='red', fg='black',
command=root.quit).pack(fill=tk.X, expand=True)
root.title("PFA !")
root.mainloop()
Ce isultat est illusti pai la guie 9.2.
licUvr 9.2 PlA appliqu un widget
9.4 Les tests
Des lois quun piogiamme dpasse le stade du petit sciipt, le piobleme des eiieuis et donc des tests
se pose invitablement.
Dnition
b
Un test consiste appelei la fonctionnalit spcie dans la documentation, avec un scnaiio qui
coiiespond un cas dutilisation, et viiei que ceue fonctionnalit se compoite comme pivu.
9.4.1 Tests unitaires et tests fonctionnels
On distingue deux familles de test
Tests unitaires validations isoles du fonctionnement dune classe, dune mthode ou dune fonction.
Pai convention, chaque module est associ un module de tests unitaiies, plac dans un ipei-
toiie tests du paquet. Pai exemple, un module nomm calculs.py auia un module de tests nomm
tests/test_calculs.py
Tests fonctionnels piennent lapplication complete comme une boite noiie et la manipulent comme
le feiait lutilisateui nal. Ces tests doivent passei pai les mmes inteifaces que celles fouinies aux
utilisateuis, cest pouiquoi ils sont spciques la natuie de lapplication et plus dlicats meuie
en uvie.
Dans ceue intioduction, nous nous limiteions une couite pisentation des tests unitaiies.
9.4.2 Module unittest
Le module Python unittest fouinit loutil PyUnit, outil que lon ietiouve dans dauties langages JUnit
(Java), NUnit (.Net), JSUnit (Javasciipt), tous diivs dun outil initialement dvelopp poui le langage
SmallTalk SUnit.
PyUnit piopose une classe de base, TestCase. Chaque mthode implmente dans une classe diive
de TestCase, et pixe de test_, seia considie comme un test unitaiie
1
"""Module de calculs."""
# fonctions
def moyenne(*args):
"""Renvoie la moyenne."""
length = len (args)
sum = 0
for arg in args:
sum += arg
return sum/length
def division(a, b):
"""Renvoie la division."""
return a/b
"""Module de test du module de calculs."""
# import ----------------------------------------------------------------------
import sys
import unittest
from os.path import abspath, dirname
sys.path.insert(0, dirname(dirname((abspath(__file__)))))
from calculs import moyenne, division
# dfinition de classe et de fonction -----------------------------------------
class CalculTest(unittest.TestCase):
def test_moyenne(self):
self.assertEquals(moyenne(1, 2, 3), 2)
self.assertEquals(moyenne(2, 4, 6), 4)
def test_division(self):
self.assertEquals(division(10, 5), 2)
self.assertRaises(ZeroDivisionError, division, 10, 0)
def test_suite():
tests = [unittest.makeSuite(CalculTest)]
return unittest.TestSuite(tests)
# auto-test ===================================================================
if __name__ == '__main__':
unittest.main()
"""
..
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
"""
1. cf. [], p. 11.
9.5 La documentation des sources 81
Poui eectuei une campagne de tests , il ieste ciei un sciipt qui
iecheiche tous les modules de test leuis noms commencent pai test_ et ils sont contenus dans un
ipeitoiie tests ,
icupeie la suite, ienvoye pai la fonction globale test_suite ,
cie une suite de suites et lance la campagne.
9.5 La documentation des sources
Duiant la vie dun piojet, on distingue plusieuis types de documentation
les documents de spcication (ensemble explicite dexigences satisfaiie) ,
les documents techniques auachs au code ,
les manuels dutilisation et auties documents de haut niveau.
Les documents techniques voluent au iythme du code et peuvent donc tie tiaits comme lui ils
doivent pouvoii tie lus et manipuls avec un simple diteui de texte.
ll existe deux outils majeuis poui concevoii des documents poui les applications Python
reStructuredText (ou reST) un foimat eniichi ,
les doctests compatibles avec le foimat reST. lls peimeuent de combinei les textes applicatifs avec les
tests.
9.5.1 Le format reST
Le foimat reStructuredText, communment appel reST est un systeme de balises utilis poui foimatei
des textes.
A la diience de L
A
T
E
X ou dHTML il eniichit le document de manieie non intiusive , cest--diie
que les chieis iestent diiectement lisibles.
docutils
Le piojet docutils, qui inclut linteipiteui reST, fouinit un jeu dutilitaiies
rst2html gneie un iendu html avec une feuille de style css intgie ,
rst2latex cie un chiei L
A
T
E
X quivalent ,
rst2s5 constiuit une pisentation au foimat s, qui peimet de ciei des pisentations inteiactives en
HTML.
Sphinx
Sphinx est un logiciel libie de type gniateui de documentation. ll sappuie sui des chieis au foimat
ieStiuctuiedText, quil conveitit en HTML, PDl, man, et auties foimats.
De nombieux piojets utilisent Sphinx poui leui documentation ocielle, tels que Python, Django,
Selenium, Uiwid, ou encoie Bazaai.
rst2pdf
Pai ailleuis, le piogiamme rst2pdf gneie diiectement une documentation au foimat PDl.
Voici un exemple
1
simple de chiei texte au foimat ieST.
On iemaique entie auties que
la piincipale balise est la ligne blane qui spaie les diientes stiuctuies du texte ,
la stiuctuiation se fait en soulignant les tities des sections de diients niveaux avec des caiacteies
de ponctuation (= - _ : , etc.). A chaque fois quil iencontie un texte ainsi soulign, linteipiteui
associe le caiacteie utilis un niveau de section ,
un titie est gnialement soulign et suilign avec le mme caiacteie, comme dans lexemple sui-
vant
1. cf. [], p. 11
======================
Fichier au format reST
======================
Section 1
=========
On est dans la section 1.
Sous-section
::::::::::::
Ceci est une sous-section.
Sous-sous-section
.................
Ceci est une sous-sous-section.
.. et ceci un commentaire
Section 2
=========
La section 2 est ``beaucoup plus`` **intressante** que la section 1.
Section 3
=========
La section 2 est un peu vantarde : la section 1 est *trs bien*.
Une image au format "png"
:::::::::::::::::::::::::
.. figure:: helen.png
:scale: 50%
Lutilitaiie rst2pdf, appliqu ce chiei, pioduit le chiei de mme nom ( lig. 9.3) mais avec
lextension .pdf.
9.5.2 Le module doctest
Le piincipe du literate programming (ou piogiammation liuiaiie) de Donald KNU1u consiste mlei
dans le souice le code et la documentation du piogiamme.
Ce piincipe t iepiis en Python poui documentei les APl via les chaines de documentation (docstring).
Des piogiammes comme Epydoc peuvent alois les extiaiie des modules poui composei une documentation
spaie.
ll est possible dallei plus loin et dincluie dans les chaines de documentation des exemples dutilisation,
ciits sous la foime de session inteiactive.
Examinons deux exemples.
Poui chacun, nous donneions dune pait le souice muni de sa chaine de documentation dans lequel le
module standaid doctest peimet dextiaiie puis de lancei ces sessions poui viiei quelles fonctionnent
et, dautie pait une captuie dcian de lexcution.
Premier exemple : documentation1.py
# -*- coding: utf-8 -*-
"""Module d'essai de doctest."""
import doctest
def somme(a, b):
"""Renvoie a + b.
>>> somme(2, 2)
4
>>> somme(2, 4)
6
"""
return a+b
if __name__ == '__main__':
print("{:-^40}".format(" Mode silencieux "))
doctest.testmod()
print("Si tout va bien, on a rien vu !")
print("\n{:-^40}".format(" Mode dtaill "))
doctest.testmod(verbose=True)
Lexcution de ce chiei donne
----------- Mode silencieux ------------
Si tout va bien, on a rien vu !
----------- Mode dtaill ------------
Trying:
somme(2, 2)
Expecting:
4
ok
Trying:
somme(2, 4)
Expecting:
6
ok
1 items had no tests:
__main__
1 items passed all tests:
2 tests in __main__.somme
2 tests in 2 items.
2 passed and 0 failed.
Test passed.
Deuxime exemple : documentation2.py
# -*- coding: UTF-8 -*-
"""Module d'essai de doctest."""
# fonctions
def accentEtrange(texte):
"""Ajoute un accent trange un texte.
Les 'r' sont Tripls, les 'e' suivi d'un 'u'
Exemple :
>>> texte = "Est-ce que tu as regard la tl hier soir ? Il y avait un thma sur les ramasseurs d'escargots en
Laponie, ils en bavent..."
>>> accentEtrange(texte)
Est-ceu queu tu as rRreugarRrd la tl hieurRr soirRr ? Il y avait un thma surRr leus rRramasseuurRrs d'
euscarRrgots eun Laponieu, ils eun baveunt...
Cette technique permet d'internationnaliser les applications
pour les rendre compatibles avec certaines rgions franaises.
"""
texte = texte.replace('r', 'rRr')
print(texte.replace('e', 'eu'))
def _test():
import doctest
doctest.testmod(verbose=True)
if __name__ == '__main__':
_test()
Lexcution de ce chiei donne
Trying:
texte = "Est-ce que tu as regard la tl hier soir ? Il y avait un thma sur les ramasseurs d'escargots en Laponie
, ils en bavent..."
Expecting nothing
ok
Trying:
accentEtrange(texte)
Expecting:
Est-ceu queu tu as rRreugarRrd la tl hieurRr soirRr ? Il y avait un thma surRr leus rRramasseuurRrs d'
euscarRrgots eun Laponieu, ils eun baveunt...
ok
2 items had no tests:
__main__
__main__._test
1 items passed all tests:
2 tests in __main__.accentEtrange
2 tests in 3 items.
2 passed and 0 failed.
Test passed.
9.5.3 Le dveloppement dirig par la documentation
Comme on peut le voii, la documentation intgie pisente nanmoins un dfaut quand la documen-
tation augmente, on ne voit plus le code '
La solution est de dpoitei ceue documentation la fonction doctest.testfile() peimet dindiquei le
nom du chiei de documentation.
Qi plus est, on peut ciiie ce chiei au foimat ieST, ce qui peimet de faiie coup double. Dune pait,
on dispose des tests intgis la fonction (ou la mthode) et, dautie pait, le mme chiei fouinit une
documentation joui.
Exemple : doctest2.py
lichiei de documentation
1
Le module `àccent``
====================
Test de la fonction `àccentEtrange``
-------------------------------------
Ce module fournit une fonction `àccentEtrange``.
On peut ainsi ajouter un accent un texte :
>>> from doctest2 import accentEtrange
>>> texte = "Est-ce que tu as regard la tl hier soir ? Il y avait un thma sur
les ramasseurs d'escargots en Laponie, ils en bavent..."
>>> accentEtrange(texte)
Est-ceu queu tu as rRreugarRrd la tl hieurRr soirRr ? Il y avait un thma surRr
leus rRramasseuurRrs d'euscarRrgots eun Laponieu, ils eun baveunt...
Les ``r`` sont tripls et les `è`` pauls par des `ù``. Cette technique permet
de se passer de systmes de traductions complexes pour faire fonctionner
les logiciels dans certaines rgions.
Souice du module
import doctest
doctest.testfile("test_documentation2.txt", verbose=True)
Nous pioduisons la documentation HTML pai la commande
rst2html test_documentation2.txt test_documentation2.html
Elle est illustie lig. 9.4.
1. cf. [], p. 11.
licUvr 9.3 Exemple de soitie au foimat PDl.
licUvr 9.4 Documentation du sciipt test_documentation2.py.
ANNrxr A
Interlude
Le Zen de Python
1
Prre
la beaut la laideur,
lexplicite limplicite,
le simple au complexe,
le complexe au compliqu,
le droul limbriqu,
lar au compact.
Prends en compte la lisibilit.
Les cas particuliers ne le sont jamais assez pour violer les rgles.
Mais, la puret, privilgie laspect pratique.
Ne passe pas les erreurs sous silence,
Ou billonne-les explicitement.
Face lambigut, deviner ne te laisse pas aller.
Sache quil ne devrait avoir quune et une seule faon de procder.
Mme si, de prime abord, elle nest pas vidente, moins dtre Nerlandais.
Mieux vaut maintenant que jamais.
Cependant jamais est souvent mieux quimmdiatement.
Si limplmentation sexplique dicilement, cest une mauvaise ide.
Si limplmentation sexplique aisment, cest peut-tre une bonne ide.
Les espaces de noms, sacre bonne ide ! Faisons plus de trucs comme a !
1. Tim Pr1rvs (PEP n
o
20), tiaduction Ccile Tvrvi~N et Bob Covur~U.
Retoui chap.1, p. 1
88 Interlude
Le Graal de Python
1
!
Arthur
Lancelot ! Lancelot ! Lancelot !
[mgaphone de police]
Lancelooooooooot !
Lancelot
Bloody hell, mais que se passe-t-il donc, mon Roi ?
Arthur
Bevedere, explique-lui !
Bevedere
Nous devons te parler dun nouveau langage de programmation : Python
Lancelot
Nouveau ? Cela fait bien dix ans quil existe, et je ne vois pas en quoi cela va nous aider rcuprer le
Saint-Graal !
Bevedere
Saint-Graal, Saint-Graal. . .
[soupii]
Tu ne peux pas penser des activits plus saines que cee qute stupide de temps en temps ?
Arthur
[soit une massue et assomme Bevedeie avec]
Son explication tait mal partie de toute manire.
Gardes franais
Est-ce que ces messieurs les Anglais peuvent aller sentretuer plus loin ?
Ne voyez-vous pas que nous sommes concentrs sur notre jeu en ligne ?
Arthur
Ce tunnel sous la Manche, quelle hrsie !
[iacle sa goige]
Lancelot, assieds-toi, et coute-moi. (et ferme ce laptop, bloody hell !)
Lancelot
[iabat lcian de son laptop]
1. cf. [], p. 11.
Interlude 89
Arthur
La qute a chang. Tu dois maintenant apprendre le langage Python, et dcouvrir pourquoi il est de
plus en plus pris par mes sujets.
Lancelot
Mais. . .
Arthur
Il ny a pas de mais !
[menace Lancelot avec sa massue]
Je suis ton Roi. dot slash.
Prends ce livre, et au travail !
Gardes franais
Oui, au travail, et en silence !
ANNrxr B
Passer du problme au programme
Loisquon a un piobleme isoudie pai un piogiamme, la dicult est de savoii
Par o commencer ?
Comment concevoir lalgorithme ?
Prrequis
Au fui et mesuie que lon acquieie de lexpiience, on dcouvie et on appiend utilisei les biblio-
theques de modules et paquets qui fouinissent des types de donnes et des seivices avancs, vitant davoii
ie-ciei, codei et dboguei une paitie de la solution.
Rutiliser
La piemieie chose faiie est de viiei quil nexiste pas dj une solution (mme paitielle) au pio-
bleme que lon pouiiait iepiendie in extenso ou dont on pouiiait sinspiiei. On peut cheichei dans les
nombieux modules standaids installs avec le langage, dans les dpots institutionnels de modules tieis (le
Python Package Index
1
pai exemple), ou encoie utilisei les moteuis de iecheiche sui llnteinet. Si on ne
tiouve pas de solution existante dans notie langage pifi, on peut tiouvei une solution dans un autie
langage, quil ny auia plus qu adaptei.
Lanalyse qui peimet de ciei un algoiithme et la piogiammation ensuite, sont deux phases qui n-
cessitent de la piatique avant de devenii videntes ou faciles .
Rir un algorithme
Poui dmaiiei, il faut paitii dlments iels, mais sui un chantillon du piobleme compoitant peu de
donnes, un cas que lon est capable de tiaitei la main .
ll est foitement conseill de dmaiiei sui papiei ou sui un tableau (le papiei ayant lavantage de laissei
plus facilement des tiaces des diientes tapes).
On identie tout daboid quelles sont les donnes que lon a tiaitei en entie et quelles sont les
donnes que lon sauend tiouvei en soitie. Poui chaque donne, on essaie de picisei quel est son
domaine, quelles sont ses limites, quelles contiaintes la lient aux auties donnes.
Rsoudre la main
On commence pai une isolution du piobleme, en ialisant les tiansfoimations et calculs sui notie
chantillon de piobleme, en fonctionnant pai tapes.
A chaque tape, on note
quelles sont les tapes peitinentes, sui quels ciiteies elles ont t choisies ,
quelles sont les squences dopiations que lon a ipt.
Loisque lon tombe sui des tapes complexes, on dcoupe en sous-tapes, ventuellement en les tiai-
tant spaiment comme un algoiithme de isolution dun sous-piobleme. Le but est daiiivei un niveau
de dtails susamment simple , soit quil sagisse dopiations ties basiques (opiation sui un texte,
expiession de calcul numiique), soit que lon pense/sache quil existe dj un outil poui tiaitei ce sous-
piobleme (calcul de sinus poui un angle, opiation de tii sui une squence de donnes. . .).
Lois de ce dcoupage, il faut vitei de considiei des opiations comme implicites ou videntes ,
il faut picisei do pioviennent les infoimations et ce que lon fait des isultats. Pai exemple on ne
1. http://pypi.python.org/
92 Passer du problme au programme
consideie pas un lment mais le nom tiait est llment suivant de la squence de noms ou
encoie le nom tiait est le x
e
lment de la squence de noms .
Noimalement, au couis de ces opiations, on a commenc nommei les donnes et les tapes au fui
et mesuie quon en a eu besoins.
Formaliser
Une fois quon a un biouillon des tapes, il faut commencei meuie en foime et identiei les
constiuctions algoiithmiques connues et les donnes manipules
Boucles (sui quelles infoimations, condition daiit).
Tests (quelle condition).
lnfoimations en entie, quel est leui type, quelles sont les contiaintes poui quelles soient valides
et utilisables, do viennent-elles
dj pisentes en mmoiie,
demandes lutilisateui,
lues dans des chieis ou icupies ailleuis (sui llnteinet pai exemple).
Calculs et expiessions
quel genie de donnes sont ncessaiies, y-a-t-il des lments constants connaitie, des isultats
inteimdiaiies iutilisei,
on peut identiei ici les contioles inteimdiaiies possibles sui les valeuis qui puissent peimeuie
de viiei que lalgoiithme se dioule bien.
Stockage des isultats inteimdiaiies.
Rsultat nal quel moment la-t-on, quen fait-on
ietouin dans le cadie dune fonction,
ach lutilisateui,
sauvegaid dans un chiei.
Factoriser
Le but est didentiei les squences dtapes qui se ipetent en diients endioits, squences qui seiont
de bons candidats poui devenii des fonctions ou des classes. Ceci peut tie fait en mme temps que lon
foimalise.
Passer de lide au programme
Le passage de lide puis de lalgoiithme au code dans un piogiamme, est ielativement facile en Python
cai celui-ci est ties pioche dun langage dalgoiithmique.
Les noms des choses que lon a manipul vont nous donnei des variables.
Les tests vont se tiansfoimei en if condition :
Les boucles sur des squences dinfoimations vont se tiansfoimei en for variable in squence :
Les boucles avec expression de condition vont se tiansfoimei en while conditions :
Les squences dinstructions qui se rptent en diients endioits vont se tiansfoimei en fonc-
tions.
Le retour de rsultat dune squence (fonction) va se tiaduiie en return variable.
Les conditions sur les donnes ncessaiies poui un tiaitement vont identiei des tests deiieuis
et des leves dexception.
ANNrxr C
Jeux de caractres et encodage
Position du problme
Nous avons vu que loidinateui code toutes les infoimations quil manipule en binaiie. Poui codei les
nombies entieis un changement de base sut, poui les ouants, on utilise une noime (lEEE 4), mais la
situation est plus complexe poui iepisentei les caiacteies.
En eet, la giande diveisit des langues humaines et de leui iepisentation ncessite un codage adapt.
La piemieie ide est de constiuiie une table qui associe les symboles iepisentei un nombie (g-
nialement cod sui un octet)
Symbole Nombre
La plus clebie est la table ASCll
1
( lig. C.1), code sui bits (soit 128 codes), mais bien dauties
tables ont t cies (EBCDlC, lSO-882-1. . .).
licUvr C.1 Table ASCll.
La table Unicode
En Python 3, les chaines de caiacteies (le type str()) sont des chaines Unicode, noime dans laquelle
les identiants numiiques de leuis caiacteies sont uniques et univeisels.
Comme il sagit de diienciei plusieuis centaines de millieis de caiacteies (on compte enviion 000
langues dans le monde) ils ne pouiiont videmment pas tie encods sui un seul octet.
En fait, la noime Unicode ne xe aucune iegle conceinant le nombie doctets ou de bits iseivei
poui lencodage, mais spcie seulement la valeui numiique de lidentiant associ chaque caiacteie
(lig. C.2).
1. Ameiican Standaid Code foi lnfoimation lnteichange
94 Jeux de caractres et encodage
licUvr C.2 Extiait de la table Unicode.
Encodage
Apies avoii collect tous les symboles et y avoii associ un nombie, il ieste leui tiouvei une repr-
sentation binaire.
Poui lASCll un seul octet susait mais poui iepisentei les millions de possibilits de lUnicode, plu-
sieuis octets pai caiacteie sont ncessaiies.
Comme la plupait des textes nutilisent que la table ASCll ce qui coiiespond justement la paitie
basse de la table Unicode, lencodage le plus conomique est lUTl-8
1
poui les codes 0 12, lUTl-8 utilise loctet de la table ASCll ,

poui les caiacteies spciaux (codes 128 204), lUTl-8 utilise 2 octets ,
poui les caiacteies spciaux encoie moins couiants (codes 2048 3), lUTl-8 utilise 3 octets ,
enn poui les auties, lUTl-8 en utilise 4.
Exemple de lencodage UTl-8 du caiacteie Unicode
Symbole Code Encodage UTF-8
233 C3 A9
Applications aux scripts Python
Puisque les sciipts Python que lon pioduit avec un diteui sont eux-mmes des textes, ils iisquent
dtie encods suivant diientes foimat. An que Python utilise le bon, il est impoitant de picisez
lencodage de caiacteies utilis (obligatoiiement en 1
ie
ou 2
e
ligne des souices).
Les encodages les plus fiquents sont
# -*- coding: latin-1 -*-
ou
# -*- coding: UTF-8 -*-
1. Retoui chap. 2, p.
ANNrxr D
Les bases arithmtiques
Dnition
Dnition
b
En aiithmtique, une base n dsigne la valeui dont les puissances successives inteiviennent dans
lciituie des nombies, ces puissances dnissant loidie de giandeui de chacune des positions occupes
pai les chiies composant tout nombie. Pai exemple 57
n
= (5 n
1
) + (7 n
0
)
Ceitaines bases sont couiamment employes
la base 2 (systeme binaiie), en lectionique numiique et infoimatique ,
la base 8 (systeme octal), en infoimatique ,
la base 1 (systeme hexadcimal), fiquente en infoimatique ,
la base 0 (systeme sexagsimal), dans la mesuie du temps et des angles.
Conversion
Dnition
b
Les changements de base un nombie dans une base n donne sciit sous la foime daddition des
puissances successives de ceue base
1
.
Exemples
57
16
= (5 16
1
) + (7 16
0
) = 87
10
57
8
= (5 8
1
) + (7 8
0
) = 47
10
1. Retoui chap.2, p.
ANNrxr E
Exercices corrigs
noncs des exercices
Remarque
Les exeicices suivants sont fouinis titie dexemples et de modeles.

lls sont soit simples, soit moins simples (nots dans la maige) soit plus diciles (nots ).
1. Eciiie un piogiamme qui, paitii de la saisie dun iayon et dune hauteui, calcule le volume dun
cone dioit.
2. Une boucle while entiez un piix HT (entiez 0 poui teiminei) et achez sa valeui TTC.
3. Une autie boucle while calculez la somme dune suite de nombies positifs ou nuls. Comptez com-
bien il y avait de donnes et combien taient supiieuies 100.
Un nombie infiieui ou gal 0 indique la n de la suite.
4. Lutilisateui donne un entiei positif n et le piogiamme ache PAIR sil est divisible pai 2 et IMPAIR
sinon.
. Lutilisateui donne un entiei positif et le piogiamme annonce combien de fois de suite cet entiei
est divisible pai 2.
. Lutilisateui donne un entiei supiieui 1 et le piogiamme ache, sil y en a, tous ses diviseuis
piopies sans rptition ainsi que leui nombie. Sil ny en a pas, il indique quil est piemiei. Pai
exemple
Entrez un entier strictement positif : 12
Diviseurs propres sans rptition de 12 : 2 3 4 6 (soit 4 diviseurs propres)
Entrez un entier strictement positif : 13 Diviseurs propres sans
rptition de 13 : aucun ! Il est premier
. Eciiie un piogiamme qui estime la valeui de la constante mathmatique e en utilisant la foimule
e =
n
i=0
1
i!
Poui cela, dnissez la fonction factoiielle et, dans votie piogiamme piincipal, saisissez loidie n et
achez lappioximation coiiespondante de e.
8. Un gaidien de phaie va aux toileues cinq fois pai joui oi les WC sont au iez-de-chausse. . .
Eciiie une piocduie (donc sans ietoui) hauteurParcourue qui ieoit deux paiameties le nombie de
maiches du phaie et la hauteui de chaque maiche (en cm), et qui ache
Entrez un entier strictement positif : 12
Diviseurs propres sans rptition de 12 : 2 3 4 6 (soit 4 diviseurs propres)
Entrez un entier strictement positif : 13 Diviseurs propres sans
rptition de 13 : aucun ! Il est premier
On noublieia pas
quune semaine compoite jouis ,
quune fois en bas, le gaidien doit iemontei ,
que le isultat est expiimei en m.
98 Exercices corrigs
9. Un peimis de chasse points iemplace dsoimais le peimis de chasse tiaditionnel. Chaque chasseui
possede au dpait un capital de 100 points. Sil tue une poule il peid 1 point, 3 points poui un chien,
points poui une vache et 10 points poui un ami. Le peimis coute 200 euios.
Eciiie une fonction amende qui ieoit le nombie de victimes du chasseui et qui ienvoie la somme
due.
Utilisez ceue fonction dans un piogiamme piincipal qui saisit le nombie de victimes et qui ache
la somme que le chasseui doit dbouisei.
10. Je suis ligot sui les iails en gaie dAiias. Eciiie un piogiamme qui ache un tableau me peimeuant
de connaitie lheuie laquelle je seiai dchiquet pai le tiain paiti de la gaie du Noid 9h (il y a
10 km entie la gaie du Noid et Aiias).
Le tableau pidiia les diientes heuies possibles poui toutes les vitesses de 100 km/h 300 km/h,
pai pas de 10 km/h, les isultats tant aiiondis la minute infiieuie.
Eciiie une piocduie tchacatchac qui ieoit la vitesse du tiain et qui ache lheuie du diame ,
ciiie le piogiamme piincipal qui ache le tableau demand.
11. Un piogiamme piincipal saisit une chaine dADN valide et une squence dADN valide ( valide
signie quelles ne sont pas vides et sont foimes exclusivement dune combinaison aibitiaiie de
"a", "t", "g" ou "c").
Eciiie une fonction valide qui ienvoie viai si la saisie est valide, faux sinon.
Eciiie une fonction saisie qui eectue une saisie valide et ienvoie la valeui saisie sous foime dune
chaine de caiacteies.
Eciiie une fonction proportion qui ieoit deux aiguments, la chaine et la squence et qui ietouine
la piopoition de squence dans la chaine (cest--diie son nombie doccuiiences).
Le piogiamme piincipal appelle la fonction saisie poui la chaine et poui la squence et ache le
isultat.
Exemple dachage
Il y a 13.33 % de "ca" dans votre chane.
12. ll sagit dciiie, dune pait, un piogiamme piincipal et, dautie pait, une fonction utilise dans le
piogiamme piincipal.
La fonction listAleaInt(n, a, b) ietouine une liste de n entieis alatoiies dans [a .. b] en utilisant
la fonction randint(a, b) du module random.
Dans le piogiamme piincipal
constiuiie la liste en appelant la fonction listAleaInt() ,
calculei lindex de la case qui contient le minimum,
changez le piemiei lment du tableau avec son minimum.
13. Comme picdemment, il sagit dciiie, dune pait, un piogiamme piincipal et, dautie pait, une
fonction utilise dans le piogiamme piincipal.
La fonction listAleaFloat(n) ietouine une liste de n ouants alatoiies en utilisant la fonction
random() du module random.
Dans le piogiamme piincipal
Saisii un entiei n dans linteivalle [2 .. 100] ,
constiuiie la liste en appelant la fonction listAleaFloat() ,
achei lamplitude du tabeau (cait entie sa plus giande et sa plus petite valeui) ,
achei la moyenne du tableau.
14. lonction ienvoyant plusieuis valeuis sous foime dun tuple.
Eciiie une fonction minMaxMoy qui ieoit une liste dentieis et qui ienvoie le minimum, le maximum
et la moyenne de ceue liste. Le piogiamme piincipal appelleia ceue fonction avec la liste [10, 18,
14, 20, 12, 16].
1. Saisii un entiei entie 1 et 3999 (pouiquoi ceue limitation `). Lachei en nombie iomain.
1. Amlioiei le sciipt picdent en utilisant la fonction zip().
1. Un tableau contient n entieis (2 < n < 100) alatoiies tous compiis entie 0 et 00. Viiei quils
sont tous diients.
Exercices corrigs 99
18. Lutilisateui donne un entiei n entie 2 et 12, le piogiamme donne le nombie de faons de faiie n en
lanant deux ds.
19. Mme piobleme que le picdent mais avec n entie 3 et 18 et tiois ds.
20. Gnialisation des deux questions picdentes. Lutilisateui saisit deux enties, dune pait le nombie
de ds, nbd (que lon limiteia piatiquement 10) et, dautie pait la somme, s, compiise entie nbd et
6.nbd. Le piogiamme calcule et ache le nombie de faons de faiie s avec les nbd ds.
21. Mme piobleme que le picdent mais cod icuisivement.
22. Nombies paifaits et nombies chanceux.
On appelle nombre premier tout entiei natuiel supiieui 1 qui possede exactement deux divi-
seuis, lui-mme et lunit.
On appelle diviseur propre de n, un diviseui quelconque de n, n exclu.
Un entiei natuiel est dit parfait sil est gal la somme de tous ses diviseuis piopies.
Les nombies a tels que (a + n + n
2
) est piemiei poui tout n tel que 0 n < (a 1), sont
appels nombres chanceux.
Eciiie un module (parfait_chanceux_m.py) dnissant quatie fonctions somDiv, estParfait, est-
Premier, estChanceux et un auto-test
la fonction somDiv ietouine la somme des diviseuis piopies de son aigument ,
les tiois auties fonctions viient la piopiit donne pai leui dnition et ietouine un boolen.
Plus picisment, si pai exemple la fonction estPremier viie que son aigument est piemiei,
elle ietouine True, sinon elle ietouine False.
La paitie de test doit compoitei quatie appels la fonction verif peimeuant de testei somDiv(12),
estParfait(6), estPremier(31) et estChanceux(11).
Puis ciiie le piogiamme piincipal (parfait_chanceux.py) qui compoite
linitialisation de deux listes parfaits et chanceux ,
une boucle de paicouis de linteivalle [2, 1000] incluant les tests ncessaiies poui iemplii ces
listes ,
enn lachage de ces listes.
Solutions des exercices
# -*- coding: utf-8 -*-
"""Volume d'un cne droit."""
# imports
from math import pi
# programme principal -----------------------------------------------
rayon = float(input("Rayon du cne (m) : "))
hauteur = float(input("Hauteur du cne (m) : "))
volume = (pi*rayon*rayon*hauteur)/3.0
print("Volume du cne =", volume, "m3")
# -*- coding: utf-8 -*-
"""Calcul d'un prix TTC."""
prixHT = float(input("Prix HT (0 pour terminer)? "))
while prixHT > 0:
print("Prix TTC : {:.2f}\n".format(prixHT * 1.196))
prixHT = float(input("Prix HT (0 pour terminer)? "))
print("Au revoir !")
# -*- coding: utf-8 -*-
"""Somme d'entiers et nombre d'entiers suprieur 100."""
somme, nombreTotal, nombreGrands = 0, 0, 0
x = int(input("x (0 pour terminer) ? "))
while x > 0:
somme += x
nombreTotal += 1
if x > 100:
nombreGrands += 1
x = int(input("x (0 pour terminer) ? "))
print("\nSomme :", somme)
print(nombreTotal, "valeur(s) en tout, dont", nombreGrands, "suprieure(s) 100")
# -*- coding: utf-8 -*-
"""Parit."""
n = int(input("Entrez un entier strictement positif : "))
while n < 1:
n = int(input("Entrez un entier STRICTEMENT POSITIF, s.v.p. : "))
if n%2 == 0:
print(n, "est pair.")
else:
print(n, "est impair.")
# -*- coding: utf-8 -*-
"""Nombre de fois qu'un entier est divisible par 2."""
while n < 1:
save = n
cpt = 0
while n%2 == 0:
n /= 2
cpt += 1
print(save, "est", cpt, "fois divisible par 2.")
# -*- coding: utf-8 -*-
"""Diviseurs propres d'un entier."""
while n < 1:
i = 2 # plus petit diviseur possible de n
cpt = 0 # initialise le compteur de divisions
p = n/2 # calcul une fois dans la boucle
print("Diviseurs propres sans rptition de ", n, ":", end=' ')
while i <= p:
if n%i == 0:
cpt += 1
print(i, end=' ')
i += 1
if not cpt:
print("aucun ! Il est premier.")
else:
print("(soit", cpt, "diviseurs propres)")
# -*- coding: utf-8 -*-
"""Approximation de 'e'."""
# fonction
def fact(n):
r = 1
for i in range(1, n+1):
r *= i
return r
n = int(input("n ? "))
exp = 0.0
for i in range(n):
exp = exp + 1.0/fact(i)
print("Approximation de 'e' : {:.3f}".format(exp))
# -*- coding: utf-8 -*-
"""Gardien de phare."""
# fonction
def hauteurParcourue(nb, h):
print("Pour {:d} marches de {:d} cm, il parcourt {:.2f} m par semaine.".format(nb, h, nb*h*2*5*7/100.0))
nbMarches = int(input("Combien de marches ? "))
hauteurMarche = int(input("Hauteur d'une marche (cm) ? "))
hauteurParcourue(nbMarches, hauteurMarche)
# -*- coding: utf-8 -*-
"""Permis de chasse."""
# fonction
def permisSup(p, c, v, a):
pointsPerdus = p + 3*c + 5*v + 10*a
nbrePermis = pointsPerdus/100.0
return 200*nbrePermis
poules = int(input("Combien de poules ? "))
chiens = int(input("Combien de chiens ? "))
vaches = int(input("Combien de vaches ? "))
amis = int(input("Combien d'amis ? "))
payer = permisSup(poules, chiens, vaches, amis)
print("\nA payer :", end=' ')
if payer == 0:
print("rien payer")
else:
print(payer, "euros")
# -*- coding: utf-8 -*-
"""Histoire de train."""
# fonction
def tchacatchac(v):
"""Affiche l'heure du drame."""
heure = 9 + int(170/v)
minute = (60 * 170 / v) % 60
print("A", v, "km/h, je me fais dchiqueter ", heure, "h", minute, "min.")
i = 100
while i <= 300:
tchacatchac(i)
i += 10
# -*- coding: utf-8 -*-
"""Proportion d'une squence dans une chane d'ADN."""
# fonctions
def valide(seq):
"""Retourne vrai si la squence est valide, faux sinon."""
ret = any(seq)
for c in seq:
ret = ret and c in "atgc"
return ret
def proportion(a, s):
"""Retourne la proportion de la squence <s> dans la chane <a>."""
return 100*a.count(s)/len(a)
def saisie(ch):
s = input("{:s} : ".format(ch))
while not valide(s):
print("'{:s}' ne peut contenir que les chanons 'a', 't', 'g' et 'c' et"
" ne doit pas tre vide".format(ch))
s = input("{:s} : ".format(ch))
return s
adn = saisie("chane")
seq = saisie("squence")
print('Il y a {:.2f} % de "{:s}" dans votre chane.'
.format(proportion(adn, seq), seq))
# -*- coding: utf-8 -*-
"""Echanges."""
# imports
from random import seed, randint
# fonction
def listAleaInt(n, a, b):
"""Retourne une liste de <n> entiers alatoires dans [<a> .. <b>]."""
return [randint(a, b) for i in range(n)]
seed() # initialise le gnrateur de nombres alatoires
t = listAleaInt(100, 2, 125) # construction de la liste
# calcul de l'index du minimum de la liste
iMin = t.index(min(t))
print("Avant change :")
print("\tt[0] =", t[0], "\tt[iMin] =", t[iMin])
t[0], t[iMin] = t[iMin], t[0] # change
print("Apres change :")
print("\tt[0] =", t[0], "\tt[iMin] =", t[iMin])
# -*- coding: utf-8 -*-
"""Amplitude et moyenne d'une liste de flottants."""
# imports
from random import seed, random
# fonctions
def listAleaFloat(n):
"Retourne une liste de <n> flottants alatoires"
return [random() for i in range(n)]
n = int(input("Entrez un entier [2 .. 100] : "))
while not(n >= 2 and n <= 100):
n = int(input("Entrez un entier [2 .. 100], s.v.p. : "))
t = listAleaFloat(n) # construction de la liste
print("Amplitude : {:.2f}".format(max(t) - min(t)))
print("Moyenne : {:.2f}".format(sum(t)/n))
# -*- coding: utf-8 -*-
"""Min, max et moyenne d'une liste d'entiers."""
# fonction
def minMaxMoy(liste):
"""Renvoie le min, le max et la moyenne de la liste."""
min, max, som = liste[0], liste[0], float(liste[0])
for i in liste[1:]:
if i < min:
min = i
if i > max:
max = i
som += i
return (min, max, som/len(liste))
lp = [10, 18, 14, 20, 12, 16]
print("liste =", lp)
l = minMaxMoy(lp)
print("min : {0[0]}, max : {0[1]}, moy : {0[2]}".format(l))
# -*- coding: utf-8 -*-
"""Nombres romains (version 1)."""
n = int(input('Entrez un entier [1 .. 4000[ : '))
while not(n >= 1 and n < 4000):
n = int(input('Entrez un entier [1 .. 4000[, s.v.p. : '))
s = "" # Chane rsultante
while n >= 1000:
s += "M"
n -= 1000
if n >= 900:
s += "CM"
n -= 900
if n >= 500:
s += "D"
n -= 500
if n >= 400:
s += "CD"
n -= 400
while n >= 100:
s += "C"
n -= 100
if n >= 90:
s += "XC"
n -= 90
if n >= 50:
s += "L"
n -= 50
if n >= 40:
s += "XL"
n -= 40
while n >= 10:
s += "X"
n -= 10
if n >= 9:
s += "IX"
n -= 9
if n >= 5:
s += "V"
n -= 5
if n >= 4:
s += "IV"
n -= 4
while n >= 1:
s += "I"
n -= 1
print("En romain :", s)
# -*- coding: utf-8 -*-
"""Nombres romains (version 2)."""
# globales
code = zip(
[1000,900 ,500,400 ,100,90 ,50 ,40 ,10 ,9 ,5 ,4 ,1],
["M" ,"CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"]
)
# fonction
def decToRoman(num):
res = []
for d, r in code:
while num >= d:
res.append(r)
num -= d
return ''.join(res)
print(i, decToRoman(i))
# -*- coding: utf-8 -*-
"""Liste d'entiers diffrents."""
# imports
from random import seed, randint
# fonction
def listAleaInt(n, a, b):
"""Retourne une liste de <n> entiers alatoires entre <a> et <b>."""
return [randint(a, b) for i in range(n)]
# construction de la liste
t = listAleaInt(n, 0, 500)
# Sont-ils diffrents ?
tousDiff = True
i = 0
while tousDiff and i < (n-1):
j = i + 1
while tousDiff and j < n:
if t[i] == t[j]:
tousDiff = False
else:
j += 1
i += 1
print("\n", t, end=' ')
if tousDiff:
print(": tous les lments sont distincts.")
else:
print(": au moins une valeur est rpte.")
# -*- coding: utf-8 -*-
"""Jeu de ds (1)."""
s = 0
for j in range(1, 7):
if i+j == n:
s += 1
print("Il y a {:d} faon(s) de faire {:d} avec deux ds.".format(s, n))
# -*- coding: utf-8 -*-
"""Jeu de ds (2)."""
s = 0
for j in range(1, 7):
for k in range(1, 7):
if i+j+k == n:
s += 1
print("Il y a {:d} faon(s) de faire {:d} avec trois ds.".format(s, n))
# -*- coding: utf-8 -*-
"""Jeu de ds (3)."""
# globale
MAX = 8
nbd = int(input("Nombre de ds [2 .. {:d}] : ".format(MAX)))
while not(nbd >= 2and nbd <= MAX):
nbd = int(input("Nombre de ds [2 .. {:d}], s.v.p. : ".format(MAX)))
s = int(input("Entrez un entier [{:d} .. {:d}] : ".format(nbd, 6*nbd)))
while not(s >= nbd and s <= 6*nbd):
s = int(input("Entrez un entier [{:d} .. {:d}], s.v.p. : ".format(nbd, 6*nbd)))
if s == nbd or s == 6*nbd:
cpt = 1 # 1 seule solution
else:
I = [1]*nbd # initialise une liste de <nbd> ds
cpt, j = 0, 0
while j < nbd:
som = sum([I[k] for k in range(nbd)])
if som == s:
cpt += 1 # compteur de bonnes solutions
if som == 6*nbd:
break
j = 0
if I[j] < 6:
I[j] += 1
else:
while I[j] == 6:
I[j] = 1
j += 1
I[j] += 1
print("Il y a {:d} faons de faire {:d} avec {:d} ds.".format(cpt, s, nbd))
# -*- coding: utf-8 -*-
"""Jeu de ds (rcursif)."""
# globale
MAX = 8
# fonction
def calcul(d, n):
"""Calcul rcursif du nombre de faons de faire <n> avec <d> ds."""
resultat, debut = 0, 1
if (d == 1) or (n == d) or (n == 6*d): # conditions terminales
return 1
else: # sinon appels rcursifs
if n > 6*(d-1): # optimisation importante
debut = n - 6*(d-1)
for i in range(debut, 7):
if n == i:
break
resultat += calcul(d-1, n-i)
return resultat
d = int(input("Nombre de ds [2 .. {:d}] : ".format(MAX)))
while not(d >= 2and d <= MAX):
d = int(input("Nombre de ds [2 .. {:d}], s.v.p. : ".format(MAX)))
n = int(input("Entrez un entier [{:d} .. {:d}] : ".format(d, 6*d)))
while not(n >= d and n <= 6*d):
n = int(input("Entrez un entier [{:d} .. {:d}], s.v.p. : ".format(d, 6*d)))
print("Il y a {:d} faon(s) de faire {:d} avec {:d} ds.".format(calcul(d, n), n, d))
# -*- coding: utf-8 -*-
"""module d'exemple de polymorphisme."""
# classes
class Rectangle:
"""classe des rectangles."""
def __init__(self, longueur=30, largeur=15):
"""Constructeur avec valeurs par dfaut."""
self.lon = longueur
self.lar = largeur
self.nom = "rectangle"
def surface(self):
"""Calcule la surface d'un rectangle."""
return self.lon*self.lar
def __str__(self):
"""Affichage des caractristiques d'un rectangle."""
return "\nLe '{:s}' de cts {:s} et {:s} a une surface de {:s}"
.format(self.nom, self.lon, self.lar, self.surface())
class Carre(Rectangle):
"""classe des carrs (hrite de Rectangle)."""
def __init__(self, cote=10):
"""Constructeur avec valeur par dfaut"""
Rectangle.__init__(self, cote, cote)
self.nom = "carr" # surchage d'attribut d'instance
# Auto-test ---------------------------------------------------------
if __name__ == '__main__':
r = Rectangle(12, 8)
print r
c = Carre()
print c
3
ANNrxr l
Glossaire
Lexique bilingue
>>>
lnvite Python pai dfaut dans un shell inteiactif. Souvent utilise dans les exemples de code extiaits
de sessions de linteipiteui Python.
lnvite Python pai dfaut dans un shell inteiactif, utilise loisquil faut entiei le code dun bloc
indent ou lintiieui dune paiie de paientheses, ciochets ou accolades.
2to3
Un outil qui essaye de conveitii le code Python 2.x en code Python 3.x en giant la plupait des
incompatibilits quil peut dtectei.
2to3 est disponible dans la bibliotheque standaid lib2to2 , un point dentie autonome est Tool/s-
cipts/2to3. Voii 2to3 Automated Python 2 to 3 code translation.
abstract base class ABC (classe de base abstiaite)
Complete le duck-typing en fouinissant un moyen de dnii des inteifaces alois que dauties tech-
niques (comme hasattt()) sont plus louides. Python fouinit de base plusieuis ABC poui les stiuc-
tuies de donnes (module collections), les nombies (module numbers) et les ux (module io). Vous
pouvez ciei votie piopie ABC en utilisant le module abc.
argument (aigument)
Valeui passe une fonction ou une mthode, aecte une vaiiable nomme locale au coips de
la fonction. Une fonction ou une mthode peut avoii la fois des aiguments pai position et avec
des valeuis pai dfaut. Ces aiguments peuvent tie de multiplicit vaiiable * accepte ou fouinit
plusieuis aiguments pai position dans une liste, tandis que ** joue le mme iole en utilisant les
valeuis pai dfaut dans un dictionnaiie.
On peut passei toute expiession dans la liste daiguments, et la valeui value est tiansmise la
vaiiable locale.
attribute (auiibut)
Valeui associe un objet ifienc pai un nom et une expiession pointe. Pai exemple, lauiibut
a dun objet o peut tie ifienc o.a.
BDFL Benevolent Dictator For Life (Dictateui Bienveillant Vie)
Suinom bienveillant de Guido van RossUx, le ciateui de Python.
bytecode (bytecode ou langage inteimdiaiie)
Le code souice Python est compil en bytecode, iepisentation inteine dun piogiamme Python
dans linteipiteui. Le bytecode est galement iang dans des chieis .pyc et .pyo, ainsi lexcution
dun mme chiei est plus iapide les fois ultiieuies (la compilation du souice en bytecode peut
tie vite). On dit que le bytecode touine sui une maine virtuelle qui, essentiellement, se iduit
une collection dappels des ioutines coiiespondant chaque code du bytecode.
class (classe)
Modele peimeuant de ciei ses piopies objets. Les dnitions de classes contiennent noimalement
des dnitions de mthodes qui opeient sui les instances de classes.
coercion (coeicition ou tianstypage)
Conveision implicite dune instance dun type dans un autie type dans une opiation conceinant
deux aiguments de types compatibles. Pai exemple, int(3.15) conveitit le nombie ouant 3.15 en
108 Glossaire
lentiei 3, mais dans 3+4.5, chaque aigument est dun type diient (lun int et lautie float) et
tous deux doivent tie conveitis dans le mme type avant dtie additionns, sinon une exception
TypeError seia lance. Sans coeicition, tous les aiguments, mme de types compatibles, doivent tie
noimaliss la mme valeui pai le piogiammeui, pai exemple, float(3)+4.5 au lieu de simplement
3+4.5.
complex number (nombie complexe)
Une extension du systeme familiei des nombies iels dans laquelle tous les nombies sont expiims
comme la somme dune paitie ielle et une paitie imaginaiie. Les nombies imaginaiies sont des
multiples iels de lunit imaginaiie (la iacine caiie de -1), souvent ciite i pai les mathmaticiens
et j pai les ingnieuis. Python a un tiaitement incoipoi des nombies complexes, qui sont ciits
avec ceue deuxieme notation , la paitie imaginaiie est ciite avec un suxe j, pai exemple 3+1j.
Poui avoii acces aux quivalents complexes des lments du module math utilisez le module cmath.
Lutilisation des nombies complexes est une possibilit mathmatique assez avance. Si vous ntes
pas ceitain den avoii besoin vous pouvez les ignoiei sans iisque.
context manager (gestionnaiie de contexte)
Objet qui contiole lenviionnement indiqu pai linstiuction with et qui dnit les mthodes __en-
ter__() et __exit__(). Voii la PEP 343.
CPython (Python classique)
lmplmentation canonique du langage de piogiammation Python. Le teime CPython est utilis dans
les cas o il est ncessaiie de distinguei ceue implmentation dauties comme Jython ou lionPython.
decorator (dcoiateui)
lonction ietouinant une autie fonction habituellement applique comme une tiansfoimation utili-
sant la syntaxe @wrapper.
classmethod() et staticmethod() sont des exemples classiques de dcoiateuis.
Les deux dnitions de fonctions suivantes sont smantiquement quivalentes
def f(...):
...
f = staticmethod(f)
@staticmethod
def f(...):
...
Un concept identique existe poui les classes mais est moins utilis. Voii la documentation function
denition et class denition poui plus de dtails sui les dcoiateuis.
descriptor (desciipteui)
Tout objet qui dnit les mthodes __get__(), __set__() ou __delete__(). Loisquun auiibut dune
classe est un desciipteui, un compoitement spcique est dclench lois de la consultation de
lauiibut. Noimalement, ciiie a.b consulte lobjet b dans le dictionnaiie de la classe de a, mais si b
est un desciipteui, la mthode __get__() est appele. Compiendie les desciipteuis est fondamental
poui la compihension piofonde de Python, cai ils sont la base de nombieuses caiactiistiques,
comme les fonctions, les mthodes, les piopiits, les mthodes de classe, les mthodes statiques et
les ifiences aux supei-classes.
Poui plus dinfoimations sui les mthodes des desciipteuis, voii Implementing Descriptors.
dictionary (dictionnaiie)
Une table associative, dans laquelle des cls aibitiaiies sont associes des valeuis. Lutilisation des
objets dict iessemble beaucoup celle des objets list, mais les cls peuvent tie nimpoite quels
objets ayant une fonction __hash__(), non seulement des entieis. Ces tables sont appeles hash en
Peil.
docstring (chaine de documentation)
Chaine liuiale appaiaissant comme piemieie expiession dune classe, dune fonction ou dun mo-
dule. Bien quignoie lexcution, elle est ieconnue pai le compilateui et incluse dans lauiibut
__doc__ de la classe, de la fonction ou du module qui la contient. Depuis quelle est disponible via
lintiospection, cest lendioit canonique poui documentei un objet.
du-typing (typage comme un canaid )
Style de piogiammation pythonique dans lequel on dteimine le type dun objet pai inspection de
ses mthodes et auiibuts plutot que pai des ielations explicites des types ( sil iessemble un
Glossaire 109
canaid et fait coin-coin comme un canaid alois ce doit tie un canaid ). En meuant laccent sui des
inteifaces plutot que sui des types spciques on amlioie la exibilit du code en peimeuant la
substitution polymoiphe. Le duck-typing vite les tests qui utilisent type() ou isinstance() (notez
cependant que le duck-typing doit tie complt pai lemploi des classes de base abstiaites). A la
place, il emploie des tests comme hasattr() et le style de piogiammation EAFP.
EAFP (Easier to ask for forgiveness than permission, ou plus facile de demandei paidon que la peimis-
sion )
Ce style couiant de piogiammation en Python consiste supposei lexistence des cls et des auii-
buts ncessaiies lexcution dun code et auiapei les exceptions qui se pioduisent loisque de
telles hypotheses se ivelent fausses. Cest un style piopie et iapide, caiactiis pai la pisence de
nombieuses instiuctions try et except. Ceue technique contiaste avec le style LBYL, couiant dans
dauties langages comme le C.
expression (expiession)
liagment de syntaxe qui peut tie valu. Autiement dit, une expiession est une accumulation
dlments dexpiession comme des liuiaux, des noms, des acces aux auiibuts, des opiateuis ou
des appels des fonctions ietouinant une valeui. A linveise de beaucoup dauties langages, toutes
les constiuctions de Python ne sont pas des expiessions. Les instiuctions ne peuvent pas tie utili-
ses comme des expiessions (pai exemple if). Les aectations sont aussi des instiuctions, pas des
expiessions.
extension module (module dextension)
Module ciit en C ou en C, utilisant lAPl C de Python, qui inteiagit avec le cui du langage et
avec le code de lutilisateui.
nder
Objet qui essaye de tiouvei le loader (chaigeui) dun module. ll doit implmentei une mthode
nomme find_module(). Voii la PEP 302 poui des dtails et importlib.abc.Finder poui une classe de
base abstiaite.
oor division (division entieie)
Division mathmatique qui laisse tombei le ieste. Lopiateui de division entieie est //. Pai exemple,
lexpiession 11//4 est value 2, pai opposition la division ouante qui ietouine 2.75.
function (fonction)
Suite dinstiuctions qui ietouine une valeui lappelant. On peut lui passei zio ou plusieuis aigu-
ments qui peuvent tie utiliss dans le coips de la fonction. Voii aussi argument et method.
__future__
Un pseudo-module que les piogiammeuis peuvent utilisei poui peimeuie les nouvelles fonction-
nalits du langage qui ne sont pas compatibles avec linteipiteui couiamment employ.
En impoitant __future__ et en valuant ses vaiiables, vous pouvez voii quel moment une caiac-
tiistique nouvelle a t ajoute au langage et quand est-elle devenue la fonctionnalit pai dfaut
>>> import __future__
>>> __future__.division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
garbage collection (gestion automatique de la mmoiie)
Piocessus de libiation de la mmoiie quand elle nest plus utilise. Python excute ceue gestion en
comptant les ifiences et en dtectant et en cassant les ifiences cycliques.
generator (fonction gniateui)
Une fonction qui ienvoie un itiateui. Elle iessemble une fonction noimale, except que la valeui
de la fonction est iendue lappelant en utilisant une instiuction yield au lieu dune instiuction
return. Les fonctions gniateuis contiennent souvent une ou plusieuis boucles for ou while qui
cedent des lments lappelant. Lexcution de la fonction est stoppe au niveau du mot-cl
yield, en ienvoyant un isultat, et elle est iepiise loisque llment suivant est iequis pai un appel
de la mthode next() de litiateui.
generator expression (expiession gniateui)
Une expiession qui ienvoie un gniateui. Elle iessemble une expiession noimale suivie dune
expiession for dnissant une vaiiable de contiole, un inteivalle et une expiession if facultative.
Toute ceue expiession combine pioduit des valeuis poui une fonction englobante
110 Glossaire
>>> sum(i*i for i in range(10)) # somme des carrs 0, 1, 4, ... 81
285
GIL
Cf. global interpreter lo.
global interpreter lo (veiiou global de linteipiteui)
Le veiiou utilis pai les threads Python poui assuiei quun seul thread touine dans la maine
virtuelle CPython un instant donn. ll simplie Python en gaiantissant que deux piocessus ne
peuvent pas accdei en mme temps une mme mmoiie. Bloquei linteipiteui tout entiei lui
peimet dtie multi-thread aux fiais du paialllisme du systeme enviionnant. Des eoits ont t
faits pai le pass poui ciei un inteipiteui free-threaded (o les donnes paitages sont veiiouilles
avec une gianulaiit ne), mais les peifoimances des piogiammes en souiaient considiablement,
y compiis dans le cas des piogiammes mono-thread.
hashable (hachable)
Un objet est hachable sil a une valeui de hachage constante au couis de sa vie (il a besoin dune
mthode __hash__()) et sil peut tie compai dauties objets (il a besoin dune mthode __eq__()).
Les objets hachables compais gaux doivent avoii la mme valeui de hachage.
Lhachabilit iend un objet piopie tie utilis en tant que cl dun dictionnaiie ou membie dun
ensemble (set), cai ces stiuctuies de donnes utilisent la valeui de hachage de faon inteine.
Tous les objets de base Python non modiables (immutable) sont hachables, alois que ceitains conte-
neuis comme les listes ou les dictionnaiies sont modiables. Les objets instances des classes dnies
pai lutilisateui sont hachables pai dfaut , ils sont tous ingaux (diients) et leui valeui de hachage
est leui id().
IDLE
Un enviionnement de dveloppement intgi poui Python. lDLE est un diteui basique et un en-
viionnement dinteipitation , il est donn avec la distiibution standaid de Python. Excellent poui
les dbutants, il peut aussi seivii dexemple pas tiop sophistiqu poui tous ceux qui doivent impl-
mentei une application avec inteiface utilisateui giaphique multi-plate-foime.
immutable (immuable)
Un objet avec une valeui xe. Pai exemple, les nombies, les chaines, les tuples. De tels objets ne
peuvent pas tie altis , poui changei de valeui un nouvel objet doit tie ci. Les objets immuables
jouent un iole impoitant aux endioits o une valeuis de hash constantes est iequise, pai exemple
poui les cls des dictionnaiies.
importer
Objet qui la fois tiouve et chaige un module. Cest la fois un objet nder et un objet loader.
interactive (inteiactif)
Python possede un inteipiteui inteiactif, ce qui signie que vous pouvez essayei vos ides et voii
immdiatement les isultats. ll sut de lancei python sans aigument (ventuellement en le slec-
tionnant dans un ceitain menu piincipal de votie oidinateui). Cest viaiment un moyen puissant
poui testei les ides nouvelles ou poui inspectei les modules et les paquetages (pensez help(x)).
interpreted (inteipit)
Python est un langage inteipit, pai opposition aux langages compils, bien que ceue distinction
puisse tie oue cause de la pisence du compilateui de bytecode. Cela signie que les chieis
souice peuvent tie diiectement excuts sans avoii besoin de ciei pialablement un chiei binaiie
excut ensuite. Typiquement, les langages inteipits ont un cycle de dveloppement et de mise
au point plus couit que les langages compils mais leuis piogiammes sexcutent plus lentement.
Voii aussi interactive.
iterable
Un objet conteneui capable de ienvoyei ses membies un pai un. Des exemples diterable sont les
types squences (comme les list, les str, et les tuple) et quelques types qui ne sont pas des s-
quences, comme les objets dict, les objets file et les objets de nimpoite quelle classe que vous
dnissez avec une mthode __iter__() ou une mthode __getitem__(). Les iterables peuvent tie
utiliss dans les boucles for et dans beaucoup dauties endioits o une squence est iequise (zip(),
map(), . . .). Loisquun objet iterable est pass comme aigument la fonction incoipoie iter() il
ienvoie un itiateui. Cet itiateui est un bon moyen poui eectuei un paicouis dun ensemble
de valeuis. Loisquon utilise des iterables, il nest gnialement pas ncesaiie dappelei la fonction
Glossaire 111
iter() ni de manipulei diiectement les valeuis en question. Linstiuction for fait cela automatique-
ment poui vous, en ciant une vaiiable tempoiaiie sans nom poui giei litiateui pendant la duie
de litiation. Voii aussi iterator, sequence, et generator.
iterator (itiateui)
Un objet iepisentant un ot de donnes. Des appels ipts la mthode __next__() de litiateui
(ou la fonction de base next()) ienvoient des lments successifs du ot. Loisquil ny a plus de
donnes disponibles dans le ot, une exception StopIteration est lance. A ce moment-l, lobjet
itiateui est puis et tout appel ultiieui de la mthode next() ne fait que lancei encoie une ex-
ception StopIteration. Les itiateuis doivent avoii une mthode __iter__() qui ienvoie lobjet
itiateui lui-mme. Ainsi un itiateui est itiatif et peut tie utilis dans beaucoup dendioits o les
iterables sont accepts , une exception notable est un code qui tenteiait des itiations multiples. Un
objet conteneui (comme un objet list) pioduit un nouvel itiateui chaque fois quil est pass la
fonction iter() ou bien utilis dans une boucle for. Si on fait cela avec un itiateui on ne icupieia
que le mme itiateui puis utilis dans le paicouis picdent, ce qui feia appaiaitie le conteneui
comme sil tait vide.
keyword argument (aigument avec valeui pai dfaut)
Aigument picd pai variable_name= dans lappel. Le nom de la vaiiable dsigne le nom local
dans la fonction auquel la valeui est aecte. ** est utilis poui acceptei ou passei un dictionnaiie
daiguments avec ses valeuis. Voii argument.
lambda
lonction anonyme en ligne ne compienant quune unique expiession value lappel. Syntaxe de
ciation dune fonction lambda
lambda[arguments]: expression
LBYL (Look before you leap ou iegaidei avant dy allei )
Ce style de code teste explicitement les pi-conditions avant deectuei un appel ou une iecheiche.
Ce style soppose lappioche EAFP et est caiactiis pai la pisence de nombieuses instiuctions
if.
list (liste)
Squence Python de base. En dpit de son nom, elle iessemble plus au tableau dauties langages
qu une liste chaine puisque lacces ses lments est en O(1).
list comprehension (liste en compihension)
Une manieie compacte deectuei un tiaitement sui un sous-ensemble dlments dune squence
en ienvoyant une liste avec les isultats. Pai exemple
result = ["0x%02x" % x for x in range(256) if x % 2 == 0]
engendie une liste de chaines contenant les ciituies hexadcimales des nombies impaiis de linteivalle
de 0 255. La clause if est facultative. Si elle est omise, tous les lments de linteivalle range(256)
seiont tiaits.
loader (chaigeui)
Objet qui chaige un module. ll doit possdei une mthode load_module(). un loader est typiquement
fouinit pai un nder. Voii la PEP 302 poui les dtails et voii importlib.abc.Loader poui une classe
de base abstiaite.
mapping (liste associative)
Un objet conteneui (comme dict) qui suppoite les iecheiches pai des cls aibitiaiies en utilisant la
mthode spciale __getitem__().
metaclass
La classe dune classe. La dnition dune classe cie un nom de classe, un dictionnaiie et une liste
de classes de base. La mtaclasse est iesponsable de la ciation de la classe paitii de ces tiois
lments. Beaucoup de langages de piogiammation oiients objets fouinissent une implmentation
pai dfaut. Une oiiginalit de Python est quil est possible de ciei des mtaclasses peisonnalises.
Beaucoup dutilisateuis nauiont jamais besoin de cela mais, loisque le besoin appaiait, les mta-
classes fouinissent des solutions puissantes et lgantes. Elles sont utilises poui eniegistiei les
acces aux auiibuts, poui ajoutei des treads scuiiss, poui dtectei la ciation dobjet, poui impl-
mentei des singletons et poui bien dauties taches.
Plus dinfoimations peuvent tie tiouves dans Customizing class creation.
112 Glossaire
method (mthode)
lonction dnie dans le coips dune classe. Appele comme un auiibut dune instance de classe, la
mthode piend linstance dobjet en tant que piemiei aigument (habituellement nomm self). Voii
function et nested scope.
mutable (modiable)
Les objets modiables peuvent changei leui valeui tout en conseivant leui id(). Voii aussi immu-
table.
named tuple (tuple nomm)
Toute classe de pseudo-tuples dont les lments indexables sont galement accessibles pai des at-
tiibuts nomms (pai exemple time.localtime() ietouine un objet pseudo-tuple o lanne est ac-
cessible soit pai un index comme t[0] soit pai un auiibut nomm comme t.tm_year.
Un tuple nomm peut tie un type de base comme time.struct_time ou il peut tie ci pai une
dnition de classe oidinaiie. Un tuple nomm peut aussi tie ci pai la fonction fabiique collec-
tions.nametuple(). Ceue deinieie appioche fouinit automatiquement des caiactiistiques suppl-
mentaiies comme une iepisentation auto-documente, pai exemple
>>> Employee(name='jones', title='programmer')
namespace (espace de noms)
Lendioit o une vaiiable est conseive. Les espaces de noms sont implments comme des diction-
naiies. ll y a des espace de noms locaux, globaux et intgis et galement imbiiqus dans les objets.
Les espaces de noms contiibuent la modulaiit en pivenant les conits de noms. Pai exemple, les
fonctions __builtin__.open() et os.open() se distinguent pai leuis espaces de noms. Les espaces
de noms contiibuent aussi la lisibilit et la maintenablit en claiiant quel module implmente
une fonction. Pai exemple, en ciivant random.seed() ou itertools.izip() on iend vident que ces
fonctions sont implmentes dans les modules random et itertools iespectivement.
nested scope (poite imbiique)
La possibilit de faiie ifience une vaiiable dune dnition englobante. Pai exemple, une fonction
dnie lintiieui dune autie fonction peut faiie ifience une vaiiable de la fonction extiieuie.
Notez que le poites imbiiques fonctionnent uniquement poui la ifience aux vaiiables et non
poui leui aectation, qui conceine toujouis la poite imbiique. Les vaiiables locales sont lues et
ciites dans la poite la plus intiieuie , les vaiiables globales sont lues et ciites dans lespace de
noms global. Linstiuction nonlocal peimet dciiie dans la poite globale.
new-style class (style de classe nouveau)
Vieille dnomination poui le style de piogiammation de classe actuellement utilis. Dans les vei-
sions picdentes de Python, seul le style de classe nouveau pouvait bnciei des nouvelles caiac-
tiistiques de Python, comme __slots__, les desciipteuis, les piopiits, __getattribute__(), les
mthodes de classe et les mthodes statiques.
object (objet)
Toute donne compienant un tat (auiibut ou valeui) et un compoitement dni (mthodes). Ega-
lement la classe de base ultime du new-style class.
positional argument (aigument de position)
Aiguments aects aux noms locaux inteines une fonction ou une mthode, dteimins pai
loidie donn dans lappel. La syntaxe * accepte plusieuis aiguments de position ou fouinit une
liste de plusieuis aiguments une fonction. Voii argument.
property (piopiit)
Auiibut dinstance peimeuant dimplmentei les piincipes de lencapsulation.
Python3000
Suinomde la veision 3 de Python (foig il y a longtemps, quand la veision 3 tait un piojet lointain).
Aussi abig Py3k .
Pythonic (pythonique)
lde ou fiagment de code plus pioche des idiomes du langage Python que des concepts fiquemment
utiliss dans dauties langages. pai exemple, un idiome fiquent en Python est de bouclei sui les
lments dun iterable en utilisant linstiuction for. Beaucoup dauties langages nont pas ce type
de constiuction et donc les utilisateuis non familieis avec Python utilisent paifois un compteui
numiique
Glossaire 113
for i in range(len(food)):
print(food[i])
Au lieu dutilisei la mthode claiie et pythonique
for piece in food:
print(piece)
reference count (nombie de ifiences)
Nombie de ifiences dun objet. Qand le nombie de ifiences dun objet tombe zio, lobjet est
dsallou. Le comptage de ifiences nest gnialement pas visible dans le code Python, mais cest
un lment cl de limplmentation de CPython. Le module sys dnit la fonction getrefcount()
que les piogiammeuis peuvent appelei poui icupiei le nombie de ifiences dun objet donn.
__slots__
Une dclaiation lintiieui dune classe de style nouveau qui conomise la mmoiie en pi-dclaiant
lespace poui les auiibuts et en liminant en consquence les dictionnaiies dinstance. Bien que po-
pulaiie, ceue technique est quelque peu dicile meuie en place et doit tie iseive aux iaies cas
o il y a un nombie impoitant dinstances dans une application o la mmoiie est iduite.
sequence (squence)
Un iterable qui oie un acces ecace aux lments en utilisant des index entieis et les mthodes sp-
ciales __getitem__() et __len__(). Des types squences incoipois sont list, str, tuple et unicode.
Notez que le type dict compoite aussi les mthodes __getitem__() et __len__(), mais est considi
comme une table associative plutot que comme une squence cai la iecheiche se fait laide de cls
aibitiaiies immuables au lieu dindex.
slice (tianche)
Objet contenant noimalement une paitie dune squence. Une tianche est cie pai une notation in-
dexe utilisant des entie les index quand plusieuis sont donns, comme dans variable_name[1:3:5].
La notation ciochet utilise les objets slice de faon inteine.
special method (mthode spciale)
Mthode appele implicitement pai Python poui excutei une ceitaine opiation sui un type, pai
exemple une addition. Ces mthodes ont des noms commenant et nissant pai deux caiacteies
souligns. Les mthodes spciales sont documentes dans Special method names.
statement (instiuction)
Une instiuction est une paitie dune suite, dun bloc de code. Une instiuction est soit une ex-
piession soit une ou plusieuis constiuctions utilisant un mot cl comme if, while ou for.
triple-quoted string (chaine multi-ligne)
Une chaine dlimite pai tiois guillemets () ou tiois apostiophes (). Bien quelles ne fouinissent
pas de fonctionnalits diientes de celles des chaines simplement dlimites, elles sont utiles poui
nombie de iaisons. Elles peimeuent dincluie des guillemets ou des apostiophes non piotgs et
elles peuvent stendie sui plusieuis lignes sans utilisei de caiacteie de continuation, et sont donc
spcialement utiles poui idigei des chaines de documentation.
type (type)
Le type dun objet Python dteimine de quelle soite dobjet il sagit , chaque objet possede un type.
Le type dun objet est accessible giace son auiibut __class__ ou peut tie ietouin pai la fonction
type(obj).
view (vue)
Les objets ietouins pai dict.keys(), dict.values() et dict.items() sont appels des dictionary
views. ce sont des squences paiesseuses
1
qui laisseiont voii les modications du dictionnaiie
sous-jacent. Poui foicei le dictionary view tie une liste complete, utilisei list(dictview). Voii
Dictionary wiew objects.
virtual maine (machine viituelle)
Oidinateui entieiement dni pai un piogiamme. la machine viituelle Python excute le bytecode
gni pai le compilateui.
1. Lvaluation paiesseuse est une technique de piogiammation o le piogiamme nexcute pas de code avant que les isultats
de ce code ne soient iellement ncessaiies. Le teime paiesseux (en anglais lazzy evaluation) tant connot ngativement en fianais
on paile aussi dvaluation ietaide.
114 Glossaire
Zen of Python
Une liste de piincipes mthodologiques et philosophiques utiles poui la compihension et lutilisation
du langage Python. Ceue liste peut tie obtenue en tapant import this dans linteipiteui Python.
Webographie
Les sites gniaux
www.python.oig
pypi.python.oig/pypi
code.google.com/p/pythonxy/wiki/Downloads
Les EDl spcialiss
code.google.com/p/spydeilib/
www.wingwaie.com/downloads/wingide-101
ipython.oig/
www.scintilla.oig/SciTEDownload.html
code.google.com/p/pysciiptei/
Les outils
hup //matplotlib.oig//
hup //www.inkscape-fi.oig//
code.google.com/p/ist2pdf/
hup //www.texniccentei.oig//
Le lien des liens
peiso.limsi.fi/pointal/liens pythonlinks
Bibliographie
[1] SviNNrN, Giaid, Apprendre programmer avec Python 3, Eyiolles, 2010.
[2] SUxxrviiriu, Maik, Programming in Python 3, Addison-Wesley, 2
e
dition, 2009.
[3] M~v1riii, Alex, Python en concentr, OReilly, 2004.
[4] M~v1riii, Alex, M~v1riii R~vrNscvoi1, Anna, Ascurv, David, Python par lexemple, OReilly, 200.
[] LU1z, Maik et B~iiiv, Yves, Python prcis et concis, OReilly, 2
e
dition, 200.
[] Zi~u, Taiek, Programmation Python. Conception et optimisation, Eyiolles, 2
e
dition, 2009.
[] Zi~u, Taiek, Python : Petit guide lusage du dveloppeur agile, Dunod, 200.
[8] Hriix~NN, Doug, e Python Standard Library by Example, Addison-Wesley, 2011.
[9] L~Nc1~NcrN, Hans Peuei, A Primer on Scientic Programming with Python, Spiingei, 2011.
[10] Cu~z~iir1, Sbastien, Python, les fondamentaux du langage, ENl, 2012.
[11] YoUNxrv, Je, Foundations of Agile Python Development, Apiess, 2008.
[12] RoUr11r Maeul, L
A
T
E
X appliqu aux sciences humaines, Atiamenta, 2012.
[13] Curv~iirv Cline et collectif, L
A
T
E
X pour limpatient, H & K, 3
e
dition, 2009.
[14] C~vrii~, David, Rgles typographiques et normes. Mise en pratique avec L
A
T
E
X, Vuibeit, 200.
Indexation des squences
Types de base
Mmento Bases Python 3
2012-2013 - Laurent Pointal
Licence Creative Commons Paternit 2
Documentation officielle Python sur
http://docs.python.org/py3k
0 783 -192 int
9.23 -1.7e-6 0.0 float
True False bool
"Un\nDeux" 'L\'me' str
"""X\tY\tZ
1\t2\t3"""
10
-6
tabulation
retour la ligne
multiligne
Types Conteneurs
list [1,5,9] ["x",11,8.9] ["mot"] []
tuple (1,5,9) 11,"y",7.4 ("mot",) ()
dict
{1:"un",3:"trois",2:"deux",3.14:""}
{"cl":"valeur"}
set
{}
{1,9,3,0}
squences ordonnes, accs index rapide, valeurs rptables
set()
sans ordre a priori, cl unique, accs par cl rapide; cls= types de base ou tuples
{"cl1","cl2"}
non modifiable
Affectation de variables
x = 1.2+8+sin(0)
y,z,r = 9.2,-7.6,"bad"
valeur ou expression de calcul
nom de variable (identificateur)
azAZ_ suivi de azAZ_09
accents possibles mais viter
mots cls du langage interdits
distinction casse min/MAJ
expression juste avec des virgules
non modifiable,
squence ordonne de caractres
dictionnaire
ensemble
entier, flottant, boolen, chane
conteneur de plusieurs
valeurs (ici un tuple)
noms de
variables
Identificateurs
a toto x7 y_max BigOne
8y and
x+=3 x-=2
incrmentation
dcrmentation
Conversions
pour les listes, tuples, chanes de caractres,
int("15")
float("-11.24e8")
bool
str(78.3) repr("Texte")
on peut spcifier la base du nombre entier en 2
nd
paramtre
int(15.56) troncature de la partie dcimale (round(15.56) pour entier arrondi)
et pour avoir la reprsentation littrale
type(expression)
utiliser des comparateurs (avec ==, !=, <, >, ), rsultat logique boolen
voir au verso le formatage de chanes, qui permet un contrle fin
":".join(['toto','12','pswd']) 'toto:12:pswd'
chane de jointure squence de chanes
"des mots espacs".split() ['des','mots','espacs']
"1,4,8,2".split(",") ['1','4','8','2']
chane de sparation
dict([(3,"trois"),(1,"un")]) {1:'un',3:'trois'}
list("abc") ['a','b','c']
utilise chaque lment de
la squence en paramtre
set(["un","deux"]) {'un','deux'}
utilise chaque lment de
la squence en paramtre
lst=[11, 67, "abc", 3.14, 42, 1968]
lst[1]67
lst[-2]42
0 1 2 3 5 4
-6 -5
-4
-3 -1 -2
accs individuel aux lments par [index]
index positif
index ngatif
0 1 2 3 5 4 6
-6 -5 -4 -3 -1 -2 tranche ngative
tranche positive
accs des sous-squences par [tranche dbut:tranche fin:pas]
len(lst) 6
lst[1:3][67,"abc"]
lst[::2][11,"abc",42]
lst[-3:-1][3.14,42]
lst[:3][11,67,"abc"]
lst[:-1][11,67,"abc",3.14,42]
lst[4:][42,1968]
lst[1:-1][67,"abc",3.14,42]
lst[:][11,67,"abc",3.14,42,1968]
Indication de tranche manquante partir du dbut / jusqu' la fin.
Instruction conditionnelle
if x==42:
# bloc si expression logique x==42 vraie
print("vrit vraie")
elif x>0:
# bloc sinon si expression logique x>0 vraie
print("positivons")
elif bTermine:
# bloc sinon si variable boolenne bTermine vraie
print("ah, c'est fini")
else:
# bloc sinon des autres cas restants
print("a veut pas")
Logique boolenne Blocs d'instructions
instruction parente:
bloc d'instructions 1

instruction parente:
bloc d'instructions 2

instruction suivante aprs bloc 1
i
n
d
e
n
t
a
t
i
o
n
!
Comparateurs: < > <= >= == !=
=
a and b
a or b
not a
et logique
ou logique
non logique
l'un ou l'autre ou les deux
les deux en mme temps
if expression logique:
bloc d'instructions
bloc d'instructions excut
uniquement si une condition est vraie
True
False
valeur constante vrai
valeur constante faux
combinable avec des sinon si, sinon si... et un seul sinon final,
exemple:
lst[-1]1968
lst[0]11
le dernier
le premier
x=None valeur constante non dfini
Maths
Oprateurs: + - * / // % **

entire reste
a
b
from math import sin,pi
' chapp
abs(-3.2)3.2
round(3.57,1)3.6
nombres flottants valeurs approches!
sin(pi/4)0.707
cos(2*pi/3)-0.4999
sqrt(81)9.0
log(e**2)2.0
angles en radians
acos(0.5)1.0471
etc. (cf doc)
(1+5.3)*212.6
pour noms de variables,
fonctions, modules, classes
Mmento v1.2.1bis
Sur les squences modifiables, utilisable pour suppression del lst[3:5] et modification par affectation lst[1:4]=['hop',9]
str en tant que squence ordonne de caractres
couples cl/valeur
"modele{} {} {}".format(x,y,r)
"{slection:formatage!conversion}"
Slection :
2
x
0.nom
4[cl]
0[2]
str
Affichage / Saisie
print("v=",3,"cm:",x,",",y+4)
Options de print:
sep=" " (sparateur d'lments, dfaut espace)
end="\n" (fin d'affichage, dfaut fin de ligne)
file=f (print vers fichier, dfaut sortie standard)
lments afficher: valeurs littrales, variables, expressions
boucle sur dict/set = boucle sur squence des cls
Instruction boucle conditionnelle bloc d'instructions excut
tant que la condition est vraie
while expression logique:
bloc d'instructions
s = 0
i = 1
while i <= 100:
# bloc excut tant que i 100
s = s + i**2
i = i + 1
print("somme:",s)
initialisations avant la boucle
condition avec au moins une valeur variable (ici i)
s=
i=1
i=100
i
2
faire varier la variable
de condition!
Instruction boucle itrative bloc d'instructions excut pour
chaque lment d'un conteneur ou d'un itrateur
for variable in squence:
bloc d'instructions
s = "Du texte"
cpt = 0
for c in s:
if c == "e":
cpt = cpt + 1
print("trouv",cpt,"'e'")
Parcours des valeurs de la squence
Comptage du nombre
de e dans la chane.
Parcours des index de la squence
changement de l'lment la position
accs aux lments autour de la position (avant/aprs)
lst = [11,18,9,12,23,4,17]
perdu = []
for idx in range(len(lst)):
val = lst[idx]
if val> 15:
perdu.append(val)
lst[idx] = 15
print("modif:",lst,"-modif:",perdu)
Bornage des valeurs
suprieures 15,
mmorisation des
valeurs perdues.
attention aux boucles sans fin!
initialisations avant la boucle
variable de boucle, valeur gre par l'instruction for
utilisation des tranches pour parcourir un sous-ensemble de la squence
rsultat de calcul aprs la boucle
Formatage de chanes
valeurs formater directives de formatage
Gnration de squences d'entiers
Fichiers
s = input("Directives:")
input retourne toujours une chane, la convertir vers le type
dsir (cf encadr Conversions au recto).
trs utilis pour les
boucles itratives for
range retourne un gnrateur, faire une conversion
en liste pour voir les valeurs, par exemple:
print(list(range(4)))
range(5) 0 1 2 3 4
range(3,8) 3 4 5 6 7
range(2,12,3) 2 5 8 11
range([dbut,] fin [,pas])
f = open("fic.txt","w",encoding="utf8")
stockage de donnes sur disque, et relecture
mode d'ouverture
'r' lecture (read)
'w' criture (write)
'a' ajout (append)
encodage des
caractres pour les
fichiers textes:
uft8 ascii
latin1
nom du fichier
sur le disque
(+chemin)
variable
fichier pour
les oprations
f.write("coucou")
en criture
fichier texte lecture / criture
de chanes uniquement, convertir
de/vers le type dsir
en lecture
s = f.read(4)
for ligne in f:
bloc de traitement de la ligne
cf fonctions des modules os et os.path
si nb de caractres
pas prcis, lit tout
le fichier
s = f.readline()
lecture ligne
suivante
f.close() ne pas oublier de refermer le fichier aprs son utilisation!
Fermeture automatique Pythonesque : with open() as f:
trs courant: boucle itrative de lecture des lignes d'un fichier texte:
Dfinition de fonction
def nomfct(p_x,p_y,p_z):
"""documentation"""
# bloc instructions, calcul de res, etc.
return res
nom de la fonction (identificateur)
valeur rsultat de l'appel.
si pas de rsultat calcul
retourner: return None
les paramtres et toutes les
variables de ce bloc n'existent
que dans le bloc et pendant l'appel la fonction (boite noire)
paramtres nomms
Appel de fonction
r = nomfct(3,i+2,2*i)
un argument par paramtre
rcupration du rsultat retourn (si ncessaire)
Oprations sur conteneurs
chane vide si fin de fichier
len(c)
min(c) max(c) sum(c)
sorted(c)
reversed(c)
modification de la liste originale
lst.append(item)
lst.pop(idx)
lst.sort() lst.reverse()
"{:+2.3f}".format(45.7273)
'+45.727'
"{1:>10s}".format(8,"toto")
' toto'
"{!r}".format("L'ame")
'"L\'ame"'
non compris par dfaut 0
Conversion : s (texte lisible) ou r (reprsentation littrale)
< > ^ = 0 au dbut pour remplissage avec des 0
entiers: b binaire, c caractre, d dcimal (dfaut), o octal, x ou X hexa
flottant: e ou E exponentielle, f ou F point fixe, g ou G appropri (dfaut),
% pourcentage
chane: s
Formatage :
car-rempl. alignement signe larg.mini.prcision~larg.max type
+ - espace
c.index(val) c.count(val)
nb d'lments
copie trie
itrateur invers
position nb d'occurences
lst.extend(seq)
ajout d'un lment la fin
ajout d'une squence d'lments la fin
lst.insert(idx,val) insertion d'un lment une position
lst.remove(val) suppression d'un lment partir de sa valeur
suppression de l'lment une position et retour de la valeur
tri / inversion de la liste sur place
Oprations sur dictionnaires Oprations sur ensembles
Oprateurs:
| union (caractre barre verticale)
& intersection
- ^ diffrence/diff symtrique
< <= > >= relations d'inclusion
d.update(d2) mise jour/ajout
des couples
Note: Pour dictionnaires et ensembles,
ces oprations travaillent sur les cls.
Spcifique aux conteneurs de squences (listes, tuples, chanes) :
val in c boolen, oprateur in de test de prsence (not in d'absence)
Oprations sur listes
d[cl]valeur del d[cl]
d[cl]=valeur
d.keys()
d.clear()
d.items()
d.values() vues sur les cls,
valeurs, couples
E
x
e
m
p
l
e
s
d.pop(cl)
s.update(s2)
s.add(cl) s.remove(cl)
s.discard(cl)
c*5 duplication c+c2 concatnation
Contrle de boucle
break
continue
sortie immdiate
itration suivante
Parcours simultan index et valeur de la squence:
for idx,val in enumerate(lst):
enumerate(c) itrateur sur (index,valeur)
Index
A
ADA, 3
aectation, 9
ALGOL, 3
algoiithme, 4, 43
alteinative, 18
aigument, 3
passage pai aectation, 3
ASCll, 93
auto-test, 40
B
Baithot, Stphane, iv
base, , 95
binaiie,
changement de, 9
hexadcimal,
octal,
Basic, 3
bibliotheque, 41
mathmatique, 42
standaid, 41
temps et dates, 43
bloc, 1
Boole, Geoige, 8
boucle, 19
dvnement,
paicouiii, 19
iptei, 19
bytecode, 1, 3
C
C, 1, 3
C, 1, 3
C-, 3
CD-ROM, 2
chaine, 11
concatnation, 11
longueui, 11
iptition, 12
COBOL, 3
commentaiie, 4
compilateui, 2
conception
association, 2
diivation, 2
giaphique, 9
console, 1
conteneui, 19, 23
Coideau
Bob, 8
Hlene, iv
D
dictionnaiie, 2
cl, 2
valeui, 2
division,
entieie,
ouante,
duck typing,
dcoiateui, 72
diivation, 53
dveloppement
diiig pai la documentation, 84
E
chappement, 1
Eiel, 3
encodage, 94
ensemble, 28
exception, 21
expiession,
gniatiice, 1
F
chiei, 29
ciituie squentielle, 29
lectuie squentielle, 30
textuel, 29
fonction, 33
application paitielle de, 8
diiective lambda,
incluse, 1
icuisive, 8
fonctions, 12
foimatage, 30
lORTRAN, 3
functoi, 3
G
gestionnaiie,
de contexte,
gniateui, 0
H
hiitage, 51
I
identicateui,
implmentation, 4
CPython, 4
lionPython, 4
Jython, 4
Pypy, 4
Stackless Python, 4
indexation, 13
instiuction, 1
compose, 1
inteifaces giaphiques,
inteipiteui, 2
intiospection,
ipython, ix
itiable, 19
J
Java, 3
K
Knuth, Donald, ix, 82
L
LabView, 3
langage
dassemblage, 2
de haut niveau, 2
machine, 2
LlSP, 3
liste, 23
liteiate piogiamming, 82
M
Meyei, Beitiand, ix
MODULA-2, 3
module, 39
impoit, 39
mot
iseiv,
mthode, 50
mthodes, 12
mthodologie
objet, 4
piocduiale, 4
O
opiateui, 8
de compaiaison, 8
logique, 8
opiation,
aiitmtique,
oidinateui, 2, 2
P
package, 2, 4
paquet, 4
paiametie
self, 0
PASCAL, 3
Peil, 3
Peteis, Tim, 8
PL/1, 3
polymoiphisme, 51
poite, 37
globale, 3
locale, 3
Piogiammation Oiiente Objet, 4
auiibut, 4
classe, 4
encapsulei, 4
instance, 4
mthode, 4
mthode spciale, 0
objet, 4
polymoiphisme, 1
POO, 4
suichaige, 1
piogiamme, 4
piopiit, 74
accesseui, 3
PSl, 1
Python, 2, 3, 88
pythonique, 9
R
RAM, 2
ieST, 81
Rossum, Guido van, 1
BDlL, 1
GvR, 1
Ruby, 3
ifiences, 2
S
saisie, 19
ltie, 19
sciipt, 2
Simula, 3
Smalltalk, 3
souice, 4
spydei, ix
suichaige, 50
squence, 20, 23
iuptuie de, 20
T
tableau, 2
associatif, 2
tcl/Tk, 3
test, 79
fonctionnel, 80
unitaiie, 9
tianche, 24
tianstypei, 1
Tievian, Ccile, iv, 8
tuple, 25
type,
binaiie, 14
bool, 8
complex, 9
oat, 8
int,
U
UAL, 2
UC, 2
Unicode, 93
USB, 2
V
vaiiable, 9
VB.NET, 3
VisualBasic, 3
W
widget, 58
Wingwaie, ix
X
XML, 44
Z
zen, 8
Ziad, Taiek, iv

Courspython3 1-6 PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Courspython3 1-6 PDF

Transféré par

Droits d'auteur :

Formats disponibles

Bob CORDEAU &

Point foit de Python la lisibilit. Python est un langage algoiithmique excutable .

UPPERCASE ou UPPER_CASE poui les constantes ,

Deux valeuis possibles False, True.

A loial, au lieu de diie a gal 2 , dites a reoit 2 .

Une instiuction compose se compose

La squence noimale dinstiuctions est place dans un bloc try.

Elments spais pai des viigules, et entouis de ciochets.

Elments spais pai des viigules, et entouis de paientheses.

Collection de couples cle : valeur entouie daccolades.

>>> print("{0!s} {0!r}".format("texte\n"))

La dnition dune fonction est compose

ll est conseill dimpoitei dans lordre

objet = attributs + mthodes

Nom Mthode spciale Utilisation

Soit deco() un dcoiateui. Poui dcoiei une fonction on ciit

poui les codes 0 12, lUTl-8 utilise loctet de la table ASCll ,

Les exeicices suivants sont fouinis titie dexemples et de modeles.

Vous aimerez peut-être aussi