Programmation Python

Syllabus INFO-F-101 Programmation Release 3.4.
0 (2015)
Thierry Massart
August 21, 2015
CONTENTS
Prsentation du cours
1.1 Avant-propos . . . . . . . . . . . . . . .
1.2 But du cours . . . . . . . . . . . . . . .
1.3 Comptences principales vises . . . . .
1.4 Ressources . . . . . . . . . . . . . . . .
1.5 Pourquoi Python ? (et pas C++, Java, ...)
1.6 Un peu de vocabulaire . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
1
2
3
3
3
Mon premier programme Python

2.1 Notions fondamentales . . . . . . . . . . . .
2.2 Python pour faire des calculs . . . . . . . . .
2.3 Erreur syntaxique . . . . . . . . . . . . . . .
2.4 Python pour manipuler du texte . . . . . . .
2.5 Variables et assignation . . . . . . . . . . .
2.6 print() . . . . . . . . . . . . . . . . . . . . .
2.7 Types . . . . . . . . . . . . . . . . . . . . .
2.8 input() . . . . . . . . . . . . . . . . . . . .
2.9 Commentaires . . . . . . . . . . . . . . . .
2.10 Assignation multiple et assignation de tuples
2.11 Autres fonctions prdfinies intressantes . .
2.12 Mon premier programme complet . . . . . .
2.13 Smantique prcise de lassignation . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5
5
5
7
7
8
9
10
11
11
12
12
13
14
Contrle de flux (instructions if et while)

3.1 Conditions et instruction conditionnelle if
3.2 Instruction pass . . . . . . . . . . . . . .
3.3 Instruction rptitive while . . . . . . . .
3.4 Instruction for . . . . . . . . . . . . . .
3.5 break et continue . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
17
17
21
21
24
24
.
.
.
.
.
25
25
26
27
28
30
.
.
.
.
.
.
.
.
.
.
Dfinition de nouvelles fonctions

4.1 Fonction retournant une valeur . . . . . . . . . . . . . . . . . . . .
4.2 Type des paramtres et du rsultat . . . . . . . . . . . . . . . . . .
4.3 Fonction ne retournant pas de valeur . . . . . . . . . . . . . . . . .
4.4 Excution de la fonction appele (passage de paramtres par valeur)
4.5 Espace de noms (namespace), variables locales et globales . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4.6
4.7
5
Passage de fonction comme argument et fonction lambda . . . . . . . . . . . 32

Valeur par dfaut pour les paramtres et argument mots-cls . . . . . . . . . . 32
Chanes de caractres (strings), tuples, listes et instruction for

5.1 Chanes de caractres (strings) . . . . . . . . . . . . . . . . .
5.2 Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3 Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.4 Instruction for . . . . . . . . . . . . . . . . . . . . . . . . .
5.5 Autres oprations et mthodes sur les squences, strings, listes
5.6 Comprhension de liste (list comprehension) . . . . . . . . .
5.7 Copie de listes complexes et rference cyclique . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
33
33
36
38
46
47
48
49
Conception dalgorithmes simples

6.1 Rcurrences simples . . . . . . . . . . . . . .
6.2 Manipulation de squences . . . . . . . . . . .
6.3 argv et eval . . . . . . . . . . . . . . . . . . .
6.4 Polygones rguliers avec le module turtle . . .
6.5 Cration dun module de gestion de polynmes
6.6 Tableaux plusieurs dimensions . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
55
55
59
62
63
64
69
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Ensembles et Dictionnaire
71
7.1 Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
7.2 Dictionnaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
7.3 Changement de type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Recherches et tris
83
8.1 Les classiques : recherches . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
8.2 Les classiques : tris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Notion de complexit et grand O

9.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . .
9.2 Le grand O . . . . . . . . . . . . . . . . . . . . . . . .
9.3 Application des rgles de calcul . . . . . . . . . . . . .
9.4 Complexit des mthodes de manipulation de squences
10 Logique, invariant et vrification dalgorithme

10.1 Introduction . . . . . . . . . . . . . . . . .
10.2 Rappel de logique . . . . . . . . . . . . . .
10.3 Exprimer ltat du programme formellement
10.4 Preuve partielle et totale . . . . . . . . . . .
10.5 Exemples de preuves dalgorithmes . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
95
95
101
108
113
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
117
117
118
121
126
129
11 Rcursivit
11.1 Motivation et introduction du concept . . . . . . . .
11.2 Mcanismes . . . . . . . . . . . . . . . . . . . . .
11.3 Structures de donnes rcursives . . . . . . . . . . .
11.4 Traduction de fonction rcursive en fonction itrative
11.5 Gestion de la mmoire lexcution . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
133
133
136
140
142
143
ii
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12 Fichiers, persistance et Exceptions

157
12.1 Fichiers et persistance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
12.2 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
13 Classes et objets
167
13.1 Objet et classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
13.2 Dfinition de nouvelles classes . . . . . . . . . . . . . . . . . . . . . . . . . . 168
13.3 Programmation oriente objet . . . . . . . . . . . . . . . . . . . . . . . . . . 178
14 Quelques mots sur les langages de programmation
14.1 Introduction . . . . . . . . . . . . . . . . . .
14.2 Les langages de programmation . . . . . . . .
14.3 Paradigmes des langages de programmation . .
14.4 Histoire des langages de programmation . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
179
179
185
189
190
15 Rgles de bonnes pratiques pour encoder en Python

199
15.1 PEP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
15.2 Convention de codage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
15.3 Rgles de bonnes pratiques pour concevoir un programme . . . . . . . . . . . 202
16 Glossaire
17 Aide-mmoire Python 3.2 - (version Octobre 2012)
17.1 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . .
17.2 Modules . . . . . . . . . . . . . . . . . . . . . . . . . .
17.3 Oprations et mthodes sur les squences (str, list, tuples)
17.4 Mthodes sur les str . . . . . . . . . . . . . . . . . . . .
17.5 Oprateurs et mthodes sur les listes s . . . . . . . . . . .
17.6 Mthodes sur les dict . . . . . . . . . . . . . . . . . . . .
17.7 Mthodes sur les fichiers . . . . . . . . . . . . . . . . . .
17.8 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . .
Index
205
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
211
211
211
212
212
213
213
214
214
215
iii
iv
CHAPTER
ONE
PRSENTATION DU COURS
1.1 Avant-propos
Author Thierry Massart <tmassart@ulb.ac.be>
Version 2.1.3
Date August 21, 2015
Copyright This document has been placed in the public domain.
1.2 But du cours

Le but premier de ce cours et des exercices associs est de donner aux tudiants une connaissance active de lalgorithmique de base et de la programmation structure. Le formalisme
utilis pour dcrire les programmes dvelopps dans ce cours est le langage de programmation
Python.
Notons que, bien quune certaine partie de la syntaxe et smantique du langage Python soit
tudie, ce cours nest pas simplement un manuel de programmation Python. De nombreuses
parties de Python ny sont dailleurs pas tudies.
Les concepts de base Python utiliss dans le cadre de ce cours pour crire un algorithme ou un
programme Python rsolvant un problme algorithmique donn sont peu nombreux. Le cours
thorique sert expliquer ces concepts. Il ne vous est pas seulement demand de comprendre
ces notions de base, mais galement de les assimiler et de pouvoir les utiliser pour concevoir et
dans une moindre mesure analyser, des programmes Python rsolvant les problmes poss. La
rsolution de nombreux exercices ainsi que les travaux effectuer vous permettront darriver
une connaissance de lalgorithmique beaucoup plus profonde, requise au terme de ce cours.
Cette matire doit donc tre pratique de faon constante la fois pendant et en dehors des
sances dexercices sur papier et sur machine. Une tude entirement comprise dans une courte
priode de temps ne peut pas aboutir au but final requis.
De faon complmentaire, ce cours aborde dautres aspects essentiels pour matriser la matire:
nous y verrons comment valuer lefficacit dun algorithme (complexit); nous verrons galement comment dcrire formellement ltat dun programme et des bribes de la thorie visant
Syllabus INFO-F-101 Programmation -, Release 3.4.0 (2015)

prouver quun programme est correct; nous placerons galement Python dans le paysage des
langages la fois au niveau historique et pour les concepts et paradigmes manipuls.
Note: Le cours ne vise donc pas passer en revue densemble des notes mises votre disposition. Lordre de prsentation ainsi que les lments prsents au cours peuvent diffrer de
celui donn dans ces pages. Ltudiant est invit lire ces notes ainsi que les rfrences donnes ci-dessous, en particulier le livre de Grard Swinnen sur Python 3 (principalement les 11
premiers chapitres), avant dassister au cours.
1.3 Comptences principales vises

Si vous avez suivi avec fruit le cours, vous aurez amliorer les comptences suivantes :
Lapprentissage autonome : vous serez dans une dynamique dapprentissage autonome
et permanent dans ce domaine en constante et rapide volution quest linformatique ;
vous pouvez vous adapter tout au long de votre carrire aux technologies nouvelles. Par
exemple, vous apprendrez, en vous rfrant aux manuels.
La rsolution de problmes : vous aurez la capacit danalyser des besoins, de structurer linformation, de concevoir, modliser et implmenter des solutions pertinentes
et efficaces ; de faon plus globale on vous demandera dans les cours dinformatique
dacqurir la pense informatique (computational thinking) en tant capable de faire
des abstractions adquates pour un problme, et dallier la thorie la pratique avec
lordinateur comme support;
La communication : vous pourrez comprendre les problmes poss, et expliquer les solutions proposes ; vous pourrez utiliser la communication scientifique et technique (formalismes mathmatiques).
En particulier vous pourrez:
dmontrer une bonne comprhension des concepts de base de Python ainsi que lire et
comprendre des programmes existants
analyser un problme simple et proposer une solution informatique pour le rsoudre et la
mettre en oeuvre en Python
exprimer formellement, en formalisme logique, les fonctionnalits attendues dun programme informatique
utiliser des outils informatiques de support la programmation; exploiter la documentation technique
raliser des programmes Python corrects et bien structurs
identifier les cas de test pour valider ces programmes.
Chapter 1. Prsentation du cours
1.4 Ressources
Ces pages
le livre de Grard Swinnen sur Python 3 (pour la premire partie du cours)
lUniversit Virtuelle (exercices, anciens examens, codes sources, ventuels complments de matire)
python.org (tutoriel, manuels, download, ...)
un environnement python 3.2, ainsi quun diteur simple comme gedit
le site de test upylab
le syllabus dexercices
Pour ceux qui veulent faire des calculs numriques : python2.7 avec pylab, numpy, scipy,
mathplotlib, ....
1.5 Pourquoi Python ? (et pas C++, Java, ...)

Python est un langage cr dbut des annes nonante par Guido van Rossum
de haut niveau multi-paradigmes (programmation imprative, oriente-objet, fonctionnelle,...)
qui permet dillustrer rapidement et simplement de nombreux concepts de programmation
portable
interprt
dot dun typage dynamique fort, dun Garbage collector (ramasse-miettes) et dune
gestion des exceptions
Ces concepts seront expliqus lors du cours.
1.6 Un peu de vocabulaire

Le but de linformatique est deffectuer du traitement de linformation.
Linformation est un ensemble dlments qui ont une signification dans le contexte tudi.
Les donnes dun problme sont reprsentes par lensemble des informations utilises pour
rsoudre ce problme en vue dobtenir les rsultats escompts.
Un algorithme nest pas conu uniquement pour obtenir un rsultat pour une donne bien prcise, mais constitue une mthode qui permet, partir de nimporte quelle autre donne du mme
type, dobtenir le rsultat correspondant.
1.4. Ressources
Un problme algorithmique peut tre vu comme une fonction f dont limage de toute donne
d de lensemble D des donnes possibles est un rsultat r (= f(d)) de lensemble R des
rsultats possibles.
Lalgorithme qui rsout le problme est la mthode calculant f(d) en un temps fini, pour toute
donne d valide.
Notons quil nexiste pas dalgorithme pour tout problme (Il est donc intressant de dterminer
thoriquement lexistence dun algorithme pour un problme donn avant dessayer de lcrire
effectivement). A ct de cela, il existe souvent de nombreux algorithmes pour rsoudre un
problme donn; leurs qualits propres permettront de les diffrencier.
Un algorithme doit tre implment sur un ordinateur. Celui-ci ne possde jamais quun nombre limit de mmoire de stockage dinformation dont la prcision est limite. De ce fait pour
rsoudre certains problmes qui en thorie pourraient requrir un calcul trop long, ou une prcision ou un stockage dinformation trop importants, des algorithmes ne donnant quune valeur
approche du rsultat doivent tre conus.
Ecrire un petit programme ou a fortiori dvelopper un gros logiciel demande une dmarche en
plusieurs tapes, appele processus de dveloppement dun programme, qui peut tre divis en
plusieurs phases (partiellement) successives.
1. Analyse de ce qui est requis et spcification,
2. Conception,
3. Implmentation,
4. Tests et installation,
5. Exploitation et maintenance.
Chaque phase produit des rsultats crits soit sous forme de rapport : spcification de ce qui
est requis (cahier de charges), manuel utilisateur, description du fonctionnement, description
succincte ou dtaille de lalgorithme, programme dment comment, historique des modifications, ....
Ce cours nabordera par tous ces points en dtails.
Chapter 1. Prsentation du cours
CHAPTER
TWO
MON PREMIER PROGRAMME

PYTHON
See Also:
Lire les chapitres 1, 2 et 6 pour print() et input() du livre de Grard Swinnen sur Python
3
2.1 Notions fondamentales

Nous avons dcrit lalgorithme comme tant une mthode de calcul dune fonction f. Cette
description donne une vue extrieure dun algorithme.
Si nous regardons lintrieur dun algorithme, la notion fondamentale est celle daction. Une
action a une dure finie et un effet bien prcis. Chaque action utilise une ou plusieurs entits ;
les changements dtats de ces entits sont les marques laisses par les actions.
Pour pouvoir dcrire cela, il faut que chaque action soit descriptible dans un langage:
Soit une action est simple ; on peut alors la dcrire sous forme dune instruction.
Soit elle est trop complexe pour tre dcrite en une instruction, elle doit alors tre dcompose en plusieurs instructions : le groupement de ces instructions est appel processus. Si
chaque instruction dun processus se suit lune lautre dans son droulement, le processus est
dit squentiel.
Un algorithme ou programme est linstruction, (au sens large) qui dcrit un processus complet. Lordre dcriture de lensemble des instructions dun algorithme ou dun programme est
gnralement diffrent de lordre dexcution de celles-ci.
Un programme Python dcrit un tel processus. Regardons quelques programmes simples pour
comprendre son fonctionnement.
2.2 Python pour faire des calculs

Aprs avoir install lenvironnement Python (nous utilisons ici la version 3.2), vous pouvez
dialoguer directement au clavier avec linterprteur Python en tapant depuis la ligne de com5
mande (dans un shell) la commande python3 ou python si la version par dfaut sur votre
ordinateur est la bonne.
Le prompt >>> invite lutilisateur taper une instruction Python. Toute commande ou instruction est envoye lordinateur en tapant la touche return.
La session suivante donne un exemple dutilisation du mode interactif pour faire des calculs
simples.
litpc30:~ tmassart$ python3
Python 3.2.3 (v3.2.3:3d0686d90f55, Apr 10 2012, 11:25:50)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 5 + 7
12
>>> 2 - 11
-9
>>> 7 + 3 * 2
13
>>> (7+3) * 2
20
>>> 20 /3
6.666666666666667
>>> 20 // 3
6
>>> -20 // 3
-7
>>> -20//-3
6
>>> 20//-3
-7
>>> 11/3
3.6666666666666665
>>> 9/3
3.0
>>> 3.14 * 5**2
78.5
>>> 3.14159 * 5**2
78.53975
>>> 3.14159 ** 100
5.187410133839704e+49
>>> 9 % 2
1
>>> exit()
litpc30:~ tmassart$
Note: les valeurs comme 5, 7, 3.14 sont appeles constantes ou littraux (literal).
Note: la fonction quit() ou exit() permet de clturer la session et revenir au prompt (symbole
dinvite) du shell.
6
Chapter 2. Mon premier programme Python
2.3 Erreur syntaxique

Malheureusement lutilisateur (le programmeur) peut commettre des erreurs (bugs) dans ce
quil demande lordinateur.
Tout dabord, le texte tap peut ne pas correspondre du code Python correct:
car le caractre ne correspond pas loprateur de division en Python (il fallait utiliser /
pour la division ou // pour la division entire plancher).
Comme indiqu par lenvironnement Python, une erreur de syntaxe a t dtecte.
Note: Les nombres sont reprsents avec la convention anglo-saxonne (avec pour les valeurs
trs grandes ou trs petites, une certaine prcision et en notation scientifique (exemple e+49)).
Les expressions sont values en utilisant les notions dassociativit et de priorit habituelles
ainsi que des parenthses pour modifier lordre dvaluation. Pour les dfinitions prcises sur le
fonctionnement des diffrents oprateurs, vous devez vous rfrer aux pages Python Standard
Library du site python.org
Note: Les oprateurs arithmtiques les plus frquemment utiliss sont + (addition), - (soustraction), * (multiplication), / (division relle), // (division entire plancher), ** (exponentiation), % (modulo) ainsi que += (incrmentation) -= (dcrmentation) *= (multiplication par
w), /= (division par w).
Note: Attention, les oprateurs habituels sont tous associatifs gauche sauf lexponentiation
qui est associatif droite (essayez 2**2**3)
2.4 Python pour manipuler du texte

Les valeurs et variables textes sont appeles chanes de caractres ou strings en anglais (classes
str Python). Une valeur de type string est reprsente sous forme de texte dlimit par des
doubles apostrophes "du texte" ou par des simples apostrophes un autre texte.
>>> type("bonjour")
<class str>
Les oprateurs + et * peuvent tre utiliss sur du texte et ont comme smantique la concatnation (mise bout bout des textes) et la rptition.
>>> cha+peau
chapeau
2.3. Erreur syntaxique
>>> "ha"*5
hahahahaha
2.5 Variables et assignation

Lexemple suivant illustre lexcution dun programme simple manipulant des variables.
>>>
>>>
>>>
>>>
>>>
>>>
>>>
(6,
x = 3
y = 12
z = x
x = 2 * x
y = 2 * y
z = x * y
x, y, z
24, 144)
Le programmeur utilise 3 variables quil a nommes x, y et z. Chaque variable est une

rfrence une adresse mmoire o est stock la valeur correspondante 1 .
Le nom (appel identificateur) de chaque variable est choisi assez librement par le programmeur
tout en respectant un ensemble de rgles prcis par rapport sa syntaxe et en vitant de choisir
un mot-cl (voir livre de Grard Swinnen sur Python 3 pour une explication simple ou The
Python Language Reference pour une dfinition complte de la syntaxe des identificateurs et la
liste complte des mots-cls Python).
Par exemple une variable ne peut sappeler if qui, comme on le verra plus tard, est un mot-cl
du langage Python.
>>> if=3
File "<stdin>", line 1
if=3
^
SyntaxError: invalid syntax
Un type daction essentiel en Python (et dans la plupart des langages de programmation) est
lassignation galement appele affectation.
Lopration dassignation a la forme:
v=w
o w est une expression donnant une valeur et v est le nom dune variable.
Dans une premire approximation cette opration consiste mettre la valeur w dans la variable
v
Ainsi la squence dinstructions donnera les valeurs suivantes pour les variables, o ? signifie
que la variable nexiste pas (et donc que sa valeur est indfinie):
1
Plus prcisment lobjet qui contient la valeur mais aussi dautres attributs, comme nous le verrons plus loin.

instruction
x=3
y = 12
z=x
x=2*x
y=2*y
z=x*y
(6, 24, 144)
x
3
3
3
6
6
6
6
y
?
12
12
12
24
24
24
z
?
?
3
3
3
144
144
Notons que la dernire instruction x, y, z a comme seul effet, dans lenvironnement interactif, dafficher les valeurs correspondantes (ici du tuple (x, y, z)).
2.6 print()
Linterprteur Python a un certain nombre de fonctions prdfinies sa disposition (voir la
liste dans la documentation de la Python Standard Library du site python.org ). Nous verrons
certaines de ces fonctions. Commenons par les fonctions print(), float() et input().
Quand le programmeur dsire, non pas faire des tests ou petits calculs rapides, mais crire
un programme complet, il dite un fichier qui par convention porte un suffixe py, contenant
son code Python. Je peux par exemple sauver le fichier mon-premier-programme.py du
code de mon premier programme sur disque (ou tout autre moyen de stockage) pour ensuite
lexcuter sur mon ordinateur en tapant la ligne de commande
python3 mon-premier-programme.py
Lexcution se fait en mode script par opposition au mode interactif.
Warning: Vos fichiers Python doivent tre sauvs dans lencodage UTF-8 (voir livre de
Swinnen pour plus dexplications). Nous vous conseillons dutiliser lditeur gedit pour
crire vos programmes Python.
Aprs un court instant, le prompt de la ligne de commande saffiche ce qui montre que
lexcution est termine: rien na t affich.
litpc30:Exemples-cours tmassart$ python3 mon-premier-programme.py
litpc30:Exemples-cours tmassart$
Si lon veut, en mode script, visualiser un rsultat dans la fentre de commande, le programme
doit utiliser linstruction
print()
par exemple, si lon remplace la dernire ligne par:
>>> print(x, y, z)
on obtient
2.6. print()
litpc30:Exemples-cours tmassart$ python3 mon-premier-programme-corr.py

6 24 144
litpc30:Exemples-cours tmassart$
Note: Le tutoriel sur python 3.2 (section Fancier Output Formatting) illustre les possibilits
dcriture quoffre le langage
2.7 Types
En Python, les objets ont un type. Lors de la cration, dun nouvel objet, son type est dfini en
fonction de lobjet cr. Plus prcisment, Python est un langage orient-objet: on dit que les
entits cres sont des objets dune certaine classe.
Les types les plus habituellement manipuls sont entier (integer), rel ou plus prcisment
nombre virgule flottante (float), boolen ou logique (boolean), chane de caractres (string).
Linstruction Python
type(x)
o x est un objet, permet de connatre la classe de x.
>>> x = 3
>>> y = x / 2
>>> type(x)
<class int>
>>> type(y)
<class float>
Les exemples prcdents nutilisent que des objets (de type) entiers et rels. Lexemple suivant
manipule dautres types.
>>> t="Ceci est un exemple de texte"
>>> t2="Cest important de faire attention aux apostrophes"
>>> flag = t == t2
>>> print(t, t2, flag)
Ceci est un exemple de texte Cest important de faire attention aux apostrophes
>>> type(t)
<class str>
>>> type(t2)
<class str>
>>> type(flag)
<class bool>
Si la traduction a un sens, il est possible et peut tre utile de prendre une valeur dun certain
type et den construire une valeur correspondante dans un autre type. Par exemple
>>> r= 3.14
>>> r2 = int(r)
>>> print(r,r2)
10
3.14 3
>>> c = 52
>>> i = int(c)
>>> type(c)
<class str>
>>> type(i)
<class int>
Une premire application est la lecture de valeurs, comme expliqu dans la section suivante.
2.8 input()
Comme dj expliqu, un algorithme ou un programme peut tre vu comme une mthode pour
rsoudre un problme spcifi. Gnralement, le programme reoit des donnes et renvoie
des rsultats. Linstruction input() permet de lire des donnes lors de lexcution du programme.
x = input("un texte qui invite lutilisateur entrer une
donne")
Aprs cette instruction x contient le texte envoy par lutilisateur du programme et lu par le
programme.
Prenons lexemple dun programme dont le but est de trouver les ventuelles racines dune
quation du second degr. Pour recevoir les trois valeurs relles on pourra crire
>>> a= float(input(valeur de a : ))
>>> b= float(input(valeur de b : ))
>>> c= float(input(valeur de c : ))
float() traduit le texte lu en valeur relle sil correspond bien un rel dans une syntaxe
correcte
2.9 Commentaires
Un programme Python doit tre syntaxiquement correct pour tre comprhensible par
lordinateur (linterprteur qui le lit et lexcute); il doit galement tre lisible pour le programmeur ou toute personne qui aurait envie de comprendre son fonctionnement.
Pour cela, il est important que le programmeur crive dans son code des commentaires pertinents. Une faon de faire est de mettre le caractre #: tout ce qui suit sur la ligne ne sera ignor
par linterprteur.
# calcule le pourcentage de lheure coule
percent = (minute * 100) / 60
v = 5
# vitesse en mtres / secondes
Pour avoir des commentaires plus long quune ligne ou un fin de ligne, les commentaires multilignes peuvent tre utiliss
2.8. input()
11
"""
Exemple de commentaire multiligne
que lon peut mettre dans un programme Python
...
"""
Nous verrons que les commentaires multilignes permettent de documenter les fonctions crites
par le programmeur qui pourra redemander ces informations plus tard.
2.10 Assignation multiple et assignation de tuples

Python permet dassigner plusieurs variables en mme temps
>>> x = y = 3
On peut aussi faire des assignations parallles

>>> min, max = 4, 7
>>> x, y = y, x
Attention, ici la virgule est un dlimiteurs des lments dune liste et srement pas le dlimiteur entre la partie entire et la partie fractionnaire dun nombre (Python utilise la convention
scientifique et anglaise pour cela).
2.11 Autres fonctions prdfinies intressantes

abs(x)
dir(objet)
divmod(x,y)
eval(expression)
float(x)
help(x)
input()
int(x)
max(a,b,...)
min(a,b,...)
print()
round(x,y)
type(objet)
12
Voir dfinition dans le manuel du Python Standard Library du site python.org

Note: Les fonctions help() et dir() donnent des exemples dintrospection que le programmeur peut utiliser (essayez par exemple help(print) aprs avoir import le module,
en utilisant ventuellement la barre despace pour passer la suite de lexplication et la
touche q pour terminer).
2.12 Mon premier programme complet

Voici un premier programme complet
"""
Calcule la circonfrence et la surface
dun cercle de rayon lu sur input
"""
__author__ = "Thierry Massart"
__date__ = "18 aot 2011"
from math import pi
rayon= int(input(rayon = ))
circ = 2.0 * pi * rayon
surface = pi * rayon**2
print(circonfrence = , circ)
print(surface = , surface)
#
#
#
#
rentrer
calcule
calcule
imprime
la donne
la circonfrence
la surface
les rsultats
__author__ et __ date__ sont des variables classiquement utilises pour identifier

lauteur et la date dcriture du programme.
2.12.1 Module math

Le module math contient de nombreuses constantes et fonctions prdfinies bien utiles telles
que :
pi cos(x) sin(x) sqrt(x) log(x,b)
Pour utiliser un module python, il faut limporter; par exemple avec :
>>> import math
>>> math.cos(math.pi / 4)
0.70710678118654757
>>> math.log(1024, 2)
10.0
ou par exemple
>>> import math as m
>>> m.cos(m.pi/4)
2.12. Mon premier programme complet
13
0.70710678118654757
>>> m.log(1024, 2)
10.0
ou encore
>>> from math import pi, cos, log
>>> cos(pi/4)
0.70710678118654757
>>> log(1024, 2)
10.0
Warning: Python permet de faire limportation de tous les lments dun module (exemple:
from math import *): ceci est fortement dconseill car
ne permet pas de savoir do vient les lments que lon utilise ensuite,
peut cacher des lments existants qui ont le mme nom
rend le code difficile debugger quand un symbole est indfini
peut provoquer des clashs entre plusieurs noms
Warning: Apprendre python : Plus important que davoir une connaissance encyclopdique de Python, il est important de pouvoir trouver linformation que lon cherche
et donc avoir une bonne mthode de recherche dinformation. Une recherche du contenu du
module math via dir(math), help(math), une recherche rapide (quich search) ou approfondie dans la documentation python (Tutorial, Library Reference, Language Reference)
ou un bon livre sur python est un bon exemple pour vous entraner. La mthode exprimentale (tester ce que fait une fonction, ...) constitue un complment important toutes ces
dmarches.
2.13 Smantique prcise de lassignation

Note: Cette section est cruciale la comprhension du fonctionnement de Python.
Leffet plus prcis dune affectation peut tre dcompos en 3 tapes:
si w nest pas une rfrence un objet dj existant, valuer la valeur w et crer un objet
Python qui mmorise cette valeur ainsi que son type (et dautres attributs)
crer et mmoriser un nom de variable v
tablir le lien (par un systme interne de pointeur) entre le nom de la variable (v) et
lobjet contenant la valeur correspondant w correspondante. Donc v contient ladresse
en mmoire de lobjet contenant la valeur correspondant w. Ceci est illustr par une
flche entre v et lobjet.
Le rsultat est illustr par le diagramme dtat suivant:
14
variable
objet contenant
la valeur w
Attention: dans une instruction dassignation, la variable assigne est toujours gauche sur
signe = et la valeur toujours droite !
Dans lexemple:
>>>
>>>
>>>
>>>
>>>
>>>
x
y
z
x
y
z
=
=
=
=
=
=
3
12
x
2 * x
2 * y
x * y
les instructions x = 3 et y = 12 crent 2 variables qui rfrencient respectivement un objet

de type entier valant 3 et un autre galement de type entier valant 12.
Linstruction z = x ne cre aucun nouvel objet; mais la variable z est cre et reoit la valeur
de x, cest--dire la rfrence vers lobjet de type entier et valant 3.
Aprs ces 3 premires instructions, le diagramme dtat suivant illustre la situation:
z
x
12
A la fin du programme entier, 5 objets (de type) entiers ont t crs, dont ceux valant 6, 24 et
144 sont rfrencs respectivement par les variables x, y et z. Les objets valant 3 et 12 ne sont
plus accessibles et donc potentiellement rcuprs par le systme (garbage collector).
2.13. Smantique prcise de lassignation
15
12
24
144
inaccessible et donc
rcupr par le systme
2.13.1 Incrmentation
Lincrmentation (respectivement la dcrmentation) dune variable x est le fait daugmenter
(resp. diminuer) sa valeur (gnralement dune unit).
le diagramme dtat de
>>> x = 3
>>> x = x + 1
donne donc:
et implique la cration de 2 objets de type (classe) int : lun valant 3 et lautre 4 .

Note: Le fonctionnement prcis de lassignation, sera important pour comprendre le fonctionnement gnral dun programme Python
16
CHAPTER
THREE
CONTRLE DE FLUX (INSTRUCTIONS

IF ET WHILE)
See Also:
Lire les chapitres 3 et 4 du livre de Grard Swinnen sur Python 3
Un programme dans un langage impratif comme lest le langage Python excute une squence
dinstructions dans un certain ordre. Jusqu prsent, les programmes prsents excutaient les
instruction en squence.
>>>
>>>
>>>
>>>
a, b = 3, 7
a = b
b = a
print(a,b)
donne un rsultat diffrent de

>>>
>>>
>>>
>>>
a, b = 3, 7
b = a
a = b
print(a,b)
Lordre dexcution, appel flux dexcution, peut tre modifi par des instructions dites composes. Nous allons voir ici les instructions conditionnelles (if) et les instructions rptitives
(while, for). Ce chapitre prsente les instructions if, while et for.
3.1 Conditions et instruction conditionnelle if

Donnons des exemples simples dinstructions if :
>>> a = 150
>>> if a > 100:
...
print("a dpasse la centaine")
...
a > 100 est appele la condition du test if. Cest une expression boolenne qui peut donc
tre value vrai ou faux. Si la condition est vraie, ce qui dpend du if est excut.
17
>>> a = 20
>>> if (a > 100):
...
print("a dpasse la centaine")
... else:
...
print("a ne dpasse pas cent")
...
Reprenons le calcul des ventuelles racines dune quation du second degr. Aprs avoir lu les
donnes du problme, cest--dire les valeurs a, b et c, il faut calculer le delta et tester sil
est ngatif, nul ou positif. Le code du programme donne :
"""
Calcul des racines ventuelles dune quation du second degr
"""
__author__="Thierry Massart"
__date__="22 aot 2012"
from math import sqrt
a= float(input(valeur de a : ))
b= float(input(valeur de b : ))
c= float(input(valeur de c : ))
delta = b**2 - 4*a*c
if delta < 0:
print(" pas de racines relles")
elif delta == 0:
print("une racine : x = ", -b/(2*a))
else:
racine = sqrt(delta)
print("deux racines : x1 = ",
(-b + racine)/(2*a), " x2 = ", (-b - racine) / (2*a))
On a donc les trois mots-cls if, else et elif; ce dernier est donc la contraction dun else
et dun if. Noubliez pas de terminer la ligne den-tte du if, else, elif par le caractre
:.
Note: En Python il est prfrable de mettre une instruction par ligne sauf si linstruction prend
trop de place et prend plusieurs ligne (auquel cas, parfois il est ncessaire de terminer la ligne
par le caractre \ qui indique que linstruction continue sur la ligne suivante. Le ; permet
galement de sparer les instructions dune mme ligne.
Lindentation (dcalage de certaines instructions de quelques - on conseille 4 - caractres) est
essentielle en Python car il dtermine quelle(s) instruction(s) dpendent de la condition.
Note: Les oprateurs relationnels Python sont :
==, !=, <, >, <=, >=, is, is not, in.
18
Chapter 3. Contrle de flux (instructions if et while)
Note: Les oprateurs boolens Python sont :

and, or et not.
La smantique (valeur) des oprateurs est donne par leur table de vrit, qui exprime le
rsultat de lexpression en fonction des valeurs des oprandes:
a
False
False
True
True
b
False
True
False
True
not a
True
True
False
False
a and b
False
False
False
True
a or b
False
True
True
True
Les lois de De Morgan sont frquemment utilises pour simplifier les tests; ayant des expressions logiques A et B
1) not (A or B) == (not A) and (not B)
2) not (A and B) == (not A) or (not B)
Ainsi la place de not ((x >= 0) and (x <10)) on crira x < 0 or x >= 10
3.1.1 If imbriqus
Lindentation est trs importante et peut tre une source derreur en cas dinstructions if (ou
while, for) imbriques.
Le code suivant :
if a > 0 :
if b > 0 :
print("cas 1")
else :
print("cas 2")
imprime cas 1 quand a et b sont positifs, cas 2 quand a est positif et b ngatif ou nul et
nimprime rien si a est ngatif ou nul. Le else dpend du second if.
Le code suivant :
if a > 0 :
if b > 0 :
print("cas 1")
else :
print("cas 2")
imprime cas 1 quand a et b sont positifs, cas 2 quand a est ngatif ou nul et donc rien quand
a est positif et b ngatif ou nul. Le else dpend du premier if.
3.1. Conditions et instruction conditionnelle if
19
3.1.2 Evaluation paresseuse (lazy evaluation)

Lorsquune expression boolene b1 and b2 est value, si b1 est fausse, b2 ne doit pas tre
value car on sait que le rsultat de lexpression est faux.
Idem si b1 or b2 est valu avec b1 valu vrai, le rsultat est doffice vrai.
Dans ces 2 cas, Python nvalue pas b2.
On peut, par exemple, utiliser cela dans le code:
>>> if x != 0 and y/x > 1.0:
...
print(ok)
3.1.3 Syntaxe gnrale du if

La syntaxe gnrale de linstruction if est :
"if" expression ":" suite
("elif" expression ":" suite )*
["else" ":" suite]
o
expression est une expression boolenne,
suite un bloc dinstructions (indentes)
( ... )\* est une mta-notation signifiant que la ligne peut ne pas tre mise, mise
une ou plusieurs fois
[...] est une mta-notation signifiant que la ligne est optionnelle, cest--dire peut tre
ou ne pas tre mise.
3.1.4 is
loprateur is peut tre utilis: il teste si deux variables rfrencent le mme objet
>>> x=3
>>> y=3
>>> x is y
True
>>> z = x
>>> x is z
True
>>> x = x + 1
>>> x is y
False
Ce code montre que lobjet entier contenant la valeur 3 nest pas cr 2 fois, ce qui serait une
perte de temps et despace mmoire. Par contre aprs incrmentation x = x + 1, x et y
rfrencent bien sr 2 objets diffrents (y vaut 3 et x vaut 4).
20
3.2 Instruction pass

Utilise gnralement quand le code doit tre complt, linstruction pass ne fait rien
if x < 0:
pass # TODO : grer le cas o x est ngatif
3.3 Instruction rptitive while

Le while est linstruction rptitive la plus simple :
i = 3
while i < 10 :
i = i + 2
print(i)
print("exemple termin")
imprime :
5
7
9
11
exemple termin
3.3.1 Calcul du plus grand commun diviseur de 2 nombres

Un trs bel exemple de lutilisation du while consiste en le calcul du plus grand commun
diviseur (pgcd) de deux entiers positifs x et y. Par exemple 6 est le pgcd de 102 et de 30 ;
nous noterons ceci par
pgcd(102, 30) = 6
La mthode du mathmaticien grec Euclide est base sur lobservation que le pgcd de x et y est
aussi le pgcd de y et du reste de la division entire de x par y. Ici 12 est le reste de la division
entire de 102 par 30 et donc
pgcd(x, y) = pgcd(y, x % y)
Donc :
pgcd(102, 30) = pgcd(30, 12)
pgcd(30, 12) = pgcd(12, 6)
pgcd(12, 6) = pgcd(6, 0)
Et comme
pgcd(x, 0) = x (puisque 0 est divisible par tout x; pour tout x : 0.x = 0)
3.2. Instruction pass
21
nous aurons
pgcd(102, 30) = 6
Le programme Python calculant le pgcd de 2 nombres entiers positifs est donn la figure
ci-dessous
"""
calcule le pgcd de 2 nombres entiers positifs
"""
x = int(input("Introduisez le premier nombre entier positif : "))
y = int(input("Introduisez le second nombre entier positif : "))
while (y > 0):
x, y = y, x % y
print("Le pgcd vaut: ", x)
La table dtat suivante donne les valeurs des variables durant les diffrentes phases de
lexcution du programme
instruction
x = int(input(...
y = int(input(...
x,y = y, x%y (1re it
x,y = y, x%y (2me it)
x,y = y, x%y (3me it)
print(...
x
102
102
30
12
6
6
y
?
30
12
6
0
0
3.3.2 Conjecture de Syracuse
n = int(input(entier positif : ))
while n != 1:
print(n, end= )
if n % 2 == 0:
n = n//2
else:
n = n*3+1
avec n = 27795317865557576576432145678
3.3.3 Autre exemple dutilisation dun while

Un autre exemple dutilisation dun while est illustr dans le bout de code suivant, qui fait le
cumul des valeurs naturelles lues (termines par une valeur -1 ne faisant pas partie de la liste) :
22
""" Somme cumule des valeurs positives lues """

res = 0
i = int(input("Donnez une valeur entire (-1 pour terminer) : "))
while i > 0:
res += i
i = int(input("Donnez une valeur entire (-1 pour terminer) : "))
print("Somme des valeurs cumules :
", res)
Note: Notons que si la condition est fausse au dbut de lexcution dun while, linstruction
ne sera jamais excute. Inversment si la condition du while ne devient jamais fausse,
linstruction while continuera sexcuter indfiniment et ceci jusqu ce que le processus
qui excute le programme soit tu cest--dire arrt de faon brutale par le programmeur ou
le superviseur de lordinateur.
Tout programmeur novice va tt ou tard avoir affaire un tel programme qui cycle. Enfin
notons quil se peut que la condition devienne fausse au milieu de lexcution de linstruction
while. Ce nest qu la fin de lexcution de linstruction que la condition est rvalue. Ainsi
dans le programme Python de la figure suivante, le corps de la boucle while est excut 4 fois.
i = 0;
print("Dbut du programme")
while i < 4 :
i += 20
print(i)
i -= 19
print("termin")
Le format gnral de linstruction while est :

"while" expression ":" suite
["else" ":" suite]
o
expression est une expression boolenne,
suite un bloc dinstructions (indentes)
[...] est une mta-notation signifiant que la ligne est optionnelle, cest--dire peut tre
ou ne pas tre mise.
Si la partie else est prsente, elle est excute une seule fois quand la condition devient fausse.
3.3. Instruction rptitive while
23
3.4 Instruction for

Le for est une instruction rptitive qui itre avec une variable de contrle qui chaque
itration, prend une valeur dune squence (ou dun container 1 ) donne.
Nous verrons plus dexemples au chapitre qui prsente les strings et les listes. Donnons en
seulement une utilisation classique:
>>> for i in range(10):
...
print(i)
...
0
1
2
3
4
5
6
7
8
9
3.5 break et continue

Python a galement les instructions break et continue que nous ne verrons pas ici
Warning: Nutilisez pas dinstruction break ou continue dans vos programmes. Ces
instructions peuvent tre vites et leur utilisation produit des programmes non bien structur
Un container est une donne compose de plusieurs donnes plus simples (exemple: chane de caractre,
liste, tuple, dictionnaire)
24
CHAPTER
FOUR
DFINITION DE NOUVELLES
FONCTIONS
See Also:
Lire le chapitre 7 du livre de Grard Swinnen sur Python 3
Python permet de dcouper les programmes en fonctions. Chaque fonction cre peut tre
vue comme un outil rsolvant un certain problme. Les autres fonctions peuvent utiliser cet
outil sans se soucier de sa structure. Il leur suffit, pour pouvoir lutiliser, de savoir comment
employer cet outil, cest--dire, comme nous le verrons ci-dessous, de connatre le nom de la
fonction, les objets (valeurs, variables) quelle ncessite et la faon dont elle renvoie un ou
plusieurs rsultats.
Cette technique a en particulier deux avantages:
chaque fonction peut (gnralement) tre teste indpendamment du reste du programme;
si une partie contient une squence dinstructions qui doit tre ralise diffrents endroits du programme, il est possible de ncrire cette squence quune seule fois.
En gros, une fonction peut tre vue comme une opration dont la valeur est dfinie par le
programmeur. Notons que, dans les chapitres prcdents, nous avons dj vu quen Python, il
existe des fonctions prdfinies que le programmeur peut utiliser. Ainsi par exemple print(),
float(), cos() sont des fonctions; comme on la vu, cette dernire est prdfinie dans le module
math et doit tre importe avant de pouvoir tre utilise.
4.1 Fonction retournant une valeur

Le code suivant dfinit une fonction pgcd() (le programmeur choisit le nom) qui reoit en
entre (donnes) deux paramtres formels (ou juste paramtres) x et y qui sont supposs ici
bien tre des valeurs naturelles et renvoie le plus grand commun diviseur de x et de y.
def pgcd(x,y):
"""Renvoie le plus grand commun diviseur des 2 valeurs reues
qui doivent tre des entiers positifs
"""
while y > 0 :
25
x,y = y, x%y
return x
o
"""Un commentaire quelconque
qui peut prendre plusieurs lignes
"""
est un commentaire multiligne qui constitue le docstring de la fonction pgcd.

Une fois dfinie la fonction pgcd() peut tre utilise en linvoquant dans le code. On parle
dappel la fonction et dargument (ou paramtre effectif) pass lors de cet appel. On parle
aussi du programme ou la fonction appelante et de la fonction appele.
a = int(input("valeur entire positive : "))
z = pgcd(26,a)
...
if pgcd(47,z+1) != 1:
...
On peut aussi demander ce que fait la fonction avec

>>> help(pgcd)
qui donnera le docstring de la fonction.

Rappel: la touche clavier q sert sortir du mode help
Note: En informatique, pour spcifier ce que fait un certain code et en particulier une fonction,
on parle de prcondition et de postcondition
Prcondition: condition que la fonction suppose vraie pour les entres, avant dexcuter
son travail
Postcondition: condition quune fonction garantit si lensemble des prconditions sont
respectes (=la validit de son rsultat)
4.2 Type des paramtres et du rsultat

Python est un langage interprt avec typage dynamique fort. Cela se remarque par exemple quand on dfini une simple fonction sum:
def sum(a,b):
return a+b
On aura
sum(3,5) renvoie 8 qui est de type int
sum("bon","jour") renvoie bonjour qui est de type str (string)
26
Chapter 4. Dfinition de nouvelles fonctions
sum("bon",5) gnre une erreur de type (lve une exception lors de lexcution de la
somme)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in sum
TypeError: Cant convert int object to str implicitly
La raison est que lon ne paut faire un + entre un entier et un string.

Warning: Il est donc impratif en Python de bien contrler les types des objets que lon
manipule et ventuellement de grer les erreurs possibles si le type reu ne correspond pas
au type ou un des types attendus. Nous verrons que la gestion des exceptions permet de
faciliter la gestion des erreurs.
Note: On dit communment dune fonction qui renvoie un rsultat dun type x, que cest une
fonction de type x ou une fonction x (par exemple une fonction entire).
Note: Dans le vocabulaire des langages de programmation, une fonction qui peut faire des
choses diffrentes en fonction du type des arguments, est dite surcharge. La fonction sum est
un exemple simple de fonction surcharge qui tantt effectue une somme, tantt une concatnation de texte.
4.2.1 Fonction boolenne

Il est frquent de devoir encoder une partie de programme qui ralise un test non lmentaire.
La fonction boolenne est_pair(x) teste si x est pair;
def est_pair(x):
"""Renvoie vrai si et seulement si x est pair """
return x%2 == 0
a = int(input("Entrez un nombre entier impair: ")
if est_pair(a):
print("il nest pas impair ! ")
4.3 Fonction ne retournant pas de valeur

On peut dfinir des fonctions dont le but nest pas de calculer une valeur renvoyer la fonction
appelante. Voici un simple exemple
def print_line(x,n):
print(x*n)
4.3. Fonction ne retournant pas de valeur
27
Note: Par dfaut une fonction renvoie la valeur None qui symbolise labsence de valeur.
Cela signifie que return sans expression donnant une valeur la fin quivaut return
None.
Par ailleurs, un return implicite existe la fin de toute fonction.
Donc aprs avoir dfini print_line, le code :
>>> print(print_line(5,7))
35
None
imprime le rsultat de la multiplication et ensuite imprime le rsultat de la fonction excute

(None).
De mme :
>>> print(print_line("*",10))
**********
None
imprime 10 fois le caractre * et ensuite imprime le rsultat de la fonction excute (None).
4.4 Excution de la fonction appele (passage de

paramtres par valeur)
Dans la suite, nous parlerons de la fonction appelante pour identifier le fonction qui effectue
lappel la fonction invoque; cette dernire sera identifie comme tant la fonction appele.
4.4.1 Excution dune fonction

Lorsquune fonction est appele par une autre fonction, la squence du traitement est la suivante:
1. Les variables locales la fonction appele, correspondantes aux paramtres formels, sont
cres (et mise dans le nouvel espace de nom associ cette instance de la fonction).
2. Les paramtres sont transmis (passs) entre la fonction appelante et la fonction appele. Ceci
sera dcrit en dtails ci-dessous.
3. Lexcution de la fonction appelante est suspendue pour laisser la place lexcution de la
fonction appele.
4. Lorsque la fonction appele termine son excution, les variables locales sont dtruites :
plus prcisment lespace de nom associ linstance de la fonction est dtruit.
28
5. La fonction appelante reprend son excution. Si la fonction prcdemment appele tait

une fonction retournant une valeur, la valeur de cette fonction a t conserve pour permettre
lvaluation de lexpression utilisant le rsultat de cette fonction.
Une fonction ou une procdure tant, en substance, une fonction de traitement paramtris, il
faut clairement prciser quoi correspond chaque paramtre formel au dbut de chacune de ses
excutions.
Tout dabord, rappelons quune fonction est vue comme un oprateur: chaque appel cette
fonction produit un rsultat (ventuellement None) qui est la valeur de cette fonction pour
cet appel ; cette valeur rsultat est donc transmise la fonction appelante. Le passage des
paramtres constitue lautre faon de transmettre des valeurs ou des rsultats entre la fonction
appelante et la fonction appele. Le seul mode de transmission des paramtres possible en
Python est la passage par valeur.
4.4.2 Correspondance des paramtres

Il doit y avoir une correspondance entre les paramtres formels et les paramtres effectifs selon
la position. Cela signifie que le ime paramtre effectif en ordre dapparition dans la liste doit
correspondre au ime paramtre formel.
Le passage de paramtre suit le mme fonctionnement quune assignation: le paramtre effectif
est soit une rfrence un objet existant soit une expression dont la valeur donne un objet; le
paramtre formel est une variable locale qui lors de lappel recevra une rfrence cet objet.
Donc avec def pgcd(x,y): lappel pgcd(26,a) aura comme effet que dans la fonction, x
rfrence lobjet entier valant 26 et y, la variable rfrence par ailleurs par a.
4.4.3 Retour de plusieurs valeurs; modification de variables

Un exemple intressant est celui de la fonction min_et_max qui reoit 2 valeurs et qui trie
ces valeurs, par ordre croissant.
La fonction suivante ne donnera pas le bon rsultat:
def min_et_max(x,y):
"""Fonction qui ne fait rien dutile
if x > y:
x,y = y,x
"""
a=int(input("premire valeur : "))

b=int(input("seconde valeur : "))
print(a,b)
min_et_max(a,b)
print(a,b)
La raison est que x et y sont des variables locales qui rfrencent les objets contenant les
valeurs, mais que la fonction ne modifie ni les objets, ni les rfrences donnes lors de lappel.
La solution est que les valeurs soient renvoyes en rsultat.
4.4. Excution de la fonction appele (passage de paramtres par valeur)
29
"""Renvoie min(x,y) suivit de max(x,y) """
if x > y:
x,y = y,x
return x,y
print(a,b)
a,b = min_et_max(a,b)
print(a,b)
Warning: Rgle de bonne pratique :

Une fonction de type None ne doit pas contenir de return. Une fonction dun type diffrent de None ne doit contenir quun seul return avec le rsultat, et ce return doit tre
place comme dernire instruction de cette fonction.
4.5 Espace de noms (namespace), variables locales et

globales
Chaque fois quune fonction est appele, Python rserve pour elle (dans la mmoire de
lordinateur) un nouvel espace de noms (namespace) o toutes les variables locales seront
mises. Un espace de nom tablit une correspondance (mapping) entre des noms (les variables)
et des objets rfrencs.
Rappelons quen Python une variable x contient la rfrence un objet o; cest lassignation
qui tablit le lien entre x et o. Un objet, une fois cr, existera tant quil sera rfrenc quelque
part.
Rappelons aussi que la smantique de x = y o x et y sont des variables, ne fait que mettre
la valeur de y, cest--dire la rfrence vers un objet, dans la variable x.
Note: Nous verrons lorsque nous aborderons les types de donnes modifiables quoi il faudra
faire attention.
Chaque module a galement son espace de nom. Ainsi import math permet de connatre le
module math (en fait de crer un objet math de type class module) et donc daccder
la fonction cos( ) avec la syntaxe math.cos( ) en utilisant la dot dotation.
Note: Le module par dfaut est dnomm __main__ (avec deux soulign au dbut et la
fin).
Lors de lexcution dune fonction, elle peut accder aux variables locales ainsi quaux variables globales (visibles). Par exemple:
30
>>> def f():

...
p=1
...
print(p,q)
...
>>> p,q=10,20
>>> f()
1 20
>>> print(p,q)
10 20
On parle de la porte (scope) des variables : zone du programme dans laquelle elle est
disponible. La porte dune variable locale ou dun paramtre est limite sa fonction.
4.5.1 Traceback
Lorsquune erreur se produit lors de lexcution dun programme Python lutilisateur reoit un
message derreur qui commence par Traceback (most recent call last):
Pour identifier o a eu lieu lerreur, le message retrace dans quelle fonction f0 et o a eu lieu
lerreur ainsi que, si cest le cas, la fonction f1 et le lieu o f0 a t appele, et ainsi de suite.
Par exemple:
def ma_fun():
une_autre_fun()
def une_autre_fun():
encore_une_fun()
def encore_une_fun():
# une_erreur utilis sans avoir t dfinie auparavant
une_erreur= une_erreur + 1
ma_fun()
donnera:
litpc30:Exemples-cours tmassart$ python3 traceback.py

File "traceback.py", line 10, in <module>
ma_fun()
File "traceback.py", line 2, in ma_fun
une_autre_fun()
File "traceback.py", line 5, in une_autre_fun
encore_une_fun()
File "traceback.py", line 8, in encore_une_fun
une_erreur= une_erreur + 1 # une_erreur utilis sans avoir t dfinie aupra
UnboundLocalError: local variable une_erreur referenced before assignment
4.5. Espace de noms (namespace), variables locales et globales
31
4.6 Passage de fonction comme argument et fonction

lambda 1
Python permet de passer des fonctions comme paramtre.
from math import sqrt, sin
def fun(f,x):
return f(x)
fun(sqrt,4)
fun(sin,0.5)
Cela peut tre intressant ou essentiel dans certain code. Ceci sera illustr dans un chapitre
ultrieur dans un code qui dessine une fonction, celle-ci tant donne en paramtre, dans un
certain intervalle.
Par ailleurs, laspect dynamique de Python permet galement de dfinir des nouvelles fonctions
lors de lexcution et davoir des variables qui rfrencient ces fonctions. En particulier on peut
utiliser des dfinition lambda, par exemple
>>> f = lambda x : x**2 - 3.0*x
>>>
# Dfinit une fonction (x^2-3x) rfrence par la variable f
...
>>> print(f(2.0)) # appel f(2.0) et imprime le rsultat
-2.0
4.7 Valeur par dfaut pour les paramtres et argument

mots-cls
Voir livre de Grard Swinnen ou manuels.
32
Matire avance
CHAPTER
FIVE
CHANES DE CARACTRES
(STRINGS), TUPLES, LISTES ET
INSTRUCTION FOR
See Also:
Python manipule des types de donnes non simples cest--dire o une donne est forme de
parties. Nous allons tudier ici les types de donnes qui forment des squences : les chanes de
caractres (strings) que nous avons dj prsentes, ainsi que les listes, et les tuples.
5.1 Chanes de caractres (strings)

Une valeur de type string est entoure des caratres ... ou ... ou .... Les ...
permettent de taper librement les passages la ligne, sinon on peut utiliser \n
>>> a = "bonjour"
>>> b = """ ici je mets
... mon texte
... sur plusieurs lignes"""
>>> print(b)
ici je mets
mon texte
sur plusieurs lignes
Nous avons dj vu que les strings pouvaient tre concatns a+b ou rpts a*5.
On peut galement comparer 2 strings: lordre de la codification unicode UTF-8 est utilise
Les composantes (caractres) dun string s sont indices de 0 len(s) o len() est une
fonction prdfinie qui donne le nombre de caractres dans le string.
Warning:
Donc quand len(s) vaut 5 on peut manipuler s[0] s[4] (=
s[len(s)-1]).
33
Python permet aussi dutiliser des indices ngatifs sachant que s[-1] est le dernier caractre du string s, s[-2] lavant dernier ....
On peut aussi avoir une tranche (slice) de s (exemple: s[2:5] correspond la partie de s
depuis le caractre dindice 2 compris jusquau caractre 5 non compris.
s[:j] est synonyme de s[0:j] et s[i:] est synonyme de s[i:len(s)].
Enfin, on peut prendre certains lments, par exemple :
s[::2] est le string form des caractres pairs de s ou
s[::-1] est le string form de tous les caractres de s mais dans lordre inverse.
>>> s = "bonjour"
>>> print(len(s))
7
>>> print(s[1])
o
>>> print(s[-1])
r
>>> print(s[2:5])
njo
>>> s2 = s[::-1]
>>> print(s2)
ruojnob
>>> print(s[::2])
bnor
>>> print(len(s))
7
>>> print(s[-len(s)])
b
>>> s3 = B+s[1:]
>>> print(s3)
Bonjour
>>> print(s[:3]*2)
bonbon
>>> vide=""
>>> len(vide)
0
Un string est une squence immuable: on ne peut donc pas la modifier

>>> s = "bonjour"
>>> s[0]="B"
TypeError: str object does not support item assignment
Ayant "bonjour" dans la variable greetings, le code correct pour mettre la premire
lettre en majuscule est :
>>> greetings = "B" + s[1:]
34
Chapter 5. Chanes de caractres (strings), tuples, listes et instruction for
greetings
5.1.1 Linstruction for ... in

permet de parcourir tous les lments dune squence. Par exemple :
nom = "Gilles"
for car in nom:
print(car + ".", end =)
print()
imprime G.i.l.l.e.s..
Le for ... in peut galement tre utilis avec les autres types de squences (tuples, listes) et
galement les dictionnaires (voir plus loin dans la matire).
5.1.2 Le test in
permet de tester si un lment appartient une squence. Par exemple :
car = "a"
voyelles = "aeiouyAEIOUY"
if car in voyelles:
print(car, " est une voyelle.")
imprime a est une voyelle..

De la mme faon le in peut tre utilis pour tester lappartenance dans dautres containers
(tuples, listes, dictionnaires).
5.1.3 Comparaison de strings

les oprateurs relationnels <, <=, >, >=, ==, != permettent de comparer les strings en utilisant
lordre donn par la codification unicode utf-8. (voir livre de Grard Swinnen). Sur la codification unicode UTF-8, vous devez juste savoir que les lettres sont codifies les unes la suite des
autres :
a, b, c , ..., z
A, B, ...Z
0, 1, ...
5.1. Chanes de caractres (strings)
35
Notez que les fonctions prdfinies

ord(c) donne la valeur entire correspondant la codification du caractre c
chr(i) donne le caractre correspondant au code i
nom = "Joseph"
nom2 = "Josephine"
if nom < "Caroline":

print("Caroline cest ma tortue")
if nom < nom2:
print("Josephine passe aprs !")
print(ord(0), ord(9), ord(A), ord(B), ord(a))
for i in range(20000):
print(chr(i), end="")
imprimera :
Josephine passe aprs !
48 57 65 66 97
suivi des 20000 premiers caractres (certains ne sont pas imprimables) dans la codification
UTF-8.
Notez que certains caractres ne sont pas imprimables proprement parler: par exemple print(chr(7)) a comme effet denvoyer le code de signal (beep) au haut-parleur de
lcran. Dautres caractres reprsentent des pictogrammes: par exemple les codes 9812
9823 reprsentent les pices du jeu dchec.
5.2 Tuples
Un tuple est une squence immuable dlments; chaque lment pouvant tre du mme type
ou dun type diffrent.
mes_nombres_lotto = 7, 21, 27, 32, 35, 41
x=int(input("nombre gagnant : ")
if x in mes_nombres_lotto:
print("le ", x," est gagnant et est dans mes nombres ", mes_nombres_lotto)
Les tuples peuvent , par exemple, servir pour assigner plusieurs valeurs en une seule assignation
multiple
a,b = b, a # permute les valeurs de a et de b
ou encore quand on veut renvoyer plusieurs valeurs dans une fonction

""" renvoie min(x,y) suivit de max(x,y) """
36
if x > y:
x,y = y,x
return x,y
print(a,b)
a,b = min_et_max(a,b)
print(a,b)
Notez que habituellement, on entoure les lments du tuple par des parenthses pour mieux
identifier les lments
...
(x,y) = (y,x)
return (x,y)
Les oprateurs + (concatnation) et * (rptition) et in ainsi que le slicing t[i:j] fonctionnent comme avec les strings. La comparaison de 2 tuples est similaire ce qui se passe avec
les strings (par exemple (1,2,3) < (1,2,3,4) est vraie).
Lassignation peut dfinir un tuple dont les lments sont les valeurs donnes droite du symbole = dassignation,
>>> s = 1,2,3
Cest ce que lon appelle le packing. Linverse (unpacking) est galement possible, quand ayant
une squence (tuple ou string ou liste,...) de n lments, on demande dassigner n variables
les valeurs de ces n lments:
>>> s=(1,2,3)
>>> print("s =", s)
s = (1, 2, 3)
>>> a,b,c = s
# unpack les 3 valeurs dans respectivement a, b et c
>>> print("a = ", a)
a = 1
>>> print("b = ", b)
b = 2
>>> print("c = ", c)
c = 3
>>> d, g = s
# s a 3 composantes !!!
ValueError: too many values to unpack (expected 2)
Notez que linstruction d, g = s demande 2 valeurs mais s a 3 composantes, do lerreur.

Les comparaisons, le in dans un for ou dans une condition ou des fonctions comme len()
fonctionnent avec tout type de squences que ce soient des tuples, des strings, ou des listes, ou
mme des dictionnaires (voir plus loin), ....
Notons que lon peut avoir des tuples dlments non homognes et qui peuvent tre des l5.2. Tuples
37
ments non simples comme des strings, listes, tuples, dictionnaires (voir plus loin), ....
>>> mon_tup = bon, voici, 1, exemple, (2,3)
>>> print(mon_tup)
(bon, voici, 1, exemple, (2, 3))
>>> len(mon_tup)
5
>>> print(mon_tup[4])
(2, 3)
>>> len(mon_tup[4])
2
>>> a,b,c,d,e=mon_tup
>>> print(a)
bon
Note: Le tuple contenant un seul lment (par exemple 3 se note (3,). Le tuple vide de note
() (exemple t = ())
5.3 Listes
Un liste Python est une squence que lon peut modifier (muable) dlments, chaque lment
pouvant avoir le mme type ou un type diffrent des autres :
>>> ma_liste = [1,3,7]
>>> ma_liste[0] = 2
donne le diagramme dtat suivant:
2
ma_liste
>>> ma_liste=[3,7,21,42]
>>> print(ma_liste)
[3, 7, 21, 42]
>>> print(len(ma_liste))
4
>>> empty=[]
# liste vide
>>> type(empty)
<type list>
>>> len(empty)
38
0
>>> data=[bon,"jour",0,1,[2,3,4]]
>>>len(data)
5
>>> type(data[0])
<type str>
>>> type(data[4])
<type list>
>>> data[4]=666
>>> print(data)
[bon, jour, 0, 1, 666]
>>> print(data[-1])
666
Le diagramme dtat de data la fin de lexcution du code prcdent est :
data
0
1
2
'b'
'o'
'n'
0
1
2
3
'j'
'o'
'u
'r'
666
Ici aussi, les oprateurs + (concatnation) et * (rption) et in fonctionnent comme avec les
strings. La comparaison de 2 tuples est similaire ce qui se passe avec les strings (par exemple
[1,2,3] < [1,2,3,4] est vraie).
Contrairement aux strings et aux tuples, cette squence est modifiable: chaque lment (composante) de la squence peut tre modifi. On peut aussi rajouter des lments ou en supprimer
:
>>> data=["bon","jour",0,1,[2,3,4], (7,8)]
>>> len(data)
6
5.3. Listes
39
>>> data[0]= "Bonne"

>>> data[1:1]=" "
# insert en composante 1
>>> data[2]="journe"
>>> del data[3] # supprime la composante 3 de data
>>> del data[3:] # supprime les composantes 3 et suivantes de data
>>> print(data)
[Bonne, , journe]
>>> len(data)
3
>>> data.append(1515)
>>> print(data)
[Bonne, , journe, 1515]
>>> len(data)
4
>>> data.extend([3.14,21,[3,5]])
>>> print(data)
[Bonne, , journee, 1515, 3.14, 21, [3, 5]]
>>> len(data)
7
data.insert(1," et heureuse")
>>> print(data)
[Bonne, et heureuse, , journee, 1515, 3.14, 21, [3, 5]]
>>> print(data[0][0])
B
>>> print(data[7][1])
5
5.3.1 Copie de liste

t = [1,3,7]
s = t
copy = t[:]
t[0] = 36
print(s)
print(t)
print(copy)
# s et t rfrencient la mme liste

# copy est une copie de la liste t
imprime
[36, 3, 7]
[36, 3, 7]
[1, 3, 7]
Le type de copie que nous venons de prsenter sappelle shallow copy (copie superficielle).
Nous verrons plus bas que pour des listes complexes, un shallow copy peut ne pas tre suffisant
et quun deepcopy devra tre effectu.
40
5.3.2 Objet et mthodes

Comme dj brivement expliqu lorsque nous avons parl de lassignation, Python manipule des variables qui sont des rfrences des objets. Gnralement, associes une classe
dobjets, des procdures de traitement, appeles mthodes, manipulent ces objets pour les modifier.
Une mthode ressemble une fonction mais o le traitement est propre un objet donn.
Le format gnral pour excuter une mthode meth sur un objet o est
o.meth(...)
o lintrieur des parenthses ( ), sont mis les ventuels arguments
Par exemple:
data.append(1515)
data.extend([3.14,21,[3,5]])
Comme le but de ce cours nest pas de retenir par coeur, lensemble des mthodes existantes
pour les diffrentes classes dlments, un aide mmoire est toujours mis votre disposition
(Voir le chapitre Aide-mmoire Python 3.2 et cliquer sur le logo :
en dbut du chapitre pour obtenir la dernire version pdf imprimable sur une feuille A4 recto
verso.
5.3.3 Diffrentes faons de manipuler des listes

Notez que, comme trs souvent en Python diffrentes oprations peuvent effectuer le mme
traitement. Par exemple ayant une liste quelconque s,
>>> s.append(37)
# rajoute un lment la fin de la liste t
est quivalent :
>>> s[len(s):len(s)] = [37]
# rajoute un lment la fin de la liste t
ou encore :
>>>
s.extend([37]) : rajoute s les lments de la liste en paramtre
ou :
>>>
s.insert(len(s),37) : insre 37 en fin de liste
De mme:
>>> s[0:1] = []
# supprime le premier lment de la liste s
est quivalent :
5.3. Listes
41
>>> del s[0]
# supprime le premier lment de la liste s
Egalement :
>>> del s[len(s)-1]
# supprime le dernier lment de la liste s
est quivalent :
>>> s[len(s)-1:] = []
# supprime le dernier lment de la liste s
Le programmeur a donc intrt dcider une fois pour toute quil utilise toujours la mme
faon de faire pour raliser un certain traitement, et sy tenir.
Warning: Il est interdit de manipuler en lecture (essayer de prendre la valeur de
llment) ou en criture (essayer de changer la valeur) une composante inexistante dune
liste s cest--dire en dehors de lintervalle 0 .. len(s)
>>> s= [a,b,c]
>>> s[3] = d
IndexError: list assignment index out of range
>>> print(s[3])
IndexError: list index out of range
En particulier pour tendre une liste, il faut donc utiliser par exemple une des mthodes vues
plus haut (append, extend, slicing).
42
5.3.4 Liste et rfrences

Warning: Comme pour les valeurs simples leffet prcis des instructions
>>> s = [1,2,3]
>>> t = s
>>> s is t
True
est de crer une liste de 3 objets entiers (valant 1, 2 et 3), de mettre dans s la rfrence
cette liste et ensuite de donner la mme rfrence t; et donc s is t rpond True.
Donc s et t rfrencent la mme liste comme le montre le diagramme dtat suivant:
Donc s[1] = 36 modifie la liste et donc print(s) et print(t) impriment tous les 2 [1,36,3].
Quand on utilise s[i:j] = l2 pour certains indices i et j et une liste l2 donns, ou del
s[i] ou encore s.append(v), on modifie la liste s (et donc t).
Rappelons que le test s is t (qui rpond donc True ou False) permet de savoir si s et
t rfrencent le mme objet.
Si lon fait par exemple:
>>> s = s + [37]
on cre une nouvelle liste avec les lments de lancienne liste s et la liste [37]. s reoit
la rfrence la nouvelle liste. Donc s rfrence cette nouvelle liste, t rfrence toujours
lancienne (s is t vaut False).
5.3. Listes
43
Warning: Cette faon de faire a beaucoup davantages, mais est une source derreur importante !!
Le code suivant:
>>> s= [1,2,3]
>>> t = s
>>> s[1] = 36
>>> s
[1,36,3]
>>> t
[1,36,3]
>>> t is s
True
>>> s = s + [47]
>>> s
[1,36,3,47]
>>> t
[1,36,3]
>>> s is t
False
donne en fin dexcution le diagramme dtat suivant:
36
36
47
Note: Plus prcisment, chaque constante (1, 3, 36,...) nest cre quune seule fois (un
objet) et si une composante dune squence a cette valeur, Python implmente cela comme une
rfrence vers cet objet ayant cette valeur (voir diagrammes dtat suivants).
44
Warning: Notons que :

>>> s = [1,2,3]
>>> t = [1,2,3]
>>> s is t
False
cre deux listes distinctes.

tandis que
>>> s = hello
>>> t = hello
>>> s is t
True
cre un string point par les deux variables s et t.

Lide est que comme un string est immuable, il ny a aucun risque faire pointer plusieurs
variables vers le mme string, tandis que pour les listes, a priori, elles seront modifies par
la suite et donc il semble clair que dans le code plus haut, s et t doivent rfrencer deux
listes diffrentes. Sinon on aurait crit :
s = t = [1,2,3]
5.3.5 range()
La fonction range() gnre une squence de valeurs entires.
On a dj vu que
for i in range(10):
print(i, end=" " )
imprime : 0 1 2 3 4 5 6 7 8 9
La fonction range() est un itrateur, cest--dire une fonction qui gnre une squence
dlments; range() gnre une squence dentiers.
range() peut avoir 2 ou mme trois arguments donnant le nombre de dpart, la borne et le
pas qui peut tre positif ou ngatif. Par dfaut le nombre de dpart vaut 0 et le pas vaut 1. Les
arguments doivent tre des nombres entiers.
Notons quil est possible dutiliser la fonction list() avec la fonction range(), pour
obtenir la liste des lments correspondants.
>>> t = list(range(10))
>>> print(t)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
5.3. Listes
45
5.4 Instruction for

Gnralement, linstruction for sert assigner une variable de contrle, une valeur dune
squence donne.
Ainsi dans :
>>> seq = [bon, jour, 1, peu, 2, tout]
>>> for elem in seq:
...
print(elem, " / ", end = "")
...
bon / jour / 1 / peu / 2 / tout /
la variable elem prend chaque itration une autre valeur de la liste.

Cela fonctionne aussi avec un autre type de squence telle que un string ou un tuple ou mme
un dictionnaire comme nous le verrons plus loin.
>>> mon_texte = "hello world"
>>> for c in mon_texte:
...
print(c)
...
h
e
l
l
o
w
o
r
l
d
Le code suivant illustre comment manipuler lindice de la squence, en mme temps que
llment.
>>>
>>>
...
...
0
1
2
3
4
5
6
7
8
9
10
46
mon_texte = "hello world"

for i in range(len(mon_texte)):
print(i, " ", mon_texte[i])
h
e
l
l
o
w
o
r
l
d
Note: Il est possible dcrire les rsultats dans un format plus propre (par exemple, en rservant
systmatiquement 3 espaces pour une donne ou en demandant dimprimer le rsultat rel avec
une certaine prcision). Voir livre de Grard Swinnen, section formatage des chanes de
caractres.
Notez que si on a, par exemple, une liste de strings, on peut avec deux for imbriqus, passer
en revue tous les caractres de chaque string.
>>> ma_liste = ["bon", "jour", " tu vas ", " bien"]
>>> for s in ma_liste:
...
for c in s:
...
print(c, end =" ")
...
b o n j o u r
t u
v a s
b i e n
Le premier for assigne s chaque string de ma_liste, le for imbriqu, assigne c chaque
caractre du string mis dans s.
5.5 Autres oprations et mthodes sur les squences,

strings, listes
Note: Dans le livre de Grard Swinnen, et dans laide mmoire, vous verrez que dautres
mthodes existent sur les squences (strings, tuple, listes) ou plus spcifiquement sur un type
de squence (les listes par exemple).
Exemple :
del(s[i])
del(s[i:j])
s.append(x)
s.extend(liste2)
s.count(x)
s.index(x)
s.sort()
s.pop()
s.reverse()
s.remove(v)
5.5. Autres oprations et mthodes sur les squences, strings, listes
47
5.5.1 zip
Cette fonction peut tre bien pratique quand on veut parcourir deux ou plusieurs squences en
parallle. Par exemple le code suivant est quivalent au code vu un peu plus haut :
>>>
>>>
...
...
0
1
2
3
4
5
6
7
8
9
10

for i, c in zip(range(len(mon_texte)),mon_texte):
print(i, " ", c)
h
e
l
l
o
w
o
r
l
d
Notez que zip peut recevoir plus de deux squences, et quil sarrte ds que la plus courte est
puise.
>>>
>>>
...
...
(1,
(2,
(3,

for i in zip([1,2,3],"bonjour","truc"):
print(i)
b, t)
o, r)
n, u)
5.6 Comprhension de liste (list comprehension)

La comprhension de listes (list comprehension) est une mthode efficace et concise pour crer
une liste partir des lments dune autre squence satisfaisant une certaine condition. Le
tutoriel python3 dans le site officiel (python.org) donne de trs bons exemples dutilisation de
la comprhension de liste.
on peut crire :
squares = [x**2 for x in range(10)]
la place de :
>>> squares = []
>>> for x in range(10):
...
squares.append(x**2)
...
48
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
De mme :
>>> combs = [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
est quivalent :
>>>
>>> combs = []
>>> for x in [1,2,3]:
...
for y in [3,1,4]:
...
if x != y:
...
combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
Ayant une matrice:

>>> matrix = [
...
[1, 2, 3, 4],
...
[5, 6, 7, 8],
...
[9, 10, 11, 12]]
Le code suivant construit sa transpose:

>>> trans = [[row[i] for row in matrix] for i in range(4)]
>>> trans
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
5.7 Copie de listes complexes et rference cyclique

On a vu que lon pouvait faire une copie dune liste en en prenant une tranche (slicing) depuis
le dbut jusqu la fin:
s = [1,5,9]
t = s[:] # t rfrence une nouvelle liste dont les valeurs sont les mmes
# que celles de s
Malheureusement, stricto sensu, s[:]copie les valeurs des composantes

de s et donc si on a
s = [1,5,[7,9]]
t = s[:] # t rfrence une nouvelle liste dont les valeurs sont les mmes
# que celles de s
t[0] est une rfrence vers un objet contenant la valeur entire 1

5.7. Copie de listes complexes et rference cyclique
49
t[1] est une rfrence vers un objet contenant la valeur entire 5

t[0] est une rfrence vers un objet contenant la sous-liste 2 lments [7, 9]
Si le fait que s[0] et s[1] rfrencent les mmes valeurs que respectivement t[0] et t[1]
ne posent pas de problmes (les valeurs 1 et 5 tant non modifiables), il nen va pas de mme
avec la sous-liste [7,9].
Ainsi on aura :
>>> s = [1,5,[7,9]]
>>> t = s[:] # t rfrence une nouvelle liste (shallow copy)
>>> s[0] = 36 # modifie s[0] mais pas t[0]
>>> s[2][0] = 777 # modifie la sous liste pointe par s[2] et t[2] !!
>>> print(s)
[36,5,[777,9]]
>>> print(t)
[1,5,[777,9]]
avec s[2] et t[2] modifis de la mme faon puisquils rfrencent la mme sous liste.
Le diagramme dtat prcis correspondant donne :
36
1
2
5
777
t
0
0
1
2
La sous liste rfrence par t[2] (et par s[2]) est donc modifie.
Cest pour cette raison que ce type de copie est dit superficiel (shallow copy).
Si lon dsire une structure totalement spare, mme au niveau des sous-listes, la fonction
deepcopy du module copy peut tre utilise :
50
>>> from copy import deepcopy

>>> s = [1,5,[7,9]]
>>> t = deepcopy(s) # t rfrence une nouvelle liste totalement spare de s
>>> s[0] = 36 # modifie s[0] mais pas t[0]
>>> s[2][0] = 777 # modifie la sous liste pointe par s[2]
>>> print(s)
[36, 5, [777, 9]]
>>> print(t) # t na pas t modifi
[1, 5, [7, 9]]
Ici la liste t na pas t modifie. Le diagramme dtat prcis correspondant donne :
36
1
2
5
777
t
0
0
1
1
2
7
9
0
1
Notez que les objets immuables (comme les constantes 1, 5, ...) ne sont pas recopis puisquici
aucun risque nest possible, tant donn justement quils ne sont pas modifiables.
5.7.1 Rfrence cyclique

le code suivant cre une liste s 3 lments dont le premier lment rfrence la liste elle
mme.
51
>>> s = list(range(3))
>>> s[0] = s
>>> print(s)
[[...], 1, 2]
Dans le print, le [...] signifie une rfrence cyclique une liste sans plus de prcision.
Le diagramme dtat correspondant s en fin de code donne :
Le code suivant :
>>> s = list(range(3))
>>> s[0]= t
>>> t[0] = s
>>> t[1] = t
>>> s[1] = s
>>> print(s)
[[[...], [...]], [...], 2]
Ici, [...] signifie tantt une rfrence valant s tantt une rfrence valant t.
Ce code donne la structure reprsente par le diagramme dtat suivant:
52
0
1
Tout ceci peut vous paratre dans un premier temps assez compliqu: le chapitre suivant revient
sur des choses plus abordables en passant en revue des algorithmes utilisant des squences plus
simples.
Note: Le mot conteneur (container) est utilis pour signifier un objet qui rfrence dautres
objets. Les listes, tuples (mais aussi dictionnaires) sont des exemples de conteneurs.
53
54
CHAPTER
SIX
CONCEPTION DALGORITHMES
SIMPLES
See Also:
6.1 Rcurrences simples

6.1.1 Approximation de e
Bien que la bonne connaissance de la syntaxe et de la smantique dun langage sont deux lments indispensables pour crire un algorithme, la conception proprement dite de ce dernier est
une tche souvent bien plus complexe. Pour mener bien cette tche, il faut pouvoir analyser
et dcomposer proprement le problme donn en parties, trouver une mthode de rsolution
pour chacune de ces parties, traduire ces mthodes dans le langage de programmation, et enfin sassurer que le programme obtenu est suffisamment efficace et rpond correctement au
problme pos: en un mot tre expert en programmation structure.
Pour le devenir il faut tout dabord apprendre dcomposer proprement le problme.
Prenons un exemple: supposons que lon veuille crire un programme donnant une approximation du nombre e (la constante de Nper). Python contient de nombreuses fonctionnalits ou
modules quil peut importer. Mais ici, faisons lhypothse que e nest pas connu via le module
math. e peut tre dfini comme la limite de la srie:
e = 1 + 1/1! + 1/2! + ... + 1/n! + ...
Etant donn que le programme ne peut pas sexcuter pendant une infinit de temps et que la
prcision de la machine utilise est finie, il faudra sarrter un terme donn.
Il est connu que lapproximation
1 + 1/1! + 1/2! + ... + 1/n!
diffre de e dau plus deux fois le terme suivant dans la srie, cest--dire dau plus 2/(n+1)!.
55
Si lon estime quune prcision eps donne (exemple: eps = 1.0 e-8) est suffisante, il
faut donc crire un programme qui calcule e avec une erreur infrieure la constante eps
cest--dire de sommer les termes 1/i! jusqu ce que 2/(i+1)! < eps.
Lalgorithme devra donc calculer :
1 + 1/1! + 1/2! + ... + 1/n!
avec 2/n! <= eps et 2/(n+1)! < eps
ce qui ne peut pas tre fait en une seule instruction puisque le nombre n nest pas connu a priori.
Il semble naturel de dcomposer lalgorithme en une rptitive qui calcule chaque tour de
boucle un nouveau terme et qui teste si ce nouveau terme doit tre inclus dans lapproximation.
Le canevas gnral sera alors donn par le code suivant :
"""
Approximation de la valeur de e
"""
eps = 1.0e-8
n = 1
e = 1.0
terme = 1.0
while 2*terme >= eps:
e += terme
n += 1
... # calculer le terme 1/n! suivant
print("lapproximation de e = ", e)
De plus tant donn que

n! = 1.2.3. ... .n
Calculer n! se fait grce au code:
fact_n = 1
for i in range(2,n+1):
fact_n *= i
la valeur n! grandit trs rapidement avec n, ce qui peut ne pas tre trs efficace pour les calculs.
Remarquons que :
fact_n = 0
fact_n *= i
nest videmment pas correct.

On obtient alors le programme Python suivant:
"""
"""
eps = 1.0e-8
n = 1
e = 1.0
56
Chapter 6. Conception dalgorithmes simples
terme = 1.0
while 2*terme >= eps :
# n = prochain indice, e = val jusque n-1, terme = terme dindice n
fact_n = 1
e += terme
n += 1
fact_n *= i
terme = 1/fact_n # calcul du terme 1/n! suivant
Etant donn quau nime tour de boucle on calcule n!, on voit aisment que lon peut diminuer
le nombre de calculs: il suffit de reprendre la valeur du terme obtenu au tour prcdent et de
la diviser par n.
On obtient la version amliore suivante :
"""
"""
eps = 1.0e-8
n = 1
e = 1.0
terme = 1.0
while 2*terme >= eps : # n = prochain indice, e = val jusque n-1, terme = terme
e += terme
n += 1
terme /= n # calcul du terme 1/n! suivant
Remarquons, dans le code, que le nom des objets (e, terme, n, eps, ... ) donne une ide de leur
usage. De plus, ce programme est comment et proprement indent. Ces pratiques facilitent la
tche de toute personne qui doit comprendre le fonctionnement du programme.
Warning: Une chose essentielle galement pour comprendre le fonctionnement du while
est de dcrire la situation chaque fois que lon va faire le test (ici: 2*terme >= eps):
ici on explique que lorsque lon fait ce test, que le rsultat soit True ou False,
n contient le prochain indice que lon va considrer pour la srie,
e contient lvaluation de la srie jusque lindice n-1,
terme contient le terme suivant, cest--dire dindice n
chaque itration, cette description est vraie; ce qui change dune itration lautre, est
lindice n (n += 1) et donc le fait que lon avance dans lvaluation.
6.1.2 Evaluation de la racine carre dun nombre

La mthode de Hron permet de calculer la racine carre dun nombre a. Si x est une approximation de la racine carre de a, alors (x+a/x)/2 est une meilleure approximation de cette racine.
6.1. Rcurrences simples
57
import math
__author__ = "Thierry Massart"
__date__ = "16 september 2011"
EPSILON =10**-20
def almost_equal(x, y, EPS = 10 ** -7):
return abs(y - x) < EPS
def square_root(a):
"""Calcul de la valeur approche de la racine carre de a
Par la mthode de Hron
"""
x = 0.0
y = 1.0
while not almost_equal(x, y,EPSILON):
# rq : pas almost_equal(a,y*y,epsilon) qui peut cycler
x = y
y = (y + a / y) / 2
return y
help(square_root)
print("valeur calcule par la mthode de Hron : \t" \
"{0:20.18}".format(square_root(2)))
print("valeur calcule par le module math :
\t" \
"{0:20.18}".format(math.sqrt(2)))
6.1.3 Somme des nombres pairs dans lintervalle [i,j[

Ecrire une fonction qui calcule la somme des nombres pairs prsents dans lintervalle [n, m[ (n
<= m).
>>> def sum_even(n, m):
...
if n % 2 == 1:
...
n = n + 1
...
sum = 0
...
for i in range(n, m, 2):
...
sum = sum + i
...
return sum
...
>>> sum_even(2, 5)
6
>>> sum_even(1, 6)
6
58
6.2 Manipulation de squences

6.2.1 Nettoyage dun string
La fonction keepAlnum retourne la chane passe en argument, en lui ayant retir tous les
caractres qui ne sont pas des lettres ou des chiffres.
def keepAlnum(s):
res =
for letter in s:
if letter.isalnum():
res = res + letter
return res
>>> keepAlnum(he23.?56th)
he2356th
6.2.2 Fonction qui construit la liste des lettres communes 2 mots
def in_both(word1, word2):

res=[]
for letter in word1:
if letter in word2 and letter not in res:
res.append(letter)
return res
print(in_both(pommeees, oranges))
imprime: [o, e, s]
6.2.3 Fonction qui lit une liste de valeurs (entires)

La fonction demande lutilisateur dencoder une liste de valeurs entires sur une ou plusieurs
lignes, termine par une ligne vide (return sans rien avant), et renvoie la liste des nombres
entiers lus.
La mthode split est utilise pour dcortiquer les lignes lues.
def lecture(invite):
res = []
x = input(invite)
while x != :
decoupe = x.split()
# liste des parties de x spares par un/des espace(s) ou tab
for elem in decoupe:
res.append(int(elem))
6.2. Manipulation de squences
59
x = input()
return res
print(lecture("liste dentiers termine par une ligne vide : "))
6.2.4 Jouer avec les mots

Le fichier words.txt (disponible sur lUniversit Virtuelle) contient 113809 mots anglais qui
sont considrs comme les mots officiels accepts dans les mots-croiss. Cest un fichier plain
text, c--d que vous pouvez le lire dans nimporte quel diteur de texte, mais galement via
Python. Nous allons lutiliser pour rsoudre quelques problmes sur les mots.
Lire un fichier de texte, ligne par ligne
La fonction open prend en argument le nom dun fichier, ouvre le fichier (par dfaut, en mode
lecture : mode r (read)), et retourne un objet fichier qui permet de le manipuler.
>>> fichier = open(words.txt) # cherche ce fichier dans le repertoire courant
>>> print(fichier)
<open file words.txt, mode r at 0x5d660>
La mthode readline invoque sur un objet fichier permet de lire une ligne. Lors de la
premire invocation, la premire ligne est retourne. Lors de linvocation suivante de cette
mme mthode, la prochaine ligne sera lue.
>>> fichier.readline()
aa\r\n
>>> fichier.readline()
aah\r\n
aa est une sorte de lave.

La squence \r\n reprsente deux caractres blancs (comme le sont espaces, tabulation,...)
: un retour chariot et une nouvelle ligne, qui spare ce mot du suivant. lobjet fichier retient
lendroit o lon se trouve dans la lecture, la seconde invocation permet dobtenir le mot suivant.
La mthode strip invoque sur un objet (comme un string) retourne une copie de la chane
en retirant les caractres blancs qui se trouvent au dbut et en fin de la chane.
>>> line = fichier.readline()
>>> line.strip()
aahed
>>> fichier.readline().strip()
aahing
Comprenez-vous la dernire instruction ? (Hint : que retourne readline ?)

Puisque la valeur retourne par une mthode est un objet (tout est objet), la notation point
permet dinvoquer des mthodes en cascade lire de gauche droite : cest une forme de la
composition.
60
Une boucle for peut tre utilise pour lire les lignes dun fichier de texte une une.
>>> for line in fichier:
...
print(line.strip())
aahs
aal
aalii
aaliis
...
zymoses
zymosis
zymotic
zymurgies
zymurgy
Problme: crivez un script qui lit le fichier words.txt et qui naffiche que les mots qui ont plus
de 20 caractres (sans compter les caractres blancs).
Solution :
fichier = open(words.txt)
for line in fichier:
word = line.strip()
if len(word) > 20:
print(word)
Problme: en 1939, Ernest Wright a publi une nouvelle de 50000 mots appele Gadsby qui ne
contient pas la lettre e. Comme e est la lettre la plus commune en anglais (et dans dautres
langues), ce ntait pas une tche facile. Ecrivez un script qui naffiche que les mots qui ne
contiennent pas de e et calculez le pourcentage de ceux-ci par rapport lensemble des mots
du fichier words.txt.
Notez que Georges Perec a fait le mme exercice en franais, dans son livre La disparition
(1969) o il dfinit ce qui a disparu comme un rond pas tout fait clos, fini par un trait
horizontal.
Solution :
fichier = open(words.txt)
total = 0
cnt = 0
for line in fichier:
total = total + 1
word = line.strip()
if e not in word :
print(word)
cnt = cnt + 1
print(Pourcentage de mots sans e:, cnt / total * 100.0)
Problme:
Donnez un mot anglais avec 3 doubles lettres conscutives. Je vous donne un couple de mots
qui sont presque candidats, mais pas tout fait. Par exemple, le mot committee serait parfait
sil ny avait pas ce i au milieu. Ou Mississippi : si on retirait les i, cela marcherait. Il y
6.2. Manipulation de squences
61
a cependant au moins un mot qui possde trois paires conscutives de lettres. Cest peut-tre le
seul mot, ou il peut y en avoir 500.
Problme:
Ecrire un script qui demande lutilisateur le nom dun fichier de texte (.txt), puis affiche les
mots contenus dans le fichier par ordre alphabtique (grce une liste). Un mme mot ne peut
pas tre affich deux fois. Tous les caractres qui ne sont pas des lettres ou des chiffres seront
supprims dans la cration de la liste de mots.
Hints :
la mthode isalnum invoque sur une chane retourne vrai ssi tous les caractres de la
chane sont des lettres ou des chiffres.
la mthode split invoque sur une chane retourne une liste des mots de la chane (c--d
les sous-chanes spares par des caractres blancs (Espaces, retours la ligne, tabulations, etc.)). On peut spcifier dautres sparateurs que des blancs avec le paramtre
optionnel sep.
Solution :
filename = input(Nom du fichier: )
file = open(filename)
wordsList = []
for line in file:
for word in line.split():
cleanWord = keepAlnum(word)
if not cleanWord in wordsList:
wordsList.append(cleanWord)
wordsList.sort()
print(wordsList)
6.3 argv et eval

6.3.1 argv
La fonction input permet dobtenir des entres de lutilisateur. Un autre moyen (rapide et
donc souvent apprci lutilisation) dobtenir des entres de lutilisateur, est de rcuprer les
arguments de la ligne de commande.
Exemples :
De la mme manire que la commande shell cd myDir vous permet de changer de rpertoire
dans une console (le nom du rpertoire myDir est un argument de la commande cd), la commande python3 myscript.py vous permet dinterprter le script Python3 myscript.py.
Tous les arguments passs aprs la commande python3 (et spars par des espaces 1 ) sont
disponibles via lattribut argv du module sys. La valeur argv est une liste qui contient ces
arguments.
1
62
Pour passer un argument qui contient des espaces, on peut le mettre entre apostrophes.
Ainsi pour le script args.py suivant :

import sys
print(sys.argv)
La commande
python3 args.py un deux trois "x + y"
initialise la liste sys.argv :
[args.py, un, deux, trois, x + y]
6.3.2 eval
Python tant un langage interprt, fournit une fonction eval(exp) qui value le string
exp donn en paramtre comme sil sagissait de code supplmentaire.
Cela permet par exemple dcrire un script Python qui reoit en paramtre un polynme
p et une valeur x et calcule la valeur p(x).
"""
utilisation : python3 eval-poly.py p x
o p reprsente un polynme en format python (ex: 3*x**2+2*x-2)
sans espace entre les valeurs et les oprateurs
x donne la valeur pour laquelle on veut la valeur p(x)
"""
import sys
p = sys.argv[1]
x = float(sys.argv[2])
print(eval(p))
6.4 Polygones rguliers avec le module turtle

Turtle est un module permettant de faire des dessins simples (lignes). Les principales fonctions
mises votre disposition dans le module turtle sont les suivantes :
6.4. Polygones rguliers avec le module turtle
63

Commande
reset()
goto(x, y)
forward(distance)
backward(distance)
up()
down()
color(couleur)
left(angle)
right(angle)
width(paisseur)
begin_fill()
end_fill()
write(texte)
Effet
On efface tout et on recommence
Aller lendroit de coordonnes x, y
Avancer dune distance donne
Reculer
Relever le crayon (pour pouvoir avancer sans dessiner)
Abaisser le crayon (pour recommencer dessiner)
couleur peut tre red , blue, etc.
Tourner gauche dun angle donn (exprim en degrs)
Tourner droite
Choisir lpaisseur du trac
Dbut de la zone ferme colorier
Fin de la zone ferme colorier
texte doit tre une chane de caractres
Aprs avoir install turtle et fait import turtle, nhsitez pas utiliser
help(turtle.write) par exemple pour avoir les dtails des fonctions (tailles des
caractres crits, alignement, ...).
Ecrire une fonction poly(n,long,t) qui reoit deux entiers n et long et le module turtle et qui
dessine un polygone rgulier n cts, chacun de longueur long.
import turtle
def poly(n,long,t):
for i in range(n):
t.forward(long)
t.left(360/n)
turtle.reset()
for i in range(3,12):
poly(i,50,turtle)
x=input(tapez return pour terminer : )
Modifiez votre code pour produire des toiles un nombre impair (et ensuite pair) de branches.
6.5 Cration dun module de gestion de polynmes

6.5.1 Encodage dun polynme
Une faon simple dencoder un polynme :
a_n x^n + a_n-1 x^n-1 + ... + a_1 x + a_0
est davoir une liste p contenant les coefficients, cest--dire avec p[i] qui contient le coefficient
a_i (pour i dans 0.. n)
Il devient alors assez facile deffectuer les oprations habituelles sur des polynmes.
64
6.5.2 Oprations sur les polynmes

Voici les codes pour les oprations habituelles sur un ou des polynmes :
def peval(plist,x):
"""
Eval le polynme plist en x.
"""
val = 0
for i in range(len(plist)): val += plist[i]*x**i
return val
def add(p1,p2):
""" Renvoie la somme de 2 polynmes."""
if len(p1) < len(p2):
p1,p2 = p2,p1
new = p1[:]
for i in range(len(p2)): new[i] += p2[i]
return new
def sub(p1,p2):
""" Renvoie la diffrence de 2 polynmes
"""
return add(p1,mult_const(p2,-1))
def mult_const(p,c):
""" Renvoie p multipli par une
res = p[:]
for i in range(len(p)):
res[i] = res[i]*c
return res
constante"""
def multiply(p1,p2):
""" Renvoie le produit de 2 polynmes"""
if len(p1) > len(p2):
p1,p2 = p2,p1
new = []
for i in range(len(p1)):
new = add(new,mult_one(p2,p1[i],i))
return new
def mult_one(p,c,i):
"""Renvoie le produit du polynme p avec le terme c*x^i
"""
new = [0]*i #termes 0 jusque i-1 valent 0
for pi in p:
new.append(pi*c)
return new
def power(p,e):
"""Renvoie la e-ime puissance du polynme p"""
6.5. Cration dun module de gestion de polynmes
65
assert type(e) is int " sassure que e est entier

new = [1]
for i in range(int(e)):
new = multiply(new,p)
return new
def derivee(plist):
"""Calcule la drivee du polynme dans plist.
"""
new = []
for i in range(1,len(plist)):
new.append(i*plist[i])
return new
def integrale(plist, c=0):
"""Renvoie le polynme integrale de plist avec la constante c
(0 par dfaut).
"""
new = [c]
for i in range(len(plist)):
v = plist[i]/(i+1.0)
new.append(v)
return new
6.5.3 Plot de polynmes avec turtle

Le module turtle, associ la fonction eval() et limportation des paramtres via argv
avec le module sys, permet facilement de dessiner (plot) la valeur dun polynme dans un
certain intervalle.
Le code suivant utilise turtle pour tracer une fonction donne en paramtre la commande, en
traant des sections de droite entre les points connexes pour toutes les valeurs x, f(x) avec
x valeurs entires dans lintervalle [-100, 100].
la commande sera par exemple
python simple_dessin_f.py "100*cos(x/10)+x"
Notez que nous avons exceptionnellement fait from math import * dans le code pour
permettre lutilisateur dutiliser librement les fonctions mathmatiques disponibles dans le
module math.
Notez que turtle affiche une fentre dans les valeurs environ (-300,-300) (300, 300).
La difficult principale du code dans simple_dessin_f.py est de calculer lorientation et
la longueur des dplacements que doit effectuer la tortue.
La distance euclidienne entre les anciennes valeurs des coordonnes
(old_x,old_y) et les nouvelles (x,y) est utilise.
arc tangente atan(diff_y/diff(x)) est utilise pour calculer langle (r: pour mettre la tortue en position initiale, comme on doit dplacer la tortue vers la gauche, et donc
66
on rajoute pi langle). Voir dessin.
D(y)
arctan(D(y)/D(x))
D(x)
arctan(D(y)/D(x))
D(y)
D(x)
import sys
from math import *
import turtle
def dessin_fun(t,f):
"""
exemple simple de trac dune fonction entre 2 bornes (ici -100,100)
"""
t.radians()
borne_inf = -100 # valeur impose pour simplifier le code
borne_sup = 100 # valeur impose pour simplifier le code
6.5. Cration dun module de gestion de polynmes
67
old_x, old_y = borne_inf, f(borne_inf)

# position initiale
alpha = atan(old_y/old_x) + pi # sachant que old_x est ngatif
t.left(alpha)
t.up()
t.forward((old_x**2+old_y**2)**0.5)
t.right(alpha)
old_alpha = 0
t.down()
# trace la fonction
for x in range(borne_inf+1, borne_sup+1):
y = f(x)
diff_x = x - old_x
diff_y = y - old_y
d = (diff_x**2 + diff_y**2)**0.5 # distance
alpha = atan(diff_y / diff_x) # angle
t.left(alpha - old_alpha)
t.forward(d)
old_x, old_y, old_alpha = x, y, alpha
f = lambda x: eval(sys.argv[1]) # fonction dessiner
turtle.reset() # initialise turtle
dessin_fun(turtle,f) # appel la fonction qui dessine
input("type return to finish ")
Un code plus labor est disponible ici. Il est utilis avec la commande
python3 dessin_f.py f bi bs zoom
o
f est la fonction tracer
bi la borne infrieure de lintervalle o f est trace
bs la borne suprieure de lintervalle
zoom : le zoom pour le dessin
dessin_f.py trace les axes pour les valeurs -200..200 et utilise un incrment de 0.1 pour x.
Pour cela, la fonction range est remplace par un gnrateur drange dfini dans le code. Un
gnrateur est une sorte de fonction qui gnre une squence: pour cela il remplace le return
habituel par la commande yield pour fournir les valeurs successives.
Note: les librairies pylab, numpy, scipy et mathplotlib permettent (!! en python 2.7 !!) de
faire des calculs numriques et des dessins en particulier en utilisant de nombreuses fonctions
disponibles.
68
6.6 Tableaux plusieurs dimensions

6.6.1 Produit de 2 matrices c = a * b
Une matrice est reprsente en Python sous forme de liste de listes de valeurs (exemple:
x=[[1,2,3],[4,5,6]] donne la matrice 2x3 x.
Le code suivant dfinit une fonction ralisant le produit de deux matrices donnes en paramtre
et renvoie la matrice rsultat.
def produit(a, b):
"""
Produit de la matrice a par la matrice b
Hypothse a: m x l - b : l x n (produit possible)
"""
c = []
for i in range(len(a)):
c_i = []
for j in range(len(b[0])):
c_i_j = 0
for k in range(len(a[0])):
c_i_j += a[i][k] * b[k][j]
c_i.append(c_i_j)
c.append(c_i)
return c
x=[[1,2,3],[4,5,6]]
y=[[1,2],[4,5],[7,0]]
print("le produit vaut : ", produit(x,y))
Une version plus simple, cre la matrice rsultat avec des valeurs 0 au dpart et ensuite calcule
les bonnes valeurs:
def produit(a, b):
"""
Produit de la matrice a par la matrice b
Hypothse a: m x l - b : l x n (produit possible)
"""
c = [[0 for i in range(len(b[0]))] for j in range(len(a))]
for i in range(len(a)):
for j in range(len(b[0])):
for k in range(len(a[0])):
c[i][j] += a[i][k] * b[k][j]
return c
x=[[1,2,3],[4,5,6]]
y=[[1,2],[4,5],[7,0]]
6.6. Tableaux plusieurs dimensions
69
print("le produit vaut : ", produit(x,y))
70
CHAPTER
SEVEN
ENSEMBLES ET DICTIONNAIRE
See Also:
Lire le chapitre 10 du livre de Grard Swinnen sur Python 3
7.1 Set
Le type ensemble (set) existe en Python y compris de nombreux oprateurs ensemblistes (exemple venant du tutoriel de python.org):
>>> basket = {apple, orange, apple, pear, orange, banana}
>>> print(basket)
# show that duplicates have been removed
{orange, banana, pear, apple}
>>> orange in basket
# teste dappartenance
True
>>> crabgrass in basket
False
>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set(abracadabra)
>>> b = set(alacazam)
>>> a
# lettres dans a
{a, r, b, c, d}
>>> a - b
# lettres dans a mais pas dans b
{r, d, b}
>>> a | b
# lettres soit dans a soit dans b
{a, c, r, d, b, m, z, l}
>>> a & b
# lettres la fois dans a et dans b
{a, c}
>>> a ^ b # lettres dans un des 2 mais pas dans les deux ensembles a et b
{r, d, b, m, z, l}
>>> s2 = set({})
# ensemble vide : {} donne un dictionnaire vide
Lexemple prcdent qui dtermine les lettres communes de deux mots peut simplement
scrire :
71
>>> s = set("pommeee")
>>> t = set("banane")
>>> s & t # ensemble des lettres communes
{e}
>>> list(s & t) # si on veut une liste pas un ensemble
[e]
En une ligne :
>>> list(set("pommeee") & set("banane")) # liste des lettres communes
[e]
7.2 Dictionnaire
7.2.1 Dfinition et manipulation
Un dictionnaire est une squence modifiable, o les indices peuvent tre de (presque) nimporte
quel type non modifiable.
Un dictionnaire peut tre vu comme une correspondance entre un ensemble dindices (les cls)
et un ensemble de valeurs. chaque cl correspond une valeur; lassociation entre une cl et
une valeur est vue comme une paire cl-valeur ou comme un lment de la squence.
Exemple: construisons un dictionnaire anglais-franais : les cls et les valeurs seront des
chanes de caractres.
>>> eng2fr = {one: un, two : deux, three : trois} # initialisation
>>> type(eng2fr)
<type dict>
>>> eng2fr[four] = quatre # ajoute un lment d"indice" four
>>> print(eng2fr)
{four: quatre, three: trois, two: deux, one: un}
>>> print(eng2fr[two])
deux
>>> print(eng2fr[five]) # lment inexistant
KeyError: five
>>> dico2 = {} # dictionnaire vide
En gnral, lordre des lments dun dictionnaire est imprvisible. Ce nest pas un problme
: on naccde pas aux lments avec des indices entiers, on utilise les cls.
Type des valeurs et des cls: les valeurs peuvent tre de nimporte quel type (comme pour
les listes); les cls doivent tre des lments non modifiables (exemple: valeur simple, string,
tuple) et donc pas une liste ou un autre dictionnaire qui sont des types modifiables.
>>> dico = {bon:good, jour:day}

>>> dico
{jour: day, bon: good}
>>> dico[(1,2)]= 36 # rajoute llment d"indice" (1,2)
>>> dico[[3,4]]= 49 # erreur : car [3,4] est une liste : et ne peut tre une cl
72
Chapter 7. Ensembles et Dictionnaire

TypeError: unhashable type: list
Plus prcisment, le type dune cl doit tre hachable, c--d que lon peut le convertir en un
nombre entier dune manire dterministe.
>>> hash(6)
6
>>> hash(hello)
-1267296259
>>> hash( (1, 2) )
1299869600
Les objets modifiables ne possdent pas cette proprit.

>>> hash([3, 4])
>>> hash({bon:good})
TypeError: unhashable type: dict
>>> hash((1,2,[3,4]))
Exemple plus compliqu:

>>> eng2fr = {one: un, two : deux, three : trois}
>>> d = {entier : 1, liste : [1, 2, 3], 3 : trois, dico : eng2fr}
>>> d
{liste: [1, 2, 3], dico: {three: trois, two: deux, one: un}, 3:
>>> d[entier]
1
>>> d[liste]
[1, 2, 3]
>>> d[3]
trois
>>> d[dico][two]
deux
Un dictionnaire est une squence : on peut lui appliquer certaines oprations dj vues avec les
autres squences (strings, tuples, listes).
>>> d = {entier : 1, liste : [1, 2, 3], 3 : trois, dico : eng2fr}
>>> len(eng2fr)
4
>>> one in eng2fr # eng2fr a une cl one
True
>>> deux in eng2fr # eng2fr na pas de cl deux
False
>>>for elem in d: # pour toutes les cls du dictionnaire
7.2. Dictionnaire
73
...
print("llment : ", elem, " vaut ", d[elem])
...
llment : liste vaut [1, 2, 3]
llment : dico vaut {three: trois, two: deux, one: un}
llment : 3 vaut trois
llment : entier vaut 1
Par contre on ne pourra pas utiliser le slice puisquon ne travaille pas avec des indices entiers.
Il est frquent dutiliser des tuples comme cls dun dictionnaire (principalement car on ne peut
pas utiliser des listes). Par exemple, on peut utiliser un dictionnaire pour stocker un rpertoire
tlphonique dont les cls sont un tuple (nom, prnom).
>>> tel = {}
>>> tel[Baroud,Bill] = 065-37-07-56
>>> tel[II,Albert] = 02-256-89-14
>>> tel[Poelvoorde,Benoit] = 081-23-89-65
>>> for last, first in tel:
...
printfirst, last, tel[last, first])
Benoit Poelvoorde 081-23-89-65
Bill Baroud 065-37-07-56
Albert II 02-256-89-14
Pour dterminer si une valeur est prsente dans le dictionnaire, on peut utiliser la mthode
values qui retourne toutes les valeurs sous la forme dune liste.
>>> vals = eng2fr.values()
>>> deux in vals
True
>>> print(vals)
[quatre, trois, deux, un]
7.2.2 Dictionnaires comme ensembles de compteurs

Problme (Histogramme de la frquence des lettres): comment compter la frquence de
chaque lettre dans une chane de caractres ?
Plusieurs solutions :
crer 26 variables, une pour chaque lettre. Traverser la chane et, pour chaque caractre,
incrmenter le compteur correspondant, par ex. en utilisant une instruction conditionnelle
chane (26 cas !).
crer une liste de 26 lments puis convertir chaque caractre en un nombre (en utilisant
la fonction ord() par exemple). Utiliser ce nombre comme indice de la liste pour
incrmenter le compteur appropri.
crer un dictionnaire avec les caractres comme cls et les compteurs comme valeurs. La
premire fois que lon rencontre un caractre, on lajoute dans le dictionnaire avec une
valeur 1. Lors dune prochaine occurrence de la lettre, on incrmente la valeur.
Avantage du dictionnaire : code simplifi et on utilise uniquement les compteurs utiles.
74
Solution utilisant un dictionnaire :

def histogram(s):
d = {}
for c in s:
if c not in d:
d[c] = 1
else:
d[c] += 1
return d
>>> h = histogram(brontosaurus)
>>> print(h)
{a: 1, b: 1, o: 2, n: 1, s: 2, r: 2, u: 2, t: 1}
7.2.3 Mthodes des dictionnaires

Les objets de type dictionnaire possdent une srie de mthodes.
>>> dir(eng2fr)
[__class__, __contains__, __delattr__, __delitem__, __doc__,
...
clear, copy, fromkeys, get, items, keys, pop, popitem,
setdefault, update, values]
Nous allons en voir quelques unes.

La mthode copy() permet de faire une copie superficielle (shallow copy) dun dictionnaire
(qui nest pas un alias).
La mthode clear() permet de supprimer tous les lments du dictionnaire.
>>> d = {yes : oui, no : non}
>>> e = d.copy()
>>> e
{yes: oui, no: non}
>>> e[yes] = Oui
>>> e
{yes: Oui, no: non}
>>> d
{yes: oui, no: non}
>>> d.clear()
>>> d
{}
La mthode get() prend une cl et une valeur par dfaut en paramtre. Si la cl est prsente
dans le dictionnaire, get retourne la valeur correspondante. Sinon, elle retourne la valeur par
dfaut.
>>> help(dict.get)
Help on method_descriptor:
7.2. Dictionnaire
75
get(...)
D.get(k[,d]) -> D[k] if k in D, else d.
(END)
d defaults to None.
>>> d = {yes : oui, no : non}

>>> d.get(yes,Mot inconnu)
oui
>>> d.get(five,Mot inconnu)
Mot inconnu
Ceci permet de rcrire histogram() sans instruction conditionnelle explicite.

def histogram(s):
d = {}
for c in s:
d[c] = d.get(c,0) + 1
return d
La mthode setdefault() prend une cl et une valeur par dfaut en paramtre. Si la cl

existe : retourne la valeur, si la cl nexiste pas : ajoute la paire (cl, valeur par defaut) et
retourne la valeur par dfaut.
>>> eng2fr = {one: un, two : deux, three : trois}
>>> eng2fr.setdefault(two,dos)
Deux
>>> eng2fr.setdefault(ten, dix)
dix
>>> eng2fr
{three: trois, two: deux, ten: dix, one: un}
>>> one in eng2fr
True
>>> five in eng2fr
False
Comme lexemple prcdent lillustre, lopration in permet de savoir si une cl est prsente
dans le dictionnaire.
Les mthodes keys, values et items permettent dobtenir respectivement les cls, les valeurs et
des 2-uples cl-valeur.
>>> eng2fr = {one: un, two : deux, three : trois, four:quatre}

>>> eng2fr.keys()
dict_keys([four, three, two, one])
>>> eng2fr.values()
dict_values([quatre, trois, deux, un])
>>> eng2fr.items()
dict_items([(four, quatre), (three, trois), (two, deux), (one, un
La mthode pop supprime une paire cl-valeur partir dune cl et retourne la valeur supprime.
>>> help(dict.pop)
76
pop(...)
D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised
>>> print(eng2fr.pop(five, None))
None
>>> print(eng2fr.pop(one, None))
un
>>> eng2fr
{four: quatre, three: trois, two: deux}
La mthode popitem supprime une paire cl-valeur (indtermine) et retourne la paire supprime sous la forme dun 2-uple.

>>> help(dict.popitem)
popitem(...)
D.popitem() -> (k, v), remove and return some (key, value) pair as a 2-tuple
but raise KeyError if D is empty.
>>> eng2fr.popitem() (four, quatre) >>> eng2fr {three: trois, two: de
7.2.4 Quelques algorithmes sur des dictionnaires

Problme: trouver la (les) cl(s) dune valeur donne ?
Ide : on va traverser linairement le dictionnaire et retourner une liste avec les cls correspondant une valeur donne (les cls sont uniques, mais il peut y avoir une mme valeur pour
diffrentes cls).
def get_keys(d, value):
t = []
for k in d:
if d[k] == value:
t.append(k)
return t
>>> d = histogram(evenement)
>>> d {m: 1, n: 2, e: 4, t: 1, v: 1}
>>> get_keys(d,4)
[e]
>>> get_keys(d,1)
[m, t, v]
La fonction histogram est pratique mais on pourrait avoir besoin dobtenir ces informations de
manire inverse.
Exemple : Au lieu de {m: 1, n: 2, e: 4, t: 1, v: 1},
on aimerait avoir {1 : [m, t, v], 2 : [n], 4: [e]}.
7.2. Dictionnaire
77
Problme: comment inverser les cls et les valeurs dun dictionnaire ?

Ide : on va crer un nouveau dictionnaire qui contiendra des listes : pour chaque valeur du
dictionnaire de dpart, on ajoute une paire dans le nouveau dictionnaire si celle-ci nest pas
prsente, sinon, on met jour la paire.
def invert_dict(d):
inv = {}
for k in d:
val = d[k]
if val not in inv:
inv[val] = [k]
else:
inv[val].append(k)
return inv
>>>
>>>
>>>
{1:
d = histogram(evenement)
inv_d = invert_dict(d)
inv_d
[m, t, v], 2: [n], 4: [e]}
7.3 Changement de type

Comme on la dj dj vu Python a une batterie de fonctions prdfinies pour passer dun type
lautre
Voici une liste plus complte :
int(x) : donne la valeur entire tronque de x
float(x) : donne la valeur relle (float) de x
bool(x) : donne la valeur boolenne de x (si x==0 : False, sinon True)
list(seq) : transforme la squence en liste
str(s): construit un string qui reprsente la valeur de s
repr(s) : construit un string qui reprsente la valeur canonique de s (donc on utilise les
notations \t quand il y a une tabulation \n pour le passage la ligne ...
tuple(s) : transforme en tuple
dict(s) : transforme en dictionnaire : s doit tre une squence de couples
set(s) : transforme en ensemble
Notez que les fonctions qui gnrent des squences peuvent parfois avoir des itrateurs comme
argument (exemple: set(range(10)))
La mthode dict() utilise une liste de tuples pour initialiser un dictionnaire avec la fonction
dict. Combiner dict et zip permet de crer de manire concise un dictionnaire.
78
>>> t = [(d, 3), (e, 4), (f, 5)]

>>> d = dict(t)
>>> print(d)
{e: 4, d: 3, f: 5}
>>> d = dict(zip(abc,range(3)))
>>> print(d)
{a: 0, c: 2, b: 1}
La mthode update() sur un dictionnaire prend une liste de tuples en argument et les ajoute
au dictionnaire existant. En combinant items, lassignation de tuples et une boucle for, on peut
facilement traverser les cls et les valeurs dun dictionnaire.
>>> d[a] = 0
>>> d.update(zip(bcd,range(1,4)))
>>> for key, val in d.items():
...
print(key, val)
a 0
c 2
b 1
d 3
7.3.1 Gather et scatter

Pour dfinir ses propres fonctions avec un nombre indfini darguments, on utilise un paramtre
dont le nom commence par *. Ce paramtre rassemble (gather) les arguments en un tuple, quel
que soit leur nombre.
>>> def f(*args):
...
print(type(args), of length, len(args))
...
print(args)
>>> f(2, 4)
<type tuple> of length 2 (2, 4)
>>> f(hello,2.0,[1, 2])
<type tuple> of length 3 (hello, 2.0, [1, 2])
Remarque : il ne peut y avoir quun seul paramtre de ce type, et il doit se trouver la fin de la
liste des paramtres.
On peut combiner loprateur gather * avec des paramtres requis et optionnels (avec valeurs
par dfaut). On commence par les paramtres requis, puis les optionnels et enfin le paramtre
de taille variable.
>>> def g(required, optional=0, *args):
...
print(required:, required)
...
print(optional:, optional)
...
print(others:, args)
>>> g()
TypeError: g() takes at least 1 argument (0 given)
7.3. Changement de type
79
>>> g(1)
required: 1
optional: 0
others: ()
>>> g(1,2)
required: 1
optional: 2
others: ()
>>> g(1,2,3)
required: 1
optional: 2
others: (3,)
>>> g(1,2,3,4)
required: 1
optional: 2
others: (3, 4)
Loprateur * appliqu sur un tuple lors de lappel une fonction permet galement de faire
linverse : il spare le tuple en une squence darguments.
>>> help(divmod)
Help on built-in function divmod in module __builtin__:
divmod(...)
divmod(x, y) -> (div, mod)
Return the tuple ((x-x%y)/y, x%y). Invariant: div*y + mod == x.

>>> t = (7,3)
>>> divmod(t)
TypeError: divmod expected 2 arguments, got 1
>>> divmod(*t)
(2, 1)
80
Warning: Nous avons vu que les squences peuvent tre manipules soit avec des oprateurs (+, *, ...) soit avec des mthodes. En fait les oprateurs sont des notations alternatives
de mthodes.
Par exemple si lon demande la liste des attributs dun entier (2 par exemple),
>>> dir(2)
[__abs__, __add__, __and__, __bool__,
__ceil__, __class__, __delattr__, __divmod__, __doc__,
__eq__, __float__, __floor__, __floordiv__, __format__,
__ge__, __getattribute__, __getnewargs__, __gt__,
__hash__, __index__, __init__, __int__, __invert__,
__le__, __lshift__, __lt__, __mod__, __mul__, __ne__,
__neg__, __new__, __or__, __pos__, __pow__, __radd__,
__rand__, __rdivmod__, __reduce__, __reduce_ex__,
__repr__, __rfloordiv__, __rlshift__, __rmod__,
__rmul__, __ror__, __round__, __rpow__, __rrshift__,
__rshift__, __rsub__, __rtruediv__, __rxor__,
__setattr__, __sizeof__, __str__, __sub__,
__subclasshook__, __truediv__, __trunc__, __xor__,
bit_length, conjugate, denominator, from_bytes, imag,
numerator, real, to_bytes]
la mthode __add__ apparat : lopration + renvoie cette mthode qui sexcute donc
lors de lappel lopration.
Pour ne pas crire de code erron, il est, en particulier, essentiel de bien connatre leffet
dune mthode: si lobjet est non modifiable (valeur simple, styring, tuple, ...), gnralement,
la mthode renvoie un rsultat (diffrent de None); dans le cas des objets modifiables (list,
dict, set, ...), il faut bien voir, si leffet de la mthode est
de modifier lobjet mais renvoie None
de renvoyer un rsultat sans modifier lobjet
la fois de modifier lobjet et de renvoyer un rsultat.
7.3. Changement de type
81
82
CHAPTER
EIGHT
RECHERCHES ET TRIS
Un certain nombre dalgorithmes font partie de la culture informatique. Parmi ceux-ci, les
algorithmes de
recherche de llment minimum (ou maximum) dans une squence;
recherche dun lment dans un ensemble reprsent sous une forme ou une autre
(squence, squence trie, structure plus labore);
tri des lments dune squence
sont probablement les classiques des classiques. Je me dois donc den donner une version
Python.
Heureusement pour le programmeur, mais malheureusement pour lalgorithmicien dsirant
utiliser ses connaissances, ces fonctions sont dj implmentes en Python:
>>> texte = "voici mon texte qui contient le mot que je cherche"
>>> min(texte) # lespace est llment qui a le plus petit code dans ce texte

>>> if "mot" in texte:
...
print("mot est dans mon texte")
...
mot est dans mon texte
>>> copains = ["Michelle", "Marie", "Alain", "Sophie", "Didier", "Ariane", "Gill
... "Bernadette", "Philippe", "Anne-Franoise", "Pierre"]
>>> x = input("Dis-moi ton nom")
>>> if x in copains:
...
print("bonjour", x)
...
bonjour Gilles
>>> copains.sort()
>>> for c in copains:
...
print(c)
...
Alain
Anne-Franoise
Ariane
Bernadette
Didier
Gilles
83
Marie
Michelle
Philippe
Pierre
Sophie
Notons quune recherche du minimum ou un tri dpend dun ordre.

Un ordre pour un ensemble S dlments est une relation R rflexive, transitive et antisymtrique. (Dans certains ouvrages, un ordre est une relation irrflexive, transitive et antisymtrique. Dans ce cas nous parlerons dordre strict.). Lordre R est total si pour toute paire
(a,b) dlments de S, a R b ou b R a. Sinon, on dit que lordre est partiel, ce qui signifie quil
peut exister des lments a,b tels que ni a R b ni b R a ne sont vrifies.
Dans dautres langages o sont disponibles le if, while et for avec un indice (for i in
range(len(s)), mais o la recherche ou le tri ne sont pas fournis au dpart, on a des fonctions
qui ressemblent aux codes suivants ( la syntaxe prs). On suppose que les algorithmes de
recherche ou de tri se passent sur des squences (des listes pour les tris) dont les lments sont
des tuples (cls, information satellite).
Exemple: un annuaire: chaque cl est donne par les prnom et nom dune personne et
linformation satellite est son adresse.
Les recherches et tris se font partir des cls (recherche un lment ayant cette cl ou trie selon
les cls) mais en cas de tri, tout llment y compris linformation satellite doit tre dplac.
On suppose que chaque lment s[i] de la liste s contient la cl en s[i][0] (et donc
linformation satellite en s[i][1])
8.1 Les classiques : recherches

8.1.1 Recherche de llment minimum dans une squence
Le principe est de retenir lindice du meilleur candidat trouv jusqu prsent (0 au dpart) et
de parcourir la squence compltement en comparant avec le candidat actuel.
def indice_min(s):
res = 0
for i in range(1,len(s)):
if s[i][0] < s[res][0]:
res = i
return res
Notons quici cest lindice du minimum qui est renvoy: cela permet davoir la fois sa valeur
s[indice_min(s)] mais aussi sa position.
84
Chapter 8. Recherches et tris
8.1.2 Recherche squentielle

Le principe est de parcourir squentiellement la squence jusqu avoir trouv ou tre arriv en
fin de squence. Notez lutilisation de lvaluation paresseuse avec loprateur and.
De nouveau, cest lindice dans s o se trouve la premire instance de x qui est retourne.
def recherche(s,x):
""" donne lindice o se trouve la valeur de x dans s (-1 si nexiste pas) ""
i = 0
while i < len(s) and s[i][0] != x:
i = i+1
if i == len(s):
i = -1 # pas trouv
return i
Version amliore
Si s est modifiable on peut ajouter llment recherch (et ensuite le retirer la fin).
def recherche(s,x):
"""
donne lindice o se trouve la valeur de x dans s (-1 si nexiste pas)
version amliore quand s est modifiable
"""
i = 0
s.append((x,0))
while s[i][0] != x: # ne teste pas si on est en fin de squence
i = i+1
del s[-1]
if i == len(s):
i = -1 # pas trouv
return i
8.1.3 Recherche dichotomique (ou binaire)

Cet algorithme effectue la recherche de la position dun lment, de cl x donne, dans une liste
n lments indics 0..n - 1 ; mais ici la liste est obligatoirement trie en ordre non dcroissant
sur les cls , ce qui veut dire que pour tout indice i et j de la liste avec i <= j on a srement
s[i][0] <= s[j][0].
Dfinissons nous une fonction recherche_dichotomique qui reoit la liste s et la cl x et dont
le rsultat est lindice, dans s, dun lment quelconque dont la cl vaut x (ou -1 si x nest pas
dans s). Sachant que x est suppos tre dans la liste s, la recherche seffectue dans la tranche
de liste s[bi:bs]. Initialement bi = 0 et bs = len(s).
La recherche de x dans s[bi:bs] consiste regarder llment milieu dindice m = (bi + bs)//2.
1. Soit s[m][0] < x et il faut recommencer la recherche avec une nouvelle borne infrieure
(bi = m + 1).
8.1. Les classiques : recherches
85
2. Soit s[m][0] > x et il faut recommencer la recherche avec une nouvelle borne suprieure
(bs = m - 1).
3. Soit s[m][0] = x et m est lindice recherch.
Cette recherche se termine soit lorsque s[m][0] = x soit lorsque la tranche [bi:bs] est vide. Dans
le premier cas m est lindice recherch sinon, par convention, le rsultat de la recherche vaudra
-1.
def recherche_dichotomique(s,x):
"""
recherche dichotomique ou binaire de x dans s
rsultat:
donne lindice o se trouve la valeur de x dans s
(-1 si nexiste pas)
"""
bi, bs = 0, len(s)
m = (bi+bs)//2
while bi < bs and x != s[m][0]:
m = (bi+bs)//2
if s[m][0] < x:
bi = m+1
else:
bs = m # x est avant ou est trouv
len(s) <= m or s[m][0] != x:
m = -1
return m
if
# pas trouv
8.2 Les classiques : tris

Trier une collection dobjets est lopration qui consiste les ranger selon lordre donn. Un tel
rangement revient effectuer une permutation des lments pour les ordonner. Gnralement
la relation <= est utilise comme relation dordre.
Le tri peut tre effectu
soit par ordre croissant (ou plus prcisment, non dcroissant), ce qui signifie quon aura
pour tout couple dindice i, j avec i<j: s[i] <= s[j]
soit par ordre dcroissant (ou plus prcisment, non croissant), ce qui signifie quon aura
pour tout couple dindice i, j avec i<j: s[i] >= s[j].
Ici aussi on considre que les algorithmes de tri manipulent des listes dlments chacun contenant:
une cl,
une information satellite.
Par exemple, on pourrait avoir besoin de trier un tableau contenant des informations sur des
personnes:
86
les noms et prnoms peuvent constituer la cl sur laquelle on effectue les comparaisons
pour trier les valeurs,
les autres informations constituent linformation satellite associe.
Ainsi, aprs le tri, le tableau contiendra les informations sur les personnes, classes dans lordre
alphabtique de leur nom. La figure suivante illustre un tel tableau avant et aprs le tri.
Avant le tri
Nom
Vanbegin Marc
Dupont Jean
Pascal Paul
Van Aa Michel
Dupont Jean
Milcamps Ren
Alexandre Eric
Adresse
Av. Louise
rue du Moulin
...
...
rue du Chteau
rue de Lige
...
Aprs le tri
Nom
Alexandre Eric
Dupont Jean
Dupont Jean
Milcamps Ren
Pascal Paul
Van Aa Michel
Vanbegin Marc
Adresse
...
rue du Moulin
rue du Chteau
rue de Lige
...
...
Av. Louise
Plusieurs remarques peuvent tre formules partir de lexemple prcdent.

Tout dabord, la relation dordre doit tre prcisment dfinie. Ici nous avons ignor les espaces
ventuels et considr que les lettres majuscules sont quivalentes aux minuscules.
Ainsi: Van Aa = vanaa < vanbegin = Vanbegin.
Nous pouvons galement constater que 2 Dupont Jean se trouvent dans la table; lalgorithme
de tri peut, a priori, les classer dans nimporte quel ordre. Dans le cas o la table contient 2
entres de mme cl, il est parfois important que lalgorithme de tri conserve lancien ordre
relatif: on dira alors que la mthode de tri est stable. On avait
en indice 2 <Dupont Jean, rue du Moulin>
en indice 5 <Dupont Jean, rue du Chteau>
et donc, si lalgorithme est stable, la fin, <Dupont Jean, rue du Moulin> doit rester avant
<Dupont Jean, rue du Chteau>
Il existe de nombreuses mthodes de tri. Dans les sections suivantes nous donnerons 4 mthodes de tri; chacune dentre elles sera un reprsentant simple dune technique de tri classiquement utilise.
Dautres mthodes de tri ne seront pas prsentes ici car elles font appel des techniques de
programmation non encore tudies jusqu prsent.
8.2. Les classiques : tris
87
Comme pour les algorithmes de recherche, nous allons prsenter nos algorithmes de tri sur des
listes s dlments (les valeurs de s[i][0] reprsentant les cls).
Notons galement que les tris prsents ci-dessous rangent les lments par ordre non dcroissant.
8.2.1 Tri par slection

Le tri par slection prsent ici est lexemple le plus simple des tris qui utilisent la technique
consistant slectionner les lments trier dans un certain ordre, afin de les mettre, un par un,
leur place dfinitive.
chaque tape, la slection consiste reprer un lment minimum parmi les lments qui
nont pas encore t correctement placs, et le placer sa position dfinitive.
Si parmi les lments non encore placs correctement, il existe plusieurs valeurs minimales,
la slection choisit le premier, cest--dire celui qui a un indice minimum, afin que le tri soit
stable.
Ainsi, ltape 0, cest--dire la premire tape o lon traite s[0], la slection
choisit un minimum dans toute la liste (entre lindice 0 et lindice n-1 inclus), et
lchange avec s[0].
la deuxime tape le minimum slectionn dans lintervalle entre 1 et n-1 de s est chang
avec s[1].
Ainsi, au dbut de ltape i, les lments s[0] jusque s[i-1] ont dj pris leur place dfinitive, et
les lments s[i] jusque s[n-1] sont non encore tris mais on est assur que toutes les valeurs
de s[i] jusque s[n-1] sont suprieures ou gales toutes les valeurs s[0] jusque s[i-1] incluses
et en particulier s[i-1].
La situation de la liste au dbut de ltape i du tri par slection est illustr par la figure suivante
:
lments tris contenant les i-1
premiers minima
composantes 0 i-1
lments non tris contenant des valeurs

suprieures ou gales aux valeurs tries
composantes i n-1
Ainsi aprs ltape n-2, la liste s est entirement trie puisque s[n-1] est suprieur ou gal aux
lments s[0] jusque s[n-2] tris.
La figure suivante montre les tapes du tri par slection pour une liste dont on ne reprsente
que les cls valant 1 7.
88
3 7 2 6 5 1 4
1 7 2 6 5 3 4
1 2 7 6 5 3 4
1 2 3 6 5 7 4
1 2 3 4 5 7 6
1 2 3 4 5 7 6
1 2 3 4 5 6 7
Code du tri par slection dune liste s.
def tri_selection(s):
"""
Trie la liste s par slection
"""
n = len(s)
for i in range(n-1):
# recherche du min dans s[i..n]
min = i # min = indice du min provisoire
for j in range(i+1,n):
if s[j][0] < s[min][0]:
min = j
# placement du ime lment: change s[i]<->s[min]
s[min],s[i] = s[i],s[min]
Notons que ce tri nest pas stable.

Essayons de nous assurer que lalgorithme fonctionne correctement mme dans les cas limites.
Si n=0 ou 1, lalgorithme ne fait rien.
Sinon, si ltape i, le i+1me minimum est, au dpart, en indice i, lchange entre s[i]
et s[min] ne modifie rien.
8.2.2 Tri par insertion

La technique consiste considrer chaque lment trier, un par un et linsrer en bonne
place relative dans la partie des lments dj tris aux tapes prcdentes.
chaque tape, linsertion dun lment est effectue.
Au dpart, s[0] est llment de rfrence.
ltape 1, llment s[1] est plac correctement par rapport la partie dj trie, cest--dire
uniquement s[0].
la ime tape, s[i] est donc insr.
La figure suivante donne la situation de s au dbut de cette ime tape.
Situation de la liste au dbut de la ime tape du tri par insertion
89

lments tris entre eux
composantes 0 i-1
partie non encore modifie

composantes i n-1
La ime tape peut donc tre dcompose en 3 parties:

La recherche de la place j o doit sinsrer s[i],
Le dplacement vers la droite dune position des lments qui doivent se mettre aprs
llment insrer (car leur valeur est suprieure celle de s[i]),
Linsertion de s[i] sa nouvelle place.
Notons que la nouvelle place de la valeur insre x nest pas a priori, sa place dfinitive puisquil
se peut que dautres lments soient insrs, par aprs, avant x.
La figure suivante montre les tapes du tri par insertion pour une liste dont on ne reprsente que
les cls valant 1 7.
3 7 2 6 5 1 4
3 7 2 6 5 1 4
2 3 7 6 5 1 4
2 3 6 7 5 1 4
2 3 5 6 7 1 4
1 2 3 5 6 7 4
1 2 3 4 5 6 7
La procdure prsente la figure suivante effectue le tri par insertion en fusionnant la partie 2
et 3. En effet, la recherche de la nouvelle position de llment insrer (plac temporairement
dans Save se fait dans ce cas ci linairement en partant de lindice i-1 et en descendant. Tant
que s[j] est strictement suprieur llment insrer, on le dplace en s[j+1] et on dcrmente
j.
def tri_insertion(s):
"""
Trie liste s par insertion
"""
n = len(s)
for i in range(1,n):
Save = s[i]
#utilis pour lchange
# insertion de s[i]
j = i-1
while j>=0 and s[j][0] > Save[0]:
s[j+1] = s[j]
j=j-1
s[j+1] = Save
Lalgorithme fonctionne mme si n=0 ou 1 (dans ces cas il ne fait rien) et est stable.
90
8.2.3 Tri par change (Bulle)

La technique dchange consiste comparer les lments de la liste, 2 par 2, et les permuter
(ou changer) sils ne sont pas dans le bon ordre, jusqu ce que la liste soit compltement trie.
Le tri Bulle effectue des comparaisons entre voisins.
la premire tape, s[0] et s[1] sont compars et ventuellement permuts. Ensuite,
lalgorithme compare s[1] et s[2], et ainsi de suite jusque s[n-2] et s[n-1]. Etant parti de
s[0] jusqu s[n-2], on peut voir quaprs cette premire tape, s[n-1] contiendra le maximum
des valeurs de s, la sous-liste de s dindices 0..(n-2) contenant les autres valeurs dj lgrement
rorganises.
la 2me tape, on recommence donc les comparaisons/changes pour les valeurs entre s[0]
et s[n-2], ce qui aura pour effet de mettre en place dans s[n-2], le second maximum et de
rorganiser nouveau lgrement les autres valeurs dans la sous-liste de s dindices 0..(n-3).
la ime tape, on devra donc rorganiser la sous-liste de s dindices 0..(n-i).
La figure suivante montre les tapes du tri Bulle dune liste dont on ne reprsente que les cls
valant 1 7.
Code du tri Bulle :

def tri_bulle(s):
"""
Trie les n premires composantes de la liste s
par mthode Bulle
"""
n = len(s)
for i in range(n,1,-1): # rarrange s[0..i]
for j in range(i-1):
if s[j][0] > s[j+1][0]:
s[j], s[j+1] = s[j+1], s[j]
Notons que lalgorithme donn donne un tri stable.
91
8.2.4 Tri par numration (comptage)

La technique de tri par numration consiste, grosso modo,
compter le nombre n_i de valeurs infrieures ou gales toute valeur s[i][0] de la liste
trier,
sachant que n_i valeurs devront tre places avant la valeur s[i], placer cette dernire
sa position dfinitive.
Pour que cette technique soit praticable, il faut:
que lintervalle des valeurs possibles dans s soit petit,
que lon puisse travailler avec une liste w de mme type que s.
Si le nombre de valeurs diffrentes possibles est grand (fort suprieur n), lalgorithme devient
non efficace et prend trop de place mmoire.
Nous supposons ici que les valeurs possibles sont dans lintervalle [0..m-1]. Lalgorithme doit
se rserver une liste count de m composantes entires (dindice 0..m-1), qui est utilise pour
effectuer le comptage des valeurs. m ne peut donc pas tre trop grand.
Lalgorithme effectue plusieurs tches successives:
le comptage dans la liste count du nombre de chacune des valeurs possibles (initialement
count[0] = -1), les autres compteurs sont mis 0; ceci permet la fin de placer les
lments aux positions 0 n-1.
le calcul dans les diffrentes entres count[i] du nombre de valeurs infrieures ou gales
i: cette tape revient sommer dans count[i], les valeurs de count[0] count[i] calcules
ltape 1.
le placement dans w des lments de s de faon trie. Cette tape se base sur le fait
quaprs ltape 2, si count[i] = p, un lment de valeur i pourra se mettre en position p
dans w, le suivant en position p-1, ....
le copiage de w dans s pour remettre le rsultat dans la liste initiale.
Lalgorithme est donn par le code:
m = 5
def tri_enumeration(s):
"""
Trie les n premires composantes de la liste s
par numration
"""
n = len(s)
w = [0]*n
count = [-1]+[0]*(m-1)
# 1 Comptage
for j in range(n):
count[s[j][0]] +=1
92
# 2 Cumul des compteurs

for i in range(1,m):
count[i] += count[i-1]
# 3 Placement des lments dans w
for j in range(n-1,-1,-1):
w[count[s[j][0]]] = s[j]
count[s[j][0]] -= 1
# 4 Recopiage de w dans s
s[:] = w
Notons que:
ltape 3. procde par un for dont la variable de contrle a sa valeur qui va en dcroissant,
ceci pour que le tri soit stable.
Si m < n ce tri est trs efficace (voir plus loin).
93
94
CHAPTER
NINE
NOTION DE COMPLEXIT ET GRAND

O
See Also:
Rfrence: livre de Thomas Cormen, Charles Leiserson, Ronald Rivest, Clifford Stein - Algorithmique
Thomas Cormen, Charles Leiserson, Ronald Rivest, Clifford Stein - Algorithmique - 3me dition - Cours avec 957 exercices et 158 problmes, Dunod, 2010,
ISBN: 978-2-10-054526-1 http://www.books-by-isbn.com/2-10/2100545264Algorithmique-Cours-avec-957-exercices-et-158-problemes-2-10-054526-4.html
9.1 Motivation
Montrer quune version dun programme est plus efficace quune autre nest, a priori, pas ais.
La succession ou limbrication des tests et des boucles et la multitude des possibilits fait
quil nest gnralement pas possible ou raisonnable dvaluer lefficacit de lalgorithme pour
chaque cas possible.
Dans ce chapitre, nous donnerons un aperu des techniques et mthodes destimation de
lefficacit dun algorithme. En particulier nous dfinirons la notation grand O qui permettra de classer les algorithmes selon leur type defficacit sans devoir dtailler le nombre exact
dinstructions excutes par lalgorithme.
9.1.1 Critres de choix dun algorithme

Gnralement, il existe plusieurs mthodes pour rsoudre un mme problme. Il faut alors en
choisir une et concevoir un algorithme pour cette mthode de telle sorte que cet algorithme
satisfasse le mieux possible aux exigences.
Parmi les critres de slection dune mthode et en consquence dun algorithme, deux critres
prdominent: la simplicit et lefficacit de cet algorithme.
Si parfois ces critres vont de paire, bien souvent ils sont contradictoires; un algorithme efficace
est, en effet, bien souvent compliqu et fait appel des mthodes fort labores. Le concepteur
95
doit alors choisir entre la simplicit et lefficacit.

Si lalgorithme devra tre mis en oeuvre sur un nombre limit de donnes qui ne demanderont
quun nombre limit de calculs, cet algorithme doit de prfrence tre simple. En effet un
algorithme simple est plus facile concevoir et a moins de chance dtre erron que ne le sera
un algorithme complexe.
Si, par contre, un algorithme est frquemment excut pour une masse importante de donnes,
il doit tre le plus efficace possible.
Au lieu de parler de lefficacit dun algorithme, on parlera gnralement de la notion oppose,
savoir, de la complexit dun algorithme.
La complexit dun algorithme ou dun programme peut tre mesure de diverses faons.
Gnralement, le temps dexcution est la mesure principale de la complexit dun algorithme.
Dautres mesures sont possibles dont:
la quantit despace mmoire occupe par le programme et en particulier par ses variables;
la quantit despace disque ncessaire pour que le programme sexcute;
la quantit dinformation qui doit tre transfre (par lecture ou criture) entre le programme et les disques ou entre le programme et des serveurs externes via un rseau;
...
Nous nallons pas considrer de programme qui change un grand nombre dinformations avec
des disques ou un autre ordinateur.
En gnral nous analyserons le temps dexcution dun programme pour valuer sa complexit.
La mesure de lespace mmoire occup par les variables sera un autre critre qui pourra tre
utilis ici.
De faon gnrale, la complexit dun algorithme pour un ensemble de ressources donn est
une mesure de la quantit de ces ressources utilises par cet algorithme.
Le critre que nous utiliserons dans la suite est un nombre dactions lmentaires excutes.
Nous prendrons soin, avant toute chose, de prciser le type dactions prises en compte et si
nous voulons une complexit minimale, moyenne ou maximale.
Nous verrons que, gnralement, la complexit dun algorithme est exprime par une fonction
qui dpend de la taille du problme rsoudre.
9.1.2 Exemple: la recherche du minimum

Le travail ncessaire pour quun programme sexcute dpend de la taille du jeu de donnes
fourni.
Par exemple, si nous analysons la fonction indice_min(s) donne au dbut du chapitre,
(recherche lindice de llment de valeur minimale dans une liste s, il est intuitivement normal que cet algorithme prenne un temps proportionnel len(s), et soit not, par exemple,
T(len(s)).
96
Chapter 9. Notion de complexit et grand O
Dnotons len(s) = n. n est la taille de la liste et donc par extension, galement la taille du
problme.
Redonnons ici la partie traitement de cet algorithme en ayant eu soin de transformer le for en
while pour mieux dtailler chaque tape dexcution de lalgorithme et nous supposons n =
len(s) connu dans le programme :
res = 0
i = 1
while i< n :
if s[i][0] < s[res][0]:
res = i
i = i+1
return res
#
#
#
#
#
#
#
1
2
3
4
5
6
7
Pour obtenir des rsultats qui restent valables quel que soit lordinateur utilis, il faut raliser
des calculs simples donnant une approximation dans une unit qui soit indpendante du processeur utilis. On peut, par exemple, faire lapproximation que chaque assignation de donne
simple ou test lmentaire reprsente une unit de temps dexcution.
Dautres hypothses auraient pu tre faites. Par exemple, on aurait pu ne considrer que les
assignations et rechercher la complexit en nombre dassignations, ou ne considrer que les
tests et rechercher la complexit en nombres de tests effectus par lalgorithme.
La complexit dpend donc fortement de lunit prise qui doit tre clairement prcise.
Avec nos hypothses, les instructions des lignes 1, 2 et 7 prennent chacune une unit de temps
dexcution.
La boucle while de la ligne 3 6 sexcute n-1 fois, mais le test seffectue n fois. La ligne 3
prend n units et la ligne 6, n-1 units.
Le test de la ligne 4 prend une unit; il est effectu n-1 fois et donc la ligne 4 utilisera au total
n-1 units.
Lassignation de la ligne 5 prend une unit. Elle nest effectue que lorsque le test du if est
vrifi. Si lon ne dsire pas uniquement faire une seule mesure sur un jeu de donnes bien
prcis, il faut donc expliciter si lon dsire connatre le temps dexcution dans le meilleur des
cas T_min(n), le pire des cas T_MAX(n)), ou en moyenne T_moyen(n). Ici:
T_min(n) est donn dans le cas o le test du if nest jamais vrifi, ce qui signifie
que le minimum se trouve la premire composante. On a alors: T_min(n) =
1+1+n+(n-1)+(n-1)+1=3n+1
T_MAX(n) est donn dans le cas o le test du if est chaque fois vrifi, ce qui correspond au cas o toutes les valeurs de s sont distinctes et tries en ordre dcroissant. On a alors: T_MAX(n) = 1+1+n+(n-1)+(n-1)+(n-1)+1= 4n
Le calcul de T_moyen(n) est gnralement beaucoup plus difficile effectuer. Pour cela, on
peut faire des hypothses sur les jeux de donnes possibles et leur distribution statistique; ces
hypothses doivent tre le plus raliste possible. Pour que le calcul de T_moyen(n) ne soit pas
trop compliqu, on tolre gnralement certaines hypothses simplificatrices. Nous pouvons,
par exemple, supposer que toutes les valeurs dans s sont distinctes et faire lhypothse que la
distribution des valeurs est uniforme, la liste tant non trie a priori.
9.1. Motivation
97
Pour faire ce calcul, sparons les actions dues au while, au if et lassignation finale, des
actions dassignation de la variable res et posons:
C(n) = le nombre moyen dassignations res pour une liste de taille n
Si nous posons R(n) = le nombre dactions dues au while, au if et lassignation finale, ce
nombre est connu et vaut: R(n) = 3n.
Nous avons: T_moyen(n) = C(n) + R(n)
Pour exprimer la valeur de C(n), regardons dabord sa valeur pour n valant 1,2, ...
Pour n valant 1, C(1)=1 puisquil y a une assignation en dbut, et que le corps de la boucle
while ne sexcute jamais.
Pour n valant 2, la liste contient une valeur maximale Max et une valeur minimale min. Deux
possibilits quiprobables peuvent se prsenter:
1. s = min suivi de Max
2. s = Max suivi de min
Le cas 1. donne une assignation et le cas 2. deux assignations, soit en moyenne: C(2) = 3/2
Essayons davoir une expression gnrale pour C(n): s[0] a une chance sur n dtre le minimum, une chance sur n dtre le deuxime minimum, .... Donc s[0] a 1/n chance dtre le ime
minimum et cela pour tout i entre 1 et n.
Si nous posons C(0) = 0 et si dans la sous-liste quil reste traiter il y a j lments plus petits
que le minimum provisoire, le nombre dassignations quil faudra encore effectuer vaudra,
daprs la dfinition donne, C(j), car les nombres plus grands que le minimum provisoire
nimpliqueront aucune assignation supplmentaire. Ce raisonnement est valable pour tout i >=
1.
En consquence:
i1
1
C(i) = 1 +
C(j)
i j=0
(i 1)
le 1 tant d la premire assignation (cest--dire linstruction 1).

Pour avoir une ide prcise de la valeur de C(n), il faut liminer les C(j) du membre de droite.
Pour cela exprimons cette quation dune autre faon en le multipliant par i
i.C(i) = i +
i1
C(j)
j=1
et de mme si on multiplie C(i+1) par i+1:
98
(i + 1).C(i + 1) = (i + 1) +
C(j)
j=1
En soustrayant la seconde quation de la troisime nous obtenons:
(i + 1).C(i + 1) i.C(i) = 1 + C(i)

Ce qui peut scrire:
C(i + 1) =
1
+ C(i)
i+1
(i 1)
Pour C(1) la formule reste vrai (C(1)=1)

Et donc:
1
1
1
C(n) = +
+ ... + 1 =
n n1
i
i=1
Notons que nous aurions pu dduire ce rsultat plus rapidement en exprimant que C(i+1) vaut
le nombre moyen dassignations d la recherche du minimum pour les i premiers nombres,
cest--dire C(i), plus la probabilit que le nombre s[i] soit le minimum, cest--dire 1/i+1, ce
qui nous redonne lquation prcdente.
Pour effectuer une approximation de C(n), valuons les aires S1 et S2 donnes en gris dans la
figure suivante o la fonction f(x) = 1/x.
f(x) = 1/x
= S1
2
= S2
x
1
Ayant
n+1
n+1
1
dx = n(n + 1)
x
on voit que
S2 < n(n + 1) < S1

9.1. Motivation
99
Comme
1
1
1
S1 = 1 + + . . . + =
= C(n)
2
n
i
i=1
n+1
1
1 1
1
S2 = + + . . . +
=
= C(n + 1) 1
2 3
n+1
i
i=2
et ceci pour tout n >= 1.

On a donc:
C(n + 1) 1 < n(n + 1) < C(n)
(n 1)
De ce fait:
C(n) < n(n) + 1
(n > 1)
Et finalement, comme ln(n) < ln(n+1), on obtient:
n(n) < C(n) < n(n) + 1

Cette dernire quation permet de borner T_moyen(n) (rappelons-nous que T_moyen(n) = C(n)
+ R(n) avec R(n) = 3n)
Nous obtenons donc:
3n + n(n) < Tmoyen (n) < 3n + n(n) + 1

9.1.3 Autre exemple: la recherche dun lment
Calculons les T_min(n), T_Max(n) et T_moyen(n) de lalgorithme de recherche dun lment
dans une liste s.
Redonnons ici la partie traitement de cet algorithme en supposant que n = len(s):
i = 0
while i < n and s[i][0] != x:
i = i+1
if i == n:
i = -1 # pas trouv
return i
#1
#2
#3
#4
#5
#6
T_min(n) est donn lorsque lon trouve directement llment.

Si lon suppose ici encore que toute assignation et tout test lmentaire prend une unit de
temps et que le test du while est compos de deux tests lmentaires (le temps pour le and tant
omis), on obtient: T_min(n) = 5 (cest--dire 1 en #1 + 2 en #2 + 1 en #4 + 1 en #6)
T_MAX(n) est donn dans le cas o llment x nest pas dans s: T_MAX(n) = 3n+5
100
T_moyen(n) dpend de la probabilit p que x soit dans s.

En supposant que si x est dans s, il a la mme probabilit dtre dans nimporte quelle composante s[i] (pour 0 <= i < n), en numrant les cas possibles on obtient:
Cas possibles
1: on trouve x en s[0]
2: on trouve x en s[1]
...
n: on trouve x en s[n-1]
Nombre dunits
3+2
6+2
3n+2
Si x est dans s:
moyen
=
=
=
3
n (1 + 2 + . . .
3(n+1)
+2
2
3
7
2n + 2
+ n) + 2
n
(puisque i=1 i =
(1+n)n
)
2
Si x nest pas dans s:

min = moyen = MAX = 3n+5
Finalement
3
7
3
3
Tmoyen (n) = (1 p)(3n + 5) + p( n + ) = (3 p)n + ( p + 5)
2
2
2
2
9.2 Le grand O
Les exemples prcdents montrent quil est souvent trs difficile de calculer le temps moyen
(ou maximal) dexcution dun algorithme. Ces calculs prcis sont, de plus, inutiles puisquils
se basent sur des approximations grossires du temps dexcution des actions lmentaires;
valuations qui ne tiennent pas non plus compte, par exemple, de lordinateur et du compilateur
ou de linterprteur utiliss.
Une valuation du temps dexcution dun algorithme ne devient gnralement intressante que
lorsque la taille du jeu de donnes, cest--dire de n dans nos exemples prcdents, est grande.
En effet pour n petit, les algorithmes sexcutent gnralement trs rapidement.
Supposons que la complexit maximale dun algorithme A = 100.n, que la complexit maximale dun algorithme B = 15.n^2 , celle de C = n^4 et celle de D = 2^n.
La table suivante donne les valeurs de complexit pour n = 1,10,100,1000, 10^6 et 10^9; les
figures qui suivent donnent les valeurs des fonctions respectivement pour n variant entre 0 et
12, et 0 et 18.
9.2. Le grand O
101
n=
1
10
100
1000
10000
106
109
A
100
1000
10000
100000
106
108
1011
B
15
1500
150000
15.106
15.108
15.1012
15.1018
C
1
10000
108
1012
1016
1024
1036
D
2
103
1030
10300
103000
10300000
8
103.10
Valeur de 100.n, 15.n^2, n^4 et 2^n pour diffrentes valeurs de n

5000
4500
4000
3500
3000
2500
2000
1500
1000
500
0
0
10
12
Valeur des fonctions A = , B = - -, C = -.- et D = ... pour n allant de 0 12
102
x10 4
12
10
10
12
14
16
18
Valeur des fonctions A = , B = - -, C = -.- et D = ... pour n allant de 0 18

Ces valeurs doivent tre divises par le nombre dinstructions lmentaires par seconde pour
obtenir un temps exprim en seconde.
Les micro ou mini ordinateurs actuels permettent dexcuter de lordre de 10^9 instructions par
seconde soit environ 10^14 instructions par jour.
Cela signifie quen un jour, si aucune autre limitation ne perturbe lexcution des algorithmes
(telle que lespace mmoire disponible par exemple), on peut rsoudre avec lalgorithme
A , un problme pour n valant approximativement 10^12
B , un problme pour n valant approximativement 10^7
C , un problme pour n valant approximativement 3000
D , un problme pour n valant approximativement 50
et donc A est meilleur que B, B est meilleur que C et C est meilleur que D (sauf pour de petites
valeurs de n).
En vertu des remarques prcdentes et de ces chiffres, on prfre donner un ordre de grandeur
permettant davoir une ide du type dalgorithme. Pour cela, on utilise la notation grand O
dfinie ci-dessous, qui permet:
de dterminer si un algorithme a une chance de sexcuter pour un n donn,
9.2. Le grand O
103
connaissant le temps dexcution pour un n donn, de faire une approximation de ce

temps pour une autre valeur de n.
9.2.1 Dfinition
La notation grand O est dfinie comme suit:
Dfinition (O) : Une complexit T(n) est dite en grand O de f(n) (en O(f(n)) sil existe un
entier N et une constante c > 0 tels que pour tout entier n > N nous avons T(n) <= c.f(n)
Cette dfinition permet deffectuer de nombreuses simplifications dans les calculs. En effet de
cette dfinition il rsulte que:
Les facteurs constants ne sont pas importants. En effet, si par exemple T(n)=n ou si
T(n)=100n, T(n) est toujours en O(n)
Les termes dordres infrieurs sont ngligeables. Ainsi si T(n) = n^3 + 4n^2 + 20n +
100, on peut voir que pour n > N = 5
n^3 > 4n^2
n^3 > 20n
n^3 > 100
et donc pour n>5, T(n) = n^3 + 4n^2 + 20.n + 100 < 4n^3.
De ce fait T(n) est en O(n^3).
9.2.2 Calcul du grand O

Classes de complexit
Si on peut calculer quun algorithme est un O(n^2 ), il nest pas intressant, mme si cela est
trivialement vrai, dexprimer le fait que T(n) est en O(n^3 ), O(n^4 ), ....
Lorsque lon value le grand O dune complexit, cest la meilleure estimation simple que
lon cherche obtenir.
Ainsi on classe gnralement les complexits dalgorithmes selon leur grand O comme donn
par la table suivante :
104

O
O(1)
O(log n)
O(n)
O(n log n)
O(n^2 )
O(n^3 )
O(2^n )
O(3^n )
...
O(n^n )
...
Classe dalgorithmes
constant
logarithmique
linaire
n log n
quadratique
cubique
exponentiel en base 2
exponentiel en base 3
exponentiel en base n
Classes de complexit
Dans la suite, nous essayerons toujours de donner une approximation de la complexit des
algorithmes vus.
Remarquons quen vertu du fait que pour tout a,b positif : log_a n = (log_a b).(log_b n)
et comme log_a b est une constante pour a et b fixs, si T(n) est en O(log_a n) il est galement
en O(log_b n). (la base du logarithme na donc pas dimportance pour exprimer un grand O).
Notons encore que ceci nest pas vrai pour la base des complexits exponentielles.
Donnons ici un petit nombre de rgles permettant dvaluer la complexit dun algorithme. Ces
rgles ne donnent en gnral quune surapproximation parfois grossire; une estimation plus
prcise devant tenir compte du fonctionnement de lalgorithme.
Rgles de calcul du grand O
Rgle sur lunit :
Rgle 1 (unit)
Il faut clairement dfinir lunit utilise et les lments pris en compte. Ainsi si lon tient
compte des tests lmentaires, des assignations, des lectures de donnes et des critures de
rsultats, une assignation une variable simple, une instruction input ou print dune donne
simple, ou lvaluation dune expression (ou dune condition) simple ne donnant pas lieu
lexcution de fonctions, prend un temps constant fix et est donc en O(1). Lassignation des
objets plus complexes ou des input ou print de donnes plus complexes peut ne plus tre en
O(1) en fonction de leur taille qui peut dpendre de la taille du problme (n).
Rgle de la squence :
Rgle 2 (squence)
9.2. Le grand O
105
Si un traitement 1 prend un temps T_1(n) qui est en O(f_1(n)) et un traitement 2 prend un temps
T_2(n) qui est en O(f_2(n)) alors le traitement 1 suivi du traitement 2 prend T_1(n) + T_2(n) et
est en
O(f_1(n) + f_2(n)) = O (max(f_1(n) , f_2(n)))
o max prend la fonction qui crot le plus vite cest--dire de plus grand ordre.
Par exemple si T_1(n) est en O(n^2 ) et T_2(n) est en O(n), T_1(n) + T_2(n) est en O(n^2 + n)
= O(n^2)
En particulier une squence dinstructions simples (dont on tient compte) ne faisant aucun appel
une procdure ou une fonction ne dpend pas de n et sont donc en O(1).
Rgle du if :
Rgle 3 (if)
Pour un if condition:
instruction_1 else:
instruction_2
o
instruction_1 est en O(f_1(n))
instruction_2 est en O(f_2(n))
lvaluation de la condition est en O(g(n))
suivant le test, le if sera en O(max(f_1(n),g(n))) ou en O(max(f_2(n),g(n))) et peut tre born
par:
O(max(f_1(n), f_2(n), g(n)))
Notons que souvent g(n) est en O(1).

Cette rgle peut tre gnralise pour une instruction if ayant une ou des parties elsif.
Rgle du while :
Rgle 4 (while)
Pour un while, sachant que le corps de la boucle est en O(f_1(n)) et que lvaluation de la
condition est en O(f_2(n)), si on a une fonction en O(g(n)) qui donne une borne suprieure
du nombre de fois que le corps sera excut, alors le while est en O(f(n).g(n)) avec f(n) =
max(f_1(n),f_2(n)).
Rgle du for :
106
Rgle 5 (for)
Pour une boucle for, il suffit de traduire le for en while.
Par exemple :
for i in range(n):
print(i)
se traduit en:
i=0
while i < n:
print(i)
i=i+1
La fonction iter() applique sur une squence ou un range, permet de pouvoir ensuite utiliser la
fonction next() sur lobjet produit.
Par exemple :
st = "bonjour"
for i in st:
print(i)
se traduit en:
st = "bonjour"
i = iter(st)
s=next(i)
while s != None:
print(s)
s=next(i)
Donnons de simples exemples de complexit avec des for o ici aussi n est la taille du problme
:
for i in range(10):
traitement
est en O(10.f(n)) o O(f(n)) est la complexit dune excution du traitement et donc le

code complet est galement en O(f(n))
for i in range(n):
traitement
est en O(n.f(n)) o O(f(n)) est la complexit dune excution du traitement.

Ainsi le produit de matrice (M.L par L.N) est en O(M.L.N).
Rgle de la fonction :
Rgle 6 (fonction)
9.2. Le grand O
107
Lappel une fonction est en O(f(n)) correspondant la complexit du traitement de cette

fonction pour les paramtres effectifs donns.
On peut raffiner ces calculs, selon que lon essaye de trouver une complexit minimale,
moyenne ou maximale. Ce raffinement se situera dans le nombre de fois quune instruction
sera rpte, ayant par exemple certaines hypothses sur la probabilit que certaines conditions
de if ou de boucles sont vrifies.
9.3 Application des rgles de calcul

Ayant ces rgles dvaluation du grand O pour chaque type dinstruction, le calcul de la complexit dun algorithme se fait en partant des complexits des instructions simples, et en calculant, de proche en proche, les complexits des instructions non simples partir des rsultats dj
calculs. Ces calculs procdent en quelque sorte par des regroupements en suivant la structure
de lalgorithme.
9.3.1 Complexit de la recherche du minimum

Prenons lexemple de la recherche du minimum cest--dire du traitement suivant (aprs traduction en utilisant un while en ayant n = len(s):
res = 0
i = 1
while i < n
:
if s[i][0] < s[res][0]:
res = i
i = i+1
return res
#1
#2
#3
#4
#5
#6
#7
Nous supposons que chaque instruction simple est prise en compte pour le calcul de la complexit.
Le traitement, comme tout algorithme, peut tre dcompos sous forme darbre (informatique)
comme donn par la figure suivante o chaque noeud reprsente une instruction Python simple
ou compose.
108
1-7
3-6
4-5
Dcomposition dun traitement en suivant la structure

Les noeuds sans fils, appels les feuilles de larbre, correspondant aux instructions 1, 2, 5, 6 et
7, reprsentent des instructions dassignations simples ou return qui, daprs la rgle 1, sont
en O(1).
De ce fait, daprs la rgle 3, le noeud 4-5 correspondant linstruction if est en O(1).
Daprs la rgle 2, la complexit de la squence dinstructions 4-6 est en O(1).
On peut maintenant valuer la complexit du while (noeud 3-6), il sexcute n-1 fois et la
complexit du corps de la boucle est, comme on vient de le voir, en O(1). Donc daprs la rgle
4, la complexit du while est en O(n).
Finalement, daprs la rgle 2, la complexit de tout le traitement est en O(1+1+n+1) qui peut
tre simplifi par O(n).
Note:
Si, par exemple, un algorithme A est en O(n) et un algorithme B est en O(n^2 ), A est
meilleur, en terme, de complexit que B.
Par contre si A et B sont tous les deux en O(f(n)), il faut dtailler le calcul de la complexit
pour dterminer lequel est plus complexe que lautre.
9.3. Application des rgles de calcul
109
Daprs la dfinition du O, lalgorithme de recherche du minimum est en O(n) et donc

trivialement galement en O(n^2), O(n^3), ..., O(n^n). Lorsque lon cherche la complexit dun algorithme, on essaye bien videmment de donner la valeur la plus prcise
(Exemple: O(n) pour la recherche du minimum)
Rappelons que lon peut valuer plusieurs complexits diffrentes. Par exemple, pour
les algorithmes de tris de liste, on peut regarder la complexit en terme de nombre
dinstructions ou seulement regarder les instructions qui effectuent des dplacements
dlments (le dplacement dun lment peut prendre beaucoup plus de temps que les
autres instructions). Certains tris sont en O(n^2) si lon regarde toutes les instructions,
mais en O(n) en terme de dplacement dinformations.
9.3.2 Complexit de la recherche squentielle et dichotomique

Il est facile de voir que lalgorithme de recherche squentielle est galement en O(n) o n est
la longueur de la liste et en supposant que les lments sont tests en O(1).
Pour calculer la complexit de la recherche dichotomique, en utilisant les rgles vues
prcdemment, on peut assez rapidement observer que la complexit moyenne ou maximale
en nombre dactions lmentaires de cet algorithme est en O(f(n)) o f(n) est le nombre respectivement moyen (f_moyen(n)) ou maximum (f_max(n)) de fois que la boucle while est
excute.
Pour valuer f_max(n), commenons par analyser le comportement de lalgorithme. Nous
pouvons tout dabord remarquer qu chaque tour de boucle, au pire des cas, lintervalle de
recherche est divis par deux, quelle que soit la valeur de x.
La figure suivante donne une volution possible de lintervalle de recherche dans s pour une
liste 100 lments en supposant que x nest pas dans s mais que s[40] < x < s[41]
110
intervalle de recherche
10
20
30
40
50
10
20
30
40
48
25 30
40
48
37
60
nombre d'lments
70
80
90
99
48
3 7 41
40 41
41
100
49
24
12
Evolution de lintervalle de recherche lors dune recherche dichotomique

Le while sexcute donc au maximum 7 fois. De faon gnrale on peut voir que:
2fmax (n)1 n < 2fmax (n)
et donc que f_max(n) <= log_2(n) + 1
La recherche dichotomique a donc une complexit maximale en O(ln n). On peut calculer que
la complexit moyenne (en supposant ou non que x est dans s) est galement en O(ln n).
9.3.3 Complexit du tri par slection

Pour calculer la complexit maximale du tri par slection, dcomposons lalgorithme sous
forme darbre en suivant sa structure; ceci est donn en figure suivante:
9.3. Application des rgles de calcul
111
1-13
6-13
9-11
13
10-11
11
Dcomposition du tri par slection

En supposant que toutes les instructions et les traitements de passages de paramtres interviennent dans ce calcul, en suivant les rgles pour calculer cette complexit, nous obtenons :
1, 5, 8, 11 et 13 , sont en O(1)
le if (10-11) est en O(1)
le for (9-11) imbriqu est en O(n-i) et peut tre born par O(n)
le for global (6-13) est en O(n^2)
la procdure tri_selection (1-13) est en O(n^2)
112
9.3.4 Complexit du tri par insertion

En analysant lalgorithme de tri par insertion, on peut voir que sa complexit maximale est
galement en O(n^2). On peut voir que la complexit minimale est rencontre dans le cas o la
liste est dj trie et vaut O(n)
9.3.5 Complexit du tri Bulle

Ici aussi la complexit maximale est en O(n^2). La complexit minimale est galement en
O(n^2).
9.3.6 Complexit du tri par numration

Si m < n, la complexit moyenne et maximale de ce tri est en O(n) ce qui est remarquable.
9.3.7 Quelques exemples intressants

Les exemples suivants viennent dinterrogation ou dexamens prcdents o lon considre que
m,l,n sont des paramtres entiers positifs.
i = 1
while i < n**3 :
i=i*2
for i in range(n):
for j in range(m):
for k in range(l):
print(hello)
i = 2
while i < n:
i=i*i
9.4 Complexit des mthodes de manipulation de

squences
Voir le site wiki python pour plus de dtails:
http://wiki.python.org/moin/TimeComplexity
On suppose que n est le nombre dlments dans la liste et k la valeur (ex: longueur) du
paramtre.
La complexit moyenne suppose que les paramtres sont gnrs uniformment de faon alatoire.
9.4. Complexit des mthodes de manipulation de squences
113
9.4.1 Complexit des oprations sur les listes

De faon interne, une liste est reprsente sous forme de vecteur o les composantes sont
contigus en mmoire et avec, en moyenne, de la place libre pour allonger la liste. La pire
opration est donc une insertion ou suppression en dbut de liste car toutes les composantes
doivent bouger. Malheureusement, au pire des cas, un simple s.append(x) peut demander
de recopier toute la liste sil ny a plus de place libre juste aprs la liste s.
Opration
Copy
Append
Insert
Get Item
Set Item
Delete Item
Iteration
Get Slice
Del Slice
Set Slice
Extend
Sort
Multiply
x in s
min(s), max(s)
len(s)
Complexit moyenne
O(n)
O(1)
O(n)
O(1)
O(1)
O(n)
O(n)
O(k)
O(n)
O(k+n)
O(k)
O(n log n)
O(nk)
O(n)
O(n)
O(1)
Complexit maximale
O(n)
O(n)
O(n)
O(1)
O(1)
O(n)
O(n)
O(k)
O(n)
O(n+k)
O(n+k)
O(n log n)
O(nk)
O(n)
O(n)
O(1)
9.4.2 Complexit des oprations sur les ensembles

Limplmentation des ensembles est similaire celle des dictionnaires.
Opration
x in s
s|t
s&t
s-t
s^t
Complexit moyenne
O(1)
O(len(s)+len(t))
O(max(len(s),len(t))
Complexit maximale
O(n)
O(len(s) * len(t))
O(len(s) * len(t))
O(len(s) * len(t))
O(len(s) * len(t))
9.4.3 Complexit des oprations sur les dictionnaires

La complexit moyenne suppose que les collisions sont rares avec la fonction de hashage (ce
qui est gnralement la cas).
Le cas moyen suppose que les paramtres sont choisis uniformment alatoirement parmi les
cls possibles.
114

Opration
Copy
Get Item
Set Item
Delete Item
Iteration
Complexit moyenne
O(n)
O(1)
O(1)
O(1)
O(n)
Complexit maximale
O(n)
O(n)
O(n)
O(n)
O(n)
9.4. Complexit des mthodes de manipulation de squences
115
116
CHAPTER
TEN
LOGIQUE, INVARIANT ET
VRIFICATION DALGORITHME
10.1 Introduction
Jusqu prsent nous avons expliqu nos algorithmes en dcrivant, de faon informelle, les diffrents traitements effectus par ceux-ci. Nous nous sommes assurs de leur bon fonctionnement en les testant sur certains exemples et, en particulier, sur des cas limites. Pour vrifier
compltement, en utilisant des tests, quun algorithme fonctionne correctement dans tous les
cas, il faudrait, en thorie, le tester avec toutes les donnes possibles, ce qui, en pratique, est
gnralement impossible vu le nombre norme de donnes possibles.
Notons que ceci est vrai si nous nous limitons aux algorithmes squentiels (une seule action
la fois), dterministes (2 excutions de lalgorithme avec les mmes donnes, donnent lieu
exactement au mme traitement). Si ce nest pas le cas, le problme de test ou de vrification
dun algorithme est beaucoup plus complexe.
Ce chapitre prsente, sur des exemples simples, le problme de la vrification dun algorithme. Le problme gnral de vrification complte dalgorithme est complexe et ne possde pas de mthode systmatique automatisable. Il est pourtant essentiel que le concepteur
dalgorithmes soit conscient des problmes et quil ait des notions de base en matire de vrification dalgorithmes. En effet, il est vident que la conception et la vrification dalgorithmes
vont de pair. En particulier, la notion dinvariant de boucle, prsente ci-dessous, est essentielle
pour comprendre comment fonctionne un programme.
Dans la suite de ce chapitre, aprs avoir fait un bref rappel de logique et avoir expliqu comment
formaliser en logique, ltat dun programme un endroit donn de son excution, nous allons
noncer le problme rsoudre en parlant de la notion de preuve partielle et totale, et ensuite,
prsenter la notion dinvariant de boucle qui, associe la notion de terminaison de boucle,
permet de vrifier un algorithme.
117
10.2 Rappel de logique

10.2.1 Le calcul des propositions
Syntaxe
Soit un ensemble P de propositions p, q, r, .... Nous dfinissons lensemble des formules f
possibles en logique des propositions par les dfinitions en Backus Naur Form (BNF) suivante:
f
f
f
f
::= p (p P)
::= f
::= f op f
::= (f )
avec
op ::= | | | |
(le ou inclusif, le et, et les implications droite gauche ou dans les deux sens).
Note: La dfinition prcdente utilise la notation Backus Naur Form (BNF). BNF est un
formalisme qui permet de dfinir un langage; par exemple lensemble des syntaxes possibles
pour une formule logique ou pour un programme Python. Les dfinitions donnent un systme
de rcriture o la notation f ::= p signifie f peut tre rcrit en p. Quand f peut tre rcrit en
p ou q on crit f ::= p , f :: q ou de faon plus compacte f ::= p | q.
Par exemple;
pq
est une formule correcte puisque la dfinition BNF permet la squence de rcriture suivante:
f
f op f
f f
pf
pq
De mme les formules suivantes peuvent tre obtenues:

p (q r)
(p q) r
Smantique
Une formule peut avoir la valeur vraie ou fausse suivant la valeur des diffrentes propositions.
Nous dirons que le domaine smantique dune formule est lensemble {True, False} (Vrai
ou Faux) (dnot aussi {T, F}). Nous parlons dinterprtation dune formule, cest--dire son
valuation, en ayant donn une valeur T ou F chaque proposition.
La smantique de chaque oprateur logique est dfinie grce sa table de vrit.
Par exemple: pour linterprtation v o v(p) = F et v(q) = T
118
Chapter 10. Logique, invariant et vrification dalgorithme

v(p q) = F
v(p q) = F
v(p q) = T
Pour viter de parenthser compltement les formules nous posons:

< , < , ,
o < signifie est plus prioritaire que.

Une formule logique est consistante si elle est vraie pour au moins une interprtation, et est
valide ou tautologique si elle est vraie pour toutes les interprtations.
Deux formules f_1 et f_2 sont (logiquement) quivalentes, dnot f_1 <=> f_2 (o <=> est
un mta-oprateur) si pour toute interprtation v, v(f_1) = v(f_2) cest--dire si f_1 <-> f_2 est
toujours vrai.
Par exemple:
pq qp
<=> est moins prioritaire que les autres oprateurs logiques.

Notons quune quivalence logique reste valable si lon substitue partout une proposition par
nimporte quelle formule (rgle de substitution uniforme).
La liste suivante donne quelques quivalences logiques reprsentatives:
f f
f f f f f
f1 f2 f2 f1
f1 f2 f2 f1
f1 f2 f2 f1
f1 (f2 f3 ) (f1 f2 ) f3
f1 (f2 f3 ) (f1 f2 ) f3
Tf f
Tf T
Ff F
Ff f
f1 f2 f1 f2
f1 T T
f1 F f1
T f2 f2
F f2 T
(p q) (p) (q)
(p q) (p) (q)
Enfin, si f_1 -> f_2 est valide (toujours vraie) nous disons que f_1 implique logiquement f_2 ou
que f_1 est une condition suffisante pour f_2 et que f_2 est une condition ncessaire pour f_1
(notation f_1 => f_2 o => est un mta-oprateur).
=> a la mme priorit que <=>.
10.2. Rappel de logique
119
10.2.2 La logique des prdicats

Pour pouvoir exprimer des contraintes sur des variables de programmes, il faut ajouter aux
formules logiques, la possibilit dutiliser des variables simples ou indices (listes, tuples...),
deffectuer des manipulations dexpressions arithmtiques et relationnelles. De plus il faut
ajouter les quantificateurs
(pour tout) , (il existe)
Le format gnral dune formule resp. pour tout et il existe est:

x f (x)
x f (x)
o f(x) est une formule qui utilise la variable x, variable qui est lie par le quantificateur existentiel (il existe) ou universel (pour tout).
Par opposition, les variables simples ou indices qui ne sont pas lies par un quantificateur sont
nommes variables libres.
x<y+1
x=7y=3
x (x y = 0 x = 0)
x (x y = 0 x = 0 y = 0)
:x
:x
:x
:x
et y sont libres
et y sont libres
est lie par x et y est libre
est lie par x et y est libre
Le pour tout et il existe sont moins prioritaires que la ngation mais sont plus prioritaires que
le et, ou, les implications, et les mta-oprateurs => et <=>. Notons que lavant dernire
formule est consistante (peut tre vraie) tandis que la dernire est valide (est vraie pour toute
interprtation).
De mme, la formule :
x (0 x < 0 x = 7)
est valide (toujours vraie) puisque 0 <= x < 0 est toujours fausse.
Cette logique est la logique des prdicats ou logique du premier ordre.
Les notions dquivalence et dimplication logiques sont tendues. La liste suivante donne
quelques quivalences logiques reprsentatives o f(x), f_1(x) et f_2(x) sont des formules utilisant la variable libre x:
1. x f (x) x f (x)
2. x f (x) x f (x)
3. Si le domaine des valeurs possibles pour x nest pas vide:
x f (x) x f (x) (sinon ce nest pas vrai)
4. x (f1 (x) f2 (x)) (x f1 (x) x f2 (x))
5. x (f1 (x) f2 (x)) (x f1 (x) x f2 (x))
120
10.3 Exprimer ltat du programme formellement

Pour simplifier nos propos, nous nallons travailler dans nos exemples, quavec des valeurs
simples (gnralement entires ou caractres) et des squences de valeurs simples.
Le formalisme logique va servir formaliser ltat dun programme au cours de son excution. Dans un premier temps, pour simplifier les explications, nous allons considrer du code
squentiel qui ne fait appel aucune fonction.
Supposons par exemple que le programme manipule une variable x, on va construire des propositions grce des oprateurs relationnels. Par exemple
x=3
reprsente un proposition vraie si x vaut 3 et fausse sinon (ici on utilise le symbole = pour
dsigner lgalit).
Par extension, la smantique de cette formule, sera lensemble des tats o cette formule est
vraie, et donc lensemble des tats du programme o x vaut 3, quelque soit la valeur des autres
variables.
Exemple:
En pratique nous allons dcrire ltat dun programme un moment de son excution. Cet
tat est constitu par la valeur de chacune de ses variables (ou plus prcisment des objets
rfrencs par ses variables) et du point de contrle, cest--dire lendroit (instruction) o se
trouve lexcution du programme.
Par exemple dans le code :
x = 3
y = 4
z = x * y
#1
#2
#3
on peut voir ltat du programme trois moments:

1. au dbut, cest--dire avant quaucune instruction naie t excute,
2. aprs lexcution de linstruction #1,
3. aprs #2, et
4. aprs #3.
Pour exprimer ces tats 1. 4. les formules logiques parleront de x, y et z.
Aprs #1 on a
x=3
Aprs #2, on a :
x=3y =4
Aprs #3, on a :
x = 3 y = 4 z = 12
10.3. Exprimer ltat du programme formellement
121
qui formalise la postcondition la plus forte (cest--dire qui a le plus de contraintes) que lon
peut imaginer avec ce code.
Notons que ltat du programme avant la premire instruction est, si aucune variable nest
initialise, quaucune contrainte sur la valeur des variables nexiste: dans ce cas, formalise
par la formule True dont la smantique est lensemble de tous les tats possibles.
De faon gnrale, la smantique dune formule f pour un programme donn, est lensemble
des tats o f est vraie. Donc quand on exprime quavec une prcondition donne Pre, le code
donne la postcondition Post, cela signifie que si lon prend nimporte quel tat de Pr en terme
de valeur de variables du programme satisfaisant Pr, la fin du code on sera dans un tat
satisfaisant Post cest--dire parmi lensemble des tats satisfaisant le rsultat Post.
Malheureusement les programmes, mme squentiels sans appels de fonctions, ne sont
gnralement pas si simples. En effet, le flux de lexcution du programme dpend videmment
des donnes lues qui vont influencer les tests des instructions conditionnelles (if) et rptitives
(while, et for).
Sil suffit de suivre la squence dexcution et leffet sur les variables pour un jeu de donnes
prcis, cela na aucun sens en gnral car ce que lon veut pouvoir faire sest exprimer ltat du
programme en particulier la fin de son excution quelles que soit les donnes traites pour
dterminer si la Postcondition (rsultat escompt) est toujours satisfaite.
Autre exemple:
Supposons le code suivant qui suppose que x et y sont des variables entires initialises:
if x > y:
x,y = y,x
On peut voir que la formule :

xy
est une postcondition valide ce code, cest--dire que quelque soit la valeur initiale de x et y,
on a la fin de lexcution le fait que la valeur de x est plus petit ou gal la valeur de y.
En supposant x et y rels la figure suivante reprsente les valeurs possibles de x et de y:
122
(0,0)
valeur de x
valeur de y
Par ailleurs, pour comprendre comment sexcute un programme, il est crucial de pouvoir
dcrire prcisment son tat au milieu de son excution. Dans le cas dune rptitive (while ou
for), il est essentiel de pouvoir fournir une description unique de ltat du programme qui est
valable au dbut de chaque itration ou plus prcisment au moment o lon teste la condition
(du while ou du fait quil reste un lment traiter par le for).
Ainsi dans la recherche squentielle,
i = 0
while i < n and s[i] != x:
i = i + 1
chaque fois que le test du while est ralis (que le rsultat de ce test soit vrai ou faux), ltat
du programme est dcrit par la formule suivante:
(0 i n) (j 0 j < i s[j] = x)
qui exprime que i est entre 0 et n compris et que tous les lments de s[0:i] (i non compris) sont
diffrents de x.
10.3.1 Exemples de formule exprimant une condition

Il est important de pouvoir exprimer en logique, ce que lon dsire comme rsultat dun code
ou la postcondition la plus prcise (cest--dire la plus forte possible) dun code donn. Il
est galement important de pouvoir, partir de la spcification dune postcondition donne,
comprendre ce qui est dsir et crire le code correspondant.
Donnons des exemples de formalisation logique de conditions exprimes au dpart en franais:
Note: La plupart des exemples proviennent dnoncs dexamen dannes prcdentes.
123
x est dans lintervalle entre 0 compris et n non compris

Formule correspondante :
0x<n
La valeur de x est infrieure ou gale celle de tous les lments dune liste s
(dentiers):
Formule correspondante :
(i 0 i < len(s) x s[i])
Notons ici, que x, s et len(s) sont des variables (et fonctions) du programme Python. Par
contre i est une variable lie au quantificateur logique pour tout. Ce nest donc pas une variable
du programme Python.
Au niveau de la formule logique, x, s (et len(s)) sont vues comme des variables libres tandis
que i est une variable lie au quantificateur pour tout et ne correspond donc pas une variable
du programme.
Notez le canevas utilis: on a un pour tout avec une variable dont on donne un nom de variable
(si possible pas celui dune variable du programme pour ne pas mettre de la confusion) et
ensuite une implication logique :
i hypothese(i) conclusion(i)
o hypothse(i) et conclusion(i) signifient que ce sont des formules qui utilisent la variable i.
Lhypothse sert identifier les endroits o il y a une contrainte. Par exemple ici, ce sont pour
les valeurs de i entre 0 compris et len(s) non compris.
La conclusion exprime la contrainte: ici x est infrieur ou gale s[i].
En conclusion la formule dit: pour tous les indices corrects i de s on doit avoir x plus petit ou
gale s[i].
liste s trie par ordre non dcroissant:
Formellement il suffit dexprimer que les lments voisins sont dans le bon ordre:
i ((0 i < len(s) 1) (s[i] s[i + 1]))
Notez que jai rajout des parenthses pour bien identifier les deux parties de limplication,
mme si cela nest pas ncessaire car limplication est moins prioritaire que les comparaisons.
liste range de faon bizarre:
Donnons une postcondition correcte dun algorithme qui trie une liste avec les lments
dindices pairs tris en ordre croissant et les lments dindices impairs, tris en ordre
dcroissant:
124

i((0
i((0
i < len(s
1)//2)
(s[2i]
i < len(s)//2
1)
(s[2i + 1]
s[2i + 2]))
s[2i + 3]))
Donnons une postcondition correcte dun algorithme qui trie une liste avec les lments
pairs tris en ordre croissant et les lments impairs, tris en ordre dcroissant (attention,
ce nest pas comme le prcdent !!) :
i, j ((0 i < j < len(s) s[i]%2 = 0 s[j]%2 = 0) (s[i] s[j]))
i, j ((0 i < j < len(s) s[i]%2 = 1 s[j]%2 = 1) (s[i] s[j]))
10.3.2 Exemple de formule exprimant une condition de code

Ayant un code, il peut tre intressant dexprimer formellement ce quil fait (cest--dire la
postcondition) ainsi que la prcondition ncessaire le plus prcisment possible.
fonction logique
On peut par exemple demander en franais et en logique dexprimer la prcondition et postcondition prcise de ce code:
def test_liste(s):
"""
prcondition : ...
postcondition: ...
"""
delta = 0
i = 0
n = len(s)
while i < n-1 and s[i] + delta <= s[i+1]:
delta = s[i+1] - s[i]
i = i+1
return (i == n-1)
prcondition : liste non vide. Formellement: len(s) > 0

Postcondition: renvoie vrai si s est tri par ordre croissant et quen le parcourant squentiellement depuis le dbut, lcart entre les valeurs successives reste constant ou augmente de plus
en plus. Formellement:
n = len(s)
j ((0 j < n 1) (s[j] s[j + 1]))
j ((1 j < n 1) (s[j] s[j 1] s[j + 1] s[j]))
125
Encore un exemple
Exprimez en logique du premier ordre le rsultat (valeur de res) de lalgorithme suivant qui
travaille avec une liste s dentiers:
n = len(s)
i = 1
res = 0
while i < n:
if s[i] != s[res]:
i = i+1
else:
res = res+1
i = res+1
Postcondition:
n = len(s)
0 res < n
j ((0 j < res) (k(j < k < n s[j] = s[k]))
j ((res j < n) (s[j] = s[res]))
Notez que pour le quantificateur existentiel, le canevas gnral est :

i hypothese(i) conclusion(i)
o hypothse(i) indique par exemple les conditions sur lindice i et conclusion(i), la formule
que lon veut exprimer sur les donnes du programme.
10.3.3 Code satisfaisant une postcondition exprime formellement

Gnralement, la spcification formelle de ce que doit faire le code arrive avant celui-ci.
Par exemple on peut demander une fonction f qui reoit un string s et dont la postcondition
est:
(i (0 i < len(s)) j(0 j < len(res)) s[i] = res[j])
(i, j (0 i < j < len(res)) res[i] = res[j])
Pouvez-vous me donner un tel algorithme en Python ?
10.4 Preuve partielle et totale

Etant donn quil est, en pratique gnralement impossible de tester compltement le bon fonctionnement dun algorithme, il faut se rabattre sur des mthodes analytiques pour le vrifier.
126
Essayons de prouver que le calcul du pgcd par la mthode dEuclide, donn la figure suivante
donne le bon rsultat en supposant quau dpart x >= 0 et y >0.
def pgcd(x, y):
""" calcule le pgcd(x,y)"""
while (y > 0):
x,y = y,x % y
return x
Deux problmes doivent tre rsolus. Il faut sassurer:

1. que pour tout couple de donnes (x,y) possible la fonction pgcd se termine,
2. que si cette fonction se termine, elle donne le bon rsultat.
Nous dirons que pour faire la preuve totale dun algorithme, il faut vrifier le point 2., cest-dire en faire sa preuve partielle et prouver le point 1., cest--dire vrifier la terminaison.
Pour un algorithme sans boucle ni appel de fonction, la preuve totale est relativement simple
puisque lon peut suivre, instruction par instruction, son volution en dcoupant les diffrents
cas possibles suivant les tests effectus tout au long de son excution.
Le problme provient des boucles o le mme code peut tre utilis plusieurs fois, le nombre
de rptitions variant suivant les donnes.
La formule logique qui dcrit la situation des boucles est appele invariant. Intuitivement,
linvariant dune while (ou dun for) donne ltat du programme chaque fois que lon effectue
le test associ (que le rsultat du test soit vrai ou faux). Ainsi la formule donne dans lexemple
de la recherche squentielle est un invariant. Formellement, pour que cette formule soit un
invariant correct trois conditions doivent tre remplies:
Warning: Pour effectuer la preuve partielle dune boucle, il faut tout dabord trouver
un invariant de boucle cest--dire une affirmation ou assertion vraie chaque fois que
lexcution du programme atteint le dbut de chaque itration de la boucle et qui permet de
dduire le rsultat voulu, si lexcution de la boucle while se termine.
Une formule I est un invariant si:
1. I est vrai au dbut de lexcution de la boucle while au moment o lexcution du
programme atteint cet endroit.
2. Ayant I vrai et la condition C de continuation du while galement vraie (et donc que le
corps du while est valu une fois de plus), il faut pouvoir vrifier quaprs lexcution
dune itration du corps la boucle while, linvariant I est nouveau vrai.
3. Enfin pour effectuer la preuve partielle, cet invariant, compos avec le fait que la
condition C de continuation du while devienne fausse, doit permettre de vrifier que
la boucle while a effectivement calcul le rsultat R qui lui tait demand.
Essayons de dgager une interprtation intuitive de la notion dinvariant. Si lon regarde
lensemble des situations dans lesquelles se trouve un algorithme au dbut de chaque itration dune boucle, on remarque que les situations voluent tout en ayant des points communs.
Effectivement, la boucle est une faon de raliser de faon itrative un certain traitement qui ne
peut tre ralis en une fois. Linvariant sera gnralement une faon dexprimer que le rsultat
escompt ( la terminaison de la boucle) est gal ce qui a dj t ralis lors des prcdentes
itrations de la boucle plus ce qui reste encore raliser. Au dbut de la boucle, ce qui est
10.4. Preuve partielle et totale
127
ralis est vide, on aura alors Rsultat = Ce qui reste raliser. A la terminaison de la boucle,
la condition darrt de la boucle permet de vrifier que ce qui reste raliser est vide. On aura
alors Rsultat = Ce qui est ralis et la preuve partielle pour la boucle sera ralise.
Formellement pour un code while C: instruction , les trois conditions suivantes
doivent tre vraies :
code avant le while I
I C + corps du while execute une iteration I
I C R
Pour exprimer linvariant de la boucle while de la fonction pgcd, il faut utiliser des notations
permettant de distinguer les valeurs initiales de x et de y de leur valeur courante.
Nous dnoterons x_i , y_i les valeurs respectivement de x et y aprs la ime itration, (initialement x = x_0 , y = y_0) et x, y leur valeur courante.
Linvariant vaut alors:
Invariant: (pgcd(x0 , y0 ) = pgcd(x, y)) (x 0) (y 0)
Cette formule exprime le fait que pour calculer pgcd(x_0 , y_0 ) il reste calculer pgcd(x,y) (ici
on peut oublier ce qui a dj t ralis). Le progrs provient du fait quil est plus simple de
calculer pgcd(x,y) que pgcd(x_0 , y_0 ).
Vrifier un invariant se fait par rcurrence. Pour le pgcd,
Base: : Initialement, linvariant est trivialement vrai puisque x=x_0 et y=y_0 avec x_0
et y_0 >= 0.
Induction:: Si la formule est vraie au dbut de la ime itration et que la boucle effectue une itration supplmentaire alors linvariant est vrai au dbut de la i+1me
itration.
En effet, on peut montrer que
x > 0 y > 0 pgcd(x, y) = pgcd(y, x % y)
De plus
x > 0 y > 0 x %y 0
Et donc, tant donn quaprs chaque itration, les nouvelles valeurs de x et y valent
respectivement lancienne valeur de y et lancienne valeur de x modulo lancienne
valeur de y (ce que lon peut noter x_i = y_(i-1) , y_i = x_(i-1) % y_(i-1)) on voit
que linvariant est vrai au dbut de la i+1me itration.
Pour complter la preuve partielle il faut montrer que linvariant et la terminaison implique le
rsultat.
En effet:
(pgcd(x0 , y0 ) = pgcd(x, y)) (x 0) (y 0) (y 0) pgcd(x0 , y0 ) = x
Enfin, pour complter la preuve totale il faut encore montrer que la boucle se termine effectivement.
128
Ayant x_0 > 0 et y_0 >= 0 on peut voir qu chaque itration, la valeur (entire) y diminue dau
moins une unit. De ce fait le test (y > 0) sera assurment faux un moment donn.
Fonction de terminaison
En gnral, on vrifie quune boucle se termine toujours en mettant en vidence une fonction de
terminaison, cest--dire une fonction f valeur entire qui dpend de la valeur des variables
et telle que:
la valeur de la fonction dcrot strictement dau moins une unit chaque itration;
si linvariant de la boucle est vrai, f est positif ou nul.
Linvariant tant par dfinition vrai au dbut de chaque itration de la boucle, on est alors assur
de la terminaison de celle-ci. Comme pour la recherche dun invariant correct, la recherche
dune telle fonction de terminaison ne possde pas de mthode systmatique.
10.5 Exemples de preuves dalgorithmes

Cette section analyse brivement diffrents algorithmes vus prcdemment et donne les diffrents invariants des boucles.
10.5.1 minimum
Dans la fonction de recherche de lindice du minimum, pour trouver linvariant de la boucle
for, il faut traduire ce for en un while. On obtient le code suivant:
res = 0
i = 1
while i < n:
if V[i] < V[res]:
res = i
i += 1
et linvariant du while permettant deffectuer la preuve totale de lalgorithme est donne ci-dessous:
I 0 < i n j (1 j i 1 V [i min provisoire] V [j])
Notons bien que I reste vrai mme quand la condition du while i<n devient fausse. Une
fonction de terminaison qui, associe linvariant, permet de faire la preuve totale, vaut: n-i
Note: Trouver linvariant dune boucle peut tre difficile puisquaucun algorithme systmatique nexiste pour le trouver. Dans le cadre de ce cours, nous vous demandons seulement
de pouvoir prouver quun invariant que lon vous donne est correct (cest--dire remplit les 3
conditions donnes plus haut).
10.5. Exemples de preuves dalgorithmes
129
10.5.2 Autre exemple:

On donne le code suivant avec la fonction incseq o v est une liste dlments simples :
def incseq(v):
n= len(v)
i=0
k=0
maxseq = 0
while i<n-1:
seq = 1
j=i
while j<n-1 and v[j]<=v[j+1]:
seq += 1
j += 1
if seq > maxseq:
maxseq = seq
k = i
i += seq
return v[k:k+maxseq]
Que fait cette fonction ? Montrez que la formule suivante :

0 k k + maxseq i n
m. k m < k + maxseq 1 v[m] v[m + 1]
p, q. ((0 p q < i) (r. p r q 1 v[r] v[r + 1])) q p < maxseq
est un invariant correct pour la boucle while principale.
10.5.3 Tri par slection

Le code suivant donne le tri par slection. Les commentaires donnent les invariants des boucles.
def tri_selection(s):
"""
Trie la liste s par slection
"""
n = len(s)
i=0
while i < n-1: # invariant I2 (voir plus bas)
# fonction de terminaison 2: n-1-i
# recherche du min dans V[i..n]
min = i # min = indice du min provisoire
j = i+1
while j < n: # invariant I1 (voir plus bas)
# fonction de terminaison 1: n-j
if V[j][0] < V[min][0]:
min = j
j = j+1
# placement du ime lment: change V[i]<->V[min]
130
V[min],V[i] =
i = i+1
V[i],V[min]
avec
invariant I2 :
0i<n
k (0 k < i 1 V [k] V [k + 1])
m k (0 m i 1 i k < n V [m] V [k])
invariant I1 :
(i < j n) k (i k < j V [min] V [k])
10.5.4 Tri par insertion

Le code suivant donne le tri par insertion.
def tri_insertion(s):
"""
Trie liste s par insertion
"""
n = len(s)
i = 1
while i < n: # invariant I2 (voir plus bas)
# fonction de terminaison 2: n-i
Save = V[i]
# utilis pour lchange
# insertion de V[i]
j = i-1
while j >= 0 and V[j][0] > Save[0]: # invariant I1 (voir plus bas)
# fonction de terminaison 1: j
V[j+1] = V[j]
j=j-1
V[j+1] = Save
i = i+1
avec
invariant I2 :
0<in
k (0 k < i 1 V [k] V [k + 1])
invariant I1 :
1 j i 1
k (j + 2 k i V [k] > Save)
10.5. Exemples de preuves dalgorithmes
131
132
CHAPTER
ELEVEN
RCURSIVIT
See Also:
Rfrence: livre de Thomas Cormen, Charles Leiserson, Ronald Rivest, Clifford Stein - Algorithmique
Thomas Cormen, Charles Leiserson, Ronald Rivest, Clifford Stein - Algorithmique - 3me dition - Cours avec 957 exercices et 158 problmes, Dunod, 2010,
ISBN: 978-2-10-054526-1 http://www.books-by-isbn.com/2-10/2100545264Algorithmique-Cours-avec-957-exercices-et-158-problemes-2-10-054526-4.html
11.1 Motivation et introduction du concept

Un algorithme est dit rcursif sil sappelle lui-mme directement ou indirectement via lappel
dune ou de plusieurs autres fonctions qui elles-mmes finissent par lappeler.
La rcursivit est un concept fondamental en informatique qui met naturellement en pratique
un mode de pense puissant qui consiste pouvoir dcouper la tche raliser en sous-tches
de mmes natures mais plus petites qui finalement sont simples rsoudre.
La dmarche sinspire de la dmarche inductive mathmatique utilise dans les preuves par
rcurrence:
Rappel du principe
Si lon doit prouver lassertion S(n) = f (n) pour tout n suprieur ou gal n_0
Pour le cas de base on prouve lassertion pour certaines petites valeurs de n (n_0 par exemple)
Pour ltape de rcurrence : on suppose que cest vrai pour n infrieure ou gale k (avec k
suprieure ou gal n0), et prouve que cest galement vrai pour n = k + 1
Remarque : on peut aussi supposer que cest vrai pour n infrieur ou gal k - 1 et prouver que
cest vrai pour n = k.
Cest ce quon fera ici : souvent plus intuitif dun point de vue informatique.
Prenons par exemple le calcul de la factorielle dun nombre n. Par dfinition pour un n entier
strictement positif, n! est gale au produit des entiers strictement positifs infrieurs n. Par
convention on a aussi 0! = 1.
133
Rappelons le code itratif dune fonction calculant la factorielle:

def fact(n):
res = 1
i = 1
res = res * i
return res
La dfinition rcursive se base sur la dfinition n! = n.(n-1)! pour tout n>0 avec 0! = 1
On obtient le code:
def fact(n):
if n == 0:
res = 1
else:
res = n*fact(n-1)
return res
ou plus court:
def fact(n):
return 1 if n == 0 else n * fact(n-1)
Notons que nous avons dj vu plusieurs algorithmes crits de faon itrative mais dont lide
de base tait rcursive.
Le programme de test de la conjecture de syracuse:
def test_syracuse(n):
while n != 1:
if n % 2 == 0:
n = n//2
else:
n = n*3+1
return True
snonce chaque tape si n est pair on le divise par 2 sinon on le multiplie par 3 et ajoute 1.
Littralement on pourrait lcrire:
if n == 1:
res = True
else:
if n%2 == 0:
n = n//2
else:
n = 3*n+1
res = test_syracuse(n)
return res
ou de faon plus abrge:
134
Chapter 11. Rcursivit
if n == 1:
res = True
else:
res = test_syracuse(n//2 if n%2 == 0 else 3*n+1)
return res
ou encore plus abrg (ce qui devient illisible):

return True if n == 1 else test_syracuse(n//2 if n%2 == 0 else 3*n+1)
Note: En pratique, le nombre dappels imbriqus de fonction est limit, par dfaut, 1000
appels. Par exemple, lexcution de la version rcursive de fact(1000) provoque lerreur
RuntimeError: maximum recursion depth exceeded in comparison.
Le code pour la recherche dichotomique sur une liste de couples tris sur la cl (premier lment
des couples):
def recherche_dichotomique(s,x):
bi, bs = 0, len(s)
m = (bi+bs)//2
while bi < bs and x != s[m][0]:
m = (bi+bs)//2
if s[m][0] < x:
bi = m+1
else:
bs = m # x est avant ou est trouv
len(s) <= m or s[m][0] != x:
m = -1
return m
if
# pas trouv
peut scrire rcursivement

def recherche_dichotomique(s,x,bi, bs):
if bi >= bs:
res = -1
else:
m = (bi+bs)//2
if s[m][0] < x:
res = recherche_dichotomique(s,x,m+1,bs)
elif s[m][0] > x:
res = recherche_dichotomique(s,x,bi,m)
else:
res = m
return res
11.1. Motivation et introduction du concept
135
11.2 Mcanismes
Prenons un simple code rcursif (fonction foo) dont le cas de base est celui o le paramtre n
vaut 0 et qui sinon fait un appel rcursif une instance foo(n-1).
def foo(n):
if n == 0:
# traitement cas de base
else
...
foo(n-1)
...
La fonction foo ralise gnralement un certain traitement pour le cas de base, et peut effectuer
un traitement avant (pr-traitement), ou aprs (post-traitement) lappel rcursif.
Les trois codes suivants illustrent ces possibilits o les traitements correspondent simplement
des print :
Avec pr-traitement:
def foo(n):
if n==0:
print("cas de base :", n)
else:
print("pre-traitement pour :" , n)
foo(n-1)
foo(5)
donne:
pre-traitement pour
pre-traitement pour
pre-traitement pour
pre-traitement pour
pre-traitement pour
cas de base : 0
:
:
:
:
:
5
4
3
2
1
Avec post-traitement:
def foo(n):
if n==0:
print("cas de base")
else:
foo(n-1)
print("post-traitement pour :" , n)
foo(5)
donne:
136
cas de base : 0
post-traitement pour
:
:
:
:
:
1
2
3
4
5
Avec pr et post-traitement :
def foo(n):
if n==0:
print("cas de base : ", n)
else:
print("pre-traitement pour :" , n)
foo(n-1)
print("post-traitement pour :" , n)
foo(5)
donne:
pre-traitement pour : 5
cas de base : 0
post-traitement pour : 1
Notons quici on suppose que linstance n appelle une fois linstance n-1. Il se peut quelle
appelle plusieurs instances n-1 comme nous le verrons dans certains exemples plus bas.
Note: Quand une instance donne (par exemple de paramtre n) de la fonction foo appelle
rcursivement une instance plus petite (par exemple de paramtre n-1, on dit gnralement que
linstance pre foo(n) appelle une instance fils foo(n-1).
Illustrons ces trois canevas.
11.2.1 Fonction rcursive avec pr-traitement

Le code rcursif du test de Syracuse ainsi que celui de la recherche dichotomique sont des
exemples de code avec uniquement un pr-traitement ou un traitement de base (except le
return du rsultat obtenu qui constitue un post-traitement trs simple). Dans les deux codes,
on fait un test en dbut de fonction et ensuite on appelle rcursivement la fonction avec des
paramtres modifis.
11.2. Mcanismes
137
Les deux exemples suivant illustrent aussi bien un traitement rcursif avec pr-traitement:
Calcul de toutes les permutations des lments dune squence
Lide est simple: lensemble des permutations des lments dune squence s est donn en
prenant lensemble des squences commenant par un symbole quelconque de s suivi de toutes
les permutations des symboles restants.
On obtient facilement le code suivant:
def Permutations(prefixe, s):
if len(s) == 0: # prefixe est une nouvelle permutation
print(prefixe)
else: # prend un lment de la squence comme suivant
# et construit la suite avec ce quil reste a permuter
for i in range(len(s)):
Permutations(prefixe + s[i], s[:i]+s[i+1:])
Permutations("", "abcd")
print()
Permutations("", ("belle Marquise ", "vos beaux yeux ", "me font ",\
"mourir ", "damour ", "pour vous "))
On peut aussi stocker les rsultats dans une liste:

def Permutations(prefixe, s, l):
if len(s) == 0:
l.append(prefixe)
else:
for i in range(len(s)):
Permutations(prefixe + s[i],s[:i]+s[i+1:], l)
# fact est utilis pour limpression du rsultat

def fact(n):
return 1 if n==0 or n == 1 else n * fact(n-1)
sequence= input("squence : ") # lecture de la squence
# de caractres dont on veut les permutations
liste = [] # contiendra les rsultats construits par la fonction Permutations
Permutations("", sequence, liste)
# imprime les rsultats
for i,j in zip(range(fact(len(sequence))),liste):
print("{0:5d} : {1}".format(i,j))
Tri rapide (Quicksort)

Le tri rapide est galement un algorithme rcursif avec pr-traitement
138
Lide est que pour trier un vecteur (liste python), on choisit au hasard un (par exemple le
premier) lment du vecteur : il sera appel llment pivot. Ensuite on classe les lments
du vecteur de manire placer avant le pivot les lments qui lui sont infrieurs, et aprs ceux
qui lui sont suprieurs. On appelle (rcursivement) le tri rapide sur les deux moitis de part et
dautre du pivot. Lorsque la squence trier est de taille 0 ou 1, il ny a plus rien faire, car le
tableau est dj tri.
Le tri rapide sera donn ultrieurement dans un cours dalgorithmique.
Une implmentation nave du quicksort donne:
def quick_sort(s):
""" Tri rapide (quicksort) de s (liste de couples (cl, valeur)) """
if len(s) <= 1:
res = s
else:
pivot = s[0]
prefixe = quick_sort([x for x in s[1:] if x[0] < pivot[0]])
suffixe = quick_sort([x for x in s[1:] if x[0] >= pivot[0]])
res = prefixe + [pivot] + suffixe
return res
Notez quici s nest pas modifi, mais que la fonction renvoie une nouvelle liste trie. Une
version en place et plus efficace du Tri rapide est possible.
11.2.2 Fonction rcursive avec post-traitement:

Dans ce cas, souvent quand pour calculer le rsultat de linstance pre de la fonction, on doit
dabord avoir la valeur de son ou ses fils.
La fonction rcursive fact(n) en est un exemple trs simple.
Donnons en deux autres exemples.
Evaluation dexpressions arithmtiques
Cest un exemple typique de post-traitement: par exemple, 3 + 4*5 prend la valeur 3 (dont
on a directement la valeur) et (4*5) value avant, pour finalement avoir le rsultat de la somme.
def evalue(v):
if type(v) is not list:
res= v
elif v[1]==+:
res = evalue(v[0]) +
elif v[1]==-:
res = evalue(v[0]) elif v[1] == *:
res = evalue(v[0]) *
elif v[1]==/:
res = evalue(v[0]) /
11.2. Mcanismes
evalue(v[2])
evalue(v[2])
evalue(v[2])
evalue(v[2])
139
elif v[1] == ^:
res = evalue(v[0]) ** evalue(v[2])
else:
res = None # error
return res
Tri fusion (Mergesort)

Un autre exemple de rcursivit avec post-traitement est le Tri fusion. On divise la squence
de n lments trier en deux sous-squences de n/2 lments, on trie les deux sous-squences
laide du tri fusion (appel rcursif), on combine, en les fusionnant, les deux sous-squences
tries pour produire la squence trie.
Le cas de base est le tri dune squence de taille 1.
Le code suivant est une version non optimise du Tri fusion:
def merge(t1, t2):
if len(t1) == 0:
res = t2
elif len(t2) == 0:
res = t1
elif t1[0][0] < t2[0][0]:
res = [t1[0]] + merge(t1[1:], t2)
else:
res = [t2[0]] + merge(t1, t2[1:])
return res
def merge_sort(t):
if len(t) > 1:
(t1, t2) = (t[:len(t)//2], t[len(t)//2:])
t1 = merge_sort(t1)
t2 = merge_sort(t2)
res = merge(t1, t2)
else:
res = t
return res
l=list(zip("bonjour",range(10)))
res = merge_sort(l)
print(res)
Notez aussi que ici l nest pas modifi, mais que la fonction renvoie une nouvelle liste trie.
11.3 Structures de donnes rcursives

Le rcursivit est intensivement utilise dans des structures de donnes telles que les graphes
ou les arbres informatiques.
140
11.3.1 Graphe
Un graphe G = (V,E) est une structure de donnes, forme dun ensemble V dlments et dun
ensemble de pairs (ou de couples) tablissant les liens entre ces lments.
Si E est un ensemble de pairs, on dit que le graphe est non orient, sil sagit de couples, le
graphe est orient.
Le graphique suivant dcrit un graphe orient donnant un ensemble V de personnes (V= {Jean,
Germaine, Catherine, Luc, Bernadette, Jules, Michel} avec la relation E (connat).
E = { Jean -> Germaine ; Germaine -> Catherine ; Catherine -> Jean ; Bernadette -> Luc ;
Bernadette -> Michel ; Michel -> Luc ; Bernadette -> Jules ; Jules -> Bernadette }
Jean
Bernadette
Germaine
Michel
Catherine
Jules
Luc
Une faon simple dimplmenter un tel graphe en python est avec un dictionnaire dont les
lments sont les cls, et la liste de leurs connaissances, leur valeur. Dans lexemple plus haut
on aurait:
graphe = { "Jean"
"Germaine"
"Catherine"
"Luc"
"Michel"
"Bernadette"
"Jules"
:
:
:
:
:
:
:
["Germaine"] ,
["Catherine"],
["Jean"] ,
[],
["Luc"],
["Luc", "Michel", "Jules"],
["Bernadette"] }
11.3.2 Arbre binaire

Lexemple de lexpression valuer, vu plus haut, est en fait une implmentation python, avec
des listes, de la notion darbre binaire.
Un arbre binaire est une structure de donnes soit vide soit forme dun noeud et de deux
sous-arbres binaires, appels respectivement fils gauche et un fils droit.
Chaque noeud contient une information appele contenu.
11.3. Structures de donnes rcursives
141
Ainsi lexpression 3+4*5 est vu comme larbre binaire illustr par la figure suivante :
o les noeuds vides ne sont pas reprsents.

Notre implmentation python donnait: exp = [3,+,[4,*,5]]
Note: La rcursivit ainsi que de nombreux algorithmes sur les arbres et les graphes seront
vus plus en dtails dans des cours dalgorithmiques ultrieurs.
11.4 Traduction de fonction rcursive en fonction itrative

Toute rcursivit peut plus ou moins facilement tre traduite en fonction non rcursive.
Dans le cas de rcursivit terminale (tail recursion) cest--dire o la dernire action de la
fonction consiste en un appel rcursif, il est assez simple de remplacer la rcursivit par une
boucle while.
Dans le cas o le traitement est uniquement un post-traitement, il est possible de prendre le
code lenvers cest--dire, de traduire le code en boucle qui fait le traitement de base, suivi
du post-traitement pour n valant 1 ensuite pour n valant 2, ... jusqu avoir trait le cas pour la
valeur n initiale. Cest ce qui se passe pour le code non rcursif de la factorielle.
Quand la fonction plusieurs appels des instances plus petites ou quil y a la fois un
pr-traitement et un post-traitement, il est plus difficile de supprimer la rcursivit et ne peut
souvent tre fait quavec une pile (stack) simulant cette rcursivit.
142
11.5 Gestion de la mmoire lexcution

11.5.1 Noms et objets
Nous avons dj vu quune variable est une rfrence un objet. Manipuler cet objet se fait
grce cette variable qui en quelque sorte lidentifie.
Ainsi comme nous lavons dj expliqu :
a = 3
a = a + 1
cre un objet de classe entire (int) dont la valeur est 3, et place dans la variable a son adresse
(sa rfrence). Ensuite laddition cre un autre objet de type (classe) int et de valeur 4 et a
reoit la rfrence ce nouvel objet.
>>> dir(a)
[__abs__, __add__, __and__, __bool__, __ceil__, __class__,
__delattr__, __divmod__, __doc__, __eq__, __float__,
__floor__, __floordiv__, __format__, __ge__,
__getattribute__, __getnewargs__, __gt__, __hash__,
__index__, __init__, __int__, __invert__, __le__,
__lshift__, __lt__, __mod__, __mul__, __ne__, __neg__,
__new__, __or__, __pos__, __pow__, __radd__, __rand__,
__rdivmod__, __reduce__, __reduce_ex__, __repr__,
__rfloordiv__, __rlshift__, __rmod__, __rmul__, __ror__,
__round__, __rpow__, __rrshift__, __rshift__, __rsub__,
__rtruediv__, __rxor__, __setattr__, __sizeof__, __str__,
__sub__, __subclasshook__, __truediv__, __trunc__,
__xor__, bit_length, conjugate, denominator, from_bytes,
imag, numerator, real, to_bytes]
dir(a) renvoie la liste des attributs et mthodes de lobjet rfrenc par la variable a.
En fait en Python tout est objet (ou rfrence un objet).
Dans le vocabulaire Python, une variable est appel nom et est lie un objet. Un objet peut
avoir plusieurs noms, par exemple dans le code ci-dessous o lobjet de type liste est connu
sous les noms s et t dans un code appelant et x dans la fonction foo appele.
def foo(x):
x[0] = 3
s = [0, 0, 7]
t = s
foo(s)
Tout objet Python x a un identificateur (donn par id(x)), un type (donn par type(x)), et
un contenu.
Lors de son excution, un programme Python gre des espaces de noms (namespace). Un
espace de nom est un mappage (mapping) de noms vers des objets. Des exemples de tels
11.5. Gestion de la mmoire lexcution
143
espaces de noms sont donns par lensemble des noms globaux (donn par globals()) ou
des noms locaux une instance de fonction (donn par locals()).
Note:
Les espaces de nom peuvent tre implments sous forme de dictionnaires Python.
Ainsi, lassignation ainsi que le passage de paramtres une fonction modifient les espaces de noms et pas les objets eux mmes !
Par contre :
x = []
x.append(3)
cre un liste et un nom dans lespace de nom courant et ensuite appelle la mthode append() qui va modifier lobjet rfrenc par x.
11.5.2 Scope et espace de nom (namespace)

En pratique la gestion des objets et des espaces de nom en mmoire implique deux espaces
mmoire:
1- lun, appel pile dexcution (runtime stack) qui va contenir lespace de nom global et les
espaces de noms locaux;
2- lautre, tas dexcution (runtime heap), qui contient les objets.
La gestion des espaces de nom locaux (ainsi que dautres lments en mmoire, ncessaires
pour le bon fonctionnement du programme) est effectue dans des trames (frames) dans la pile
dexcution (runtime stack): chaque fois quune instance de fonction foo() est appele, une
trame associe cette instance est cre et mise comme un lment supplmentaire de la pile
dexcution. Cette trame contient en particulier, lespace de nom local cette instance. Cette
trame sur la pile dexcution continuera a exister jusqu la fin de lexcution de cette instance
de foo(). Ensuite (au moment du return), la trame est enleve de la pile systme et on revient
linstance appelante dont la trame se trouve maintenant au sommet de la pile dexcution.
Par contre un objet cr, continue exister jusqu ce quil ne soit plus reli aucun nom
dans un espace de noms quelconque et que le systme dcide de rcuprer lespace mmoire
qui lui tait attribu. Cette opration est nomme garbage collection et seffectue de faon
transparente pour le programmeur, si ce nest quil peut observer un ralentissement ponctuel
du programme pendant que le garbage collector sexcute. Cest en raison de la gestion sans
ordre de cet espace mmoire o se trouvent les objets Python, quil est appel le tas dexcution
(runtime heap).
Exemple dexcution dun programme
Prenons lexcution du programme suivant qui est une version simplifie du tri par fusion pour
des listes de caractres, excute sur la liste list("CDAB").
144
def merge_sort(t):
if len(t) > 1:
(t1, t2) = (t[:len(t)//2], t[len(t)//2:])
t1 = merge_sort(t1)
t2 = merge_sort(t2)
# merge
res = []
while len(t1) > 0 and len(t2) > 0:
if t1[0] < t2[0]:
res.append(t1[0])
del t1[0]
else:
res.append(t2[0])
del t2[0]
res += t1 + t2
else:
res = t
return res
l= list("DCBA")
print(merge_sort(l))
Illustrons en particulier les valeurs des variables t1 et t2 avant et aprs les appels rcursifs et
au moment des return (pour simplifier les diagrammes dtats, on reprsente par le caractre
X la rfrence ce caractre X).
Etat dans linstance de fonction de niveau 1 (DCBA) avant les appels au niveau 2.
Objets
Trames
Variables globales
merge_sort
l
fonction merge_sort(t)
"D"
"C"
"D"
"C"
"B"
"A"
"B"
"A"
merge_sort
t
t1
t2
Etat dans linstance de fonction de niveau 2 (DC) avant les appels au niveau 3.
145
Objets
Trames
Variables globales
merge_sort
"D"
"C"
"D"
"C"
"B"
"A"
"B"
"A"
merge_sort
t
t1
t2
merge_sort
t
t1
t2
"D"
"C"
Etat dans linstance de fonction de niveau 3 pour (D)
146
Objets
Trames
Variables globales
merge_sort
"D"
"C"
"D"
"C"
"B"
"A"
"B"
"A"
merge_sort
t
t1
t2
merge_sort
t
t1
t2
"D"
"C"
merge_sort
t
Etat dans linstance de fonction de niveau 3 pour (C)
147
Objets
Trames
Variables globales
merge_sort
l
"D"
"C"
"D"
"C"
"B"
"A"
"B"
"A"
merge_sort
t
t1
t2
merge_sort
t
t1
t2
"D"
"C"
merge_sort
t
Etat dans linstance de fonction de niveau 2 aprs la fusion de D et C.
148
Objets
Trames
Variables globales
merge_sort
l
"D"
"C"
"D"
"C"
"B"
"A"
"B"
"A"
merge_sort
t
t1
t2
merge_sort
t
t1
t2
res
"D"
empty list
"C"
"D"
Modification de t1 dans linstance de fonction de niveau 1.
149
Objets
Trames
Variables globales
merge_sort
l
"D"
"C"
"C"
"D"
"B"
"A"
"B"
"A"
merge_sort
t
t1
t2
Etat dans linstance de fonction de niveau 2 (BA) avant les appels au niveau 3.
150
Objets
Trames
Variables globales
merge_sort
"D"
"C"
"C"
"D"
"B"
"A"
"B"
"A"
merge_sort
t
t1
t2
merge_sort
t
t1
t2
"B"
"A"
Etat dans linstance de fonction de niveau 3 pour (B)
151
Objets
Trames
Variables globales
merge_sort
"D"
"C"
"C"
"D"
"B"
"A"
"B"
"A"
merge_sort
t
t1
t2
merge_sort
t
t1
t2
"B"
"A"
merge_sort
t
Etat dans linstance de fonction de niveau 3 pour (A)
152
Objets
Trames
Variables globales
merge_sort
l
"D"
"C"
"D"
"C"
"B"
"A"
"B"
"A"
merge_sort
t
t1
t2
merge_sort
t
t1
t2
"B"
"A"
merge_sort
t
Etat dans linstance de fonction de niveau 2 aprs la fusion de B et A.
153
Objets
Trames
Variables globales
merge_sort
l
"D"
"C"
"C"
"D"
"B"
"A"
"B"
"A"
merge_sort
t
t1
t2
merge_sort
t
t1
t2
res
"B"
empty list
"A"
"B"
Modification de t2 dans linstance de fonction de niveau 1.
154
Objets
Trames
Variables globales
merge_sort
l
"D"
"C"
"C"
"D"
"A"
"B"
"B"
"A"
merge_sort
t
t1
t2
Aprs fusion de CD avec AB dans linstance de niveau 1 de merge_sort()
Objets
Trames
Variables globales
merge_sort
l
merge_sort
t
"D"
"C"
"C"
"D"
"B"
"A"
"C"
"D"
t1
t2
empty list
res
"A"
"B"
155
156
CHAPTER
TWELVE
FICHIERS, PERSISTANCE ET
EXCEPTIONS
See Also:
Lire le chapitres 9 du livre de Grard Swinnen sur Python 3 ainsi que
http://docs.python.org/3/library/string.html et http://docs.python.org/3/library/exceptions.html
12.1 Fichiers et persistance

Il est souvent intressant de sauver des informations dans des fichiers qui continueront exister
aprs la fin de lexcution du programme python. De telles informations sont appeles en
informatique persistantes par opposition aux donnes volatiles cres en mmoire vive lors
de lexcution du programme et qui disparaissent en cours ou en fin de cette excution. Les
donnes persistantes sont gnralement sauves sur disque, sous forme soit de fichiers soit de
bases de donnes.
Nous avons dj vu, dans un chapitre prcdent, quil tait possible douvrir un fichier texte
en mode lecture (read) et de lire les donnes quil contenait,
ou en mode criture (write) et dy crire des rsultats.
La liste des mthodes standard sur les fichiers est la suivante:
Instruction
f=open(fichier) :
f=open(fichier,w) :
f=open(fichier,a) :
f.read() :
f.readline() :
f.readlines() :
f.write(s) :
f.close() :
Effet
ouvre fichier en lecture
ouvre fichier en criture
ouvre fichier en criture en rajoutant aprs les donnes dj prsentes
retourne le contenu du fichier f
lit une ligne
renvoie la liste des lignes de f
crit la chane de caractres s dans le fichier f
ferme f
Lexemple suivant
utilise un fichier data.txt de donnes, contenant des expressions valuer,
157
utilise un fichier result.txt rsultat qui va recevoir pour chaque expression lue, le
texte de lexpression suivie de = et de la valeur obtenue grce la fonction eval()..
d=open("data.txt")
r=open("result.txt",w)
for i in d:
i = i.strip()
r.write("{0} = {1}\n".format(i, eval(i)))
d.close()
r.close()
Note: la mthode write reoit en paramtre un string qui sera imprim. Comme nous lavions
dj vu avec les print, la mthode s.format() peut tre fort utile. Son principe gnral est
dexaminer le string s et de remplacer les lments entre accolades avec des numros et des
informations de formatage, par les paramtres donns, formats tel que spcifi.
12.1.1 Pickle: criture dun objet

Il est possible de sauvegarder des valeurs dobjets de nimporte quel type. Le problme est la
phase dencodage : on peut utiliser un fichier texte encore faut-il traduire la valeur de lobjet
en string. Si cela semble facile pour des valeurs simples, lexercice devient plus prilleux pour
des squences, ensembles ou dictionnaires.
Le module pickle contient une mthode dump() qui ralise cette traduction, appele srialisation.
Il suffit ensuite de sauver le texte produit par cette srialisation en lcrivant, par exemple, dans
un fichier. Quand le programmeur veut retrouver la valeur sauve, il devra la lire sur le fichier
et faire le travail de traduction inverse, grce la mthode load().
Donc, la mthode pickle.dumps prend un objet en paramtre et retourne une reprsentation
de lobjet sous forme de chane. La chane obtenue nest pas destine tre comprhensible
ou lue par lhumain. Par contre, la mthode pickle.loads prend une chane de ce type en
paramtre et reconstitue un objet identique celui donn pickle.dumps.
Exemples :
>>> import pickle
>>> t = [1, 2, 3]
>>> pickle.dumps(t)
(lp0\nI1\naI2\naI3\na.
>>> pickle.dumps({a:3, b:8, c:9})
"(dp0\nSa\np1\nI3\nsSc\np2\nI9\nsSb\np3\nI8\ns."
>>> pickle.dumps(hello)
"Shello\np0\n."
>>> pickle.dumps(12)
I12\n.
>>> save_t = pickle.dumps(t)
158
Chapter 12. Fichiers, persistance et Exceptions
>>> t2 = pickle.loads(save_t)
>>> t2
[1, 2, 3]
>>> t == t2
True
>>> t is t2
False
Les fonctions dump et load (sans s) prennent un fichier comme argument supplmentaire
pour sauvegarder / rcuprer un objet depuis le fichier.
>>>
>>>
>>>
>>>
>>>
>>>
import pickle
f = open(data.txt, w)
d = {a:3, b:8,c:9}
pickle.dump(d, f)
f.close()
exit()
ensuite si on relance une nouvelle session,

>>> import pickle
>>> # d est sauvegard dans data.txt
>>> f = open(data.txt)
>>> d = pickle.load(f)
>>> d
{a: 3, c: 9, b: 8}
12.1.2 Shelve
Le pickling est un moyen simple de sauvegarder un objet (ou plusieurs objets squentiellement
dans le mme fichier). Un autre moyen, plus souple, est dutiliser le module shelve qui fournit une solution de persistance de type base de donnes. Concrtement, la base de donne
est crite (automatiquement) dans un fichier; la mthode shelve.open cre un fichier de
sauvegarde sil nexiste pas, et retourne un objet de type shelve; un shelve fonctionne (presque)
comme un dictionnaire. La plupart des oprations et mthodes des dictionnaires lui sont applicables; toute modification applique au shelve est (automatiquement) sauvegarde; la mthode
shelve.close permet de fermer le shelve, comme pour un fichier.
>>> import shelve
>>> t = [0,1,2,3]
>>> p = (1, 2, 3)
>>> i = 12
>>> s = hello
>>> db = shelve.open(data.db)
>>> db[liste] = t
>>> db[point] = p
>>> db[entier] = i
>>> db[chaine] = s
>>> print(db)
{liste: [0, 1, 2, 3], chaine: hello, entier: 12, point: (1, 2, 3)}
12.1. Fichiers et persistance
159
>>> db.close()
>>> exit() # ferme la session
et relancer une session

>>> import shelve
>>> db = shelve.open(data.db)
>>> print(db[liste])
[0, 1, 2, 3]
>>> db[chaine] = bonjour
>>> print(db)
{liste: [0, 1, 2, 3], chaine: bonjour, entier: 12, point: (1, 2, 3)}
12.2 Exceptions
Les exceptions sont frquentes, en particulier quand on manipule des fichiers.
>>> 3 / 0
ZeroDivisionError: integer division or modulo by zero
>>> t[4]
IndexError: list index out of range
>>> s = 2 + 2
TypeError: cannot concatenate str and int objects
>>> open(xyz.txt)
IOError: [Errno 2] No such file or directory: xyz.txt
>>> open(/etc/passwd, w)
IOError: [Errno 13] Permission denied: /etc/passwd
>>> open(music)
IOError: [Errno 21] Is a directory: music
12.2.1 Lancer une exception

Une exception indique que quelque chose dexceptionnel sest produit. Vous pouvez vous
mme lancer des exceptions.
def square_root(a, eps = 10**-9):
if not isinstance(a,int) and not isinstance(a,float):
raise TypeError(a must be an integer or a float)
if a < 0.0:
raise ValueError(a must be >= 0)
x = 0.0
approx = 1.0
while (abs(approx - x) > eps):
x = approx
approx = (x + (a / x)) / 2.0
return approx
160
>>> square_root(4)
2.0
>>> square_root(-2)
ValueError: a must be >= 0
>>> square_root(hello)
TypeError: a must be an integer or a float
La syntaxe pour lancer une exception est donc :
raise ExceptionType(message)
Les types dexceptions les plus frquentes que vous pouvez lancer sont :
Nom
ValueError:
TypeError:
IndexError:
IOError:
Cause
Erreur de valeur (par ex., ne respecte pas les pr-conditions)
Erreur de type pour un paramtre
Indice hors bornes
Erreur dentre / sortie (par ex. fichiers)
12.2.2 Grer les exceptions

Jusqu prsent, quand une exception se produit, le script sinterrompt brutalement. Comment
grer les exceptions pour viter cette sortie brutale et effectuer du code spcifique quand une
exception se produit ?
Solution 1 [utiliser des instructions conditionnelles pour] viter les exceptions.
Exemple [avant douvrir un fichier, vrifier quil existe, que] ce nest pas un rpertoire, etc.
avec des fonctions comme os.path.exists ou os.path.isdir.
Inconvnients :
code difficile lire et crire car nombreux cas possibles;
les tests peuvent tre coteux en temps de calcul;
ncessite de penser aux cas exceptionnels, et de les grer a priori, plutt que de se
concentrer sur le code principal;
le nombre dexceptions possibles peut tre trs important. Par exemple, pour les fichiers,
lexception suivante suggre quil y a au moins 21 types derreurs possibles !
>>> open(music)
IOError: [Errno 21] Is a directory: music
comment tre sr de ne pas oublier un cas exceptionnel ?

Une meilleure solution serait de pouvoir crire le code principal et demander linterprteur
dessayer (try) de lexcuter, et grer les problmes seulement sils se produisent.
Cest exactement ce que propose la syntaxe try - except.
Solution 2 (de loin prfre) : utiliser une instruction try - except.
12.2. Exceptions
161
La forme la plus simple dune instruction try - except est la suivante.

try:
# code principal
except:
# code spcifique en cas dexception
Comportement [le code principal est excut. Ds que celui-ci] produit une exception, il est
interrompu et le code spcifique est excut. Si aucune exception ne sest produite, le
code spcifique nest pas excut.
On dit quon rattrape (catch) une exception (dans une clause except).
Exemple :
try:
print(Avant)
raise ValueError(Test)
print(Apres)
except:
print(Gestion exception)
print(Fin)
Rsultat :
Avant
Gestion exception
Fin
Exemple :
try:
i = int(input(Entier : ))
print("Nous pouvons travailler avec", i)
except:
print("Je ne peux travailler quavec un entier")
print("Fin du programme")
Si on entre un entier :
Entier : 2
Nous pouvons travailler avec 2
Fin du programme
Sinon :
Entier : hello
Je ne peux travailler quavec un entier
Fin du programme
Il est possible de spcifier dans la clause except le type dexception que lon veut rattraper.
Exemple :
162
ok = False
while not ok:
try:
x = int(input("Please enter a number: "))
ok = True
except ValueError:
print("Oops! That was no valid integer. Try again...")
print("Now Im sure that", x, "is a valid integer.")
Remarque : dans cet exemple, si une autre exception quune ValueError se produit, elle
nest pas rattrape et le comportement sera celui habituel : le programme sarrte brutalement.
On peut spcifier plusieurs clauses except, pour grer diffrents types dexceptions.
Exemple :
try:
f = open(myfile.txt)
s = f.readline()
i = int(s.strip())
except IOError:
print Cannot open myfile.txt
except ValueError:
print(Could not convert, s.strip(), to an integer.)
except:
print(Unexpected error.)
raise
Remarque : le dernier cas permet de relancer les exceptions qui nont pas t spcifiquement
gres (par ex. si ce code est encapsul dans une fonction, lappelant pourra alors grer ces
exceptions).
On peut spcifier un tuple dexceptions grer dans une mme clause except.
Exemple :
try:
s = f.readline()
i = int(s.strip())
except (IOError, ValueError):
print(Cannot open file or cannot convert integer)
On peut placer un else, aprs les clauses except. Il sera excut si aucune exception nest
produite. Cest utile dans le cas o il faut excuter du code seulement si linstruction try na
pas provoqu dexceptions.
Exemple :
import sys
for arg in sys.argv[1:]:
try:
f = open(arg, r)
except IOError:
12.2. Exceptions
163
print(cannot open, arg)

else:
print(arg, has, len(f.readlines()), lines)
f.close()
Remarque : lutilisation dune clause else est ici meilleure que dajouter du code dans le
try car cela vite dattraper accidentellement une exception qui serait provoque par une autre
instruction que open.
Pour obtenir des informations sur une exception, on peut la faire suivre par le mot-cl as et
le nom dune variable. Cette variable possde comme valeur un objet de type exception. En
affichant celle-ci, on obtient le message associ lexception.
Exemple :
try:
except IOError as e:
print(Cannot open myfile.txt:, e)
else:
s = f.readline().strip()
print(s)
Enfin, on peut ajouter une clause finally qui sera excute dans tous les cas (quil y ait une
exception ou pas). Cela permet de raliser des tches de clean-up comme fermer un fichier
quon savait ouvert avant le try, ou sauvegarder les donnes avant que le programme sarrte
suite une exception, etc. La clause finally est excute juste avant de sortir du try except, quune exception soit provoque ou non.
Exemple :
try:
raise KeyboardInterrupt
finally:
print(Goodbye, world!)
donne:
Goodbye, world!
KeyboardInterrupt
Remarques : la commande Ctrl-C permet dinterrompre lexcution dun programme. En

Python, une telle commande provoque un KeyboardInterrupt.
Exemple :
import time
print(This is a malicious script!)
print(Try to find the exit before the bomb exploses!)
try:
for i in range(10):
print(10-i, end= )
if i % 2 == 0:
print(tic)
164
else:
print(tac)
time.sleep(1)
except KeyboardInterrupt:
print(Well done! You have found the exit!)
else:
print(BOOOM! You lose!)
finally:
print(Goodbye!)
Exercice : Quels sont les messages que la fonction suivante va afficher (et dans quel ordre) si
x = 2 et y = 1;
x = 2 et y = 0;
x = 2 et y = 1 ?
def divide(x, y):
try:
result = x / y
except ZeroDivisionError:
print("division by zero!")
else:
print("result is", result)
finally:
print("executing finally clause")
12.2. Exceptions
165
166
CHAPTER
THIRTEEN
CLASSES ET OBJETS
13.1 Objet et classe
Nous avons dj vu que lors de lexcution dun programme, lenvironnement dexcution
Python gre un espace mmoire, appel tas dexcution (runtime heap) et un autre espace
mmoire, appel pile dexcution (runtime stack) qui, en particulier, un instant donn, contient
un espace de noms par instance locale dune fonction en cours dexcution.
Nous avons galement vu quune variable est en fait un nom dun objet; manipuler cet objet se
fait grce cette variable qui lidentifie.
Tout objet Python x a :
un identificateur unique et dont la valeur est constante tout au long de sa vie (donn par
id(x)),
un type (donn par type(x)),
un contenu
Note:
a is b est quivalent id(a) == id(b).
Deux objets dont les dures de vie nont pas dintersection peuvent avoir le mme identificateur.
On ne peut pas changer lidentit dun objet ni son type (sauf exception). On peut changer le
contenu des objets modifiables (mutables) sans changer leur identit ou leur type.
Un objet a donc un identificateur et un type et peut avoir un ou plusieurs noms. Il a galement,
en fonction du type de lobjet, une ou plusieurs mthodes qui permettent soit de consulter le
contenu de lobjet soit, si lobjet est modifiable, de modifier son contenu.
Un objet a aussi des attributs (de donnes) qui sont manipuls par les mthodes __setattr__
/ __getattr__ pour les attributs ou __setitem__ / __getitem__ pour les composants
dune squence.
La section suivante explique comment Python permet au programmeur de dfinir des nouvelles
classes dobjets et ainsi de crer et manipuler des objets de cette classe.
167
13.2 Dfinition de nouvelles classes

13.2.1 La notion de classe
On peut dfinir ses propres types en donnant une dfinition de classe. On peut donc voir une
dfinition de classe comme la dfinition dun nouveau type.
Dfinissons un nouveau type (classe) pour reprsenter des points dans le plan.
class Point(object):
""" represente un point dans le plan """
le mot-clef class indique le dbut dune dfinition de classe;

on donne ensuite le nom de la classe (par convention, avec une majuscule);
entre parenthses, on prcise quun lment de classe Point sera une sorte
dobject, qui est une classe prdfinie.
Pour linstant notre modle (classe) est trs peu prcis. On a juste donn un nom et un docstring.
>>> print(Point)
<class __main__.Point>
>>> help(Point)
Help on class Point in module __main__:
class Point(builtins.object)
| represente un point dans le plan
|
| Data descriptors defined here:
|
| __dict__
|
dictionary for instance variables (if defined)
|
| __weakref__
|
list of weak references to the object (if defined)
(END)
13.2.2 La notion dobjets

Cependant, on peut dj crer des objets de la classe Point. Pour ce faire, on appelle Point
comme si ctait une fonction.
>>> p = Point()
>>> print(p)
<__main__.Point object at 0xe73bd0>
la valeur de retour est une rfrence vers un objet de type Point, que lon assigne la
variable p;
crer un objet est une instanciation, et lobjet est une instance de la classe Point;
168
Chapter 13. Classes et objets
quand on affiche une instance, Python nous dit quelle classe elle appartient et o elle est
stocke en mmoire (sous la forme dune adresse reprsente par un nombre hexadcimal).
0xe73bd0
Point
13.2.3 Attributs
Une des proprits des objets est quil possde des attributs. Un attribut est une valeur.
Par exemple, pour reprsenter un point dans le plan, on a besoin de deux attributs (coordonnes
x et y).
Pour assigner un attribut un objet, on peut utiliser la notation point.
>>> p.x = 2.0
>>> p.y = 4.0
100.0
box
200.0
width
Point
height
corner
x
y
0.0
On accde aux attributs dun objet galement via la notation point.

p.x peut tre lu comme aller dans lobjet rfr par p et rcuprer la valeur de son attribut x
>>> import math
>>> print(p.x)
2.0
>>> y = p.y
>>> print(y)
4.0
>>> print("({0}, {1})".format(p.x, p.y))
(2.0, 4.0)
13.2. Dfinition de nouvelles classes
169
>>> dist_from_orig = math.sqrt(p.x**2 + p.y**2)

>>> print(dist_from_orig)
4.472135955
Un attribut peut tre une rfrence vers un autre objet.

>>>
...
...
...
...
...
>>>
>>>
>>>
>>>
>>>
>>>
class Rectangle(object):
""" represente un rectangle dans le plan
attributs: width, height, corner
(coin inferieur gauche, Point)
"""
box = Rectangle()
box.width = 100.0
box.height = 200.0
box.corner = Point()
box.corner.x = 0.0
box.corner.y = 0.0
100.0
box
200.0
width
Point
height
corner
x
y
0.0
13.2.4 Objet comme valeur de retour

Une fonction peut crer un objet et retourner la rfrence vers celui-ci.
>>> def find_center(r):
...
c = Point()
...
c.x = r.corner.x + r.width / 2.0
...
c.y = r.corner.y + r.height / 2.0
...
return c
>>> center = find_center(box)
>>> print_point(center)
(50, 100)
13.2.5 Copie dobjets

Un objet pass en argument peut tre modifi par une fonction. On a vu que cela peut provoquer
des problmes dans certains cas (par exemple pour les listes non simples).
170
On peut copier un objet pour viter laliasing grce au module copy.

>>> p1 = Point()
>>> p1.x = 3.0
>>> p1.y = 4.0
>>> p2 = p1
>>> p2.y = 7.0
>>> print_point(p1)
(3, 7)
>>> p1 is p2
True
>>> import copy
>>> p2 = copy.copy(p1)
>>> p2.y = 9.0
>>> print_point(p1)
(3, 7)
>>> print_point(p2)
(3, 9)
>>> p1 is p2
False
Notons que :
>>>
>>>
>>>
>>>
p1 =
p1.x
p1.y
p2 =
Point()
= 3.0
= 4.0
copy.copy(p1)
p1 == p2 retourne False !
En effet, pour les objets, le comportement par dfaut de == est le mme que loprateur is.
Mais ce comportement pourra tre modifi (dans la dfinition de classe).
Soit :
>>> box2 = copy.copy(box)
>>> box2 is box
False
Mais box2.corner is box.corner renvoie True car la fonction copy.copy ralise

une shallow copy, c--d quelle copie les rfrences contenues dans les attributs mutables.
Rappel [la fonction copy.deepcopy ralise une deep copy,] c--d quelle copie galement les objets rfrencs dans les attributs mutables (et ceux rfrencs par ceux-ci,
etc.).
>>> box3 = copy.deepcopy(box)
>>> box3 is box
False
>>> box3.corner is box.corner
False
Les objets rfrencs par box et box3 sont maintenant compltement spars (et indpendants).
171
13.2.6 Mthodes
Les attributs dun objet modlisent son tat, ses particularits dans la famille des objets du
mme type.
Exemples:
un point a comme coordonnes (2,3); un autre (4,5), mais ce sont deux points dans le
plan.
un rectangle a une largeur de 10, une hauteur de 20, et un coin infrieur droit en (3,7).
Un autre sera plus grand, ou plus droite, mais il reste un rectangle.
un temps dans la journe correspond la manire dont nous dcrivons un temps donn,
c--d, une heure, une minute et une seconde.
Mais un objet possde dautres proprits que ses attributs : les mthodes associes son type
(sa classe).
Une mthode est une fonction qui est dfinie pour un type donn et qui sapplique sur les objets
de ce type.
Intuitivement, une mthode est une action applique sur un objet (et peut avoir besoin dautres
entres que lobjet sur lequel elle est applique, et peut produire galement des sorties).
Exemple: Pour manipuler des heures nous pouvons dfinir une classe Time :
class Time(object):
""" represente un temps (heure).
attributs: hour, minute, second
"""
Nous pourrions dfinir une mthode display associe le classe Time :

>>> class Time(object):
""" represente un temps (heure).
attributs: hour, minute, second
"""
def display(self):
print("{0}:{1}:{2}".format(self.hour, self.minute, self.second))
>>> start = Time()
>>> start.hour = 9
>>> start.minute = 45
>>> start.second = 0
>>> start.display()
09:45:00
Dfinir une mthode revient simplement donner sa dfinition lintrieur de la dfinition de

la classe. Pour accder lobjet sur lequel la mthode sera invoque, on utilise la premire
variable nomme self (par convention).
Une mthode destine tre invoque sur un objet possde toujours cet objet comme premier
paramtre; quand on invoque la mthode sur un objet, il ne faut pas donner largument (self);
ce type de mthodes est appel une mthode dinstance;
172
Note: il existe dautres types de mthodes (de classes et statiques) qui ne seront pas vues dans
ce cours.
Notons que lon a ici une bauche de programmation oriente-objets :
>>> start.display()
09:45:00
o les objets sont les agents actifs.

Supposons que lon veuille avoir une mthode qui additionne un temps un autre. Un des deux
objets sera lobjet sur lequel la mthode sera invoque et qui sera modifi, lautre sera donn
en paramtre.
Pour cela nous allons dabord crire une mthode to_sec qui traduit un temps en secondes.
Inversment crivons une mthode update qui prend un nombre de secondes en arguments et
met jour lobjet Time en transformant ce nombre en temps.
class Time(object):
# ...
def to_sec(self):
mins = self.hour * 60 + self.minute
secs = mins * 60 + self.second
return secs
def update(self, secs):
mins, self.second = divmod(secs, 60)
self.hour, self.minute = divmod(mins, 60)
def add(self, other):
secs = self.to_sec() + other.to_sec()
self.update(secs)
On pourra alors par exemple avoir:

>>> start = Time()
>>> start.hour = 9
>>> start.minute = 45
>>> start.second = 0
>>> duration = Time()
>>> duration.hour = 1
>>> duration.minute = 35
>>> duration.second = 0
>>> start.display()
09:45:00
>>> duration.display()
01:35:00
>>> duration.to_sec()
5700
>>> duration.update(5760)
>>> duration.display()
173
01:36:00
>>> start.add(duration)
>>> start.display()
11:21:00
13.2.7 La mthode init

La mthode init (__init__) est une mthode spciale qui est invoque automatiquement
quand un objet est cr. Cela permet dajouter des arguments (par dfaut) quand on cre un
objet.
class Time(object):
# ...
def __init__(self, hour=0, minute=0, second=0):
self.hour = hour
self.minute = minute
self.second = second
# ...
On pourra ainsi avoir le code:

>>> t1 = Time()
>>> t2 = Time(3)
>>> t3 = Time(4, 12)
>>> t4 = Time(18, 35, 17)
>>> t1.display()
00:00:00
>>> t2.display()
03:00:00
>>> t3.display()
04:12:00
>>> t4.display()
18:35:17
13.2.8 Les mthodes __str__ et __rep__

La mthode str (note __str__ dans la dfinition dune nouvelle classe) est une mthode spciale qui est cense retourner une reprsentation de lobjet sous forme de chane de caractres.
Lors dune instruction print, Python appelle automatiquement cette mthode.
class Time(object):
# ...
def __str__(self):
return "{0:02d}:{1:02d}:{2:02d}".format(self.hour, self.minute, self.secon
# ...
174
>>> t = Time(8,30)
>>> print(t)
08:30:00
>>> str(t)
08:30:00
La mthode display dfinie plus haut devient inutile.

La mthode repr (note __repr__ dans la dfinition dune nouvelle classe) est galement
une mthode spciale; elle est cense retourner une reprsentation non ambige de lobjet sous
forme de chane de caractres.
Si pour les objets simples, __repr__ et __str__ peuvent produire la mme valeur (par
exemple repr(3) ou str(3)), on peut dj constater une diffrence entre
>>> str(Hello)
Hello
>>> repr(Hello)
"Hello"
>>>
Le premier donnant le string qui sera imprim, lautre le string de la reprsentation non ambige
(donc entour de quotes pour indiquer quun lobjet est lui mme un string).
Lors dune session interactive, lorsque vous tapez juste le nom de lobjet x suivi de la touche
clavier de retour la ligne, linterprteur Python ralise un print(repr(x)).
>>> x = 36
>>> x
36
>>> s = Hello
>>> s
Hello
>>> print(s)
Hello
>>>
Pour la classe Time, on pourra ainsi avoir le code:

class Time(object):
def __init__(self, hour=0, minute=0, second=0):
self.hour = hour
self.minute = minute
self.second = second
def __str__(self):
return "{0:02d}:{1:02d}:{2:02d}".format(
self.hour, self.minute, self.second)
def __repr__(self):
return "{0}({1:02d}:{2:02d}:{3:02d})".format(
self.__class__, self.hour,self.minute, self.second)
# ...
Dans le code prcdent, attribut __class__ renvoie un string avec le nom de la classe dfnie
(dans ce cas ci <class __main__.Time>)
175
13.2.9 Surcharge doprateur

On peut galement dfinir des oprateurs sur les objets. Par exemple, loprateur + peut tre
dfini en crivant une mthode spciale __add__ pour la classe Time.
On parle de surcharge des oprateurs : adapter le comportement dun oprateur un type dfini
par le programmeur.
class Time(object):
# ...
def __add__(self, other):
res = Time()
secs = self.to_sec() + other.to_sec()
res.update(secs)
return res
# ...

>>> t1 = Time(9)
>>> t2 = Time(1,30)
>>> t3 = t1 + t2
>>> print(t3)
10:30:00
Pour chaque oprateur prsent en Python,

il y a une mthode spciale qui correspond et qui permet de surcharger loprateur !
(Voir:
http://docs.python.org/3/reference/datamodel.html#special-method-names)
Time + int : pour le moment loprateur + opre sur deux objets Time. Nous voudrions
pouvoir galement pouvoir ajouter un nombre entier (secondes) ces objets.
class Time(object):
# ...
def __add__(self, other):
res = Time()
secs = self.to_sec()
if isinstance(other, Time):
secs += other.to_sec()
elif isinstance(other, int):
secs += other
else:
raise NotImplemented(op + only for Time and int)
res.update(secs)
return res
# ...

>>> t1 = Time(9)
>>> t2 = t1 + 600
>>> print(t2)
09:10:00
176
>>> t3 = t1 + t2
>>> print(t3)
18:10:00
Problme : malheureusement, cette addition nest pas commutative. Si lentier est le premier
oprateur, on obtient une erreur.
>>> 1200 + t3
TypeError: unsupported operand type(s) for +: int and Time
Le problme vient du fait quau lieu de demander un objet Time dajouter un entier, on fait le
contraire, et on ne peut pas modifier les objets de type entiers pour quils connaissent les objets
Time.
Solution : crire la mthode spciale __radd__ (right-side add). Cette mthode est automatiquement invoque quand un objet Time est le membre droit dun oprateur + (et que la
mthode __add__ nexiste pas ou retourne NotImplemented sur le membre gauche).
class Time(object):
# ...
def __radd__(self, other):
return self.__add__(other)
# ...

>>> t1 = Time(8)
>>> t2 = 1200 + t1
>>> print(t2)
08:20:00
Note: les mthodes spciales peuvent tre galement invoques la main, comme nimporte
quelle autre mthode.
13.2.10 Polymorphisme
On a dj vu quune fonction peut sappliquer sur diffrents types dobjets, pour peu que le
corps de la fonction applique des oprateurs disponibles pour ce type dobjet. On appelle cette
caractristique le polymorphisme. Cela signifie par exemple que lon peut utiliser la fonction
sum sur nos objets Time !
>>> sum(range(10))
45
>>> t = [Time(1,30), Time(2), Time(3,45,30)]
>>> total_time = sum(t)
>>> print(total_time)
07:15:30
177
13.3 Programmation oriente objet

Des langages comme Python, C++ ou Java permettent de dfinir des classes, dinstancier des
objets et de les manipuler.
Cette partie de la syntaxe nest pas ncessaire (on pourrait tout faire rien quavec des fonctions),
mais elle permet une programmation intuitive, concise et rutilisable : la programmation oriente objet.
Nous navons couvert quune toute petite partie des concepts orients objets. Il existe une srie
de techniques trs intressantes et permettant daccentuer encore les avantages prcits.
Les cours de programmation ou dalgorithmiques suivants couvriront bien plus cette matire.
178
CHAPTER
FOURTEEN
QUELQUES MOTS SUR LES

LANGAGES DE PROGRAMMATION
Note: La plupart des sections de ce chapitre proviennent des diffrentes sources listes cidessous:
http://en.wikipedia.org/wiki/History_of_programming_languages
dcembre 2012)
(consultation
http://fr.wikipedia.org/wiki/Histoire_des_langages_de_programmation (consultation 4
dcembre 2012)
http://en.wikipedia.org/wiki/Programming_language (consultation 4 dcembre 2012)
http://fr.wikipedia.org/wiki/Langage_de_programmation
2012)
(consultation
dcembre
http://www.computerhistory.org/ (consultation 5 dcembre 2012)

http://histoire.info.online.fr/ (consultation 5 dcembre 2012)
http://www.histoire-informatique.org/ (consultation 5 dcembre 2012)
Ancien syllabus du cours (langage C++)
14.1 Introduction
Un langage de programmation est une notation artificielle, destine exprimer des algorithmes
et produire des programmes. Dune manire similaire une langue naturelle, un langage de
programmation est fait dun alphabet, un vocabulaire, des rgles de grammaire (syntaxe), et
des significations (smantique). Les langages de programmation servent dcrire les structures
des donnes qui seront manipules par lordinateur, et indiquer comment sont effectues les
manipulations, selon quels algorithmes. Ils servent de moyens de communication par lesquels
le programmeur communique avec lordinateur, mais aussi avec dautres programmeurs; les
programmes tant dordinaire cris, lus, compris et modifis par une communaut.
Un langage de programmation est mis en oeuvre par un traducteur automatique: compilateur
ou interprteur.
179
Les langages de programmation offrent diffrentes possibilits dabstraction, et une notation

proche de lalgbre, permettant de dcrire de manire concise et facile saisir les oprations
de manipulation de donnes et lvolution du droulement du programme en fonction des situations. La possibilit dcriture abstraite libre lesprit du programmeur dun travail superflu,
et lui permet de se concentrer sur des problmes plus avancs.
Chaque langage de programmation reflte un ou plusieurs paradigmes, un ensemble de notions
qui orientent le travail de rflexion du programmeur, sa technique de programmation et sa
manire dexprimer le fruit de ses rflexions dans un langage de programmation.
Les premiers langages de programmation ont t crs dans les annes 1950. De nombreux
concepts ont t lancs par un langage, puis amliors et tendus dans les langages suivants.
La plupart du temps la conception dun langage de programmation a t fortement influence
par lexprience acquise avec les langages prcdents
14.1.1 Compilateur
Un compilateur est un programme informatique qui transforme un code source crit dans un
langage de programmation (le langage source) en un autre langage informatique (le langage
cible).
programme source
Compilateur
code objet
Pour quil puisse tre exploit par la machine, le compilateur traduit le code source, crit dans
un langage de haut niveau dabstraction, facilement comprhensible par lhumain, vers un langage de plus bas niveau, un langage dassemblage ou langage machine. Dans le cas de langage
semi-compil (ou semi-interprt), le code source est traduit en un langage intermdiaire, sous
forme binaire (code objet ou bytecode), avant dtre lui-mme interprt ou compil.
Un compilateur effectue les oprations suivantes : analyse lexicale, pr-traitement (prprocesseur), analyse syntaxique (parsing), analyse smantique, gnration de code intermdiaire,
optimisation de code et gnration de code final.
Quand le programme compil (code objet) peut tre excut sur un ordinateur dont le processeur ou le systme dexploitation est diffrent de celui du compilateur, on parle de compilateur crois (cross-compiler).
Structure et fonctionnement
La tche principale dun compilateur est de produire un code objet correct qui sexcutera
sur un ordinateur. La plupart des compilateurs permettent doptimiser le code, cest--dire
quils vont chercher amliorer la vitesse dexcution, ou rduire loccupation mmoire du
programme.
180
Chapter 14. Quelques mots sur les langages de programmation
Un compilateur fonctionne par analyse-synthse : au lieu de remplacer chaque construction du

langage source par une suite quivalente de constructions du langage cible, il commence par
analyser le texte source pour en construire une reprsentation intermdiaire (appele image)
quil traduit son tour en langage cible.
On spare le compilateur en au moins deux parties : une partie avant (ou frontale - front-end)
qui lit le texte source et produit la reprsentation intermdiaire (appele galement image); et
une partie arrire (ou finale - back-end), qui parcourt cette reprsentation pour produire le code
cible. Dans un compilateur idal, la partie avant est indpendante du langage cible, tandis que
la partie arrire est indpendante du langage source.
Java
Haskell
Prolog
Image
P7
RISC
Certains compilateurs effectuent des traitements substantiels sur la partie intermdiaire, devenant une partie centrale part entire, indpendante la fois du langage source et de la
machine cible. On peut ainsi crire des compilateurs pour toute une gamme de langages et
darchitectures en partageant la partie centrale, laquelle on attache une partie avant par langage et une partie arrire par architecture.
Les tapes de la compilation incluent :
le prtraitement, ncessaire pour certaines langues comme C, qui prend en charge la
substitution de macro et de la compilation conditionnelle. Gnralement, la phase de
prtraitement se produit avant lanalyse syntaxique ou smantique.
lanalyse lexicale (scanning), qui dcoupe le code source en petits morceaux appels
jetons (tokens). Chaque jeton est une unit atomique unique de la langue (units lexicales
ou lexmes), par exemple un mot-cl, un identifiant ou un symbole. Le logiciel qui
effectue une analyse lexicale est appel un analyseur lexical ou un scanner. Deux outils
classiques permettent de construire plus aisment des scanners : lex et flex.
lanalyse syntaxique implique lanalyse de la squence de jetons pour identifier la structure syntaxique du programme. Cette phase sappuie gnralement sur la construction
dun arbre danalyse ; on remplace la squence linaire des jetons par une structure en
arbre construite selon la grammaire formelle qui dfinit la syntaxe du langage. Par exemple, une condition est toujours suivie dun test logique (galit, comparaison...). Larbre
danalyse est souvent modifi et amlior au fur et mesure de la compilation. Yacc et
GNU Bison sont les outils les plus utiliss pour construire des analyseurs syntaxiques.
lanalyse smantique est la phase durant laquelle le compilateur ajoute des informations
14.1. Introduction
181
smantiques larbre danalyse et construit la table des symboles. Cette phase fait un
certain nombre de contrles: vrifie le type des lments (variables, fonctions, ...) utiliss dans le programme, leur visibilit, vrifie que toutes les variables locales utilises
sont initialises, .... Lanalyse smantique ncessite habituellement un arbre danalyse
complet, ce qui signifie que cette phase fait suite la phase danalyse syntaxique, et
prcde logiquement la phase de gnration de code ; mais il est possible de replier ces
phases en une seule passe.
la transformation du code source en code intermdiaire ;
lapplication de techniques doptimisation sur le code intermdiaire : cest--dire rendre
le programme meilleur selon son usage;
la gnration de code avec lallocation de registres et la traduction du code intermdiaire
en code objet, avec ventuellement linsertion de donnes de dbogage et danalyse de
lexcution.
Scanning
Parsing
Errors
management
Semantic
Analysis
Intermediate
code generation
Optimisation
Final code
generation
}
}
Analysis
Symbol
table
Lanalyse lexicale, syntaxique et smantique, le passage par un langage intermdiaire et

loptimisation forment la partie frontale. La gnration de code 1 constitue la partie finale.
Ces diffrentes tapes font que les compilateurs sont toujours lobjet de recherches.
1
182
avec ldition de liens,
Synthesis
14.1.2 Interprteur
Un interprteur est un outil informatique ayant pour tche danalyser, de traduire et dexcuter
un programme crit dans un langage informatique. De tels langages sont dits langages interprts.
Linterprteur est capable de lire le code source dun langage sous forme de script, habituellement un fichier texte, et den excuter les instructions (une la fois) aprs une analyse syntaxique du contenu. Cette interprtation conduit une excution daction ou un stockage de
contenu.
Principe
Linterprtation consiste en lexcution dynamique du programme par un autre programme
appel interprteur, plutt que sur sa conversion (compilation) en un autre langage (par exemple
le langage machine) ; ainsi la traduction et lexcution sont simultanes.
Le cycle dun interprteur est le suivant :
lire et analyser une instruction (ou expression) ;
si linstruction est syntaxiquement correcte, lexcuter (ou valuer lexpression) ;
passer linstruction suivante.
Ainsi, contrairement au compilateur, linterprteur excute les instructions du programme (ou
en value les expressions), au fur et mesure de leur lecture pour interprtation. Du fait de
cette phase sans traduction pralable, lexcution dun programme interprt est gnralement
plus lente que le mme programme compil.
La plupart des interprteurs nexcutent plus la chane de caractres reprsentant le programme,
mais une forme interne, telle quun arbre syntaxique.
En pratique, il existe souvent des mlanges entre interprteurs et compilateurs.
Lintrt des langages interprts rside principalement dans la facilit de programmation et
dans la portabilit. Les langages interprts facilitent normment la mise au point des programmes car ils vitent la phase de compilation, souvent longue, et limitent les possibilits de
bogues. Il est en gnral possible dexcuter des programmes incomplets, ce qui facilite le
dveloppement rapide dapplications ou de prototypes dapplications.
Ainsi, le langage BASIC fut le premier langage interprt permettre au grand public daccder
la programmation, tandis que le premier langage de programmation moderne interprt est
Lisp.
La portabilit permet dcrire un programme unique, pouvant tre excut sur diverses platesformes sans changements, pourvu quil existe un interprteur spcifique chacune de ces
plates-formes matrielles.
Les inconvnients dune interprtation plutt quune compilation sont la lenteur lors de
lexcution, comme dj voqu, mais aussi labsence de contrle pralable sur la structure
du programme et les types des lments manipuls avant le dbut de son excution.
14.1. Introduction
183
Un certain nombre de langages informatiques sont aujourdhui mis en oeuvre au moyen dune
machine virtuelle applicative. Cette technique est mi-chemin entre les interprteurs tels que
dcrits ici et les compilateurs. Elle offre la portabilit des interprteurs avec une bonne efficacit. Par exemple, des portages de Java, Lisp, Scheme, Ocaml, Perl (Parrot), Python, Ruby, Lua,
C, etc. sont faits via une machine virtuelle.
Note: Lors de la conception dun programme dans un langage interprt, tant donn labsence
dun compilateur qui contrle les types, la visibilit, ..., les techniques de conception insistent
fortement sur la notion de test unitaire qui teste si possible lentiret du code dune fonction
ou dune classe, la fois au niveau fonctionnalit quen testant lensemble des lignes de code
crites, avant lintgration de ce code dans le reste du programme.
Notons cependant que tester ou vrifier la logique dun code est gnralement plus complexe
et doit se faire tant avec les langages interprts que compils.
Historique
Avec lapparition du langage compil Pascal et de compilateurs commerciaux rapides comme
Turbo Pascal, les langages interprts connurent partir du milieu des annes 1980 un fort
dclin. Trois lments changrent la donne dans les annes 1990 :
avec la ncessit dautomatiser rapidement certaines tches complexes, des langages de
programmation interprts (en fait, semi-interprts) de haut niveau comme, entre autres,
Tcl, Ruby, Perl ou Python se rvlrent rentables ;
la puissance des machines, qui doublait tous les dix-huit mois en moyenne (selon la loi de
Moore), rendait les programmes interprts des annes 1990 dune rapidit comparable
celle des programmes compils des annes 1980 ;
il est bien plus rapide de faire voluer un programme interprt. Or la vague Internet demandait une rponse trs rapide aux nouveaux besoins du march. amazon.com fut, dans
sa premire version, dvelopp largement en Perl. Smalltalk permettait un prototypage
trs rapide dapplications.
14.1.3 Runtime
Un runtime est lenvironnement dexcution du programme qui utilise un ensemble de bibliothques logicielles pour mettre en oeuvre le langage de programmation, permettant deffectuer
des oprations simples telles que copier des donnes, ou des oprations beaucoup plus complexes telles que le travail de garbage collection (ramasse-miettes).
Lors de la traduction dun programme vers le langage machine les oprations simples sont
traduites en les instructions correspondantes en langage machine tandis que les oprations complexes sont traduites en des utilisations de fonctions du runtime.
Chaque langage de programmation a une manire conventionnelle de traduire lexcution de
procdures ou de fonctions, de placer les variables en mmoire et de transmettre des paramtres.
Ces conventions sont appliques par le runtime. Le runtime sert galement mettre en oeuvre
184
certaines fonctionnalits avances des langages de programmation telles que le garbage collector qui rcupre de lespace mmoire 2 quand cest ncessaire pour continuer lexcution du
programme.
14.2 Les langages de programmation

14.2.1 Dfinition de la syntaxe dun langage de programmation - la
BNF
Un langage de programmation est dfini formellement grce une grammaire formelle, qui
inclut des symboles et des rgles syntaxiques, auxquels on associe des rgles smantiques. Ces
lments sont plus ou moins complexes selon la capacit du langage.
Lensemble des syntaxes possibles dun programme crit dans un certain langage de programmation (Python, Java ou C++ par exemple) (voir http://docs.python.org/3/reference/ pour
Python3) est souvent dfini grce au mtalangage EBNF (Forme de BackusNaur Etendu Extended BackusNaur Form) qui est un BNF tendu cr par Niklaus Wirth.
Donnons une brve prsentation du EBNF utilis pour dfinir Python.
Ainsi :
lc_letter ::=
name
::=
"a"..."z"
lc_letter (lc_letter | "_")*
dfinit un lment lc_letter comme tant nimporte quelle lettre alphabtique minuscule
et name comme tant nimporte quelle squence dau moins une lettre alphabtique qui peut
tre suivie de zro ou plus de caractres "_" ou alphabtique.
Dans ce mtalangage,
ce qui est rellement reprsent est mis entre " ";
le symbole ::= signifie que le nom gauche reprsente nimporte quel lment compatible avec la dfinition droite (par exemple dans lc_letter ::= "a"..."z");
"a"..."z" signifie tous les caractres entre "a" et "z";
(r1|r2) (par exemple dans (lc_letter | "_")) reprsente le choix entre la possibilit r1 et r2;
r* (par exemple dans lc_letter*) reprsente la rptition zro, une ou plusieurs fois
un lment de r;
r+ (par exemple dans lc_letter+) reprsente la rptition une ou plusieurs fois un
lment de r;
[ r ] reprsente loption: zro ou une fois r.
Ainsi les constantes (littraux) entiers et rel Python
http://docs.python.org/3/reference/lexical_analysis.html) par :
2
sont
dfinis
(voir
sur le tas dexcution (runtime heap)
14.2. Les langages de programmation
185
integer
decimalinteger
nonzerodigit
digit
octinteger
hexinteger
bininteger
octdigit
hexdigit
bindigit
::=
::=
::=
::=
::=
::=
::=
::=
::=
::=
decimalinteger | octinteger | hexinteger | bininteger

nonzerodigit digit* | "0"+
"1"..."9"
"0"..."9"
"0" ("o" | "O") octdigit+
"0" ("x" | "X") hexdigit+
"0" ("b" | "B") bindigit+
"0"..."7"
digit | "a"..."f" | "A"..."F"
"0" | "1"
et
floatnumber
pointfloat
exponentfloat
intpart
fraction
exponent
::=
::=
::=
::=
::=
::=
pointfloat | exponentfloat
[intpart] fraction | intpart "."
(intpart | pointfloat) exponent
digit+
"." digit+
("e" | "E") ["+" | "-"] digit+
Linstruction if est dfinie par:

if_stmt ::=
"if" expression ":" suite

( "elif" expression ":" suite )*
["else" ":" suite]
14.2.2 Dfinition de la smantique dun langage de programmation

La smantique dfinit le sens de chacune des phrases qui peuvent tre construites dans le langage, en particulier quels seront les effets de la phrase lors de lexcution du programme
La smantique est gnralement dcompose en smantique statique et smantique dynamique.
La smantique dpend trs fort des paradigmes du langage.
Smantique statique
Dans un langage impratif, comme C++, Java, Python, lanalyse smantique statique appele
aussi gestion de contexte soccupe des relations non locales ; elle soccupe ainsi :
du contrle de visibilit et du lien entre les dfinitions et utilisations des identificateurs;
du contrle de type des objets, nombre et type des paramtres de fonctions;
du contrle de flot (vrifie par exemple quun goto est licite).
Pour les langages compils, il sagit en gros, de tout ce qui peut tre contrl pendant la compilation.
186
Smantique dynamique
Pour un langage compil, cest la partie de contrle qui a lieu lors de lexcution du programme.
Par exemple, si le type prcis dune variable ne peut tre connue qu lexcution, le contrle
de type est dynamique.
Note: Si un programme sexcute sans erreur (exception,...) mais ne fournit pas le bon rsultat,
on parle d erreur de logique ou d erreur de logique de conception.
14.2.3 Types
Un type de donne dfinit les valeurs que peut prendre une donne, ainsi que les oprateurs qui
peuvent lui tre appliqus.
Un type peut tre:
simple (prdfinis ou non): par exemple: boolen, entier, rel, pointeur (cest--dire
adresse), ou
compos : par exemple, string, tuple, dictionnaire, liste, structure, classe.
Si on prend lexemple de C++ on y trouve des variables simples (par exemple entire), des
pointeurs et des rfrences.
Par exemple:
int i = 18;
int *p = &i;
int &j = i;
int tab[5] = {0,0,0,0,0};
*p = 36;
j = 36;
dclare quatre lments que le programme va pouvoir manipuler:

une variable i entire, initialise la valeur 18;
une variable p de type pointeur vers un entier, initialise ladresse de la variable i;
une constante j de type rfrence qui est un alias (autre nom) i;
une constante qui est un pointeur (une adresse) vers un tableau de 5 lments entiers
initialiss 0, cest--dire une zone mmoire qui contient 5 variables entires initialises
0.
Dans ce programme
i et j sont vues comme deux noms pour la mme variable. On peut donc faire le parallle
avec le code Python j = i = 18;
tab est similaire au code Python tab = [0]*5 qui dfinit une liste de 5 lments
nuls;
14.2. Les langages de programmation
187
Par contre, Python na pas la notion de pointeur, qui permet explicitement de manipuler des
adresses dans des variables et qui permet tant damusement en programmation C++ (y compris
labsence de garbage collector).
Note: En pratique pointeur (comme p dans le programme plus haut) et rfrence (comme
j) manipulent tous les deux des adresses. La diffrence est que dans le cas du pointeur, si
lutilisateur veut manipuler la variable ou lobjet point, il doit lexprimer explicitement
(comme avec *p = 36 qui assigne la variable pointe par p, cest--dire i, la valeur 36).
Avec les rfrences, le drfrenage (dereferencing) est automatique; on ne peut manipuler
ladresse mais uniquement lobjet rfrenc (comme avec j = 36 qui a le mme effet que
linstruction prcdente).
Typage statique et typage dynamique

On parle de typage statique (exemple: avec C++, Java, Pascal) quand la majorit des vrifications de type sont effectues au moment de la compilation. Au contraire, on parle de typage
dynamique (exemple avec SmallTalk Common Lisp, Scheme, PHP, Perl, Tcl, Python, Ruby,
Prolog) quand ces vrifications sont effectues pendant lexcution.
Les avantages des langages statiques par rapport aux dynamiques sont :
beaucoup derreurs sont dcouvertes plus tt (grce au contrle de type la compilation);
le fait de contraindre les programmeurs bien structurer leur code;
permet davoir un code compil plus rapide o le contrle de type est (en grande partie)
termin aprs la compilation;
fixe les types ce qui permet un code plus simple comprendre
Les avantages des langages dynamiques par rapport aux langages statiques sont :
puissance et flexibilit: permet de faire des choses difficiles implmenter avec des
langages statiques (polymorphisme, introspection, excution de code dynamique, ...).
Typage fort et typage faible
Un langage de programmation est dit fortement typ lorsquil garantit que les types de donnes
employs dcrivent correctement les donnes manipules. Par opposition, un langage sans
typage fort peut tre faiblement typ, ou pas du tout typ (mais en pratique ce nest jamais
le cas). BASIC, JavaScript, Perl, PHP sont plutt mettre dans la catgorie des langages
faiblement typs; C++, C#, Java, Python, OCaml dans les langages fortement typs.
Typage explicite et typage implicite
Avec un typage explicite, cest lutilisateur dindiquer lui-mme les types quil utilise, par
exemple lors des dclarations de variables ou de fonctions.
Par exemple, en langage C, le typage est explicite :
188
int i = 0;
// cette dclaration indique explicitement que

// la variable i est de type entier
Au contraire, avec un systme de typage implicite, le dveloppeur laisse au compilateur ou au

runtime le soin de dterminer tout seul les types de donnes utilises, par exemple par infrence.
Python a donc un typage dynamique, fort et implicite.
14.3 Paradigmes des langages de programmation

Chaque langage de programmation reflte un ou plusieurs paradigmes de programmation. Un
paradigme est un ensemble de notions qui oriente le travail de rflexion du programmeur et peut
tre utilis pour obtenir une solution un problme de programmation. Chaque paradigme
amne une technique diffrente de programmation; une fois quune solution a t imagine
par le programmeur selon un certain paradigme, un langage de programmation qui suit ce
paradigme permettra de lexprimer.
14.3.1 Le paradigme impratif ou procdural

est bas sur lide dune excution tape par tape semblable une recette de cuisine. Il est bas
sur le principe de la machine de Von Neumann. Un ensemble de structures permet de contrler
lordre dans lequel sont excutes les commandes qui dcrivent les tapes. Labstraction est
ralise laide de procdures auxquelles sont transmises des donnes. Il existe une procdure
principale, qui est la premire tre excute, et qui peut faire appel dautre procdures
pour effectuer certaines tches ou certains calculs. Les langages de programmation C, Pascal,
Fortran, COBOL, Java, Python sont en paradigme impratif.
14.3.2 Le paradigme fonctionnel

est bas sur lide dvaluer une formule, et dutiliser le rsultat pour autre chose 3 . Tous
les traitements sont faits en valuant des expressions et en faisant appel des fonctions, et
lexcution tape par tape nest pas possible dans le paradigme fonctionnel. Le rsultat dun
calcul sert de matire premire pour le calcul suivant, et ainsi de suite, jusqu ce que toutes
les fonctions aient produit un rsultat. ML et Lisp sont des langages de programmation en
paradigme fonctionnel. Python possde galement des notions permettant de programmer dans
ce paradigme.
Note: La rcursivit est une technique naturellement associe au paradigme fonctionnel.
3
, selon le modle du lambda-calcul
14.3. Paradigmes des langages de programmation
189
14.3.3 Le paradigme logique

est bas sur lide de rpondre une question par des recherches sur un ensemble, en utilisant
des axiomes, des demandes et des rgles de dduction. Lexcution dun programme est une
cascade de recherche de donnes dans un ensemble, en faisant usage de rgles de dduction.
Les donnes obtenues, et associes un autre ensemble de rgles peuvent alors tre utilises
dans le cadre dune autre recherche. Lexcution du programme se fait par valuation, le systme effectue une recherche de toutes les affirmations qui, par dduction, correspondent au
moins un lment de lensemble. Le programmeur exprime les rgles, et le systme pilote le
processus. Prolog est un langage de programmation en paradigme logique.
14.3.4 Dans le paradigme orient objet,

chaque objet est une entit active, qui communique avec dautres objets par change de messages. Les changes de message entre les objets simulent une volution dans le temps dun
phnomne rel. Les procdures agissent sur les donnes et le tout est cloisonn dans des objets. Les objets sont groups en classes ; les objets dune mme classe sont similaires. La
programmation consiste dcrire les classes. Les classes sont organises selon une structure
hirarchique o il y a de lhritage: de nouveaux objets peuvent tre crs sur la base dobjets
existants. Ce paradigme a t dvelopp pour parer aux limitations de son prdcesseur, le
paradigme procdural, tout particulirement avec les trs grands programmes. Le paradigme
orient objet aide le programmeur crer un modle organis du problme traiter, et permet
dassocier fortement les donnes avec les procdures. Simula, Smalltalk, C++ et Java sont des
langages de programmation en paradigme orient objet. Python possde galement des notions
permettant de programmer dans ce paradigme.
14.4 Histoire des langages de programmation

Note: Cette section rsume succinctement lHistoire de linformatique lie aux langages de
programmation. Les rfrences donnes en dbut de chapitre sont intressantes pour voir plus
gnralement lHistoire de linformatique et en particulier les aspects matriels ou principes
mathmatiques ou algorithmiques sous-jacents (ordinateurs, thorie de linformation et du
codage, thorie des langages, thorie de la dcidabilit et de la calculabilit, algorithmique,
...).
14.4.1 La prhistoire (avant 1940)
820 : Le mathmaticien perse Al Khawarizmi publie Bagdad un trait intitul Abrg

du calcul par la restauration et la comparaison qui, import en Europe Occidentale lors
des invasions arabes aura une grande influence sur le dveloppement des mathmatiques.
190
En 1801, le mtier Jacquard utilisait des trous dans des cartes perfores pour reprsenter
les mouvements du bras du mtier tisser, et ainsi gnrer automatiquement des motifs
dcoratifs.
1840 : Collaboratrice de Babbage, Ada Lovelace, mathmaticienne, dfinit le principe
des itrations successives dans lexcution dune opration. En lhonneur du mathmaticien perse Al Khawarizmi (820), elle nomme le processus logique dexcution dun
programme : algorithme (dformation de Al Khawarizmi). Ada Lovelace a traduit le mmoire du mathmaticien italien Luigi Menabrea sur la Machine analytique, la dernire
machine propose par Charles Babbage.
1854 : Boole publie un ouvrage dans lequel il dmontre que tout processus logique peut
tre dcompos en une suite doprations logiques (ET, OU, NON) appliques sur deux
tats (ZERO-UN, OUI-NON, VRAI-FAUX, OUVERT-FERME).
1887: Herman Hollerith a cr une machine cartes perfores qui a servi au recensement
de 1890.
1863-1895 : On peut galement considrer les rouleaux en papier dun pianola (piano
mcanique) comme un programme limit un domaine trs particulier, quoique non
destin tre exploit par des humains.
14.4.2 Les annes 1940

1943 : Le Plankalkl imagin par Konrad Zuse (implment fin des annes nonantes)
1943 : Le langage de programmation de lENIAC
1948 : Le langage machine du premier programme enregistr, i.e. le jeu dinstructions
de la SSEM : premire machine programme enregistr.
Note: En 1945, un insecte coinc dans les circuits bloque le fonctionnement du calculateur
Mark I. La mathmaticienne Grace Murray Hopper dcide alors que tout ce qui arrte le bon
fonctionnement dun programme sappellera BUG.
Il faut noter que le terme BUG tait dj utilis avant cela : Thomas Edison par exemple avait
employ ce terme dans un courrier o il parlait de la mise au point problmatique de lune de
ses inventions.
14.4.3 Les annes 1950 et 1960

1950 : Invention de lassembleur par Maurice V. Wilkes de luniversit de Cambridge.
Avant, la programmation seffectuait directement en binaire.
1951 : Invention du premier compilateur A0 par Grace Murray Hopper qui permet de
gnrer un programme binaire partir dun code source.
14.4. Histoire des langages de programmation
191
Les trois premiers langages de programmation modernes ont t conus :

1957 : FORTRAN (langage impratif), le traducteur de formules (FORmula TRANslator), invent par John Backus et al. (voir exemple)
1958 : LISP (langage impratif et fonctionnel) , spcialis dans le traitement des listes
(LISt Processor), invent par John McCarthy et al. (exemple: fonction factorielle)
1960 : COBOL (langage impratif), spcialis dans la programmation dapplication de

gestion (COmmon Business Oriented Language), cr par le Short Range Committee
dans lequel on retrouve entre autres Grace Hopper. (voir exemple)
Les descendants de ces trois langages sont actuellement encore trs utiliss.
Une autre tape cl de ces annes a t la publication Zurich par une commission
dinformaticiens europens et amricains dun nouveau langage permettant de dcrire les problmes de manire algorithmique : ALGOL (ALGorithmic Oriented Language). Le rapport,
publi pour la premire fois en 1958, fait la synthse des principales ides circulant lpoque,
et propose deux innovations majeures :
Structure en blocs imbriqus : le programme peut tre structur en morceaux de codes
logiques sans avoir besoin de donner un nom explicite ce bloc de code ; on pourrait
rapprocher cette notion du paragraphe dans le monde littraire.
Notion de porte : un bloc peut manipuler des variables qui lui sont propres ; aucun code
en dehors de ce bloc ne peut y accder, et encore moins les manipuler.
La manire mme dont le langage a t dcrit est innovante en soi : la syntaxe du langage a t
dcrite de manire mathmatique, en utilisant le mtalangage BNF (Forme de BackusNaur).
Presque tous les langages venir utiliseront une variante de cette notation BNF pour dcrire
leur syntaxe (ou au moins la sous-partie non-contextuelle de leur syntaxe).
Les ides essentielles dAlgol se retrouvent finalement dans Algol 68 :
La syntaxe et la smantique deviennent encore plus orthogonales, avec des procdures
anonymes, un systme de types rcursifs, des fonctions dordre suprieur...
Niklaus Wirth abandonne alors la commission de conception dAlgol, et partir de ses travaux
sur Algol-W (pour Wirth) crera un langage plus simple, le Pascal.
Vue densemble :
1951 - Regional Assembly Language

1952 - AUTOCODE
1955 - FLOW-MATIC, ou encore B-0 (Business Language version 0) [anctre de
COBOL]
1957 - FORTRAN
192
1957 - COMTRAN (COMmercial TRANslator) [anctre de COBOL]

1958 - LISP
1958 - ALGOL 58
1959 - FACT (Fully Automated Compiling Technique) [anctre de COBOL]
1960 - COBOL
1962 - APL (A Programming Language)
1962 - Simula I (Simple universal language)
1964 - BASIC (Beginners All-purpose Symbolic Instruction Code)
1964 - PL/I (Programming Language number 1) dvelopp par IBM
14.4.4 1967 1978 : mise en place des paradigmes fondamentaux

Vritable foisonnement des langages de programmation. La plupart des paradigmes des principaux langages sont invents durant cette priode :
Simula 67, invent par Nygaard et Dahl comme sur-couche dAlgol 60, est le premier
langage conu pour pouvoir intgrer la programmation oriente objet.
C, un des premiers langages de programmation systme, est dvelopp par Dennis
Ritchie et Ken Thompson pour les laboratoires Bell entre 1969 et 1973.
Smalltalk (milieu des annes 1970) est lun des premiers langages de programmation
disposer dun environnement de dveloppement intgr compltement graphique.
Prolog (PROgrammation LOGique), dfini en 1972 par Colmerauer, Roussel et Kowalski
est le premier langage de programmation logique.
ML (Meta Language) invent par Robin Milner en 1973, construit sur un typage statique
fort et polymorphe au-dessus de Lisp, pionnier du langage de programmation gnraliste
fonctionnel.
Chacun de ces langages a donn naissance toute une famille de descendants, et la plupart des
langues modernes comptent au moins lun dentre eux dans son ascendance.
Note: Les annes 1960 et 1970 ont galement t lpoque dun considrable dbat sur le
bien-fond de la programmation structure, qui signifie essentiellement la programmation sans
lutilisation de GOTO (ou break). Ce dbat a t troitement li la conception de langages :
certaines langages nintgrant pas GOTO, beaucoup sont donc contraints dutiliser la programmation structure. Bien que ce dbat et fait rage lpoque, dsormais un trs large consensus
existe parmi les programmeurs : mme dans des langages qui intgrent GOTO, utiliser cette
instruction est devenu quasiment tabou, sauf dans de rares circonstances.
Voici une liste de quelques langages importants qui ont t dvelopps au cours de cette priode:
1967 - Simula
193
1970 - Pascal
1970 - Forth
1972 - C
1972 - Smalltalk
1972 - Prolog
1973 - ML
1978 - SQL (Structured Query Language), au dpart seulement un langage de requtes,
puis tendu par la suite la construction de programme procdural de type SQL/PSM,
PL/SQL,...
14.4.5 Les annes 1980 : consolidation, modules, performance

Annes dune relative consolidation.
C++ combine la programmation systme et oriente-objet.
Le gouvernement des tats-Unis normalise Ada, un langage de programmation systme
destin tre utilis par les sous-traitants de la dfense.
Au Japon et ailleurs, des sommes normes ont t dpenses pour tudier ce quon appelle les langages de cinquime gnration des langages qui intgrent la logique de
construction des programmes.
Les groupes de langages fonctionnels continuent normaliser ML et Lisp ces ides
labores et inventes pendant la dcennie prcdente plutt que dinventer de nouveaux
modles.
Tendances:
utilisation de modules;
adaptation de nouveaux contextes (par exemple, les langages systmes Argus et Emerald adapts la programmation oriente-objet pour les systmes distribus);
progrs dans la mise en oeuvre des langages de programmation (pour architectures RISC,
amliorations de plus en plus agressive des techniques de compilation)
1983 - Ada
1983 - C++
1983 - LaTeX (dition de textes scientifiques)
1985 - Eiffel
1987 - Perl
194
14.4.6 Les annes 1990

voient peu de nouveauts fondamentales apparatre. Au contraire, beaucoup dides anciennes
sont combines et portes maturit, dans lobjectif principal daugmenter la productivit du
programmeur. Beaucoup de langages dveloppement rapide dapplication (RAD : rapid
application development) apparaissent. Ce sont souvent des descendants de langages plus anciens. Ils sont gnralement orients objet et fournis avec un environnement de dveloppement
intgr ainsi quavec un ramasse-miettes (garbage collector). Cest ainsi que sont apparus Object Pascal, Visual Basic et C#. Java est un langage orient-objet qui implmente galement le
ramasse-miettes, et a t un important centre dintrt.
Les nouveaux langages de script ont une approche plus novatrice et aussi plus radicale. Ceuxci ne descendent pas directement dautres langages : ils prsentent de nouvelles syntaxes et
de nouvelles fonctionnalits leur sont incorpores de manire plus souple. Beaucoup considrent que ces langages de script sont plus productifs que les langages RAD. Cependant, si les
programmes les plus petits sont effectivement plus simples, on peut considrer que des programmes plus gros seront plus difficiles mettre en oeuvre et maintenir. En dpit de ces
raisons, les langages de script sont devenus les plus utiliss dans un contexte Web.
1990 - Haskell
1991 - Python
1991 - Visual Basic
1991 - HTML (Mark-up Language)
1993 - Ruby
1993 - Lua
1995 - Java
1995 - Delphi (Object Pascal)
1995 - JavaScript
1995 - PHP
14.4.7 Les annes 2000

Lvolution des langages de programmation continue, la fois dans lindustrie et la recherche.
Quelques tendances actuelles:
Ajout de scurit et de sret, notamment dans la vrification du langage (analyse statique
de programmes), dans le contrle du flux dinformation (format des entres/sorties) et
dans la protection lors de lexcution de threads simultans (threadsafe).
Nouveaux concepts concernant la modularit : les mixin, la dlgation, la programmation
oriente aspect.
Le dveloppement orient composant.
195
La mtaprogrammation, et en particulier la rflexivit ou la manipulation de larbre syntaxique abstrait.

Concentration sur la distribution et la mobilit.
Intgration avec les bases de donnes, en particulier les bases de donnes relationnelles
et XML.
Internationalisation avec le support de lUnicode dans le code source : possibilit
dutiliser des caractres spciaux (autres que ASCII) dans le code source.
Utilisation gnralise dXML, notamment pour les interfaces graphiques (XUL,
XAML).
Langages massivement parallles
2000 - ActionScript
2001 - C#
2001 - Visual Basic .NET
2002 - F#
2003 - Groovy
2003 - Scala
2003 - Factor
2007 - Clojure
2009 - Go
2011 - Dart
14.4.8 Personnalits importantes dans lhistoire des langages de

programmation
John Backus, inventeur de Fortran.
John McCarthy, inventeur de LISP.
Alan Cooper, dveloppeur de Visual Basic.
Ole-Johan Dahl, co-crateur du langage Simula et de la programmation oriente objet.
Edsger Dijkstra, inventeur de lalgorithme de chemin le plus court qui porte son nom.
Il avait une aversion de linstruction GOTO en programmation et publia un article ce
sujet Go To Statement Considered Harmful en 1968. Inventeur du langage Algol.
James Gosling, dveloppeur de Oak, prcurseur de Java.
Tony (C.A.R.) Hoare, inventeur du QuickSort, de la logique de Hoare, du langage de
spcification CSP (qui a inspir le langage Occam) et de la notion de moniteur.
196
Grace Hopper conceptrice du premier compilateur en 1951 (A-0 System) et du langage

COBOL.
Anders Hejlsberg, dveloppeur de Turbo Pascal et C#.
Joseph-Marie Jacquard, inventeur de la programmation par carte perfore des mtiers
tisser.
Kenneth E. Iverson, dveloppeur de APL.
Donald Knuth, inventeur de TeX, et de nombreux travaux sur la complexit et lanalyse
syntaxique LR(k), la programmation lettre....
Alan Kay, prcurseur de la programmation oriente objet et lorigine de Smalltalk.
Brian Kernighan, co-auteur du premier livre sur le langage C avec Dennis Ritchie, coauteur des langages AWK et AMPL.
Leslie Lamport, LaTeX, algorithmes distribus.
Ada Lovelace, premire programmeuse au monde (a donn son prnom au langage ADA)
Yukihiro Matsumoto, crateur de Ruby.
Bertrand Meyer, inventeur de Eiffel.
Robin Milner, inventeur de ML, de LCF (le premier systme de dmonstration automatique de thormes) et le langage de spcification de processus concurrents CCS (calculus
of communicating systems) et son successeur, le pi-calcul.
John von Neumann, inventeur du concept de systme dexploitation.
Kristen Nygaard, co-crateur du langage Simula et de la programmation oriente objet.
Martin Odersky, crateur de Scala.
Dennis Ritchie, inventeur du langage C.
Guido van Rossum, crateur de Python.
Bjarne Stroustrup, dveloppeur de C++.
Ken Thompson, inventeur de Unix.
Larry Wall, crateur de Perl et Perl 6
Niklaus Wirth inventeur de Pascal et Modula.
197
198
CHAPTER
FIFTEEN
RGLES DE BONNES PRATIQUES

POUR ENCODER EN PYTHON
15.1 PEP
Les recommandations et amliorations pour le langage Python sont rpertories dans
des documents appels PEPs (Python Enhancement Proposals) sur le site officiel
https://www.python.org. Chaque PEP porte un numro. Le PEP 20 rsume les 20 aphorismes
(dont seulement 19 ont t rdigs) utiliss par Guido van Rossum, le BDFL (Benevolent Dictator for Life) Python pour concevoir le langage lui-mme.
Voici son contenu
15.1.1 PEP 20: The Zen of Python

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases arent special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one and preferably only one obvious way to do it.
Although that way may not be obvious at first unless youre Dutch.
199
Now is better than never.

Although never is often better than right now.
If the implementation is hard to explain, its a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea lets do more of those!
Note: Lors de vos sessions de codage Python, en cas de doute, vous pouvez faire
>>> import this
qui vous rappelera le contenu du PEP 20.

Le PEP 8 donne plus concrtement le style conseill pour coder en Python, cest--dire,
lensemble des conventions dcriture et de faon de structurer le code, non obligatoires pour
quun programme soit correct et efficace mais permettant den optimiser sa lisibilit et sa comprhension. PEP 8 recommande dutiliser un style de faon consistante cest--dire de
garder le mme style tout au long du code, sauf quand le respect de ce style nuit la lisibilit.
Warning: Rgle de bonne pratique
Suivre les recommandations faites dans PEP 8
Dans ce qui suit nous reprenons les recommandations qui nous semble les plus importantes.
15.2 Convention de codage

15.2.1 Indentation
La rgle simple est dajouter 4 caractres pour chaque nouvelle indentation. Ne pas utiliser de
tabulation.
15.2.2 Lignes de continuation

Les lignes doivent avoir moins de 79 caractres (72 pour les Doscstrings). Les blocs de texte
plus longs scrivent sur plusieurs lignes. Il se peut que le caractre de continuation
backslash ( \ ) soit ncessaire, mme si la plupart du temps il peut tre vit.
Note: Exemple o le backslash est ncessaire pour continuer le bloc sur plusieurs lignes
x = "ceci est un long texte" + \
"qui prend plus dune ligne"
200
Chapter 15. Rgles de bonnes pratiques pour encoder en Python
Warning: Bonnes pratiques

Par ordre de prfrence:
# Aligned with opening delimiter.
foo = long_function_name(var_one, var_two,
var_three, var_four)
# More indentation included to distinguish this from the rest.
def long_function_name(
var_one, var_two, var_three,
var_four):
print(var_one)
# Hanging indents should add a level.
foo = long_function_name(
var_one, var_two,
var_three, var_four)
Pour les listes:

my_list = [
1, 2, 3,
4, 5, 6,
]
result = some_function_that_takes_arguments(
a, b, c,
d, e, f,
)
15.2.3 Lignes blanches

On peut de faon parcimonieuse, mettre une ligne blanche pour sparer des groupes de fonctions qui ne sont pas logiquement lies ou pour mettre en vidence une nouvelle partie dans
une fonction.
15.2.4 Espaces
Pas despace juste aprs une parenthse ouvrante ou avant une parenthse fermante. espace
aprs une virgule.
15.2. Convention de codage
201

spam(ham[1], {eggs: 2})
if x == 4:
print(x, y)
x, y = y, x
spam(1)
dict[key] = list[index]
x = 1
y = 2
long_variable = 3
15.3 Rgles de bonnes pratiques pour concevoir un

programme
Nous avons rdig un document qui tient sur une page, et disponible ici, reprenant un ensemble
de recommandations que nous voulons donner au programmeur dbutant. Le texte de ce
document est repris ci-dessous.
15.3.1 Traduction dun problme en programme

Analysez le problme
Identifiez clairement ce que sont les donnes fournies, ainsi que les rsultats et types
attendus lissue du traitement.
Formalisez une dmarche gnrale de rsolution par une squence doprations simples.
Vrifiez que vous envisagez tous les cas de figures (en particuliers les cas limites).
Dcoupez votre problme en fonctions
Chaque fonction doit raliser une tche clairement identifie.
Limitez les fonctions 15 lignes maximum, sauf dans des cas exceptionnels.
Eviter la redondance dans le code (copier/coller). Si cela arrive, cest quil manque soit
une fonction, soit une boucle, soit que des tests conditionnels peuvent tre regroups.
Nutilisez pas de variables globales.
Veillez ce que tous les paramtres et variables dune fonction soient utiliss dans cette
fonction.
Pour une fonction qui renvoie un rsultat, organisez le code pour quil ne contienne
quun seul return, plac comme dernire instruction de la fonction.
202
Ne modifiez pas les paramtres. Exemple: si vous recevez une borne infrieure first et
une suprieure last et que vous devez itrer de la premire la dernire, nincrmentez
pas first dans la boucle, car la signification nen serait plus claire; crez plutt une variable locale pos initialise first.
Sauf si la fonction a comme but de modifier la (structure de) donnes reue en paramtre;
dans ce cas la fonction ne renvoie pas de valeur.
Testez le code au fur et mesure du dveloppement
Crez des scnarios de test, pour lesquels vous choisissez les donnes fournies et vous
vrifiez que le rsultat de la fonction est conforme ce que vous attendez.
Vrifiez les cas particuliers et les conditions aux limites. Exemple: pour le calcul dune
racine carre, que se passe-t-il lorsque le paramtre est un nombre ngatif?
15.3.2 Programmation
Style de programmation
Utilisez la forme raccourcie if(is_leap_year(2008)) plutt que la forme quivalente
if(is_leap_year(2008) == true)
Utilisez la forme return expression_bool plutt que la forme quivalente
if expression bool : # Code proscire !!
res = true
else:
res = false
return res
Nexcutez pas plusieurs fois une fonction alors quune excution suffit en retenant le
rsultat.
Prcisez le domaine de validit des paramtres et grez les erreurs ventuelles avec des
exceptions.
Nutiliser pas les exceptions pour faire des tests lis lalgorithme et non la gestion des
erreurs.
Quelques erreurs classiques
Vous essayez dutiliser une variable avant de lavoir initialise.
Lalignement des blocs de code nest pas respect.
Vous oubliez de fermer un fichier que vous avez ouvert.
15.3. Rgles de bonnes pratiques pour concevoir un programme
203
15.3.3 Nommage de variables, fonctions, etc.

Utilisez une convention de nommage
joined_lower pour les variables (attributs), et fonctions (mthodes)
ALL_CAPS pour les constantes
StudlyCaps pour les classes
Choisissez bien les noms
Donner des noms de variables qui expriment leur contenu, des noms de fonctions qui
expriment ce quelles font (cf. rgles de nommage ci-dessus).
Codez si possible en anglais.
vitez les noms trop proches les uns des autres.
Utilisez aussi systmatiquement que possible les mmes genres de noms de variables.
Exemples: i, j, k pour des indices, x, y, z pour les coordonnes, max_length pour une
variable, is_even() pour une fonction, etc.
15.3.4 Documentation du code

Soignez la clart de votre code
... cest la premire source de documentation.
Utilisez les docstrings dans chaque fonction pour : (1) brivement dcrire ce que fait
la fonction, pas comment elle le fait, et prciser ses entres et sorties, (2) dcrire les
arguments des fonctions.
Soignez les indentations (2 4 espaces chacune) et la gestion des espaces et des lignes
blanches.
Il faut commenter le code bon escient et avec parcimonie. vitez dindiquer le fonctionnement du code dans les commentaires. Exemples: Avant linstruction for car in line:,
ne pas indiquer quon va boucler sur tous les caractres de la line....
vitez de paraphraser le code. Nutilisez les commentaires que lorsque la fonction dun
bout de code est difficile comprendre.
15.3.5 Derniers conseils

Nhsitez pas consulter les manuels sur internet (et autres sources de documentation) pour
rsoudre vos problmes concrets.
204
CHAPTER
SIXTEEN
GLOSSAIRE
__main__ le module __main__ est le module par dfaut
algorithme squence dtapes prcises et non ambigus pouvant tre excutes de faon automatique
appel de fonction instruction qui excute une fonction. Elle consiste en le nom de la fonction
suivi par une liste darguments entre parenthses.
argument valeur fournie une fonction quand une fonction est appele. Cette valeur est
assigne au paramtre correspondant dans le corps fonction.
assignation instruction qui assigne une valeur une variable (variable = valeur)
boucle infinie une boucle dont la condition de fin nest jamais satisfaite.
bug une erreur dans un programme
chane vide chane sans caractre et de longueur 0, reprsente par deux apostrophes.
chemin chane de caractres qui identifie un fichier.
chemin absolu chemin qui commence au rpertoire du plus haut niveau du systme.
chemin relatif chemin qui commence depuis le rpertoire courant.
code source un programme crit en langage de haut niveau avant sa compilation ou son interprtation
commentaire information dans un programme destine au lecteur du code source et qui na
pas deffet sur lexcution du programme
compiler traduire un programme crit dans un langage de haut niveau en un langage de bas
niveau en une fois, en vue de sa future excution
concatner joindre bout bout des chanes de caractres
condition expression boolenne dans une instruction conditionnelle qui dtermine quelle
branche doit tre excute
conditions chanes instruction conditionnelle avec une srie de branches alternatives
conditions imbriques instruction conditionnelle qui apparat lintrieur dune autre instruction conditionnelle
205
constante valeur qui ne peut tre modifie, par opposition aux variables
corps dune fonction (body) squence dinstructions dans une dfinition de fonction.
deboguer le processus didentification et de correction des 3 types derreurs de programmation
dcrmenter mettre jour une variable en diminuant sa valeur (souvent de -1).
dfinition de fonction instruction qui cre une nouvelle fonction, spcifie son nom, ses
paramtres, et les instructions quelle doit excuter.
diagramme dtat reprsentation graphique dun ensemble de variables et des valeurs
quelles rfrent
dictionnaire squence mutable de paires clef-valeur.
division entire opration qui divise deux nombres entiers et retourne un entier (uniquement
la partie entire du rsultat)
docstring commentaire multiligne plac au dbut du corps dune fonction, destin sa documentation.
en-tte dune fonction (header) la premire ligne de la dfinition dune fonction (def, nom de
la fonction, liste darguments, caractre deux points).
erreur de syntaxe une violation des rgles dcriture dans un programme qui le rend impossible interprter ou compiler
erreur smantique une erreur dans un programme qui fait que quelque chose de diffrent de
ce que le programmeur voulait raliser se produit
exception une erreur dtecte pendant lexcution du programme
excutable un programme aprs compilation, prt tre excut
expression combinaison de variables, doprateurs et de valeurs et dont le rsultat est une
valeur
expression boolenne expression qui retourne soit vrai (True), soit faux ( False)
lment (item) une des valeurs dune squence.
valuer simplifier une expression en appliquant les oprations dans le but dobtenir la valeur
rsultat
fichier texte squence de caractres stocke dans un support permanent (disque dur, CDROM, etc.).
flot dexcution ordre dans lequel les instructions sont excutes dans un programme.
fonction squence dinstructions qui possde un nom. Les fonctions peuvent prendre des
arguments (ou pas) et peuvent retourner une valeur (ou pas : retourne None).
hachable proprt dun type immuable lui permettant dtre converti de manire dterministe
en un nombre entier.
immuable proprit dune squence dont les lments ne peuvent tre assigns.
206
Chapter 16. Glossaire
import instruction qui lit un module et cre un objet module.

incrmenter mettre jour une variable en augmentant sa valeur (souvent de 1).
instruction morceau du code qui reprsente une commande ou une action
instruction conditionnelle instruction qui contrle le flot dexcution en fonction de certaines
conditions
interprter excuter un programme crit dans un langage de haut niveau en le traduisant pas
pas
introspection capacit dun programme examiner son propre tat
introspection particularit du langage Python qui lui permet de sauto-explorer.
itration (ou boucle) excution rpte dun ensemble dinstructions.
lancer (une exception) on lance une exception quand quelque chose dexceptionnel se produit, via linstruction raise.
langage de bas niveau un langage excutable par un ordinateur (aussi appel langage machine ou assembleur)
langage de haut niveau un langage comme Python facile lire et crire pour lhumain
langage impratif langage (de programmation) o un programme est form explicitement
dinstructions que lordinateur doit excuter tape par tape. Il est bas sur le principe de
la machine de Von Neumann.
littral constante dont la reprsentation est donne explicitement (exemple: 3 3.14,
bonjour)
mthode fonction qui est associe un objet et qui est invoque en utilisant la notation point.
mode interactif une manire dutiliser Python en tapant les instructions via le prompt
mode script une manire dutiliser Python en lisant les instructions depuis un fichier
module fichier qui contient une collections de fonctions et dautres dfinitions.
mot-cl mot reserv et utilis par le langage Python pour parser un programme; on ne peut
pas utiliser les mots-clef comme nom de variables
notation point (dot notation) syntaxe pour appeler une fonction ou utiliser une variable dfinie
dans un module en spcifiant le nom du module suivi dun point, et du nom de la fonction
ou de la variable. Permet galement daccder aux attributs dun objet fonction ou dun
objet module.
objet quelque chose quune variable peut rfrer. Pour le moment, un objet est une valeur qui
possde des attributs et des mthodes.
objet fonction valeur cre par la dfinition dune fonction. Le nom de la fonction est une
variable qui rfre un objet fonction.
objet module valeur cre par une instruction import et qui fournit un accs aux valeurs et
fonctions dfinies dans le module.
oprande une des valeurs sur lesquelles un oprateur sapplique
207
oprateur symbole spcial qui reprsente une opration simple comme laddition, la multiplication ou la concatnation de chanes de caractres
oprateur de comparaison un des oprateurs qui comparent ses oprandes : ==, !=, <, >, <=
et >=.
oprateur logique un des oprateurs qui combinent des expressions boolennes : and, or et
not.
paramtre variable utilise lintrieur dune fonction qui rfre la valeur passe en argument.
parser examiner un programme et analyser sa structure syntaxique
portabilit le fait quun programme puisse tre excut sur plus dune sorte dordinateurs
porte (scope) la porte dune variable est la zone du programme dans laquelle elle est
disponible. La porte dune variable locale ou dun paramtre est limite sa fonction.
postcondition condition quun code ou une fonction garantit si lensemble des prconditions
sont respectes (= la validit de son rsultat)
prcondition condition que le code ou la fonction suppose vraie pour les entres, avant
dexcuter son travail
print instruction qui ordonne linterprteur Python dafficher une valeur lcran
programme squence dinstructions crites dans un langage de programmation particulier et
qui spcifie comment raliser un calcul ou une tche
prompt les caractres >>> qui indiquent que linterprteur est prt recevoir des instructions
rattraper (une exception) on rattrape une exception dans une clause except, pour y excuter du code spcifique.
rgles de prcdence ensemble de rgles dfinissant lordre dans lequel les expressions impliquant plusieurs oprateurs et oprandes sont values
rpertoire (dossier) un rpertoire possde son propre nom et contient une collection de
fichiers ou dautres rpertoires.
rsolution de problme processus de formulation dun problme (spcification), trouver une
solution et exprimer la solution
script un programme stock dans un fichier (en vue dtre interprt)
smantique la signification (la logique, le sens) dun programme
squence ensemble ordonn, cest--dire un ensemble de valeurs o chaque valeur est identifie par un index entier.
syntaxe la structure et les rgles dun langage de programmation
traceback liste de fonctions qui sont exctues, affiches quand une exception se produit.
tranche (slice) partie dune chane spcifie par un intervalle dindice s.
type classe de valeurs (exemple: entiers (int), rels (float), chanes de caractres (str))
208
valeur unit lmentaire de donnes, comme un nombre ou une chane de caractres, quun
programme manipule
valeur de retour le rsultat dune fonction. Si un appel de fonction est utilis comme une
expression, sa valeur de retour est la valeur de lexpression.
variable nom qui rfre une valeur
variable locale variable dfinie lintrieur dune fonction. Une variable locale ne peut tre
utilise qu lintrieur de sa fonction.
209
210
CHAPTER
SEVENTEEN
AIDE-MMOIRE PYTHON 3.2 (VERSION OCTOBRE 2012)
17.1 Fonctions
int(x) : convertit x, de type float ou str, en entier
float(x) : convertit x, int ou str, en rel
str(x) : convertit x, int ou float, en str
list(x) : convertit x en list
tuple(x) : convertit x en tuple
help(x) : aide sur x
dir(x) : liste des attributs de x
type(x) : type de x
print ... : imprime
input(x) : imprime le string x et lit le string qui est introduit au clavier
round(x) : valeur arrondie du float x
len(s) : longueur de la squence s
range([start], stop, [step]) : retourne une suite arithmtique dentiers
17.2 Modules
math : accs aux constantes et fonctions mathmatique (pi, sin(), sqrt(x), exp(x),floor(x)
(valeur plancher), ceil(x) (valeur plafond), ...) : exemple: math.ceil(x)
211
copy: copy(s), deepcopy(s): shallow et deepcopy de s

pickle:
dumps(v) : transforme v en une reprsentation,
loads(r) : reconstitue lobjet
dump(v,f) : transforme et crit dans le fichier f
load(f) : reconstitue partir de la reprsentation lue de f
shelve
db = open() : crer un fichier comme objet de type shelve
db.close() : fermeture
17.3 Oprations et mthodes sur les squences (str,

list, tuples)
min(s),max(s): lment minimum, maximum
sum(s): (ne fonctionne pas pour les string): somme de tous les lments (valeur
numrique)
s.index(value, [start, [stop]]) : premier indice de value dans s[start:stop]
s.count(sub [,start [,end]]) : le nombre doccurrences sans chevauchement de sub dans
s[start:end]
map(f,s) : crer une liste o chaque lment i de s est remplac par f(i)
filter(f,s) : crer une squence du mme type que s avec les lments i de s tel que f(i) ou
i.f() est vrai
reduce(f,s) : applique f() deux deux aux lments conscutifs de s (de gauche droite)
et renvoie le rsultat
17.4 Mthodes sur les str

s.lower() : string avec caractres en minuscule
s.upper() : string avec caractres en majuscule
s.islower(), s.isdigit(), s.isalnum(),s.isalpha(), s.isupper(): vrai si dans s on a (respectivement) des minuscules, des chiffres, des car. alphanumriques, alphabtiques, majuscules
s.find(sub [,start [,end]]) : premier indice de s o le sous string sub est trouv dans
s[start:end]
s.replace( old, new[, co]) : retourne une copie de s en remplaant toutes les (ou les co
premires) occurrences de old par new.
212
Chapter 17. Aide-mmoire Python 3.2 - (version Octobre 2012)
s.format(...) : sert au formatage (en particulier) doutput

s.capitalize() : met la premire lettre en majuscule
s.strip() : copie de s en retirant les blancs en dbut et fin
s.join(t) : crer un str qui est le rsultat de la concatnation des lments de t chacun
spar par le str s
s.split([sep [,maxsplit]) : renvoie une liste dlments spars dans s par le caractre sep
(par dfaut blanc); au max maxsplit sparations sont faites
17.5 Oprateurs et mthodes sur les listes s

s.append(v) : ajoute un lment valant v la fin de la liste
s.extend(s2) : rajoute s tous les lments de la liste s2
s.insert(i,v) : insert lobjet v lindice i
s.pop() : supprime le dernier lment de la liste et retourne llment supprim
s.remove(v) : supprime la premire valeur v dans s
s.reverse() : retourne la liste, le premier et dernier lment change leurs places, le second
et lavant dernier, et ainsi de suite
s.sort(cmp=None, key=None, reverse=False) : trie s
del s[i], del s[i:j] : supprime un ou des lments de s
zip (a,b,c): construit une liste de des triples dont le ime lment reprend le ime lment
de chaque squence a,b,c
it=iter(s) : cr un itrateur
it.next() : lment suivant de litrateur sil existe, exception StopIteration sinon
17.6 Mthodes sur les dict

d.clear() : supprime tous les lments de d
d.copy() : shallow copie de d
{}.fromkeys(s,v) : cre un dict avec les cls de s et valeur v
d.get(k [,v]) : renvoie la valeur d[k] si elle existe v sinon
d.items() : liste des items (k,v) de d
d.keys() : liste des cls
d.pop(k [,v]) : enlve d[k] et renvoie sa valeur ou v
d.popitem() : supprimer un item (k,v) et retourne litem sous forme de tuple
17.5. Oprateurs et mthodes sur les listes s
213
d.setdefault(k [,v]) : d[k] si elle existe sinon v et rajoute d[k]=v

d.update(s) : s est une liste de tuples que lon rajoute d
d.values() : liste des valeurs de d
17.7 Mthodes sur les fichiers

f=open(fichier) : ouvre fichier en lecture
f=open(fichier,w) : ouvre fichier en criture
f=open(fichier,a) : ouvre fichier en criture en rajoutant aprs les donnes dj
prsentes
f.read() : retourne le contenu du fichier f
f.readline() : lit une ligne
f.readlines() : renvoie la liste des lignes de f
f.write(s) : crit la chane de caractres s dans le fichier f
f.close() : ferme f
17.8 Exceptions
try:
...
raise ...
...
except:
...
else:
...
finally:
...
214
Chapter 17. Aide-mmoire Python 3.2 - (version Octobre 2012)
INDEX
Symbols
lment, 206
valuer, 206
__main__, 205
en-tte dune fonction, 206

erreur de syntaxe, 206
erreur smantique, 206
excutable, 206
exception, 206
expression, 206
expression boolenne, 206
A
algorithme, 205
appel de fonction, 205
argument, 205
assignation, 205
B
boucle infinie, 205
bug, 205
C
chane vide, 205
chemin, 205
chemin absolu, 205
chemin relatif, 205
code source, 205
commentaire, 205
compiler, 205
concatner, 205
condition, 205
conditions chanes, 205
conditions imbriques, 205
constante, 206
corps dune fonction, 206
D
dcrmenter, 206
dfinition de fonction, 206
deboguer, 206
diagramme dtat, 206
dictionnaire, 206
division entire, 206
docstring, 206
F
fichier texte, 206
flot dexcution, 206
fonction, 206
H
hachable, 206
I
immuable, 206
import, 207
incrmenter, 207
instruction, 207
instruction conditionnelle, 207
interprter, 207
introspection, 207
itration, 207
L
lancer (une exception), 207
langage de bas niveau, 207
langage de haut niveau, 207
langage impratif, 207
littral, 207
M
mthode, 207
mode interactif, 207
mode script, 207
215
module, 207
mot-cl, 207
N
notation point, 207
O
objet, 207
objet fonction, 207
objet module, 207
oprande, 207
oprateur, 208
oprateur de comparaison, 208
oprateur logique, 208
P
paramtre, 208
parser, 208
porte, 208
portabilit, 208
postcondition, 208
prcondition, 208
print, 208
programme, 208
prompt, 208
R
rpertoire, 208
rsolution de problme, 208
rgles de prcdence, 208
rattraper (une exception), 208
S
smantique, 208
squence, 208
script, 208
syntaxe, 208
T
traceback, 208
tranche, 208
type, 208
V
valeur, 209
valeur de retour, 209
variable, 209
variable locale, 209
216
Index

Programmation Python

Transféré par

Droits d'auteur :

Formats disponibles

Programmation Python

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Programmation Python

Transféré par

Droits d'auteur :

Formats disponibles

Syllabus INFO-F-101 Programmation Release 3.4.

August 21, 2015

Mon premier programme Python

Contrle de flux (instructions if et while)

Dfinition de nouvelles fonctions

Passage de fonction comme argument et fonction lambda . . . . . . . . . . . 32

Chanes de caractres (strings), tuples, listes et instruction for

Conception dalgorithmes simples

Notion de complexit et grand O

10 Logique, invariant et vrification dalgorithme

12 Fichiers, persistance et Exceptions

15 Rgles de bonnes pratiques pour encoder en Python

1.2 But du cours

Syllabus INFO-F-101 Programmation -, Release 3.4.0 (2015)

1.3 Comptences principales vises

Chapter 1. Prsentation du cours

Syllabus INFO-F-101 Programmation -, Release 3.4.0 (2015)

1.5 Pourquoi Python ? (et pas C++, Java, ...)

1.6 Un peu de vocabulaire

Syllabus INFO-F-101 Programmation -, Release 3.4.0 (2015)

Chapter 1. Prsentation du cours

MON PREMIER PROGRAMME

2.1 Notions fondamentales

2.2 Python pour faire des calculs

Syllabus INFO-F-101 Programmation -, Release 3.4.0 (2015)

Chapter 2. Mon premier programme Python

Syllabus INFO-F-101 Programmation -, Release 3.4.0 (2015)

2.3 Erreur syntaxique

2.4 Python pour manipuler du texte

2.3. Erreur syntaxique

Syllabus INFO-F-101 Programmation -, Release 3.4.0 (2015)

2.5 Variables et assignation

Le programmeur utilise 3 variables quil a nommes x, y et z. Chaque variable est une

Chapter 2. Mon premier programme Python

Syllabus INFO-F-101 Programmation -, Release 3.4.0 (2015)

Syllabus INFO-F-101 Programmation -, Release 3.4.0 (2015)

litpc30:Exemples-cours tmassart$ python3 mon-premier-programme-corr.py

Chapter 2. Mon premier programme Python

Syllabus INFO-F-101 Programmation -, Release 3.4.0 (2015)

Syllabus INFO-F-101 Programmation -, Release 3.4.0 (2015)

2.10 Assignation multiple et assignation de tuples

On peut aussi faire des assignations parallles

2.11 Autres fonctions prdfinies intressantes

Chapter 2. Mon premier programme Python

Syllabus INFO-F-101 Programmation -, Release 3.4.0 (2015)

Voir dfinition dans le manuel du Python Standard Library du site python.org

2.12 Mon premier programme complet

__author__ et __ date__ sont des variables classiquement utilises pour identifier

2.12.1 Module math

2.12. Mon premier programme complet

Syllabus INFO-F-101 Programmation -, Release 3.4.0 (2015)

2.13 Smantique prcise de lassignation

Chapter 2. Mon premier programme Python

Syllabus INFO-F-101 Programmation -, Release 3.4.0 (2015)

les instructions x = 3 et y = 12 crent 2 variables qui rfrencient respectivement un objet

2.13. Smantique prcise de lassignation

Syllabus INFO-F-101 Programmation -, Release 3.4.0 (2015)

et implique la cration de 2 objets de type (classe) int : lun valant 3 et lautre 4 .

Chapter 2. Mon premier programme Python

author et date sont des variables classiquement utilises pour identifier