Cours et exerces pour apprendre à programmer avec Python
UNE INTRODUCTION àPYTHON 3
En se partageant le savoir ne se divise pas, il se multiplie.
Table des matières
1 Introduction 1
1.1 Principales caractéristiques du langage Python . 1
1.2 Matériel et logiciel . 2
1.2.1 L’ordinateur . . . . . . . . 2
1.2.2 Deux sortes de programmes . . . . . . . 2
1.3 Les langages . . . . 2
1.3.1 Des langages de différents niveaux . . . 2
1.3.2 Très bref historique des langages . . . . 3
1.4 Production des programmes . . . 3
1.4.1 Deux techniques de production des programmes . . . 3
1.4.2 Technique de production de Python . . . 3
1.4.3 La construction des programmes . . . . 4
1.5 Algorithme et programme . . . . 4
1.5.1 Définitions . . . . . . . . 4
1.5.2 La présentation des programmes . . . . 4
1.6 Les implémentations de Python . 4
2 La calculatrice Python 5
2.1 Les modes d’exécution . . . . . . 5
2.1.1 Les deux modes d’exécution d’un code Python . . . . . 5
2.2 Identificateurs et mots clés . . . . 5
2.2.1 Identificateurs . . . . . . . 5
2.2.2 Style de nommage . . . . 6
2.2.3 Les mots réservés de Python 3 . . . . . . 6
2.3 Notion d’expression . . . . . . . . 6
2.4 Les types de données entiers . . . 7
2.4.1 Le type int . . . . . . . . 7
2.4.2 Le type bool . . . . . . . . 8
2.5 Les types de données flo?ants . . 8
2.5.1 Le type float . . . . . . . 8
2.5.2 Le type complex . . . . . . 9
2.6 Variables et affectation . . . . . . 9
2.6.1 Les variables . . . . . . . 9
2.6.2 L’affectation . . . . . . . . 9
2.6.3 Affecter n’est pas comparer! . . . . . . . 10
2.6.4 Les variantes de l’affectation . . . . . . . 10
2.6.5 Représentation graphiques des affectations . . . . . . 11
2.7 Les chaînes de caractères . . . . . 11
2.7.1 Présentation . . . . . . . . 11
2.7.2 Opérations . . . . . . . . 12
2.7.3 Fonctions vs méthodes . . 12
2.7.4 Méthodes de test de l’état d’une chaîne . 12
2.7.5 Méthodes retournant une nouvelle chaîne . . . . . . . 13
2.7.6 Indexation simple . . . . . 14
2.7.7 Extraction de sous-chaînes . . . . . . . . 14
2.8 Les données binaires . . . . . . . 14
2.9 Les entrées-sorties . 15
v
vi TABLE DES MATIÈRES
2.9.1 Les entrées . . . . . . . . 15
2.9.2 Les sorties . 15
2.9.3 Les séquences d’échappement . . . . . . 16
3 Le contrôle du flux d’instructions 17
3.1 Les instructions composées . . . . 17
3.2 Choisir . . . . . . . 18
3.2.1 Choisir : if - [elif] - [else] . . . . . 18
3.2.2 Syntaxe compacte d’une alternative . . . 18
3.3 Boucles . . . . . . . 19
3.3.1 Répéter : while . . . . . . 19
3.3.2 Parcourir : for . . . . . . . 19
3.4 Ruptures de séquences . . . . . . 20
3.4.1 Interrompre une boucle : break . . . . . 20
3.4.2 Court-circuiter une boucle : continue . . 20
3.4.3 Utilisation avancée des boucles . . . . . 20
3.4.4 Traitement des erreurs — les exceptions . . . . . . . . 21
4 Les conteneurs standard 23
4.1 Les séquences . . . 23
4.1.1 ?’est-ce qu’une séquence? . . . . . . . 23
4.2 Les listes . . . . . . 23
4.2.1 Définition, syntaxe et exemples . . . . . 23
4.2.2 Initialisations et tests . . . 24
4.2.3 Méthodes . 24
4.2.4 Manipulation des « tranches » (ou sous-chaînes) . . . 24
4.2.5 Des séquences de séquences . . . . . . . 25
4.3 Les tuples . . . . . . 25
4.4 Retour sur les références . . . . . 25
4.4.1 Complément graphique sur l’assignation . . . . . . . . 26
4.5 Les tableaux associatifs . . . . . . 27
4.5.1 Les types tableaux associatifs . . . . . . 27
4.5.2 Les dictionnaires (dict) . 27
4.6 Les ensembles (set) . . . . . . . . 28
4.7 Les fichiers textuels . . . . . . . . 29
4.7.1 Introduction . . . . . . . . 29
4.7.2 Gestion des fichiers . . . . 29
4.8 Itérer sur les conteneurs . . . . . 30
4.9 L’affichage formaté . . . . . . . . 30
5 Fonctions et espaces de noms 33
5.1 Définition et syntaxe . . . . . . . 33
5.2 Passage des arguments . . . . . . 35
5.2.1 Mécanisme général . . . . 35
5.2.2 Un ou plusieurs paramètres, pas de retour . . . . . . . 35
5.2.3 Un ou plusieurs paramètres, un ou plusieurs retours . 35
5.2.4 Passage d’une fonction en paramètre . . 36
5.2.5 Paramètres avec valeur par défaut . . . 36
5.2.6 Nombre d’arguments arbitraire : passage d’un tuple de valeurs . . . 37
5.2.7 Nombre d’arguments arbitraire : passage d’un dictionnaire . . . . . . 37
5.3 Espaces de noms . . 37
5.3.1 Portée des objets . . . . . 37
5.3.2 Résolution des noms : règle « LGI » . . . 38
TABLE DES MATIÈRES vii
6 Modules et pa?ages 39
6.1 Modules . . . . . . 39
6.1.1 Import . . . 39
6.1.2 Exemples . 40
6.2 Bibliothèque standard . . . . . . . 41
6.2.1 La bibliothèque standard . 41
6.3 Bibliothèques tierces . . . . . . . 44
6.3.1 Une grande diversité . . . 44
6.3.2 Un exemple : la bibliothèque Unum . . . . 44
6.4 Paquets . . . . . . . 45
7 La Programmation Orientée Objet 47
7.1 Terminologie . . . . 47
7.1.1 Notations UML de base . . 48
7.2 Classes et instanciation d’objets . 48
7.2.1 L’instruction class . . . . 48
7.2.2 L’instanciation et ses a?ributs . . . . . . 48
7.2.3 Retour sur les espaces de noms . . . . . 49
7.3 Méthodes . . . . . . 50
7.4 Méthodes spéciales . . . . . . . . 50
7.4.1 L’initialisateur . . . . . . 50
7.4.2 Surcharge des opérateurs . . . . . . . . 50
7.4.3 Exemple de surcharge . . 51
7.5 Héritage et polymorphisme . . . . 51
7.5.1 Héritage et polymorphisme . . . . . . . 51
7.5.2 Exemple d’héritage et de polymorphisme . . . . . . . . 52
7.6 Notion de conception orientée objet . . . . . . . 52
7.6.1 Association . . . . . . . . 52
7.6.2 Dérivation . 53
7.7 Un exemple complet . . . . . . . . 54
8 La POO graphique 57
8.1 Programmes pilotés par des événements . . . . 57
8.2 La bibliothèque tkinter . . . . . . 58
8.2.1 Présentation . . . . . . . . 58
8.2.2 Les widgets de tkinter . . 58
8.2.3 Le positionnement des widgets . . . . . 59
8.3 Deux exemples . . . 59
8.3.1 tkPhone, un exemple sans menu . . . . . 59
8.3.2 IDLE, un exemple avec menu . . . . . . . 63
9 Te?niques avancées 65
9.1 Techniques procédurales . . . . . 65
9.1.1 Le pouvoir de l’introspection . . . . . . 65
9.1.2 Gestionnaire de contexte (ou bloc gardé) : . . . . . . . 68
9.1.3 Utiliser un dictionnaire pour lancer des fonctions ou des méthodes . 68
9.1.4 Les fonctions récursives . 69
9.1.5 Les listes définies en compréhension . . 69
9.1.6 Les dictionnaires définis en compréhension . . . . . . 70
9.1.7 Les ensembles définis en compréhension . . . . . . . . 70
9.1.8 Les générateurs et les expressions génératrices . . . . 71
9.1.9 Les fonctions incluses . . 72
9.1.10 Les décorateurs . . . . . . 72
9.2 Techniques objets . 73
9.2.1 Les Functors . . . . . . . . 74
9.2.2 Les accesseurs . . . . . . . 74
9.2.3 Le duck typing . . . . . . 77
9.3 Techniques fonctionnelles . . . . 78
9.3.1 Directive lambda . . . . . 78
viii TABLE DES MATIÈRES
9.3.2 Les fonctions map, filter et reduce . . . 78
9.3.3 Les applications partielles de fonctions . 79
9.4 La persistance et la sérialisation . 80
9.4.1 Sérialisation avec pickle et json . . . . . 80
9.4.2 Stockage avec sqlite3 . . 81
9.5 Les tests . . . . . . 82
9.5.1 Tests unitaires et tests fonctionnels . . . 82
9.5.2 Module unittest . . . . . 82
9.6 La documentation des sources . . 83
9.6.1 Le format reST . . . . . . 83
9.6.2 Le module doctest . . . . 84
9.6.3 Le développement dirigé par la documentation . . . . 86
A Interlude 91
B Passer du problème au programme 95
C Jeux de caractères et encodage 97
D Les bases arithmétiques 99
E Exercices corrigés 101
F Glossaire 113
Webographie 121
Bibliographie 122
Memento Python 3 124
Index 126
Avant-propos
À qui s’adresse ce cours ?
Utiliséàl’origineparlesétudiantsdeMesuresPhysiquesdel’IUTd’Orsay,cecourss’adresseplusgénéralement à toute personne désireuse d’apprendre Python en tant que premier langage de programmation.
Cette introduction reposent sur quelques partis pris :
- le choix du langage Python version 3. La version actuelle abolit la compatibilité descendanteavec la série des versions 2.x dans le but d’éliminer les faiblesses originelles du langage;
- le choix de logiciels libres ou gratuits :
– des éditeurs spécialisés comme ipython, spyder ou Wingware, – des outils open source de production de documents : LATEX, Inkscape, Dia.
- et sur l’abondance des ressources et de la documentation sur le Web!
Numéro de version ?
Suivant l’exemple de Donald K????, l’inventeur du logiciel de composition TEX, le numéro de la ie version de ce document, au lieu d’être « 1.1 » ou « 2.0 », est la ie décimale d’un nombre célèbre.
Pour joindre les auteurs :
k k
Sauf mention contraire, le contenu de cet ouvrage est publié sous la licence :
Creative Commons BY-NC-SA-3.0
La copie de cet ouvrage est autorisée sous réserve du respect des conditions de la licence
Ce premier chapitre introduit les grandes caractéristiques du langage Python, le replace dans l’histoire des langages informatiques, donne les particularités de production des programmes, définit la notion si importante d’algorithme et conclut sur les divers implémentations disponibles.
1.1 Principales caractéristiques du langage Python
- Historique
– 1991 : Guido van R????? travaille aux Pays-Bassur le projet AMOEBA, un système d’exploitation distribué. Il conçoit Python à partir du langage ABC et publie la version 0.9.0 sur un forum Usenet
– 1996 : sortie de Numerical Python
– 2001 : naissance de la PSF (Python So?ware Fundation)
– Les versions se succèdent Un grand choix de modules est disponible, des colloques annuels sont organisés, Python est enseigné dans plusieurs universités et est utilisé en entreprise
– Fin 2008 : sorties simultanées de Python 2.6 et de Python 3.0
– 2013 : versions en cours des branches 2 et 3 : v2.7.3 et v3.3.0
- Langage Open Source
– Licence Open Source CNRI, compatible GPL, mais sans la restriction copyle?. Donc Python est libre et gratuit même pour les usages commerciaux
– GvR (Guido van R?????) est le « BDFL » (dictateur bénévole à vie!)
– Importante communauté de développeurs
– Nombreux outils standard disponibles : Ba?eries included
- Travail interactif
– Nombreux interpréteurs interactifs disponibles
– Importantes documentations en ligne
– Développement rapide et incrémentiel
– Tests et débogage outillés
– Analyse interactive de données
- Langage interprété rapide
– Interprétation du bytecode compilé
– De nombreux modules sont disponibles à partir de bibliothèques optimisées (souvent écrites en C ou C++)
- Simplicité du langage (cf. Zen of Python, annexe A, p. 91) :
– Syntaxe claire et cohérente
– Indentation significative
– Gestion automatique de la mémoire (garbage collector)
– Typage dynamique fort : pas de déclaration
Introduction
- Orientation objet
– Modèle objet puissant mais pas obligatoire
– Structuration multifichier aisée des applications : facilite les modifications et les extensions
– Les classes, les fonctions et les méthodes sont des objets dits de première classe. Ces objets sont traités comme tous les autres (on peut les affecter, les passer en paramètre)
- Ouverture au monde
– Interfaçable avec C/C++/FORTRAN
– Langage de script de plusieurs applications importantes
– Excellente portabilité
- Disponibilité de bibliothèques
– Plusieurs milliers de packages sont disponibles dans tous les domaines
Remarque
3 Point fort de Python : la lisibilité.
Python est un « langage algorithmique exécutable ».
1.2 Environnements matériel et logiciel
1.2.1 L’ordinateur
On peut schématiser la définition de l’ordinateur de la façon suivante :
Définition b Ordinateur : automate déterministe à composants électroniques.
L’ordinateur comprend entre autres :
- un microprocesseur avec une UC (Unité de Contrôle), une UAL (Unité Arithmétique et Logique), une horloge, une mémoire cache rapide;
- de la mémoire volatile (dite vive ou RAM), contenant les instructions et les données nécessaires à l’exécution des programmes. La RAM est formée de cellules binaires (bits) organisées en mots de 8 bits (octets);
- des périphériques : entrées/sorties, mémoires permanentes (dites mortes : disque dur, clé USB, CDROM ), réseau
1.2.2 Deux sortes de programmes
On distingue, pour faire rapide :
- Le système d’exploitation : ensemble des programmes qui gèrent les ressources matérielles et logicielles. Il propose une aide au dialogue entre l’utilisateur et l’ordinateur : l’interface textuelle (interpréteur de commande) ou graphique (gestionnaire de fenêtres). Il est souvent multitâche et parfois multiutilisateur;
- les programmes applicatifs sont dédiés à des tâches particulières. Ils sont formés d’une série de commandes contenues dans un programme source qui est transformé pour être exécuté par l’ordinateur.
1.3 Les langages
1.3.1 Des langages de différents niveaux
- Chaque processeur possède un langage propre, directement exécutable : le langage machine. Il est formé de 0 et de 1 et n’est pas portable, c’est le seul que l’ordinateur puisse utiliser;
- le langage d’assemblage est un codage alphanumérique du langage machine. Il est plus lisible que le langage machine, mais n’est toujours pas portable. On le traduit en langage machine par un
assembleur ;
- les langages de haut niveau. Souvent normalisés, ils perme?ent le portage d’une machine à l’autre.
Ils sont traduits en langage machine par un compilateur ou un interpréteur.
1.4 Production des programmes 3
1.3.2 Très bref historique des langages
- Années 50 (approches expérimentales) : FORTRAN, LISP, COBOL, ALGOL
- Années 60 (langages universels) : PL/1, Simula, Smalltalk, Basic
- Années 70 (génie logiciel) : C, PASCAL, ADA, MODULA-2
- Années 80 (programmation objet) : C++, LabView, Eiffel, Perl, VisualBasic
- Années 90 (langages interprétés objet) : Java, tcl/Tk, Ruby, Python
- Années 2000 (langages commerciaux propriétaires) : C#,
Des centaines de langages ont été créés, mais l’industrie n’en utilise qu’une minorité.
1.4 Production des programmes
1.4.1 Deux te?niques de production des programmes
La compilation est la traduction du source en langage objet. Elle comprend au moins quatre phases (trois phases d’analyse — lexicale, syntaxique et sémantique — et une phase de production de code objet). Pour générer le langage machine il faut encore une phase particulière : l’édition de liens. La compilation est contraignante mais offre au final une grande vitesse d’exécution.
F????? 1.1 – Chaîne de compilation
Dans la technique de l’interprétation chaque ligne du source analysé est traduite au fur et à mesure en instructions directement exécutées. Aucun programme objet n’est généré. Ce?e technique est très souple mais les codes générés sont peu performants : l’interpréteur doit être utilisé à chaque nouvelle exécution
F????? 1.2 – Technique de l’interprétation
1.4.2 Te?nique de production de Python
- Techniquemixte:l’interprétationdubytecodecompilé.Boncompromisentrelafacilitédedéveloppement et la rapidité d’exécution;
- le bytecode (forme intermédiaire) est portable sur tout ordinateur muni de la machine virtuelle Python.
F????? 1.3 – Interprétation du bytecode compilé
Pour exécuter un programme, Python charge le fichier source .py (ou .pyw) en mémoire vive, en fait l’analyse (lexicale, syntaxique et sémantique), produit le bytecode et enfin l’exécute.
Afin de ne pas refaire inutilement toute la phase d’analyse et de production, Python sauvegarde le bytecode produit (dans un fichier .pyo ou .pyc) et recharge simplement le fichier bytecode s’il est plus récent que le fichier source dont il est issu.
En pratique, il n’est pas nécessaire de compiler explicitement un module, Python gère ce mécanisme de façon transparente.
Introduction
1.4.3 La construction des programmes
Le génie logiciel étudie les méthodes de construction des programmes. Plusieurs modèles sont envisageables, entre autres :
- la méthodologie procédurale. On emploie l’analyse descendante (division des problèmes) et remontante (réutilisation d’un maximum de sous-algorithmes). On s’efforce ainsi de décomposer un problème complexe en sous-programmes plus simples. Ce modèle structure d’abord les actions;
- la méthodologie objet. Centrée sur les données, elle est considérée plus stable dans le temps et meilleure dans sa conception. On conçoit des fabriques (classes) qui servent à produire des composants(objets)quicontiennentdesdonnées(a?ributs)etdesactions(méthodes).Lesclassesdérivent (héritage et polymorphisme) de classes de base dans une construction hiérarchique.
Python offre les deux techniques.
1.5 Algorithme et programme
1.5.1 Définitions
Définition
b Algorithme : ensemble des étapes perme?ant d’a?eindre un but en répétant un nombre fini de fois un nombre fini d’instructions.
Un algorithme se termine en un temps fini.
b Programme : un programme est la traduction d’un algorithme en un langage compilable ou interprétable par un ordinateur.
Il est souvent écrit en plusieurs parties dont une qui pilote les autres : le programme principal.
1.5.2 La présentation des programmes
Un programme source est destiné à l’être humain. Pour en faciliter la lecture, il doit être judicieusement présenté et commenté.
La signification de parties non triviales (et uniquement celles-ci) doit être expliquée par un commentaire. En Python, un commentaire commence par le caractère # et s’étend jusqu’à la fin de la ligne :
|
#--------------------# Voici un commentaire #---------------------  9 + 2 # En voici un autre |
1.6 Les implémentations de Python
Remarque
3 Une « implémentation » signifie une « mise en œuvre ».
- CPython : Classic Python, codé en C, implémentation portable sur différents systèmes
- Jython : ciblé pour la JVM (utilise le bytecode de JAVA)
- IronPython : , écrit en C#, utilise le MSIL (MicroSo? Intermediate Language)
- Sta?less Python : élimine l’utilisation de la pile du langage C (permet de récurser tant que l’on veut)
- Pypy : projet de recherche européen d’un interpréteur Python écrit en Python
Comme tout langage, Python permet de manipuler des données grâce à un vocabulaire de mots réservés et grâce à des types de données – approximation des ensembles de définition utilisés en mathématique.
Ce chapitre présente les règles de construction des identificateurs, les types de données simples (les conteneurs seront examinés au chapitre 4) ainsi que les types chaîne de caractères.
Enfin, last but not least, ce chapitre s’étend sur les notions non triviales de variable, de référence d’objet et d’affectation.
2.1 Les modes d’exécution
2.1.1 Les deux modes d’exécution d’un code Python
- Soit on enregistre un ensemble d’instructions Python dans un fichier grâce à un éditeur (on parle alors d’un script Python) que l’on exécute par une commande ou par une touche du menu de l’édi-
teur;
- soit on utilise l’interpréteur Python embarqué qui exécute la boucle d’évaluation (+ Fig. 2.1).
F????? 2.1 – La boucle d’évaluation de l’interpréteur Python
2.2 Identificateurs et mots clés
2.2.1 Identificateurs
Comme tout langage, Python utilise des identificateurs pour nommer ses objets.
Définition b Un identificateur Python est une suite non vide de caractères, de longueur quelconque, formée d’un caractère de début et de zéro ou plusieurs caractères de continuation.
Sachant que :
- le caractère de début peut être n’importe quelle le?re Unicode (cf. annexe C, p. 98), y compris le caractère souligné (_);
- un caractère de continuation est un caractère de début ou un chiffre.
Attention
j Les identificateurs sont sensibles à la casse et ne doivent pas être un mot réservé de Python 3.
2.2.2 Style de nommage
Il est important d’utiliser une politique cohérente de nommage des identificateurs. Voici le style utilisé dans ce document:
- UPPERCASE ou UPPER_CASE pour les constantes;
- TitleCase pour les classes;
- UneExceptionError pour les exceptions;
- camelCase pour les fonctions et les méthodes;
- unmodule_m pour les modules;
- lowercase ou lower_case pour tous les autres identificateurs. Exemples :
NB_ITEMS = 12 # UPPER_CASE class MaClasse : pass # TitleCase def maFonction() : pass # camelCase
mon_id = 5 # lower_case
Pour ne pas prêter à confusion, éviter d’utiliser les caractères l (minuscule), O et I (majuscules) seuls. Enfin, on évitera d’utiliser les notations suivantes :
_xxx # usage interne
__xxx # attribut de classe
__xxx__ # nom spécial réservé
2.2.3 Les mots réservés de Python 3
La version 3.3.0 de Python compte 33 mots clés :
and del from None True
as elif global nonlocal try assert else if not while break except import or with class False in pass yield continue finally is raise def for lambda return
2.3 Notion d’expression
Définition
b Une expression est une portion de code que l’interpréteur Python peut évaluer pour obtenir une
valeur.
Les expressions peuvent être simples ou complexes. Elles sont formées d’une combinaison de li?éraux représentant directement des valeurs, d’identificateurs et d’opérateurs.
Exemples de deux expressions simples et d’une expression complexe :
>>> id1 = 15.3
>>> >>> id2 = maFonction(id1)
>>>
>>> if id2 > 0: id3 = (id2) else :
id4 = id1 - 5.5*id2
2.4 Les types de données entiers
2.4 Les types de données entiers
Python 3 offre deux types entiers standard : int et bool.
2.4.1 Le type int
Le type int n’est limité en taille que par la mémoire de la machine.
Les entiers li?éraux sont décimaux par défaut, mais on peut aussi utiliser les bases suivantes (cf. annexe D, p. 99) :
>>> 2013 # décimal
2013
>>> 0b11111011101 # binaire
2013
>>> 0o3735 # octal
2013
>>> 0x7dd # hexadecimal
2013
Opérations arithmétiques
Les principales opérations :
>>> 20 + 3 23
>>> 20 - 3 17
>>> 20 * 3
60
>>> 20 ** 3
8000
>>> 20 / 3
6.666666666666667
>>> 20 // 3 # division entière
6
>>> 20 % 3 # modulo
2
>>> abs(3 - 20) # valeur absolue
17
Bien remarquer le rôle des deux opérateurs de division : / : produit une division flo?ante, même entre deux entiers; // : produit une division entière.
Bases usuelles
Un entier écrit en base 10 (par exemple 179) peut se représenter en binaire, octal et hexadécimal en utilisant les syntaxes suivantes :
>>> 0b10110011 # binaire
179
>>> bin(179) '0b10110011'
>>> 0o263 # octal
179
>>> oct(179)
'0o263'
>>> 0xB3 # hexadécimal
179
>>> hex(179)
'0xb3'