Cours Sur Python 3

Livre Python
Version 1.0-draft
Harold Erbin
18 February 2012
Table des matires
I
1 2 3 4
Prface
Avant-propos Remerciements Plan de louvrage Conventions 4.1 Prsentation du code 4.2 Symboles . . . . . . 4.3 Touches . . . . . . . 4.4 Informations . . . . 4.5 Exercices . . . . . . 4.6 Divers . . . . . . . .
3
5 7 9 11 11 12 12 12 12 13
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
II
5
Introduction
Langages de programmation 5.1 Interprt et compil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2 Haut niveau et bas niveau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3 Typage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Paradigmes 6.1 Programmation imprative . . 6.2 Programmation procdurale . 6.3 Programmation oriente objet 6.4 Programmation fonctionnelle
15
17 17 17 18 19 19 19 19 19 21 21 23 23 23 i
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
Introduction lalgorithmique 7.1 Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Programmation oriente objet 8.1 Gnral . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8.2 Hritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Concepts 9.1 Espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.2 Ramasse-miettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25 25 25 27 27 27 27 28
10 Mthodologie 10.1 Organisation . 10.2 Erreurs . . . . 10.3 Recherche . . 10.4 Autres conseils
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
III
Le langage
29
31 33 33 34 37 37 39 42 45 46 47 47 48 51 57 58 58 59 59 61 62 62 63 64 64 65 65 65 67 67 69 71 72 72 73 75
11 Prsentation 12 Installation et initialisation 12.1 Installation de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12.2 Lancement et utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 Bases et structure 13.1 Tokens de structure 13.2 Autres tokens . . . 13.3 Variables . . . . . 13.4 Rsum . . . . . . 13.5 Exercices . . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
14 Types de base 14.1 Introduction . . . . . . 14.2 Nombres . . . . . . . . 14.3 Conteneurs et squences 14.4 Autres objets . . . . . . 14.5 Rsum . . . . . . . . . 14.6 Exercices . . . . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
15 Structures de contrle 15.1 Construction de prdicats . . . . . 15.2 Condition if . . . . . . . . . . . 15.3 Boucle conditionnelle while . . 15.4 Itration for . . . . . . . . . . . 15.5 Autres techniques pour les boucles 15.6 Instruction pass . . . . . . . . . . 15.7 Imbrications . . . . . . . . . . . . 15.8 Exceptions . . . . . . . . . . . . . 15.9 Rsum . . . . . . . . . . . . . . . 15.10 Exercices . . . . . . . . . . . . . . 16 Fonctions 16.1 Gnralits . . . . . 16.2 Arguments . . . . . 16.3 Fonctions rcursives 16.4 Fonctions anonymes 16.5 Generators . . . . . 16.6 Fonctions built-in . . 16.7 Exercices . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
ii
17 Classes 17.1 Introduction . . . . . 17.2 Mthodes spciques . 17.3 Hritage . . . . . . . 17.4 Exercices . . . . . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
77 77 79 80 80 81 81 81 82 84 84 85 85 86 86 87 89 89 90 91 91 92 92 93
18 Erreurs et exceptions 18.1 Introduction . . . . . . 18.2 Lever une exception . . 18.3 Grer les exceptions . . 18.4 Dnition dexceptions 18.5 Exceptions built-in . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
19 Entres et sorties 19.1 Afchage de donnes (print()) 19.2 Entre au clavier (input()) . . 19.3 Fichiers . . . . . . . . . . . . . . 19.4 Exercices . . . . . . . . . . . . . 20 Modules 20.1 Introduction . . . . . . 20.2 Variantes . . . . . . . . 20.3 Scripts . . . . . . . . . 20.4 Mcanismes . . . . . . 20.5 Modules standards . . . 20.6 Packages . . . . . . . . 20.7 Imports relatif et absolus
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
IV
Aspects spciques
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
95
97 97 97 98 99 99 99 101 101 102 103 104 104 104 105 105 106 106 107
21 Expressions rgulires 21.1 Introduction . . 21.2 Syntaxe . . . . . 21.3 Utilisation . . . 21.4 Exemples . . . . 21.5 Liens . . . . . . 21.6 Exercices . . . .
22 Gestion des chiers et dossiers 22.1 Introduction aux notions de chiers et de dossiers . 22.2 Manipulation des noms chemins . . . . . . . . . . 22.3 Lister les chiers et les dossiers . . . . . . . . . . 22.4 Tests sur les chiers et les dossiers . . . . . . . . . 22.5 Autres oprations . . . . . . . . . . . . . . . . . . 22.6 Exercices . . . . . . . . . . . . . . . . . . . . . . 23 Systme 23.1 Informations sur Python . . . . . 23.2 Informations sur le systme . . . 23.3 Arguments en ligne de commande 23.4 Exercices . . . . . . . . . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
24 Classes tendues 109 24.1 Itrateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
iii
24.2 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 25 Persistance 111 25.1 Base de donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 25.2 Srialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 26 Internationalisation et localisation 115
Annexes
117
119 121 123 123 123 124 124
27 Histoire 28 volutions 29 Bonnes et mauvaises pratiques 29.1 Imports . . . . . . . . . . 29.2 Exceptions . . . . . . . . 29.3 Utilisation des backslash . 29.4 Conventions et style . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
30 diteurs 125 30.1 Interprteurs interactifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 30.2 Environnements de dveloppement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 31 Outils 127 31.1 Gnrateurs de documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 31.2 Pylint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 32 Liens 129 32.1 Autres tutoriels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 32.2 Projets lis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 33 Glossaire 34 Bibliographie 131 133
VI
Sur le livre
135
35 Changements 137 35.1 Version 1.0 (en cours de rdaction) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 36 Licence et auteurs 139 36.1 Licence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 36.2 Auteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
VII
Indices and tables
141
145 147
Python Module Index Index
iv
Livre Python, Version 1.0-draft
Version : 18 February 2012 Les mises jour de ce livre et les corrections des exercices peuvent tre trouves sur le site : http ://harold.e.free.fr/python/. Nhsitez pas me contacter (harold.erbin@gmail.com) pour tout commentaire ou crer un ticket sur Bitbucket (https ://bitbucket.org/Melsophos/tutoriel-python-3/issues/new) pour proposer une amlioration ou rapporter une erreur.
Table des matires
Table des matires
Premire partie
Prface
CHAPITRE 1
Avant-propos
Ce livre a pour but doffrir une large description du langage Python. Il abordera le langage lui-mme, lutilisation des interfaces graphiques (GTK et Qt), la cration dun site web (avec Django) ainsi que des applications aux sciences. Ce projet est n suite la constatation quil nexistait que peu de documentations franaises et rcentes sur Python (mme si celles qui existent sont dune excellente qualit), et a fortiori sur les domainces avancs prcdemment cits. Les parties sur ces derniers points seront rdiges avec le temps. Le point de vue adopt sera rsolument moderne, savoir que seule la version 3 de Python sera traite. Enn, il nest pas ncessaire de connaitre un autre langage avant de pouvoir commencer lire ce livre, car jai pris le parti de dbuter par une introduction la programmation en gnrale, avant de poursuivre en expliquant chaque dtail de Python. Toutefois jespre que mme les connaisseurs y trouveront des informations prcieuses.
Chapitre 1. Avant-propos
CHAPITRE 2
Remerciements
19. Goldszmidt (remarques sur le contenu).
Chapitre 2. Remerciements
CHAPITRE 3
Plan de louvrage
Introduction Cette partie vise donner quelques informations sur la programmation en gnral, sans toutefois entrer dans les dtails puisque dautres ouvrages plus spcialiss existent (et linformation est abondante). Le langage Cette partie abordera le langage lui-mme et ses principaux concepts. Aspects spciques Cette partie abordera des points spciques du langage, qui ne servent que dans certains cas particuliers. GTK Cette partie abordera la cration dune interface graphique avec pyGTK. Qt Cette partie abordera la cration dune interface graphique avec pyQt. Django Cette partie concernera la cration dun site internet avec le framework Django. Sciences Cette partie explicitera lutilisation de Python dans un cadre scientique. Il abordera aussi lalgorithmique. Outils Dans cette partie seront dtaills tous les outils pouvant servir lutilisation de Python. Annexes Enn, cette dernire partie apportera des informations complmentaires. Des exercices seront prsents la n de chaque chapitres, an de donner au lecteur quelques pistes pour sentrainer, mais en aucun cas il ne doit se limiter aux exercices indiqus : la curiosit et les tests personnels sont trs importants pour progresser. De plus, il ne faut pas sempresser daller regarder la correction ds que lon bloque. Au contraire, il faut persvrer, en passant ventuellement autre chose avant dy revenir : il est impossible de tout trouver en quelques secondes. De plus, je vous conseille de chercher sil existe dautres manires de concevoir les programmes des exercices : parfois il existe des manires plus simples ou plus rapides de programmer, que nous navions pas vu au dbut (la question de la rapidit sera aborde en dtails dans la partie scientique).
10
Chapitre 3. Plan de louvrage
CHAPITRE 4
Conventions
4.1 Prsentation du code

Les exemples de code seront afchs comme ceci print a en ligne, et sinon comme ceci :
print a
Parfois la code comportera les numros de ligne ou sera mis en valeur (cadre par exemple). Le symbole >>> (prompt primaire) indique une invite de commande en mode interactif (voir section Interprteurs interactifs pour davantage dexplications), et ... (prompt secondaire) lorsquune commande stend sur plusieurs lignes. Enn, dans le cas dune invite de commande, lafchage attendu est afch juste en dessous.
>>> a = 1 >>> if a == 1: ... print(a) 1
Il sagira donc exactement de ce que le lecteur doit sattendre crire et voir lorsquil utilise Python dans le terminal classique. Dans le cas dun code destin tre plac dans un chier, le code ne sera pas prcd de linvite de commande (et la sortie ne sera logiquement pas afche dans le code).
def function(): return a function()
Enn, lorsque la reprsentation dun objet sera afche, des points de suspension remplaceront son adresse (tout ceci sera vu en dtails) : par exemple, au lieu de <function func at 0xb7a9242c>, il sera crit <function func at ...>, car ladresse change chaque excution. Parfois il sera ncessaire de se servir du terminal (ou ligne de commandes ou encore shell les trois termes seront utiliss) pour lancer une commande bash. En ce cas, linvite de commandes sera reprsente par $. La sortie ventuelle sera afche la ligne.
$ echo 1 1
11
Dans le cas dune simple commande au sein dun paragraphe, linvite et le rsultat ne seront pas afchs, par exemple echo 1. De mme, les noms de chiers, modules, noms de classe ou de fonction, ou tout autre lment du langage, seront afch en police tltype, comme script.py. Lorsque des variables sont utilises sans avoir t dnies explicitement, il est sous-entendu que lutilisateur doit le faire lui-mme. Par exemple si on crit
print a + 1
on part du principe que la variable a a t dnie auparavant, par exemple comme a = 2. Lutilisateur devra prendre garde ce que les types ne soient pas incompatibles (dans lexemple ci-dessus, il est vital que a soit un nombre).
4.2 Symboles
Jutiliserai parfois certains symboles an de simplier les notations. Ces symboles sont les suivants : | est quivalent OU, il indique donc une alternative, (a|b signie que lon peut crire a ou b) ; * remplace un ou plusieurs caractres quelconques ; [] indique une option. Ils ne seront utiliss que lorsque aucune confusion avec un autre lment du langage Python ne sera possible.
4.3 Touches
Lorsquil sera ncessaire dappuyer sur une touche, cela se indiqu ainsi : A. Un + entre deux touches indiquent quil faut appuyer sur les deux touches en mme temps : Ctrl + A.
4.4 Informations
Des encadrs peuvent donner des informations complmentaires : Remarque : un ajout propos dun sujet voqu, moins important que le reste du sujet. Mise en garde : une remarque particulirement importante. Note : Le titre du cadre changera en fonction du sujet. Une rfrence une PEP (Python Enhancement Proposals) sera faite de manire trs similaire une information. Voir aussi : PEP 0 Index of Python Enhancement Proposals
4.5 Exercices
Les solutions aux exercices sont tries par partie puis par chapitre. Le nom du chier correspond au numro de lexercice. Dans les cas o plusieurs algorithmes sont proposs, une lettre (a, b. . . ) sera ajoute aprs le numro.
12
Chapitre 4. Conventions
4.6 Divers
Les traductions en anglais des mots importants seront indiques entre parenthses, an que le lecteur puisse consulter la littrature ou la documentation anglaises sans problmes. La version de Python utilise dans ce livre est la 3.2, mais la majorit du contenu sera valable pour toute version 3.x (o x dsigne un numro quelconque de version). Les prsentations des modules nincluent pas la description de toutes leurs fonctionnalits : lobjectif est de les prsenter et de donner une ide de quel module utiliser en fonction du contexte. Pour une utilisation plus pousse, il faudra se reporter la documentation. Les exemples fournis seront uniquement crits en anglais, pour la simple et bonne raison que la quasi totalit des projets sont en anglais, et quil sagit dune habitude prendre (de plus, il faut sabstraire de la langue utilise et concentrer nos efforts sur la logique). Lautre raison sera dtaille dans le cur du livre et concerne le fait quil est impossible dutiliser des caractres UTF-8 (lettres accentues, par exemple) et que cela nuit la lecture du code. De plus, je noffrirai pas de comparaisons dtailles de Python par rapport aux autres langages.
4.6. Divers
13
14
Chapitre 4. Conventions
Deuxime partie
Introduction
15
CHAPITRE 5
Langages de programmation
Les langages de programmation se distinguent par de nombreuses caractristiques, qui doivent tre prises en compte lors du choix du langage.
5.1 Interprt et compil

Dans un langage compil, le code source nest pas directement lisible par la machine : il est ncessaire de le compiler pour le transformer en langage machine. On obtient alors un excutable qui constitue le programme. Notons quune vrication de la syntaxe est faite lors de la compilation. Lexcutable compil dpend de la plateforme (cest dire du systme dexploitation), et il est ncessaire de recompiler le programme la moindre modication. Au contraire, le code source dun langage interprt est transform la vole par un interprteur en langage machine, ce qui explique la plus grande portabilit de ces langages par rapport aux langages compils. Toutefois il est ncessaire que linterprteur soit prsent sur chaque machine, sans quoi le programme ne pourra pas fonctionner. Dune manire intermdiaire, il existe les langages semi-interprts, dont le code source est compil en bytecode. Cest ce bytecode qui sera interprt, plus rapidement que si le code source ne lavait directement t lui-mme. Exemples : interprt : PHP, Basic ; compil : C, C++ ; semi-interprt : Java, Python.
5.2 Haut niveau et bas niveau

Le niveau dun langage reprsente son degr dabstraction : plus le niveau est haut, plus le langage est abstrait et comprhensible par lhumain. Exemples : haut niveau : Basic, Python ; bas niveau : Assembler.
17
5.3 Typage
Il est ncessaire de dclarer manuellement le type de chaque variable dans les langages typage statique. Par exemple en C, on aurait int number = 1 (dnition de la variable number, qui est de type entier et qui se voit attribuer la valeur 1). De plus, dans un tel langage, le type dune variable ne peut changer de lui-mme en fonction du contexte. Au contraire, dans les langages typage dynamique, il nest pas ncessaire de dclarer le type dune variable. En Python, on pourra crire number = 1, ce qui aura le mme effet que le code plus haut en C, et, plus loin, number = c aprs la dernire commande (number est cette fois-ci de type chaine de caractres et possde la valeur c), ce qui serait interdit en C. Dans un langage typage fort, il est impossible dutiliser un type la place dun autre sans convertir explicitement lobjet. Au contraire, lorsque le typage est faible, un type peut aisment se substituer un autre. Par exemple en PHP (langage typage faible et dynamique), on a
echo 1 + 1;
La sortie de ce programme sera 2. Cela montre bien que lon peut sommer une chaine de caractres et un nombre 1 : PHP convertit de lui-mme la chaine de caractres en nombre car il juge cela adapt ici ; un tel programme en C ou en Python ne fonctionnerait pas. Exemples : typage statique : C, Java ; typage dynamique : Python, PHP ; typage fort : Python ; typage faible : PHP.
1. Voir le Chapitre Types de base pour plus dinformations sur les types.
18
Chapitre 5. Langages de programmation
CHAPITRE 6
Paradigmes
Il existe diffrents paradigmes de programmation, cest dire dapproches des problmes. Un mme langage peut tre utilis selon diffrents paradigmes, cela dpend essentiellement de lobjectif nal. Ci-aprs suit une liste, non exhaustive, des diffrents paradigmes qui existent.
6.1 Programmation imprative

En programmation imprative, le code est excut de manire presque linaire : des boucles et des conditions permettent de contrler le ux dinstructions. Exemples : Assembler.
6.2 Programmation procdurale

Le code est est plus modulaire car structur en fonctions ou procdures qui sont appeles dautres endroits.
6.3 Programmation oriente objet

Il sagit dun paradigme qui consiste considrer chaque donne manipule comme un objet, dnis par ses attributs (donnes le constituant) et ses mthodes (utilises pour le manipuler). Ce paradigme, au coeur de la programmation Python, sera dtaill dans le chapitre suivant. Exemples : C++, Java, Python. . .
6.4 Programmation fonctionnelle

Exemples : Lisp, Scheme, Haskell, OCaml, Erlang. . .
19
20
Chapitre 6. Paradigmes
CHAPITRE 7
Introduction lalgorithmique
7.1 Structure
7.1.1 Grammaire
Il faut distinguer en premire approche les instructions des expressions : Une expression est une combinaison doprateurs, de variables et de valeurs qui sera interprte et qui retournera une valeur (type). Lon peut assimiler une expression avec ce que lon crirait dans une calculatrice. Toutefois, une expression nindique pas ce qui doit tre fait de cette valeur, il faut donc une instruction pour la traiter. Ainsi, une expression peut tre remplace par une valeur du mme type quelle renvoie tout en laissant le programme grammaticalement correct. Il existe diffrents types dexpressions : expression arithmtique : un simple calcul (1+2, 10/2...) ; expression boolenne : une valeur boolenne, ou encore une comparaison (True, 1<2...) ; une variable ; une chaine de caractres (chaine) ; lappel une fonction. Une instruction indique quune action ou une commande doit tre effectue. L aussi il en existe diffrents types : afchage (print 1) ; affectation : dnition dune variable (a = 1) ; condition (if a > 1: print a) ; boucle (while a > 1: print a). Parfois, le lien entre expression et instruction dans le langage est tnu.
7.1.2 Syntaxe
Lignes Une ligne physique se termine par le caractre de n de ligne (LF, ou \n, sous les systmes UNIX, CRLF, ou \r\n, sous Windows). Dans la plupart des langages, une instruction peut stendre sur plusieurs lignes physique 1 : dans ce cas, un caractre spcial (comme le point-virgule ; en C ou en PHP) marque la n dune ligne.
1. Nous verrons que ceci nest pas le cas en Python, sauf cas particuliers.
21
Bloc On dsigne par bloc tout ensemble dinstructions relies logiquement. Par exemple une suite dinstructions excutes dans une boucle. Tokens Un token est une unit lexicale (on pourrait traduire par lexme, en franais), cest dire un ensemble de symboles (ponctuation, lettres et chiffres, mots particuliers...) reconnu et interprt dune manire spcique. Par exemple, dans de nombreux langages, le symbole if permet dintroduire une condition. Le morceau de code
22
Chapitre 7. Introduction lalgorithmique
CHAPITRE 8
Programmation oriente objet
8.1 Gnral
Un objet est dit immuable (imutable en anglais) sil ne peut pas tre modi une fois quil a t cr. Un objet est dit appelable (callable en anglais) sil est possible dy faire appel pour lutiliser. Cela revient dire que lon doit faire suivre son nom de parenthses pour lappeler.
8.2 Hritage
Lhritage consiste driver une ou plusieurs classes prexistantes an den crer une nouvelle qui possdera les attributs et mthodes des classes parentes (ventuellement modis) plus des attributs et mthodes nouveaux.
23
24
Chapitre 8. Programmation oriente objet
CHAPITRE 9
Concepts
9.1 Espaces de noms 9.2 Ramasse-miettes

Le ramasse-miettes est un mcanisme permettant de supprimer les variables qui ne sont plus utilises par le programme. Cela permet lutilisateur de ne pas (ou trs peu) avoir sinquiter de la gestion de la mmoire. Python dispose dun ramasse-miettes, Java aussi par exemple.
25
26
Chapitre 9. Concepts
CHAPITRE 10
Mthodologie
10.1 Organisation
En programmation comme en toute chose que lon cre de manire raisonne, il peut tre ncessaire dagir avec mthode et rigueur, pour de multiples raisons : viter de se disperser, gagner du temps, travailler efcacement. . . Ainsi il convient dadopter des conventions lors de lcriture du code : elles permettent de sy retrouver plus aisment lorsque lon revient sur notre code plusieurs mois plus tard, dadopter un style homogne lorsque plusieurs personnes travaillent sur un mme projet (et ainsi de faciliter linsertion des arrivants). . . La communaut Python a dailleurs tabli ses propres conventions (voir la section Conventions et style). De mme, il est important dajouter de nombreux commentaires pour accompagner le code, et ce pour plusieurs raisons : cela facilite la comprhension du code par les autres membres du projet ; cela permet de reprendre plus aisment un code mis de ct quelques temps.
10.2 Erreurs
Il est dit quun programmeur passe la majorit de son temps non pas crire du code, mais le dbugger. Il est possible de rduire ce temps en tant rigoureux, mais aussi en sachant adopter le bon comportement. Ainsi, il est important de savoir analyser et comprendre les erreurs qui surviennent lors de lexcution dun programme (et en cela Python est dune grande aide), la manire la plus triviale tant de comprendre le mode de fonctionnement interne du langage (sa logique) et a fortiori les dtails de lalgorithme utilis (car un code qui fonctionne un temps sans que lon ne comprenne pourquoi sera trs difcile corriger si cela devient ncessaire). La programmation demande donc, plus que de la rigueur, de la logique ; pour rappel, lalgorithmique relve des mathmatiques. Pour cette mme raison il est dconseill de recopier un code trouv quelque part et lutiliser tel quel (attention, je ne parle pas des modules, qui sont eux crs dans cette optique).
10.3 Recherche
La programmation consiste en un vritable travail de recherche : recherche des erreurs, dans la documentation, sur internet. . . Il sagit dun lment au coeur de tout projet, ncessaire pour mener bien ce dernier. Le premier aspect de la recherche est la dcouverte de ce qui provoque des bugs, via diffrentes mthodes.
27
De plus, il est gnralement fortement dconseill de chercher apprendre par coeur plus que les bases du langage car la logique importe bien plus, comme je lexpliquais au-dessus et, ce faisant, il devient primordial de savoir trouver efcacement les informations que lon cherche (aussi bien pour rparer un bug que pour explorer un point spcique du langage ou encore ne pas rinventer la roue 1 ). Je recommande vivement chaque programmeur, mme dbutant, davoir sous la main la documentation (que ce soit site internet ou chier. . . ) du langage concern ainsi que celle des extensions les plus utilises. Souvent, un index ainsi quune table des matires dtailles permettent de trouver facilement ce que lon cherche dans tel ou tel domaine. Il est aussi important de savoir chercher les informations sur internet (et pour cela connaitre les fonctionnements des moteurs de recherche) lorsque les informations sont insufsantes dans la documentation. Enn, il est toujours de bon gout dexprimenter, cest dire ne pas hsiter modier les exemples proposs, observer ce quils donnent et, ds que le rsultat nest pas celui escompt, rechercher pourquoi et comment corriger le problme.
10.4 Autres conseils

Il est toujours conseill de rchir notre programme : savoir ce quil doit faire, comment, etc., et de ne pas se lancer directement dans la programmation. Cela permet davoir une ide densemble du programme et de mieux le construire, comme je le conseillais dans la premire section. De plus, il est important de prvoir tout ce qui peut arriver dans un programme, et de traiter tous les cas imaginables, mme les plus improbables, an de ne pas avoir de surprises (par exemple, il est conseill de toujours prvoir un choix par dfaut lorsque lon demande quelque chose lutilisateur). Cest dailleurs pour cette raison quil est recommand de tester les programmes, an de dcouvrir des comportements tranges.
1. Not Invented Here, NIH, en anglais
28
Chapitre 10. Mthodologie
Troisime partie
Le langage
29
CHAPITRE 11
Prsentation
Python est un langage : semi-interprt ; de haut niveau ; orient objet. Il est utilis dans de nombreux domaines, aussi bien pour concevoir des sites internet, des applications de bureautique, scientiques, ou encore des scripts dadministration de systmes. . . Contrairement dautres langages, tel que Perl, o il existe de nombreuses manires de faire la mme chose 1 , une seule voie est privilgie en Python. Ceci permet aux divers relecteurs de ne pas se retrouver dsempar face une suite dinstructions sotriques, impossibles comprendre si lon a pas lu ce sujet. Il ny aura pas beaucoup dexercices dans les premiers chapitres, puisquil sagit dapprendre les bases du langage, de shabituer avec la syntaxe et les concepts. Toutefois, il est important de faire vos propres tests.
1. Theres More Than One Way To Do It, un adage Perl.
31
32
Chapitre 11. Prsentation
CHAPITRE 12
Installation et initialisation
12.1 Installation de Python

12.1.1 UNIX
Dans la plupart des cas, Python est prinstall sur les systmes UNIX (MacOS compris). Toutefois, la version installe est peut-tre trop ancienne, et en ce cas il faut installer une plus rcente. An de vrier la version installe, tapez dans votre terminal 1 :
$ python -V
La sortie de la commande devrait tre quelque chose comme :

Python 2.7.2
Ou encore :
Python 3.2.1
Si la version est infrieure la 3.0, alors il faut en installer une plus rcente. Il faut tre prudent quant la coexistence de plusieurs versions de Python qui peut entrainer des incompatibilits. Linux La dmarche la plus simple sous Linux est dinstaller une version depuis les dpts. Pour ce faire, utiliser votre gestionnaire de logiciels (Synaptic ou apt-get sous Debian par exemple) pour chercher la dernire version 3 disponible. Voici quelques exemples dinstallation : Debian et drivs (dont Ubuntu) : sudo apt-get install python3 ArchLinux : pacman -S python3 Fedora : yum install python3 Il peut arriver que la version 3 ne soit pas disponible dans les dpts, en ce cas il faut compiler soi-mme une version de Python depuis les sources (trouves sur http ://www.python.org/download/), mais ceci dpasse le cadre de ce livre. Avant den arriver l, vrier si le nom du paquet nest pas lgrement diffrent (par exemple python3.x au lieu de python3).
1. Il est accessible dans Applications Utilitaires Terminal sous MacOS.
33
MacOS Linstallation laide de brew doit fonctionner :

brew info python3
Sinon il peut tre ncessaire l aussi de compiler les sources. En autre recours, il est possible de consulter cette page : http ://www.python.org/download/mac/.
12.1.2 Windows
Python nest presque jamais install sous Windows, il faut donc le faire soi-mme aprs lavoir tlcharg : http ://www.python.org/download/. Choisir Python 3.x Windows x86 MSI Installer (Windows binary does not include source) . 2 Il est conseill de linstaller dans un dossier la racine de C:, par exemple dans C:\python. Il convient ensuite dajouter Python au PATH de Windows, ce qui permettra de lancer les scripts directement par un double-clic. Pour ce faire : 1. Clic droit sur Poste de travail. 2. Proprits. 3. Onglet Avanc. 4. Bouton Variables denvironnement. 5. Dans la section Variables systmes, slection Path et appuyer sur Modier. 6. Ajouter un point-virgule, suivi du chemin vers lexcutable Python. 7. Par exemple, si vous navez rien chang : C :\Python31\python.exe 8. Il faut redmarrer pour que le changement prenne effet.
12.2 Lancement et utilisation

Il existe deux principales manires dutiliser Python : en mode interactif ; en lanant un script.
12.2.1 Mode interactif

Bien quil puisse apparaitre peu utile au premier abord, le mode interactif sera dune grande aide pendant toute votre vie de dveloppeur Python : il permet de se familiariser avec la syntaxe au dbut, dutiliser laide interactive sur les commandes... De plus, moins que vous nutilisiez des commandes qui affectent les chiers du systme, tout est rinitialis ds que vous quittez le mode interactif, donc rien de grave ne peut arriver. Dans un terminal UNIX ou DOS, il suft de taper python (ou python3 si la version 3 nest pas celle installe par dfaut 3 ) pour lancer Python en mode interactif. Linvite principale >>> apparait alors (rappelons que linvite est indique dans les exemples, mais il ne faut pas la recopier, car elle nest l que pour signier que lexemple a lieu dans le mode interactif). Lorsque lon crit plusieurs commandes relies ensemble (condition, boucle), linvite principale est remplace par linvite secondaire .... Voici un exemple :
2. Vous pouvez aussi tlcharger Python 3.x Windows AMD64 installer si vous avez un processeur 64 bits. 3. A fortiori, il est possible dutiliser pythonx.y pour lancer la version x.y ( condition quelle soit installe, bien entendu).
34
Chapitre 12. Installation et initialisation
>>> 1+1 2 >>> if 2 > 1: ... print(2 est plus grand que 1.) 2 est plus grand que 1.
Note : Sous Windows, pour ouvrir le terminal DOS, il faut faire chercher Excuter (accessible dans le menu Dmarrer jusqu Windows XP) puis taper cmd et valider. Sur les Windows plus rcents, le menu Excuter est cach par dfaut : pour le faire apparaitre, il est ncessaire de cocher la case Commande Excuter dans Proprits Menu Dmarrer Personnaliser. On peut aussi y accder par le raccourci Windows + R. Dans tous les cas, il est possible de lancer un terminal Python via les programmes. Warning : Il sera fortement conseill de prfrer IPython (dtails en annexe) au mode interactif de base, lorsque celui-ci supportera enn Python 3. Ainsi, on crira une commande directement la suite de linvite, et on validera avec la touche Entre. Aprs chaque commande, lventuel rsultat est afch, puis une nouvelle invite apparait. Une variable peut directement tre afcher, sans ncessairement utiliser la fonction print(), pour ce faire, il suft dcrire le nom de la variable :
>>> a = 1 >>> a 1
De plus, une variable spciale, lunderscore _, est disponible en mode interactif : sa valeur vaut celle de la dernire expression.
>>> 1 + 1 2 >>> _ 2 >>> _ + 1 3
Note : La combinaison Ctrl+D permet de quitter le mode interactif python. On peut aussi utiliser la fonction exit(). La fonction help(), dnie seulement dans le mode interactif, permet dafcher des informations sur un objet (son docstring plus prcisment) : celles-ci comprennent les arguments quil faut fournir lobjet, une courte description ainsi que la liste des mthodes et des attributs (accompagns eux aussi dune description) :
>>> help(print) Help on built-in function print in module builtins: print(...) print(value, ..., sep= , end=\n, file=sys.stdout) Prints the values to a stream, or to sys.stdout by default. Optional keyword arguments: file: a file-like object (stream); defaults to the current sys.stdout. sep: string inserted between values, default a space. end: string appended after the last value, default a newline.
12.2. Lancement et utilisation
35
Si on ne lui donne aucun argument, alors la fonction help() lance laide interactive, et lon peut demander des informations sur plusieurs objets la suite. On peut quitter ce mode en crivant q ou quit.
12.2.2 Fichier
Gnralement, lon crit le code Python dans un chier (portant souvent lextension .py), que lon peut lancer depuis le terminal avec la commande python script.py. Un tel chier peut tre dit avec nimporte quel diteur de texte (on se reportera lannexe sur les diteurs pour plus de dtails et quelques conseils). Il est aussi possible de lancer un script par un double-clic si Python est dans le PATH de Windows ou, dans le cas des systmes UNIX (si le chier a t rendu excutable), si la premire ligne du chier est
#! /usr/bin/python3
Le systme utilisera la version la plus rcente de Python 3 (si on avait indiqu seulement python, alors le systme choisit la version par dfaut, qui est souvent une 2.x). Finalement, la solution la plus simple (au moins pour des programmes peu tendus, ainsi que pour tester) pour lancer un programme Python consiste utiliser la ligne de commandes :
python3 name.py
aprs stre plac (avec cd, par exemple) dans le rpertoire contenant le chier lancer.
36
Chapitre 12. Installation et initialisation
CHAPITRE 13
Bases et structure
Dans ce chapitre, nous allons tudier laspect structurel gnral du Python, savoir comment on prsente le code, quels sont les mots et les symboles importants... Le but est de donner une ide de la manire dont Python est construit et dont les programmes sont analyss. Ne soyez pas surpris si nous navons pas encore vu le sens de certaines expressions, elles ne sont l que pour donner un aperu visuel et pour permettre de lire un programme Python : lessentiel est de savoir reconnaitre les divers symboles et lorganisation logique, le reste viendra avec lhabitude. Note : Mme si laspect technique de ce chapitre peut rebuter, il est important au moins dy jeter un il an davoir une ide gnrale de ce que lon peut faire ou pas faire (les deux sections sur les variables sont vitales). On pourra souhaiter relire ce chapitre aprs stre habitu au langage travers les chapitres suivants, an de mieux saisir certains points. On peut dcomposer les tokens en deux types : ceux responsables de la structure gnrale, que lon peut assimiler laspect visuel : indentation, nouvelle ligne... les autres, qui sont plus proches du langage : variables, mots-cls, dlimiteurs...
13.1 Tokens de structure

13.1.1 Lignes
Il faut distinguer les lignes physiques (cest dire les lignes afches lcran) des lignes logiques (telles quelles sont reconnues par Python). Gnralement, une ligne physique correspond une ligne logique, et une instruction Python ne peut pas stendre sur plusieurs lignes. Toutefois, il est possible de crer une ligne logique stendant sur plusieurs lignes relles de deux manires : explicitement : il faut indiquer linterprteur quune instruction stend sur plusieurs lignes en ajoutant un antislash \ la n de la ligne. La ligne qui suit peut tre indente de nimporte quelle manire. Il est quand mme conseill dadopter une certaine logique pour facilier la lecture.
>>> if a > 1 and b > 5 \ ... and c < 3: ... print(1)
implicitement : une expression entoure de parenthses (ou de crochets, ou encore daccolades) peut stendre sur plusieurs lignes. De mme, pour les dictionnaires ou les listes.
37
>>> if (a > 1 and b > 5 ... and c < 3): ... print(1)
Note : Il est souvent plus lisible dutiliser des parenthses quun antislash. Dans les deux cas, lindentation de la deuxime ligne est arbitraire :
>>> if (a > 1 and b > 5 ... and c < 3): ... print(1)
On prfrera malgr tout le premier exemple qui est beaucoup plus lisible. Plusieurs instructions peuvent tre places sur une mme ligne condition dtre spares par un point-virgule ;, mais cela nuit grandement la lisibilit : on rservera donc cette criture au mode interactif :
>>> print(1); print(2) 1 2
Enn, une ligne vierge ou contenant uniquement des espaces ou tabulations est ignore par linterprteur. Elles peuvent donc tre insres selon le bon vouloir du programmeur an darer le code et de sparer les blocs logiques. Note : print() est une fonction permettant dafcher du texte. Son utilisation sera dtaille dans le chapitre Entres et sorties. Pour le lecteur curieux, on notera que le token permettant dindiquer la n dune ligne logique est nomm NEWLINE.
13.1.2 Blocs et indentation

En Python, les blocs dinstructions sont dlimits par lindentation. Pour cette raison, il nest pas possible dindenter librement les lignes comme on peut le faire dans dautres langages.
a = 1 if a > 2: b = a + 1 print(b) print(a)
Les lignes 3 et 4 ne seront excutes que si la condition est vraie (ici ce nest pas le cas), tandis que la dernire, qui nest pas indente, nest pas inclue dans la condition. Voici un exemple de mauvaise indentation :
>>> print(1) File "<stdin>", line 1 print(1) ^ IndentationError: unexpected indent
Reprenant lexemple prcdent, mais avec une lgre erreur dindentation :
38
Chapitre 13. Bases et structure
>>> if a > 2: ... b = a + 1 ... print(b) File "<stdin>", line 3 print(b) ^ IndentationError: unexpected indent
Lon rajoute facilement un espace en dbut de ligne, espace qui sera compt comme une indentation et causera donc une erreur. Il faut y prendre garde. Les indentations et dsindentations successives sont reprsentes par les tokens INDENT et DEDENT. Ainsi, ce sont les indentations relatives qui sont importantes, et il nest pas ncessaire quelles soient consistantes dans tout le code :
>>> if a > 2: ... print(1) ... else: ... print(2) ... 1
Mais par piti, ne faites jamais a !
13.1.3 Commentaires
Un commentaire est introduit par le signe # et stend jusqu la n de la ligne. Il peut tre ajout la n dune expression
>>> # commentaire >>> # print(1) >>> print(1) # un autre commentaire 1
Les commentaires sont ignors au moment de lanalyse du code et ne sont donc pas considrs comme des tokens.
13.2 Autres tokens

13.2.1 Variables
Une variable permet de stocker une donne quil sera possible de rutiliser plus tard. Laspect dynamique des variables permet dexpliquer les interactions possibles avec un programme 1 . Le nom dune variable : doit contenir uniquement des caractres alphanumriques (lettres non-ASCII comprises), ou des underscores ; doit commencer obligatoirement par un caractre alphabtique ou un underscore ; est sensible la casse (cela signie que var est diffrent de Var ou encore VAR) ; ne peut tre nomme de la mme manire quun mot-cl (voir section Mots-cls). Note : La possibilit dutiliser des caractres non-ASCII est apparue en Python 3. Toutefois, malgr la possibilit dcrire ainsi le programme dans nimporte quelle langue (franais, grec, chinois. . . ), il est vivement dconseill de le faire : pour quun programme vive, il doit y avoir des changes, et langlais est (hlas) la langue qui est gnralement comprise par tous.
1. Par exemple, une page internet en HTML pur ne saurait tre dynamique car ce langage ne possde pas de variables.
13.2. Autres tokens
39
Voir aussi : PEP 3131 Warning : Mme si cela est possible, il est fortement dconseill de renommer une fonction built-in :
>>> print = 2 >>> print(test) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: int object is not callable
Dans la second expression, Python essaie dappeler le chiffre 2 avec largument test. Or un nombre na pas dattribut call (cest dire quil ne peut pas se comporter comme une fonction), do lerreur. Utiliser un identiant invalide lvera une exception SyntaxError.
>>> a@ = 1 Traceback (most recent call last): File "<stdin>", line 1 a@ = 1 ^ SyntaxError: invalid syntax >>> 2abc = 1 Traceback (most recent call last): File "<stdin>", line 1 2abc = 1 ^ SyntaxError: invalid syntax
Note : Il existe certaines conventions de nommage pour les variables (ainsi que pour les classes, fonctions, etc). Voir la section Conventions et style. En premire approche, il est conseill dutiliser uniquement des minuscules et des underscores, et dessayer de faire des noms aussi courts que possible (mais qui conservent un sens). Il existe certaines catgories didentiants spciaux, reconnaissables un schma particulier : _* est utilis pour indiquer les attributs protgs. Ces derniers ne seront pas imports par from module import *, ni directement accessible par la notation pointe. __* est utilis pour indiquer les attributs privs. __*__ est utilis par certains noms dnis par le systme. Une application ne devrait pas avoir utiliser des identiants de cette forme. Nous les reverrons en temps voulu.
13.2.2 Littraux
Les littraux sont des valeurs constantes de certains types prdnis : les chaines de caractres et autres types similaires (encadrs par des guillemets) ; les nombres (entiers, ottants et imaginaires). Voici quelques exemples : a, abc, 1, 2.3...
13.2.3 Mots-cls
Les mots-cls introduisent une instruction et ils servent indiquer une action spciale ou dnir une variable trs spciale. Contrairement aux fonctions, leur argument nest pas entour de parenthses. 40 Chapitre 13. Bases et structure
False None True and as assert break
class continue def del elif else except
finally for from global if import in
is lambda nonlocal not or pass
raise return try while with yield
Lutilisation de ces mots-cls sera dtaille au cours du livre. On parle aussi de mots rservs, car on na pas le droit de les utiliser comme nom de variables :
>>> for = 2 File "<stdin>", line 1 for = 2 ^ SyntaxError: invalid syntax
Note : Dans les versions 2.x, print et exec sont des mots-cls. Ne vous tonnez donc pas de les voir tre utiliss sans parenthses dans des programmes crits dans une ancienne version.
13.2.4 Oprateurs
Un oprateur permet dexcuter, comme son nom lindique, une opration particulire. Les valeurs auxquelles ils sont appliqus sont appeles oprandes. Il existe de nombreux oprateurs, lists dans le tableau Liste des oprateurs. Leurs effets sont diffrents selon les types avec lesquels ils sont utiliss, par exemple :
>>> 1 + 1 2 >>> a + b ab
Leurs utilisations seront donc dtailles dans les sections associes chaque type. Nous verrons aussi comment surcharger les oprateurs, cest dire les utiliser avec de nouveaux objets.
& << < + / | >> > // ^ == <= * % ~ != >= **
Il est ncessaire de faire attention lordre des oprateurs, car ils ont des priorits diffrentes lors de lvaluation 2 . Note : Il est de coutume de placer un espace autour de chaque oprateur ; comme toute convention, celle-ci nest bonne respecter que si elle ne nuit pas la lisibilit : par exemple, on crira plutt (2+1)*4 que (2 + 1) * 4.
2. Au mme titre que les oprateurs en mathmatiques.
13.2. Autres tokens
41
13.2.5 Dlimiteurs
Voici la liste des dlimiteurs :
( , += &= ) : -= |= [ . *= ^= ] ; /= >>= { @ //= <<= } = %= **=
Notons que le point . sera aussi utilis comme sparateur dcimal.
13.3 Variables
Dans cette section nous allons voir plus en dtails lutilisation des variables.
13.3.1 Affectation
On parle aussi dassignation. Laffectation se fait grce au signe =. Elle permet dattribuer une valeur variable. Il est bien entendu possible de changer le contenu dune variable en lui affectant une nouvelle valeur.
>>> a = 1 >>> a 1 >>> a = var >>> a var
Lors de laffectation, linterprteur effectue plusieurs actions : il cre et stocke lobjet (et dtermine son type) associ la variable sil nexiste pas encore ; il stocke le nom de la variable ; il effectue un lien (on parle de rfrence) entre lobjet et le nom de la variable ; il attribue dynamiquement un type lobjet. Toutes les informations sont stockes dans la mmoire de lordinateur. Warning : Il ne faut pas confondre loprateur daffectation avec celui dgalit (==).
13.3.2 Affectation calcule

Il est possible de raccourcir linstruction a = a+1 3 en a += 1. De mme, cela est possible avec tous les autres oprateurs binaires.
>>> >>> >>> 2 >>> >>> 16 >>> a = 0 a += 2 a a *= 8 a a %= 3 + 2
3. En mathmatiques, cette notation na bien entendu aucun sens. Toutefois, comme il est prcis, plus haut, il ne sagit pas dune galit mais dune affectation.
42
>>> a 1
Au cas o la dernire affectation serait difcile comprendre, il faut la lire ainsi : a = a % (3+2). Bien que lon ait utilis des chiffres dans cet exemple, laffectation calcule est dnie pour tous les oprateurs et reste valable quels que soient les types dobjets manipuls :
>>> s = ha >>> s *= 5 >>> s hahahahaha
Note : On parle dincrmentation dans le cas o lon ajoute 1 par cette mthode, et de dcrmentation dans le cas o lon retranche 1. Les notations du type a++ que lon peut voir dans dautres langages nexistent pas en Python.
13.3.3 Rfrences
Lorsque lon assigne le mme objet diffrentes variables, cet objet nest pas cr nouveau chaque fois : une rfrence est cre. Elle peut tre vue comme un lien entre les noms, et le contenu. Tant quau moins un lien existe, lobjet perdure. Il ne sera supprim que lorsque la dernire rfrence disparait (grce au ramasse-miettes). Par exemple, le code suivant ne crera quun seul objet, mais trois rfrences :
>>> x = 1 >>> y = 1 >>> z = 1
Il est dailleurs possible de vrier que lobjet est bien unique grce au mot-cl is (qui sera dtaill plus loin) :
>>> x is y True
13.3.4 Afchage dune variable

Nous prendrons un peu davance an daborder le point essentiel quest lafchage dune variable dans le mode interactif ou dans le terminal pour un programme lanc depuis la ligne de commande. Nous avons dj vu la premire mthode, uniquement en mode interactif, qui consiste crire le nom de la variable au prompt :
>>> var = a >>> var a
La seconde solution est dutiliser la fonction print().

>>> print(var) a >>> print(chaine) chaine
Elle admet une grande diversit darguments, que nous tudierons plus tard. Notons simplement que si plusieurs arguments sont fournis, alors ils seront tous afchs sur la mme ligne, spars par un espace :
13.3. Variables
43
>>> print(Nous sommes le, 2, dcembre.)
Note : Remarquez que dans le premier cas, a est afch, tandis que dans le second lon obtient a. En fait, print afche la valeur de lobjet, tandis que lautre mthode afche la reprsentation de lobjet. Nous verrons cela en dtails plus loin.
13.3.5 Affectations multiples

Il est possible daffecter plusieurs valeurs plusieurs variables en une seule ligne :
>>> a, b, c = 1, 2, var >>> a 1 >>> b 2 >>> c var
On peut aussi affecter la mme valeur plusieurs variables dun seul coup de la manire suivante :
>>> a = b = 1 >>> a, b (1, 1)
Toutefois cette criture peut avoir des effets pervers, car Python cre deux rfrences dun mme objet, et non deux objets diffrents : ainsi, si on modie lobjet travers une des deux variables, alors la modication sera rpercute dans la deuxime. Pour illustrer ce fait, crons deux listes qui contiennent lorigine la squence de chiffre 1, 2, 3, et nous cherchons ensuite remplacer le dernier chiffre de la seconde liste uniquement :
>>> >>> >>> [1, >>> [1, l1 = l2 = [1, 2, 3] l2[2] = 5 l2 2, 5] l1 2, 5]
Ainsi que nous le voyons, la valeur de la premire liste a aussi chang ! On peut vrier que les deux listes ne sont pas deux objets distincts :
>>> l1 is l2 True
Il existe plusieurs solutions ce problme, que nous verrons dans le chapitre sur les listes. Nous esquissons une premire solution dans la note. Note : Reprenons lexemple prcdent o lon a assign la valeur 1 a et b, et changeons la valeur de b :
>>> >>> >>> (1, a = b = 1 b = 2 a, b 2)
44
Pourquoi a na-t-il pas pris la valeur 2 lui aussi ? La raison est que nous avons affect une nouvelle valeur la variable b, et donc un nouvel objet, ce qui ne modie en rien lobjet prcdent. Ainsi, une premire mthode pour contourner le problme prcdent consiste recrer une liste et lassigner b.
13.3.6 change de valeurs

Parfois lon souhaite changer les valeurs de deux variables. L o dautres langages obligent le programmeur utiliser une variable intermdiaire, Python offre une solution lgante :
>>> x, y = y, x
Ceci est une consquence directe de laffectation multiples vue juste avant. Ainsi, il est de mme possible dchanger les valeurs de plusieurs variables :
>>> c, a, d, b = a, b, c, d
Vrions-le sur un exemple particulier :

>>> x, y = 1, 2 >>> x, y = y, x >>> print(x, y) 2 1
13.3.7 Suppression dune variable

Pour supprimer une variable, nous utilisons le mot-cl del, qui accepte un ou plusieurs arguments. Dans lexemple qui suit, nous supposons que les variables ont t dclares prcdemment.
>>> del a >>> del b, c, d >>> del a Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name a is not defined
Nous remarquons quune exception est leve si nous essayons de supprimer une variable qui nexiste pas (ou plus).
13.4 Rsum
Dans ce chapitre nous avons expliqu la construction dun programme Python, en dtaillant les structures et les identiants reconnus par le langage. Les diffrents tokens non lis la structure sont les suivants : identiants de variables ; les littraux ; mots-cls ; oprateurs ; dlimiteurs. Les espaces permettent de sparer les tokens, mais ils nen sont pas eux-mmes. Ensuite, nous avons dtaill lutilisation des variables : cration et gestion par lordinateur, suppression et afchage.
13.4. Rsum
45
13.5 Exercices
1. Essayer de changer le contenu de deux variables sans utiliser laffectation multiple.
46
CHAPITRE 14
Types de base
Nous allons maintenant tudier les principaux objets utiliss en Python, que nous appellerons des types : il sagit dobjets relativement simples, compars ceux que lon peut trouver ou construire dans des modules spcialiss, et ces types reprsentent des objets assez intuitifs : les nombres (entier, virgule...) ; les listes, les chaines de caractres et dautres squences ; les boolens, llment nul... Nous ne dtaillerons pas toutes les subtilits ni les usages des types tout de suite, et nous nous contenterons de jeter un il leur dnition, leurs principales caractristiques ainsi que leur comportement en fonction des oprateurs.
14.1 Introduction
Commenons par prsenter deux fonctions que nous utiliserons continuellement : type(object) Retourne le type de object au moyen un objet de type. isinstance(object, classinfo) La variable classinfo peut tre une classe ou un tuple de classes. La fonction retourne True si object est une instance dune des classes de la liste ou dune sous-classe. Nous verrons quelques exemples explicites dans les sections qui suivent. On prfrera rserver lusage de type() au mode interactif, quand on veut vrier le type dun objet : en effet, la fonction isinstance() est plus robuste car elle vrie aussi si lobjet ne drive pas dune sous-classe des classes indiques. De plus, comme elle retourne un boolen, la fonction est plus propre pour crire un test. Comparer les critures suivantes :
>>> type(1) == int True >>> isinstance(1, int) is True True
On aurait mme pu crire omettre le is True comme la syntaxe est assez claire. Note : type() retourne en fait lobjet de classe et permet donc de construire directement un objet du mme type que son argument :
47
>>> type(1)(102) 102
qui a bien le mme effet que :

>>> int(102) 102
Cette construction peut tre utile si on veut convertir un objet dans le mme type quun second, sans connaitre ce type lavance.
14.2 Nombres
14.2.1 Introduction
Cette section suppose que le lecteur possde quelques notions de mathmatiques, mme si certains aspects un peu plus avancs sont traits an de viser lexhaustivit. Note : Tous les objets nombres drivent de la classe numbers.Number.
14.2.2 Flottants
Les ottants, ou nombres rels, reprsentent les nombres virgule. Ils peuvent tre reprsents de plusieurs manires : notation virgule (ex. : 1.1) : la partie entire est spare de la partie dcimale par un point 1 ; notation scientique (ex. : 11e-1) : un nombre est mis multipli par la puissance de 10 indiqu aprs un e (minuscule ou majuscule) : mathmatiquement, cela revient a crire 11 101 = 1.1. La fonction float() permet de convertir un nombre en ottant. La prcision de ces nombres dpend entirement de la machine sur laquelle est excute Python, mme si cela nest pas afch explicitement lcran.
>>> 1.1 1.1 >>> type(1.1) <class float> >>> float(1) 1.0 >>> type(1.0) <class float> >>> 2e-2 0.02 >>> type(2e-2) <class float>
Un nombre entier dont la partie dcimale est explicitement reprsente est considr comme un nombre virgule. Cela pouvait tre utile dans les versions prcdentes mais beaucoup moins dans la version 3. Nous remarquons un effet de bord indsirable lorsque lon entre 1.1 : il sagit dun problme commun tous les langages ds que lon utilise des nombres ottants. Ceci est d la manire dont les nombres sont grs.
1. La notation des nombres virgule diffre ici de celle habituellement adopte en France.
48
Chapitre 14. Types de base
Warning : Il faut faire trs attention utiliser le point et non la virgule pour les nombres dcimaux : deux nombres spars par une virgule seront considrs comme un tuple. Warning : Les anciennes versions de Python peuvent afcher de manire incorrecte les nombres ottants cause derreurs darrondis :
>>> 1.1 1.1000000000000001
14.2.3 Entiers
Il sagit des nombres entiers (integer en anglais, abrg en int), positifs ou ngatifs. Leur taille a pour seule limite la mmoire virtuelle du systme (l o les nombres dautres langages sont limits, par exemple les int en C ne peuvent dpasser 32 bits). La fonction int() permet de convertir un objet en nombre entier. Si on lui transmet un nombre ottant, alors elle ne garde que la partie entire.
>>> 1 1 >>> type(1) <class int> >>> 23923 * 985 23564155 >>> 1234567899876543212345678998765432123456789 1234567899876543212345678998765432123456789 >>> int(3.5) 3
Une manire de sassurer quun nombre est bien entier est dutiliser lexpression n == int(n), qui ne sera vraie que si n est un nombre entier la base (mme crit sous forme de ottant) :
>>> a, b, c = 1, 1.0, 1.5 >>> a == int(a) >>> b == int(b) True >>> c == int(c) False
14.2.4 Complexes
Note : moins que vous ntudiez les sciences (et encore), cette section sera pour ainsi dire inutile et vous pouvez lignorer sans tats dme. Les nombres complexes (ou imaginaires) ont t invents pour rsoudre certains problmes mathmatiques. Depuis, ils sont utiliss dans de nombreux domaines (ingnierie, physique...). Un nombre complexe est de la forme a + bj 2 , o a et b sont des rels 3 4 . La forme utilisant un J est aussi accepte. On peut obtenir un nombre complexe grce la fonction complex().
2. On a j = -1. 3. a est appel partie relle et b est appel partie imaginaire. 4. Les mathmaticiens prfrent utiliser la lettre i.
14.2. Nombres
49
>>> c = 2+3j >>> c (2+3j) >>> type(c) <class complex> >>> 2.2j 2.2j >>> 1+2J (1+2j) >>> complex(3.5) (3.5+0j)
Les parties relles et imaginaires dun nombre complexe sont accessibles avec les attributs real et imag (qui renvoient des oat). Enn, le conjugu sobtient avec la mthode conjugate().
>>> c.real 2.0 >>> c.imag 3.0 >>> c.conjugate() (2-3j)
Note : Il est impossible dcrire simplement j car linterprteur le considre comme lidentiant dune variable. Le nombre purement imaginaire unit scrit donc 1j.
14.2.5 Boolens
Il sagit dune classe drive de int. Les boolens indiquent une valeur de vrit : il nexiste ainsi que deux valeurs possibles : vrai (1, qui correspond lobjet True) ou faux (0, soit False). La conversion en boolen se fait avec la fonction bool(). Nous reviendrons sur ces objets et leur utilisation dans le chapitre Structures de contrle.
14.2.6 Oprations
La plupart des oprations numriques classiques (addition, soustraction, multiplication...) existent en Python et sont accessibles par les oprateurs idoines : a + b : addition de a et b ; a - b : soustraction de b a ; a * b : multiplication de a et b ; a / b : division de a par b ; a // b : division entire de a par b ; a % b : reste de la division entire (modulo) de a par b ; a**b : mise de a la puissance b ; -a : oppos de a (revient multiplier par -1) 5 ; +a : positif de a (revient multiplier par 1). Les comparaisons sont celles usuellement dnies avec les nombres : un nombre est suprieur un autre sil est plus grand... Ces oprations sont valables avec chacun des nombres dnis prcdemment et peuvent mme tre utilises entre des nombres de types diffrents.
5. Ainsi, les nombres ngatifs ne sont pas des nombres en eux-mmes, mais plutt considr comme les opposs des nombres positifs.
50
Voici quelques exemples dutilisation :

>>> 2 + 3.5 5.5 >>> 3 * 6 18 >>> 3 - 7 -4 >>> 7 / 2 3.5 >>> 7 // 2 3 >>> 7 % 2 1 >>> (2+3j) + 0.1 (2.1+3j) >>> -+-1 1
Le dernier exemple montre bien quil sagit doprateur unaire (mme si ce genre doprations est peu intressant). Lopration modulo % est extrmement utile pour dterminer si un nombre a est multiple dun autre b : en effet, si a est un multiple de b, alors b divise exactement a et le reste est nul. Ainsi, lexpression a % b == 0 sera vraie :
>>> 9 % 3 == 0 True
car 9 est bien un multiple de 3. Python sait reconnaitre un mme nombre mme sil est admet plusieurs critures diffrentes (donc mme sil est reprsent par diffrents objets) :
>>> 1 == 1.0 True >>> 1 == (1 + 0j) True
Note : La coercition est une opration consistant convertir de manire implicite le type dun objet en un autre type lors dune opration (grce lusage implicite de la fonction built-in coerce et la mthode spciale de classe __coerce__), an dviter au programmeur de devoir le faire manuellement. Ainsi, cela permet dutiliser les oprations qui viennent dtre dnies entre des nombres de types diffrents. Il sagit dune fonctionnalit dprcie depuis Python 3, car elle contredisait lide du typage fort. Ceci ne change pas rellement les habitudes du programmeur puisque, lors de la dnition dun nouveau type, il fallait et il faudra dans tous les cas prendre en charge explicitement les conversions.
14.3 Conteneurs et squences

Les conteneurs sont des objets qui en contiennent dautres. Une sous-catgorie trs importante des conteneurs est celle des squences : dans ces dernires, les objets contenus sont ordonnes selon un certain ordre. Dans la suite de cette section, nous allons tudier quelques squences (listes, tuples et chaines de caractres), ainsi que les dictionnaires et les ensembles. Dans une squence, un objet est repr par un indice (index en anglais), qui vaut 0 pour le premier lment de la squence, et n-1 pour le dernier (n tant la longueur de celle-ci).
14.3. Conteneurs et squences
51
Warning : Il convient de faire trs attention au fait que la numrotation des index commence 0. Il sagit dune particularit en programmation, trs commune. Dans le cas dun conteneur non ordonn, laccs aux lments lorsquil est possible se fait laide dune cl (key) : il sagit dun identiant, qui peut tre nimporte quel objet non modiable (une chaine, un nombre, un tuple...). Les index et cls sont indiqus entre crochets immdiatement aprs lobjet.
sequence[key] sequence[index]
Laccs avanc aux lments, notamment avec le slicing, sera abord plus loin.
14.3.1 Listes
Une liste est dlimite par des crochets, et chaque lment est spar du prcdent par une virgule. Il sagit dun conteneur dont les diffrents lments peuvent tre modis grce une simple affectation. Lajout se fait avec la mthode append(). Finalement, la fonction list() permet de convertir un objet en liste.
>>> l = [a, b, c] >>> l [a, b, c] >>> type(l) <class list> >>> l[0] a >>> l[2] c >>> l[4] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: list index out of range >>> l[1] = e >>> l [a, e, c] >>> l.append(z) [a, e, c, z]
14.3.2 Tuples
Les tuples sont construits partir de plusieurs lments spars par des virgules ; le tout peut ventuellement tre dlimit par des parenthses. Les tuples sont trs semblables aux listes, mis part quils sont immuables : comme consquence, ils consomment moins de mmoire et ils sont privilgier si lon sait que lon ne souhaite pas modier la squence dobjets. La fonction tuple() permet de convertir en tuple.
>>> t1 = a, b, c, d >>> t1 (a, b, c, d) >>> t = (a, b, c, d) >>> t[1] b >>> t[1] = e
52
Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: tuple object does not support item assignment
Puisque les parenthses servent aussi dlimiter les expressions, un tuple constitu dun seul lment doit se dterminer par une virgule.
>>> (1) 1 >>> type((1)) <class int> >>> (1,) (1,) >>> type((1,)) <class tuple>
Warning : Cette particularit est rgulirement source derreurs, et lon oublie trop aisment la virgule nale.
14.3.3 Chaines de caractres

Une chaine de caractres (string, abrg en str), comme son nom lindique, est un ensemble de lettres, que lon utilisera pour des mots, des phrases, voire des textes entiers. Une chaine est reprsente comme une squence de caractres (chaine de longueur 1), mme sil nexiste aucune diffrence fondamentale entre ces deux concepts. La fonction de conversion est str(). Une chaine est dlimite par des apostrophes ou par des guillemets ". Note : Contrairement certains langages qui font la diffrence entre les apostrophes et les guillemets pour entourer, il ny en a aucune en Python : les deux dlimiteurs sont totalement quivalents. Il sagit dun type immuable car il est impossible de changer individuellement lun des caractres, mais il est possible daccder individuellement aux caractres par leurs indices.
>>> s = Hello >>> type(s) <class str> >>> isinstance(s, str) True >>> s[1] e >>> s[1] = a Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: str object does not support item assignment >>> "string" string
53
Warning : Il est impossible dutiliser le dlimiteur choisi dans la chaine elle-mme : il est ncessaire de lchapper laide de lantislash \.
>>> lenfant File "<stdin>", line 1 lenfant ^ SyntaxError: invalid syntax
Pour viter cette erreur, on peut soit choisir dentourer la chaine avec des guillemets, soit faire prcder lapostrophe intrieur dun antislash :
>>> "lenfant" "lenfant" >>> l\enfant "lenfant"
Warning : Rappelons que Python est un langage au typage fort : il ne considre donc pas 1 comme un nombre :
>>> 1 + 1 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: Cant convert int object to str implicitly
14.3.4 Dictionnaires
Un dictionnaire est un conteneur, dlimits par des accolades, dont les lments sont accessibles par une cl. Les paires cl-valeur scrivent cl: valeur et sont spars par des virgules. Enn, il est possible de changer la valeur associe une cl ou dajouter une nouvelle paire par une simple affectation. La fonction intgre ddie la cration de dictionnaires est dict().
>>> dic = {a: val, 3: x, key: 124} >>> type(dic) <class dict> >>> dic[a] val >>> dic[3] x >>> dic[key] = 9 >>> dic {a: val, 3: x, key: 9} >>> dic[new] = Hello >>> dic {a: val, new: Hello, 3: x, key: 9}
Remarquons que la nouvelle valeur se retrouve en deuxime position : les dictionnaires ne sont pas des ensembles ordonns, cest dire que lon ne peut prdire quel endroit sajoutera une paire. Ils ne sont pas adapts pour stocker des objets qui doivent rests classs quoiquil arrive (pour cela il convient de se tourner vers les listes ou les tuples).
54
14.3.5 Ensembles
Les ensembles (set) Python sont trs similaires aux ensembles mathmatiques : il sagit dun ensemble dobjets non ordonns et uniques. On peut les crer soit en utilisant la fonction set() (remarquons quil existe la fonction frozenset() pour crer un ensemble immuable), soit en utilisant les accolades {} et en plaant lintrieur la liste des objets :
>>> deck = {3, 4, 12, 7, 9} >>> deck {3, 4, 12, 7, 9}
Il ne faut pas confondre les dictionnaires et les ensembles, bien que la syntaxe utilise le mme dlimiteur. Voici la liste des oprateurs spciques aux ensembles (dautres oprations communes tous les conteneurs seront prsentes bientt) et de leurs effets : a & b : intersection de a et b, soit lensemble des lments communs aux deux ensembles ; a | b : union de a et b, cest dire tous les lments de chaque ensemble (en ne comptant quune fois ceux en communs) ; a - b : sous-ensemble des lments de a qui ne sont pas dans b (diffrence) ; a ^ b : sous-ensembles des lments de a et b qui ne sont communs aucun des deux ensembles. Ils ne trouvent que rarement une utilit, mais je vais ici donner un exemple, qui permettra de plus de mettre en applications les oprations. Imaginons que je souhaite collectionner les quinze cartes dun certain jeu, (numrotes de 1 15) et que je ne mintresse pas la quantit que je possde (un peu comme si on collait ces cartes dans un album). Dans ce cas les ensembles seront parfaitement adapts pour reprsenter ma collection. Finalement je peux agrandir ma collection un achetant un blister de trois cartes :
>>> cards = set(range(1, 16)) >>> deck < cards True >>> cards - deck {1, 2, 5, 6, 8, 10, 11, 13, 14, 15} >>> blister = {2, 7, 11} >>> deck | blister {2, 3, 4, 7, 9, 11, 12} >>> deck & blister {7} >>> blister - deck {2, 11}
Nous avons dabord vri que nos cartes tait bien un sous-ensemble des de la collection, puis calcul successivement : les cartes qui nous manquent, les cartes que lon a aprs avoir achet le blister, les cartes en doublons puis les nouvelles cartes apportes par le blister. Les oprations peuvent bien sr tre enchaines :
>>> {1, 3} | {5} | {4, 10, 12} {1, 3, 4, 5, 10, 12}
14.3.6 Autres conteneurs

Le module collections propose diffrents types de conteneurs qui peuvent tre utiliss lorsque lon a des besoins prcis. Par exemple, an de rpondre une question qui se pose souvent, on peut construire des dictionnaires ordonnes partir de la classe OrderedDict du module standard . Toutefois, une rexion plus ou moins pousse permet de trouver une mthode plus lgante quun dictionnaire ordonn (par exemple en choisissant une liste de tuple la place...). On y trouvera aussi un objet pour fabriquer des compteurs (Counter). Notons enn lexistence des types bytes et bytearray, qui permettent de reprsenter des chaines de caractres ASCII.
55
La fonction range() retourne un objet de ce type, qui reprsente une suite de nombres entiers.
14.3.7 Oprations
De nombreuses oprations sont dnies sur les conteneurs : x in s : retourne vrai si lobjet x se trouve dans le conteneur s, sinon faux ; x not in s : retourne vrai si lobjet x ne se trouve pas dans la conteneur s, sinon faux ; s1 + s2 (squences) : concatnation des squences s1 et s2 ; s * n, n * s (squences) : cration puis concatnation de n copies supercielles (swallow) de s (n doit tre un entier positif). Nous avons dit que les tuples taient immuables, or nous prsentons ici des oprations entre eux : en fait, cre un nouveau tuple, dans lequel il place les lments des deux tuples dorigine. Warning : Les copies ralises avec la multiplication sont supercielles, cest dire que seules les rfrences sont copies :
>>> l = [[]] >>> l *= 3 >>> l[0].append(3) >>> l [[3], [3], [3]]
De plus, il existe quelques fonctions qui peuvent tre utiles. len(s) Retourne la longueur dans le conteneur s. min(s) Retourne le plus petit lment dans le conteneur s. max(s) Retourne le plus grand lment dans le conteneur s. Note : Si s est un dictionnaire, alors toutes les oprations se font au niveau des cls. Les squences possdent les deux mthodes suivantes : s.index(i) : retourne lindice de la premire occurrence de lobjet i dans la squence s ; s.count(i) : compte le nombre doccurrences de lobjet i dans la squence s. Mettons un peu en pratique toutes ces oprations :
>>> d = {a: 1, b: 5} >>> a in d True >>> 5 in d False >>> max(d) b >>> t = (1, 3) + (5, 6, 1) >>> t (1, 3, 5, 6, 1) >>> 8 not in t True >>> len(t) 5 >>> t.count(1)
56
2 >>> 1 >>> 1 >>> [1,
t.index(3) min(t) [1, 2] * 4 2, 1, 2, 1, 2, 1, 2]
14.3.8 Slicing
Le slicing permet dextraire une sous-squence dune autre squence (dans le cas o un seul lment est slectionn, il est simplement retourn). La syntaxe gnrale est seq[i:j:k], o i, j et k sont des entiers, ventuellement ngatifs : la sous-squence sera compose de tous les lments de lindice i jusqu lindice j-1, par pas de k (ce dernier nombre peut tre omis). Si i ou j sont ngatifs, cela est quivalent lindice n-i et n-j, o n est la taille de la squence (on a crit explicitement le signe moins des variables i et j). Si k est ngatif, alors lordre des lments est invers.
>>> >>> 7 >>> 7 >>> [2, >>> [4, >>> [4, >>> [5, >>> [2, l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] l[-3] l[7] l[2:5] 3, 4] l[-6:8] 5, 6, 7] l[-6:-2] 5, 6, 7] l[5:2:-1] 4, 3] l[2:9:3] 5, 8]
14.4 Autres objets

14.4.1 Lobjet nul
Lobjet nul est None. Il correspond la valeur NULL (PHP, C...), ou encore nil (Pascal) dautres langages. Dans la plupart des cas, il signie labsence de valeur. Il est par exemple utilis comme valeur de retour par les fonctions qui ne retournent aucune valeur explicitement.
14.4.2 Type
type(), dj utilise de nombreuses fois, renvoie un objet type. Il sagit donc du constructeur dune classe.
>>> type <class type> >>> type(str) <class type>
14.4. Autres objets
57
14.5 Rsum
Dans ce chapitre, nous avons tudi de manire supercielle les principaux types du langage Python, ainsi que leurs oprations : les nombres : entiers, virgule, complexes et boolens ; les conteneurs et les squences : listes, tuples, chaines de caractres, dictionnaires ; les objets nul et type. Les fonctions isinstance() et type() permettant dtudier le type dun objet ont aussi t abordes.
14.6 Exercices
1. Essayez les diffrentes oprations sur les divers types de nombres. Observez les rsultats lorsque les types taient diffrents la base. 2. De mme, crez diverses listes et entrainez-vous les manipuler. 3. Choisir un nombre (par exemple 1) et divisez-le mille fois par 10. Multipliez-le ensuite mille fois par 10 (on pourra attendre davoir lu le chapitre sur les boucles). Expliquez le rsultat. 4. Crer un systme de permissions qui fonctionne comme suit : chaque permission est associe un nombre (e.g. 1 : peut crire un article, 2 : peut diter un article...) ; chaque groupe se voit attribu plusieurs permissions ; un utilisateur peut appartenir plusieurs groupes ; tester si un utilisateur a certaines permissions (on pourra attendre la lecture du prochain chapitre pour rpondre cette question, voire celle sur les fonctions an de simplier le code).
58
CHAPITRE 15
Structures de contrle
15.1 Construction de prdicats

Un prdicat est une expression qui possde une valeur de vrit : par exemple, La variable x est un nombre plus grand que deux est un prdicat, qui pourra tre vrai ou faux selon la valeur de la variable, mais, dans tous les cas, le rsultat sera sans ambigit. Par contre, la phrase La variable x est grande nest pas un prdicat, car il ny a pas de comparaison.
15.1.1 Valeur de vrit des objets

Tout objet en Python possde naturellement une valeur de vrit. En fait, tous les objets sont quivalents vrai, sauf les suivants : objets particuliers : False, None ; les conteneurs vides : (), [], {} (dictionnaire), , etc. ; les nombres qui sont zros : 0, 0.0, 0j, etc. An de simplier les termes, on dira simplement quun objet est vrai/faux, mme si ce nest quune quivalence. On peut vrier cette particularit avec la fonction bool() :
>>> bool([]) False >>> bool([1, 2]) True >>> 1 is True False >>> 1 == True True
15.1.2 Combinaison dexpressions

Loprateur not retourne True si lexpression qui suit est fausse, et inversement, elle retourne False si ce qui vient aprs est vrai :
>>> not True False >>> not False True
59
Finalement, les deux mots-cls and et or permettent de combiner plusieurs expressions : x and y : lexpression x est dabord value et sa valeur est retourne si elle est fausse. Sinon, y est value et sa valeur est retourne. x or y : lexpression x est dabord value et sa valeur est retourne si elle est vraie. Sinon, y est value et sa valeur est retourne. Ces relations sont rsumes dans les deux tableaux suivants (le second traduit le premier en termes de valeurs de vrit). A False True False True A False True False True B False False True True B False False True True A and B A B A B A and B False False False True A or B B B A A A or B False True True True
Il est important de noter que la valeur retourne nest pas convertie en boolen. Cette construction est utile par exemple si on veut attribuer une valeur par dfaut un objet vide :
>>> True and False False >>> s = or dfaut >>> s dfaut >>> 1 or 2 1 >>> 1 and 2 2
15.1.3 Comparaisons
Un oprateur permet de comparer deux objets, selon diffrents critres. Voici la liste de ces oprateurs, ainsi que leur signication : a is b : vrai si a est identique b ; a is not b : vrai si a nest pas identique b ; a == b : vrai si a est gal b ; a != b : vrai si a est diffrent de b ; a > b : vrai si a est plus grand que b ; a < b : vrai si a est plus petit que b ; a >= b : vrai si a est plus grand ou gal b ; a <= b : vrai si a est plus petit ou gal b. Note : En ce sens, les deux mots-cls in et not in peuvent tre vus comme des oprateurs de comparaison. Le symbole dgalit == dnote une galit supercielle, dans le sens o deux objets peuvent tre gaux mais pas identiques :
>>> 1.0 is 1 False >>> 1.0 == 1 True
60
Chapitre 15. Structures de contrle
La mme distinction existe entre is not et !=. Les oprateurs ont tous le mme ordre de priorit, qui est plus faible que celle des oprateurs arithmtiques (+, -...), et ils seront donc lus de la gauche vers la droite : il est permis dcrire a op1 b op2 c (o a, b, et c sont des expressions, op1 et op2 sont des oprateurs), qui sera interprt comme a op1 b and b op2 c :
>>> a = 3 >>> 1 < a < 10 True >>> 1 < a > 2 True
La dernire ligne peut paraitre trange, mais elle est tout fait valable : en effet, elle est interprte comme 1 < a and a > 2.
15.1.4 Conclusion
Les diffrents oprateurs de combinaison dexpressions permettent de construire des prdicats complexes partir de prdicats plus simples, comme des comparaisons ou des oprations arithmtiques. Ces prdicats jouent rellement le rle de boolen et peuvent tre utiliss partout l o un boolen est attendu.
15.2 Condition if
Une condition if (si en anglais) permet dinterprter ou non une suite dinstructions en fonction de la valeur de vrit dune expression 1 .
>>> if False: ... print(1) >>> if True: ... print(2) 2
Il est possible de construire des conditions plus volues grce aux mots-cls elif (contraction de else if : sinon si) et else (sinon). Les conditions elif sont values tour tour jusqu ce que lune soit vrie. Si aucune ne lest, alors les instructions du bloc else sont values :
>>> >>> ... ... ... ... ... ... ... ... ... "a" a = 3 if a > 4: print("a" elif a > 2: print("a" elif a > 0: print("a" elif a == 0: print("a" else: print("a" is higher than
is higher than 4) is higher than 2 and lower than or equal to 4) is higher than 0 and lower than or equal to 2) is equal to 0) is lower than 0) 2 and lower than or equal to 4
Nhsitez pas changer la valeur de a et tester nouveau.

1. En vertu de ce qui a t dit dans la conclusion de la section prcdente, le True et le False peuvent tre remplacs par nimporte quel prdicat.
15.2. Condition if
61
15.3 Boucle conditionnelle while

Une boucle conditionnelle while (tant que) excute une suite dinstructions tant quune condition vaut vraie.
>>> a = 0 >>> while a < 5: ... print(a) ... a += 1 0 1 2 3 4
Warning : Dans le cas o vous auriez indiqu un prdicat tout le temps vrai on parle de boucle innie , il est possible dinterrompre la boucle en appuyant sur Ctrl+C. Sil sagit dune interface graphique, alors il est ncessaire de demander au gestionnaire des programmes de tuer le processus en question. Toutefois, il existe des situations les boucles innies peuvent savrer utile, condition quelle puise tre interrompue quand leur rle est termin. Nous y reviendrons la n du chapitre car il nous manque encore un outil important : le mot-cl break.
15.4 Itration for

La boucle for est construite sur le modle for obj in cont (pour . . . dans . . . en anglais). Elle consiste slectionner un un les objets du conteneur cont, en les plaant successivement dans la variable obj. Ainsi, chaque itration, cette variable prend une valeur diffrente, qui est celle dun objet du conteneur.
>>> for i in [a, b, c]: ... print(i) a b c
Warning : Dans le cas particulier dune squence, les objets sont parcourus dans lordre, mais il nest pas possible de prdire lordre de parcours pour un conteneur gnral, comme un dictionnaire, car aucun ordre nest dni. Il est fortement dconseill de modier les objets sur lesquels on itre dans une boucle for, car le risque est grand que linterprteur ne fasse pas ce que lon attendait de lui, ou mme quil lve une exception RuntimeError :
>>> dic = {a: 1, b: 2} >>> for i in dic: ... del dic[i] Traceback (most recent call last): File "<stdin>", line 1, in <module> RuntimeError: dictionary changed size during iteration
Ici, linterprteur est mcontent car la taille du dictionnaire a chang au cours de la boucle, et il ne sait plus o il en est. Il est ncessaire de faire une petite digression an de prsenter linestimable fonction range(ini, fin)(), qui cre un objet reprsentant les entiers de ini fin-1 (la structure dtaille est donne dans la section Fonctions built-in) :
62
>>> range(3, 10) range(3, 10) >>> list(_) [3, 4, 5, 6, 7, 8, 9]
Combine avec la structure for ... in, elle remplace avantageusement la boucle for ( la syntaxe parfois complique) des autres langages, qui permet seulement dnumrer une liste de nombres :
>>> for i in range(5): ... print(i) 0 1 2 3 4
15.5 Autres techniques pour les boucles

Les mots-cls continue et break permettent dinuencer le droulement des boucles for et while, et un bloc else peut leurs tre ajoutes.
15.5.1 Continue
Le mot-cl continue force linterprteur revenir au dbut de la boucle et entamer litration suivante, sans excuter les instructions qui suivent ce mot-cl.
>>> for i in range(4): ... if i == 2: ... continue ... print(i) 0 1 3
Dans cet exemple, on voit que lorsque la variable i vaut 2, la condition devient vraie et linstruction print(i) est ignore.
15.5.2 Break
Le mot-cl break permet dinterrompre lexcution dune boucle, quel que soit son avancement.
>>> for i in range(20): ... if i == 4: ... break ... print(i) 0 1 2 3
Nous voyons que ds que i prend la valeur 4, linstruction break termine lexcution de la boucle mme si lafchage des nombres aurait d se poursuivre jusqu 19.
15.5. Autres techniques pour les boucles
63
15.5.3 Else
Il est possible dajouter une clause else nale une boucle. Le bloc dinstructions ne sera excut que si la boucle sest termin normalement, cest dire quaucune instruction break na t rencontre 2 . Voici un premier cas o la boucle se termine et o la clause else est excute :
>>> for i in range(6): ... print(i) ... else: ... print("end") 0 1 2 3 4 5 end
Maintenant, regardons un exemple o la boucle est arrte :

>>> for i in range(6): ... if i == 4: ... break ... print(i) ... else: ... print("end") 0 1 2 3
15.6 Instruction pass

pass ne fait strictement rien. Il est utilis lorsque linterprteur attend un bloc de code mais que lon ne souhaite rien crire pour un temps, ou ne rien faire. Nous verrons son utilisation pratique dans le cadre des Erreurs et exceptions, des Fonctions et des Classes.
15.7 Imbrications
Rien nempche dimbriquer plusieurs structures de contrle (ou blocs) dans les autres, tant que lindentation est respecte. Le code suivant afche la liste des nombres pairs ou impairs compris entre 0 et 10 (exclus) selon que la variable n soit pair ou impair :
>>> n = >>> for ... ... ... ... 2 4 12 i in range(1, 10): if (n % 2) == 0 and (i % 2) == 0: print(i) elif (n % 2) != 0 and (i % 2) != 0: print(i)
2. Elles permettent donc, entre autres, de faire ce que font les boucles foreach de langages tel que le PHP.
64
6 8
Les parenthses autour des oprations de modulo auraient pu tre omises, comme loprateur de modulo valu avant loprateur dgalit. Loprateur and est valu en dernier. En principe on vitera dimbriquer plus de trois ou quatre an de garder une certaine lisibilit du code, dautant plus que, dans ces cas-l, il existe des manires plus lgantes de disposer le code. Avant de conclure ce chapitre, donnons un exemple typique de boucle inni : lafchage dun menu dans un programme en ligne de commande, qui propose diffrentes actions lutilisateur. Ce dernier choisit une action effectuer en appuyant sur une touche, et, une fois laction termine, il est ramener au menu. Et ainsi de suite jusqu ce quil appuie sur une touche permettant de quitter le programme (nous omettons les indications du prompt) :
while True: print(Menu) print(Action A : touche A) print(...) print(Action F : touche F) print(Quitter : touche Q) choice = input(Quel est votre choix ? ) print() if choice == A: print("Excuter laction A") if choice == F: print("Excuter laction F") if choice == Q: print("Fin du programme") break print()
Notez la prsence des guillemets au lieu de lapostrophe, ce qui permet dcrire laction sans devoir chapper lapostrophe aprs le l. La prsence des print() sans argument permet de sauter une ligne.
15.8 Exceptions
Les exceptions sont une sorte de structures de contrle, mais un chapitre entier leur est rserv du fait de leur spcicit. Ainsi, pour plus de dtails, se reporter au chapitre Erreurs et exceptions.
15.9 Rsum
Dans ce chapitre nous avons vu comment crer des prdicats et nous en servir pour construire des blocs conditionnels et des boucles, que lon a ensuite imbriqus.
15.10 Exercices
1. crire une boucle qui calcule la somme des dix premiers carrs (cest dire 1 + 2 + . . . + 9). 2. Afchez lcran les quinze premiers multiples dun nombre que vous choisirez. 3. crire une boucle qui afche tous les nombres divisibles par 3 et par 5 dans un intervalle que vous choisirez. 4. Calculer la longueur dune chaine de caractres (sans utiliser la fonction len()). 15.8. Exceptions 65
5. crire une boucle qui permet de compter le nombre de voyelles dans une chaine de caractres. 6. Crer un programme qui doit faire deviner au joueur un nombre entre 1 et 100 tir alatoirement (on pensera utiliser le module random). Aprs chaque entre, on indiquera au joueur si le nombre est plus grand ou petit. On pourra envisager dajouter un compteur de tentatives. 7. crire un algorithme semblable au prcdent, en inversant les rles : le joueur choisit un nombre entier dans un certain intervalle, et lordinateur doit deviner ce dernier. 8. Amliorer le programme prcdent pour faire deviner un nombre virgule. Lordinateur pourra-t-il deviner prcisment le nombre ? Penser adapter lalgorithme.
66
CHAPITRE 16
Fonctions
16.1 Gnralits
16.1.1 Dnition
Une fonction se dnit laide du mot-cl def suivi dun identiant puis de parenthses. Ces dernires contiennent la dnition des diffrents arguments que la fonction peut recevoir : rappelons quun argument permet de modier le comportement dune fonction en lui fournissant des donnes supplmentaires, qui permettent ainsi un comportement diffrent en fonction du contexte. Enn, la ligne contenant linstruction def se termine par deux points et est suivie dun bloc dinstructions(indentes). On aura donc la forme suivante :
def name(args): instructions
Une fonction peut retourner une valeur grce au mot-cl return (dans certains langages, on appelle procdure une fonction ne retournant rien, mais la distinction nest pas importante ici). Il faut noter que le mot-cl return interrompt lexcution de la fonction, cest dire que toute instruction situe aprs sera ignore (sauf dans un cas que nous verrons dans le chapitre Erreurs et exceptions). Note : En ralit, une fonction retournera toujours une valeur, qui sera None si aucun return nest prsent. Voici quelques exemples de dnitions de fonctions :
>>> def func(): ... return 1 >>> func() 1 >>> def square(n): ... m = n**2 ... return m >>> square(3) 9
67
>>> def nothing(): ... pass >>> print(nothing()) None
La premire fonction nest pas trs utile puisquelle est quivalente entrer directement 1. Il aurait t possible de simplier la deuxime fonction en crivant directement return n**2.
16.1.2 Valeurs de retour

Il est possible de retourner nimporte quel type dobjet grce return.
>>> def return_obj(obj): ... return obj >>> type(return_obj(1)) <class int> >>> type(return_obj(string)) <class str> >>> type(return_obj([1, 2, 3])) <class list> >>> return_obj([1, 2, 3]) [1, 2, 3]
Sil nest pas possible dutiliser plusieurs return pour retourner plusieurs valeurs, il est possible de retourner plusieurs objets par un mme return, soit explicitement avec un objet de notre choix (tuple, liste, dictionnaire), soit implicitement (ce sera alors un tuple).
>>> def tds(n): ... return n*3, n/2, n**2 >>> tds(4) (12, 2, 16)
16.1.3 Docstrings
Il convient dassocier chaque fonction une docstring, cest dire une chaine de documentation. Celle-ci permet de donner diverses informations sur la fonction. Les docstrings peuvent tre utilises par certains gnrateurs de documentation pour crer automatiquement la documentation dun programme. Une docstring doit respecter quelques conventions : la premire ligne consiste en une courte description de la fonction (moins dune ligne), et elle doit dbuter par une majuscule et nir par un point ; la deuxime ligne doit tre vide ; les lignes suivantes dcrivent dune manire plus complte la fonction (comment lappeler, les objets retourns, etc), ventuellement en utilisant des marquages pour les gnrateurs de documentations. Seule la premire ligne nest pas optionnelle. Il est possible daccder au docstring dune fonction grce lattribut __doc__.
def func(): Do nothing. This function does not make anything. pass
Lon peut alors afcher la documentation avec print(func.__doc__). 68 Chapitre 16. Fonctions
16.1.4 Remarques
Rappelons que les variables dans une fonction sont locales (et donc supprimes par le ramasse-miettes de Python ds que linterprteur sort de la fonction).
>>> def func(): ... a = 1 >>> func() >>> a Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name a is not defined
Une fonction est un objet appellable. Il est donc ncessaire dutiliser des parenthses mme si elle ne prend aucun argument. Dans le cas contraire, lon aurait simplement accs lobjet fonction lui-mme, et le code lintrieur ne serait pas excut.
>>> def re1(): ... return 1 >>> re1 <function re1 at ...> >>> re1() 1
Enn, il est fortement dconseill dafcher du texte (via print() par exemple) directement dans le corps dune fonction (du moins, pour une autre raison que du dbuggage), car cela peut conduire des effets indsirables.
16.2 Arguments
16.2.1 Gnral
Il est possible de crer une fonction avec autant dargument que lon souhaite. Dans lexemple qui suit, nous utilisons trois arguments, mais lon aurait trs bien pu en utiliser deux comme cinq ou vingt.
>>> def add(a, b, c): ... return a + b + c >>> add(1, 2, 3) 6 >>> add(2, -4, 7) 5
Il est toutefois important de signaler que, lorsque lon appelle la fonction, les arguments doivent tre dans le mme ordre quils le sont dans la dnition.
>>> def test(string, integer): ... print(The string is + string + and the integer is + str(integer)) >>> test(abc, 1) The string is abc and the integer is 1 >>> test(1, abc) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 1, in test TypeError: Cant convert int object to str implicitly
Ici, une exception est leve car, en thorie, il faut fournir en premier une chaine puis un nombre. Or lon fait linverse, ce pour quoi le programme na pas t prvu la base.
16.2. Arguments
69
16.2.2 Arguments par dfaut

Dans la dnition de la fonction, il est possible de donner une valeur par dfaut certains arguments, de sorte que lon ait pas fournir tous les arguments lorsque lon appelle la fonction. La valeur par dfaut ne sera utilise que si aucune valeur nest fournie pour largument en question. Une valeur par dfaut se dnit par argument=valeur. Warning : Il est ncessaire de placer les arguments ayant une valeur par dfaut en dernier, sans quoi une exception SyntaxError sera leve.
>>> def add(n, m=1): ... return n + m >>> add(2, 5) 7 >>> add(2) 3
Lon peut utiliser une variable pour indiquer la valeur par dfaut dun argument. Toutefois la valeur de la variable utilise est celle quelle avait au moment de la dnition de la fonction.
>>> >>> ... >>> >>> 5 i = 5 def f(arg=i): return arg i = 6 f()
Warning : Il est fortement dconseill dutiliser un objet mutable comme valeur par dfaut, car, comme nous lavons vu au-dessus, la valeur par dfaut nest value quune seule fois.
>>> ... ... >>> ... [0] [0, [0, def f(a, L=[]): L.append(a) return L for i in range(3): print(f(i)) 1] 1, 2]
Note : Il est fortement conseill de toujours mettre une valeur par dfaut tous les arguments dune fonction, a fortiori lorsquils ne sont pas forcment ncessaires.
16.2.3 Arguments nomms

Lors de lappel dune fonction il est possible dattribuer explicitement la valeur dun argument. Cela se fait en crivant argument=valeur. Il faut aussi faire attention ne pas fournir deux (ou plus) valeurs pour un mme argument.
>>> def test(string, integer=2): ... print(string is + string + and integer is + str(integer)) >>> test(abc, 1) string is abc and integer is 1 >>> test(abc, integer=1)
70
Chapitre 16. Fonctions
string is abc and integer is 1 >>> test(string=abc, integer=1) string is abc and integer is 1 >>> test(integer=1, string=abc) string is abc and integer is 1 >>> test(string=abc) string is abc and integer is 2
Toutefois, au mme titre que lattribution dune valeur par dfaut, il est ncessaire de placer les arguments nomms la n.
16.2.4 Capture darguments non dnis

Il existe deux sortes darguments spciaux qui permettent de capturer les arguments fournis par lutilisateur mais qui ne sont pas dnis dans la fonction : **kwargs, qui sera un dictionnaire des arguments nomms (o largument sera la cl) ; *args, qui sera un tuple des autres arguments. Cela permet donc dobtenir une liste darguments de taille variable, et non dnie lavance, ce qui peut tre un gage de souplesse. *args doit absolument tre plac avant **kwargs.
>>> def func(n, *num, **kwargs): ... return(n, num, kwargs) >>> func(1, 2, 3, 4, a=5, b=6) (1, (2, 3, 4), {a: 5, b: 6})
Il est bien sr possible de manipuler les variables dans le corps de la fonction comme un tuple et un dictionnaire normaux (puisque cest ce quils sont). Toutefois il faut prendre garde ne pas utiliser les astriques en dehors de la dnition. Note : Les noms kwargs et args sont utiliss par conventions, mais ils peuvent tre nomms nimporte comment. Ce qui compte est le nombre dastrisques devant le nom. Il est aussi possible dutiliser **kwargs et *args pour transmettre des arguments une fonction. Le terme en anglais pour cette opration est unpack (dpaquetter).
>>> def add(a, b, c): ... return a + b + c >>> t = (1, 2, 3) >>> add(*t) 6
Sans lastrisque, nous aurions eu une exception TypeError. Il est possible de faire de mme pour transmettre des paramtres nomms.
16.3 Fonctions rcursives

Une fonction rcursive est une fonction qui sappelle elle-mme. Dnissons par exemple une fonction calculant la factorielle dun nombre.
>>> def fact(n): ... if n == 0: ... return 1 ... else:
16.3. Fonctions rcursives
71
... return n * fact(n-1) >>> fact(4) 24
La rcursivit sera aborde en dtails plus loin.
16.4 Fonctions anonymes

Il sagit dune fonctionnalit hrite de langages de programmation fonctionnelle. Le mot-cl lambda permet de crer une fonction anonyme, cest dire une fonction employe directement l o lon en a besoin, au lieu de la dnir auparavant. Une expression lambda peut donc tre utilise nimporte o un objet fonction devrait tre requis en temps normal.
>>> 4 >>> >>> 4 >>> ... >>> >>> 8 >>> 8 (lambda a: a**2)(2) f = lambda a: a**2 f(2) def power(n): return lambda m: m**n f = power(3) f(2) power(3)(2)
Il est bien entendu possible de dnir une expression lambda utilisant plusieurs arguments.
>>> f = lambda a, b: a + b >>> f(1, 2) 3
Remarquons quune seule expression ne peut tre dnie dans une fonction lambda, et que le return est implicite (le rajouter lve une exception SyntaxError). Note : Les fonctions lambda peuvent compliquer la lecture du code, et il est conseill pour cette raison de ne pas en utiliser trop. De mme, ds quune mme fonction lambda est utilise plusieurs endroits, il faut songer srieusement dnir une fonction normale.
16.5 Generators
Un gnrateur est une fonction qui, au lieu de retourner des objets via return, utilise yield. Dune certaine manire, lon peut voir le processus ainsi : on appelle la fonction, qui retourne un objet gnrateur ; le premier appelle de next() lance lexcution de la fonction ; au premier yield rencontr, lexcution sarrte et un objet est retourn ; on appelle nouveau next(), et la fonction reprend son excution l o elle avait t stoppe par yield ; lexcution sarrte nouveau ds quun yield est rencontr ; et ainsi de suite. Pour commencer, prenons un exemple de gnrateur simple :
72
>>> def gen(): ... yield 1 ... yield 2 ... yield 3 >>> g = gen() >>> g <generator object gen at ...> >>> next(g) 1 >>> next(g) 2 >>> next(g) 3 >>> next(g) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
Lon observe quune exception StopIteration est leve ds que le gnrateur est puis. Ceci permet de contrler ce qui se passe ds quil ne peut plus retourner dobjet. Les gnrateurs peuvent se comporter comme des itrateurs, cest dire quune boucle for permet ditrer sur les objets quil contient. ce moment-l, la boucle for appelle implicitement la fonction next() chaque itration, et elle se termine ds que lexception StopIteration est leve. Comme exemple nous allons dnir la suite de Fibonacci.
>>> ... ... ... ... >>> 1 1 2 3 5 >>> >>> 1 >>> 12 def fibo(n): a, b = 0, 1 while b < n: yield b a, b = b, a + b for i in fibo(6): print(i)
g = fibo(3) next(g) sum(fibo(6))
Le calcul de la somme sexplique du fait que la fonction sum() accepte un itrateur.
16.6 Fonctions built-in

Quelques fonctions nappartenant aucun module sont dnies sans quil ne soit ncessaire des les importer (se rfrer au chapitre Modules pour plus dinformations). On les appelle fonctions built-in (que lon pourrait traduire par intgre, mais le terme anglais restera utilis). Elles son gnralement souvent utilises, do leur disponibilit immdiate. Ici sera dresse une liste des fonctions les plus importantes, la dcouverte des autres tant laisse en exercice. dir([object ]) Retourne une liste des toutes les mthodes et attributs de object sil est fourni, sinon retourne une liste de
16.6. Fonctions built-in
73
tous les objects du contexte courant. Cette fonction est essentiellement utilise dans linterprteur interactif pour tester les objets. eval(expression) Cette fonction analyse et excute expression (qui doit tre une chaine).
>>> x = 1 >>> eval(x + 2) 3
globals() Retourne un dictionnaire reprsentant les variables prsente dans le contexte global. hasttr(object, attribut) Retourne True si lobjet possde lattribut en question. help([object ]) Afche laide au sujet dun objet si object est fourni, sinon afche laide gnrale. Cette fonction est destine tre utilise dans linterprteur interactif. input([prompt ]) Si le paramtre prompt est fourni, alors il sera afch sur la sortie standard. Dans tous les cas, la fonction lit une ligne crite (dont saisie est interrompue par la touche entre) et la retourne sous forme de chaine.
>>> name = input(Enter your name: ) Enter your name: Harold >>> print(name) Harold
isinstance(object, class) Retourne True si object est une instance de class. class peut aussi tre un tuple contenant plusieurs classes, et la fonction retournera True si object est une instance de lun dentre eux. Il sagit de LA manire la plus correcte de vrier le type dun objet.
>>> if isinstance(1, int): ... print(1 is an instance of int.) 1 is an instance of int. >>> if isinstance(1, (int, str)): ... print(1 is an instance of int or str.) 1 is an instance of int or str. >>> if isinstance("1", (int, str)): ... print("1" is an instance of int or str.) "1" is an instance of int or str.
len(seq) Retourne la longueur de la squence seq. locals() Fait de mme que globals(), mais avec le contexte local. print([obj1, ..., objn][, sep= ][, end=n]) Afche obj1 jusque objn, spars par sep, en ajoutant end la n. sep et end doivent tre des chaines. range([start=0 ], stop[, step=1 ]) Retourne un objet range, qui est un objet itrable quivalent une liste dentiers, commenant start et nissant end - 1, et spars par le pas sep.
>>> list(range(3)) [0, 1, 2] >>> list(range(2, 5))
74
[2, >>> [1, >>> [0,
3, 4] list(range(1, 9, 2)) 3, 5, 7] list(range(0, -3, -1)) -1, -2]
repr(obj) Afche la reprsentation (dnie par la mthode __repr__() de obj. reversed(seq) Retourne linverse de la squence passe en argument. Ceci est quivalent seq.reverse(), excepte que cette fonction retourne un nouvel objet, et peut donc tre utilise dans une boucle for.
>>> for i in reversed(range(3)): ... print(i) 2 1 0
round(x[, n=0 ]) Arrondit x n dcimales. sorted(seq) Retourne une squence trie partir de seq. Cette fonction est quivalent appeler la mthode seq.sort(), except le fait quelle retourne un nouvel objet (comme reversed()). sum(iterable) Permet de sommer un itrable contenant uniquement des nombres (de nimporte quels types, qui peuvent tre mlangs). Quelques exemples dutilisations :
>>> sum([1+4j, 3.3, -2]) (2.3+4j)
16.7 Exercices
1. crire une fonction qui permet de convertir des francs en euros. Pour rappel : 1C = 6.55957F. 2. crire une fonction qui calcule le primtre dun cercle de rayon R (qui sera donc largument). Pour rappel : le primtre est P = 2R. On pourra prendre = 3.14 ou, mieux, chercher un module qui contient ce nombre et lutiliser. 3. crire une fonction qui prend en argument un nombre n et qui calcule n ! (n factorielle), sans utiliser la rcursivit. Rappel : n ! correspond la multiplication des n premiers entiers avec la convention que 0 ! = 1. Ainsi, par exemple, 4 ! = 1234 = 24. 4. crire une fonction qui prend deux arguments, lun deux tant une fonction. La premire fonction doit appliquer la fonction passe en argument au second argument, et renvoyer le rsultat. 5. crire une fonction qui prend une date de naissance en argument et qui retourne le nombre de jours couls depuis. On pensera aux annes bissextiles ; une anne est bissextile si : elle est divible par 4 mais par par 100 ; elle est divisible par 400. On pourra utiliser le module datetime pour obtenir la date du jour courant automatiquement. 16.7. Exercices 75
6. crire une fonction similaire range(), mais qui accepte des ottants en argument.
76
CHAPITRE 17
Classes
17.1 Introduction
17.1.1 Dnition
Un objet est construit partir dune classe. On dit que lon cre une instance dune classe. Les classes peuvent tre vues comme une description de lobjet, qui rassemble ses proprits (les attributs) et comment agir sur ces dernires (les mthodes). Une classe est dclare laide du mot-cl class, suivi dun nom puis de deux points. Suit ensuite un bloc dinstructions. De mme que pour les fonctions, il est possible de dnir une docstring.
class Name: Docstring. instructions
Note : Par convention, les noms des classes sont en CamelCase. Une classe est un objet callable : ainsi, pour crer un objet partir dune classe, il faut crire son nom suivi de parenthses.
>>> class Vector: ... pass >>> v = Vector() >>> v <__main__.Vector object at ...>
Note : Il est possible de mettre des parenthses aprs le nom de la classe, mais ceci est tout fait optionnel : class Name(): est tout aussi correct que class Name:.
17.1.2 Attributs
Il est possible daccder aux attributs dun objet grce au point. Il est aussi possible de dnir un attribut par simple assignation.
77
>>> ... ... >>> >>> (3, >>> >>> 6 >>> 9 >>> >>> >>> 7
class Vector: x = 3 y = 4 v = Vector() v.x, v.y 4) v.z = 6 v.z v.z + 3 del v.z v.x = v.x + 4 v.x
Note : Bien quil soit possible de crer ou modier directement un attribut en Python, il est plutt dconseill de le faire : mieux vaut passer par des mthodes ddies cet effet. Il est possible daccder rcursivement aux attributs dun objet en utilisant plusieurs points.
>>> class CVector: ... pass >>> cv = CVector >>> cv.affix = 1+3j >>> cv.affix (1+3j) >>> cv.affix.imag 3.0
Les attributs dune classe sont encapsuls dans celle-ci et ne sont donc pas visible depuis lextrieur.
>>> v.x 7 >>> x Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name x is not defined
17.1.3 Mthodes
Une mthode consiste simplement en une fonction dnie lintrieur de la classe et dont le premier paramtre est toujours une rfrence linstance (par convention, lon utilise self soi-mme en anglais). Ainsi self dsigne, dans le corps de la mthode, linstance qui contient la mthode.
>>> class Vector: ... x = 3 ... y = 4 ... def norm(self): ... return (self.x**2 + self.y**2)**(1/2) ... def homothety(self, n): ... self.x = self.x * n ... self.y = self.y * n >>> v = Vector() >>> v.norm()
78
Chapitre 17. Classes
5.0 >>> v.homothety(3) >>> v.x, v.y (9, 12)
17.1.4 Constructeur
Le constructeur est une mthode spciale (il en existe dautres, que nous verrons par la suite), appele __init__(), qui est appele lors de linstanciation de lobjet : cela permet deffectuer diverses oprations sur chaque nouvel objet leur cration. Par exemple, si lon reprend le cas prcdent, il nest pas trs intressant davoir un vecteur dont les attributs x et y sont dj dnis. Nous pouvons y remdier ainsi :
>>> class Vector: ... def __init__(self, x=0, y=0): ... self.x = x ... self.y = y ... def norm(self): ... return (self.x**2 + self.y**2)**(1/2) >>> v1 = Vector(3, 4) >>> v1.x, v1.y (3, 4) >>> v2 = Vector(-2, 7) >>> v2.x, v2.y (-2, 7)
17.1.5 lments publics et privs

Contrairement dautres langages, les concepts de membres privs ou protgs nexistent pas rellement en Python : certaines conventions indiquent quun lment est priv, mais lutilisateur peut toujours choisir dy accder. Ainsi, Python part du principe que lutilisateur naccdera pas nimporte comment aux lments. Un membre protg commence par un simple underscore, tandis quun membre priv commence par deux underscores.
17.2 Mthodes spciques

17.2.1 Destructeur
La mthode destructeur, nomme __del__() est appele lorsque lon dtruit lobjet avec del.
17.2.2 Oprateurs
Il est possible de surcharger les oprateurs pour une classe, ce qui permet de dnir le comportement des objets lorsquon les manipule avec des oprateurs. Lles mthodes associes aux oprateurs sont : __add__() pour laddition, __sub__() pour la soustraction, __mul__() pour la multiplication, __truediv__() pour la division, __floordiv__() pour la division entire, __mod__() pour le modulo, __pow__() pour la puissance.
>>> class Vector: ... def __init__(self, x, y): ... self.x, self.y = x, y ... def __add__(self, other): ... if isinstance(other, Vector):
17.2. Mthodes spciques
79
... return Vector(self.x + other.x, self.y + other.y) >>> v1 = Vector(2, 3) >>> v2 = Vector(-4, 7) >>> v3 = v1 + v2 >>> v3.x, v3.y (-2, 10)
17.3 Hritage
17.3.1 Introduction
Il est ais de driver une classe : pour ce faire, il suft dindiquer la ou les classes parentes (spares par des virgules) entre parenthses aprs le nom de la classe enfant.
class Name(ParentName1, ..., ParentNamen): instructions
Il est alors possible daccder chaque attribut des classes parentes.

>>> class Fruit: ... def __init__(self, color): ... self.color = color >>> class Appel(Fruit): ... pass >>> a = Appel(red) >>> a.color red
Il est possible de driver une classe qui est dj drive dune autre classe, et ce autant de fois que lon souhaite.
17.3.2 Polymorphisme
17.4 Exercices
1. crire une classe qui permettra de grer un chier (dont le nom sera pass au constructeur). Elle devra comporter plusieurs mthodes qui raliseront des oprations sur le chier : count : renvoie le nombre de lignes, de mots et de lettres. head(n) : renvoie les n premires lignes. tail(n) : renvoie les n dernires lignes. nd(str) : afcher toutes les lignes contenant la chaine str. replace(str1, str2) : afcher lcran toutes les lignes du chier, en remplaant chaque occurrence de str1 par str2. tout ce qui pourra vous passer par la tte (mais qui ne modie pas le chier lui-mme). Il faudra veiller ne pas charger en mmoire tout le contenu du chier, ni le conserver ouvert trop longtemps. 2. Proposer une amlioration du systme de droits (exercice 4 du chapitre Types de base) en utilisant les classes.
80
Chapitre 17. Classes
CHAPITRE 18
Erreurs et exceptions
18.1 Introduction
Les erreurs et exceptions ont t mentionnes de nombreuses fois dans ces pages, mais nous nous sommes toujours contenter de dire ce qui les dclenchait (et donc comment les viter). Mme si parfois, les exceptions indiquent un rel problme, elles ne devraient pas forcment interrompre lexcution du programme. Lon peut distinguer deux types derreurs : les erreurs de syntaxe, qui indiquent une mauvaise syntaxe dans lcriture du programme ; les exceptions, qui surviennent lorsquun comportement non prvu lorigine survient. Dans tous les cas, une pile, appele Traceback, est afche. Elle permet de retracer les diffrentes tapes qui ont conduit lerreur, ainsi que des informations utiles pour la rparer (le type derreur, le cher, la ligne. . . ).
18.2 Lever une exception

Une exception est leve grce au mot-cl raise : il suft dindiquer le nom de lexception leve, suivie ventuellement darguments :
raise ExceptionName(args)
Voici un exemple simple :

>>> raise ValueError(Just a test.) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: Just a test.
Si vous souhaitez dterminer si une erreur a t leve, mais sans la prendre en charge, il est possible de lever la mme erreur dans le bloc except laide de raise.
>>> try: ... raise Exception(An exception) ... except Exception: ... print(Here the exception is catched.) ... raise Here the exception is catched. Traceback (most recent call last):
81
File "<stdin>", line 1, in <module> Exception: An exception
18.3 Grer les exceptions

18.3.1 Gnralits
Les exceptions se grent grce au couple try-except. Un bloc try doit tre accompagn dau moins un bloc except (il ny a aucune limite maximale). Il existe trois manires dcrire la ligne except : en indiquant le nom de lerreur concerne : except Error: ; en indiquant un tuple contenant plusieurs erreurs : except (Error1, ..., Errorn): ; en nindiquant rien : except:. Ainsi, un ensemble try-except scrira de la forme :
try: instructions except Error1: instructions si Error1 except Error2: instructions si Error2 except (Error3, Error4): instructions si Error3 ou Error4 except: instructions si autre erreur
Prenons un exemple concret :

>>> try: ... num1 = int(input(Enter a number: )) ... num2 = int(input(Enter another number: )) ... except ValueError: ... print(You must enter only numbers.)
Imaginons que nous souhaitions demander deux nombres lutilisateur, pour ensuite effectuer diverses oprations (par exemple). Comme la fonction input() retourne une chaine, nous devons la convertir en entier. Toutefois, si lutilisateur na pas suivi la consigne, et quil entre une chaine, alors linterprteur ne parviendra pas la convertir en nombre et lvera une exception ValueError. Si jamais une exception qui ntait pas attendue tait leve, alors le Traceback normal serait afch (ce qui nest pas le cas ici). Notons aussi que le try prend en charge toute erreur (du mme type que celui spci) qui pourrait survenir dans une fonctions appeles dans le bloc try (et ce rcursivement).
>>> ... >>> ... ... ... Int def zerodiv(): 1/0 try: zerodiv() except ZeroDivisionError: print(Int division by zero.) division by zero.
Note : Il est tout fait possible de ne prciser aucune erreur aprs except, comme on la vu, mais il sagit dune pratique fortement dconseill : lon perd en souplesse, puisque lon ne peut grer chaque erreur au cas par cas ; 82 Chapitre 18. Erreurs et exceptions
cela masque toutes les erreurs qui surviennent, mme celles que lon imaginait pas, ce qui a pour consquence de complexier largement le dbuggage.
18.3.2 Blocs volus

Au mme titre que pour les boucles, il est possible dadjoindre un bloc else aux blocs de gestion dexceptions : ce dernier ne sera excut que si aucune exception na t leve. Il est aussi possible dajouter un bloc finally : les instructions de ce dernier bloc seront excutes quoiquil arrive. Ce dernier peut tre utilis pour les actions de nettoyage (fermeture dun chier ouvert dans try, fermeture dune base de donnes. . . ). Note : with peut parfois remplacer avantageusement finally. Voici un exemple gnral (testez-le en entrant une chaine puis un nombre) :
>>> ... ... ... ... ... ... ... try: num = int(input(Enter a number: )) except ValueError: print(You must enter a number.) else: print(You have enter a number.) finally: print(This text is always printed.)
Note : Il est important de noter que le bloc finally sera toujours excut, mme si un return, break ou continue intervient avant (dans le code).
>>> def func(): ... try: ... return 1 ... except: ... pass ... finally: ... print(2) >>> func() 2 1
18.3.3 Variable de lerreur

Il est aussi possible de stocker lerreur dans une variable, an de la manipuler et dobtenir des informations plus prcises : la variable spcie dans la ligne except est alors associe lexception qui a t leve. Il est alors possible daccder aux attributs et aux arguments de lexception concerne.
>>> try: ... raise Exception(First argument, Another argument) ... except Exception as error: ... print(type(error)) ... print(error.args) <class Exception> (First argument, Another argument)
18.3. Grer les exceptions
83
18.4 Dnition dexceptions

Les exceptions, comme tout lment en Python, est un objet. Il est donc trs simple de dnir des exceptions personnalises : il suft de driver une classe dexception pr-existante.
>>> class MyError(Exception): ... pass >>> raise MyError Traceback (most recent call last): File "<stdin>", line 1, in <module> __main__.MyError
Note : Il aurait bien entendu t possible de rednir la mthode __init__(), ou encore dajouter dautres mthodes et attributs. Toutefois, les classes dexception sont souvent simplies autant que possible.
18.5 Exceptions built-in

Au mme titre que pour les fonctions, Python contient tout un set dexceptions built-in. Voici donc une liste des exceptions les plus courrantes :
84
Chapitre 18. Erreurs et exceptions
CHAPITRE 19
Entres et sorties
19.1 Afchage de donnes (print())

La fonction print() permet dafcher du texte. Lutilisation la plus simple que lon puisse en faire est de passer en argument 1 la variable afcher : print(variable).
>>> print(a variable) a variable >>> print(10) 10 >>> var = hello >>> print(var) hello
Il est possible de donner plusieurs arguments la suite :

>>> print(1, str, 1+2j) 1 str (1+2j)
On peut modier le symbole qui les spare en renseignant largument sep (par dfaut il sagit dun espace) :
>>> print(1, str, 1+2j, sep=_) 1_str_(1+2j)
Enn, il est aussi possible de choisir le symbole en n de ligne (par dfaut cest un n de ligne) :
>>> print(first print, end= ); print(second print) first print second print
Pour afcher une nouvelle ligne, il suft dappeler la fonction sans argument :
>>> print() >>>
Enn, on peut spcier le chier o est crit largument laide de largument file.
1. Lutilisation et le vocabulaire des fonctions seront dtaills dans le chapitre Fonctions.
85
19.2 Entre au clavier (input())

La fonction input() permet de lire une ligne crite et de la stocker dans une variable. La saisie de la ligne est interrompue avec la touche entre. Elle accepte un argument optionnel qui permet dafcher une chaine de caractres (par exemple, pour donner des informations) :
>>> input() Two words Two words >>> input() 1 1 >>> prompt = input() Text >>> prompt Text >>> name = input(Enter your name: ) Enter your name: Harold >>> name Harold
Warning : Le type de la variable cre sera toujours une chaine de caractres. Il faudra donc prendre garde effectuer les tests et conversions ncessaires avant son utilisation.
19.3 Fichiers
19.3.1 Ouverture et fermeture
On ouvre un chier laide de la fonction open() : open(le, mode) Les deux arguments doivent tre des chaines de caractres. Le mode peut tre : r : lecture seule ; w : criture ; a : ajout. Le chier est cr sil nexiste pas avec les options w et a. Avec ces modes, il nest pas possible de lire ce qui est dans le chier. La mthode close() permet de fermer un chier.
19.3.2 Mthodes de chier

read() Lit tout le contenu du chier et le renvoie sous forme dune chaine de caractres. readline() Lit la ligne suivant le curseur dans le chier et la renvoie sous forme dune chaine de caractres. readlines() Lit tout le contenu du chier et retourne les lignes sous forme dune liste de chaines de caractres,.
86
Chapitre 19. Entres et sorties
write(string) crit la chaine string dans le chier. writelines(sequence) crit la squence sequence dans le chier, en mettant bout bout les lments. Rien ne sera crit dans le chier avant lappel de la mthode close().
19.3.3 Exemple
>>> >>> >>> ... >>> names = [Yves, Jean, Dupont] file = open(names.txt, w) for name in names: output = file.write(name + \n) file.close()
En ouvrant le chier names.txt, vous pourrez voir un nom sur chaque ligne. On aurait pu utiliser la mthode writelines() plutt que de passer par une boucle.
>>> file = open(names.txt, r) >>> for line in file.readlines(): ... print(line) Yves Jean Dupont
Warning : Il peut tre ncessaire de supprimer les signes de nouvelles \n avant dafcher les chaines de caractres. De mme, il peut tre ncessaire de les ajouter si lon dsire crire plusieurs chaines sur des lignes diffrentes. Une utilisation plus gnrale des chiers et des dossiers sera aborde dans le chapitre Gestion des chiers et dossiers.
19.4 Exercices
1. crivez un programme qui demande son nom lutilisateur, et qui lafche ensuite lcran avec un message daccueil. 2. crire un programme qui demande deux nombres lutilisateur, et qui afche ensuite la somme, la diffrence et la multiplication de ces deux nombres. 3. Amliorez le programme prcdent en ajoutant la division. Faites attention prendre en compte le cas o le deuxime nombre est nul. 4. crire un programme qui rcupre une liste de noms dans un chier (un nom par ligne) et qui les trie par ordre alphabtique.
19.4. Exercices
87
88
Chapitre 19. Entres et sorties
CHAPITRE 20
Modules
20.1 Introduction
Lutilisation interactive de Python nest pas trs pratique, car elle ne permet pas de sauvegarder les variables et autres rsultats. Pour y remdier, lon crit le code dans des chiers 1 , appels modules (ou scripts), qui permettent de rutiliser le code. De mme, il est fortement conseill de diviser un long programme en de nombreux modules pour plus de clart. Un module peut contenir aussi bien des dnitions (de classe ou de fonctions) que des expressions, mais ces dernires ne seront excutes quune seule fois (la premire fois que le module est import). Les modules peuvent tre nomms de la mme manire que les variables. Un module est import grce au mot-cl import suivi du nom dun ou plusieurs modules 2 : import mod1, ..., modn Il est alors possible daccder aux lments quil contient grce au point (puisquun module est considr comme un objet). Tout module peut tre import dans un autre module, dans le module principal ou dans linterprteur interactif. Enn, au mme titre que pour les fonctions et le classes, un module peut comporter une docstring. Crons par exemple un chier fibo.py contenant du code :
This module contains the Fibonacci series. __all__ = [fibo_func] def fibo_func(n): a, b = 0, 1 while b < n: yield b a, b = b, a + b func_type = "generator" if __name__ == __main__: print(list(fibo_func(6)))
1. Par convention, ces chiers portent lextension .py. 2. Il est commun de placer tous les imports au dbut du chier (mais aprs la docstring), mme si ce nest pas oblig.
89
Maintenant, lanons linterprteur interactif :

>>> import fibo >>> print(fibo.func_type) generator >>> list(fibo.fibo_func(4)) [1, 1, 2, 3]
Il est possible de dnir des alias 3 :

>>> fib = fibo.fibo_func >>> list(fib(4)) [1, 1, 2, 3]
Dans chaque module import est dnie la variable __name__, qui contient le nom du module :
>>> fibo.__name__ fibo
Terminons cette section en notant quun module nest import quune seule fois. Les modications apportes aprs limport ne seront donc pas prises en compte, moins que lon redmarre linterprteur ou que lon relance le programme.
20.2 Variantes
Lon peut choisir dimporter certaines lments dun module directement dans le contexte global, en utilisant from-import. Lon peut attribuer un alias un lment apport laide du mot-cl as. Il est possible de mixer les lments avec alias et sans alias. from module import name1 [as alias1], ..., namen [as aliasn] Dans ce cas l, il convient de noter que le module lui-mme nest pas import.
>>> from fibo import fibo_func, func_type as type >>> list(fibo_func(4)) [1, 1, 2, 3] >>> type generator >>> fibo Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name fibo is not defined >>> from fibo import fibo_func as fib >>> list(fib(4)) [1, 1, 2, 3]
Ltoile * permet dimporter tout un ensemble dlments, dnis dans une liste nomme __all__. Reprenons le chier prcdent et ajoutons au dbut de ce dernier :
__all__ = [fibo_func] >>> from fibo import * >>> list(fibo_func(4)) [1, 1, 2, 3]
3. Ceci nest pas la manire habituelle de procder. Nous verrons par la suite comment crer un vritable alias.
90
Chapitre 20. Modules
Toutefois, cette syntaxe nest pas autorise en dehors du niveau du module (par exemple elle ne peut tre utilise dans la dnition dune fonction).
20.3 Scripts
Pour utiliser un module comme un script, il suft de fournir, dans un shell, le nom du module en argument :
$ python fibo.py
Dans ce cas uniquement, la variable __name__ vaut __main__. Ceci sert gnralement introduire, en n de module, du code qui ne doit tre excut que si le module est utilis comme un script. Par exemple, nous pourrions ajouter la n de notre chier fibo.py :
if __name__ == __main__: print(list(fibo_func(6)))
Le rsultat de sera videmment [1, 1, 2, 3, 5].
20.4 Mcanismes
20.4.1 Module path
Lorsque lon importe un module, ce dernier est recherch dans les dossiers contenus dans la variable sys.path (une liste, que lon peut modier). Cette dernire contient les mmes lments que la variable shell PYTHONPATH (dont la syntaxe est la mme que pour PATH) ainsi que les ventuels rpertoires ajouts. Ainsi, si lun de vos modules ne veut pas tre import, vriez sil est bien dans le path. Warning : Un module ne devrait pas tre nomm de la mme manire quun module standard.
20.4.2 Fichiers compils

Linterprteur Python cre, lorsquil importe un module (nomm name.py pour lexemple), un chier nomm name.pyc. Il sagit dune version compile, et donc plus rapide, du chier en question. Ainsi, lorsquil existe la fois une version .py et une version .pyc, linterprteur vrie si le code contenu dans le .py na pas chang depuis la dernire fois quil a t import ; le cas chant, linterprteur utilisera la version compile. Par contre, si le code a chang, alors linterprteur chargera la version .py et crera un nouvel .pyc, pour un usage ultrieur. Note : Il est aussi possible de gnrer du bytecode optimit (lextension des chiers sera alors .pyo). Ceci sera vu en dtails plus tard.
20.4.3 Mise en garde sur limport

Lorsquun module est import, une rfrence est stocke dans le dictionnaire sys.modules. Par exemple, au lancement de linterprteur interactif, jobtiens :
20.3. Scripts
91
>>> from sys import modules >>> modules {__main__: <module __main__ (built-in)>, site: <module site from /usr/local/lib/python3.1/si
Cela signie quun module nest import quune fois : les fois suivantes, Python ne fait rien. Ainsi, il vite dimporter plusieurs fois des modules ce qui permet damliorer les performances. Toutefois, cela est peu pratique lorsque lon veut tester un module, car il est ncessaire de quitter linterprteur et de le relancer si on dite le chier. Pour remdier ce problme, on pourra se tourner vers linterprteur IPython.
20.5 Modules standards

Il existe de nombreux modules distribus par dfaut avec Python, dont il serait trop long de faire la liste. Pour cette raison, la liste qui suit contient uniquement les principaux modules. sys : de nombreuses informations sur le systme ; os : fonctions pour interragir avec le systme dexploitation ; os.path : fonctions pour manipuler chiers et dossiers ; glob : ce module contient une fonction pour crer une liste de chiers au moyen de jokers (*) ; re : utilisation des expressions rgulires ; math : fonctions et constantes mathmatiques (sin, cos, exp, e, pi, etc) ; random : gnration de nombres alatoires ; datetime : utilisation de dates. Il ne sagit que dun trs bref aperu, et il est conseill au lecteur de se renseigner dans la documentation ds quil a besoin dune certaine fonction.
20.6 Packages
Un package est un ensemble de plusieurs modules. Il sagit donc dun dossier qui, pour que Python sache quil sagit dun package, doit contenir un chier __init__.py 4 . Lon accde au module dun package en utilisant le point, et il est possible de crer autant de sous-packages que lon souhaite. Nous pourrions donc avoir une arborescence de ce type :
sound/ __init__.py formats/ __init__.py wavread.py wavwrite.py ... effects/ __init__.py echo.py surround.py ... filters/ __init__.py equalizer.py vocoder.py
Nous pouvons alors importer tout un package, un ou plusieurs modules individuellement.

4. Ce chier est gnralement vide, mais il peut contenir du code qui sera excut lors de limport du package, comme par exemple dnir la variable __all__.
92
>>> >>> >>> >>> >>> >>>
import sound.filters.echo # access at the elements with "sound.filters.echo" from sound.filters import echo # access at the elements with "echo" from sound.effects.echo import echofilter # access at the function "echofilter"
20.7 Imports relatif et absolus

Il est possible daccder un module aussi bien grce au chemin absolu, ou bien grce au chemin relatif si ce dernier se trouve dans le mme dossier (ou donc dans un sous-dossier). Par exemple, si lon reprend la liste de chiers prcdentes, dans le chier echo.py, nous pourrions importer le module surround grce lune des deux syntaxes suivantes :
import sound.effects.surround import surround
20.7. Imports relatif et absolus
93
94
Quatrime partie
Aspects spciques
95
CHAPITRE 21
Expressions rgulires
21.1 Introduction
Les expressions rgulires (ou rationnelles), communment abrg en regex, constituent un outil fondamental lorsquil sagit de rechercher/remplacer des caractres dune manire complexe. Les regex elles-mmes demanderaient un livre entier pour tre maitris, aussi conseillerai-je de se reporter des livres ou des sites spcialiss sur le sujet, mme si je donnerai les bases pour sen servir et comprendre leur intrt. Une expression rgulire consiste en une chaine de caractres, souvent appele motif 1 . Elle sera donc crite entre guillemets. Un r plac devant la chaine permet de considrer lantislash \ comme un caractre normal. Par exemple, on pourra crire :
>>> regex = ra0\
Note : OpenOfce permet de faire des recherches par regex (Rechercher Autres options). Cela peut tre utile pour sentrainer manipuler les regex.
21.2 Syntaxe
Les regex rpondent une syntaxe trs codie et possdent de nombreux symboles ayant un sens particulier. Pour dbuter, tout caractre alphanumrique na pas de signication spciale : A correspond simplement la lettre A, 1 au chiffre 1, etc. Quant aux principaux symboles spciaux, il sont : . : dsigne nimporte quel caractre ; ^ : indique que le dbut de la chaine doit correspondre (cest dire quune chaine ne pourra correspondre que si elle commence de la mme manire, quelle est prcde despaces ou dun saut de ligne) ; $ : indique que la n de la chaine doit correspondre (la mme remarque que prcdemment sapplique, mais au niveau de la n) ; {n} : indique que le caractre prcdent doit tre rpt n fois. {n,m} : indique que le caractre prcdent doit tre rpt entre n et m fois.
1. Ou encore pattern en anglais.
97
* : le caractre prcdent peut tre rpt aucune ou plusieurs fois. Par exemple, ab* peuvent correspondre : a, ab, ou a suivi dun nombre quelconque de b. + : le caractre prcdent peut tre rpt une ou plusieurs fois. Par exemple, ab+ correspond un a suivi dun nombre quelconque de b. ? : le caractre prcdent peut tre rpt zro ou une fois. Par exemple, ab? correspondent ab et a. Les quatres derniers symboles sont dits gourmands 2 : cela signie quils chercheront un maximum de caractres, ce qui peut parfois poser problme. Pour viter ce comportement, on peut rajouter un ? aprs ces derniers, cest dire utiliser : ??, +? et *?. Lantislash permet dchapper tous ces caractres spciaux. Les crochets [] permettent dindiquer une plage de caractre, par exemple [e-h] correspondra e, f, g ou h. Les parenthses permettent de grouper certaines expressions 3 . Finalement, il reste quelques caractres spciaux assez utiles : \w : il correspond tout caractre alphabtique, cest dire quil est quivalent [a-zA-Z] ; \W : il correspond tout ce qui nest pas un caractre alphabtique ; \d : il correspond tout caractre numrique, cest dire quil est quivalent [0-9] ; \D : il correspond tout ce qui nest pas un caractre numrique.
21.3 Utilisation
Le module sappelle re. Il existe deux manires dutiliser les regex : 1. La premire consiste appeler la fonction avec en premier paramtre le motif, et en deuxime paramtre la chaine analyser. 2. La seconde consiste compiler la regex, et ensuite utiliser les mthodes de lobjet crer pour analyser une chaine passe en argument. Cette mthode permet dacclrer le traitement lorsquune regex est utilise plusieurs fois. La plupart des fonctions et mthodes prennent des arguments optionnels, appels drapeau (ag en anglais) qui permettent de modier le traitement de lobjet. Le drapeau le plus intressant est re.I (ou re.IGNORECASE) qui permet dignorer la casse lors de la recherche. re.compile(pattern) Compiler une expression rgulire et retourne un objet contenant les mmes mthodes que les fonctions dcrites juste aprs. re.search(pattern, string) Cherche le motif dans la chaine passe en argument et retourne un MatchObject si des correspondances sont trouves, sinon retourne None. re.split(pattern, string) Dcoupe la chaine string selon les occurences du motif.
>>> re.split(r\W, Truth is beautiful, without doubt.) [Truth, is, beautiful, , without, doubt, ]
re.findall(pattern, string) Retourne toutes les sous-chaines de string correspondant au motif. re.sub(pattern, repl, string) Retourne la chaine string o le motif a t remplac par repl.
2. Greedy en anglais. 3. Ce qui peut permettre de sy rfrer par la suite.
98
Chapitre 21. Expressions rgulires
Le principal intrt est dutiliser la fonction match() an de vrier si une chaine se trouve dans une autre ou si elle respecte un certain format (ce qui peut tre utilis pour vrier si un numro de tlphone ou une adresse email un format correct). Pour tout autre utilisation des MatchObject, je renvoie le lecteur la documentation. La squence
prog = re.compile(pattern) result = prog.match(string)
est quivalente
result = re.match(pattern, string)
21.4 Exemples
>>> import re >>> # trouver tous les adverbes en -ment >>> text = "Il stait prudemment dguis mais fut rapidement captur par la police." >>> re.findall(r"\w+ment", text) [prudemment, rapidement]
21.5 Liens
Regular Expression HOWTO par A.M. Kuchling : il sagit dun document utilisant une ancienne version de Python mais toujours adapte pour apprendre les regex. Python Regular Expression Testing Tool : ce site permet de tester des regex en utilisant un site particulier. Dive Into Python 3 : Chapter 5.
21.6 Exercices
1. crire un motif pour les numros de tlphone, en prenant garde aux diffrentes manires de les crire (avec un point, un tiret ou un espace entre les chiffres). On se limitera des numros franais dont les numros sont groups par deux ou pas du tout. 2. Utiliser le motif prcdent qui extrait tous les numros de tlphone dun texte et qui les afche lcran, sous une forme normalise (par exemple tous les chiffres sont groups par deux, et le sparacteur est un point).
21.4. Exemples
99
100
Chapitre 21. Expressions rgulires
CHAPITRE 22
Gestion des chiers et dossiers
Les principaux modules utiliss sont os et os.path. Pour cette raison, je supposerai que ces modules auront t imports dans tous les exemples qui suivent.
22.1 Introduction aux notions de chiers et de dossiers

Presque nimporte qui saurait faire la diffrence entre un chier qui contient des informations (texte, musique, vido, image. . . pour les plus connus) et un dossier (ou rpertoire) qui contient dautres dossiers ou des chiers. Toutefois, si lon veut comprendre comment les langages de programmation (et donc aussi les systmes dexploitation) les traitent, il faut aller un peu plus loin. Je nintroduirai que les notions de base, puisque ce nest pas le sujet principal de ce livre. Le systme de chiers est donc organis hirarchiquement : on parle darborescence.
22.1.1 Chemins
Sur un ordinateur un chemin 1 , reprsente une suite de noms de dossier (avec ventuellement un chier la n) qui indique commencer arriver un endroit prcis. Voici quelques exemples de chemins :
/home/harold C:\Python31\python.exe
Nous remarquons une diffrence agrante entre ces deux chemins : dans le premier, le sparateur est un slash / typique des systmes Unix 2 , tandis quil sagit dun antislash \ dans le second propre au systme Windows 3 . Heureusement pour nous, nous naurons pas faire la diffrence car Python comprend mme lorsque nous utilisons des slashs sous Windows ; ainsi nous pourrons crire sans problmes :
C:/Python31/python.exe
Il existe deux types de chemins : les chemins absolus : ces derniers partent de la racine du systme (/ sous Unix, C: sous Windows), et indiquent le chemin dtaill pour arriver lendroit indiqu (les deux exemples donns plus haut sont des chemins absolus) ;
1. Path en anglais. Ce terme est trs souvent utilis. 2. Les urls sont aussi des chemins vers des chiers et dossiers dun systme Unix, do lcriture identique. 3. Gnralement, lorsque le chemin se termine par un dossier, on met quand mme le sparateur la n.
101
les chemins relatifs : le chemin est donn partir dun dossier spcique, qui est considr, en quelque sorte, comme une nouvelle racine. Par exemple
python.exe
est un chemin relatif et na de sens que si lon prcise le dossier courant (celui o lon est) ; ici il sagira donc du dossier C:\Python31. Il est trs important de faire la diffrence entre ces deux types de chemins. Gnralement, nous prfrerons utiliser des chemins absolus dans nos programmes, an dtre certain de lendroit o lon travaille (par contre, lors de nos tests, nous utiliserons des chemins relatifs). Il est facile de distinguer les chemins relatifs et absolus : un chemin absolu commencera toujours par un slash sous Unix, ou par une lettre de lecteur suivie de deux points sous Windows. Sous Unix, deux dossiers particuliers sont dnis dans chaque rpertoire : . dsigne le rpertoire courant. .. dsigne le rpertoire suprieur. Pour xer les ides, imaginons que je me trouve dans le dossier /home/harold/python/livre. Alors .. sera quivalent au dossier /home/harold/python et . dsignera /home/harold/python/livre.
22.2 Manipulation des noms chemins

En Python, les chemins sont tout simplement des objets de type str. Il est donc possible de les manipuler avec les oprations classiques des chaines, bien que cela ne soit pas toujours conseiller (par exemple, pour coller deux chemins, il vaut mieux utiliser join() que loprateur +). Toutes les fonctions de base pour manipuler les noms de chemin se trouvent dans le module os.path. os.path.abspath(path) Retourne le chemin absolu du chemin relatif path donn en argument. Il permet aussi de simplier les ventuelles rptitions de sparateurs. os.path.realpath(path) Retourne le chemin path en remplaant les liens symboliques par les vrais chemins, et en liminant les sparateurs excdentaires. os.path.split(path) Spare path en deux parties lendroit du dernier sparateur : la deuxime partie contient le chier ou le dossier nal, et la premire contient tout le reste (cest dire le chemin pour y accder). Type retourn 2-tuple of strings os.path.basename(path) Retourne le dernier lment du chemin. Cela revient appeler :func :~os.path.split et rcuprer le deuxime lment du tuple. os.path.dirname(path) Retourne le chemin pour accder au dernier lment. Cela revient appeler :func :~os.path.split et rcuprer le premier lment du tuple. os.path.expanduser(path) Si path est ~ ou ~user, retourne le chemin permettant daccder au dossier personnel de lutilisateur. os.path.join(path1[, path2[, ... ]]) Permet de concatner plusieurs chemins. Warning : Toutes ces fonctions retournent une valeur mme si le chemin donn en argument nexiste pas. Il peut donc tre ncessaire de tester leur existence avec les fonctions que nous verrons plus bas.
102
Chapitre 22. Gestion des chiers et dossiers
Voici quelques exemples de manipulations de noms de chemin :

>>> path = /home/harold/Musique >>> os.path.split(path) (/home/harold, Musique) >>> os.path.join(path, Classique) /home/harold/Musique/Classique >>> os.path.expanduser(~) /home/harold >>> os.path.abspath(.) /mnt/data/Projets/Enseignements/Python >>> os.path.realpath(/mnt//dev/) /mnt/dev >>> os.path.dirname(path) /home/harold >>> os.path.basename(path) Musique
Warning : Observez le code suivant :

>>> path = /home/harold/Musique/ >>> os.path.split(path) (/home/harold/Musique, )
Il faut donc faire attention ne pas laisser de sparateur la n. On pourra utiliser realpath() ou abspath() avant tout appel une autre fonction de chemins, an de sassurer que les chemins sont au bon format :
>>> path = /home/harold/Musique/ >>> os.path.split(os.path.abspath(path)) (/home/harold, Musique)
22.3 Lister les chiers et les dossiers

Le module os contient une fonction qui permet de lister simplement les lments dun dossier. os.listdir(path) Liste tous les dossiers et chiers qui se trouvent dans path. Les dossiers . et .. sont automatiquement retirs. Toutefois, pour un usage plus compliqu, on prfera le module glob, qui contient deux fonctions uniquement. Les fonctions de ce module permettent de lister tous les chiers dont les noms correspondent au motif donn en argument. Le motif peut contenir certains caractres spciaux : * remplace nimporte quelle squence de caractres. ? remplace un caractre. [] symbolise nimporte quel caractre indiqu dans les crochets. glob.glob(pathname) Liste tous les dossiers et chiers dont le motif du nom correspond pathname. glob.iglob(pathname) Fonctionne de mme que glob() mais retourne un itrateur. Cette fonction est donc prfrable. Lexemple qui suit est tir de la documentation Python. Il suppose que vous ayez un dossier qui contient au moins les chiers suivants : 1.gif, 2.txt et card.gif.
22.3. Lister les chiers et les dossiers
103
>>> import glob >>> glob.glob(./[0-9].*) [./1.gif, ./2.txt] >>> glob.glob(*.gif) [1.gif, card.gif] >>> glob.glob(?.gif) [1.gif]
22.4 Tests sur les chiers et les dossiers

Les tests de base sur les dossiers et chiers se font tous partir de fonctions du module os.path. os.path.exists(path) Permet de vrier si path est un chemin rel. os.path.isabs(path) Teste si path est un chemin absolu. os.path.isdir(path) Teste si path pointe vers un dossier. os.path.isfile(path) Teste si path pointe vers un chier. Voici quelques exemples :
>>> os.path.exists(path) True >>> os.path.isabs(path) True >>> os.path.isfile(path) False
22.5 Autres oprations

Dans cette section nous tudierons les fonctions du module os qui permettent de crer, supprimer et renommer les chiers et rpertoires. os.mkdir(path) Cre le dossier la n de path. Si lun des dossiers intermdiaires nexiste pas, une exception OSError. os.makedirs(path) Cette fonction est quivalente un appel rcursif mkdir() : elle cre rcursivement tous les dossiers qui nexiste pas jusquau dossier nal de path. os.remove(path) Supprime le chier ou le dossier point par path. os.rename(old, new) Renomme old en new.
22.6 Exercices
1. Crer un programme qui liste uniquement les chiers dun rpertoire et qui les ordonne par taille croissante.
104
Chapitre 22. Gestion des chiers et dossiers
CHAPITRE 23
Systme
Ce chapitre est fortement li au prcdent, et cest pour cette raison quil sera trs court : nous nous contenterons daborder les dernires fonctions utiles du module os ainsi que celle du module sys.
23.1 Informations sur Python

Le module sys permet dobtenir des informations sur certaines proprits de la version Python qui est utilise, ainsi que sur son comportement. sys.path Liste des dossiers dans lesquels Python cherche les modules importer (voir Modules). sys.modules Liste des modules imports par le programme (voir Modules). sys.version Donne des informations sur la version de Python qui est utilise. sys.version_info Donne, sous forme dun tuple, des informations sur la version de Python. Cette forme peut tre plus pratique utilise lorsquil sagit de tester si la version utilise correspond certains critres.
>>> if sys.version_info[0] < 3: ... print(La version de Python que vous utilisez est trop ancienne.)
sys.float_info Donne, sous forme dun objet, des informations sur les nombres virgule du systme (prcision, taille maximale. . . ). sys.getfilesystemencoding() Renvoie le nom de lencodage utilis par le systme. Voici quelques exemples :
>>> sys.version 3.1.1 (r311:74480, Feb 5 2010, 20:43:13) \n[GCC 4.4.2 20091222 (Red Hat 4.4.2-20)] >>> sys.version_info sys.version_info(major=3, minor=1, micro=1, releaselevel=final, serial=0)
105
23.2 Informations sur le systme

Le module os permet daccder de nombreuses informations sur le systme. os.name Indique le nom du systme. Les principales possibilits sont : posix (Linux, Mac), nt (Windows). os.getcwd() Indique le rpertoire de travail, cest dire, en quelque sorte, lendroit o sont excuts les scripts : tout chemin relatif partira de ce dernier. Il est possible de le changer avec chdir(). os.uname() Renvoie un 5-tuple contenant : le nom du systme, le nom de la machine, la version du systme et le type darchitecture. Voici quelques exemples :
>>> os.name posix >>> os.getcwd() /mnt/data/Projets/Enseignements/Python >>> os.uname() (Linux, harold-laptop, 2.6.32.9-70.fc12.i686.PAE, #1 SMP Wed Mar 3 04:57:21 UTC 2010, i686)
23.3 Arguments en ligne de commande

Lorsque lon cre un programme, il peut tre trs utile de lui donner des informations supplmentaires ds le lancement an de modier son comportement ou pour viter dutiliser input(). Ceci peut tre ralis en utilisant des arguments de ligne de commandes : il sagit simplement de texte (qui peut reprsenter un nom de chier, un nombre, une chaine. . . ) qui se place aprs le nom du chier, cest dire, dans un terminal, on crira :
$ python file.py arg1 arg2 arg3 ...
Il est ensuite possible de rcuprer les arguments grce lattribut sys.argv 1 : il sagit dune liste qui contient tous les arguments (le premier lment tant le nom du chier). Warning : Les lments de sys.argv sont toujours des chaines de caractres. On peut imaginer, par exemple, vrier si largument -v est prsent pour activer le mode verbeux et aussi donner la possibilit de donner un nom de chier pour sauvegarder dans ce dernier le rsultat du script.
Le code suivant affiche la somme des cinq premiers entiers. Si le mode verbeux est activ, alors il affiche les rsultats intermdiaires. Si un nom de fichier est donn, il crira le rsultat dans ce fichier, sinon il laffichera lcran. from sys import argv if -v in argv: VERBOSE = True else: VERBOSE = False
1. sys.argc permet dobtenir le nombre darguments. Cela revient au mme que len(sys.argv).
106
Chapitre 23. Systme
if -f in argv: # on rcupre lindex de llment qui suit "-f". index = argv.index(-f) + 1 FILE = argv[index] else: FILE = None s = 0 for i in range(6): s += i if VERBOSE is True: print(s) if FILE is None: print(Le rsultat est :, s) else: result_file = open(FILE, w) result_file.write(str(s)) result_file.close() print(Le rsultat a t sauvegard dans :, FILE)
Testons notre code :

$ python3.1 Le rsultat $ python3.1 0 1 3 6 10 15 Le rsultat $ python3.1 Le rsultat commandline.py est : 15 commandline.py -v
est : 15 commandline.py -f fichier.txt a t sauvegard dans : fichier.txt
Le module optparse permet une gestion beaucoup plus pousse des arguments pass en ligne de commande.
23.4 Exercices
1. Corriger le programme donner en exemple dans la dernier section an dajouter une gestion des exceptions : par exemple prendre en compte le cas o -f nest pas suivi dun nom de chier. On pourra aussi vrier si le dossier o lon veut sauvegarder le chier existe. 2. Corriger le script prcdent an de permettre lutilisateur dentre le nombre n dentiers quil veut sommer.
23.4. Exercices
107
108
Chapitre 23. Systme
CHAPITRE 24
Classes tendues
Dans ce chapitre, nous aborderons les diffrentes techniques qui permettent de dnir des classes ayant un comportement spcique.
24.1 Itrateurs
24.1.1 Introduction
Un itrateur est un objet qui peut tre parcouru par une boucle for. De nombreux objets Python sont en ralits des itrateurs, et leur utilisation permet de simplier dune manire lgante le code. De plus, les itrateurs permettent de gagner en performance : en effet, les lments de ces derniers ne sont valus que lorsquils sont ncessaires et utiles. Ainsi, contraitement une squence qui est garde toute entire en mmoire (ce qui peut rduire grande consommation de mmoire), les itrateurs prennent peu de place. Enn, les itrateurs peuvent tre innis. De nombreuses fonctions, comme map(), sum() ou encore max(), acceptent des itrateurs en argument. Les itrateurs les plus basiques sont les tuples et les listes :
>>> for i in (1, 2): ... print(i) 1 2 >>> for i in [a, b]: ... print(i) a b
Les dictionnaires eux aussi sont des itrateurs, ce qui permet dcrire
>>> dic = {a: 1, b: 2} >>> for key in dic: ... print(key)
bien quune ide plus intuive aurait pu tre ditrer sur la liste des cls en utilisant la mthode keys() (qui retourne dsormais aussi un itrateur depuis la version 3) :
>>> for key in dic.keys(): ... print(key)
109
Les chiers eux-mmes sont des itrateurs : les syntaxes for line in f et for line in f.readlines() ont le mme effet, bien que la premire soit plus efcace. La fonction iter() permet de transformer un objet en itrateur, tandis que next() permet dobtenir llment suivant.
24.1.2 Implmentation
Une classe peut devenir un itrateur condition dimplmenter les deux mthodes __iter__ et __next__. Comme exemple, construisons une classe qui prend en argument une squence et, qui, lorsque utilise en tant quitrateur, retourne les lments de cette squence en ordre inverse :
class Reverse: def __init__(self, data): self.data = data self.index = len(data) def __iter__(self): return self def __next__(self): if self.index == 0: raise StopIteration self.index = self.index - 1 return self.data[self.index]
Lexception StopIteration permet dindiquer que litration est termine et que la boucle doit sarrter. Cette exception est automatiquement intercepte par la boucle for.
>>> for char in Reverse(Jour): ... print(char) r u o J
24.1.3 Module itertools

Ce module contient de nombreuses fonctions utiles pour travailler avec des itrateurs. Citons par exemple la fonction chain() qui permet de coller deux itrateurs.
24.2 Exercices
1. crire une classe qui permette de reprsenter un tableau circulaire, cest dire que lorsquil est parcouru jusqu la n, on revienne au dbut. Par exemple, si on prend la squence (1, 2, 3), alors cinq appels next() donneront successivement : 1, 2, 3, 1, 2.
110
Chapitre 24. Classes tendues
CHAPITRE 25
Persistance
La persistance rfre lensemble des outils permettant de sauvegarder et rutiliser des donnes ou un tat du programme.
25.1 Base de donnes

Nous tudierons le cas de la base de donnes SQLite3, car il sagit de la plus simple mettre en place 1 . Toutefois, ce qui est dcrit ici fonctionnera pour toutes les bases de donnes, comme Python fournit une interface identique pour toutes. Pour comprendre totalement la section qui suit, il est ncessaire davoir des notions sur les bases de donnes et le langage SQL. La premire chose faire est de crer un objet Connection qui reprsente une base de donnes :
>>> db = sqlite3.connect(database.sqlite3)
Note : Il est possible dutiliser largument spcial :memory: an de crer une base de donnes virtuelles, qui sera dtruite une fois ferme. Cette technique peut tre utile en vue de tester. An dexcuter une requte, il faut crer un objet Cursor et utiliser a mthode execute() :
>>> >>> >>> >>> >>> curs = db.cursor() curs.execute(create table persons (name, age)) curs.execute(insert into persons values(Jean, 21)) db.commit() curs.close()
Il est important de valider les requtes avec la mthode commit() puis de fermer le curseur an de ne pas gaspiller de la mmoire. Il peut tre dangereux dinsrer directement la valuer dune variable dans une requte. la place, il faut utiliser le symbole ? et fournir les variables en arguments supplmentaires execure() :
1. Une base de donnes SQLite consiste en un simple chier sur le disque dur, au contraire de la plupart des autres bases de donnes qui font appel tout un attirail pour fonctionner.
111
>>> >>> >>> >>> >>> >>> >>>
curs = db.cursor() name = Jean param = (name,) curs.execute(select * from persons where name=?, param) params = (Michel, 10) curs.execute(insert into persons values(?, ?), params) db.commit()
Aprs une requte select, il est possible daccder aux donnes en utilisant le curseur comme un itrateur, ou en utilisant les mthodes Cursor.fetchone() ou Cursor.fetchall().
>>> curs.execute(select * from persons) >>> for row in curs: ... print(row) (Jean, 21) (Michel, 10)
Voir aussi : http ://www.sqlite.org Le site ofciel de SQLite : la documentation sur ce dernier dcrit la syntaxe et les types disponibles. PEP 249 Database API Specication 2.0
25.2 Srialisation
La srialisation consiste stocker nimporte quel objet dans un chier, ce qui permet de le rutiliser ultrieurement, mme si le programme a t interrompu entre temps. Gnralement, le stockage sera effectu en binaire.
25.2.1 Pickle
Le module pickle permet de transformer des objets en bytes. De fait, lorsque quun chier sera requis, ce dernier devra tre ouvert en mode binaire. pickle.dump(obj, le) Srialise obj et crit sa reprsentation dans le chier file. pickle.load(le) Lit une reprsentation srialise dun objet dans le chier file et retourne lobjet original. Deux classes permettent de dsigner une fois pour toute le chier considr : Pickler(file) (qui possde une mthode dump()) et Unpickler(file) (qui possde une mthode load()). Warning : Tous les objets ne peuvent pas tre srialiss. Il est possible de modier le comportement dune classe lorsquelle est (d)srialise grce plusieurs mthodes : __getnewargs__() qui dnit quels arguments seront passs __new__(). Les mthodes __getstate__() et __setstate__() permettent de modier la manire dont le dictionnaire __dict__ est gr. Il convient de noter que la mthode __init__() nest gnralement pas appele lorsquun objet est dsrialis.
112
Chapitre 25. Persistance
25.2.2 Shelve
la diffrence de pickle, le module shelve permet de srialiser plusieurs objets dans un mme chier : ces derniers sont accessibles via un systme de cls, comme pour un dictionnaire 2 . shelve.open(lename) Ouvre un dictionnaire persistant dans lequel sera stock les donnes. Ce dernier possde les mmes mthodes que les dictionnaires dict. Shelf.sync() Synchronise tous les changements mis en cache. Il est ncessaire dappeler cette mthode pour que les changements soient crits dans le chier. Shelf.close() Cette mthode appelle sync() avant de fermer le dictionnaire.
2. Shelf veut dailleurs dire tagre en anglais.
25.2. Srialisation
113
114
Chapitre 25. Persistance
CHAPITRE 26
Internationalisation et localisation
Linternationalisation et la localisation (ou rgionalisation), dsignes respectivement par les sigles i18n et l10n 1 , consistent : le premier dsigne toutes les techniques permettant au logiciel de sadapter la culture et la langue de lutilisateur ; le second concerne plus prcisment la traduction des messages afchs. Pour ce faire, le module gettext fournit de nombreux outils utiles. Ce dernier utilise des chiers textes portant lextension .po et leur version compile .mo qui contiennent les traductions 2 . Usuellement, ces chiers sont placs dans le dossier /locale/lang/LC_MESSAGES/, o lang est remplac par le sigle de la langue voulue (fr pour franais, en pour anglais. . . ). gettext.bindtextdomain(domain[, localedir ]) Associe domain au dossier localedir contenant les chiers de localisation. Cela signie que gettext va rechercher les chiers .mo correspondant au domaine indiqu. gettext.textdomain([domain ]) Si domain vaut None, alors le domaine courant est retourn, sinon, le domaine est chang domain. gettext.gettext(message) Retourne la traduction de message, base sur le domaine actuel, le langage et le dossier de translations 3 . gettext.gettext(message_sing, message_plur, n) Cette fonction est utilise pour les formes plurielles. Si une traduction trouve, elle applique la formule n, sinon elle retourne message_sing si n vaut 1 et message_plur sinon. Voici un exemple :
>>> import gettext >>> gettext.bindtextdomain(app, /path/to/my/language/directory) >>> gettext.textdomain(app) app >>> _ = gettext.gettext >>> print _(Cette chaine est traductible.)
La fonction install() permet dautomatiser plusieurs mchanismes. Elle prend en argument le domaine et le dossier de traduction, et se charge dajouter lalias _(). Si certaines sont construites partir de variables, il est conseill dutiliser des arguments nomms an de permettre au traducteur de savoir quest-ce qui sera insr et, surtout, pour quil puisse intervertir lordre sans souci :
1. Le chiffre indique le nombre de lettres entre les lettre initiale et nale. 2. On parle de locale en anglais. 3. Gnralement, on dnit lalias _() pour la fonction gettext() : _ = gettext.gettext
115
>>> name = Anais >>> age = 23 >>> print _(Hello %(name)s, today is %(age)d) % {name: name, age: age}
Toutefois, lcriture la main des chiers .po est fastidieuse 4 . Pour cette raison, un logiciel permettant de simplier grandement le travail a t conu : poEdit. Ce dernier peut tudier le code Python an de slectionner les chaines gettext. Son interface permet ensuite de les traduire aisment. Voir aussi : http ://lyb.info/post/2006/11/02/413-tutoriel-traduire-un-programme-en-python-et-glade Cet article dtaille aussi la manire dutiliser les outils gettext sans passer par poEdit.
4. Il serait possible de rcuprer les chaines et compiler les chiers en ligne de commande, mais cette mthode ne sera pas prsente ici.
116
Chapitre 26. Internationalisation et localisation
Cinquime partie
Annexes
117
CHAPITRE 27
Histoire
119
120
Chapitre 27. Histoire
CHAPITRE 28
volutions
Ce chapitre liste les diffrences entre les versions 2.5 et 3 de Python, ce qui permettra dadapter en consquences le code si la version 3 ntait pas utilise.
121
122
Chapitre 28. volutions
CHAPITRE 29
Bonnes et mauvaises pratiques
29.1 Imports
Il est fortement dconseill dutiliser linstruction form module import *, car cela surcharge lespace de noms global et peut conduire des conits. Observons le code suivant :
>>> from math import * >>> cos(1) 0.54030230586813977 >>> from cmath import * >>> cos(1) (0.54030230586813977-0j)
Lon remarque que la fonction cos() du module cmath remplace celle du module math. La seule exception notable cette pratique est lorsque lon utilise Python en mode interactif (par exemple en important tout le module math pour se servir du terminal comme dune calculatrice).
29.2 Exceptions
Lorsquune erreur est intercepte, il est vital de spcier aprs linstruction except quelle erreur est attendue. Le cas chant, toutes les erreurs leves seront interceptes, et cela pourra cacher certains problmes au programmeur, et rendre le dbugage trs difcile. Par exemple :
try: foo = opne(file) except: sys.exit(could not open file)
Ce code interceptera toutes les erreurs, mme celle indiquant que la fonctionopn opne() nexiste pas, et le programmeur sera dans lincapacit de comprendre o est le problme. Au contraire, le code suivant lui permettra de rapidement trouver lerreur :
try: foo = opne(file) except IOError: sys.exit(could not open file)
123
29.3 Utilisation des backslash

Comme il a t vu au dbut, un backslash permet dcrire une expression ou une instruction sur plusieurs lignes. Toutefois, il peut tre plus simple dutiliser des parenthses an damliorer la lecture. Les deux expressions suivantes sont quivalentes :
value = foo.bar()[first][0]*baz.quux(1, 2)[5:9] \ + calculate_number(10, 20)*forbulate(500, 360) value = (foo.bar()[first][0]*baz.quux(1, 2)[5:9] + calculate_number(10, 20)*forbulate(500, 360))
29.4 Conventions et style

Voici une liste (non exhaustive) des conventions communment adoptes : utiliser quatre espaces par niveau dindentation, et surtout pas de tabulations : couper chaque ligne 79 caractres 1 ; insrer une ligne vierge entre les dnitions de fonctions et, classes, ainsi quentre les grandes articulations du code ; utiliser des docstrings ; mettre un espace de chaque ct des oprateurs, aprs une virgule ou deux points (mais pas avant), enn, ne pas mettre despace aprs un signe ouvrant ou avant un signe fermant (cest dire (), {}, []) ; nommer les classes en CamelCase, les fonctions, mthodes et variables en lower_case. Voir aussi : PEP 8 Style Guide for Python Code
1. Ceci pour faciliter la lecture du code et pour quil soit adapt toutes les rsolutions
124
Chapitre 29. Bonnes et mauvaises pratiques
CHAPITRE 30
diteurs
Il est important de choisir des outils avec lequels on se sent laise, car ce sont avec ces derniers que lon passera la majeure partie de notre temps de programmeur ! De nombreux logiciels permettent de coder, mme le bloc-notes de Windows pourrait sufre ! Il est toutefois vivement conseill de choisir un logiciel plus avancs, la coloration syntaxique tant un minimum vital. Il ne faut pas hsiter tester de nombreux diteurs, regarder sur internet comment les congurer, quels sont les avis des utilisateurs... Dans cette annexe, nous nous concentrerons sur la prsentation des interprteurs et des diteurs.
30.1 Interprteurs interactifs

30.1.1 IDLE
IDLE (pour Integrated DeveLopment Environment) est un interprteur interactif plus volu (grce sa coloration syntaxique par exemple). Il sagit dune manire plus agrable pour dbuter que le terminal Windows, qui est trs austre et peu ais dutilisation. Il est install en mme temps que Python sous Windows, mais il peut tre ncessaire de linstaller depuis les dpts sous Linux ou les autres systmes, mme si son intrt est alors moindre.
30.1.2 IPython
IPython est un interprteur interactif qui amliore signicativement linterprteur par dfaut, en proposant de nombreuses fonctionnalits : auto-compltion avec tab (comme dans le terminal Unix), prenant en compte les mthodes et attributs des objets ; un historique persistant des commandes excues ; une indentation automatique ; des raccourcis et des commandes magiques permettant de tester et dbugger ; la possibilit de lancer des commandes bash ; sortie colore et plus agrable. Warning : Actuellement, iPython nest compatible quavec les versions 2.x.
125
Je me contenterai de prsenter les principales fonctionnalits et renvoie la documentation pour un usage plus dtaill. Il est possible daccder une documentation sommaire dans le terminal en tapant ?. Lauto-compltion est trs pratique la fois viter dcrire compltement les commandes, mais aussi pour avoir un rsum rapide des mthodes et des attributs des objets, sans avoir besoin de consulter la documentation ! Une commande bash sexcute en la prxant par un point dexclamation ! :
# affichage de la date In [1]: !date dim. mai 30 18:23:34 EEST 2010 # cration dun dossier appel "test" In [2]: !mkdir test
Une commande magique commence par le signe pourcentage % (utiliser %magic pour accder la liste complte des commandes magiques ainsi qu leur description, et %lsmagic pour obtenir uniquement la liste). Les plus utiles sont : %run module : excute un module et importe dans linterprteur les variables dnies dans ce dernier. Lavantage est qu chaque %run, les dnitions des objets sont mises jour, contrairement ce qui se passe lorsque avec import. %timeit fonction : excute un grand nombre de fois la fonction passe en argument et afche le temps moyen dexcution. De plus, loption -pylab permet dajouter un support interactif de la librairie matplotlib, ce qui permet de tracer et analyser rapidement des donnes.
30.2 Environnements de dveloppement

30.2.1 diteurs texte
Malgr lapparence spartiate des diteurs de texte, nombre dentre eux sont largement sufsants pour le dbutant, et certains peuvent mme tre fortement personnaliss jusqu devenir de vrais IDE ! Voici une liste des diteurs texte les plus rpandus : Windows : Notepad++. Linux : Gedit (Gnome), Kate (KDE). UNIX : Emacs, Vi(m) 1 .
30.2.2 Eclipse (Pydev)

LIDE Eclipse, lorigine prvu pour la programmation en Java, possde un systme de plugins qui permet de ltendre si facilement quun grand nombre dextensions ont vu le jour et ajoutent le support de nombreux langages et doutils. Le plugin ddi au Python sappelle PyDev. On peut noter que la suite Aptana (base sur Eclipse, et que lon peut ajouter en plugin ce dernier), qui se concentre sur le dveloppement web, contient aussi PyDev.
1. Ces deux logiciels, correctement congurs, peuvent devenir trs puissants et sont dailleurs trs utiliss par les geeks (qui se livrent une guerre acharne pour dterminer lequel est le meilleur des deux). Toutefois il faut de la patience et de la pratique pour sy habituer.
126
Chapitre 30. diteurs
CHAPITRE 31
Outils
31.1 Gnrateurs de documentation

31.1.1 Sphinx
Sphinx est un logiciel qui permet de crer trs facilement de belles documentations pour les logiciels Python. Toutefois, sa puissance ne le limite pas du code Python et il peut tre utilis pour rdiger dautres documents 1 . De nombreux formats sont disponibles pour la sortie : PDF (via LaTeX), HTML. . . Le langage de balisage ReST est utilis par Sphinx an de mettre en forme le contenu de la documentation. Il sagit dun langage trs simple apprendre et intuitif. Warning : Sphinx ne supporte pas encore la version 3 de Python.
31.1.2 Autres
Dautres outils permettant de gnrer des documentations existent, mais ils sont gnralement moins adapts Python et leur rendu est moins agrable. Voici une liste non exhaustive : Doxygen : Lavantage de ce logiciel est de fonctionner avec la plupart des langages couramment utiliss (Python, PHP, C, Java. . . ). Epydoc : Logiciel utilis historiquement pour les documentations Python.
31.2 Pylint
Pylint est un logiciel utilisable en ligne de commande qui permet danalyser du code, dans le but de chercher des erreurs et de vrier la bonne rdaction (respect de la PEP 8 voir lannexe Bonnes et mauvaises pratiques). Il peut sutiliser pour vrier la syntaxe dun chier seul ou dun package entier. Il sutilise comme suit :
$ pylint package $ pylint file.py
1. Dailleurs ce manuel a t rdig grce Sphinx.
127
Un rapport dtaill des erreurs et des fautes de style (chacune identie par une catgorie) pour chaque chier sera afch. la n, le rapport indique un rcapitulatif par modules et un autre global, en plus dattribuer une note sur 10. Pylint est trs strict quant la vrication du code, et il est souvent ncessaire de crer sa propre conguration an quil accepte certaines formes quil considre comme des erreurs.
128
Chapitre 31. Outils
CHAPITRE 32
Liens
32.1 Autres tutoriels

Python Challenge http ://www.pythonchallenge.com/ : il sagit dun site constitu dun ensemble dpreuves, qui ncessitent de programmer pour tre rsolues.
32.2 Projets lis

Voici une liste des projets lis Python que jai pu citer. GTK http ://www.gtk.org/ Sphinx http ://sphinx.pocoo.org/
129
130
Chapitre 32. Liens
CHAPITRE 33
Glossaire
Algorithme Plan dtaillant la manire de rsoudre un problme. Bytecode Code binaire intermdiaire entre le code compil et le code source. Code Texte formant un programme. Dbugging Dtection et rparation des erreurs dun programme. Dclaration Instruction reliant une expression (un objet) une variable. Excutable Fichier permettant de lancer le programme. Expression Suite de symboles interprte retournant un nouvel objet. IDE (Integrated Development Environment) La traduction franaise signie environnement de dveloppement intgr. Un tel logiciel a pour vocation de rassembler de nombreux outils en une seule interface. Instruction Action effectuer par lordinateur. Elle tient gnralement sur une ligne. PEP Une PEP (Python Enhancement Proposals) est un document visant apporter des informations la communaut ou dcrire une nouvelle fonctionnalit. Portabilit Capacit dun programme fonctionner plus ou moins bien dans diffrents environnements. Prdicat Un prdicat est une expression qui possde une valeur de vrit Procdure Il sagit dune fonction qui ne retourne aucune valeur. Rcursivit Une fonction qui sappelle elle-mme est dite rcursive. Variable Nom dun objet. Vrication Dmonstration quun programme fonctionne correctement.
131
132
Chapitre 33. Glossaire
CHAPITRE 34
Bibliographie
David Ascher, Alex Martelli. Python Cookbook. OReilly, 2005. Allen Downey. Think Python : An Introduction to Software Design. Cambridge University Press, June 2008. http ://www.greenteapress.com/thinkpython/. Mark Pilgrim. Dive into Python 3. http ://diveintopython3.ep.io/. Grard Swinnen. Apprendre programmer avec Python. OReilly, May 2005. http ://www.cifen.ulg.ac.be/inforef/swi/python.htm. Wesley J. Chun. Au coeur de Python, version 2.5, Volume 1 : Notions fondamentales CampusPress, 2007.
133
134
Chapitre 34. Bibliographie
Sixime partie
Sur le livre
135
CHAPITRE 35
Changements
Tables des matires Version 1.0 (en cours de rdaction)
35.1 Version 1.0 (en cours de rdaction)

Partie Introduction : notions gnrales en programmation. Partie Langage : description gnrale du langage Python. Partie Aspects spciques.
137
138
Chapitre 35. Changements
CHAPITRE 36
Licence et auteurs
36.1 Licence
Ce livre est publi sous la licence Creative Commons-BY-NC-SA : BY [Paternit] Vous devez citer le nom de lauteur original NC [Pas dUtilisation Commerciale] Vous navez pas le droit dutiliser cette cration des ns commerciales. SA [Partage des Conditions Initiales lIdentique] Si vous modiez, transformez ou adaptez cette cration, vous navez le droit de distribuer la cration qui en rsulte que sous un contrat identique celui-ci. Voir aussi : Creative Commons-BY-NC-SA http ://creativecommons.org/licenses/by-nc-sa/3.0/deed.fr
36.2 Auteurs
Harold Erbin <harold.erbin@gmail.com>
139
140
Chapitre 36. Licence et auteurs
Septime partie
Indices and tables
141
genindex modindex search Glossaire
143
144
Python Module Index
g
gettext, 115 glob, 103
o
os, 103 os.path, 102
p
pickle, 112
r
re, 98
s
shelve, 113 sys, 105
145
146
Python Module Index
Index
Symbols
diteur IDLE, 125 diteurs Eclipse, 126 IPython, 125
chaine de caractres, 53 compteur, 55 dictionnaire, 54 dictionnaire ordonn, 55 ensemble, 55 continue, 63
A
abspath() (dans le module os.path), 102 affectation, voir variable : affectation Algorithme, 131 assignation, voir affectation
D
Dbugging, 131 Dclaration, 131 dlimiteur, 42 dir() (fonction de base), 73 dirname() (dans le module os.path), 102 docstring, 68
B
basename() (dans le module os.path), 102 bindtextdomain() (dans le module gettext), 115 boolen, 50 boucle conditionnelle, 62 itrative, 62 techniques avances, 63 break, 63 Bytecode, 131 bytecode, 17
E
elif, 61 else, 61, 64 eval() (fonction de base), 74 Excutable, 131 exists() (dans le module os.path), 104 expanduser() (dans le module os.path), 102 Expression, 131 expression combinaison, 59
C
close() (mthode shelve.Shelf), 113 Code, 131 coercition (Python 2), 51 commentaire, 39 comparaison galit/identit, 60 identit/galit, 60 compilation, 17 compile() (dans le module re), 98 condition, 61 conteneur, 51
F
ndall() (dans le module re), 98 oat_info (dans le module sys), 105 ottant, voir nombre virgule fonctionnelle programmation, 19
G
getcwd() (dans le module os), 106 getlesystemencoding() (dans le module sys), 105 gettext (module), 115
147
gettext() (dans le module gettext), 115 glob (module), 103 glob() (dans le module glob), 103 globals() (fonction de base), 74
mot rserv, voir mot-cl mot-cl, 40
N
name (dans le module os), 106 nombre, 48 virgule, 48 complexe, 49 entier, 49
H
hasttr() (fonction de base), 74 help() (fonction de base), 74
I
IDE, 131 IDLE, 125 if, 61 iglob() (dans le module glob), 103 imprative programmation, 19 indentation, 38 input() (fonction de base), 74 installation UNIX, 33 Linux, 33 MacOS, 34 Windows, 34 Instruction, 131 IPython, 125 isabs() (dans le module os.path), 104 isdir() (dans le module os.path), 104 isle() (dans le module os.path), 104 isinstance() (fonction de base), 47, 74 itration, 62
O
objet nul, 57 type, 57 oprateur, 41 comparaison, 60 open() (fonction de base), 86 oriente objet programmation, 19 os (module), 103 os.path (module), 102
P
paradigmes, 19 pass, 64 path (dans le module sys), 105 PEP, 131 pickle (module), 112 pickle.dump() (dans le module pickle), 112 pickle.load() (dans le module pickle), 112 Portabilit, 131 Prdicat, 131 prdicat, 59 print() (fonction de base), 74 procdurale programmation, 19 Procdure, 131 programmation fonctionnelle, 19 imprative, 19 oriente objet, 19 procdurale, 19 Python Enhancement Proposals PEP 0, 12 PEP 249, 112 PEP 3131, 40 PEP 8, 124
J
join() (dans le module os.path), 102
L
langage bas niveau, 17 compil, 17 haut niveau, 17 interprt, 17 len() (fonction de base), 56, 74 ligne, 37 listdir() (dans le module os), 103 littral, 40 locals() (fonction de base), 74
M
makedirs() (dans le module os), 104 max() (fonction de base), 56 min() (fonction de base), 56 mkdir() (dans le module os), 104 mode interactif, 34 modules (dans le module sys), 105
R
Rcursivit, 131 rfrence, 42, voir variable : rfrence range() (fonction de base), 74 re (module), 98 read(), 86 Index
148
readline(), 86 readlines(), 86 realpath() (dans le module os.path), 102 remove() (dans le module os), 104 rename() (dans le module os), 104 repr() (fonction de base), 75 reversed() (fonction de base), 75 round() (fonction de base), 75
version_info (dans le module sys), 105
W
write(), 86 writelines(), 87
S
squence, 51 bytes, 55 liste, 52 range, 55 slicing, 57 tuple, 52 search() (dans le module re), 98 shelve (module), 113 shelve.open() (dans le module shelve), 113 slicing, voir slicing (squence) sorted() (fonction de base), 75 split() (dans le module os.path), 102 split() (dans le module re), 98 sub() (dans le module re), 98 sum() (fonction de base), 75 sync() (mthode shelve.Shelf), 113 sys (module), 105
T
textdomain() (dans le module gettext), 115 typage, 18 dynamique, 18 faible, 18 fort, 18 statique, 18 type() (fonction de base), 47
U
uname() (dans le module os), 106
V
Vrication, 131 valeur de vrit, 59 Variable, 131 variable, 39, 42 affectation, 42 calcule, 42 multiple, 44 afchage, 43 identiant, 39 rfrence, 43 suppression, 45 version (dans le module sys), 105
Index
149

Cours Sur Python 3

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Cours Sur Python 3

Încărcat de

Drepturi de autor:

Formate disponibile

Livre Python

Table des matires

Concepts 9.1 Espaces de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9.2 Ramasse-miettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

24 Classes tendues 109 24.1 Itrateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

Indices and tables

Python Module Index Index

Livre Python, Version 1.0-draft

Table des matires

Livre Python, Version 1.0-draft

Table des matires

Livre Python, Version 1.0-draft

19. Goldszmidt (remarques sur le contenu).

Livre Python, Version 1.0-draft

Livre Python, Version 1.0-draft

Chapitre 3. Plan de louvrage

4.1 Prsentation du code

Livre Python, Version 1.0-draft

Livre Python, Version 1.0-draft

Livre Python, Version 1.0-draft

5.1 Interprt et compil

5.2 Haut niveau et bas niveau

Livre Python, Version 1.0-draft

Chapitre 5. Langages de programmation

6.1 Programmation imprative

6.2 Programmation procdurale

6.3 Programmation oriente objet

6.4 Programmation fonctionnelle

Livre Python, Version 1.0-draft

Livre Python, Version 1.0-draft

Chapitre 7. Introduction lalgorithmique

Programmation oriente objet

Livre Python, Version 1.0-draft

Chapitre 8. Programmation oriente objet

9.1 Espaces de noms 9.2 Ramasse-miettes

Livre Python, Version 1.0-draft

Livre Python, Version 1.0-draft

10.4 Autres conseils

1. Not Invented Here, NIH, en anglais

Chapitre 10. Mthodologie

1. Theres More Than One Way To Do It, un adage Perl.

Livre Python, Version 1.0-draft

Chapitre 11. Prsentation

12.1 Installation de Python

La sortie de la commande devrait tre quelque chose comme :

Livre Python, Version 1.0-draft

MacOS Linstallation laide de brew doit fonctionner :

12.2 Lancement et utilisation

12.2.1 Mode interactif

Chapitre 12. Installation et initialisation

Livre Python, Version 1.0-draft

12.2. Lancement et utilisation

Livre Python, Version 1.0-draft

Chapitre 12. Installation et initialisation

13.1 Tokens de structure

Livre Python, Version 1.0-draft

13.1.2 Blocs et indentation

Reprenant lexemple prcdent, mais avec une lgre erreur dindentation :

Chapitre 13. Bases et structure

Livre Python, Version 1.0-draft

Mais par piti, ne faites jamais a !

13.2 Autres tokens

13.2. Autres tokens

Livre Python, Version 1.0-draft