Vous êtes sur la page 1sur 185

Lyce Louis-Le-Grand, Paris

Cours dinformatique commune


MPSI 4

Alain TROESCH

Version du:
21 octobre 2016

Table des matires

1 Les bases de la programmation en Python


I
Python dans le paysage informatique . . . . . . . .
II
Les variables . . . . . . . . . . . . . . . . . . . . .
II.1
Affectation . . . . . . . . . . . . . . . . . .
II.2
Affichage . . . . . . . . . . . . . . . . . . .
II.3
Type et identifiant . . . . . . . . . . . . . .
III Objets et mthodes . . . . . . . . . . . . . . . . . .
III.1 Les nombres . . . . . . . . . . . . . . . . . .
III.2 Les boolens et les tests . . . . . . . . . . .
III.3 Les listes . . . . . . . . . . . . . . . . . . .
III.4 Les ensembles . . . . . . . . . . . . . . . . .
III.5 Les tuples . . . . . . . . . . . . . . . . . . .
III.6 Les dictionnaires (HP) . . . . . . . . . . . .
III.7 Les chanes de caractres . . . . . . . . . .
III.8 Les itrateurs . . . . . . . . . . . . . . . . .
III.9 Conversions de types . . . . . . . . . . . . .
IV Structuration dun programme . . . . . . . . . . .
IV.1 Notion de programme . . . . . . . . . . . .
IV.2 Les fonctions . . . . . . . . . . . . . . . . .
IV.3 Les structures conditionnelles . . . . . . . .
IV.4 Les structures itratives . . . . . . . . . . .
IV.5 La gestion des exceptions . . . . . . . . . .
V
Modules complmentaires . . . . . . . . . . . . . .
V.1
Utilisation dun module . . . . . . . . . . .
V.2
Le module math . . . . . . . . . . . . . . .
V.3
Le module numpy (calcul numrique) . . . .
V.4
Le module scipy (calcul scientifique) . . .
V.5
Le module matplotlib (trac de courbes) .
V.6
Autres modules (random, time, sqlite3,...)
VI Lecture et criture de fichiers . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

5
5
7
7
7
8
8
9
9
10
12
13
13
15
16
17
18
18
20
21
22
23
26
26
27
27
29
29
30
31

2 Matriel et logiciels
I
lments darchitecture dun ordinateur . . . . . . . . . . . . . . . . . . . . . . . . . . . .
I.1
Modle de Von Neumann . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
I.2
Mmoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

33
33
33
36

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

Table des matires


.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

38
41
41
44
45
48
50
52
52
53
54
55
59
59
61
61
63
63
63
64
64

3 Variables informatiques
I
Notion de variable informatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
II
Structures de donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
III Mutabilit ; cas des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

67
67
69
73

4 Algorithmique lmentaire
I
Algorithmes . . . . . . . . . . . . . . . . .
I.1
Dfinition . . . . . . . . . . . . . .
I.2
Le langage . . . . . . . . . . . . .
I.3
Les structures lmentaires . . . .
I.4
Procdures, fonctions et rcursivit
II
Validit dun algorithme . . . . . . . . . .
II.1
Terminaison dun algorithme . . .
II.2
Correction dun algorithme . . . .
III Exercices . . . . . . . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.

79
79
79
80
80
84
86
86
89
92

.
.
.
.
.
.
.
.
.
.
.
.
.

95
95
96
96
98
99
100
100
102
102
103
104
104
104

II

III

IV

I.3
Le processeur (CPU, Central Process Unit) . . . . . .
Codages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
II.1
Bases de numration . . . . . . . . . . . . . . . . . . .
II.2
Codage des entiers . . . . . . . . . . . . . . . . . . . .
II.3
Dveloppement en base b dun rel . . . . . . . . . . .
II.4
Codage des rels (norme IEEE 754) . . . . . . . . . .
II.5
Problmes lis la reprsentation non exacte des rels
Circuits logiques . . . . . . . . . . . . . . . . . . . . . . . . .
III.1 Portes logiques . . . . . . . . . . . . . . . . . . . . . .
III.2 Un exemple dvelopp : laddition sur n bits . . . . .
III.3 Dcodeurs dadresse . . . . . . . . . . . . . . . . . . .
III.4 Circuits bascules et mmoires . . . . . . . . . . . . . .
Systmes dexploitation . . . . . . . . . . . . . . . . . . . . .
IV.1 Quest-ce quun systme dexploitation ? . . . . . . . .
IV.2 Arborescence des fichiers . . . . . . . . . . . . . . . . .
IV.3 Droits daccs . . . . . . . . . . . . . . . . . . . . . . .
Langages de programmation . . . . . . . . . . . . . . . . . . .
V.1
Quest-ce quun langage de programmation ? . . . . .
V.2
Niveau de langage . . . . . . . . . . . . . . . . . . . .
V.3
Interprtation et compilation . . . . . . . . . . . . . .
V.4
Paradigmes de programmation . . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

5 Complexit
I
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . .
II
Complexit en temps (modle cots fixes) . . . . . . . . .
II.1
Premire approche . . . . . . . . . . . . . . . . . . .
II.2
Simplification du calcul de la complexit . . . . . . .
II.3
Amlioration de la complexit de lexemple donn .
III Complexit dans le meilleur ou le pire des cas, en moyenne
III.1 Complexit dans le meilleur et le pire des cas . . . .
III.2 Complexit en moyenne . . . . . . . . . . . . . . . .
III.3 Algorithmes randomiss . . . . . . . . . . . . . . . .
IV Limitations du modle cots fixes . . . . . . . . . . . . . .
V
Complexit en mmoire, ou en espace . . . . . . . . . . . .
VI tude de quelques algorithmes de recherche . . . . . . . . .
VI.1 Recherche du maximum dune liste . . . . . . . . . .

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.

Table des matires


VI.2
VI.3
VI.4

Recherche dun lment dans une liste . . . . . . . . . . . . . . . . . . . . . . . . . 105


Recherche dans une liste trie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
Autres algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

6 Calculs dintgrales
I
La mthode des rectangles . . . . .
II
La mthode des trapzes . . . . . .
III La mthode de Simpson (HP) . . .
IV La mthode de Monte-Carlo (HP)

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

109
110
113
114
115

7 Rsolution numrique dquations


I
Dichotomie . . . . . . . . . . . . . . . . . . .
II
Mthode de la scante (HP) . . . . . . . . . .
III Mthode de Newton . . . . . . . . . . . . . .
IV Le problme de la drivation numrique (HP)

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

117
117
119
122
124

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

8 Rsolution numrique dquations diffrentielles


I
Mthode dEuler . . . . . . . . . . . . . . . . . . .
II
Notion dordre dune mthode . . . . . . . . . . . .
III quations diffrentielles dordre suprieur . . . . .
IV Mthode de Runge-Kutta, HP . . . . . . . . . . . .

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

127
128
130
132
133

9 Rsolution numrique de systmes linaires


I
Structures de donnes adaptes en Python . .
II
Rappels sur la mthode du pivot de Gauss . .
III Dcomposition LU . . . . . . . . . . . . . . .
IV Problmes de conditionnement . . . . . . . .

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

139
139
143
145
147

10 Bases de donnes relationnelles


I
Environnement client / serveur . . .
I.1
Le serveur informatique . . .
I.2
Le client . . . . . . . . . . . .
I.3
Architecture 3-tiers . . . . . .
II
Bases de donnes . . . . . . . . . . .
II.1
Prsentation intuitive . . . .
II.2
Dpendances et redondances
III Algbre relationnelle . . . . . . . . .
III.1 Schma relationnel et relation
III.2 Cls . . . . . . . . . . . . . .
III.3 Schma de base de donne . .
IV Exercices . . . . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.

149
149
149
151
151
152
152
159
161
161
163
165
166

11 SQL : Cration dune BDD et requtes


I
Cration dune base de donnes . . . . .
I.1
Cration des tables . . . . . . . .
I.2
Entre des donnes . . . . . . . .
II
Interrogation dune BDD (Requtes) . .
II.1
Requtes simples . . . . . . . . .
II.2
Sous-requtes . . . . . . . . . . .
II.3
Constructions ensemblistes . . .
II.4
Jointure . . . . . . . . . . . . . .
II.5
Algbre relationnelle . . . . . . .

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

167
168
168
169
170
171
177
179
180
182

.
.
.
.
.
.
.
.
.
.
.
.

Table des matires

1
Les bases de la programmation en
Python
Ce chapitre nest pas un chapitre dapprentissage du Python (pour cela, se reporter au tutoriel en ligne
sur le site https://docs.python.org/3/tutorial/index.html, rfrence absolue en la matire). Il nest
pas destin tre dispens en cours, mais est plutt voir comme un aide-mmoire auquel se reporter
tout au long de lanne pour les fonctionnalits les plus frquemment utilises de Python. Bien sr, on ne
peut pas tre exhaustif, et laide en ligne, ainsi que le tutoriel, restent les rfrences privilgies pour aller
au-del de ce qui est expos dans ce chapitre. Certains aspects voqus dans ce chapitre seront dvelopps
dans les chapitres suivants.
En revenant la page principale du site sus-cit https://www.python.org/, vous trouverez galement
diffrentes distributions de Python tlcharger et installer sur vos ordinateurs personnels (plus que
conseill !), notamment pour Windows ou MacOS. Pour une distibution Linux, renseignez-vous sur les forums ; il y a moyen de linstaller avec les moteurs dinstallation (yum install pour Fedora par exemple).
Sur certains systmes, Python est install par dfaut (vrifier dans ce cas la version). Il existe des diffrentes notables entre les versions 2 et 3, les rendant incompatibles. Nous utiliserons la version 3 en TP.
Choisissez donc la version 3 la plus rcente.
Il peut galement tre utilise de tlcharger un environnement de programmation (essentiellement un
programme incluant dans un mme environnement graphique un diteur de code et un interprteur
permettant de taper des instructions en ligne, et de visualiser les rsultats de vos programmes). Certains
environnements sont gnralistes (prvus pour la programmation dans plusieurs langages diffrents),
comme Eclipse ; dautres sont plus spcifiques Python, comme IDLE, conu par le concepteur de Python,
ou Pyzo, que nous utiliserons en TP. Ce dernier est donc privilgier sur vos ordinateurs personnels , afin
de vous habituer. IDLE est plus minimaliste, pour ceux qui prfre la sobrit. Certains environnements
viennent avec une distribution prcise de Python (quil nest dans ce cas pas ncessaire dinstaller avant).
On peut aussi utiliser un diteur de texte standard, comme emacs, puis lancer Python sur le fichier en
ligne de commande. La plupart des diteurs reconnaissent le langage Python et proposent une coloration
syntaxique, mais ils ne disposent pas en revanche des aides syntaxiques lorsquon tape le nom dune
fonction.

Python dans le paysage informatique

Les concepts voqus dans cette mise en contexte seront expliqus un peu plus dans le chapitre suivant.

CHAPITRE 1. LES BASES DE LA PROGRAMMATION EN PYTHON


Python est un langage hybride, adapt la programmation imprative, tout en utilisant certaines
facilits de la programmation objet, au travers de mthodes, applicables des objets dun certain
type (on parle de classe). Il existe la possibilit de crer de nouvelles classes dobjets, et dy dfinir
des mthodes. Nous nexplorerons pas ces possibilits cette anne, mme sil sagit dun point de
vue trs important.
Python est un langage de haut niveau. Il gre tout le ct matriel sans que le programmeur ait
sen proccuper. La seule tche du programmeur est laspect purement algorithmique. Le haut
niveau se traduit aussi par la possibilit dutiliser des mthodes labores sur les objets (recherche
dlments dans une liste, tri, etc), et dimporter des modules complmentaires spcialiss suivant les besoins, dans lesquels sont dfinies des fonctions complexes (calcul matriciel, rsolution
dquations diffrentielles, rsolution de systmes linaires, mthode de Newton...). Les mthodes
et fonctions ainsi dfinies cachent une grande partie de la technique au programmeur, qui na donc
qu se proccuper de lessentiel. Lavantage est une facilit de programmation, et une utilisation
de mthodes le plus souvent optimises (plus efficaces en gnral que ce que peut esprer faire un
programmeur dbutant). Linconvnient est une connaissance beaucoup plus floue de la complexit
des algorithmes crits. Par ailleurs, ces fonctions et mthodes, ainsi que la gestion du matriel,
sont optimiss pour la situation la plus gnrale possible, mais pas pour les situations particulires.
Cest pour cela quun programme en langage de plus bas niveau (en C par exemple) est souvent
plus efficace, sil est bien conu, quun programme en Python. Pour cette raison, il est frquent
en entreprise dutiliser Python comme langage de prototypage, puis de traduire en C pour plus
defficacit, une fois que lalgorithmique est en place. Cela permet de scinder lcriture du code en 2
phases, la phase algorithmique, et la phase programmation. De la sorte, il est possible dutiliser du
personnel plus spcialis (des concepteurs dalgorithmes dune part, et des programmeurs dautre
part, plus au fait du fonctionnement-mme de lordinateur)
Python est un langage semi-compil. Il ne ncessite pas une compilation spcifique avant lancement.
Il est compil sur le tas, lexcution, de sorte reprer certaines erreurs de syntaxe avant le
lancement-mme du programme, mais il ne ressort pas de fichier compil utilisable directement.
Lavantage est une certaine souplesse lie la possibilit dutiliser Python en ligne de commande
(nexcuter quune seule instruction dans un shell) : on peut ainsi tester certaines fonctions avant
de les utiliser dans un programme, ce qui est parfois assez pratique. Linconvnient est une lenteur
dexcution du programme dfinitif, puisquil faut le compiler chaque utilisation : un langage
compil peut directement tre excut partir du code compil, en assembleur, proche du langage
machine, et est donc plus rapide lexcution. Cest une autre raison pour que Python servent plus
au prototypage qu la finalisation, notamment pour tous les dispositifs ncessitant une ractivit
assez importante (tlphones...)
Contrairement beaucoup de langages, Python est un langage dans lequel la prsentation est un
lment de syntaxe : les dlimitations des blocs dinstructions se font par indentation (en pratique
de 4 caractres), contrairement de nombreux autres langages qui utilisent des dbuts et fins de
blocs du type begin et end. Ces indentations sont donc ici faire de faon trs rigoureuses pour
une correction du programme. Une mauvaise indentation peut amener une erreur de compilation,
voire un mauvais rsultat (ce qui est plus dur dtecter). Lavantage est une plus grande clart
(impose) du code par une dlimitation trs visuelle des blocs (mme si cette indentation est de
fait trs fortement conseille dans les autres langages, mais de nombreux programmeurs dbutants
la ngligent).

Une fonction essentielle, et inclassable, est la fonction daide, que vous pouvez appliquer la plupart des
noms dobjets, de modules, de fonctions :
help()

# ouverture de la page daide de lobjet spcifi

Par exemple help(print) renvoie la page daide sur la fonction print() ralisant laffichage dune chaine
de caractres.

II

Les variables

II

Les variables

En Python , les variables bnficient dun typage dynamique : le type est dtect automatiquement lors
de la cration de la variable par affectation. Il nest donc pas ncessaire de dclarer la variable avant de
lutiliser (comme dans la plupart des autres langages).

II.1

Affectation

Laffectation est laction consistant donner une valeur une variable.


a = 2

# affectation

Laffectation dune valeur une variable se fait avec lgalit. La ligne ci-dessus donne la valeur 2 la
variable a, ceci jusqu la prochaine modification.
Une affectation peut prendre en argument le rsultat dune opration :
a = 2 + 4
Ce calcul peut mme utiliser la variable a elle-mme :
a = a + 4*a*a
Dans ce cas, le calcul du membre de droite est effectu dabord, et ensuite seulement laffectation. Ainsi,
le calcul est effectu avec lancienne valeur de a. Il faut en particulier quune valeur ait dj t attribue
a. Par exemple, si a a initialement la valeur 2, la ligne ci-dessus attribue la valeur 18 a.
Il existe des raccourcis pour certaines oprations de ce type :
Affectations avec opration:
a += 2
# quivaut a = a + 2
a -= 1
# quivaut a = a - 1
a *= 3
# quivaut a = a * 3
a /= 2
# quivaut a = a / 2 (division relle)
a //= 2 # quivaut a = a // 2 (division entire)
a %= 3
# quivaut a = a % 3 (reste modulo 3)
a **= 4 # quivaut a = a ** 4 (puissance)
etc.

II.2

Affichage

En ligne de commande, il suffit de taper le nom de la variable aprs linvite de commande :


>>> a = 2
>>> a
2
Faire un affichage du contenu dune variable lors de lexcution dun programme ncessite la fonction
print(), qui affiche une chaine de caractre. On peut aussi lutiliser en ligne de commande
>>> print(a)
2
Cette fonction ralise une conversion automatique pralable du contenu de la variable en chane de
caractres, car la fonction print() prend toujours en argument une chane de caractres (voir section
chanes de caractres ).

II.3

CHAPITRE 1. LES BASES DE LA PROGRAMMATION EN PYTHON

Type et identifiant

Chaque variable possde un identifiant (ladresse mmoire associe), et un type (la nature de lobjet
stock dans la variable). Lidentifiant change chaque raffectation, le type peut changer lui-aussi. Les
mthodes associes un objet peuvent le modifier sans changement didentifiant.
type(a)
id(a)

# affiche le type (la classe) de la variable ou de lobjet


# affiche lidentifiant (ladresse en mmoire)

Les principaux types (hors modules complmentaires) :


int
float
complex
bool
list
set
tuple
str
function

#
#
#
#
#
#
#
#
#

Entiers, de longueur non borne


Flottants (rels, en norme IEEE 754 sur 64 bits, voir chapitre 1)
Nombres complexes
Boolens (True / False)
Listes
Ensembles
$n$-uplets
Chanes de caractres (string)
Fonctions

Par exemple :
>>> type(87877654)
<class int>
>>> type(1.22)
<class float>
>>> type(True)
<class bool>
>>> type([1,2])
<class list>
>>> type({1,2})
<class set>
>>> type(abc)
<class str>
>>> type(lambda x:x*x)
<class function>
Dautres types plus complexes peuvent tre rattachs un type donn, comme les itrateurs de liste
(objet permettant dnumrer les uns aprs les autres les lments dune liste, ce qui permet dappliquer
la liste une boucle for.
Nous rencontrerons dautres types dans des modules spcifiques, en particulier les type array et matrix
du module numpy, pour les tableaux et les matrices.

III

Objets et mthodes

Python utilise certains concepts de la programmation objet, notamment travers la possibilit de modifier
un objet en lui appliquant une mthode. Pour lister lensemble des mthodes associes une classe dobjets
nomme cl :
help(cl)

# aide associe la classe cl, en particulier, description des


# mthodes dfinies sur les objets de cette classe

III

Objets et mthodes

III.1

Les nombres

Trois classes essentiellement (entiers, flottants, complexes).


Les complexes scrivent sous la forme a + bj. Le rel b doit tre spcifi, mme si b = 1, et accol la
lettre j. Par exemple 1+1j dsigne le complexe 1 + i.
Oprations sur les nombres:
x + y
# somme de deux entiers, rels ou complexes
x * y
# produit de deux entiers, rels ou complexes
x - y
# diffrence de deux entiers, rels ou complexes
x / y
# division de rels (retourne un objet de type float mme si
# le rsultat thorique est un entier; peut tre appliqu
# des entiers, qui sont alors convertis en flottants
x // y
# division entire (quotient de la division euclidienne)
# sapplique des entiers ou des rels. Appliqu des
# entier, retourne un int, sinon un float
x % y
# modulo (reste de la division euclidienne)
# sapplique des entiers ou rels.
divmod(x)
# renvoie le couple (x // y, x % y)
# permet de faire les deux calculs en utilisant une seule
# fois lalgorithme de la division euclidienne.
x ** y
# x puissance y
abs(x)
# valeur absolue
int(x)
# partie entire de lcriture dcimale (ne correspond pas
# la partie entire mathmatique si x < 0:
# par exemple int(-2.2)=-2.
x.conjugate() # retourne le conjugu du nombre complexe x
x.real
# partie relle
x.imag
# partie imaginaire

III.2

Les boolens et les tests

Les deux lments de la classe des boolens sont True et False (avec les majuscules).
Oprations sur les
x.__and__(y) ou
x.__or__(y)
ou
x.__xor__(y) ou

boolens:
x & y
ou
x | y
ou
x ^ y

x and y
x or y
not x

#
#
#
#

et
ou
ou exculsif
ngation de x

Toute opration valable sur des entiers lest aussi sur les boolens : le calcul se fait en prenant la valeur
0 pour False, et la valeur 1 pour True
La plupart du temps, les boolens sont obtenus au moyen de tests :
Tests:
x == y
x
x
x
x
x
x
x

< y
> y
<= y
>= y
!= y
in y
is y

#
#
#
#
#
#
#
#
#

galit (la double galit permet de distinguer


syntaxiquement de laffectation)
infriorit stricte
supriorit stricte
infriorit large
supriorit large
diffrent (non galit)
appartenance (pour les listes, ensembles, chanes de caratres)
identit (comparaison des identifiants de x et y)

10

CHAPITRE 1. LES BASES DE LA PROGRAMMATION EN PYTHON

Attention, suivant la classe de y, le test de lappartenance est plus ou moins long. Ainsi, si y est une liste,
il se fait en temps linaire, alors quil est en temps quasi-constant pour un ensemble.

III.3

Les listes

Une liste est une suite ordonne dobjets, pouvant tre de types diffrents. Ces objets peuvent ventuellement tre eux-mme des listes (listes imbriques). Ils peuvent mme tre gaux la liste globale
(dfinition rcursive).
Notation dune liste
[1,2,3,4]
# numration des objets entre []
[[1,2],[1],1] # liste dont les deux premiers termes sont des listes
[]
# liste vide
Laccs un lment dune liste est direct (contrairement lusage algorithmique thorique, et de
nombreux langages, ou laccs se fait par chanage, en suivant les pointeurs partir du premier lment).
Lindexation des lments commence 0 :
Accs aux lments dune liste par indexation positive:
>>> li = [1,2,3]
>>> li[0]
1
>>> li[2]
3
>>> li[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
On peut aussi accder aux lments par indexation ngative. Le dernier lment de la liste est alors
numrot -1. Avec la liste de lexemple prcdent, on obtient par exemple :
>>> li[-1]
3
>>> li[-3]
1
>>> li[-4]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
Cette possibilit est surtout intressante pour accder aux derniers lments dune liste.
Voici une liste des oprations et mthodes les plus utilises sur les listes. Pour une liste plus exhaustive,
utilisez help(list). On indique par un (m) le fait que la mthode modifie directement la liste sur laquelle
elle agit. Les autres retourne le rsultat en sortie de fonction.
Oprations et mthodes applicables une liste:
len(L)
# longueur (nombre dlments) de L
L1 + L2
# concatnation des listes
n * L
# pour n entier: concatnation rpte de L avec elle-mme.
L.append(a)
# ajout de lobjet a en fin de liste (m)
L.insert(i,a)
# insertion de lobjet a en position i (m)
L.remove(a)
# retrait de la premire occurrence de a (m)
L.pop(i)
# retrait et renvoi de llment dindice i (m)
# par dfaut, si i non prcis: dernier lment

III

Objets et mthodes
del(L[i])
L.index(a)
L.count(a)
a in L
L.copy()
L.reverse()
L.sort()

11
#
#
#
#
#
#
#
#
#
#
#

suppression de lattribut dincide i


position de la premire occurrence de a
ValueError si a nest par dans la liste
nombre doccurrences de a dans la liste
teste lappartenance de a L
copie simple de L
attention aux problmes de dpendance des attributs
retourne la liste (inversion des indexations) (m)
trie la liste dans lordre croissant (m)
(si compose dobjets comparables)
voir ci-dessous pour des paramtres

Le tri dune liste possde deux paramtres : un qui permet de prciser si le tri est croissant ou dcroissant,
lautre qui permet de dfinir une cl de tri (une fonction : on trie alors la liste suivant les valeurs que la
fonction prend sur les lments de la liste)
Paramtres de tri:
li.sort()
li.sort(reverse=True)
li.sort(key = f)

# tri simple
# tri invers
# tri suivant la cl donne par la fonction f

La fonction donnant la cl de tri peut tre une fonction prdfinie dans un module (par exemple la
fonction sin du module math), une fonction dfinie prcdemment par le programmeur (par def), ou une
fonction dfinie sur place (par lambda). Voir plus loin pour plus dexplications ce propos.
Lors de la copie dune liste (par la mthode copy, ou par affectation directe), les attributs gardent mme
adresse. Donc modifier la copie modifie aussi loriginal, et rciproquement.
Pour copier avec modification dadresse des attributs, utiliser un slicing (voir ci-dessous) M = L[:]. Cela
ne rend pas la copie compltement indpendante de loriginal, si les objets de la liste sont eux-mme des
structures composes (listes, ensembles...). Il faut dans ce cas faire une copie profonde, laide dune
fonction dfinie dans le module copy :
Copie profonde (compltement indpendante tous les niveaux):
>>> import copy
>>> M = copy.deepcopy(L)
Aux mthodes prcdentes, sajoute pour les listes une technique particulirement utile, appele saucissonnage, ou slicing. Il sagit simplement de lextraction dune tranche de la liste, en prcisant un indice
initial et un indice final. On peut dfinir un pas p, ce qui permet de nextraire quun terme sur p (par
exemple les termes dindice pair ou impair en prenant p = 2)
Technique de slicing:
L[i:j]
# Extraction de la tranche [L[i], ... , L[j-1]]
L[i:j:p]
# De mme de p en p partir de L[i], tant que i+k*p < j
noter que :
Si le premier indice est omis, il est pris gal 0 par dfaut.
Si le deuxime indice est omis, il est pris gal la longueur de la liste par dfaut (on extrait la
tranche finale)
Si le troisime indice est omis, il est pris gal 1 par dfaut (cas de la premire instruction
ci-dessus)
Un pas ngatif permet dinverser lordre des termes
Le slicing est possible aussi avec des indexations ngatives.
Par exemple :
>>> M = [0,1,2,3,4,5,6,7,8,9,10]

12

CHAPITRE 1. LES BASES DE LA PROGRAMMATION EN PYTHON


>>>
[3,
>>>
[2,
>>>
[0,
>>>
[3,
>>>
[0,
>>>
[0]
>>>
[0,
>>>
[8,
>>>
[]
>>>
[6,

III.4

M[3:6]
4, 5]
M[2:8:2]
4, 6]
M[:3]
1, 2]
M[3::3]
6, 9]
M[::5]
5, 10]
M[:2:4]
M[:5:4]
4]
M[-3:-1]
9]
M[2:6:-3]
M[6:2:-3]
3]

Les ensembles

La structure densemble (set) ressemble celle de liste, mais sans ordre dfini sur les ensembles, et
sans rptition possible des lments. Elle nest en thorie pas au programme, mais peut savrer utile
loccasion. On peut par exemple sen servir pour supprimer les doublons dans une liste (en convertissant
en ensemble puis nouveau en liste : attention, cela perturbe en gnral fortement lordre des termes dans
la liste). Elle peut aussi tre intressante lorsquon est surtout intress par des tests dappartenance, plus
rapides sur des ensembles que sur des listes.
Notation dun
{1,2,3,4}
{1,1,2,3,4,4}
set()

ensemble
# numration des objets entre {}
# mme ensemble que le premier
# ensemble vide

Attention, {} dsigne non pas lensemble vide, mais le dictionnaire vide (voir ci-dessous).
Principales oprations et mthodes applicables un ensemble
len(S)
# cardinal
S.add(a)
# ajoute a lensemble S, si pas dj prsent (m)
S.discard(a)
# enlve a de S si cen est un lment (m)
S.remove(a)
# comme discard, mais retourne une erreur
# si a nest pas lment de S (m)
S.pop()
# retourne et enlve un lment au hasard de S (m)
S.intersection(T)
# retourne lintersection de S et T
S.union(T)
# retourne lunion de S et T
S.difference(T)
# retourne les lments de S qui ne sont pas dans T
S.symmetric_difference(T) # retourne la diffrence symtrique
S.isdisjoint(T)
# retourne True ssi S et T sont disjoints
S.issubset(T)
# retourne True ssi S est inclus dans T
a in S
# teste lappartenance de a S
S.copy()
# copie simple de S
# Attention aux problmes de dpendance des attributs

III

Objets et mthodes

13

Ici encore, on peut faire une copie compltement indpendante laide de deepcopy du module copy
Du fait mme de la nature dun ensemble, on ne peut pas extraire un lment par indexation, ni appliquer
la mthode de slicing un ensemble.

III.5

Les tuples

Les tuples sont des n-uplets. Ils sont nots entre parenthses :
Notation dun tuple:
(1,2,3,4)
# numration des objets entre ()
Dans certains cas, lomission des parenthses est supporte.
Contrairement une liste, ils ont une taille fixe (aucune mthode ne peut ajouter une coordonne en
place). On peut accder une coordonne par indexation, mais pas la modifier :
>>> u = (2,3)
>>> u[1]
3
>>> u[1]=2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: tuple object does not support item assignment
Principales oprations et mthodes applicables un tuple
len(U)
# nombre de coordonnes
U+V
# retourne la concatnation
n * U
ou
U * n
# concatnation rpte n fois
U.count(a)
# retourne le nombre doccurrences de a
U.index(a)
# retourne le premier indice de a, ou une
# erreur si a nest pas un attribut
a in U
# teste lappartenance de a U

III.6

Les dictionnaires (HP)

Un dictionnaire (classe dict) permet de dfinir une association entre un ensemble dindices (appels
cls, et pouvant tre de type quelconque) et des valeurs. Lassociation entre une cl et une valeur est
appele un objet ou une entre du dictionnaire (item)
d = {}
# dictionnaire vide
d = {key1:val1, key2:val2} # cration dun dictionnaire 2 entres accessibles
# par les indices key1 et key2
d[key1]
# accs val1, associ lindice key1
del(d[key2])
# suppression de lentre associe lindice key2
Voici par exemple quelques manipulations sur les dictionnaires :
# Cration dun dictionnaire par ajouts successifs
>>> d = {}
>>> d[a]= (2,3,4)
>>> d[42]= quarante-deux
>>> d[un]=1

14

CHAPITRE 1. LES BASES DE LA PROGRAMMATION EN PYTHON


# Affichage du dictionnaire d
>>> d
{un: 1, 42: quarante-deux, a: (2, 3, 4)}
# Affichage dune valeur du dictionnaire, associe une certaine cl
>>> d[42]
quarante-deux
# Accs une cl non dfinie
>>> d[2]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 2
# Modification de la valeur associe une cl
>>> d[a] = 23
>>> d[a]
23
>>> d[a]+=3
>>> d[a]
26
# Suppression dun lment
>>> del d[un]
>>> d
{42: quarante-deux, a: 26}
# Dfinition globale dun dictionnaire
>>> e = {a:1,b:2,c:3}
>>> e[a]
1

En plus de ce qui prcde, voici quelques possibilits sur des objets de type dictionnaire :
d.keys()
d.values()
d.items()
d.pop(key)
d.popitem()

d.clear()

#
#
#
#
#
#
#
#
#
#
#

donne la liste des cls sous forme dun itrable


donne la liste des valeurs sous forme dun itrable
donne la liste des objets (entres) sous forme dun itrable
Les lments de cet itrable sont des couples (key,val)
ressort lobjet associ la cl key et supprime
lentre correspondante dans le dictionnaire
ressort un couple (key,val) du dictionnaire et le supprime
on na pas la main sur le choix du couple retourn
Peut tre utilis lorsque le dictionnaire reprsente une
pile dattente de tches effectuer.
Efface tout le contenu du dictionnaire.

Par exemple :
>>> d.keys()
dict_keys([42, a])
>>> for a in d.keys():
...
print(a, , d[a])
...

III

Objets et mthodes

15

42 quarante-deux
a 26
>>> d.values()
dict_values([quarante-deux, 26])
>>> d.items()
dict_items([(42, quarante-deux), (a, 26)])
>>> d
{42: quarante-deux, a: 26}
>>> d.pop(a)
26
>>> d
{42: quarante-deux}
>>> d[(2,3)]= 5
>>> d.popitem()
(42, quarante-deux)
>>> d
{(2, 3): 5}

III.7

Les chanes de caractres

Il sagit dun assemblage non interprt de caractres.


Notation dune chane de caractres:
abcd
# numration des caractres successifs entre
"abcd"
# numration des caractres successifs entre ""
"""abcd"""
# numration des caractres successifs entre """ """ (raw string)
Lintrt davoir 2 dlimiteurs possibles est de pouvoir utiliser sans problme une apostrophe ou un
guillemet dans une chane de caractres. Si les deux apparaissent dans la chane, on peut utiliser une raw
string. Celle-ci permet aussi dutiliser des retours-chariot explicites. Sans raw string, les retours la ligne
se notent avec le caractre spcial \ n.
Les raw string sont aussi utiliss pour commenter les fonctions (voir plus loin)
Laccs un caractre dune chane se fait par indexation de la mme manire que pour les listes. Le
premier caractre est index par 0. Les indexations ngatives sont possibles dans la mme mesure que
pour les listes.
Accs aux lments dune chane par indexation positive:
>>> ch = abcd
>>> ch[2]
c
>>> ch[-1]
d
Les slicings (saucissonnages) peuvent se faire galement sur les chanes de caractres, de la mme manire
que pour les listes :
>>> ch = azertyuiopqsdfghjklmwxcvbn
>>> ch[3:12]
rtyuiopqs
>>> ch[20:10:-1]
wmlkjhgfds
>>> ch[::2]
aetuoqdgjlwcb

16

CHAPITRE 1. LES BASES DE LA PROGRAMMATION EN PYTHON

Voici une liste (non exhaustive) des oprations et mthodes les plus utiles. Voir help(str) pour (beaucoup) plus.
Oprations et mthodes sur les chanes de caractres:
len(c)
# longueur (nombre de caractres)
print(c)
# affichage lcran de la chane c
c + d
# concatnation des chanes
n * c
# concatnation rpte n fois
c.join(li)
# concatnation des chanes de la liste li
# valable avec dautres itrables
c.split(sep)
# scinde c en une liste de chanes, en
# recherchant les sparateurs sep
c.center(n)
# centre n dans une chane de longueur n
c.format(x,y,...) # insertion des nombres x, y,... aux endroits
# dlimits par des {} dans la chane
d in c
# teste si d est sous-chane de c
c.count(d)
# nombre doccurrences ne se recouvrant pas de la chane d
c.find(d)
# indice de la premire occurrence de d
# renvoie -1 si pas doccurrence
c.index(d)
# indice de la premire occurrence de d
# erreur si pas doccurrence
c.rfind(d)
# de mme que find pour la dernire occurrence
c.rindex(d)
# de mme que index pour la dernire occurrence
c.replace(d,e)
# remplace toutes les sous-chanes d par e
Dcouvrez les nombreuses autres mthodes avec help. En particulier, plusieurs mthodes pour grer
majuscules et minuscules, ou pour des tests sur la nature des caractres.
Nous prcisons la mthode format, particulirement utile pour paramtrer laspect des insertions de
nombres dans le texte. Pour commencer, nous donnons des exemples simples :
>>>
Il
>>>
Il

Il
y a
Il
y a

y a {} arbres.format(10)
10 arbres
y a {} tulipes et {} roses.format(3,4)
3 tulipes et 4 roses

Il existe diffrents paramtres sur le format des valeurs numriques. Ces paramtres sont indiquer entre
les accolades :
:g
:.4f
:.5e
:<15.2e

#
#
#
#
#
:>15.2e #
:^15.2e #

choisit le format le plus adapt


criture en virgule flottante, fixe le nombre de dcimales, ici 4.
criture en notation scientifique, fixe le nombre de dcimales, ici 5.
Fixe la longueur de la chane (elle est remplie par des espaces),
et justifie gauche. Le 2e a la mme signification que plus haut.
Fixe la longueur de la chane, et justifie droite.
Fixe la longueur de la chane, et centre.

Par exemple, aprs import du module math :


>>> pivautenviron:{:^12.6f}!.format(math.pi)
pivautenviron:3.141593!

III.8

Les itrateurs

Les itrateurs sont des objets grnant des valeurs les unes aprs les autres en les retournant successivement. On peut utiliser ces valeurs successives grace linstruction for (voir section sur les boucles)

III

Objets et mthodes

17

Litrateur le plus utile pour nous sera range, numrant des entiers dans un intervalle donn.
Litrateur range:
range(a,b,p)
# retourne les entiers de a b-1, avec un pas p
range(a,b)
# de mme, avec la valeur par dfaut p=1
range(b)
# de mme, avec la valeur par dfaut a=0
Ainsi, range(b) permet dnumrer les entiers de 0 b 1.
Certaines classes composes possdent une mthode objet.__iter__(), permettant de le transformer
en itrateur. Cette conversion est rarement effectue explicitement, mais intervient de faon implicite.
Elle permet de faire des boucles dont lindice porte sur les lments de ces structures (par exemple les
lments dune liste, dun ensemble ou dune chane de caractres).
Boucles portant sur des objets itrables:
for i in range(n): # excute linstruction instr pour toute valeur de
instr
#
i entre 0 et n-1
for i in liste:
# excute linstruction instr pour toute valeur (non
instr
#
ncessairement numrique) de i dans la liste liste
for i in chaine:
# excute linstruction instr pour tout caractre
instr
#
i de la chane de caractre chaine.
On dit que les types list, set et str sont itrables.
Cela permet galement des dfinitions de structures composes par construction puis par comprhension,
en rajoutant une condition :
Dfinitions de listes et ensembles par comprhension:
[ f(i) for i in range(n) if g(i)] # liste des f(i) si la condition
# g(i) est satisfaite
De mme avec les ensembles. La clause if est facultative.
range peut tre remplac par un itrateur ou un objet itrable.
Par exemple :
>>> [i*i for i in [2,5,7]]
[4, 25, 49]
>>> {i for i in range(100) if i%7 == 2}
{65, 2, 37, 72, 9, 44, 79, 16, 51, 86, 23, 58, 93, 30}
Remarquez le dsordre !

III.9

Conversions de types

Certains objets dun type donn peuvent tre convertis en un autre type compatible.
Conversions de type.
float(a)
# Convertit lentier a en rel flottant
complex(a)
# Convertit lentier ou le flottant a en complexe
str(x)
# Convertit lobjet x de type quelconque en
# une chane de caractres.
list(x)
# Convertit un itrable x (set, tuple, str, range)
# en objet de type liste.
set(x)
# Convertit un itrable x en set
tuple(x)
# Convertit un itrable x en tuple
eval(x)
# Convertit la chane x en un objet adquat, si possible
float(x)
# convertit la chane x en flottant si possible
int(x)
# convertit la chane x en entier si possible

18

CHAPITRE 1. LES BASES DE LA PROGRAMMATION EN PYTHON

Par exemple :
>>> float(2)
2.0
>>> complex(2)
(2+0j)
>>> str({2,3,1})
{1, 2, 3}
>>> str(77+2)
79
>>> list({1,2,3})
[1, 2, 3]
>>> list(ens)
[e, n, s]
>>> set([1,2,3])
{1, 2, 3}
>>> set(range(10))
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> tuple(abc)
(a, b, c)
>>> eval(2)
2
>>> eval([2,3])
[2, 3]
>>> float(24)
24.0
>>> int(24)
24
>>> eval(24)
24
>>> int(024)
24
>>> eval(024)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1
024
^
SyntaxError: invalid token
Remarquez que pour valuer des chanes reprsentant des entiers, int et eval ne sont pas quivalents :
int est dfini de faon plus large, en incluant des cas particuliers non pris en compte par eval.
En revanche, eval est bien pratique lorsquon ne connat pas a priori le type de lobjet dfini par la
chane.

IV
IV.1

Structuration dun programme


Notion de programme

Un programme est constitu dune succession dinstructions, crites dans un fichier, structures de faon
rigoureuse laide de la syntaxe approprie. Cette succession dinstructions peut tre prcde par la
dfinition dun certain nombre de fonctions (dans le mme fichier, ou dans un fichier annexe quil faut

IV

Structuration dun programme

19

alors importer) qui pourront alors tre utilises dans le programme.


Les instructions peuvent tre :
une affectation
lutilisation dune fonction, ou dune mthode sur un objet, ou un calcul
une structure compose (conditionnelle, itrative, gestion dexception...)
Les structures composes peuvent porter sur des blocs de plusieurs instructions. Il est important de
pouvoir dlimiter de faon trs prcise ces blocs. Contrairement beaucoup de langages utilisant des
dlimiteurs de type begin et end, la dlimitation des blocs en Python se fait uniquement par lindentation.
Par exemple, comparons le deux petits programmes suivants :
# Importance des indentations
x = y = 1
for i in range(5):
x += 1
y += 1
print(x,y)
et :
# Importance des indentations
x = y = 1
for i in range(5):
x += 1
y += 1
print(x,y)
Le premier renvoie 6 6 tandis que le second renvoie 6 2. En effet, lincrmentation de y nest pas dans la
boucle, et na donc lieu quune fois dans le second programme.
La taille de lindentation na pas dimportance, mais dans un bloc donn, il faut tre cohrent (la mme
indentation sur chaque ligne du bloc). Cependant, dans un soucis dunification, on adopte gnralement
la rgle suivante (respecte par les environnements adapts via la tabulation) :
Un nouveau bloc sera dtermin par une indentation de 4 caractres de chacune
de ses lignes.
videmment, des blocs peuvent tre imbriqus les uns dans les autres. Dans ce cas, on additionne les indentations (un bloc lintrieur dun autre bloc principal sera donc indent de 4 espaces supplmentaires,
soit 8 caractres).
Un programme peut interagir avec lutilisateur, soit en lui demandant dentrer des donnes (entre), soit
en agissant sur les priphriques (sortie).
La demande dentre de donne par lutilisateur se fait avec :
input(texte)
Cette instruction affiche texte lcran, puis attend que lutilisateur entre une donne, valide
par la touche Entre . On associe souvent cette instruction une affectation de sorte conserver
la donne fournie :
>>> x = input(Que voulez-vous me dire? )
Que voulez-vous me dire? ZUT!
>>> x
ZUT!

20

CHAPITRE 1. LES BASES DE LA PROGRAMMATION EN PYTHON


Ici, le texte Que voulez-vous me dire? a t affich par lordinateur, et lutilisateur a tap
ZUT !, valeur qui a t stocke dans la variable x. videmment, cette fonction input est plus
intressante en programme quen ligne de commande, afin de pouvoir donner la main lutilisateur.
Attention, toute donne entre par lutilisateur lest au format str, y compris les valeurs numriques. Si on veut les utiliser dans un calcul, il faut donc dabord les convertir, laide de la fonction
eval, int ou float :
>>> x = input(Entrez une valeur : )
Entrez une valeur : 2
>>> x
2
>>> x = eval(input(Entrez une valeur : ))
Entrez une valeur : 2
>>> x
2
Nous ne ferons cette anne que des sorties sur cran, laide de la fonction print, ou des sorties
sur des fichiers. Nous reparlerons plus loin de la lecture et lcriture de fichiers en Python.

IV.2

Les fonctions

Une fonction est un morceau de programme que lon isole, et quon peut faire dpendre de paramtres.
Cela permet de :
dgager le cur mme du programme de toute technique en isolant cette technique dans des
fonctions (clart et lisibilit du code)
pouvoir rpter une certaine action plusieurs endroits dun mme programme, ou mme dans
des programmes diffrents (en dfinissant des fonctions dans des fichiers spars quon importe
ensuite)
rendre certains actions plus modulables en les faisant dpendre de paramtres.
Une fonction prend en paramtres un certain nombre de variables ou valeurs et retourne un objet (ventuellement None), calcul suivant lalgorithme donn dans sa dfinition. Il peut aussi agir sur les variables
ou les priphriques.
La syntaxe gnrale de la dfinition dune fonction est la suivante :
def nom_de_la_fonction(x,y):
"""Description"""
instructions
return rsultat
La chane de caractres en raw string est facultative. Elle permet de dfinir la description qui sera donne
dans la page daide associe cette fonction. Les instructions sont les diffrents tapes permettant darriver
au rsultat. Linstruction spcifique commenant par return permet de retourner la valeur de sortie de
la fonction. Si cette ligne nest pas prsente, la valeur de sortie sera None (pas de sortie). Cela peut tre
le cas pour une fonction dont le but est simplement de faire un affichage.
Voici un exemple :
def truc(x,y):
"""Que peut bien calculer cette fonction?"""
while x >= y:
x -= y
return x
Par exemple, en ajoutant la ligne print(truc(26,7)) et en excutant le programme, on obtient la
rponse 5.

IV

Structuration dun programme

21

Si on veut savoir ce que calcule cette fonction, on peut rajouter la ligne help(truc). Lexcution du
programme nous ouvre alors la page daide de la fonction truc :
Help on function truc in module __main__:
truc(x, y)
Que peut bien calculer cette fonction?
(END)
ce qui en loccurrence ne va pas vous aider beaucoup. Il va falloir faire marcher vos neurones...
On peut rendre certains paramtres optionnels, en leur dfinissant une valeur par dfaut, qui sera utilise
si lutilisateur nentre pas de valeur pour le paramtre considr. Il suffit par exemple de remplacer lentte
de la fonction prcdente par :
def truc(x=100,y=7):
On peut alors utiliser la fonction truc de la faon suivante :
>>>
2
>>>
4
>>>
4
>>>
2
>>>
1

truc(200,9)

# x = 200, y = 9

truc(200,7)

# x = 200, y = 7, entre manuelle

truc(200)

# x = 200, y = 7, entre par dfaut pour y

truc()

# x = 100, y = 7, entres par dfaut pour x et y

truc(y=9)

# x = 100, y = 9, entre par dfaut pour x

Enfin, notons quon peut dcrire une fonction ponctuellement (sans la dfinir globalement) grce linstruction lambda :
lambda x: expression en x

# dsigne la fonction en la variable x dfinie


# par lexpression

Cela permet par exemple de donner une fonction en paramtre (cl de tri par exemple), sans avoir la
dfinir globalement par def

IV.3

Les structures conditionnelles

Une seule structure connatre ici :


if test1:
instructions1
elif test2:
instructions2
elif test3:
instructions3
...
else:
instructions4
Les clauses elif (il peut y en avoir autant quon veut), ainsi que else sont facultatives.
La structure est comprendre comme suit :
Les intructions1 sont effectues uniquement si le test1 est positif

22

CHAPITRE 1. LES BASES DE LA PROGRAMMATION EN PYTHON

Les instructions instructions2 sont effectues uniquement si le test1 est ngatif et le test2
positif
Les instructions instructions3 sont effectues uniquement si le test1 et le test2 sont ngalifs
et le test3 est positif
...
Les instructions instructions4 sont effectues dans tous les autres cas.
Le mot elif est comprendre comme une abrviation de else if. Ainsi, la structure prcdente est en
fait quivalente une imbrication de structures conditionnelles simples :
if test1:
instructions1
else:
if test2:
instructions2
else:
if test3:
instructions3
else:
instructions4

Avertissement 1.4.1
Noubliez pas les double-points, et faites attention lindentation !

Remarque 1.4.2
Les tests peuvent tre remplacs par toute opration fournissant une valeur boolenne. On peut en
particulier combiner plusieurs tests laide des oprations sur les boolens. Par ailleurs, Python autorise
les ingalits doubles (par exemple un test 2 < x < 4).

IV.4

Les structures itratives

Il faut distinguer deux types de structures itratives ; celles o le nombre ditrations est connu ds le
dbut (itration sur un ensemble fixe de valeurs), et celles o larrt de litration est dtermine par un
test.
La structure itrative for permet ditrer sur un nombre fini de valeurs. Elle sutilise avec un objet itrable
quel quil soit. La boucle est alors rpte pour toute valeur fournie par litrateur. Lobjet itrable tant
fix, le nombre ditrations est connu ds le dpart.
# Boucle for, pour un nombre ditrations connu davance
for i in objet_iterable:
instructions
# qui peuvent dpendre de i
Par exemple :
for i in [1,2,5]:
print(i)
va afficher les 3 valeurs 1, 2 et 5.
Le classique for i = 1 to n (ou similaire) quon trouve dans la plupart des langages se traduit alors
par :

IV

Structuration dun programme

23

for i in range(1,n+1):
instructions
Si les instructions ne dpendent par de i, on peut remplacer range(1,n+1) par range(n).
Que fait par exemple le code suivant ?
x = 0
for i in range(1,1001):
x += 1 / i

La boucle while permet dobtenir un arrt de litration par un test. Il sagit en fait plutt dune condition
de continuation, puisquon itre la boucle tant quune certaine condition est vrifie.
# Boucle while, pour larrt des itrations par un test
while cond:
instructions
Tant que la condition cond est satisfaite, litration se poursuit.
Remarquez quune boucle for traditionnelle (de 1 n) peut se traduire aussi par une boucle while :
i = 1
while i <= n:
instructions
i +=1
En revanche, ce nest pas le cas de la boucle for sur dautres objets itrables.

IV.5

La gestion des exceptions

Lexcution de certaines instructions peut fournir des erreurs. Il existe diffrents types derreur en Python,
par exemple : ZeroDivisionError, ValueError, NameError, TypeError, IOError, etc.
Dans certaines conditions, on veut pouvoir continuer lexcution du programme tout de mme, ventuellement en adaptant lgrement lalgorithme au cas problmatique dtect. On dispose pour cela de la
structure try, qui dans sa version la plus simple, scrit :
try:
instructions1
except:
instructions2
else:
instructions3
Lordinateur essaie deffectuer la srie dinstructions1.
Sil survient une erreur dexcution, il effectue les instructions2 et saute les instructions3
Sinon, il saute les instructions2 et excute les instructions3.
On peut aussi rajouter une clause finally: qui sera excute dans les deux situations.
La clause except est obligatoire, la clause else est facultative. Si on na rien a faire dans la clause except,
on peut utiliser linstruction vide pass.
La gestion des exceptions peut diffrer suivant le type derreur qui intervient. Dans certains conditions, il
faut donc pouvoir distinguer plusieurs dmarches suivre suivant lerreur obtenue. En effet, considrons
lexemple suivant :

24

CHAPITRE 1. LES BASES DE LA PROGRAMMATION EN PYTHON

y = input("Entrez une valeur inverser : ")


try:
x = 1 / eval(y)
except:
print("0 na pas dinverse, Banane!")
else:
print(x)
Lanons lexcution du programme. Si on entre la valeur 2, on obtient en sortie 0.5. Si on entre la valeur
0, on se fait injurier. Mais si on entre une lettre (disons a), cest maintenant lvaluation de a qui pose
problme (car il ne sagit pas dune valeur numrique). Ainsi, lordinateur va dtecter une erreur et donc
excuter la clause except. On va donc se retouver face un 0 na pas dinverse, Banane ! assez
inappropri. Pour cela, il faut pouvoir ne considrer que le cas o lerreur obtenue est une division par 0.
En effectuant 1/0 dans la console, on rcupre le nom de cette erreur, et on peut indiquer que la clause
except ne doit porter que sur ce type derreur :
y = input("Entrez une valeur inverser : ")
try:
x = 1 / eval(y)
except ZeroDivisionError:
print("0 na pas dinverse, Banane!")
else:
print(x)
Le comportement nest pas chang si on entre les valeurs 2 ou 0. En revanche, avec la lettre a, on obtient :
Entrez une valeur inverser : a
Traceback (most recent call last):
File "try.py", line 3, in <module>
x = 1 / eval(y)
File "<string>", line 1, in <module>
NameError: name a is not defined
Si on veut pouvoir grer diffremment plusieurs types dexceptions, on peut mettre plusieurs clauses
except :
y = input("Entrez une valeur inverser : ")
try:
x = 1 / eval(y)
except ZeroDivisionError:
print("0 na pas dinverse, Banane!")
except NameError:
print("Cest a que tappelles une valeur, Banane?")
else:
print(x)
Cette fois, entrer la lettre a provoque le second message dinsultes.
On peut aussi provoquer volontairement des erreurs (on dit soulever des erreurs ou des exceptions ).
Cela se fait avec linstruction raise :
raise NomErreur(texte)
Le NomErreur doit tre un des types derreur existant (on peut ventuellement en dfinir dautres, mais
nous ntudierons pas cette anne cette possibilit), le texte est la petite explication saffichant lors du
message derreur :

IV

Structuration dun programme

25

>>> raise TypeError(Quel est le rapport avec la choucroute?)


Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Quel est le rapport avec la choucroute?
On peut par exemple utiliser cela pour dfinir une fonction sur un intervalle donn. Supposons que nous
voulions dfinir f : x 7 x2 2 sur lintervalle [1, 3] (allez savoir pourquoi !). On peut vouloir soulever
une erreur si on cherche valuer f en un rel x hors de cet intervalle. Voici comment faire :
def f(x):
if (x<-1) or (x>3):
raise ValueError(valeur hors du domaine de dfinition de f)
return x ** 2 - 2
print(f({})={}.format(2,f(2)))
print(f({})={}.format(4,f(4)))
Lexcution de ce programme retourne le rsultat suivant :
f(2)=2
Traceback (most recent call last):
File "raise.py", line 8, in <module>
print(f({})={}.format(4,f(4)))
File "raise.py", line 4, in f
raise ValueError(valeur hors du domaine de dfinition de f)
ValueError: valeur hors du domaine de dfinition de f
noter que soulever une erreur arrte de facto le programme, moins dinclure cette erreur dans une
clause try de gestion des exceptions.
Enfin, on peut utiliser ce quon vient de voir dans le simple but de redfinir les messages derreurs. En
reprenant le premier exemple, et en ne grant que lexception relative la division par 0, on peut par
exemple ecrire :
y = input("Entrez une valeur inverser : ")
try:
x = 1 / eval(y)
except ZeroDivisionError:
raise ZeroDivisionError("0 na pas dinverse, Banane!")
else:
print(x)
Pour la valeur 0, on obtient alors :
Traceback (most recent call last):
File "try.py", line 3, in <module>
x = 1 / eval(y)
ZeroDivisionError: division by zero
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
File "try.py", line 5, in <module>
raise ZeroDivisionError("0 na pas dinverse, Banane!")
ZeroDivisionError: 0 na pas dinverse, Banane!

26

CHAPITRE 1. LES BASES DE LA PROGRAMMATION EN PYTHON

noter que le comportement est totalement diffrent du premier exemple, puisquici, le programme est
interrompu sil y a une division par 0.

Modules complmentaires

Nous terminons ce chapitre par une description rapide dun certain nombre de modules qui nous seront
utiles en cours danne.

V.1

Utilisation dun module

De nombreuses fonctions sont dfinies dans des modules spcialises ; cela permet de ne pas encombrer la
mmoire de la dfinition de plein de fonctions dont on ne se servira pas : on peut se contenter de charger
(importer) les modules contenant les fonctions utilises (ou mme selectionner les fonctions quon importe
dans chaque module). De cette manire, on peut dfinir un trs grand nombre de fonctions, sans pour
autant alourdir lensemble.
Pour utiliser une fonction fonct dun module mod, il faut importer cette fonction, ou le module entier
avant lutilisation de cette fonction. Cela peut se faire de 3 manires :
Import simple du module
import mod
#Cette instruction permet de faire savoir lordinateur quon
#utilise le module \texttt{mod}. On peut alors utiliser les fonctions
#de ce module en les faisant prcder du prfixe \texttt{mod} (nom du
#module):
mod.fonct()
Lutilisation de prfixes permet dutiliser des fonctions ayant ventuellement mme nom et se
situant dans des modules diffrents. Certains noms de module sont longs, ou seront utiliss trs
souvent. On peut, au moment de limport du module, crer un alias, qui permettra dappeler les
fonctions de ce module en donnant comme prfixe lalias au lieu du nom complet :
import mod as al
al.fonct()
Un alias dusage trs courant est :
import numpy as np
Import dune fonction dun module
from mod import fonct
# Cette instruction permet dimporter la dfinition de la fonction
# \texttt{fonct}, qui peut alors tre utilise sans prfixe:
fonct()
# les autres fonctions du module ne peuvent pas tre utilises, mme
# avec le prfixe.
Attention, si une fonction du mme nom existe auparavant (de base dans Python, ou importe
prcdemment), elle sera crase.
Import de toutes les fonctions dun module
from mod import *
# Cette instruction permet dimporter la dfinition de toutes les
# fonctions du module
fonct()
# les autres fonctions du module peuvent tre utilises de mme.

Modules complmentaires

27

Attention aussi aux crasements possibles. Par ailleurs, limport est plus long effectuer, et dune
gestion plus lourde, surtout si le module est gros.
Nous passons en revue les modules qui nous seront les plus utiles. Il existe une foule dautres modules (se
renseigner sur internet en cas de besoin), dans des domaines trs spcifiques.

V.2

Le module math

Ce module contient les fonctions et constantes mathmatiques usuelles, dont nous citons les plus utiles
(utiliser help() pour avoir la liste de toutes les fonctions du module)
### Exponentielle et logarithme ###
e
# constante e, base de lexponentielle
exp(x)
# exponentielle de x
log(x)
# logarithme nprien
log10(x)
# logarithme en base 10
### Fonctions trigonomtriques ###
pi
# le nombre pi
cos(x)
# cosinus
sin(x)
# sinus
tan(x)
# tangente
acos(x)
# arccos
asin(x)
# arcsin
atan(x)
# arctan
### Fonctions hyperboliques ###
cosh(x)
# cosinus hyperbolique
sinh(x)
# sinus hyperbolique
tanh(x)
# tangente hyperbolique
### parties entires ###
floor(x)
# partie entire
ceil(x)
# partie entire par excs
### Autres fonctions ###
sqrt(x)
# racine carre
factorial(x) # factorielle (pour x entier)

V.3

Le module numpy (calcul numrique)

Il est impossible de faire le tour de faon rapide de ce module dfinissant un certain nombre dobjets
indispensables en calcul numrique, en particulier lobjet matriciel, et toutes les rgles associes. Nous
ne faisons quun survol rapide de cet aspect, en vous laissant dcouvrir le reste laide de laide ou des
guides dutilisation.
Le module numpy contient lui-mme des sous-modules, en particulier le sous-module linalg. Le module
principal numpy est suppos import sous laliasnp. Si on nutilise quun sous-module particulier, on peut
importer uniquement ce sous-module (par exemple import numpy.linalg as al permettra dutiliser
toutes les fonctions de linalg, en se contentant de prciser le suffixe al).
### La structure array (np.array): tableau multidimentionnel ###
array(liste) # convertisseur: transforme une liste en tableau
# En imbriquant des listes dans des listes, on peut

28

CHAPITRE 1. LES BASES DE LA PROGRAMMATION EN PYTHON


# obtenir des tableaux multidimentionnels
### Exemples ###
np.array([1,2,3])
# tableau 3 entres (matrice ligne)
np.array([[1,2],[3,4]]) # matrice 2x2 de premire ligne (1,2) seconde ligne (3,4)
np.array([[1],[2],[3]]) # matrice colonne
### fonctions de structure sur les array ###
np.shape(A)
# format du tableau (nombre de lignes, de colonnes...,
# sous forme dun tuple
np.rank(A)
# profondeur dimbrication (dimension spatiale)
# ATTENTION, ce nest pas le rang au sens mathmatique!

Quelques diffrences entre les listes et les np.array :


Homognit : toutes les entres doivent tre de mme type
Le format est immuable. La taille est dfinie partie de la premire affectation. Pour initialiser, il
faut donc souvent crer un tableau pralablement rempli de 0 ou de 1.
### Cration de tableaux particuliers ###
np.ones(n)
# Cre une matrice ligne de taille n constitue de 1.
np.ones((n1,n2))
# matrice de taille n1 x n2, constitue de 1
# se gnralise des tuples
np.zeros(n)
# Cre une matrice ligne de taille n constitue de 0.
np.zeros((n1,n2)) # matrice de taille n1 x n2, constitue de 0
# se gnralise des tuples
np.eye(n)
# matrice identit dordre n (des 1 sur la diagonale)
np.diag(d0,...,dn) # matrice diagonale de coefficients diagonaux d1,...,d_n
np.linspace(a,b,n) # matrice ligne constitue de n valeurs rgulirement rparties
# entre $a$ et $b$
np.arange(a,b,p)
# matrice ligne des valeurs de a b en progressant de pas p
np.fromfunction(f,(n,))
# matrice ligne remplie des valeurs f(k) pour
# k de 0 n-1
np.fromfunction(f,(n1,...,nd)) # De mme pour plus de dimension
# f dpend ici de d variables
Les np.array permettent le calcul matriciel. Les oprations matricielles usuelles sont dfinies :
###
A +
a *
A *

Oprations matricielles ###


B
# Somme de deux matrices
M
# Multiplication par un scalaire
B
# Produit coefficient par coefficient (produit de Schur)
# ATTENTION, ce nest pas le produit matriciel
np.dot(A,B) ou A.dot(B) # Produit matriciel
np.linalg.det(A)
# dterminant
np.trace(A)
# trace
np.transpose(A)
# transpose
np.power(A,n)
# A puissance n
np.linalg.inv(A)
# inverse de A
np.linalg.eigvals(A)
# valeurs propres de A
np.linalg.eig(A)
# valeurs propres et base de vecteurs propres
Remarquez que dans la syntaxe suffixe A.dot(B), il nest pas ncessaire de prciser quon utilise le module
numpy, puisque cette notation suffixe signifie quon utiliser une mthode associe la structure d lobjet
A, donc la structure de np.array. Il ne peut donc pas y avoir derreur daiguillage.

Modules complmentaires

29

La rsolution de systmes de Cramer est programme aussi :


### Rsolution de systmes de Cramer ###
np.linalg.solve(A,b) # Donne lunique solution du systme de Cramer Ax=b
Enfin, le sous-module numpy.random dfinit un certain nombre de fonctions de gnration alatoire de
nombres, suivant la plupart des lois classiques. Nous nen citons que la loi uniforme, utiliser laide
help(numpy.random) pour dcouvrir les autres en cas de besoin. On suppose numpy.random import
sous le nom npr
npr.randint(a)

#
#
npr.randint(a,b)
#
#
npr.random(a,b,n) #
#
npr.random()
#
npr.sample(n)
#
#
npr.sample(tuple) #
#

V.4

gnre alatoirement un entier de 0 a-1 inclus,


de faon uniforme
gnre alatoirement un entier de a b-1 inclus,
de faon uniforme
gnre un tableau 1 x n dentiers alatoirement
choisis uniformment entre a et b-1
gnre alatoirement un rel de [0,1[ de faon uniforme
gnre un np.array 1 ligne n colonnes rempli alatoirement
par des rels de [0,1[ choisis uniformment
de mme pour un tableau multidimentionnel de
taille dfinie par le tuple

Le module scipy (calcul scientifique)

Le module scipy regroupe un certain nombre de fonctions de calcul scientifique (algorithmes classiques
de calcul numrique). Nous donnons celles qui sont incontournables dans le cadre de votre programme :
### Calcul numrique ###
scipy.integrate.quad(f,a,b)
scipy.optimize.newton(f,a,g)

#
#
#
#
scipy.optimize.newton(f,a)
#
scipy.integrate.odeint(f,y0,T) #
#
#
#

V.5

intgrale de f de a b
rsolution dquation par la mthode de Newton
initialise au point a
g doit tre gal f
de mme par la mthode de la scante
Rsolution de lED y=f(y,t)
y0 est la valeur initial (t minimal)
T est un tableau des temps auquels
calculer les valeurs de y

Le module matplotlib (trac de courbes)

Ce module donne un certain nombre doutils graphiques, notamment pour le trac de courbes. Nous
nutiliserons que le sous-module matplotlib.pyplot, que nous supposerons import sous lalias plt.
Notons que le prfixe matplotlib fait rfrence au mot matrice et non mathmatique .
plt.plot(L1,L2, label=nom) #
#
#
#

trace la ligne brise entre les points


dont les abscisse sont dans la liste L1
et les ordonnes dans la liste L2
Le label sert identifier la courbe

plt.title("titre")

# Dfinit le titre du graphe (affich en haut)

plt.grid()

# Affiche un grille en pointills pour


# une meilleure lisibilit

30

V.6

CHAPITRE 1. LES BASES DE LA PROGRAMMATION EN PYTHON

plt.legend(loc = ...)

#
#
#
#
#
#

Affiche une lgende (associant chaque


courbe son label)
loc peut tre un nombre (1,2,3,4,5,...)
plaant la lgende un endroit prcis
loc peut aussi tre plus explicitement:
upper left etc.

plt.savefig(nom.ext)

# Sauvegarde le graphe dans un fichier de ce nom


# Lextention dfinit le format
# Voir laide pour savoir les formats accepts

plt.show()

# Affichage lcran de la figure

plt.matshow(T)

#
#
#
#

Affiche une image constitue de points dont


les couleurs sont dfinies par les valeurs du
tableau T de dimension 2 ( voir comme un
tableau de pixels)

Autres modules (random, time, sqlite3,...)

Parmi les autres modules que nous utiliserons, citons random, qui proposent des fonctions de gnration
alatoire, qui peuvent rentrer en conflit avec celles dfinies dans numpy.random :
### Module random ###
random.randint(a,b) #
#
sample(l,k)
#
#
#

entier alatoire entre a et b inclus.


Notez la diffrence avec la fonction de numpy
Liste alatoire dlments distincts de la liste l
Deux occurrences dune mme valeur dans l sont
considres comme distinctes.

A part pour cette dernire fonction qui peut savrer utile, ce module est plutt moins fourni que celui
de numpy
Le module time permet daccder lhorloge. On sen servira essentiellement pour mesurer le temps
dexcution dune fonction :
### Module time ###
time.perf_counter() ou time.time()

# donne une valeur dhorloge correspondant


# linstant en cours en seconde.

Cette fonction sera utilise comme suit :


import time
debut = perf_counter()
instructions
fin = perf_counter()
temps_execution = fin - debut
Enfin, le module sqlite3 nous sera utile pour traiter des bases de donnes en fin danne. Il nest pas
utile de retenir les instructions ci-dessous ds maintenant. Supposons ce module import sous le nom sql.
### Module sqlite3 ###
connection = sql.connect(base.db)
# cre un objet de connexion vers la base base.db

VI

Lecture et criture de fichiers

31

cur = connection.cursor()
# cre un curseur qui permettra des modifications de la base
cur.execute("instruction SQL")
# Excute linstruction donne, dans la syntaxe SQL,
# dans la base pointe par le curseur
connection.commit()
connection.close()
# fermeture de la connection la base

VI

Lecture et criture de fichiers

Nous voyons enfin comment il est possible daccder aux fichiers en Python (lecture, criture). Sont
dfinies dans le noyau initial les fonctions suivantes :
### Lecture, criture dans un fichier ###
f = open(nom_fichier,r ou w ou a)
# ouvre le fichier nom_fichier (accessible ensuite dans la variable f)
# nom_fichier peut contenir un chemin daccs, avec la syntaxe standard
# pouvant diffrer suivant le systme dexploitation.
# r : ouverture en lecture seule
# w : ouverture en criture (efface le contenu prcdent)
# a : ouverture en ajout (crit la suite du contenu prcdent)
f.readline()
# lit la ligne suivante (en commanant la premire) (renvoie un str)
f.readlines()
# renvoie une liste de str, chaque str tant une ligne du fichier
# en commenant la ligne en cours sil y a dj eu des lectures
f.write(texte)
# crit le texte la suite de ce qui a t crit depuis louverture
f.close()
# ferme le fichier f.
Dans le module os, et plus prcisment le sous-module os.path on trouve des fonctions permettant de
grer la recherche de fichiers dans une arborescence, et la manipulation des chemins et noms de fichiers.
### Fonctions de manipulation de chemins dans os.path ###
abspath(chemin) # transforme un chemin (relatif) en chemin absolu
basename(chemin) # extrait la dernire composante du chemin
dirname(chemin) # extrait le rpertoire
isfile(chemin)
# teste si le chemin correspond un fichier
isdir(chemin)
# teste si le chemin correspond un rpertoire
splitext(chemin) # revoie (partie initiale, extension de fichier)
etc.

32

CHAPITRE 1. LES BASES DE LA PROGRAMMATION EN PYTHON

2
Matriel et logiciels
Dans ce chapitre, nous dcrivons de faon schmatique le fonctionnement dun ordinateur, ainsi que
certaines limitations intrinsques.

lments darchitecture dun ordinateur

Nous commenons par dcrire le matriel informatique constituant un ordinateur, et permettant son
fonctionnement. Notre but est de donner une ide rapide, sans entrer dans le dtail logique du fonctionnement du processeur (portes logiques) et encore moins dans le dtail lectronique cach derrire ce
fonctionnement logique (amplificateurs oprationnels, transistors etc.)

I.1

Modle de Von Neumann

Pour commencer, interrogeons-nous sur la significtion-mme du terme informatique .


Dfinition 2.1.1 (Informatique)
Le mot informatique est une contraction des deux termes information et automatique. Ainsi, linformatique est la science du traitement automatique de linformation.
Il sagit donc dappliquer un ensemble de donnes initiales des rgles de transformation ou de calcul
dtermines (cest le caractre automatique), ne ncessitant donc pas de reflexion ni de prise dinitiative.
Dfinition 2.1.2 (Ordinateur)
Un ordinateur est une concrtisation de cette notion.

Il sagit donc dun appareil concret permettant le traitement automatique des donnes. Il est donc ncessaire que lordinateur puisse communiquer avec lutilisateur, pour permettre lentre des donnes initiales,
la sortie du rsultat du traitement, et lentre des rgles dautomatisation, sous la forme dun programme.
Le modle le plus couramment adopt pour dcrire de faon trs schmatique le fonctionnement dun
ordinateur est celui dcrit dans la figure 2.1, appel architecture de Von Neumann. Dans ce schma, les
flches reprsentent les flux possibles de donnes.
Note Historique 2.1.3 (von Neumann)
John von Neumann (Jnos Neumann) est un scientifique amricano-hongrois (Budapest, 1903 - Washington,
D.C., 1957). Ses domaines de recherche sont trs varis, de la mcanique quantique aux sciences conomiques, en
passant par lanalyse fonctionnelle, la logique mathmatique et linformatique. Il contribue au projet Manhattan,

34

CHAPITRE 2. MATRIEL ET LOGICIELS

Mmoire

Unit centrale
(Processeur)
Unit de
contrle

Unit arithmtique
et logique (UAL)
Accumulateur

Entres

Sorties

Figure 2.1 Modle darchitecture de Von Neumann

et notamment llaboration de la bombe A, puis plus tard de la bombe H. Son nom reste attach la description
de la structure dun ordinateur, en 1945. Cest sur ce schma quont ensuite t labors les premiers ordinateurs.
Si les ordinateurs actuels sont souvent beaucoup plus complexes, leur schma grossier reste cependant trs proche
du schma de larchitecture de von Neumann.

Note Historique 2.1.4 (architecture de von Neumann)


Le schma dun ordinateur (architecture de von Neumann) a t donn en 1945 par John von Neumann, et deux
collaborateurs dont les noms sont injustement rests dans loubli : John W. Maukly et John Eckert. John von
Neumann lui-mme attribue en fait lide de cette architecture Alan Turing, mathmaticien et informaticien
britannique dont le nom reste associ la notion de calculabilit (lie la machine de Turing), ainsi quau
dcryptage de la machine Enigma utilise par les nazis durant la seconde guerre mondiale.

Entres - sorties
Les entres et sorties se font au moyen de priphriques spciaux destins cet usage.
Les priphriques dentre permettent un utilisateur dentrer lordinateur des donnes, sous
des formats divers : clavier, souris, scanner, webcam, manettes de jeu etc.
Les priphriques de sortie permettent de restituer des informations lutilisateur. Ils sont
indispensables pour pouvoir profiter du rsultat du traitement de linformation : cran, imprimante, hauts-parleurs, etc.
Certains priphriques peuvent parfois jouer la fois le rle dentre et de sortie, comme les
crans tactiles. Ils peuvent aussi avoir des fonctions non lies aux ordinateurs, comme certaines
photocopieuses, dont lutilisation essentielle ne requiert pas dordinateur, mais qui peuvent
aussi faire office dimprimante et de scanner.
La mmoire permet le stockage des donnes et des logiciels (programmes) utiliss pour les traiter.
Ce stockage peut tre :
dfinitif (mmoire morte, ou ROM, inscrite une fois pour toute, et non modifiable, moins
dinterventions trs spcifiques) ;

lments darchitecture dun ordinateur

35

temporaire moyen et long terme (stockage de donnes et logiciels que lutilisateur veut garder,
au moins momentanment) ;
temporaire court terme (donnes stockes linitiative du processeur en vue dtre utilises
ultrieurement : il peut par exemple sagir de rsultats intermdiaires, de piles dinstructions
etc.).
Larchitecture de von Neumann utilise le mme type de mmoire pour les donnes et les programmes, ce qui permet la modification des listes dinstructions (elle-mmes pouvant tre gres
comme des donnes). Ce procd est lorigine des boucles.
Nous reparlerons un peu plus loin des diffrents types de mmoire qui existent.
Le processeur est le cur de lordinateur. Cest la partie de lordinateur qui traite linformation.
Il va chercher les instructions dans un programme enregistr en mmoire, ainsi que les donnes
ncessaires lexcution du programme, il traduit les instructions (parfois complexes) du programme en une succession doprations lmentaires, excutes ensuite par les units de calcul
(UAL et unit de calcul en virgule flottante). Il interagit aussi ventuellement avec lutilisateur,
suivant les instructions du programme. Nous tudierons un peu plus loin le processeur de faon
un peu plus prcise, sans pour autant entrer dans les dtails logiques associs aux traductions et
aux excutions.
Le transfert des donnes (les flches dans le schma de la figure 2.1) se fait laide de fils lectriques
transportant des impulsions lectriques, appels bus.
Un bus est caractris :
par le nombre dimpulsions lectriques (appeles bits) quil peut transmettre simultanment. Ce nombre dpend du nombre de conducteurs lectriques parallles dont est constitu
le bus. Ainsi, un bus de 32 bits est constitus de 32 fils conducteurs pouvant transmettre
indpendamment des impulsions lectriques.
par la frquence des signaux, cest--dire le nombre de signaux quil peut transmettre de
faon successive dans un temps donn. Ainsi, un bus de 25 MHz peut transmettre 25 millions
dimpulsions sur chacun de ses fils chaque seconde.
Ainsi, un bus de 32 bits et 25 MHz peut transmettre 25 106 32 bits par seconde, soit 800 106
bit par seconde, soit environ 100 Mo (mgaoctet) par seconde (un octet tant constitu de 8
bit). Le environ se justifie par le fait que les prfixes kilo et mga ne correspondent pas
tout--fait 103 et 106 dans ce cadre, mais 210 = 1024 et 220 = 10242.
Les bus peuvent donc transmettre les donnes condition que celles-ci soient codes dans un
systme adapt ces impulsions lectriques. La base 2 convient bien ici (1 = une impulsion
lectrique, 0 = pas dimpulsion lectrique). Ainsi, toutes les donnes sont codes en base 2,
sous forme dune succession de 0 et de 1 (les bits). Ces bits sont souvent groups par paquets
de 8 (un octet). Chaque demi-octet (4 bits) correspond un nombre allant de 0 15, crit
en base 2. Ainsi, pour une meilleure concision et une meilleure lisibilit, les informaticiens
amens manipuler directement ce langage binaire le traduisent souvent en base 16 (systme
hexadcimal, utilisant les 10 chiffres, et les lettres de a f). Chaque octet est alors cod par 2
caractres en hexadcimal.
Les bus se rpartissent en 2 types : les bus parallles constitus de plusieurs fils conducteurs,
et permettant de transmettre un ou plusieurs octets en une fois ; et les bus sries, constitus
dun seul conducteur : linformation est transmise bit par bit.
Paradoxalement, il est parfois plus intressant dutiliser des bus sries. En effet, puisquun bus
srie utilise moins de conducteur quun bus parallle, on peut choisir, pour un mme prix, un
conducteur de bien meilleure qualit. On obtient alors, au mme cot, des bus sries pouvant
atteindre des dbits gaux, voire suprieurs, des bus parallles.
Un ordinateur utilise des bus 3 usages essentiellement :
le bus dadresses, dont la vocation est ladressage en mmoire (trouver un endroit en mmoire). Cest un bus unidirectionnel ;
les bus de donnes, permettant la transmission des donnes entre les diffrents composants.

36

CHAPITRE 2. MATRIEL ET LOGICIELS


Ce sont des bus bidirectionnels ;
les bus de contrle, indiquant la direction de transmission de linformation dans un bus de
donnes.
La carte-mre est le composant assurant linterconnexion de tous les autre composants et des
priphriques (via des ports de connection). Au dmarrage, elle lance le BIOS (Basic Input/Output
System), en charge de reprer les diffrents priphriques, de les configurer, puis de lancer le
dmarrage du systme via le chargeur damorage (boot loader).

I.2

Mmoires

Nous revenons dans ce paragraphe sur un des composants sans lequel un ordinateur ne pourrait rien
faire : la mmoire.
La mmoire est caractrise :
par sa taille (nombre doctets disponibles pour du stockage). Suivant le type de mmoire, cela peut
aller de quelques octets plusieurs Gigaoctets ;
par sa volatilit ou non, cest--dire le fait dtre efface ou non en absence dalimentation lectrique.
par le fait dtre rinscriptible ou non (mmoire morte, mmoire vive).
Nous numrons ci-dessous diffrents types de mmoire quon peut rencontrer actuellement. Du fait de
limportance de la mmoire et des besoins grandissants en capacit de mmoire, les types de mmoire sont
en volution constante, aussi bien par leur forme que par les techniques ou principes physiques utiliss.
Nous ne pouvons en donner quune photographie instantane, et sans doute dj prime et loin dtre
exhaustive.
Mmoire morte (ROM, read-only memory)
Il sagit de mmoire non volatile, donc non reprogammable. Ce qui y est inscrit y est une fois
pour toutes, ou presque. Le BIOS, permettant le lancement de lordinateur, est sur la ROM
de lordinateur. Il sagit plus spcifiquement dune EPROM (erasable programmable read-only
memory). Comme son nom lindique, une EPROM peut en fait tre efface et reprogramme, mais
cela ncessite une opration bien particulire (elle doit tre flashe avec des ultras-violets).
Mmoire vive (RAM, random access memory)
Le nom de la RAM provient du fait que contrairement aux autres types de stockages existant
lpoque o ce nom a t fix (notamment les cassettes magntiques), la lecture se fait par accs
direct (random), et non dans un ordre dtermin. Le nom est maintenant un peu obsolte, la
plupart des mmoires, quelles quelles soient, fonctionnant sur le principe de laccs direct.
La mmoire vive est une mmoire volatile, utilise par lordinateur pour le traitement des
donnes, lorsquil y a ncessit de garder momentanment en mmoire un rsultat dont il
aura se resservir plus tard. Elle est daccs rapide, mais peu volumineuse. Elle se prsente
gnralement sous forme de barrettes enficher sur la carte-mre.
Physiquement, il sagit de quadrillages de condensateurs, qui peuvent tre dans 2 tats (charg
= 1, dcharg = 0). Ces condensateurs se dchargent naturellement au fil du temps. Ainsi, pour
garder un condensateur charg, il faut le recharger (rafrachir) intervalles rguliers. Il sagit
du cycle de rafraichissement, ayant lieu des priodes de quelques dizaines de nanosecondes.
Par consquent, en labsence dalimentation lectrique, tous les condensateurs se dchargent,
et la mmoire est efface.
Mmoires de masse
Ce sont des mmoires de grande capacit, destines conserver de faon durable de grosses donnes (bases de donnes, gros programmes, informations diverses...) De par leur vocation, ce sont
ncessairement des mmoires non volatiles (on ne veut pas perdre les donnes lorsquon teint
lordinateur !). Par le pass, il sagissait de bandes perfores, puis de cassettes, de disquettes etc.
Actuellement, il sagit plutt de disques durs, de bandes magntiques (frquent pour les sauvegardes rgulires), de CD, DVD, ou de mmoires flash (cl USB par exemple).

lments darchitecture dun ordinateur

37

Mmoires flash
Les mmoires flash (cl USB par exemple) que nous venons dvoquer ont un statut un peu
particulier. Techniquement parlant, il sagit de mmoire morte (EEPROM : electrically erasable
programmable read-only memory), mais qui peut tre flashe beaucoup plus facilement que les
EPROM, par un processus purement lectrique. Ce flashage fait partie du fonctionnement mme
de ces mmoires, ce qui permet de les utiliser comme des mmoires rinscritptibles et modifiables
souhait.
Une caractristique trs importante de la mmoire est son temps daccs, qui reprsente un facteur limitant
du temps de traitement de donnes. Ce temps daccs est bien entendu dpendant du type de mmoire,
ainsi que de sa position par rapport au processeur : mme si elle est trs grande, la vitesse de circulation
des impulsions lectriques nest pas nulle, et loin dtre ngligeable dans la situation prsente. Ainsi, les
mmoires auquelles on soit accder souvent (celles utilises pour des stockages temporaires de rsultats
intermdiaires par exemple) doivent tre physiquement places prs du processeur. Ainsi, plus on construit
des mmoires peu volumineuse, plus on peu placer de mmoire prs du processeur. La recherche de la
miniaturisation na donc pas quun rle esthtique. Le processeur lui-mme et les composantes auquels
il est rattach subissent le mme principe de miniaturisation en vue de laugmentation de lefficacit. De
ce fait, il y a physiquement peu de place prs du processeur.
Par ailleurs, le temps daccs dpend beaucoup de la technologie utilise pour cette mmoire. Les mmoires
lectroniques, composes de circuits bascules (ou circuits bistables), sont rapides daccs, tandis que les
mmoires base de transistors et de condensateurs (technologie usuelle des barrettes de RAM) sont plus
lentes daccs (temps de charge + temps de latence d la ncessit dun rafraichissement priodique,
du fait de la dcharge naturelle des condensateurs). Les mmoires externes ncessitant un processus de
lecture sont encore plus lentes (disques durs, CD...)
Pour cette raison, les mmoires les plus rapides sont aussi souvent les moins volumineuses, et les plus
onreuses (qualit des matriaux + cot de la miniaturisation), le volume tant dautant plus limit que
dun point de vue lectronique, un circuit bistable est plus volumineux quun transistor.
On peut reprsenter la hirarchie des mmoires sous forme dun triangle (figure 2.2)
Vers le processeur
registres
Cache
Mm. centrale
(RAM)
Stockage magntique
(DD)
Archivage (externe)

Capacit
Figure 2.2 Hirarchie des mmoires
Les registres sont des mmoires situes dans le processeur, ne dpassant souvent pas une dizaine doctets,
et la plupart du temps sont usages spcialiss (registres dentiers, de flottants, dadresses, compteur
ordinal indiquant lemplacement de la prochaine instruction, registres dinstruction...). Les donnes stockes dans ces registres sont celles que le processeur est en train dutiliser, ou sur le point de le faire. Le

38

CHAPITRE 2. MATRIEL ET LOGICIELS

temps daccs est trs court. Ces mmoires sont le plus souvent constitus de circuits bascule (voir plus
loin).
La mmoire cache se dcompose souvent en deux parties, lune dans la RAM, lautre sur le disque dur.
Pour la premire, il sagit de la partie de la RAM la plus rapide daccs (SRAM). La mmoire cache est
utilise pour stocker momentanment certaines donnes provenant dailleurs ou venant dtre traites, en
vue de les rapprocher, ou les garder prs de lendroit o elles seront ensuite utiles, afin damliorer par
la suite le temps daccs. Ainsi, il arrive quavant de parvenir au processeur, les donnes soient dabord
rapproches sur la mmoire cache.

I.3

Le processeur (CPU, Central Process Unit)

Cest le cur de lordinateur. Cest lui qui ralise les oprations. Dans ce paragraphe, nous nous contentons dune description sommaire du principe de fonctionnement dun processeur. Nous donnerons ultrieurement un bref aperu de lagencement lectronique ( partir de briques lectroniques lmentaires,
traduisant sur les signaux lectroniques les fonctions boolennes lmentaires) permettant de faire certaines oprations. Nous nentrerons pas dans le dtail lectronique dun processeur.
Composition dun processeur
Le processeur est le calculateur de lordinateur. Il lit les instructions, les traduit en successions doprations
lmentaires qui sont ensuite effectues par lunit arithmtique et logique (UAL), couple (actuellement)
une unit de calcul en virgules flottantes (format usuellement utilis pour les calculs sur les rels). Il
est constitu de :
une unit de traitement, constitue dune UAL (unit arithmtique et logique), dun registre de
donnes (mmoire destine aux donnes rcentes ou imminentes), et dun accumulateur (lespace
de travail). Le schma global est celui de la figure 2.3.
Bus de donnes

Registres
entr. 1

OPCODE

entr. 2

UAL

Accumulateur

Figure 2.3 Schma dune unit de traitement


Ce schma correspond au cas dune machine plusieurs adresses (lUAL peut traiter simultanment
des donnes situes plusieurs adresses). Il existe galement des machines une seule adresse : la
deuxime donne ncessaire aux calculs tant alors celle stocke dans laccumulateur. Cela ncessite
de dcomposer un peu plus les oprations lmentaires (notamment dissocier le chargement de
laccumulateur du calcul lui-mme).
Le code de lopration (OPCODE) correspond une succession de bits indiquant la nature de
lopration effectuer sur lentre, ou les entres (par exemple, un certain code correspond

lments darchitecture dun ordinateur

39

laddition, un autre la multiplication, dautres aux diffrents tests boolens etc.)


Une instruction lmentaire doit donc arriver lunit de traitement sous la forme dun code
(une succession de bits, reprsents par des 0 et des 1, correspondant en ralit des impulsions
lectriques), donnant dune part le code de lopration (OPCODE), dautre part les informations
ncessaires pour trouver les entres auquelles appliquer cette opration (la nature de ces informations diffre suivant le code de lopration : certains oprations demandent 2 adresses, dautres
une seule adresse et la donne dune valeur immdiate , dautres encore dautres formats). Ce
codage des instructions diffre galement dun processeur lautre. Par exemple, dans un processeur darchiteture MIPS, lopration est code sur 6 bits. Lopration 100000 demande ensuite la
donne de 3 adresses a1 , a2 et a3 . Cette opration consiste en le calcul de a2 + a3 , le rsultat tant
ensuite stock ladresse a1 :
100000

a1

a2

a3

$a1 $a2 + $a3

Dans cette notation, $a reprsente la valeur stocke ladresse a. Lopration 001000 est galement
une opration daddition, mais ne prenant que deux adresses a1 et a2 , et fournissant de surcrot une
valeur i directement code dans linstruction (valeur immdiate). Elle ralise lopration daddition
de la valeur i la valeur stocke ladresse a2 , et va stocker le rsultat ladresse a1 :
001000

a1

a2

$a1 $a2 + i

LUAL est actuellement couple avec une unit de calcul en virgule flottante, permettant le calcul
sur les rels (ou plutt leur reprsentation approche informatique, dont nous reparlerons plus loin).
Un processeur peut avoir plusieurs processeurs travaillant en parallle (donc plusieurs UAL), afin
daugmenter la rapidit de traitement de lordinateur ;
une unit de contrle, qui dcode les instructions dun programme, les transcrit en une succession dinstructions lmentaires comprhensibles par lunit de traitement (suivant le code voqu
prcdemment), et envoie de faon bien coordonne ces instructions lunit de traitement. La
synchronisation se fait grce lhorloge : les signaux dhorloge (impulsions lectriques) sont envoys de faon rgulire, et permettent de cadencer les diffrentes actions tels les coups de timbales
dans une galre romaine. De faon schmatique, la rception dun signal dhorloge par un composant marque laccomplissement dune tape de la tche quil a faire. Les diffrentes tapes se
succdent donc au rythme des signaux dhorloge. Une unit de contrle peut tre schmatise la
manire de la figure 2.4.
Le registre dinstruction contient linstruction (non lmentaire) en cours, le compteur ordinal
contient ce quil faut pour permettre de trouver ladresse de linstruction suivante, et le registre
dadresse contient ladresse de linstruction suivante.
Le dcodeur dcode linstruction contenue dans le registre dinstruction et la traduit en une succession dinstructions lmentaires envoyes lunit de traitement au rythme de lhorloge. Lorsque
linstruction est entirement traite, lunit va chercher linstruction suivante, dont ladresse est
stocke dans le registre dadresse, et la stocke dans le registre dinstruction. Le dcodeur actualise
le compteur ordinal puis ladresse de linstruction suivante.
Dcomposition de lexcution dune instruction
On peut schmatiquement dcomposer lexcution dune instruction par lunit de traitement en 4 tapes :
la rception de linstruction code (provenant de lunit de contrle) (FETCH)
Le dcodage de cette instruction ; les diffrentes donnes sont envoyes aux diffrents composants
concern (en particulier lOPCODE est extrait et envoy lUAL)
Lexcution de linstruction, correspondant au fonctionnement de lUAL (EXECUTE)
lcriture du rsultat dans une mmoire (WRITEBACK)

40

CHAPITRE 2. MATRIEL ET LOGICIELS


Signal dhorloge
Bus dadresse
Bus de donnes

Horloge

Registre dinstruction

Registre dadresse

Dcodeur

Compteur ordinal

Code instruction

Vers unit de traitement


Figure 2.4 Schma dune unit de contrle
Si nous avons 4 instructions excuter successivement, cela nous donne donc 16 tapes successives :
tape
Instr. 1
Instr. 2
Instr. 3
Instr. 4

1
FE

2
DE

3
EX

4
WR

FE

DE

EX

WB

10

11

12

FE

DE

EX

WB

13

14

15

16

FE

DE

EX

WB

On se rend compte que lUAL nest pas utilise son plein rgime : elle nest solicite quaux tapes
3, 7, 11 et 15 (EXECUTE). En supposant les instructions indpendantes les unes des autres (donc ne
ncessitant pas dattendre le rsultat de la prcdente pour pouvoir tre excute), et en ngligeant les
dpendances ventuelles lies aux problmes dadresses, on peut imaginer le fonctionnement suivant, dans
lequel on nattend pas la fin de linstruction prcdente pour commencer le traitement de la suivante :
tape
Instr. 1
Instr. 2
Instr. 3
Instr. 4

1
FE

2
DE
FE

3
EX
DE
FE

4
WR
EX
DE
FE

WB
EX
DE

WB
EX

WB

On dit que le processeur est muni dun pipeline sil est muni dun dispositif permettant deffectuer
ces oprations en parallle de faon dcale. videmment, un pipeline doit aussi permettre de grer
les problmes de dpendance, ncessitant parfois la mise en attente dune instruction pour attendre le
rsultat dune autre. Dans cet exemple, nous avons un pipeline 4 tages (cest le nombre dtapes dans
la dcomposition de lexcution de linstruction, correspondant aussi au nombre dinstructions maximal
pouvant tre traites simultanment. Des dcompositions plus fines peuvent permettre dobtenir des
pipelines constitus dun nombre plus important dtages (une dizaine).
Par ailleurs, certains processeurs sont munis de plusieurs curs (plusieurs units de traitement), permettant lexcution simultane dinstructions. Ainsi, toujours en supposant les 4 instructions indpendantes,
pour un processeur muni de 2 curs pipeline 4 tages, on obtient le tableau suivant :

II

Codages

41
tape
Instr. 1
Instr. 2
Instr. 3
Instr. 4

1
FE 1
FE 2

2
DE 1
DE 2
FE 1
FE 2

3
EX
EX
DE
DE

1
2
1
2

4
WR 1
WB 2
EX 1
EX 2

WB 1
WB 2

On parle dans ce cas darchitecture en parallle. Le paralllisme demande galement un traitement spcifique des dpendances.
Puissance de calcul dun processeur
La puissance dun processeur est calcule en FLOPS (Floating Point Operation Per Second). Ainsi, il
sagit du nombre doprations quil est capable de faire en une seconde sur le format flottant (rels).
Pour donner des ordres de grandeur, voici lvolution de la puissance sur quelques annes rfrences :
1964 : 1 mgaFLOPS (106 )
1997 : 1 traFLOPS (1012 )
2008 : 1 ptaFLOPS (1015 )
2013 : 30 ptaFLOPS
On estime que lexaFLOPS (1018 ) devrait tre atteint vers 2020.
videmment, ces puissances correspondent aux super-calculateurs. La puissance des ordinateurs personnels suit une courbe bien infrieure. Par exemple, en 2013, un ordinateur personnel tait muni en moyenne
dun processeur de 200 gigaFLOPS, ce qui est comparable la puissance des super-calculateurs de 1995.

II

Codages

Toute information tant code en impulsions lectriques (cest--dire dans un systme 2 tats : impulsion
ou absence dimpulsion), le codage naturel des donnes doit se faire en binaire. Nous faisons dans ce
paragraphe quelques rappels sur les bases de numration, puis nous indiquons plus prcisment les normes
de codage des entiers et des rels.

II.1

Bases de numration

Soit b un entier suprieur ou gal 2.


Thorme 2.2.1 (existence et unicit de la reprsentation en base b)
Soit N N. Il existe une unique suite (xn )nN dentiers de [[0, b 1]], tous nuls partir dun certain
rang, tels que :
+
X
N=
xn bn .
n=0

Dfinition 2.2.2 (reprsentation dun entier dans une base)


On dit que lcriture de N sous la forme de la somme
N=

+
X

xn bn ,

n=0

o les xn sont nuls partir dun certain rang, et vrifient xn [[0, b 1]], est la reprsentation en
base b de N . Si k est le plus grand entier tel que xk 6= 0, on crira cette reprsentation sous la forme
synthtique suivante :
N = xk xk1 . . . x1 x0 b .

42

CHAPITRE 2. MATRIEL ET LOGICIELS

Il convient de bien distinguer lentier N de sa reprsentation sous forme de caractres. Il en est de mme
des xi , qui dans la somme reprsente des valeurs (des entiers), alors que dans la notation introduite, ils
reprsentent des caractres (les chiffres de la base de numration). De fait, lorsque b 6 10, on utilise
pour ces caractres les chiffres de 0 b 1, tandis que si b > 10, on introduit au-del du chiffre 9 des
caractres spcifiques (souvent les premires lettres de lalphabet). Ainsi, usuellement, les chiffres utiliss
pour la reprsentation des entiers en base 16 (hexadcimal), trs utilise par les informaticiens, sont les
10 chiffres numriques de 0 9, et les 6 premires lettres de lalphabet, de A F .
Il faut bien comprendre la notation sous forme dune juxtaposition de caractres (il ne sagit pas du
5
produit des xi ). Par exemple, 1443 reprsente lentier
N = 3 50 + 4 51 + 4 52 + 1 53 = 248.
Une mme succession de caractres reprsente en gnral des entiers diffrents si la base b est diffrente.
6
Ainsi 1443 reprsente lentier
N = 3 + 4 6 + 4 62 + 1 63 = 387.
4

En revanche, la notation 1443 na pas de sens, puisque seuls les caractres 0, 1, 2 et 3 sont utiliss en
base 4.
Notation 2.2.3
Une reprsentation dun entier N sous forme de juxtaposition de chiffres sans mention de la base
(et sans surlignage) dsignera suivant le contexte la numration en base 10 (numration usuelle en
mathmatiques) ou en base 2 (dans un contexte informatique). On sarrangera pour que le contexte
lve toute ambigut.
On remarquera que le seul cas dambigut dans ce contexte est le cas o seuls les chiffres 0 et 1 sont
utiliss.
Mthode 2.2.4 (Convertir dune base b la base 10)
Soit N reprsent sous la forme xk xk1 . . . x0 b . On trouve lentier N en effectuant le calcul :
N=

k
X

xi bi .

i=0

Pour ce calcul, consistant en lvaluation dun polynme, on utilisera de prfrence lalgorithme de


Hrner, bas sur la factorisation suivante :
N = x0 + b(x1 + b(x2 + + b(xk1 + bxk ))).
Ainsi, initialisant xk , on trouve N en rptant lopration consistant multiplier par b et ajouter le
chiffre prcdent.
Ce calcul peut tre effectu en base 10, en convertissant les chiffres xi en leur analogue en base 10,
ainsi que b, puis en utilisant les algorithmes usuels de calcul des sommes et produits en base 10 (poser
les oprations).

Remarque 2.2.5
Lalgorithme de Hrner est plus gnralement un algorithme permettant dvaluer tout polynme en
une valeur donne a. Ici, la correspondance entre la valeur de N et sa reprsentation de N sexprime
sous forme dun polynme en b. Lalgorithme de Hrner, consistant mettre en facteur les termes b
autant que possible, permet dviter certaines multiplications par b : on ne reprend pas le calcul des

II

Codages

43

puissances de b depuis le dbut chaque fois. Cela permet dobtenir calcul ncessitant un nombre
doprations linaire en le nombre de chiffres (cest--dire peu prs gal une quantit k, lorsque k
devient grand), alors quun algorithme naf reprenant le calcul des puissances au dbut chaque fois
ncessite un nombre quadratique doprations (cest--dire de lordre de k 2 . Lorsque k est de lordre
de 1000, on gagne un facteur 1000 entre les deux temps de calcul, ce qui nest pas ngligeable !

Remarque 2.2.6
La mthode dcrite ci-dessus permet en thorie de convertir tout entier dune base b vers une base c. Les
rgles arithmtiques du calcul dune somme et dun produit se gnralisent en effet en base quelconque.
Dans la pratique, pour mener un tel calcul la main, il vaut mieux connatre ses tables daddition et
de multiplication en base c (on peut dresser ces tables avant de commencer le calcul pour les avoir sous
les yeux).

Exemple 2.2.7
5

Convertir 342 en base 6 et en base 2, sans passer par la base 10.

Cependant, le manque dhabitude quon a des calculs en base diffrente de 10 fait quen pratique, on
prfre souvent faire une tape par la base 10, de sorte navoir utiliser des algorithmes de calculs
que sur des numrations en base 10. Ainsi, on commence par convertir de la base b la base 10, puis
de la base 10 la base c, en utilisant cette fois la mthode suivante, permettant de faire cette tape en
nutilisant que la numration en base 10.
Mthode 2.2.8 (Convertir de la base 10 une base b)
Soit N (dont on connait la reprsentation en base 10). Pour trouver la reprsentation de N en base
b, on effectue les divisions euclidiennes de N , puis des quotients successifs, par b, jusqu obtenir un
quotient nul. Les restes successifs sont les chiffres de N dans la numration en base b, dans lordre
croissant des poids (le premier reste est le chiffre des units).

Exemple 2.2.9
Convertir 2016 en base 7, en base 2.

Mthode 2.2.10 (cas particulier : convertir dune base b la base bk )


Il suffit pour cela de regrouper k par k les chiffres de la reprsentation de N en base b, en commenant
par les units. Les nombres reprsents par ces groupements de k chiffres sont dans [[0, bk 1]], et
donnent les chiffres de la reprsentation de N en base bk :
base b :

xik1 . . . x(i1)k

base bk :

{z

yi1

x2k1 . . . xk

...

{z

y1

xk1 . . . x0
}|

{z

y0

(dans cette reprsentation, on complte ventuellement la tranche la plus gauche par des 0).
On peut galement faire la dmarche inverse sur le mme principe.

44

CHAPITRE 2. MATRIEL ET LOGICIELS

Exemples 2.2.11
1. Donner la reprsentation hexadcimale de 2016, en utilisant la reprsentation binaire calcule
ci-dessus.
16

2. Donner la reprsentation en base 2 de af 19b .


Ce dernier principe est trs largement utilis par les informaticiens, pour passer du binaire lhexadcimal
et rciproquement.

II.2

Codage des entiers

Dans un systme o le nombre de bits destins la reprsentation dun entier est constant (langages
traditionnels), seule une tranche de lensemble des entiers peut tre code. Plus prcisment, avec n bits,
on peut coder une tranche de longueur 2n , par exemple [[0, 2n 1]], ou [[2n1 , 2n1 1]], ou toute autre
tranche de la mme longueur suivant la convention adopte. Nous nous bornerons ltude de cette
situation o le nombre n de bits est une constante, mme si en Python, le langage que nous utiliserons
par la suite, le nombre n de bits allous la reprsentation dun entier varie suivant les besoins (les entiers
sont aussi grand quon veut en Python).
Pour pouvoir considrer des entiers de signe quelconque, de faon la plus quilibre possible, on cherche
donner un codage des entiers de lintervalle [[2n1 , 2n1 1]]. On pourrait imaginer diffrents codages,
ayant chacun leurs avantages, mais aussi leurs inconvnients ; par exemple :
coder la valeur absolue sur 7 bits, par la numration en binaire, et attribuer la valeur 0 ou 1 au 8e
bit suivant le signe ; il faudrait ensuite corriger bien artificiellement le doublon du codage de 0 et
labsence du codage de 2n1 .
Compter les nombres partir de 2n1 , qui on attibue la valeur initiale 0 (autrement dit,
considrer le code binaire de x + 2n1 )
Ces deux codages sont simples dcrire et calculer, mais savrent ensuite assez peu commodes dans
limplmentation des calculs lmentaires.
Le codage adopt gnralement est le codage appel codage en complment 2, correspondant grossirement une mise en cyclicit des entiers de 2n1 2n1 1, donc un codage modulo 2n . On commence
numrer les entiers depuis 0 jusqu 2n1 1, puis, les codages suivants en binaire vont correspondre
aux entiers de 2n1 1. Plus prcisment :
Dfinition 2.2.12 (Codage en complment 2)
Dans ce codage sur n bits des entiers de [[2n1 , 2n1 1]] :
le code binaire dun entier k [[0, 2n1 1]] est sa reprsentation binaire
le code binaire dun entier k [[2n1 , 1]] est la reprsentation binaire de k + 2n = 2n |k|.
Remarque 2.2.13
On distingue facilement par ce codage les entiers de signe positif (leur premier bit est 0) des entiers de
signe ngatif (leur premier bit est 1). On dit que le premier bit est le bit de signe.
Lintrt de ce codage est la facilit dimplmentation des algorithmes usuels de calcul (somme, produit...).
En effet, ce codage vite davoir distinguer dans ces algorithmes diffrents cas suivant le signe des
oprandes : lalgorithme usuel pour la somme (et les autres galement), correspondant poser laddition,
est valable aussi bien pour les entiers ngatifs, en posant la somme de leur reprsentation binaire en
complment 2, condition :
doublier une ventuelle retenue qui porterait sur un n + 1-ime bit
que le rsultat thorique de lopration soit bien compris dans lintervalle [[2n1 , 2n1 1]].

II

Codages

45

En effet, les nombres thoriques et leur reprsentation binaire sont congrus modulo 2n . De plus, loubli
des retenues portant sur les bits non reprsents (au del du ne) naffecte par le rsultat modulo 2n
du calcul. Ainsi, le rsultat obtenu (sur le codage binaire, puis sur lentier cod ainsi) est gal, modulo
2n , au rsultat thorique. Cette congruence est une galit si on sait que le rsultat thorique est dans
[[2n1 , 2n1 1]], intervalle constitu de reprsentants de classes de congruences deux deux distinctes.
Exemple 2.2.14
Pour un codage 8 bits, illustrer ce qui prcde pour le calcul de 45 + 17, de 45 + 65 et de 100 + 100.
Certains langages grent les dpassements de capacit (le fait que le rsultat sorte de la tranche
initialement alloue) en attribuant des octets supplmentaires pour le codage du rsultat (cest le cas
de Python), dautres ne le font pas (comme Pascal par exemple). Dans ce cas, le rsultat obtenu nest
correct que modulo 2n . Ainsi, pour des entiers standard de type integer en Pascal, lopration 32767 + 1
renvoie le rsultat 32768. Le programmeur doit tre conscient de ce problme pour prendre les mesures
qui simposent.
Pour terminer ce paragraphe, observons quil est possible dobtenir trs simplement le codage en complment 2 dun nombre m < 0, connaissant le codage de sa valeur absolue |m|. En effet, le codage
de m est le dveloppement binaire de 2n |m| = (2n 1) |m| + 1. Or, 2n 1 est le nombre qui, se
reprsente en binaire par n chiffres tous gaux 1. Par consquent, effectuer la soustraction (2n 1) |m|
est particulirement simple : elle nengendre aucune retenue, et consiste simplement changer tous les 0
en 1 et rciproquement dans la reprsentation binaire de |m|. Par exemple :

1 1
0 1
1 0

1 1
1 0
0 1

1
0
1

1 1
1 0
0 1

1
1
0

Il suffit ensuite de rajouter 1 au rsultat obtenu, ce qui se fait, par reports successifs des retenues, en
transformant le dernier bloc 011 . . . 1 en 100 . . . 0. Il convient ici de noter quun tel bloc existe toujours
(ventuellement uniquement constitu du terme 0), car sinon, le nombre obtenu est 111 . . . 1, ce qui
correspond |m| = 0, ce qui contredit lhypothse m < 0.
On rsume cela dans la mthode suivante :
Mthode 2.2.15 (Codage en complment 2 de |m|)
Pour trouver le codage en complment 2 de |m|, on change le rle des chiffres 0 et 1 dans la reprsentation binaire de |m|, puis on ajoute 1, ce qui revient changer le dernier bloc 01 . . . 1 (ventuellement
rduit 0) en 10 . . . 0.
Rciproquement si un codage correspond un nombre ngatif (i.e. le bit de signe est 1), on trouve le
codage de la valeur absolue en effectuant la dmarche inverse, cest--dire en remplaant le dernier bloc
10 . . . 0 par 01 . . . 1, puis en changeant les 0 et les 1.

On peut remarquer que cela revient aussi changer les 0 en 1 et rciproquement, sauf dans le dernier
bloc 10 . . . 0 (algorithme valable dans les deux sens)

II.3

Dveloppement en base b dun rel

La notion de reprsentation en base b dun entier se gnralise aux rels, condition daccepter des
sommes infinies de puissances ngatives de b. Ces sommes infinies sont des sommes de sries termes
positifs, considrer comme la limite de sommes finies. Nous obtenons :

46

CHAPITRE 2. MATRIEL ET LOGICIELS

Thorme 2.2.16 (Dveloppement en base b dun rel positif )


Soit x R+ . Il existe n Z et des entiers xi [[0, b 1]], pour tout i ]] , n]], tels que xn 6= 0 et
x=

n
X

xi bi =

i=

lim

n
X

xi bi .

i=N

De plus :
si pour tout m N, bm x 6 N, alors ce dveloppement est unique (cest--dire que n et les xi
sont uniques)
sil existe m N tel que bm x N, alors il existe exactement deux dveloppements, lun terminant (vers ) par une succession infinie de 0, lautre terminant par une infinit de b 1.
Notation 2.2.17
(Reprsentation du dveloppement en base b)
n
X
i
xi b un dveloppement en base b de x. Si n > 0, on note :
Soit x =
i=

x = xn xn1 . . . x0 , x1 x2 . . .b .
Si n < 0, on pose x0 = x1 = = xn+1 = 0, et on crit
b

x = x0 , x1 x2 . . .b = 0, 0 . . . 0xn xn1 . . . .
De plus, sil existe m 6 0 tel que pour tout k < m, xk = 0, on utilisera une reprsentation borne, en
omettant lultime srie de 0 :
x = xn xn1 . . . x0 , x1 x2 . . . xm b .
Enfin, si b = 10 (ou b = 2 dans un contexte informatique sans ambigut), on omettra la barre et la
rfrence b dans la notation.

Terminologie 2.2.18 (dveloppement dcimal, dveloppement dyadique)


On parlera de dveloppement dcimal plutt que de dveloppement en base 10. De mme, on parlera de
dveloppement dyadique plutt que de dveloppement en base 2. On rencontre aussi parfois la notion
de dveloppement triadique.

Exemples 2.2.19
1. En base 10, on a lgalit entre 1 et 0, 999999 . . .
3

2. En base 3, on a lgalit entre les rels 1, 0210000000 . . . et 1, 0202222222 . . .

Terminologie 2.2.20 (dveloppement propre)


On dira que le dveloppement en base b est propre sil ne termine pas par une srie de chiffres b 1.
Ainsi, daprs ce qui prcde, tout nombre rel admet une unique dcomposition propre en base b.
Proposition 2.2.21
Avec la notation prcdente, si x > 0 et si les xi , pour i < 0, ne sont pas tous gaux b 1 (cest le
cas en particulier si la dcomposition est propre), xn xn1 . . . x0 b est la reprsentation en base b de la
partie entire de x.

II

Codages

47

Ainsi, pour trouver le dveloppement en base b de x, on peut utiliser la mthode suivante :


Mthode 2.2.22 (Dveloppement en base b dun rel)
Soit x R+ (le cas x = 0 tant trivial, et le cas x R sobtenant en rajoutant au dveloppement
de |x| un signe ). Pour trouver un dveloppement en base b de x, on peut dcomposer le calcul en 2
tapes :
trouver la reprsentation en base b de la partie entire x de x, laide des mthodes exposes
prcdemment. Cette reprsentation scrit sous la forme
x = xn . . . x0 b ;
trouver le dveloppement dcimal de la partie dcimale {x} de x, par la mthode expose cidessous. Ce dveloppement scrit sous la forme
b

{x} = 0, x1 x2 . . . .
Le dveloppement en base b de x est alors :
x = xn . . . x0 , x1 x2 . . .b .
Pour trouver le dveloppement propre en base b de {x}, on peut partir de la remarque vidente suivante :
la multiplication par b consiste en le dcalage droite dun cran de la virgule. Ainsi, x1 est la partie
entire de b{x}, puis reprenant la partie dcimale de cette expression et la remultipliant par b, on obtient
x2 en prenant nouveau la partie entire du rsultat. On nonce :
Mthode 2.2.23 (Trouver le dveloppement en base b dun rel x [0, 1[)
Soit x [0, 1[. On a alors

x = 0, x1 x2 . . . ,

o :
x1 = b{x},

x2 = b{b{x}},

x3 = b{b{b{x}}}

etc.

Ainsi, on trouve les chiffres successifs du dveloppement en rptant lopration consistant multiplier
la partie dcimale obtenue prcdemment par b et en en prenant la partie entire.

Exemples 2.2.24
1. Trouver le dveloppement dyadique de 0, 7
2. De mme pour 0, 1.
3. De mme pour 3, 84375.
On peut toujours crire un nombre rel x (en base 10) sous la forme y 10k , o y [1, 10[ et k Z. Il
sagit de la notation scientifique usuelle. Ici, lexposant k correspond au rang du premier chiffre non nul
de x. De la mme faon :
Proposition/Dfinition 2.2.25 (Notation scientifique en base b)
Soit b N, b > 2. Soit x R+ . Il existe un unique entier k Z et un unique rel y [1, b[ tel que
x = y bk .
Ainsi, il existe un unique k Z, et duniques entiers yi de [[0, b 1]], i ]] , 0]], non tous gaux
b 1 partir dun certain rang, tels que
x = y0 , y1 y2 . . .b bk

et

y0 6= 0.

48

CHAPITRE 2. MATRIEL ET LOGICIELS

Il sagit de la notation scientifique en base b.

Remarque 2.2.26
Si b = 2, le chiffre y0 est ncessairement gal 1. Le stockage dun nombre rel sous ce format pourra
se dispenser du bit correspondant y0 , tout dtermin.

II.4

Codage des rels (norme IEEE 754)

Le stockage des nombres rels ne peut pas se faire de faon exacte en gnral. En effet, mme en ne se
donnant pas de limite sur le nombre de bits, on sera limit par la capacit de la mmoire (finie, aussi
grande soit-elle) de lordinateur. Or, entre deux rels distincts, aussi proches soient-ils, il existe une infinit
non dnombrable de rels. La mmoire de lordinateur est incapable de dcrire de faon exacte ce qui se
trouve entre 2 rels distincts, quels quils soient.
Ainsi, augmenter la capacit de stockage selon les besoins est vain, pour le stockage des rels. Si certains
rels peuvent se stocker facilement sur un nombre fini de bits de faon cohrente, la plupart ncessiteraient
une place infinie. Ainsi, par convention, on se fixe un nombre fini de bits, en tant conscient que ce quon
codera sur ces bits ne sera quune valeur approche du rel considr. Il faudra alors faire attention, dans
tous les calculs effectus, la validit du rsultat trouv, en contrlant, par des majorations, lerreur de
aux approximations de la reprsentation informatique des rels. On peut dans certains situations obtenir
une divergence forte entre le calcul effectu par lordinateur et le calcul thorique. Nous en verrons un
exemple frappant en TP lors de ltude de lalgorithme dArchimde pour le calcul de .
Dfinition 2.2.27 (Reprsentation des rels sur 32 bits)
Le stockage des rels en norme IEEE 754 se fait sous la forme scientifique binaire :
2

x = 1, x1 x2 . . . 2k .
| {z }
mantisse

Sur les 32 bits, 1 bit est rserv au stockage du signe, 8 au stockage de lexposant et 23 au stockage de
la mantisse. Le 1 prcdant la virgule na pas besoin dtre stock (valeur impose) :

Signe Exposant

Mantisse

Le bit de signe est 0 si x > 0 et 1 si x < 0.


Lexposant k peut tre compris entre 126 et 127. Les 8 bits destins cet usage donnent
la reprsentation binaire de 127 + k, compris entre 1 et 254. Les valeurs binaires 00000000 et
11111111 sont interdites (reserves dautres usages, correspondant des reprsentations non
normalises)
La mantisse est reprsente de faon approche par son dveloppement dyadique 23 chiffres
aprs la virgule (donc les xi , i < 1).
IEEE = Institute of Electrical and Electronics Engineers
Exemples 2.2.28
La reprsentation sur 32 bits de 0, 1 est :
00111101110011001100110011001100

II

Codages

49

Donner la reprsentation sur 32 bits de 5890, 3


Quel est le nombre reprsent par :
11000001010001100000000000000000 ?

Remarque 2.2.29 (Valeurs extrmales, prcision pour un codage sur 32 bits)


2

La valeur maximale est alors 1.111111111 . . . 2127 2128 3, 403 1038 .


La valeur minimale est 2126 1, 75 1038 .
La prcision de la mantisse est de lordre de 223 1, 192 107 .
Ainsi, cette reprsentation nous donne des valeurs relles avec environ 8 chiffres significatifs en notation
dcimale (en comptant le premier). Cette prcision est souvent insuffisante, surtout aprs rpercussion et
amplification des erreurs. On utilise de plus en plus frquemment la norme IEEE 754 avec un codage sur
64 bits, permettant une augmentation des extrmes et de la prcision. Cest le cas en Python, que nous
utiliserons.
Dfinition 2.2.30 (Reprsentation des rels sur 64 bits)
Le stockage des rels en norme IEEE 754 sur 64 bits se fait sur le mme principe que sur 32 bits avec
les modifications suivantes : sur les 64 bits, 1 bit est rserv au stockage du signe, 11 au stockage de
lexposant et 52 au stockage de la mantisse.

Signe Exposant

Mantisse

Le bit de signe est 0 si x > 0 et 1 si x < 0.


Lexposant k peut tre compris entre 1022 et 1023. Les 11 bits destins cet usage donnent
la reprsentation binaire de 1023 + k, compris entre 1 et 2046. Les valeurs binaires 00000000000
et 11111111111 sont interdites (reserves dautres usages, correspondant des reprsentations
non normalises)
La mantisse est reprsente de faon approche par son dveloppement dyadique 52 chiffres
aprs la virgule.

Remarque 2.2.31 (Valeurs extrmales, prcision pour un codage sur 64 bits)


2

La valeur maximale est alors 1.111111111 . . . 21023 21024 1, 797 10308 .


La valeur minimale est 21022 2, 225 10308 .
La prcision de la mantisse est de lordre de 252 2, 22 1016 .
On obtient donc, avec le bit implicite, une prcision correcte 16 ou 17 chiffres significatifs. Cela
explique que Python (par exemple) retourne les rsultats rels en donnant 16 chiffres aprs la virgule.

Dfinition 2.2.32 (Nombres dnormaliss)


La valeur 11111111111 de lexposant permet le codage des nombres infinis (NaN, not a nomber).
Nous nen parlerons pas.
La valeur 00000000000 de lexposant permet de coder des nombres un peu plus petits que la
borne trouve ci-dessous, mais en diminuant la prcision (nombres normaliss). Dans ce cas, le
bit implicite nest plus considr gal 1, mais 0. Un codage :
1000000000000001000000000000000000000000000000000000000000000000

50

CHAPITRE 2. MATRIEL ET LOGICIELS

correspond par exemple au nombre 21022 0, 0001 = 21026 .


Le plus petit nombre quon puisse alors obtenir est 2102252 = 21074 . Python renvoie 5.e-324 pour
cette valeur (on a perdu toute la prcision derrire la virgule). Le calcul de 21075 renvoie 0.

II.5

Problmes lis la reprsentation non exacte des rels

Il faut faire attention essentiellement trois problmes :


1. Problmes darrondi
La plupart des nombres ntant pas reprsents de faon exacte, les approximations faites peuvent
sajouter dans les calculs. Le caractre approch des rsultats des calculs peut se constater sur un
exemple trs simple :
>>> 0.3-0.2-0.1
-2.7755575615628914e-17
Ces petites erreurs sadditionnent, et peuvent devenir grandes si on effectue un grand nombre de
calculs :
>>> S = 0
>>> for i in range(1000):
...
S += 0.1
...
>>> S
99.9999999999986
>>> S-100
-1.4068746168049984e-12
2. Problme dabsorption
Ce problme se produit lors de la somme de deux rels nayant pas du tout le mme ordre de
grandeur. Si le plus petit des deux a un ordre de grandeur infrieur la prcision du plus grand
(donc de lordre de grandeur du dernier chiffre significatif), le rsultat de la somme admet la mme
reprsentation que la valeur la plus grande. On dit que la petite valeur a t absorbe par la grande.
Cette situation se produit ds lors que xy > 252 . Par exemple, comparons les 2 calculs suivants :
>>> 2**100 + 1 - 2**100
1
>>> 2**100 + 1. - 2**100
0.0
La premire ligne de calcul se fait avec des entiers (aussi grands quon veut en Python). Il ny a
dans ce cas pas de problme. La seconde ligne reprsente le mme calcul avec des rels (le point
aprs le 1 force le calcul se faire en type rel). Le 1 a t absorb.
Nous illustrons le fait que le rapport de grandeurs limite est 252 en remarquant que 1 est absorb
face 253 , mais pas 2 :
>>> 2**53 + 1. - 2**53
0.0
>>> 2**53 + 2. - 2**53
2.0
On peut alors imaginer des algorithmes finissant (rapidement) en thorie, mais ne sarrtant pas
en pratique cause de ce problme. On en donne dabord une version avec des entiers (tap en
ligne de commande) :

II

Codages

>>>
>>>
>>>
...
...
...
>>>
2

51

S=0
i=2**53
while i < 2**53 + 2:
i += 1
S += 1
S

Le comportement est celui quon attend. Voici la version relle du mme algorithme :
>>> S=0
>>> i=2**53
>>> while i < 2**53 + 2:
...
i += 1.
...
S += 1
...
^CTraceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyboardInterrupt
>>> S
30830683
On est oblig dinterrompre le calcul avec Ctrl-C. En demandant ensuite la valeur de S, on se
rend compte quon est pass un grand nombre de fois dans la boucle. Le fait de travailler en rels
a comme consquence que la valeur de i considre est toujours la mme, car le 1 quon lui ajoute
est absorb.
3. Problme de cancellation
Il sagit du problme inverse. Lorsquon effectue la diffrence de deux nombres de mme ordre de
grandeur, il se peut que de nombreux bits de la reprsentation se compensent. Par exemple, si seuls
les 2 derniers bits diffrent, le premier bit du rsultat sera de lordre de grandeur de lavant-dernier
bit des deux arguments, le second bit significatif sera de lordre de grandeur du dernier bit des
arguments, et les suivants nont pas de signification, car provenant de rsidus de calculs approchs.
Leur valeur exacte ncessiterait de connatre les chiffres suivants dans le dveloppement des deux
arguments. Nous illustrons ceci sur lexemple suivant :
>>> def f(x):
...
return (x+1)**2-x**2-2*x-1
...
>>> f(1000000000)
0
>>> f(1000000000.)
-1.0
>>> f(10000000000)
0
>>> f(10000000000.)
-2049.0
>>> f(100000000000)
0
>>> f(100000000000.)
-905217.0
>>>

52

CHAPITRE 2. MATRIEL ET LOGICIELS


Dans cet exemple, la fonction f est identiquement nulle. Le calcul est correct sil est effectu avec
des entiers, mais plus du tout lorsquon passe aux rels.
4. Comparaisons par galit
Aux trois problmes prcdents, nous ajoutons le quatrime, qui est en fait driv du premier
(problme de linexactitude de la reprsentation des rels). Comparer par une galit 2 rels,
surtout sils sont issus de calculs, na pas beaucoup de pertinence, car mme sils sont gaux en
thorie, il est probable que cela ne le soit pas en pratique. Ainsi, en reprenant un exemple vu plus
haut, on obtient le rsultat suivant, assez surprenant, pour un test trs simple :
>>> 0.3==0.2+0.1
False
On y remdie souvent en sautorisant une petite inexactitude, ce qui oblige remplacer lgalit
par un encadrement :
>>> abs(0.3-0.2-0.1)<1e-15
True

III

Circuits logiques

Du fait de la circulation de linformation sous forme dimpulsions lectiques, comme nous lavons dit plus
haut, la base de reprsentation privilgie est la base 2. Mais comment en pratique effectuer les calculs
lmentaires sur ces reprsentations en base 2 ? Autrement dit, comment, partir dimpulsions lectriques
correspondant deux arguments, rcuprer les impulsions lectriques correspondant, par exemple, la
somme ?
Le but de cette section est dapporter quelques lments de rponse, bass sur ltude des portes logiques,
sans entrer dans le dtail lectronique de ces portes, et en se contentant dun exemple dopration, le cas
de laddition.

III.1

Portes logiques

Nous admettons lexistence de dispositifs lectriques simples permettant de raliser les oprations suivantes :
Dfinition 2.3.1 (Les portes logiques)
Dans les diagrammes ci-dessus, les entres sont reprsentes gauche, la sortie droite ;
1. La porte NOT (NON) :

NOT

La sortie vaut 1 si et seulement si lentre vaut 0.


2. La porte AND (ET) :

AND

III

Circuits logiques

53

La sortie vaut 1 si et seulement si les deux entres valent 1 simultanment.


3. La porte OR (OU non exclusif) :

OR

La sortie vaut 1 si et seulement si lune au moins des deux entres vaut 1.


4. La porte XOR (OU exclusif) :

XOR

La sortie vaut 1 si et seulement si une et une seule des deux entres vaut 1.
5. La porte NAND (NON ET) :

NAND

La sortie vaut 1 si et seulement si les deux entres ne sont pas toutes les deux gales 1, donc
lune au moins vaut 0.
6. La porte NOR (NON OU) :

NOR

La sortie vaut 1 si et seulement si aucune des deux entres ne vaut 1, donc si les deux valent 0.

III.2

Un exemple dvelopp : laddition sur n bits

Le point de dpart est la remarque suivante : laddition de deux bits peut facilement se traduire laide
des portes logiques. En effet, en base 2, on a, en forant le rsultat tenir sur 2 bits :
0 + 0 = 00

0 + 1 = 1 + 0 = 01

1 + 1 = 10.

Ainsi, le chiffre des units vaut 1 si et seulement si un et un seul des deux bits additionns est gal
1 : il sagit de lopration boolenne XOR. De mme, le chiffre des 2-aines est gal 1 si et seulement
si les deux bits sont tous deux gaux 1 : il sagit de lopration boolenne AND. Ainsi, on obtient le
bit en cours sous forme dune opration boolenne, ainsi quun bit de retenue, sous forme dune autre
opration boolenne, ces deux oprations tant directement donnes par lutilisation de portes logiques
lmentaires.
Nous obtenons ainsi le schma dun demi-additionneur, additionnant deux bits x et y, et renvoyant un
bit de somme et un bit de retenue :

54

CHAPITRE 2. MATRIEL ET LOGICIELS


x
XOR

AND

Somme

Retenue

Nous voyons ds lors comment faire pour sommer des nombres de 2 bits x1 x0 et y1 y0 , en donnant le
rsultat sous forme dun nombre deux bits z1 z0 , et dune retenue r1 (figure 2.5)
x0
z0

XOR

y0

AND

r0
z1

XOR

x1

AND
XOR

y1

OR

r1

AND

Figure 2.5 Schma logique dun additionneur 2 bits


On comprend alors comment continuer en branchant en srie des demi-additionneurs sur le mme principe,
de sorte obtenir un additionneur sur n bits. Remarquez quon obtiendra au bout un bit de retenue, qui
donner la validit du rsultat : si le rsultat ne reste pas dans lintervalle dentiers considr (donn par
le nombre de bits), la retenue va valoir 1. Si elle vaut 0 en revanche, cest quil ny a pas de dpassement
de capacit.

III.3

Dcodeurs dadresse

Dfinition 2.3.2 (Dcodeur dadresses)


Un dcodeur dadresses sur n bits est un assemblage lectronique n entres et 2n sorties, qui pour un
signal dentre (a0 , , an1 ) {0, 1}n ressort une impulsion uniquement sur la ligne de sortie dont la
numrotation correspond au nombre n1 . . . a1 a0 2 . Typiquement, lentre correspond au codage dune
adresse, la sortie correspond la slection de cette adresse parmi toutes les adresses possibles.
Nous nous contentons de dcrire comment on peut construire des dcodeurs dadresses sur un petit nombre
de bits laide de portes logiques.
Dcodeur dadresses 1 bit

III

Circuits logiques

55

Nous disposons dune entre a0 et de deux sorties s0 et s1 . La description qui prcde amne le tableau
de vrit suivant pour le dcodeur dadresse :
Entre
a0
0
1

Sortie
s0 s1
1 0
0 1

La sortie s0 correspond non-a0 et s1 correspond a0 . On obtient donc le circuit logique 2.6, ralisant
le dcodeur dadresses sur 1 bit.
s0

NOT

a0
s1
Figure 2.6 Dcodeur dadresses sur 1 bit
Dcodeur dadresses sur 2 bits
La table de vrit du dcodeur dadresses sur 2 bits est :
Entre
a0 a1
0
0
0
1
1
0
1
1

s0
1
0
0
0

Sortie
s1 s2
0
0
1
0
0
1
0
0

s3
0
0
0
1

On constate que :
s0 = a0 a1 ,

s1 = a0 a1 ,

s2 = a0 a1 ,

s3 = a0 a1 .

On obtient alors le circuit du dcodeur dadresses sur 2 bits de la figure 2.7


Dcodeur dadresses sur n bits
De faon plus gnrale, on duplique chaque entre, en appiquant une porte NOT lune des deux branches,
puis on applique une porte AND ( n entres) toutes les slections dune des deux branches pour chacune
des n entres. Cela selectionne une unique sortie pour chacune des 2n entres possibles. En numrotant
ces sorties de faon convenable, on obtient le dcodeur dadresse voulu.
Ce circuit ncessite 2n portes AND n entres. Chacune de ces portes est elle-mme ralisable laide
de n 1 portes AND 2 entres (appliques en cascade). On peut gagner en nombre de portes logiques
en factorisant les oprations boolennes, ce quon illustre par la figure 2.8, pour un dcodeur sur 3 bits.
On peut noter quon peut obtenir des circuits de plus petite profondeur (nombre de composantes en
srie), donc plus performants, en utilisant un branchement du type diviser pour rgner pour raliser
les portes AND n entres, mais cela augmente le nombre de composantes ncessaires. Comme souvent,
il faut trouver le bon compromis entre cot et performance.

III.4

Circuits bascules et mmoires

Nous tudions dans ce paragraphe comment les portes logiques peuvent tre utilises en vue de mmoriser
de linformation, grce aux proprits des circuits-bascule, aussi appels circuits bistables.
Le schma lmentaire la base de ces mmoires est celui de la bascule RS minimale, dans lequel on
utilise deux portes AND dont les sorties sont branches sur une entre de lautre.

56

CHAPITRE 2. MATRIEL ET LOGICIELS

AND

s0

NOT

a0
AND

NOT
AND

s1

s2

a1

AND

s3

Figure 2.7 Dcodeur dadresses sur 2 bits

Dfinition 2.3.3 (Bascule RS minimale)


Le circuit bascule RS minimale, est le circuit dont le schma lectronique est le suivant :
R

(reset)

NOR

NOR

Q
(set)
Il sera not par le schma suivant :
R

Le principe de la bascule est le suivant :


R et S ne peuvent pas prendre simultanment la valeur 1 (valeur interdite)
Les deux sorties ne peuvent pas tre simultanment gales 0 (cela ncessiterait que les deux
entres soient gales 1), ni toutes deux gales 1 (si lune est gale 1, par dfinition dune
porte NOR, la seconde vaut 0). Ainsi, les deux sorties sont complmentaires (Q et Q).
Si R = S = 0, les deux positions Q = 0 et Q = 1 sont possibles (stables)

III

Circuits logiques

57

AND

AND

AND

AND

AND

AND

AND

AND

s0

NOT

a0

NOT

s1

s2

a1

s3

NOT

a2

AND

AND

AND

AND

s4

s5

s6

s7

Figure 2.8 Dcodeur dadresses sur 3 bits

Si R = 1, Q prend ncessairement la valeur 0 (bouton reset pour remettre 0)


Si S = 1, Q prend ncessairement la valeur 0, donc Q la valeur 1 (bouton set , pour mettre la
valeur 1)
Ainsi, une impulsion sur lentre R ou S permet de donner une valeur Q, puis, en absence dautre
impulsion, la valeur de Q reste inchange. On a donc mmoris une valeur.
Pour que les mises jour se fassent uniquement lors des signaux dhorloge, on peut brancher le signal
dhorloge sur chacune des 2 entres avec une porte AND. Ainsi, la bascule ne peut pas recevoir de signal
en labsence dun signal dhorloge :

58

CHAPITRE 2. MATRIEL ET LOGICIELS

Dfinition 2.3.4 (Bascule synchrone)


La bascule synchrone est donne par le schma suivant :
r
AND

CLK

Q
AND

On notera une bascule synchrone par le schma :


R

CLK
La mmorisation dun bit D se fait alors laide du schma suivant :
Dfinition 2.3.5 (Bascule D)
Une bascule D est un dispositif lectronique dcrit par le schma suivant :

NOT

AND

(data)

(write)

Q
AND

CLK
Un tel dispositif sera not :
D

CLK
Le fonctionnement de la bascule D est alors le suivant :
En labsence dun signal W (write), les deux entres de la bascule RS sont nulles, donc la sortie Q
reste inchange.

IV

Systmes dexploitation

59

En prsence dun signal W, les entres de la bascule RS sont respectivement non-D et D. On vrifie
sans peine qu tout signal dhorloge, la sortie Q sera gale lentre D.
Ainsi :
Proposition 2.3.6 (Fonctionnement dune bascule D)
Envoyer une donne D accompagne de linstruction dcriture W enregistre la donne D dans Q. Cette
donne ne sera pas modifie tant quil ny aura pas dautre signal dcriture.
Nous donnons en figure 2.9 le schma des circuits-mmoire (registres), bass sur lutilisation des bascules D.
a0

an1

a1

...
W
CLK

CLK

CLK

CLK

W
R
AND

s1

AND

AND

s0

...

sn1

Figure 2.9 Schma dun registre n bits


Lorsque le signal dcriture W est donn, de faon synchrone, les bits a0 , . . . , an1 sont enregistrs par
les n bascules D, jusquau prochain signal dcriture. La ligne R (lecture) permet en cas de signal sur
cette ligne (signal de lecture) de sortir en s0 , . . . , sn1 les valeurs mmorises par les bascules D lors du
dernier enregistrement (sans signal de lecture, ces sorties sont nulles).
Ainsi, W est la ligne commandant lcriture, R est la ligne commandant la lecture des donnes.

IV
IV.1

Systmes dexploitation
Quest-ce quun systme dexploitation ?

Dfinition 2.4.1 (Systme dexploitation)


Un systme dexploitation est un ensemble de programmes permettant de grer de faon conviviale et
efficace les ressources de lordinateur. Il ralise un pont entre lutilisateur et le processeur.
En particulier, le systme dexploitation :
fournit une interface la plus conviviale possible, permettant le lancement dapplications diverses
par lutilisateur ;

60

CHAPITRE 2. MATRIEL ET LOGICIELS

soccupe de linitialisation de lordinateur, ainsi que de la communication avec les priphriques ;


propose une interface simple et intuitive pour le rangement des donnes (structure arborescente
du systme de fichier) : lutilisateur na pas se soucier lui-mme de la localisation physique de ses
fichiers sur lespace mmoire, il les retrouve dans larborescence, en gnral logique et thmatique,
quil a lui-mme labore ;
gre les ressources de lordinateur.
En particulier, les systmes dexploitation actuels (parmi les plus connus, citons Linux, Windows, MacOS...) permettent lexcution simultane de plusieurs programmes, par le mme utilisateur, ou mme
par diffrents utilisateurs. Chaque utilisateur doit dans ce cas avoir la sensation davoir lordinateur pour
lui seul (machine virtuelle), ce qui ncessite une rpartition des tches assez labore.
Dfinition 2.4.2 (processus)
Un processus est une activit de lordinateur rsultant de lexcution dun programme.
On peut imaginer plusieurs modes de fonctionnement :
Les processus accdent au processeur dans lordre de leur cration, et utilisent ses ressources jusqu
leur terminaison. Ainsi, les programmes sont excuts les uns aprs les autres. Le temps de rponse
dpendra beaucoup plus de la file dattente que du temps dexcution du programme lanc. Cela
dfavorise nettement les processus courts. On peut arranger un peu le systme en donnant une
priorit plus forte aux processus courts, mais malgr tout, ce systme nest pas satisfaisant.
Mthode du tourniquet (ou balayage cyclique) : le processeur tourne entre les diffrents processus
en cours. Chaque processus accde au processeur pour un temps donn, fix lavance (le quantum),
et au bout de ce temps, cde la place au processus suivant, mme sil nest pas achev. Il accdera
de nouveau au processeur lorsque celui-ci aura fait le tour de tous les processus actifs. Certains
processus peuvent tre mis en attente sils ont besoin de donnes dautres processus pour continuer.
Mthode du tourniquet multiniveau : cest une amlioration du systme prcdent. On peut attribuer un niveau de priorit aux diffrents processus. Le processeur soccupe dabord des processus
de priorit la plus leve, par la mthode du tourniquet, puis descend petit petit les priorits.
Un processus naccde au processeur que sil ny a plus de processus en cours de niveau de priorit
plus lev.
Cest au systme dexploitation de grer ce dcoupage des processus de sorte ce que du point de vue
de lutilisateur, tout se passe comme sil tait seul, ou sil ne lanait quune tche (sur un ordinateur un
peu plus lent). videmment, le quantum doit tre assez petit pour que lutilisation dun logiciel semble
continue lutilisateur, mme si en ralit son excution est entrecoupe un grand nombre de fois. On ne
doit pas ressentir ce hchage lors de lutilisation.
Note Historique 2.4.3
Trois grands systmes dexploitation se partagent le march grand public actuellement : Windows de Microsoft,
Linux, driv de Unix, et MacOS de Apple, galement construit sur un noyau Unix. Windows est rput plus
convivial que Linux dans sa prsentation (interfaces sous forme de fentres, menus droulants etc), lutilisation
de Linux se faisant davantage laide de Shells (terminaux dinvites de lignes de commandes) : on y tape des
instructions directement en ligne de commande plutt quen utilisant la souris et des interfaces graphiques.
Les deux points de vue se dfendent, mais dans des contextes diffrents. Pour un usage tout public et non
professionnel, une interface graphique plaisante est souvent plus intuitive. Pour des utilisations plus pousses,
la possibilit dutiliser un terminal de commandes est plus efficace (rapidit de manipulation, possibilit de
scripts labors etc.), mais ncessite un apprentissage et une habitude accrus. Il faut noter dailleurs quUnix
( lorigine de Linux) a t dvelopp des fins professionnelles et industrielles, puis les distributions de Linux
se sont petit petit adaptes au grand public par lajout dinterfaces graphiques, mais restent tout de mme
tournes vers une activit professionnelle ; linverse, Windows a t dvelopp pour les ordinateurs personnels,
donc pour un usage non professionnel : sa priorit est la convivialit, de sorte rendre lutilisation de lordinateur
accessible tous. Ce nest que par la suite que Microsoft a adapt Windows des utilisations professionnelles
en entreprise. Ces deux grands systmes dexploitation ont donc eu une volution oppose qui explique un peu

IV

Systmes dexploitation

61

leur philosophie de la prsentation, mme si les diffrences de convivialit et de souplesse dutilisation tendent
samenuiser au fil des versions.

IV.2

Arborescence des fichiers

La gestion de la mmoire est un des autres grands rles du systme dexploitation, aussi bien la mmoire
vive que les mmoires de stockage. Lors de lenregistrement dun fichier, il recherche une place disponible
sur lespace mmoire de stockage (disque dur par exemple). Au fur et mesure des enregistrements et
effacements, ces espaces disponibles de stockage peuvent tre de moins en moins pratiques et de plus en
plus fragments, ce qui ncessite parfois denregistrer un mme fichier en plusieurs endroits non contigus
(fragmentation). Plus le systme est oblig de fragmenter les fichiers, plus lutilisation de ces fichiers
devient lente. Cest pourquoi il faut parfois rorganiser lensemble du disque dur, en dplaant un grand
nombre de donnes, pour regrouper ce qui va ensemble (dfragmentation). Par exemple, Windows lance
automatiquement la dfragmentation du disque dur lorsque la situation devient critique.
Une telle gestion de la mmoire, o on range les donnes l o on trouve de la place nest pas compatible
avec une utilisation humaine directe et efficace. On ne peut pas demander lutilisateur de se souvenir
que tel fichier qui lintresse est coup en 3 morceaux rangs aux adresses 1552f ab1, 5ce42663 et 4ceb5552.
Lutilisateur aurait tt fait dtre compltement perdu.
Ainsi, le systme dexploitation propose lutilisateur une interface facile : lutilisateur ordonne son espace
mmoire sa convenance sous la forme dune arborescence de dossiers (rpertoires) dans lesquels il peut
ranger des fichiers (figure 2.10). Cette arborescence doit tre construite de faon logique, et correspond
au rangement thmatique queffectuerait lutilisateur dans une armoire. Chaque noeud correspond un
dossier, chaque feuille correspond un fichier (ou un dossier vide). Le contenu dun dossier est lensemble
de ses fils et de leur contenu. Un dossier peut contenir simultanment des fichiers et dautres dossiers.
Lutilisateur peut se dplacer facilement dans son arborescence, et visualiser son contenu. Il na pas pour
cela se soucier des adresses physiques sur le disque, cest le systme dexploitation qui se charge de
cela. Dailleurs, la position dun fichier dans larborescence na pas dincidence sur ladresse physique sur
le disque : lorsquon dplace un fichier dans larborescence, on ne fait que modifier certains pointeurs
dadresse dans la description de larborescence, mais le fichier lui-mme ne change pas de place physique
sur le disque. Ainsi, dplacer un gros fichier est tout aussi rapide que dplacer un petit fichier, et quasiinstantan. Ce nest videmment pas le cas en cas de dplacement vers un autre support, ou en cas de
copie.

IV.3

Droits daccs

Avec lvolution des rseaux locaux et dinternet, la protection des fichiers est importante : il faut pouvoir
vous assurer que personne ayant accs au contenu de votre poste de travail (par exemple dans un rseau
dentreprise) ne pourra ouvrir ou excuter vos fichiers sans votre autorisation. Pour cette raison, chaque
fichier et chaque dossier sont associs des droits daccs. Ces droits se classent en 3 types :
droit de lecture (r) ;
droit dcriture (w) : un fichier en droit dcriture peut tre modifi. Attention, il est possible de
modifier des fichiers sans les ouvrir en lecture ;
droit dexcution (x).
Ces droits se comprennent intuitivement pour les fichiers. Pour un rpertoire, le droit de lecture permet
de lister son contenu, le droit dexcution permet daccder ce rpertoire, le droit dcriture permet dy
ajouter ou den supprimer des fichiers.
La gestion des droits diffre selon les systmes dexploitation. Sous Linux par exemple, on peut visualiser
les droits associs un fichier par la commande ls -l, qui liste le contenu dun rpertoire et donne
les proprits essentielles de chaque fichier. chaque fichier ou rpertoire est associ un code du type
rwxrwxrwx, certaines lettres pouvant tre remplaces par un -, lensemble tant prcd dune lettre d

62

CHAPITRE 2. MATRIEL ET LOGICIELS


Alain

Enseignement

Bureau
...

...
2013

...
macros

2014

Baseexos

... ...

Dm
...

Ds

colloscope

...
ds1

...
Exos
...

ds2

Musique
...

Photos
...

...

...

...

...

...

...

Figure 2.10 Exemple darborescence de fichiers (simplifie !)


(pour directory si cest un rpertoire), dune lettre s (si cest un lien symbolique), ou dun - (si cest un
fichier). Ce code est comprendre de la sorte :
Les lettres rwx reprsentent les droits en lecture, criture et excution respectivement.
Si le droit est accord, la lettre est apparente, sinon, elle est remplace par Le premier groupe rwx donne les droits pour lutilisateur u (le propritaire du fichier)
Le second groupe rwx donne les droits pour le groupe g (dfini par lingnieur systme : une
entreprise peut se diviser en plusieurs entits ; le groupe est lentit dans laquelle se trouve le
propritaire du fichier)
Le troisime groupe rwx donne les droits pour les autres o.
root possde tous les droits.

Le propritaire dun fichier peut modifier les droits de ses fichiers. Pour des raisons historiques, ces
modifications sont moins accessibles sous Windows que sous Linux, mais restent possibles. Sous Linux,
il suffit dutiliser la commande chmod, puis prciser en paramtre la ou les lettre(s) associe(s) au(x)
groupe(s) et les lettres associes aux droits quon veut ajouter (avec +) ou supprimer (avec -). Par
exemple :
chmod go-r exemple.txt
supprime les droits de lecture pour les membres du groupe et pour les autres utilisateurs.
La fonction chmod peut aussi sutiliser en transcrivant les droits en binaire : les droits de chaque groupe
fournissent un nombre binaire de 3 chiffres (0 pour un droit non accord, 1 pour un droit accord). Il
sagit donc dun nombre entre 0 et 7. Ainsi, la donne dun nombre 3 chiffres compris entre 0 et 7 (donc
en base 8) suffit dcrire lensemble des droits. On peut utiliser ce nombre directement en paramtre de
chmod pour redfinir entirement les droits. Par exemple
chmod 640 exemple.txt
attribuera les droits rw-r-----.

Langages de programmation

V
V.1

63

Langages de programmation
Quest-ce quun langage de programmation ?

Le langage machine, cest--dire le code binaire compris par le processeur, est assez peu accessible au
commun des mortels. Sil fallait communiquer avec le processeur directement ainsi, seule une lite trs
restreinte pourrait faire de la programmation, dautant plus que chaque processeur a son propre langage
machine.
Un langage de programmation est un langage qui se place gnralement un niveau plus comprhensible
par lhumain lambda, permettant, dans une syntaxe stricte, de dcrire un algorithme par la donne dune
succession dinstructions (des ordres). Cette succession dinstructions sera ensuite traduite en langage
machine par un programme spcifique (le compilateur ou linterprteur).
Ainsi, un langage de programmation est voir comme un langage intermdiaire permettant de communiquer indirectement avec le cur opratoire de lordinateur.
Nous utiliserons cette anne le langage de programmation Python, dans sa troisime version.

V.2

Niveau de langage

Comme vous le savez, il existe un grand nombre de langages de programmation. Pourquoi une telle
varit ? Pourquoi certaines personnes ne jurent-elles que par un langage en particulier ? Y a-t-il rellement
des diffrences fondamentales entre les diffrents langages ?
La rponse est OUI, de plusieurs points de vue. Nous abordons 3 de ces points de vue dans les 3 paragraphes qui viennent.
Le premier point de vue est celui du niveau (dabstraction) de langage. Il sagit essentiellement
de savoir quel point le langage de programmation sloigne du langage machine et des contraintes
organisationnelles de la mmoire et des priphriques qui lui sont lies pour sapprocher du langage
humain et saffranchir de la gestion de laccessoire pour se concentrer sur laspect algorithmique :
Un langage de bas niveau est un langage restant proche des contraintes de la machine ; le but est
davantage la recherche de lefficacit par une gestion pense et raisonne des ressources (mmoire,
priphrique...), au dtriment du confort de programmation. Parmi les langages de bas niveau, on
peut citer Assembleur ou C.
Un langage de haut niveau est un langage sapprochant davantage du langage humain, et
dgageant la programmation de toutes les contraintes matrielles qui sont gres automatiquement
(mmoire, priphriques...). Lintrt principal est un confort de programmation et la possibilit
de se concentrer sur laspect algorithmique. En revanche, on y perd ncessairement en efficacit :
la gestion automatique des ressources ne permet pas de grer de faon efficace toutes les situations
particulires.
Ainsi, dans la vie pratique, les langages de haut niveau sont largement suffisants en gnral. Cest le cas
en particulier pour la plupart des applications mathmatiques, physiques ou techniques, pour lesquelles
le temps de rponse est suffisamment court, et qui sont amenes tre utilises lunit et non de faon
rpte.
videmment, ds que lenjeu de la rapidit intervient (calculs longs, par exemple dans les problmes de
cryptographie, ou encore besoin de ractivit dun systme, donc pour tout ce qui concerne la programmation lie aux systmes dexploitations, embarqus ou non), il est prfrable dadopter un langage de
plus bas niveau.
Il est frquent dans des contextes industriels lis lefficacit de systmes embarqus, que le prototypage
se fasse sur un langage de haut niveau (travail des algorithmiciens), puis soit traduit en un langage de
bas niveau (travail des programmeurs), souvent en C.

64

CHAPITRE 2. MATRIEL ET LOGICIELS

Python est un langage de trs haut niveau dabstration. Sa philosophie est de dgager lutilisateur de
toute containte matrielle, et mme de se placer un niveau o la plupart des algorithmes classiques (tri,
recherche de motifs, algorithmes de calcul numrique...) sont dj implments. Ainsi, Python propose
un certain nombre de modules complmentaires facultatifs, proposant chacun un certain nombre doutils
algorithmiques dans un domaine prcis. Python se place donc dlibrment un niveau o une grande
partie de la technique est cache.
Cela fournit un grand confort et une grande facilit de programmation, mais une matrise moins parfaite
des cots des algorithmes utilisant des fonctions prdfinies.

V.3

Interprtation et compilation

Une autre grande diffrence entre les langages de programmation est la faon dont ils sont traduits en
langage machine. Cest lors de cette traduction quest rajoute toute la gestion de la basse-besogne dont
on stait dispens pour un programme de haut-niveau. Ainsi, cette traduction est dautant plus complexe
que le langage est de haut-niveau.
Il existe essentiellement deux types de traduction :
La compilation. Elle consiste traduire entirement un langage de haut niveau en un langage
de bas niveau (souvent en Assembleur), ou directement en langage machine (mais cela cre des
problmes de portabilit dune machine une autre). Le programme charg de faire cette traduction
sappelle le compilateur, et est fourni avec le langage de programmation. Le compilateur prend
en argument le code initial, et retourne en sortie un nouveau fichier (le programme compil),
directement exploitable (ou presque) par lordinateur.
Avantages : une fois la compilation effectue, le traitement par lordinateur est plus rapide (il
repart de la source compile). Cest donc intressant pour un programme finalis, vou tre
utilis souvent.
Inconvnients : Lors du dveloppement, la compilation peut tre lente, et ncessite que le
programme soit syntaxiquement complet : elle ncessite donc de programmer tape entire par
tape entire, sans pouvoir faire de vrifications intermdiaires.
Linterprtation. Contrairement la compilation, il ne sagit pas de la conversion en un autre
programme, mais dune excution dynamique. Lexcution est effectue directement partir du
fichier source : linterprteur lit les instructions les unes aprs les autres, et envoie au fur et
mesure sa traduction au processeur.
Avantages : il est inutile davoir un programme complet pour commencer lexcuter et voir
son comportement. Par ailleurs, les environnements de programmation associs ces langages
permettent souvent la localisation dynamique des erreurs de syntaxes (le script est interprt
et valid au moment-mme o il est crit). Enfin, lexcution dynamique est compatible avec
une excution en console, instruction par instruction. Cest un atout majeur, notamment pour
vrifier la syntaxe dutilisation et le comportement dune instruction prcise. De plus, les essais
effectus lors de llaboration du programme sont plus rapides (ne ncessitent pas la lourdeur
dune compilation chaque nouvel essai).
Inconvnients : Le programme finalis est plus lent lexcution, puisque la traduction part
toujours du code initial, lointain du programme machine.
Python est un langage interprt, semi-compil. On peut ainsi bnficier dune utilisation en console,
ainsi que, suivant les environnements, dune dtection dynamique des erreurs de syntaxe. En revanche,
lexcution du programme commence par une compilation partielle, ncessitant une syntaxe complte.

V.4

Paradigmes de programmation

Un paradigme de programmation est un style de programmation dterminant de quelle manire et sous


quelle forme le programmeur manipule des donnes et donne des instructions. Il sagit en quelque sorte

Langages de programmation

65

de la philosophie du langage. Il existe un grand nombre de paradigmes de programmation. Parmi les plus
utiliss, citons les suivants :
La programmation imprative. Le programme consiste en une succession dinstructions. Lexcution dune instruction a pour consquence une modification de ltat de lordinateur. Ltat final
de lordinateur fournit le rsultat voulu.
La programmation oriente objet. On agit sur des objets (des structures de donnes). Les objets ragissent des messages extrieurs au moyen de mthodes. Ainsi, le gros de la programmation
porte sur la dfinition de mthodes associes des classes dobjets.
La programmation fonctionnelle. On ne sautorise pas les changements dtat du systme.
Ainsi, on ne fait aucune affectation. On nagit pas sur les variables mais on exprime le programme
comme un assemblage de fonctions (au sens mathmatique).
La programmation logique. Cest un paradigme bas sur les rgles de la logique formelle. Il est
notamment utilis pour les dmonstrations automatiques, ou pour lintelligence artificielle.
Python est un langage hybride, adapt plusieurs paradigmes. Essentiellement cette anne, nous utiliserons Python en tant que langage impratif et orient objet.

66

CHAPITRE 2. MATRIEL ET LOGICIELS

3
Variables informatiques
Dans ce chapitre, nous nous intressons la nature dune variable informatique, donc la structure de la
mmorisation de donnes de calcul. Nous tudions les structures de donnes composes, et nous voquons
certains problmes lis la mutabilit (anglicisme largement utilis en franais) des variables.

Notion de variable informatique

La variable est le concept fondamental de la programmation (plus prcisment de la programmation


imprative).
Dfinition 3.1.1 (Variable informatique)
Une variable est la donne de :
une localisation en mmoire, reprsente par son adresse (identifiant de la variable)
un nom donn la variable pour la commodit dutilisation (appels, affectations)
Ainsi, une variable est voir comme une correspondance entre un nom et un emplacement en mmoire.
Une variable x va pointer vers un certain emplacement en mmoire, en lequel il pourra tre stock des
choses.
Dfinition 3.1.2 (Contenu dune variable)
Le contenu dune variable est la valeur (ou lobjet) stocke lemplacement mmoire rserv la
variable. Le dchiffrage du code binaire de ce contenu dpendra du type de la variable.

Ainsi, dire quune variable x est gale ( un moment donn) 2, signifie quon a une variable, dont le
nom est x, et qu lemplacement mmoire rserv est stocke la valeur 2.
Dfinition 3.1.3 (Affectation)
Laffectation est laction consistant dfinir le contenu dune variable, cest--dire, explicitement,
stocker une valeur donne lemplacement mmoire associ.

Laffectation se fait toujours en associant (suivant une certaine syntaxe qui dpend du langage) la valeur
stocker et le nom de la variable. Ainsi, en Python la syntaxe est :
x = 3

68

CHAPITRE 3. VARIABLES INFORMATIQUES

Attention, lgalit daffectation nest pas commutative : on place le nom de la variable gauche, et la
valeur droite. Par ailleurs, il ne faut pas confondre lgalit daffectation, du test dgalit entre deux
valeurs, souvent not diffremment (par exemple, en Python, le test dgalit est not a == b).
Dfinition 3.1.4 (Lecture, ou appel)
La lecture, ou lappel dune variable est le fait daller rcuprer en mmoire le contenu dune variable,
afin de lutiliser dans une instruction.
La lecture se fait le plus souvent en donnant le nom de la variable :
>>>
>>>
2
>>>
>>>
5

a = 2
a
b = a + 3
b

Dfinition 3.1.5 (tat dune variable)


Ltat momentan dune variable est la donne de cette variable (donc son nom et son adresse) et de
son contenu.

Dfinition 3.1.6 (Type dune variable)


Les variables peuvent avoir diffrents types, prdfinis, ou quon peut dfinir. Le type reprsente la
nature du contenu (un rel, un entier, un complexe...).

Le type dtermine la taille rserver en mmoire pour la variable, ainsi que lalgorithme de traduction
de lobjet en code binaire et inversement.
Remarque 3.1.7 (Dclaration de variables)
Certains langages imposent de dclarer les variables avant de les utiliser. Cest lors de cette
dclaration que lordinateur attribue une localisation en mmoire la variable. Pour le faire, il
doit connatre le type de la variable. Ainsi, on dclare toujours une variable en prcisant son
type.
Certains langages (dont Python) dispensent lutilisateur de cette dclaration pralable des variables. Dans ce cas, un emplacement en mmoire est allou une variable lors de laffectation.
Le type (ncessaire pour savoir quelle place attribue) est dtermin automatiquement, suivant
la nature de la valeur stocke lors de cette affectation.

>>> x=3
>>> type(x)
<class int>
>>> x=3.
>>> type(x)
<class float>
>>> x=(3,4)
>>> type(x)
<class tuple>

II

Structures de donnes

69

Dfinition 3.1.8 (Typage dynamique, typage statique)


On dit quun langage de programmation a un typage statique sil impose la dclaration pralable. Dans
le cas contraire, on parle de typage dynamique.
Lattribution automatique du type peut parfois tre ambigu. Par exemple, si lutilisateur veut stocker
la valeur 3, comme indiqu plus haut, Python va le stocker sous un type entier. Mais lutilisateur pouvait
avoir envie den faire une utilisation relle. Cela est possible du fait que le type dune variable peut
changer :
>>> x = 3
>>> type(x)
<class int>
>>> x /= 2
>>> x
1.5
>>> type(x)
<class float>
La variable x est passe du type entier au type rel.
Dfinition 3.1.9 (Typage faible)
On dit quun langage a un typage faible (ou est faiblement typ) sil autorise une variable changer
de type au cours de son existence.
Ainsi, notre essai ci-dessus montre que Python est faiblement typ.
Mais physiquement, comment grer le fait quune variable relle prend plus de place en mmoire quune
variable entire ? La rponse est simple :
>>> x =3
>>> id(x)
211273705504
>>> x /= 2
>>> id(x)
140635669676560
Lemplacement de x a chang. En fait, toute affectation modifie lemplacement mmoire (donc lidentifiant) dune variable, mme si elle conserve le mme type.
Certaines mthodes modifient certaines variables en place (donc sans changement dadresse) : il ne sagit
dans ce cas pas daffectations.

II

Structures de donnes

Il est frquent de regrouper plusieurs valeurs dans une variable ayant une structure plus complexe capable
de mmoriser plusieurs valeurs selon une hirarchie dtermine, par exemple sous forme dune liste ou
dun ensemble.
Dfinition 3.2.1 (Structure de donnes, attribut)
Une structure de donnes est une organisation de la mmoire en vue de stocker un ensemble de donnes
(ntant pas ncessairement de mme type). Les donnes qui constituent la structure sont appeles
attributs.

70

CHAPITRE 3. VARIABLES INFORMATIQUES

Une structure de donnes est dtermine par la faon dont sont rangs les attributs les uns par rapport
aux autres, et la faon laquelle on accde ces donnes. Ainsi, il existe plusieurs types de structures de
donnes.
Une structure de donnes est dfinie par une classe, possdant un type (le nom de la classe, dterminant
la structure en mmoire adopter), et un ensemble de mthodes associes la classe (des fonctions
permettant de modifier dune faon ou dune autre un objet)
Dfinition 3.2.2 (Instantiation)
Une instantiation dune classe est la cration dune variable dont le type est celui de la classe. Il sagit
donc de la cration :
dun nom de variable, coupl une adresse mmoire et un type
dun contenu, ladresse mmoire en question, dont la structure de stockage dpend de la classe.
Une des structures les plus utilises est la structure de tableau (les listes de Python par exemple). Nous
lvoquons ci-dessous un peu plus en dtail.
Dfinition 3.2.3 (Structure de tableau)
Un tableau (statique) informatique est une structure de donnes squentielle (un rangement linaire
des attributs), dont tous les attributs sont de mme type. Un tableau a une taille fixe, dtermine au
moment de sa cration.
En mmoire, les diffrents attributs dun tableau sont stocks de faon contigu. Lhomognit du type
des attributs permet alors de stocker chaque attribut sur un nombre dtermin doctets. Ainsi, la place
prise en mmoire ne dpend pas du type dobjet stock, et ne risque pas de varier au cours du temps :

attr0

addr0

attr1

addr1

attr2

addr2

attr(n-2) attr(n-1)

addr(n-1)

Les donnes tant ranges de faon contigu, la connaissance de ladresse initiale addr0 dtermine compltement ladresse de dbut de lattribut i. Plus explicitement, si les donnes sont dun type ncessitant
une place N de stockage, on aura une relation du type : addr(i)= addr(0) + Ni.
Ainsi :
Proposition 3.2.4 (Complexit des oprations lmentaires sur un tableau)
(i) Laccs un lment dun tableau se fait en temps constant (ne dpendant ni de la taille du
tableau, ni de la valeur de lindice)
(ii) La recherche dun lment se fait en O(n), cest--dire au plus en un temps proportionnel la
taille du tableau (il faut parcourir tout le tableau dans lordre)
(iii) Linsertion dun lment se fait en O(n) (il faut dcaler tous les suivants, par rcritures)

II

Structures de donnes

71

(iv) La suppression dun lment se fait en O(n) (il faut dcaler aussi)
(v) La recherche de la longueur se fait en temps constant (cest une donne initiale).

On peut amliorer cette structure, en autorisant des tableaux de taille variable. On parle alors de tableaux
dynamiques.
Dfinition 3.2.5 (Tableaux dynamiques)
Un tableau dynamique est une structure de donnes squentielle de taille variable, pour des donnes
ayant toutes le mme type.

Dfinition 3.2.6 (Capacit, taille)


La capacit dun tableau est le nombre de cases momentanment disponibles en mmoire pour
le tableau
La taille dun tableau (ou la longueur) est le nombre de cases rellement utilises (les autres
tant considrs comme vides).

La capacit dun tableau dynamique peut voluer suivant les besoins ; en particulier, insrer des lments
peut faire dpasser la capacit. Dans ce cas, la capacit est double : il est donc cr un nouveau tableau
de taille double. On ne peut pas se contenter de crer les cases manquantes, car comme pour un tableau,
les cases doivent tre contigus en mmoire, et il nest pas certain que les cases suivant les cases dj
existantes soient disponibles.
Ainsi, une augmentation de capacit ncessite en principe un changement dadresse donc une rcriture
complte (on recopie les donnes). Cest pour cette raison que lorsquon augmente la capacit, on le fait
franchement (on double), quitte avoir des cases inutilise, afin de ne pas avoir faire ces rcritures
chaque opration. Cest la raison de la distinction entre capacit et taille.
La capacit et la taille du tableau sont stocks en des emplacements directement accessibles. Ainsi, n
dsignant la taille dun tableau, on peut tendre les rsultats obtenus pour les tableaux standards :
Proposition 3.2.7 (Complexit des oprations lmentaires sur un tableau dynamique)
(i) Laccs un lment dun tableau dynamique se fait en temps constant (ne dpendant ni de la
taille du tableau, ni de la valeur de lindice)
(ii) La recherche dun lment se fait en O(n),
(iii) Linsertion dun lment se fait en O(n) (sauf lorsque cela induit un dpassement de capacit)
(iv) La suppression dun lment se fait en O(n)
(v) La recherche de la longueur se fait en temps constant (il faut juste rcuprer la donne en mmoire).

Dfinition 3.2.8 (Listes Python)


Une liste en Python est assimilable une structure de tableau dynamique, dont les attributs sont des
pointeurs (adresses) vers des emplacements mmoires o sont stockes les donnes de la liste.

Ainsi les attributs rels dune liste sont tous de mme type (des adresses), comme cela doit tre le cas
pour un tableau. Mais les objets cibles (quon appellera aussi attributs par abus, ou donnes) peuvent
tre de type quelconque, et diffrents les uns des autres.
Par exemple, crons la liste suivante :

72

CHAPITRE 3. VARIABLES INFORMATIQUES

>>> liste = [42,bestial,{phi,pi}]


>>> id(liste)
139889451112064
>>> id(liste[0])
211273706752
>>> id(liste[1])
139889451291456
>>> id(liste[2])
139889451200824
>>> type(liste[0])
<class int>
>>> type(liste[1])
<class str>
>>> type(liste[2])
<class set>
La structure de cette liste en mmoire sera donc :

attr0:
211273706752

42

attr1:

attr2:

139889451291456 139889451200824

bestial

{phi,pi}

Plus gnralement, on aura une structure en mmoire du type suivant :

liste
addr0

addr1

addr(n-2) addr(n-1)

data0

data1

data(n-2) data(n-1)

addr

Remarque 3.2.9
Cela ne correspond pas la terminologie adopte dans beaucoup dautres langages, ou une liste possde
une structure diffrente (liste chane, ou doublement chane) : dans une structure de ce type, les
donnes ne sont pas ncessairement stockes de faon contigu. lemplacement de la donne k, on
trouve la donne mmoriser, ainsi que ladresse de la donne de rang k + 1 (cest le chanage), et
ventuellement de rang k 1 (en cas de double-chanage). La donne intiale de la liste est ladresse

III

Mutabilit; cas des listes

73

du premier terme. Ainsi, pour accder au k-ime lment, on est oblig de parcourir tous les premiers
lments de la liste, en suivant les liens successifs : laccs un lment nest plus en temps constant ; ni
le calcul de la longueur qui ncessite de parcourir toute la liste. En revanche, linsertion et la suppression
se font en temps constant (une fois la position repre).

Nous restons assez vagues sur la structure densemble qui est plutt du ressort du programme doption.
Dfinition 3.2.10 (Structure densemble, set)
Un ensemble informatique est une structure de donnes, donc les attributs sont stocks un emplacement en mmoire dpendant de leur valeur (plus rigoureusement, un ensemble est une structure
arborescente).

Le positionnement en mmoire en fonction de la valeur donne une structure non ordonne (les lments ne
sont pas rangs dans un certain ordre), pour lequel le test dappartenance se fait en temps quasi-constant
en cherchant une valeur la place o elle doit tre (il sagit dun temps logarithmique en fait, car on doit
explorer un arbre le long dune branche)
En Python, les ensembles sont du type set, et reprsents entre accolades : {1,2,3} par exemple.

III

Mutabilit ; cas des listes

Dfinition 3.3.1 (Mutabilit)


Un type dobjets est dit mutable si les objets de ce type sont modifiables (sans changement dadresse,
donc pas sous forme dune raffectation). Il est dit non mutable ou immuable sinon.

>>> liste = [1,2]


>>> id(liste)
140098803414224
>>> liste[1]+=1
>>> liste
[1, 3]
>>> id(liste)
140098803414224
>>> couple = (1,2)
>>> couple[1]+=1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: tuple object does not support item assignment
Lexemple ci-dessus montre que les listes sont mutables : on peut changer leurs attributs, sans changer
ladresse de la liste elle-mme. En revanche, les tuples ne semblent pas mutables.
Exemple 3.3.2 (Mutabilit des principales classes en Python)
Les list et les set sont mutables.
Les types numriques (int, float, boolean, complex...), les tuples, les str (chanes de caractres) ne sont pas mutables.

Voyons quel est leffet de la modification sur les attributs rels de la liste, donc sur ladresse des donnes :

74

CHAPITRE 3. VARIABLES INFORMATIQUES

>>> liste = [1,2]


>>> id(liste[0])
211273705440
>>> id(liste[1])
211273705472
>>> liste[1]+=1
>>> id(liste[1])
211273705504
Ainsi, comme toute raffectation sur une variable, lopration effectue sur la donne modifie son adresse
(en fait, les types numriques sont non mutables). Cette nouvelle adresse est stocke dans la liste.
Une affectation sur un des attributs peut donc tre reprsent de la faon suivante :

data1

liste
addr0

addr1
addr1

addr(n-2) addr(n-1)

data0

data1

data(n-2) data(n-1)

addr

Intressons-nous maintenant la copie de listes. Pour commencer, tudions ce quil se passe quand on
copie un entier, et quon modifie une des deux copies :
>>> a = 1
>>> b = a
>>> id(a)
211273705440
>>> id(b)
211273705440
>>> a += 1
>>> a
2
>>> b
1
>>> id(a)
211273705472
>>> id(b)
211273705440
Au moment de la copie, la donne na pas t recopie : il a t cr une variable b pointant vers la
mme adresse que a. Ainsi, la donne nest stocke quune fois en mmoire. La modification de a par

III

Mutabilit ; cas des listes

75

raffectation se fait avec modification dadresse, donc avec copie ailleurs du rsultat. Comme b pointe
toujours vers lancienne adresse, le contenu de b nest pas modifi. Cela peut se reprsenter ainsi :

data
a
addr
addr
data
b
addr
De faon gnrale, on a toujours indpendance entre une variable et sa copie lorsquon travaille avec un
objet non mutable (car toute modification se fait avec changement dadresse).
Voyons maintenant ce quil en est des listes. En particulier, que se passe-t-il sur une copie dune liste
lorsquon modifie un attribut de la liste initiale ?
>>> listeA=[1,2,3]
>>> listeB = listeA
>>> id(listeA)
140293216095552
>>> id(listeB)
140293216095552
>>> listeA[1]+=2
>>> listeA
[1, 4, 3]
>>> listeB
[1, 4, 3]
Les modifications faites sur la liste initiale sont aussi visibles sur la copie ! Ainsi, la copie nest pas du
tout indpendante de loriginal. Ceci sexplique bien par le diagramme suivant :

data1
listeA
addr
addr0

addr1
addr1

addr(n-2) addr(n-1)

data0

data1

data(n-2) data(n-1)

listeB
addr

La modification naffecte par directement ladresse de listeA, mais une adresse dun des attributs, adresse
stocke en un espace mmoire vers lequel pointe galement listeB.

76

CHAPITRE 3. VARIABLES INFORMATIQUES

Pour rendre les copies plus indpendantes, il faut recopier les adresses des donnes ailleurs. Cela peut
se faire par exemple par un slicing (couper une tranche dune liste), qui se fait par copie des adresses en
un autre emplacement mmoire. En revanche, les donnes elles-mmes conservent la mme adresse (donc
les identifiants des attributs de listeA et listeB sont les mmes) :
>>> listeA = [1,2,3]
>>> listeB = listeA[:]
>>> id(listeA)
140379366079808
>>> id(listeB)
140379366057168
>>> id(listeA[0])
211273705440
>>> id(listeB[0])
211273705440
Modifions maintenant un attribut de listeA, et voyons leffet sur listeB :
>>> listeA[0]+=3
>>> listeA
[4, 2, 3]
>>> listeB
[1, 2, 3]
>>> id(listeA[0])
211273705536
>>> id(listeB[0])
211273705440
Cette fois, la modification nest pas faite sur listeB. Ceci sexplique aisment par le diagramme suivant :

data1

listeA
addr0

addr1
addr1

addr(n-2) addr(n-1)

data0

data1

data(n-2) data(n-1)

addr0

addr1

addr(n-2) addr(n-1)

addrA

listeB
addrB

Mais cela ne rgle pas entirement le problme. En effet, si les donnes elles-mmes sont mutables, elles
peuvent tre modifies sans changement dadresse. Dans ce cas, la copie pointe encore vers la mme
adresse que lobjet modifi : la modification est nouveau visible sur la copie. Nous illustrons cela dans
le cas o un des attributs est une liste :

III

Mutabilit ; cas des listes

>>>
>>>
>>>
>>>
[1,
>>>
[1,

77

listeA=[1,[phi,theta],3]
listeB = listeA[:]
listeA[1][1] = pi
listeA
[phi, pi], 3]
listeB
[phi, pi], 3]

Cela sillustre par le diagramme suivant :


listeA
addr0

addr1

addr2

addrA

addr10

addr11
addr11

phi

theta

pi

listeB
addr0

addr1

addr2

addrB
Pour rgler compltement le problme, on peut faire une copie rcursive, qui va explorer la liste en profondeur, afin de recopier des adresses diffrentes les sous-listes, sous-sous-listes etc. Une copie rcursive
se fait avec la fonction deepcopy disponible dans le module copy :
>>>
>>>
>>>
>>>
>>>
[1,
>>>
[1,

listeA = [1, [phi,theta],3]


import copy
listeB = copy.deepcopy(listeA)
listeA[1][1] = pi
listeA
[phi, pi], 3]
listeB
[phi, theta], 3]

Ainsi, loriginal et la copie sont compltement indpendants.

78

CHAPITRE 3. VARIABLES INFORMATIQUES

4
Algorithmique lmentaire
Dans ce chapitre, nous introduisons les concepts lmentaires de lalgorithmique. Nous revoyons tout
dabord les structures lmentaires partir desquelles sont construits tous les algorithmes crits dans un
langage impratif. Ces structures ont dj t introduites au cours du chapitre 1 dans le cadre de Python.
Nous tudions ensuite des mthodes dtude de ces algorithmes, notamment ltude de la terminaison (le
fait que lalgorithme sarrte, autrement dit quil finisse par renvoyer un rsultat), de la correction (le fait
que le rsultat renvoy est bien le rsultat attendu), et enfin de la complexit, tude que nous repoussons
au chapitre suivant.

I
I.1

Algorithmes
Dfinition

Le mot Algorithme vient du nom du mathmaticien arabe Al Khwarizmi, auteur au IXe sicle dun ouvrage faisant la synthse de la rsolution des quations du second degr, suivant le signe des coefficients
(afin dviter lusage du signe moins). Louvrage en question, proposant des mthodes de rsolution par
manipulations algbriques (rduction des formes connues) a donn son nom lalgbre. Les mthodes
exposes peuvent sapparenter des algorithmes : on y expose, par disjonction de cas (structure conditionnelle) des faons systmatiques de rsoudre un certain problme, ne laissant ainsi rien au hasard. Il
sagit bien dun algorithme de rsolution.
Dfinition 4.1.1 (Algorithme)
Un algorithme est une succession dinstructions lmentaires, faciles faire et non ambigus, dtermines de faon unique par les donnes initiales, et fournissant la rponse un problme pos.
Le dveloppement de linformatique a marqu lessor de lalgorithmique, mais cette discipline nest pas
lapanage de linformatique. La notion dalgorithme est lie mathmatiquement la possibilit de rsolution systmatique dun problme, donc la notion de mthode de calcul. On trouve dans le domaine
purement mathmatique de nombreux algorithmes :
tous les algorithmes de calcul des oprations lmentaires (addition pose, multiplication pose...)
lalgorithme de la division euclidenne par diffrences successives
lalgorithme dEuclide du calcul du pgcd
lalgorithme de rsolution des quations de degr 2
lalgorithme du pivot de Gauss pour rsoudre les systmes dquations linaires, et rpondre
dautres questions dalgbre linaire.
lalgorithme de Hrner pour lvaluation dun polynme
etc.

80

CHAPITRE 4. ALGORITHMIQUE LMENTAIRE

Les questions quon peut se poser sont alors les suivantes :


1. Quelles sont les structures lmentaires partir desquelles sont construits les algorithmes.
2. Lalgorithme sarrte-t-il ? (problme de la terminaison)
3. Lalgorithme renvoie-t-il le rsultat attendu ? (problme de la correction)
4. Combien de temps dure lexcution de lalgorithme, notamment lorsquon le lance sur de grandes
donnes ? (problme de la complexit).

I.2

Le langage

Ltude algorithmique formelle ncessite de se dgager de toute contrainte idiomatique relevant des spcificits de tel ou tel langage. Pour cela, nous utiliserons un pseudo-code, indpendant de toute implmentation. Les traductions ultrieures dans un langage de programmation spcifique se font alors sans
difficult, sachant que certains langages offrent parfois certaines possibilits supplmentaires (qui sont
essentiellement du confort, mais najoutent rien la description formelle des algorithmes, comme par
exemple le fait de pouvoir construire une boucle for sur un objet itrable queconque en Python).
Nous dcrirons systmatiquement un algorithme en :
1. lui donnant un nom ;
2. dfinissant les donnes initiales (variables dentre, prciser leur type) ;
3. dfinissant la sortie (variables de rsultat, prciser leur type) ;
4. donnant le bloc dinstructions dfinissant lalgorithme.
La structure gnrale est donc la suivante :
Algorithme 4.1 : Nom ou description de lalgorithme
Entre : a,b,... : type
Sortie : c,d,... : type
instructions ;
renvoyer (c, d,...)
La dernire ligne, permet de dfinir le ou les rsultats.

I.3

Les structures lmentaires

Un algorithme repose sur certains types dinstructions lmentaires. Une instruction est une phrase du
langage de programmation indiquant lordinateur une ou plusieurs actions effectuer, induisant un
changement dtat de lordinateur (cest--dire une modification de la mmoire).
Les diffrentes structures lmentaires partir desquelles sont contruits les algorithmes en programmation
imprative sont, en plus de lvaluation dexpressions, de lutilisation de fonctions antrieures, et de
laffectation (note x valeur) :
1. La squence :

Il sagit dun regroupement dinstructions lmentaires, qui seront excutes successivement. Il


sagit de la notion de bloc en informatique, dlimit suivant les langages par des balises de dbut
et fin (begin, end), ou tout simplement par lindentation, comme en Python.
Lintrt de la squence est de pouvoir considrer plusieurs instructions comme une seule, et de
pouvoir inclure cette succession dans des structures plus complexes (structures conditionnelles,
rptitives...)
Nous crirons un bloc de la faon dcrite dans lalgorithme 2.
La plupart du temps, un bloc permettra de dlimiter la porte dune structure compose. Dans ce
cas, le mot bloc sera remplac par le mot cl de la structure correspondante, par exemple dbut
pour et fin pour.

Algorithmes

81

Algorithme 4.2 : Bloc


dbut bloc
instructions
fin bloc

2. La structure conditionnelle simple :


Cest la structure permettant deffectuer des disjonctions de cas. Elle permet de distinguer plusieurs
cas si ces cas ncessitent des modes opratoires diffrents. Cela permet galement de traiter les cas
particuliers.
La structure basique est un branchement deux issues :
si condition alors instructions sinon instructions
La condition peut tre nimporte quel boolen, par exemple le rsultat dun test, ou le contenu
dune variable de type boolen. De plus, la clause alternative (else) est le plus souvent facultative
(algorithmes 3 et 4).
Algorithme 4.3 : Structure conditionnelle simple sans clause alternative
Entre : classe : entier
Sortie :
si classe = 4 alors
Afficher(Bestial ! )
fin si

Algorithme 4.4 : Structure conditionnelle simple avec clause alternative


Entre : classe : entier
Sortie :
si classe = 4 alors
Afficher(Bestial ! )
sinon
Afficher(Khrass )
fin si
Certains langages autorisent le branchement multiple, soit via une autre instruction (par exemple
case of en Pascal), soit comme surcouche de linstruction basique. Nous utiliserons cette possibilit en pseudo-code (algorithme 5).
Algorithme 4.5 : Structure conditionnelle multiple
Entre : classe : entier
Sortie :
si classe = 4 alors
Afficher(Bestial ! )
sinon si classe = 3 alors
Afficher(Skiii ! )
sinon
Afficher(Khrass )
fin si
videmment, dun point de vue de la compltion du langage, cette possibilit napporte rien de
neuf, puisquelle est quivalente un embotement de structures conditionnelles (algorithme 6).

82

CHAPITRE 4. ALGORITHMIQUE LMENTAIRE

Algorithme 4.6 : Version quivalente


Entre : classe : entier
Sortie :
si classe = 4 alors
Afficher(Bestial ! )
sinon
si classe = 3 alors
Afficher(Skiii ! )
sinon
Afficher(Khrass )
fin si
fin si

3. Les boucles
Une boucle est une succession dinstructions, rpte un certain nombre de fois. Le nombre de
passages dans la boucle peut tre dtermin lavance, ou peut dpendre dune condition vrifie
en cours dexcution. Cela permet de distinguer plusieurs types de boucles :
(a) Boucles conditionnelles, avec condition de continuation.
On passe dans la boucle tant quune certaine condition est ralise. Le test de la condition est
ralis avant le passage dans la boucle. On utilise pour cela une boucle while ou tant que en
franais. Voici un exemple :
Algorithme 4.7 : Que fait cet algorithme ?
Entre : (marge derreur) : rel
Sortie :
u1;
tant que u > faire
u sin(u)
fin tant que

Ici, on calcule les termes dune suite dfinie par la rcurrence un+1 = sin(un ). On peut montrer
facilement que cette suite tend vers 0. On rpte litration de la suite (donc le calcul des termes
successifs) tant que les valeurs restent suprieures .
Comme dans lexemple ci-dessus, une boucle while sutilise le plus souvent lorsquon ne connat
pas lavance le nombre de passages dans la boucle. Souvent dailleurs, cest le nombre de
passages dans la boucle qui nous intresse (afin, dans lexemple ci-dessus, destimer la vitesse
de convergence de la suite). Dans ce cas, il faut rajouter un compteur de passages dans la
boucle, cest--dire une variable qui sincrmente chaque passage dans la boucle. Cest ce que
nous avons fait dans lalgorithme 8.
La valeur finale de i nous dit maintenant jusqu quel rang de la suite il faut aller pour obtenir
la premire valeur infrieure (et par dcroissance, facile montrer, toutes les suivantes
vrifieront la mme ingalit).
(b) Boucles conditionnelles, avec condition darrt
Il sagit essentiellement de la mme chose, mais exprim de faon lgrement diffrente. Ici,
on rpte la srie dinstructions jusqu la ralisation dune certaine condition. Il sagit de la
boucle repeat... until..., ou rpter... jusqu ce que..., en franais. Lalgorithme
prcdent peut se rcrire de la faon suivante, de faon quasi-quivalente, laide dune boucle
repeat... until... (algorithme 9

Algorithmes

83

Algorithme 4.8 : Calcul de i tel que ui 6


Entre : (marge derreur) : rel
Sortie : i : entier
u1;
i0;
tant que u > faire
u sin(u) ;
i i+1
fin tant que
renvoyer i
Algorithme 4.9 : Vitesse de convergence de un
Entre : (marge derreur) : rel
Sortie : i (rang tel que ui 6 ) : entier
u1;
i0;
rpter
u sin(u) ;
ii+1
jusqu ce que u 6 ;
renvoyer i;

La diffrence essentielle avec une boucle while est que, contrairement une boucle while,
on passe ncessairement au moins une fois dans la boucle. part ce dtail, on a quivalence
entre les deux structures, en remplaant la condition de continuation par une condition darrt
(par ngation). Ainsi, une boucle repeat instructions until condition est quivalente
la structure donne en algorithme 10.
Algorithme 4.10 : Structure quivalente repeat... until... : version 1
instructions ;
tant que condition faire
instructions
fin tant que
Remarquez ici le passage forc une premire fois dans la succession dinstructions (bloc isol
avant la structure).
On peut viter la rptition de la succession dinstructions en forant le premier passage
laide dune variable boolenne (algorithme 11)
Algorithme 4.11 : Structure quivalente repeat... until... : version 2
b True ;
tant que ( condition) b faire
instructions ;
b False
fin tant que
Cela a cependant linconvnient daugmenter le nombre daffectations.
Rciproquement, une boucle while condition do instructions est quivalente la structure de lalgorithme 12.

84

CHAPITRE 4. ALGORITHMIQUE LMENTAIRE

Algorithme 4.12 : Structure quivalente while... do...


si condition alors
rpter
instructions
jusqu ce que condition;
fin si

Au vu de ces quivalences, mme si en Python, les boucles repeat nexistent pas, nous nous
autoriseront dcrire les algorithmes en utilisant cette structure, plus naturelle dans certaines
situations. Il faut cependant garder dans lesprit que dans le cadre dune dfinition formelle
dun algorithme, cela cre une redondance avec la structure while.
(c) Boucles inconditionnelles
Il sagit de boucles dont larrt ne va pas dpendre dune condition darrt teste chaque
itration. Dans cette structure, on connat par avance le nombre de passages dans la boucle.
Ainsi, on compte le nombre de passages, et on sarrte au bout du nombre souhait de passages.
Le compteur est donn par une variable incrmente automatiquement :
Algorithme 4.13 : Cri de guerre
Entre :
Sortie : cri : chane de caractres
cri besti ;
pour i 1 42 faire
cri cri +
fin pour
cri cri + l ;
renvoyer cri

I.4

Procdures, fonctions et rcursivit

Un algorithme peut faire appel des sous-algorithmes, ou procdures, qui sont des morceaux isols de
programme. Lintrt est multiple :
viter davoir crire plusieurs fois la mme squence dinstructions, si elle est utilise diffrents
endroits dun algorithme. On peut mme utiliser une mme procdure dans diffrents algorithmes
principaux.
Une procdure peut dpendre de paramtres. Cela permet dadapter une squence donne des
situations similaires sans tre totalement semblables, les diffrences entre les situations tant traduites par des valeurs diffrentes de certains paramtres.
crire des procdures permet de sortir la partie purement technique de lalgorithme principal, de
sorte dgager la structure algorithmique de ce dernier de tout encombrement. Cela augmente la
lisibilit de lalgorithme.
Une procdure peut sappeler elle-mme avec des valeurs diffrentes des paramtres (rcursivit).
Cela permet de traduire au plus prs certaines dfinitions mathmatiques par rcurrence. Cela a
un ct pratique, mais assez dangereux du point de vue de la complexit si on nest pas conscient
prcisment de ce quimplique ce quon crit.
La procdure 14 est un exemple typique de procdure : il sagit de laffichage dun polynme entr sous
forme dun tableau. Crer une procdure pour cela permet de pouvoir facilement afficher des polynmes
plusieurs reprises lors dun algorithme portant sur les polynmes, ceci sans avoir se proccuper, ni
sencombrer de la technique se cachant derrire. Dans cette procdure str est une fonction convertissant
une valeur numrique en chane de caractres.

Algorithmes

85

Procdure 4.14 : affichepolynome(T)


Entre : T : tableau reprsentant un polynme
Sortie :
ch ;
pour i Taille (T)-1 descendant 0 faire
si T [i] 6= 0 alors
si (T [i] > 0) alors
si ch 6= alors
ch ch + +
fin si
sinon
ch ch + -
fin si
si (|T [i]| 6= 1) (i = 0) alors
ch ch + str(|T [i]|);
si i 6= 0 alors
ch ch + *
fin si
fin si
si i 6= 0 alors
ch ch + X
fin si
si i > 1 alors
ch ch + + str(i)
fin si
fin si
fin pour
si ch = alors
ch 0
fin si
Afficher (ch)

Une fonction est similaire une procdure, mais renvoie en plus une valeur de sortie. En gnral, il est
conseill de faire en sorte que la seule action dune fonction soit ce retour dune valeur. En particulier, on
ne fait aucune interface avec lutilisateur : pas daffichage, ni de lecture de valeur (les valeurs utiliser
pour la fonction tant alors passes en paramtres).
La fonction 15 est une fonction simple dterminant le nombre de lettres a dans une chane de caractres :
Dfinition 4.1.2 (Rcursivit)
Une fonction est dite rcursive si elle sappelle elle-mme pour une autre valeur des paramtres. Il faut
prendre garde initialiser la rcursivit, en donnant explicitement la valeur obtenue pour certaines
valeurs des paramtres, en sassurant que ces valeurs de paramtres sont absorbantes.
La fonction 16 est une fonction rcursive pour le calcul la suite dfinie par une rcurrence simple, en
loccurrence un+1 = sin(un ), initialise par 1.
La fonction 17 est une trs mauvaise faon de calculer le n-ime terme de la suite de Fibonacci par
rcursivit. En pratique, vous calculerez plus vite la main F100 que lordinateur par la fonction cidessus. Pourquoi cet algorithme rcursif est-il si mauvais ?
Ltude de la rcursivit est du ressort du programme de Sp (ou de Sup en cours doption). Nous nous
contenterons donc cette anne dune utilisation nave de la rcursivit, tout en restant conscient des

86

CHAPITRE 4. ALGORITHMIQUE LMENTAIRE

Fonction 4.15 : comptea(ch)


Entre : ch : chane de caractres
Sortie : n : entier
n0;
pour i 0 Taille(ch) faire
si ch[i] = a alors
n n+1
fin si
fin pour
renvoyer n
Fonction 4.16 : un(n)
Entre : n : entier positif
Sortie : un(n) : rel
si n = 0 alors
renvoyer 1
sinon
renvoyer sin(un(n 1))
fin si

dangers dexplosion de complexit que cela peut amener.

II

Validit dun algorithme

Deux questions peuvent se poser pour juger de la validit dun algorithme :


Lalgorithme sarrte-t-il ? (problme de terminaison)
Lalgorithme renvoie-t-il le rsultat attendu ? (problme de correction).
Nous tudions ces deux points dans ce paragraphe. Nous donnons notamment des moyens de justifier la
terminaison et la correction dun algorithme.

II.1

Terminaison dun algorithme

Dans un algorithme non rcursif correctement structur, et sans erreur de programmation (par exemple
modification manuelle dun compteur de boucle for), les seules structures pouvant amener une non
terminaison dun algorithme sont les boucles while et repeat. Nous nvoquerons pas dans ce cours la
terminaison et la correction dun algorithme rcursif (tude se ramenant le plus souvent une rcurrence).
Pour ltude de la terminaison, partons de lexemple de lalgorithme dEuclide (algorithme 18).
La preuve mathmatique classique de la terminaison de lalgorithme dEuclide passe par le principe de
descente infinie : les restes successifs non nuls (cest--dire les valeurs successives de b) forment une
squence strictement dcroissante dentiers positifs (sauf ventuellement la premire tape si la valeur
initiale de b est ngative ; mais dans ce cas, le premier reste est positif). Le principe de descente infinie
assure alors que la squence est finie, donc que lalgorithme finit par sarrter.
Plus prcisment, si on veut couler cette preuve dans le moule de la dmonstration par descente infinie de
Fermat, on peut partir dun couple (a, b) tel que a > 0 et tel que lalgorithme dEuclide ne sarrte pas.
Alors lalgorithme dEuclide ne sarrte pas non plus pour (a , b ) = (b mod a, a), et on a 0 6 a < a. On
a donc trouv une situation similaire pour une valeur entire positive strictement plus petite de a, ce qui
amne la contradiction voulue par le principe de descente infinie.
Cet exemple est larchtype dune preuve de terminaison. On prouve la terminaison dune boucle en
exhibant un variant de boucle :

II

Validit dun algorithme

87

Fonction 4.17 : fibo(n)


Entre : n : entier positif
Sortie : fibo(n) : rel
si n = 0 alors
renvoyer 0
sinon si n = 1 alors
renvoyer 1
sinon
renvoyer fibo(n 1) + fibo(n 2)
fin si

Algorithme 4.18 : Euclide


Entre : a, b : entiers positifs
Sortie : d : entier
tant que b > 0 faire
(a, b) (b, a mod b)
fin tant que
renvoyer a

Dfinition 4.2.1 (Variant de boucle)


On appelle variant de boucle une quantit v dfinie en fonction des variables (x1 , . . . , xk ) constituant
ltat de la machine, et de n, le nombre de passages effectus dans la boucle et telle que :
v ne prenne que des valeurs entires ;
la valeur de v en entre de boucle soit toujours positive ;
v prenne des valeurs strictement dcroissantes au fur et mesure des passages dans la boucle :
ainsi, si vn dsigne la valeur de v au n-ime passage dans la boucle, si les passages n et n + 1
ont lieu, on a vn+1 < vn .

Le principe de descente infini permet alors daffirmer que :


Thorme 4.2.2 (Terminaison dune boucle, dun algorithme)
1. Si, pour une boucle donne, on peut exhiber un variant de boucle, alors le nombre de passages
dans la boucle est finie.
2. Si, pour un algorithme donn, on peut exhiber, pour toute boucle de lalgorithme, un variant de
boucle, alors lalgorithme sarrte en temps fini.

Avertissement 4.2.3
Il faut bien justifier la validit du variant de boucle pour toute valeur possible dentre.

Exemple 4.2.4
Dans le cas de lalgorithme dEuclide, un variant de boucle simple est donn simplement par la variable
a, partir du rang 1 (le premier passage permet de se ramener au cas o a > 0, ce qui nest pas
ncessairement le cas initialement).

88

CHAPITRE 4. ALGORITHMIQUE LMENTAIRE

Remarque 4.2.5 (Quarante-Deux.5)


La terminaison assure un arrt thorique de lalgorithme. En pratique, un deuxime paramtre entre en
jeu : le temps de rponse. Ce temps de rponse sans tre infini, peut tre trs grand (certains algorithmes
exponentiels peuvent avoir un temps de rponse de lordre de milliards dannes pour des donnes
raisonnablement grandes : cest le cas par exemple du calcul rcursif de la suite de Fibonacci donn
ci-dessus, pour des valeurs de n restant raisonnables). videmment dans ce cas, mme si lalgorithme
sarrte en thorie, cest dassez peu dintrt, et quand il finit par sarrter, on ne se souvient plus de
la question pose...
Nous tudirons ces problmes lis la complexit dun algorithme dans le chapitre prochain.

Remarque 4.2.6
Dans le cas dune boucle for, on peut toujours construire un variant simple. Si la boucle est donne
par la structure :
Pour i a b,
un variant simple est b i
videmment, ceci ne fait que traduire un fait intuitivement vident : le nombre de passages dans une
boucle for est videmment fini, gal au nombre de valeurs que le compteur de boucle peut prendre. Dans
la pratique, cela nous dispense dun argument de terminaison pour ce type de boucles.
En guise dexemple dvelopp, nous traitons ltude de la terminaison de lalgorithme suivant :
Algorithme 4.19 : Mystre
Entre : a,b : entiers
Sortie : q, r : entiers
ra;
q0;
si b = 0 alors
Erreur
sinon
tant que r > b faire
r rb ;
q q+1 ;
fin tant que
renvoyer q,r
fin si
Le variant de boucle est contruire partir du test de continuation de la boucle. Puisquon sarrte ds
que r b < 0, que r b prend des valeurs entires, on peut considrer la quantit v = r b.
Toutes les oprations tant entires, v est bien un entier
Par dfinition mme dune boucle while, lentre dans une boucle, la valeur de v est positive
Il reste tudier la dcroissance stricte. Si on note vn la valeur de v lentre dans la n-ime
boucle, et si on passe effectivement dans les boucles dindice n et n + 1, alors vn+1 = vn b.
ce stade, on se rend compte quil y a un problme : v est bien un variant de boucle pour une valeur
initiale de b strictement positive, mais pas pour une valeur ngative. Un petit examen de la situation
nous fait comprendre queffectivement, si b est ngatif, les valeurs de r seront de plus en plus grandes,
donc le test r > b sera de plus en plus vrai . Il y a peu de chance que lalgorithme sarrte.
Il est donc ncessaire de rectifier notre algorithme, soit en excluant les valeurs ngatives en mme temps
que la valeur nulle, soit en adaptant lalgorithme. ce stade, vous aurez bien sr compris ce que calcule

II

Validit dun algorithme

89

lalgorithme Mystre : il ne sagit de rien de plus que le quotient et le reste de la division euclidienne. Or,
ces quantits sont aussi dfinies pour b strictement ngatif, avec la petite adaptation suivant : le quotient
q et le reste r de la division euclidenne de a par b sont les uniques entiers tels que
a = bq + r

r [[0, |b| 1]].

On a fait cette adaptation dans lalgorithme 20.


Algorithme 4.20 : Division euclidienne ?
Entre : a,b : entiers
Sortie : q, r : entiers
ra;
q0;
si b = 0 alors
Erreur
sinon
tant que r > |b| faire
r r |b| ;
q q+1 ;
fin tant que
si b < 0 alors
q q
fin si
renvoyer q,r
fin si
Revenons notre preuve de terminaison. Maintenant la quantit v = r |b| est bien entire, positive
en entre de boucle (si on entre dans une boucle, dans le cas contraire, la terminaison est assure !), et
strictement dcroissante dun passage lautre dans la boucle (puisquon lui retire la quantit strictement
positive |b| chaque tape, le cas b = 0 ayant t cart initialement).
Ceci prouve la terminaison de lalgorithme 20, mais pas sa correction qui nous rserve encore des surprises.

II.2

Correction dun algorithme

La terminaison dun algorithme nassure pas que le rsultat obtenu est bien le rsultat attendu, cest-dire que lalgorithme rpond bien la question pose initialement. Ltude de la validit du rsultat
quon obtient fait lobjet de ce paragraphe. On parle de ltude de la correction de lalgorithme.
Reprenons lexemple de lalgorithme dEuclide 18. Cet algorithme a pour objet le calcul du pgcd de a et
b. La preuve mathmatique classique de la correction de lalgorithme repose sur la constatation suivante :
si r est le reste de la division euclidienne de a par b, alors a b = b r. La preuve mathmatique de ce
point ne pose pas de problme.
On constate alors que la quantit w = a b prend toujours la mme valeur lentre dune boucle
(correspondant aussi la valeur la sortie de la boucle prcdente). Cest le fait davoir une valeur
constante qui nous assure que la valeur initiale recherche a b, est gale a b pour les valeurs finales
obtenues pour a et b. Or, en sortie de boucle b = 0, donc a b = a. Ainsi, le pgcd des valeurs initiales de
a et b est gal la valeur finale de a.
De faon gnrale, ltude de la correction dun algorithme se fera par la recherche dune quantit invariante dun passage lautre dans la boucle :
Dfinition 4.2.7 (Invariant de boucle)
On appelle invariant de boucle une quantit w dpendant des variables x1 , . . . , xk en jeu ainsi ventuellement que du compteur de boucle n, telle que :

90

CHAPITRE 4. ALGORITHMIQUE LMENTAIRE

la valeur prise par w en entre ditration, ainsi que la valeur quaurait pris w en cas dentre
dans litration suivant la dernire itration effectue, soit constante.
Si le passage initial dans la boucle est index 0 et que la dernire itration effectue est indexe
n 1, lgalit w0 = wn permet de prouver que lalgorithme retourne bien la quantit souhaite.
Exemple 4.2.8
Dans le cas de lalgorithme dEuclide, la quantit w = a b est un invariant de boucle : il est constant,
et la sortie, puisque b = 0, il prend la valeur a. Ainsi, la valeur retourne par lalgorithme est bien
gal a b, pour les valeurs initiales de a et b, passes en paramtres.
tudions encore une fois le cas de lalgorithme de la division euclidenne 20. On sait que le quotient et le
reste doivent satisfaire la relation a = bq + r. Il semble donc naturel de considrer w = bq + r = |b|q + r
comme invariant de boucle, o est le signe de b (cela permet de grer le changement final de signe
effectu sur q la fin de lalgorithme). On note wk la valeur de w lentre dans litration dindice k, la
boucle initiale tant dindice 0. On note de mme qk et rk les valeurs de q et r lentre dans litration
k.
Daprs les initialisations de q et r, on a w0 = a
Si le passage dans litration k est effectu, on ajoute 1 q et on retranche |b| r. Ainsi :
wk+1 = |b|qk+1 + rk+1 = |b|(qk + 1) + rk |b| = |b|qk + rk = wk .
Ainsi, (w) est bien constant.
la sortie de structure, en appelant n lindice de la premire boucle non excute, on a rn < |b|
et donc :
wn = qn |b| + rn = qb + r,
avec r < |b|
o q et r sont les valeurs retournes (avec changement de signe ventuel). On na pas encore tout
fait rpondu au problme, puisquon doit aussi sassurer que r > 0. Cette dernire proprit peut
tre obtenue facilement si on peut justifier que rn1 > |b|. Dans ce cas, rn = rn1 |b|. On peut
aussi lobtenir facilement lorsque a [[0, |b| 1]] (dans ce cas, il ny a pas de passage dans la boucle,
et n = 0). En revanche, si r peut se retrouver avoir des valeurs ngatives, on reste coinc. Or,
cest ce quil se passe si la valeur initiale de r est ngative, donc si a 6 0.
La recherche de linvariant de boucle nous a donc permis de dtecter lerreur faite dans lalgorithme 20 :
celui nest valable que pour les valeurs positives de a. Nous pouvons donc maintenant donner une version
corrige de lalgorithme de la division euclidienne (algorithme 21)
On pourrait tout de mme regrouper les deux cas en combinant les deux tests (en se rendant compte que
dans les deux cas, on tombera forcment dans le trou ), et en grant le changement de signe par un
gal 1 et 1, mais, si cela raccourcit le code, cela augmente en revanche le nombre doprations et de
tests. Nous en resterons donc la version de lalgorithme 21.
Nous reprenons donc avec ce nouvel algorithme ltude de la terminaison et de la correction correction.
Nous avons maintenant deux boucles tudier.
1. tude de la boucle du cas a > 0 :
Ltude de la terminaison de cette boucle a dj t faite.
Nous terminons ltude de correction prcdente en constatant que si a [[0, |b| 1]], il ny a
pas de passage dans la boucle, et la valeur retourne est q = 0 et r = a [[0, |b| 1]] qui rpond
bien au problme, et que si a > |b|, il y a au moins un passage dans la boucle. Ainsi, avec les
notations prcdentes, n > 1, et rn1 > |b| (sinon on ne serait pas pass dans la boule n 1,
do rn = rn1 |b| > 0. Cela fournit donc le point qui manquait prcdemment pour conclure
que (w) est un invariant de boucle
2. tude de la boucle du cas a < 0.

II

Validit dun algorithme

91

Algorithme 4.21 : Division euclidienne, version corrige


Entre : a,b : entiers
Sortie : q, r : entiers
ra;
q0;
si b = 0 alors
Erreur
sinon
si a > 0 alors
tant que r > |b| faire
r r |b| ;
q q+1 ;
fin tant que
si b < 0 alors
q q
fin si
renvoyer q,r
sinon
tant que r < 0 faire
r r + |b| ;
q q1 ;
fin tant que
si b < 0 alors
q q
fin si
renvoyer q,r
fin si
fin si

Cette fois, r est clairement un variant de boucle assurant la terminaison (il est entier, positif
tant quon entre dans la boucle, et dcroissant puisquon ajoute r une valeur strictement
positive chaque tape)
Nous prouvons de mme que ci-dessus que w = |b|q + r est un invariant pour la boucle dans le
cas a < 0 (chaque fois quon ajoute |b| r, on retranche 1 q par compensation). la sortie
multiplie q par le signe de b, donc on a la relation
a = |b|q0 + r0 = |b|qn + rn = bq + r,
et de plus, vu le test initial, on passe au moins une fois dans la boucle, et rn1 < 0 (sinon on
ne serait pas pass dans la boucle n 1, donc rn < |b|. Comme on ne passe pas dans la boucle
n, on a de plus rn > 0. Ainsi, les valeurs finales de q et r, vrifient bien les proprits attendues
caractrisant la division, ce qui assure la correction de lalgorithme.
Retenons de cette tude que non seulement, ltude de la terminaison et de la correction dun algorithme
permet de prouver sa validit, mais que par ailleurs, cette tude permet de dtecter des erreurs dans
lalgorithme le cas chant.
Remarque 4.2.9
Un invariant de boucle peut trs bien tre un boolen, cest--dire la valeur de vrit dune proprit.
Ainsi, on peut dfinir comme invariant de boucle, le fait quune proprit P(n) dpendant du rang n
de passage dans la boucle soit toujours vraie lentre de boucle.

92

CHAPITRE 4. ALGORITHMIQUE LMENTAIRE

Algorithme 4.22 : Selection du minimum


Entre : T : tableau
Sortie : T :tableau
pour i 1 Taille (T) - 1 faire
si T [i] < T [0] alors
T [0], T [i] T [i], T [0]
fin si
fin pour

Nous illustrons cette possibilit sur lexemple suivant (algorithme 22).


La terminaison de cet algorithme ne pose pas de problme (il ny a pas de boucle repeat ou while).
Pour la correction, on se convainc sans peine que lalgorithme va rechercher la valeur minimale (ou une
des valeurs minimales) du tableau T et la placer en tte de tableau, en modifiant ventuellement lordre
des autres lments. On le prouve en considrant linvariant de boucle P(n) : lentre dans la boucle
de rang n > 1, T [0] est le minimum des T [i] pour i [[0, n 1]] .
Linvariant P(n) est vrai pour n = 1 (initialement, T [0] est le minimum du sous-tableau constitu de
lunique case T [0]), et si P(n) est vraie, alors P(n+ 1) aussi, car lentre dans la boucle n, soit T [0] est le
minimum de T [i], i [[0, n]], et il le reste alors la sortie (pas de modification faite), donc lentre dans
la boucle suivante ; soit T [0] nest pas le minimum des T [i], i [[0, n]], mais comme il est le minimum des
T [i], i [[0, n 1]], on a alors T [n] < T [0], et cest T [n] le minimum recherch. On fait alors lchange de
T [0] et T [n], ce qui place lissue de la boucle le minimum en place 0 du tableau, assurant que P(n + 1)
est vrifi.
Ainsi, P(n) est toujours vrai, par principe de rcurrence, et pour la dernire valeur de n (taille t du
tableau, cest la valeur dentre dans litration suivante, celle qui na pas lieu), on rcupre que T [0] est
le minimum des T [i], pour i [[0, t 1]], ce qui prouve la correction de lalgorithme.

Mme si le fait dutiliser un invariant qui ait lair plus compliqu que prcdemment (une proposition),
il ne sagit que dun cas particulier de la dfinition, linvariant tant ici tout simplement le boolen P(n).
Dans cette situation, montrer la correction dun algorithme se fait en 3 tapes :
initialisation : montrer que linvariant est vrai avant la premire itration.
conservation : montrer que si linvariant est vrai avant une itration, il reste vrai avant litration
suivante.
terminaison : dduire de linvariant final la proprit voulue.

III

Exercices

Exercice 1 (recherche linaire)


crire un algorithme en pseudo-code prenant en entre une liste L, et une valeur v, et donnant en sortie
un indice i tel que L[i] = v, sil en existe, et la valeur spciale NIL sinon. tudier la correction et la
terminaison de cet algorithme.

Exercice 2 (Tri bulle)


tudier la correction et la terminaison de lalgorithme 23 : Proposer une amlioration reprant lors
du passage dans la boucle interne, le plus grand indice pour lequel une inversion a t faite. Jusquo
suffit-il daller pour la boucle suivante ? tudier la correction et la terminaison du nouvel algorithme
obtenu.

III

Exercices

93

Algorithme 4.23 : Tri-bulle


Entre : T :tableau de rels, n :taille du tableau
Sortie : T : tableau tri
pour i 1 n 1 faire
pour j 1 n i faire
si T [j] < T [j 1] alors
T [j 1], T [j] T [j], T [j 1]
fin si
fin pour
fin pour

Exercice 3 (Tri par slection)


Donner le pseudo-code de lalgorithme de tri par slection consistant rechercher le minimum et
le mettre sa place, puis rechercher le deuxime lment et le mettre sa place etc. tudier la
terminaison et la correction de cet algorithme.

Exercice 4 (Exponentiation rapide)


Comprendre ce que fait lalgorithme suivant. tudier sa terminaison et sa correction. crire un algorithme rcursif dexponentiation rapide.

Algorithme 4.24 : Exponentiation rapide


Entre : x : rel, n :entier
u1;
v1;
tant que n > 1 faire
(n, b) divmod(n, 2) ;
si b = 1 alors
v vu
fin si
u u2
fin tant que
renvoyer u v

Exercice 5 (Dcomposition)
Que fait lalgorithme 25 ? Justifier sa terminaison et sa correction.

94

CHAPITRE 4. ALGORITHMIQUE LMENTAIRE

Algorithme 4.25 : Dcomposition


Entre : n : entier positif
Sortie : L : liste de couples dentier ; quoi correspond-elle ?
p2;
L [] ;

tant que p 6 n faire


i0;
tant que n mod p = 0 faire
ii+1 ;
n n/p
fin tant que
si i > 0 alors
Ajouter (p, i) la liste L
fin si
si p = 2 alors
pp+1
sinon
pp+2
fin si
fin tant que
si n > 1 alors
Ajouter (n, 1) la liste L
fin si

5
Complexit
I

Introduction

La terminaison et la correction dun algorithme ne suffisent pas juger de lutilisabilit dun algorithme.
En effet, un algorithme qui se finit en thorie, mais qui en pratique a un temps de rponse de plusieurs
annes, voire plusieurs milliards dannes, est assez inutilisable en pratique. Il est donc important de pouvoir estimer le temps de rponse dun algorithme, afin de juger de sa qualit. La recherche dalgorithmes
les plus rapides possibles dans un contexte donn est un des enjeux majeurs de linformatique.
En gnral, un algorithme donn est dautant plus lent que les donnes initiales qui lui sont fournies sont
grandes : un tableau de quelques milliards dentres est plus long trier quun tableau de 10 entres !
Nous estimerons par consquent la complexit dune algorithme comme fonction de la taille des donnes
initiales.
En gnral, les qualits dalgorithmes rpondant une mme question sont compares pour des grandes
tailles de donnes (il sagit en fait dune comparaison asymptotique, pour des donnes de taille infiniment
grande). Ainsi, on dira que certains algorithmes de tris parmi les plus rapides (le tri rapide, le tri fusion...)
sont quasi-linaires (cest--dire ont un comportement moyen de lordre de n ln(n) pour un tableau de
taille n), alors que dautres tris, comme le tri par insertion, ont une complexit quadratique (cest--dire
de lordre de n2 . Les premiers sont donc bien meilleurs que les seconds, lorsque n devient grand.
Cependant, un algorithme moins bon asymptotiquement peut tre meilleur pour des petites valeurs de
n, ce qui, suivant lutilisation quon veut en faire, peut se rvler intressant. Ainsi, le tri par insertion
est meilleur que le tri rapide pour des tableaux de petite taille.
Par consquent, ltude asymptotique de la complexit nest pas toujours suffisante ni pertinente. Tout
dpend de lutilisation quon veut faire des algorithmes. La premire chose faire est donc de bien cibler
les besoins et les conditions dutilisation. Suivant la taille des donnes traiter, on na pas toujours intrt
considrer lalgorithme rput le meilleur : il est peut-tre le meilleur dans des situations diffrentes de
celle quon a traiter.
Ltude comparative de la rapidit pour des donnes de petite taille permet dailleurs aussi parfois daugmenter considrablement la complexit asymptotique de certains algorithmes. En effet, le principe des
algorithmes rcursifs est de se ramener des objets de plus petite taille (par exemple, un algorithme de
type diviser pour rgner ramne un problme de taille n/, pour une constante fixe, par exemple
= 2). Si on sait quen dessous dun certain seuil, lalgorithme rcursif est moins bon quun algorithme
classique, on a tout intrt terminer, pour les petites valeurs, par lalgorithme classique, donc changer
dalgorithme pour les donnes de plus petite taille. Le principe mme de la rcursivit tant de fractionner

96

CHAPITRE 5. COMPLEXIT

les objets en objets plus petits, ceci peut avoir un effet trs important mme sur les objets de grande
taille, et on parfois gagner un facteur 10 ou mme plus sur le temps de calcul.
Ainsi, ltude de la complexit asymptotique est importante sur fait des donnes de plus en plus grandes
quest amen manipuler un ordinateur, mais ltude du temps de rponse sur des donnes plus petites
nest pas ngliger. Cette dernire se fait souvent de faon empirique. Nous nous contenterons ici de
ltude asymptotique.
Nous estimerons la complexit asymptotique laide des comparaisons usuelles de lanalyse fournies par
les notions dquivalence, ngligeabilit et dominance. Nous rappelons (pour des suites ne sannulant
pas) :
Dfinition 5.1.1 (Comparaisons asymtotiques)
quilalence : un vn si et seulement si uvnn 1. Autrement dit, (un ) et (vn ) ont mme ordre
de grandeur asymptotique.
Ngligeabilit : un = o(vn ) si et seulement si uvnn 0. Ainsi, (un ) est asymptotiquement
infiniment petit devant (vn )
Dominance : un = O(vn ) si et seulement si uvnn est born. Ainsi, (un ) ne grossit pas dmesurment
par rapport (vn ).
ces comparaisons classiquement utilises en analyse standard, nous ajoutons deux notations dues
Knuth :
un = (vn ) sil existe m > 0 tel que uvnn > m partir dun certain rang (ainsi, un ne devient pas
dmesurment petit devant vn )
un = (vn ) sil existe m, M > 0 tels que m 6 uvnn 6 M partir dun certain rang. Ainsi, (un ) et
(vn ) restent dans un rapport comparable.
Les notations les plus utilises pour mesurer la complexit asymptotique sont O et (qui est la combinaison de O et ). Il convient de remarquer que :
O mesure les performances dun algorithme : dire que la complexit est en O(n2 ) permet de borner
( constante prs) le temps dexcution. En revanche, lalgorithme peut tout fait avoir un temps
dexcution bien meilleur : un algorithme en O(n ln(n)) est aussi en O(n2 ) !
mesure les limitations dun algorithme : dire quun algorithme est en (n) affirme quil est au
moins en temps linaire. Mais il peut tre pire.
permet donc de classer de faon prcise la complexit sur une chelle : un algorithme dont la
complexit est en (n2 ) aura de faon effective un temps de rponse de lordre de n2 ( constante
prs), ni plus lent, ni plus rapide.

II
II.1

Complexit en temps (modle cots fixes)


Premire approche

Chaque opration effectue ncessite un temps de traitement. Les oprations lmentaires effectues au
cours dun algorithme sont :
laffectation
les comparaisons
les oprations sur des donnes numriques.
valuer la complexit en temps revient alors sommer tous les temps dexcution des diffrentes oprations effectues lors de lexcution dun algorithme.
La dure dexcution des diffrentes oprations dpend de la nature de lopration : une multiplication
sur un flottant demande par exemple plus de temps quune addition sur un entier. Ainsi, si on veut une
expression prcise du temps de calcul connaissant la dure dexcution de chaque opration, il nous faut
toute une srie de constantes donnant ces diffrents temps.

II

Complexit en temps (modle cots fixes)

97

Dfinition 5.2.1 (Modle cot fixe)


Le modle cot fixe consiste considrer que la dure des oprations ne dpend pas de la taille
des objets (notamment des entiers), et que les oprations sur les flottants sont de dure similaire aux
oprations semblables sur les entiers.
videmment, suivant la situation, le modle cot fixe peut tre acceptable ou non : si on est amen
manipuler de trs longs entiers, il est vident que le modle cot fixe nest pas bon : multiplier deux
entiers 1.000.000.000 chiffres est plus long que multiplier deux entiers 1 chiffre !
Nous supposons ici que nous sommes dans une situation ou le modle cot fixe est acceptable. Nous
nous donnons alors des constantes C+ , C , C/ etc correspondant au temps des diffrentes oprations,
ainsi que C pour laffectation et C== , C<= etc. pour les tests. Ces diffrentes valeurs peuvent tre
distinctes, mais sont toutes strictement positives.
Dfinition 5.2.2 (Complexit en temps)
La complexit en temps dun algorithme est une fonction C dpendant de la taille n des donnes
(ventuellement de plusieurs variables sil y a en entre des objets pouvant tre de tailles diffrentes)
et estimant le temps de rponse en fonction de n et des constantes C dfinies ci-dessus.
tudions par exemple lalgorithme suivant :
Algorithme 5.1 : valuation nave dun polynme
Entre : T : tableau, coefficients dun polynme P , a : rel
Sortie : P (a) : rel.
S0;
pour i 0 n faire
b1;
pour j 1 i faire
bba
fin pour
S S + T [i] b
fin pour
renvoyer S
Exercice 6
1. Justifier la correction de lalgorithme ci-dessus.
2. En considrant que lincrmentation de lindice des boucles ncessite une addition et une affectation, montrer que pour un polynme de degr n (donc un tableau index de 0 n), la complexit
en temps est :




C+
3
C
3
C(n) = n2
+
+ C + n 4C + C+ + C + (4C + C ) .
2
2
2
2
Une telle expression aussi prcise peut tre importante si on a estimer de faon trs prcise le temps
dexcution pour des tableaux de taille connue. Cependant, dans ltude du comportement asymptotique,
on nest souvent intress que par lordre de grandeur de la complexit. Ici, du fait que le coefficient
prcdant le terme en n2 est strictement positif, on obtient :
C(n) = (n2 ).
On dit que lalgorithme a un cot, ou une complexit, quadratique. Les diffrents comportements de
rfrence sont :

98

CHAPITRE 5. COMPLEXIT

Dfinition 5.2.3 (Complexits de rfrence)

Cot
Cot
Cot
Cot
Cot
Cot
Cot
Cot

constant : C(n) = (1)


logarithmique : C(n) = (ln(n))
linaire : C(n) = (n)
quasi-linaire : C(n) = (n ln(n))
quadratique : C(n) = (n2 )
cubique : C(n) = (n3 )
polynomial : C(n) = (n ), > 0
exponentiel : C(n) = (xn ), x > 1.

On utilisera la mme terminologie (en prcisant ventuellement au plus ) si on ne dispose que dun O
au lieu du .
Pour information, voici les temps approximatifs de calcul pour un processeur effectuant 1 milliard doprations par seconde, et pour une donne de taille n = 106 , suivant les cots :
O(1) : 1 ns
O(ln(n)) : 15 ns
O(n) : 1 ms
O(n ln n) : 15 ms
O(n2 ) : 15 min
O(n3 ) : 30 ans
O(2n ) : 10300000 milliards dannes !
Ainsi, si on est amen traiter des grandes donnes, lamlioration des complexits est un enjeu important !
Remarque 5.2.4
En pratique, se rendre compte de lvolution de la compexit nest par trs dur : pour des donnes de
taille suffisamment grande, en doublant la taille des donnes :
on naugmente pas le temps de calcul pour un algorithme en temps constant
on augmente le temps de calcul dune constante (indpendante de n) pour un cot logarithmique
on double le temps de calcul pour un algorithme linaire
on quadruple le temps de calcul pour un algorithme quadratique
on multiplie le temps de calcul par 8 pour un algorithme cubique
a ne rpond plus pour un algorithme exponentiel (sauf si on a pris une valeur initiale n trop
ridiculement petite)

II.2

Simplification du calcul de la complexit

Le calcul de la complexit effectu ci-dessus ncessite de distinguer les diffrentes oprations. De plus,
les valeurs des diffrentes constantes ne sont pas des donnes absolues : elles dpendent de faon cruciale
du processeur utilis ! Nous voyons dans ce paragraphe comment saffranchir de la connaissance de ces
constantes.
Dans la recherche de la complexit asymptotique sous forme dun , la connaissance prcise des C
nest pas indispensable : ces constantes interviennent, comme dans lexemple trait, dans les coefficients
de lexpression obtenu, coefficients quil nest pas utile de connatre explicitement pour obtenie une
expression en (seule leur stricte positivit est indispensable)
Proposition 5.2.5 (Effet de la modification dune des constantes)
Considrons un algorithme de complxit C1 (n) suivant la valeur de la taille n de lobjet tudi. Alors

II

Complexit en temps (modle cots fixes)

99

la complexit C2 calcule en modifiant lune quelconque des constantes, disons C en une valeur C
galement strictement positive, vrifie C2 (n) = (C1 ).

Corollaire 5.2.6
condition de garder des valeurs strictement positives, on peut modifier la valeur des constantes C
comme on veut, sans changer le comportement en (un ) de la complexit.

Corollaire 5.2.7 (Calcul simplifi de la complexit asymptotique)


On peut calculer le comportement asymptotique en de la complexit en faisant la supposition que
toutes les constantes de temps C sont gales 1.
Autrement dit, le calcul de complexit asymptotique peut se faire sous la supposition que toutes les oprations ont le mme temps dexcution et on peut prendre ce temps dexcution comme unit temporelle.
On peut mme considrer, pour simplifier, lincrmentation dun compteur de boucle comme ncessitant
une seule unit de temps.
videmment, ce principe est aussi valable pour obtenir juste un O ou un .
Exemple 5.2.8
Reprendre le calcul de la complexit asymptotique de lvaluation nave dun polynme sous cet angle.

II.3

Amlioration de la complexit de lexemple donn

Un mme problme peut souvent tre rsolu par diffrents algorithmes pouvant avoir des complexits
diffrentes. Cette recherche de la performance est un enjeu capital de linformatique. Nous lillustrons sur
notre exemple de lvaluation polynomiale, en donnant deux amliorations possibles, et en recherchant
leur complexit.
La premire amlioration que nous proposons est le calcul rapide des puissances de a, bas sur la remarque
que a16 = (((a2 )2 )2 )2 , permettant de la sorte de passer de 15 oprations 4. De faon plus gnrale, il
faut tenir compte de limparit possible de lexposant.
Fonction 5.2 : exp-rapide(a,n)
Entre : a entier ou rel, n entier
Sortie : an
si n = 0 alors
renvoyer 1 et sortir
fin si
ya;
z1;
tant que n > 0 faire
si n est impair alors
nn1 ;
z zy
sinon
n n2 ;
y yy
fin si
fin tant que
renvoyer z

100

CHAPITRE 5. COMPLEXIT

Algorithme 5.3 : valuation polynomiale par exponentiation rapide


Entre : T : tableau des coefficients dun polynme P , a rel
Sortie : P (a)
S0;
pour i 0 n faire
S S + T [i] exp-rapide(a, i)
fin pour
Exercice 7
1. Justifier la terminaison et la correction de lalgorithme dexponentiation rapide.
2. Soit C(n) le cot de lexponentiation rapide pour un exposant n. Montrer que pour tout k N
et tout n [[2k , 2k+1 ]],
C(2k ) 6 C(n) < C(2k+1 ) + 2k.
3. En dduire que C(n) = (ln(n)).
4. En dduire que lalgorithme dvaluation polynomial obtenu ainsi a un cot en (n ln(n)). Pour
la minoration, on pourra se restreindre dans un premier temps des indices entre n2 et n.
Mais il est videmment possible de faire mieux : ayant dj calcul ai1 au passage prcdent dans une
boucle, il est inutile de reprendre le calcul de ai depuis le dbut : il suffit de multiplier la puissance
obtenue prcdemment par a, ce qui ne ncessite quune opration supplmentaire.
Cette remarque peut se traduire par lgalit suivante, dans laquelle on a mis ds que possible les termes
x en facteur :
a0 + a1 x + a2 x2 + + an1 xn1 + an xn = a0 + x(a1 + x(an + + x(an1 + xan ))).
Cette factorisation est la base de lalgorithme de Hrner :
Algorithme 5.4 : Hrner
Entre : T , coefficients dun polynme P , a : rel
Sortie : P (a)
S T [n] ;
pour i n 1 descendant 0 faire
S S a + T [i]
fin pour
renvoyer (S)
Exercice 8
1. Montrer la correction de lalgorithme de Hrner.
2. Montrer que lalgorithme de Hrner a un cot linaire ((n)).

III
III.1

Complexit dans le meilleur ou le pire des cas, en moyenne


Complexit dans le meilleur et le pire des cas

Il nest parfois pas possible dexprimer la complexit (que ce soit par une expression exacte, ou par une
estimation asymptotique) pour une entre quelconque. En effet, le nombre doprations effectues, est
parfois trs dpendante des valeurs fournies en entre : des valeurs de mme taille peuvent parfois ncessiter des temps de calcul trs diffrents. Un exemple trs simple est fourni par le test le plus lmentaire
de primalit :

III

Complexit dans le meilleur ou le pire des cas, en moyenne

101

Algorithme 5.5 : Test de primalit


Entre : p : entier > 1
Sortie : b boolen, rsultat du test de primalit
i2;

m= p;
tant que i 6 m faire
si p mod i = 0 alors
renvoyer False et sortir
fin si
ii+1
fin tant que
renvoyer True
Exercice 9
1. Justifier la terminaison et la correction de cet algorithme
2. Montrer que si p est pair (ce qui peut arriver pour p grand !) le temps de rponse est en (1)

(en ngligeant le cot du calcul de p)


3. Montrer que si p est premier (Euclide ma affirm un jour quon peut aussi trouver des p aussi

grand quon veut vrifiant cela), le temps de rponse est en ( p) (dans le modle cot
constant, qui devient discutable ici pour des grandes valeurs de p).

Dfinition 5.3.1 (Complexit dans le pire et le meilleur des cas)


Pour des objets de taille n, la complexit dans le meilleur des cas est le nombre minimal C (n)
doprations effectuer pour des objets dont la taille est n.
Pour des objets de taille n, la complexit dans le pire des cas est le nombre maximal C+ (n)
doprations effectuer pour des objets dont la taille est n.
Pour un objet T donne de taille n, on a donc toujours :
C (n) 6 C(T ) 6 C+ (n),
o C(T ) dsigne le nombre doprations effectuer pour lobjet T .

Exemple 5.3.2
En considrant que la taille des entiers est donne par le nombre de leur chiffres (donc en gros par
log(p)), et en remarquant que pour tout n, il existe des nombres pairs n chiffres (a, cest trivial),
et galement des nombres premiers n chiffres (a lest un peu moins, a peut tre vu comme une
consquence du postulat de Bertrand affirmant quil y a toujours un nombre premier entre m et 2m),
on obtient, pour lalgorithme de primalit :
C (n) = (1)

et

C+ (n) = (10 2 ).

Dans ce cas, mme si le nombre doprations C(n) pour des objets de taille n est impossible dfinir
explicitement (car dpendant de lobjet donn en entre), on dira que la complexit vrifie :
C(n) = O(C+ (n))

et

C(n) = (C (n)).
n

Ainsi, pour lalgorithme de primalit, C(n) = (1) et C(n) = O(10 2 ).

102

CHAPITRE 5. COMPLEXIT

Exercice 10
On propose une amlioration au tri bulle vu dans un exercice du chapitre prcdent, consistant
compter le nombre dchanges effectus lors dun passage du dbut la fin du tableau, et sarrter
lorsquaucun change nest effectu (ce qui signifie que les termes sont dans lordre). Dterminer la
complexit dans le meilleur et dans le pire des cas, en donnant chaque fois un exemple de configuration
initiale associe.

Remarque 5.3.3
De nombreux tris (mais pas tous) sont plus rapides sur des tableaux presque tris (obtenus par exemple
en ajoutant un petit nombre dlments un tableau initialement tri, cest une situation trs frquente,
correspondant par exemple lajout de quelques lments dans une base quon maintient trie). Certains algorithmes, rputs plus lents sur des tableaux gnraux, peuvent tre plus rapides dans cette
situation que des algorithmes rcursifs rputs plus rapides dans des situations gnrales. Ainsi, avant
de se prcipiter vers un algorithme rput rapide, il est important danalyser le contexte dans lequel
lalgorithme doit tre utilis.

III.2

Complexit en moyenne

La complexit dans le pire et dans le meilleur des cas nest pas forcment une donne trs reprsentative
du comportement gnral dun algorithme : il sagit souvent de situations bien particulires, qui, certes,
dans certains situations, peuvent se produire souvent (voir les tris), mais dans dautres, peuvent rester
exceptionnelles. Dans ces situations, la notion de complexit en moyenne est plus intressante.
Dfinition 5.3.4
La complexit en moyenne Cm (n) est la moyenne du nombre doprations effectuer pour chacun
des objets de taille n. Si certains objets sont plus probables que dautres, il faut en tenir compte en
pondrant convenablement. Ainsi, de faon plus formelle, cette moyenne correspond lesprance de
la variable alatoire C(n) donnant le nombre doprations effectuer, dfinie sur lespace probabilit
n des objets de taille n.
Trs souvent, on considre la mesure de probabilit uniforme sur lensemble des objets.
Exercice 11
On considre un alphabet A k lettres. On effectue, sur des tableaux constitus de caractres de
lalphabet A, la recherche du premier a. Dterminer la complexit moyenne de cet algorithme, sachant
que les tableaux considrs sont remplis alatoirement.

III.3

Algorithmes randomiss

Il est frquent dintroduire un ala artificiel de sorte viter les cas extrmes. En effet, les cas les meilleurs,
mais aussi les pires, correspondent dans certains situations, des situations frquentes. Ainsi est-on parfois
amen trier des donnes en sens inverse, les remettre dans le bon sens, trier un tableau presque tri,
dans un sens ou dans lautre. Ces diffrentes actions nous amnent souvent fleurter avec le meilleur des
cas (ce qui nest pas trop gnant), mais aussi avec le pire des cas (ce lest plus).
Introduire un ala permet parfois de se ramener (avec une probabilit forte) un cas gnral, dont la
complexit sera plutt de lordre moyen.

IV

Limitations du modle cots fixes

103

Dfinition 5.3.5 (Algorithme randomis)


On parle dalgorithme randomis lorsquon a introduit dans lalgorithme un ala dont le but est dviter
les cas extrmes.
Nous introduisons rapidement le tri rapide dont le principe gnral (et trs vague) est le suivant :
Fonction 5.6 : trirapidenonrandomis(T)
Entre : T : tableau trier
Sortie : T : tableau tri
Comparer tous les lments autres que T [0] T [0] et sparer en 2 tableaux ;
U : tableau des plus petits ;
V : tableau des plus grands ;
U trirapidenonrandomis(U ) ;
V trirapidenonrandomis(V ) ;
renvoyer concatnation de U , [T [0]] et V .
On peut montrer, mais ce nest pas compltement vident, que la complexit en moyenne du tri rapide
est en O(n ln(n)). Cest aussi la complexit dans le meilleur des cas, correspondant au cas o on divise
chaque fois le tableau en deux sous-tableaux de mme taille (donc que la valeur pivot choisie se trouve
au milieu).
Exercice 12
Montrer que le temps de calcul du tri rapide sur un tableau tri (dans un sens ou dans lautre) est en
O(n2 ).
Il sagit dailleurs l de la complexit dans le pire des cas. Ainsi, le tri rapide est particulirement mauvais
sur les listes tries et presque tries, dans un sens ou dans lautre. Comme dit plus haut, il sagit de
situations frquentes dans la vie courante. Une faon dy remdier est dintroduire un ala dans le choix
du pivot :
Fonction 5.7 : trirapiderandomis(T)
Entre : T : tableau trier
Sortie : T : tableau tri
Choisir i alatoirement dans [[0, n 1]] (indices du tableau) ;
Comparer tous les lments autres que T [i] T [i] et sparer en 2 tableaux ;
U : tableau des plus petits ;
V : tableau des plus grands ;
U trirapiderandomis(U ) ;
V trirapiderandomis(V ) ;
renvoyer concatnation de U , [T [i]] et V .
De cette faon, on subit moins les effets de bord, et on peut bnficier (sauf trs grande malchance) dun
algorithme efficace dans toutes circonstances.

IV

Limitations du modle cots fixes

Si on est amen manipuler des grands nombres, il est vident quon ne peut plus considrer le cot des
oprations comme indpendant des entres. On exprime alors le cot des oprations en fonction de lg(N ),
le nombre de chiffres de N en base 2 (ou choix dune autre base convenance). Les diffrentes oprations
ont alors un cot quil convient de ne pas ngliger, et qui diffre suivant les oprations. Par exemple, par
lalgorithme standard, le cot de laddition m + n va tre de lordre de max(lg(m), lg(n)), alors que le

104

CHAPITRE 5. COMPLEXIT

cot du produit mn va tre de lordre de lg(m) lg(n). Le cot du produit peut tre amlior en utilisant
des algorithmes plus sophistiqus, comme lalgorithme de Karatsuba, ou encore un algorithme bas sur
la transforme de Fourier rapide.
Dans certaines situations, il est possible dviter les grands nombres. Cest le cas par exemple si on
travaille modulo K, o K est un entier fix. Attention la maladresse consistant dans cette situation
rduire modulo K la fin du calcul. Comme exemple, reprenons lalgorithme de Hrner, adapt pour une
valuation modulo K. Que pensez-vous des deux algorithmes ci-dessous ? Lequel est meilleur ?
Algorithme 5.8 : Hrner 2
Entre : T , coefficients dun polynme P , a : rel, K base du modulo
Sortie : P (a)
S T [n] ;
pour i 6 n 1 descendant 0 faire
S S a + T [i]
fin pour
renvoyer (S mod K)
Algorithme 5.9 : Hrner 3
Entre : T , coefficients dun polynme P , a : rel, K base du modulo
Sortie : P (a)
S T [n] mod K ;
pour i n 1 descendant 0 faire
S ((S a + T [i]) mod K
fin pour
renvoyer (S)

Complexit en mmoire, ou en espace

Le but de ltude de la complexit en mmoire, que nous aborderons trs peu ici, est dtudier lencombrement en mmoire du fait de lexcution dun algorithme. Cette encombrement peut provenir de mises en
mmoire explicites, ou dempilements implicites de donnes et dinstructions, par exemple dans le cadre
dun algorithme rcursif.
Une mauvaise complexit en mmoire ralentit le programme (car la mise en mmoire doit se faire loin
du processeur), et peut aller jusqu la saturation de la mmoire, cas dans lequel lalgorithme ne peut
terminer son excution.

VI

tude de quelques algorithmes de recherche

Ces quelques algorithmes interviennent frquemment dans des algorithmes plus labors. On se contente
souvent dailleurs dutiliser des fonctions toutes faites, sans vraiment se proccuper de ce qui se cache
derrire. Il est cependant important de connatre leur fonctionnement, ainsi que leur complexit (afin de
pouvoir estimer la complexit des algorithmes qui les utilisent).

VI.1

Recherche du maximum dune liste

Problme : tant donn une liste de rels, trouver le maximum de cette liste (ou de faon similaire, son
minimum).
Ide de rsolution : Progresser dans le tableau en mmorisant le plus grand lment rencontr jusquel. On peut aussi mmoriser sa place.

VI

tude de quelques algorithmes de recherche

105

On utilise la convention usuelle de Python pour les indexations : un tableau de taille n est suppos index
de 0 n 1.
Algorithme 5.10 : Recherche maximum
Entre : T , tableau de rels de taille n
Sortie : max(T )
M T [0] ;
pour i 1 n 1 faire
si T [i] > M alors
M T [i]
fin si
fin pour
renvoyer (M )
Exercice 13
Montrer que lalgorithme Recherche maximum est correct, et que son cot est en (n).

VI.2

Recherche dun lment dans une liste

Problme : tant donn une liste, trouver un terme particulier dans cette liste, sil y est.
Ide de rsolution : Parcourir la liste jusqu ce quon trouve llment souhait. Variantes : si on veut
toutes les occurrences, on parcourt la liste en entier ; si on veut la dernire occurrence, on parcourt le
tableau partir de la fin.
Algorithme 5.11 : Recherche premire occurrence
Entre : T , tableau de rels de taille n ; a lment chercher dans T
Sortie : i : indice de la premire occurrence de a, ou None si pas doccurrence
i 0;
tant que i < n et T [i] 6= a faire
ii+1
fin tant que
si i < n alors
renvoyer (i)
fin si
Remarquez quon utilise ici les tests boolens dans le mode paresseux , ce qui signifie que pour obtenir
la valeur du boolen b1 et b2 , ds lors que b1 est faux, on ne va pas voir b2 et on renvoie faux . Ainsi,
dans cette boucle, si i = n, le test T [i] 6= a nest pas effectu. Sinon, on aurait un problme de validit
des indices (on sort du tableau). Beaucoup de langages (dont Python) effectue les oprations boolennes
en mode paresseux.
Exercice 14
1. Montrer la terminaison et la correction de lalgorithme Recherche premire occurrence
2. Montrer que sa complexit dans le pire des cas est en (n), et dans le meilleur des cas en (1).
3. Montrer que si T est un tableau constitu de N objets supposs quiprobables, et que a est un
de ces objets, la complexit en moyenne tend vers N lorsque n tend vers . Ainsi, la complexit
moyenne est en (1), si on considre N comme une constante. Si on est amen faire varier la
fois la taille n du tableau et le nombre N dobjets diffrents, on peut crire Cm (n, N ) = (N ).
4. Comment modifier lalgorithme ci-dessus pour quil renvoie la dernire occurrence ? Toutes les
occurrences. Quelle est la complexit dans ce cas ?

106

CHAPITRE 5. COMPLEXIT

Remarque 5.6.1
Si le tableau T est utilis essentiellement pour des tests dappartenance, il faut se demander si la
structure de tableau est vraiment adapte : il est peut-tre plus intressant de considrer une structure
densemble, le test dappartenance sy faisant plus rapidement.

VI.3

Recherche dans une liste trie

Si la liste est trie, rechercher un lment, ou rechercher la position dun lment insrer, se fait beaucoup
plus rapidement.
Problme : tant donn un tableau T tri et un lment a comparable aux lments du tableau, trouver
la premire occurrence de a (donc pouvoir dire si a est dans le tableau ou non), ou, de faon quivalente,
trouver le plus petit indice i tel que a 6 T [i] (dans ce cas, a est dans le tableau, de plus petit occurrence
i, si et seulement si a = T [i]). Ce dernier problme tant un peu plus gnral, cest lui quon tudie.
Ide 1 : parcourir le tableau dans lordre pour reprer i. Cela ne change pas grand chose la mthode
de recherche dans un tableau non tri. En particulier, en moyenne, le cot sera linaire.
Ide 2 : faire une dichotomie, en coupant chaque tape le tableau en 2, afin de nen garder que la
moiti pertinente. Intuitivement, cela va beaucoup plus vite, puisqu chaque tape, on rduit le nombre
de possibilits de moiti.
Algorithme 5.12 : Recherche par dichotomie dans tableau tri
Entre : T , tableau de rels de taille n, tri ; x lment positionner dans T
Sortie : i : indice minimal tel que T [i] > x, ventuellement i = n
a0;
bn1 ;
si T [b] < x alors
renvoyer (n)
sinon si T [a] > x alors
renvoyer (0)
sinon
tant que b a > 1 faire
c = a+b
2 ;
si T (c) > x alors
bc
sinon
ac
fin si
fin tant que
fin si
renvoyer (b)
Exercice 15
1. Prouver la terminaison et la correction de cet algorithme
2. Justifier que sauf dans le cas o les tests initiaux sont positifs, son cot est en (ln(n)).
3. Expliquer comment amliorer lalgorithme si on ne recherche pas ncessairement la premire
occurrence.
4. Expliquer comment rcuprer la dernire occurrence.
5. Comment rcuprer lensemble de toutes les occurrences ?
6. Proposer une variante de cet algorithme pour obtenir un test dappartenance une liste trie.

VI

tude de quelques algorithmes de recherche

VI.4

107

Autres algorithmes

Les recherches ci-dessus peuvent bien sr sadapter une chane de caractres. Un problme frquent est
celui de la recherche dun mot dans un texte : on peut positionner le mot en toute place du texte, et faire
une comparaison lettre lettre : en cas dchec, on dplace le mot dun cran, tant que cest possible. On
se rend bien compte que la complexit est en O(nk), o n est la longueur du texte et k la longueur du
mot.
Moyennant un prtraitement du texte (confection dune table trie des suffixes, pouvant se faire de faon
nave en (n ln(n))), on peut amliorer les performances de la recherche en descendant O(ln(n)) (en
considrant k comme constante), sans compter le prtraitement. Avec le prtraitement naf, on y perd
(mais on peut faire ce prtraitement plus rapidement). Ainsi, cela savre intressant si le prtraitement
est fait une fois pour toutes (dans un texte finalis qui nest pas trop amen tre modifi ; des mises
jours restent possibles), et est antrieur la demande de recherche. Cest ce type dalgorithmes qui est
la base des recherches dans les pages internet.
On verra en TP quelques algorithmes de tri de tableau. Ces algorithmes sont utiles dans la vie pratique
tous les jours (par exemple lorsquon ordonne des donnes dans un tableur ou une base de donnes).
Ils sont aussi la base de nombreux algorithmes plus sophistiqus. Il est donc important de pouvoir
trouver des tris de complexit minimale. Nous verrons plusieurs algorithmes en (n2 ) (tri bulles, tri
par slection, tri par insertion), et quelques algorithmes en (n ln(n)) (en moyenne) (tri rapide, tri fusion).
On peut montrer que dans une situation gnrale, cest le plus rapide quon puisse faire. Sous certaines
hypothses supplmentaires (par exemple travailler sur un ensemble fini de donnes), on peut descendre
encore.

108

CHAPITRE 5. COMPLEXIT

6
Calculs dintgrales
Le but de ce chapitre est dtudier quelques algorithmes permettant un calcul approch efficace dintgrales. Ce chapitre est le premier chapitre dune srie de chapitres danalyse numrique, dont le but est
dobtenir des mthodes approches pour la rsolution de certains problmes mathmatiques. Lintrt en
est que dune part, les solutions exactes ne sont pas toujours faciles obtenir mathmatiquement, voire
impossibles, et que dautre part, dans de nombreuses disciplines scientifiques (physique, ingnirie...),
une bonne valeur approche de la solution est souvent largement suffisante. videmment, pour des tudes
de ce type, il est important de savoir valuer le temps de calcul dune part, combin dautre part la
prcision du rsultat. Ce nest que cette matrise de la prcision du rsultat qui rend la mthode valide.
Le principe gnral du calcul des intgrales est la quadrature : linterprtation gomtrique des intgrales
est connue de tous : il sagit de laire sous la courbe. Lide est alors dapprocher la surface sous la
courbe par une somme de surfaces lmentaires dont laire est facile calculer, par exemple des rectangles.
Ainsi :
on prend une subdivision a = 0 < 1 < < n < b de lintervalle dintgration [a, b] (figure
6.1),
on approche lintgrale entre i et i+1 (cest--dire la surface sous la portion de courbe entre ces
deux valeurs) par une aire facile calculer
On recolle les morceaux par sommation, en utilisant de faon sous-jacente la relation de Chasles.
Lorsque le pas de la subdivision tend vers 0, lapproximation devient bonne.

On rappelle :

a = 0 1

b = 4

Figure 6.1 Dcoupage de lintgrale suivant une subdivision

110

CHAPITRE 6. CALCULS DINTGRALES

Dfinition 6.0.1 (Subdivision et pas dune subdivision)


1. Une subdivision de lintervalle [a, b] est une squence finie (i )i[[0,n]] telle que :
a = 0 < 1 < n1 < n = b.
2. Le pas p dune subdivision a = 0 < 1 < n = b est la distance maximale entre deux points
successifs de la subdivision :
p = max (i i1 ).
i[[1,n]]

Les trois premires mthodes que nous tudions suivent ce schma, en considrant des approximations
de plus en plus fines sur chaque sous-intervalle de la subdivision.

La mthode des rectangles

On commence par exposer la mthode des rectangles. Il sagit en fait dapprocher lintgrale par des
sommes de Riemann , donc nous donnons la construction ci-dessous (voir figure 6.2)

0 x1 1

x2 2 x3

x4

Figure 6.2 Somme de Riemann

Figure 6.3 Mthode des rectangles


Soit = {a = 0 < < n = b} une subdivision de [a, b], et X = {x1 6 x2 6 6 xn } des points
associs cette subdivision, cest--dire :
i [[1, n]], xi [i1 , i ].

La mthode des rectangles

111

On dfinit alors I(, X ) lapproximation de lintgrale obtenue en approchant la courbe sur [i1 , i ]
par la fonction constante de valeur f (xi ). Ainsi, le morceau daire sous la courbe entre les coordonnes
i1 et i est approche par laire dun rectangle de base [i1 , i ] et de hauteur f (xi ).
Ainsi :
n
X
f (xi )(i i1 ).
I(, X ) =
i=1

Thorme 6.1.1 (Convergence des sommes de Riemann)


Soit f une fonction de classe C 0 sur [a, b]. Alors la somme de Riemann I(, X ) converge vers
Z b
f (t) dt lorsque le pas p tend vers 0.
a

Ce rsultat reste vrai dans un cadre plus gnral, pour des fonctions intgrables au sens de Riemann. On
renvoie au cours de mathmatiques pour une dmonstration.
On peut majorer la vitesse de convergence avec quelques hypothses complmentaires :
Thorme 6.1.2 (Vitesse de convergence des sommes de Riemann)
Soit f une fonction de classe C 1 , et M1 un majorant de |f | sur [a, b]. On a alors :
Z

b



f (t) dt I(, X ) 6 M1 p (b a).

a


En informatique, il est assez naturel dutiliser une subdivision rgulire n = a + k
Dans ce cas, le pas est pn = n1 , et on parle de mthode des rectangles .

ba
n ,


k [[0, n]] .

Thorme 6.1.3 (Vitesse de convergence de la mthode des rectangles)


Soit f une fonction de classe C 1 sur [a, b], n la subdivision rgulire n pas de lintervalle [a, b], et
Xn une squence de points associs. Alors


Z b

M (b a)2


1
f (t) dt 6
.
I(n , Xn )


n
a
On a donc une convergence de la mthode des rectangles en O

1
n


.

Le plus souvent, on prend pour la squence Xn des points particuliers selectionns dans les intervalles
de la subdivision, par exemple la borne infrieure, la borne suprieure, ou le milieu.
Dfinition 6.1.4 (Mthode du point milieu)
Le choix des milieux des intervalles de la subdivision rgulire fournit la mthode appele mthode du
point milieu.
Notons de faon plus gnrale, pour [0, 1], Xn, la squence de points (x1 , . . . , xn ) dfinie par :
xi = a + (i 1 + )

ba
.
n

Le choix de la borne infrieure de chaque intervalle de la subdivision correspond au choix de la valeur


= 0 ; le choix de la borne suprieure au choix de = 1, et le choix du milieu = 21 . On peut donner
explicitement les formules dapproximation dans ces cas :

n1 
ba
ba X
f a+i
Borne infrieure : I(n , Xn,0 ) =
n i=0
n

112

CHAPITRE 6. CALCULS DINTGRALES

Figure 6.4 Mthode du point milieu




n
ba X
ba
f a+i
n i=1
n




n1
ba X
1 ba
f a+ i+
.
Point milieu : I(n , Xn, 12 ) =
n i=0
2
n

Borne suprieure : I(n , Xn,1 ) =

Dfinition 6.1.5 (Mthode exacte sur f )


On dit quune mthode dapproximation squentielle (cest--dire une mthode fournissant une suite
In (f ) convergeant vers la valeur I(f ) recherche) est exacte pour une fonction f si pour tout n N,
In (f ) = I(f ).
Intuitivement, plus la famille des fonctions pour laquelle une mthode est exacte est grosse, plus la
mthode a des chances de fournir de bonnes approximations.
Proposition 6.1.6
La mthode des rectangles avec un choix Xn, , 6= 21 , est exacte pour les fonctions constantes, mais
pas pour les fonctions affines non constantes.

Proposition 6.1.7
La mthode du point milieu est exacte pour toutes les fonctions affines.

Ceci peut laisser prsager une meilleure convergence de la mthode du point milieu : approximation
lordre 1 (donc par la tangente) sur chaque intervalle de la subdivision, on va avoir une bonne compensation des erreurs sur la premire et la deuxime moiti de lintervalle. Ces compensations vont permettre,

moyennant une hypothse de rgularit plus forte, dobtenir une convergence en O n12 .
Thorme 6.1.8 (Vitesse de convergence de la mthode du point milieu)

Soit f une fonction de classe C 2 sur [a, b] et M2 un majorant de f sur cet intervalle. Alors
Z

b

M2


(b a)3 .
f (t) dt I(n , Xn, 12 ) 6

a
24n2

Ainsi, la mthode du point milieu converge en O

1
n2

II

La mthode des trapzes

113

Exemple 6.1.9
Trouver un exemple de fonction pour laquelle la convergence de la mthode des rectangles avec la borne

infrieure nest pas en O n12 . Ainsi, la mthode du point milieu donne une relle amlioration.

II

La mthode des trapzes

La mthode des trapzes consiste faire une approximation de la courbe non plus par des fonctions
en escalier, mais par une fonction affine par morceaux, chaque morceau tant une corde de la courbe.
Ainsi, tant donne une subdivision = {0 , . . . , n }, on dfinit la fonction affine joignant les points de
coordonne (i , f (i )). Lintgrale de la fonction sur un intervalle de la subdivision est alors approche
par laire dun trapze. Cette aire est donne, pour lintervalle [i1 , i ], par
f (i ) + f (i1 )
.
2
Pour viter une trop grande technicit, on se place directement dans le cas dune subdivision rgulire
n .
(i i1 )

Proposition 6.2.1 (Mthode des trapzes)


Soit f une fonction continue sur [a, b]. Lapproximation de

f (t) dt par la mthode des trapzes est

donne par la suite :

ba X 1
(f (k ) + f (k1 )) ,
n
2

In (f ) =

k=1

o pour tout k [[0, n]], k = a + k


In (f ) =

ba
. Cette somme peut se rcrire plus simplement :
n
n1
(b a)(f (b) + f (a)) b a X
+
f (k ) .
2n
n
k=1

Figure 6.5 Mthode des trapzes

Proposition 6.2.2
La mthode des trapzes est exacte pour les fonctions affines.
On peut donc esprer une convergence similaire la mthode du point milieu. Cest ce quon tablit
ci-dessous :

114

CHAPITRE 6. CALCULS DINTGRALES

Thorme 6.2.3 (Vitesse de convergence de la mthode des trapzes)


Soit f une fonction de classe C 2 sur [a, b], et In (f ) la suite des approximations par la mthode des
trapzes. Soit M2 un majorant de |f |. Alors
Z

b
M (b a)3


2
.
f (t) dt In (f ) 6

a

12n2
La convergence est donc en O

1
n2


.

Corollaire 6.2.4 (Retour sur la vitesse de CV de la mthode des rectangles)


Sous les mmes hypothese, si f (a) + f (b) 6= 0, on a lquivalent suivant pour la vitesse de convergence
de la mthode des rectangles avec choix des points au bord gauche des intervalles :
Z

f (t) dt I(n , Xn,0 )

(b a)(f (b) + f (a))


.
2n

Confrontez ce rsultat une situation simple dans laquelle cette diffrence se calcule de faon exacte, par
exemple le cas dune fonction affine. Dans ce cas, lquivalent est une galit.
Remarque 6.2.5
La mthode des trapzes nest pas fondamentalement meilleure que la mthode du point milieu ; la
constante obtenue dans la majoration est mme un peu moins bonne.

III

La mthode de Simpson (HP)

Il sagit ici dapprocher localement la courbe par des courbes polynomiales de degr 2. Un polynme
de degr au plus 2 est entirement dtermin par limage de 3 points (il sagit dune interpolation de
Lagrange) : tant donns x1 < x2 < x3 trois rels distincts, et y1 , y2 , y3 trois rels, lunique polynme de
degr au plus 2 tel que pour tout i [[1, 3]], f (xi ) = yi est donn par :
P (X) = y1

(X x2 )(X x3 )
(X x1 )(X x3 )
(X x1 )(X x2 )
+ y2
+ y3
.
(x1 x2 )(x1 x3 )
(x2 x1 )(x2 x3 )
(x3 x1 )(x3 x2 )

La mthode de Simpson consiste approcher la courbe sur chaque intervalle [, ] dune subdivision de
lintervalle [a, b] par lunique parabole concidant avec la courbe aux points , et +
2 .
Daprs ce qui prcde, ce polynme est donn par :




+
+


(X ) X
(X ) X
+
(X )(X )
2
2
 + f ()
 +f

.



P (X) = f ()
+
+
+
+
2

( )
( )
2
2
2
2




1
+
=
(X )(X )
f ()(X )(2X ( + )) + f ()(X )(2X ( + ) 4f
( )2
2
Pour exprimer notre approximation, on calcule donc lintgrale de la fonction polynomiale associe entre
et , en procdant par tapes :

(t)(2t(+)) dt =

On obtient donc :

(t)(2t(+)) dt =

P (t) dt =

( )
6

( )3
6

et

(t)(t) dt =





+
f () + 4f
+ f () .
2

( )3
.
6

IV

La mthode de Monte-Carlo (HP)

115

Dfinition 6.3.1 (Mthode de Simpson)


On obtient la mthode dapproximation de Simpson en approchant, sur tout intervalle de la subdivision
rgulire de [a, b] en n pas, la courbe par le polynme dinterpolation de degr au plus 2, concidant
avec la courbe aux bords et au milieu de lintervalle. Ainsi, lapproximation au rang n est donne par :
In (f ) =




n1 
ba X
k + k+1
+ f (k+1 ) ,
f (k ) + 4f
6n
2
k=0

o k = a + k ba
n .
Cette dernire expression peut tre arrange un peu en regroupant les termes f (k ), mais lexpression
obtenue est un peu plus obscure :
!
n1
n1
X  k + k+1 
ba
(b a) X
+
f (k ) + 2
f
(f (b) + f (a)).
In (f ) =
3n
2
6n
k=1

k=0

Thorme 6.3.2 (Vitesse de convergence de la mthode de Simpson, admis)


Soit f une fonction de classe C 4 sur [a, b], et M4 un majorant de |f (4) | sur cet intervalle. Soit In (f )
lapproximation de Simpson de rang n. Alors :
Z

b

M4 (b a)5


.

f (t) dt In (f ) 6

a
2880
n4
Ainsi, la convergence de la mthode de Simpson est en O

1
n4


.

On rencontre parfois aussi la mthode de Romberg, qui est en fait base sur la mthode des trapzes,
associ un procd dacclration de convergence.

IV

La mthode de Monte-Carlo (HP)

La dernire mthode que nous tudions est dun type trs diffrent des prcdents, puisquil sagit dune
mthode probabiliste.
La mthode de Monte-Carlo exploite le fait que lintgrale peut tre interprte comme le produit de la
longueur de lintervalle dintgration et de la valeur moyenne de f sur cet intervalle. On obtient alors
la mthode suivante :
Dfinition 6.4.1 (Mthode de Monte-Carlo)
Soit f une fonction continue sur [a, b], et soit X1 , , Xn des variables alatoires mutuellement indpendantes suivant toutes la loi uniforme sur [a, b] (on parle dchantillon indpendant identiquement
distribu (i.i.d.) de loi parente la loi uniforme sur [a, b]). On dfinit alors la variable alatoire In par :
n

In =

(b a) X
f (Xi ).
n
i=1

La mthode de Monte-Carlo consiste approcher f par une ralisation de la variable alatoire In .


La justification de cette mthode provient du fait que lesprance de In est gale lintgrale quon veut
calculer, et que la variance tend vers 0 lorsque n tend vers +, ce qui assure que pour n grand, la
probabilit dobtenir une valeur proche de lintgrale voulue est grande.
On rappelle (ou on admet) le thorme de transfert, permettant le calcul des esprances de variables
alatoires f (X) : tant donne une variable alatoire X de fonction de densit dfinie sur R, et f une

116

CHAPITRE 6. CALCULS DINTGRALES

fonction continue, lesprance de f (X) existe si et seulement si lintgrale ci-dessous converge absolument,
et dans ce cas :
Z
E(f (X)) =
(t)f (t) dt.
R

Appliquons cela une variable alatoire suivant la loi uniforme sur [a, b] : sa densit est 1[a,b] .
Lemme 6.4.2

Soit X une variable alatoire suivant une loi uniforme sur [a, b], et f une fonction continue sur [a, b].
Alors
!2
Z
Z
Z
b

E(f (X)) =

f (t) dt

et

V (f (X)) =

f (t)2 dt

f (t) dt

= J(f ).

Proposition 6.4.3 (Convergence de la mthode de Monte-Carlo)


Pour tout n N,
E(In ) =

f (t) dt

et

V (In ) =

J(f )
,
n

o la quantit J(f ) est dfinie dans le lemme prcdent.


La mthode de Monte-Carlo est beaucoup plus lente et moins fiable que les mthodes tudies prcdemment. En revanche, elle est immdiate adapter au cas des fonctions de plusieurs variables, et est donc
assez utilise dans ce cadre.
On peut par exemple obtenir ainsi une approximation de en considrant la fonction f dfinie sur [0, 2]2
par
(
1 si x2 + y 2 6 4
f (x, y) =
0 sinon.
Lintgrale de cette fonction sur [0, 2]2 nous donne laire dun quart de disque de rayon 2 (ou le volume
dun cylindre de hauteur 1 et de base un quart de disque de rayon 2).

7
Rsolution numrique dquations
Le but de ce chapitre est dexposer quelques mthodes de rsolutions dquations f (x) = 0, o f : I R
est une fonction dfinie sur un intervalle I. La fonction f sera suppose continue (et pour certaines
mthodes un peu plus que cela mme).
Ltude de ces mthodes passera par la description algorithmique de la mthode, permettant limplmentation dans un langage de programmation, puis par les justifications de convergence et de rapidit.
Pour assurer la convergence, il est parfois ncessaire dajouter des hypothses (assurant lexistence dune
solution, ce qui est souvent obtenu par le TVI, ou mme parfois, assurant lexistence dune solution suffisamment proche de la valeur dinitialisation, ce qui ncessite alors une localisation grossire pralable).
Par ailleurs, en cas de non unicit des solutions, mme en cas de convergence, il nest pas toujours possible
de savoir vers quel zro on aura convergence, si on neffectue pas un prtraitement permettant de sparer
les racines.
Les mthodes que nous tudions sont tout dabord la dichotomie (cette mthode est dailleurs une preuve
possible du TVI assurant lexistence dune solution), puis la mthode de la scante, et la version limite de cette mthode, qui est la mthode de Newton. La mthode de Newton est en quelque sorte
laboutissement de la mthode de la scante et assure une convergence plus rapide, mais elle ncessite la
connaissance de la drive. Cette drive peut tre donne explicitement par lutilisateur, ou peut tre
obtenue numriquement (mais cela ncessite que la courbe soit localement suffisamment lisse, car les microvariations ne pourront pas tre prises en considration par une mthode numrique). Nous abordons
le problme de la drivation numrique dans la dernire partie de ce chapitre.
La dichotomie et la mthode de Newton sont au programme de linformatique commune de MPSI/PCSI.
La mthode de la scante, ainsi que la drivation numrique, sont hors-programme.

Dichotomie

La dichotomie est une des preuves possibles de la dmonstration du thorme des valeurs intermdiaires.
Le principe est dencadrer de plus en plus finement un zro possible, sa prsence tant dtecte par un
changement de signe de la fonction, suppose continue. Ainsi :
Mthode 7.1.1 (Description de la mthode de dichotomie)
On initialise lencadrement par deux valeurs a0 < b0 telles que f change de signe entre a0 et b0 ,
cest--dire f (a0 )f (b0 ) 6 0.
On coupe lintervalle en 2 en son milieu. Puisquil y a changement de signe sur lintervalle, il y
a changement de signe sur lune des deux moitis. On conserve la moiti correspondante.

118

CHAPITRE 7. RSOLUTION NUMRIQUE DQUATIONS

a
|

a0
a1

b0
b1
b2
b3

a2
a3
a4

b4
x

Figure 7.1 Dichotomie


On continue de la sorte en coupant chaque tape lintervalle en deux, en gardant la moiti
sur laquelle il y a un changement de signe. On continue jusqu ce que lintervalle obtenu soit
de longueur suffisamment petite pour donner une valeur approche du zro la marge derreur
souhaite.
La mthode est illustre par la figure 7.1, et se traduit par lalgorithme suivant, en supposant initialement
que f (a)f (b) < 0 (il faudrait faire un test et retourner une erreur si ce nest pas le cas) :
Algorithme 7.1 : Dichotomie
Entre : f : fonction ;
a < b : intervalle initial de recherche, tel que f (a)f (b) < 0 ;
: marge derreur
Sortie : x : valeur approche prs dun zro de f sur [a, b]
tant que b a > faire
c a+b
2 ;
si f (a)f (c) 6 0 alors
bc
sinon
ac
fin si
fin tant que
renvoyer a+b
2
Remarquez quon obtient de la sorte une valeur approche
comparer b a 2.

en fait : on pourrait se contenter de

Proposition 7.1.2 (Validit et rapidit de lalgorithme de dichotomie)


La fonction f tant suppose continue, et en notant x la valeur retourne :

II

Mthode de la scante (HP)

119

(i) Lalgorithme sarrte (la terminaison est assure)


(ii) Il existe un zro de f dans lintervalle ]x , x + [


(iii) Le temps de calcul est en O ( ln()). Plus prcisment, le nombre dtapes est log2

ba



(iv) On peut aussi dire que la convergence est linaire (en (n)) en le nombre de dcimales obtenues
(donc en exprimant = 10n )

Remarque 7.1.3
On gagne un facteur 2 en prcision chaque itration. Ainsi, il faut un peu plus de 3 itrations pour
gagner une dcimale supplmentaire.
Par exemple, en partant dun intervalle initial de longueur 1, on obtient une prcision 1010 au bout
de 33 itrations.
Cela reste un bon algorithme, mais si f elle-mme est longue calculer, tout gain de complexit peut
tre important. Nous verrons un peu plus loin la mthode de Newton, bien plus efficace.
Remarque 7.1.4 (Comparatif de la mthode de dichotomie)
Points forts :
simplicit,
convergence assure,
vitesse raisonnable.
Points faibles :
Ncessite un encadrement pralable du zro ;
sil y a plusieurs zros dans lintervalle, on nen obtient quun
Moins rapide que la mthode de Newton, ou la mthode de la scante.

II

Mthode de la scante (HP)

a = c0
|

c3

b = c1
x

c2

Figure 7.2 Mthode de la scante


La mthode de la scante consiste remplacer dans le procd de dichotomie le choix du point milieu
par lintersection entre laxe des abscisses et la corde aux extrmits de lintervalle souhait, esprant
ainsi obtenir une meilleure approximation du zro recherch. Il faut alors choisir quelle moiti dintervalle

120

CHAPITRE 7. RSOLUTION NUMRIQUE DQUATIONS

on conserve avant de ritrer lopration ; Deux choix naturels peuvent se faire, dfinissant chacun une
mthode de rsolution :
On peut dcider de conserver lintervalle assurant un changement de signe, et procder comme dans
lalgorithme de dichotomie. On obtient alors un algorithme appel algorithme de la fausse position,
ou regula falsi. On peut montrer quune des deux bornes de lintervalle va converger vers la valeur
recherche, lautre tant stationnaire (en gnral distincte de la valeur recherche) : ainsi, contrairement lalgorithme de la dichotomie, la longueur de lintervalle considr ne tend pas vers 0, ce
qui pose le problme de la condition darrt. Par ailleurs, mme si sous des conditions raisonnables,
on contrle assez bien la complexit ( peu prs linaire en le nombre de dcimales souhaites),
certaines situations o la courbe est plate au voisinage du zro peuvent savrer catastrophiques.
Un deuxime choix possible est de conserver systmatiquement les deux dernires valeurs calcules,
dfinissant de la sorte lalgorithme de la scante. Ainsi, partant dun intervalle initial [a, b], et
en notant c0 = a et c1 = b, puis c2 la premire intersection, on conserve lintervalle [c1 , c2 ]
(ventuellement, les bornes sont dans lautre sens), on calcule la valeur c3 , puis on conserve [c2 , c3 ]
etc. Ainsi, lexistence dun zro dans lintervalle conserv nest pas assur, et le point suivant
peut sortir de lintervalle prcdent, voire le lintervalle initial, et mme du domaine de dfinition
de f . Cela complique un peu ltude de cet algorithme, en imposant dtudier des conditions de
convergence.
Mthode 7.2.1 (Mthode de la scante, figure 7.2)
On part dun intervalle [a, b] = [c0 , c1 ] sur lequel f est continue. On nimpose pas de changement
de signe sur cet intervalle.
On calcule c2 le point dintersection de la corde avec laxe des abscisses.
On refait pareil sur lintervalle [c1 , c2 ], puis [c2 , c3 ] etc, jusqu obtenir une approximation suffisante.
Les intervalles [cn , cn+1 ] sont comprendre par [cn+1 , cn ] si cn+1 < cn .
Ainsi, on na cette fois quune suite calculer, dtermine par la relation de rcurrence exprimant lintersection de la corde et de laxe des abscisses :
cn+1 cn
.
cn+2 = cn+1 f (cn+1 )
f (cn+1 ) f (cn )

La condition peut tre gre comme dans la mthode de la fausse position, ou alors en sarrtant lorsque
deux valeurs conscutives sont proches lune de lautre (mais le contrle de lerreur est alors moins bon).
On obtient lalgorithme 7.2.
Algorithme 7.2 : Mthode de la scante
Entre : f : fonction ;
a < b : intervalle initial ;
: marge derreur
Sortie : x : zro de f
rpter
(a)
c a f(ba)f
(b)f (a) ;
a, b b, c
jusqu ce que f change de signe sur [c , c + ] ou b a petit ;
renvoyer (c)

Avertissement 7.2.2 (La mthode nest pas toujours bien dfinie)


Comme on nimpose plus de changement de signe de f sur [cn , cn+1 ], la valeur de cn+2 peut
sortir de cet intervalle, et mme de lintervalle [a, b] initial : la corde peut tre presque parallle

II

Mthode de la scante (HP)

121

laxe des abscisses et cn+2 est dans ce cas loign de cn et cn+1 . Dans ce cas, cn+2 peut sortir
du domaine de dfinition.
Il nest pas exclu dailleurs que la corde soit parallle laxe des abscisses. Dans ce cas, cn+2
nest pas dfini du tout.

Lemme 7.2.3
Supposons f de classe C 2 sur [a, b], telle que f (a)f (b) < 0. Supposons que f ne sannule pas sur [a, b]
1
2
et soit m1 = min(|f |) > 0, et M2 = max(|f |). Si de plus, M
m1 |b a| < 2 , alors la fonction f admet
[a,b]

[a,b]

un unique zro x dans [a, b], la suite (cn )nN est bien dfinie, et il existe deux rels dn et dn lun dans
[x, cn+1 ], lautre dans [cn , cn+1 ], tels que pour tout n N,
|cn+2 x| 6

M2
|cn+1 x| |dn dn |.
m1

La suite (|cn x|)nN est alors dcroissante et converge vers 0.


Remarque 7.2.4
1
2
La condition M
m1 |b a| < 2 peut tre obtenue par restriction de lintervalle [a, b], si m1 et M2 sont
connus. Cela ncessite une localisation grossire du zro de f (par exemple par dichotomie).

Corollaire 7.2.5
Sous les mmes hypothses que le lemme 7.2.3, pour tout n N,
|cn+2 x| 6

1
|cn+1 x| |cn x|.
ba

Pour exploiter cette ingalit, on utilise les deux lemmes suivants :


Lemme 7.2.6
Soit (yn )nN une suite positive telle que pour tout n N, yn+2 6 yn+1 yn . Alors
n

o =

1+ 5
2

n N, yn 6 ,
1/

est le nombre dor, solution positive de lquation 2 = + 1, et = max(y0 , y1

).

Lemme 7.2.7
Soit (yn ) une suite positive telle quil existe ]0, 1[, M > 0 et > 0 tels que pour tout n N,
n
n
yn 6 M a . Alors il existe N > 0 et ]0, 1[ tels que pour tout n > N , yn 6 .
En particulier, en posant yn =

1
ba |cn

x|, on obtient :

Thorme 7.2.8 (Convergence locale de la mthode de la scante)


Supposons f de classe C 2 sur [a, b], tel que f (a)f (b) < 0. Supposons que f ne sannule pas sur [a, b] et
1
2
soit m1 = min(|f |) > 0, et M2 = max(|f |). Si M
m1 (b a) < 2 , il existe ]0, 1[ tel que, pour tout n
[a,b]

[a,b]

partir dun certain rang :

|cn x| 6 .

122

CHAPITRE 7. RSOLUTION NUMRIQUE DQUATIONS

On dit que la mthode est dordre .


Remarque 7.2.9
Plus gnralement, une mthode est dordre si, en notant (xn ) lapproximation de rang n et x la
valeur recherche, il existe ]0, 1[ tel que pour tout n partir dun certain rang, on ait :
n

|cn x| 6 .
Dire quune mthode est dordre signifie grossirement que le nombre de dcimales correctes est
multipli par chaque tape.
En effet,
n

log10 ( ) = n log10 ().

Or, cette expression donne peu prs le rang du premier chiffre non nul aprs la virgule de , donc
une minoration du rang du premier chiffre de |cn x|, donc une minoration du nombre des premires
dcimales communes cn et x.
Ainsi, le nombre de dcimales correctes est multipli par environ 1.618 par la mthode de la scante. En
supposant initialement b a = 1, et vrifiant les hypothses du thorme, en 5 itrations, on a dj 11
dcimales correctes, et en 10 itrations, on a plus de 100 dcimales ! La convergence est donc trs rapide,
beaucoup plus que la dichotomie.
Remarque 7.2.10
Si f (x) 6= 0, le rsultat prcdent assure la convergence de la mthode de la scante ds lors que
linitialisation se fait suffisamment proche du zro x. En effet, on peut contrler localement f et f et
restreindre lintervalle initial suffisamment pour rcuprer les hypothses idoines.

Remarque 7.2.11 (Comparatif de la mthode de la scante)


Points forts :
Convergence trs rapide (mthode dordre )
Facilit dexpression (ne ncessite pas la drive contrairement la mthode de Newton)
Points faibles :
Instabilit : on nest pas assur de la convergence ; il faut se placer suffisamment prs de la
racine pour avoir la convergence. la distance initiale dpend dun minorant de |f | et dun
majorant de |f |.
Condition darrt mal assure.

III

Mthode de Newton

La mthode de Newton est laboutissement. Lorsque la mthode de la scante converge, les valeurs des ci
sont de plus en plus proches, et la corde est alors une bonne approximation de la tangente. La mthode
de Newton consiste remplacer dans lalgorithme de la scante la corde par la tangente. On na alors
plus besoin des deux bornes de lintervalle (la seconde ne servait qu calculer la corde).
Mthode 7.3.1 (Mthode de Newton)
On suppose f drivable.
On part dune valeur initiale x0 .
On construit x1 comme lintersection de la tangente en x0 et de laxe des abscisses.
On itre cette construction.

III

Mthode de Newton

123

a = a0
|

Figure 7.3 Mthode de Newton


Proposition 7.3.2 (Rcurrence associe la mthode de Newton)
On a alors, pour tout n N, si la suite (xn ) est dfinie :
xn+1 = xn

f (xn )
.
f (xn )

On obtient donc lalgorithme 7.3.


Algorithme 7.3 : Mthode de Newton
Entre : f : fonction ; f : drive de f ;
a : valeur initiale ;
: marge derreur
Sortie : x : zro de f
rpter
a a

f (a)
f (a)

jusqu ce que f change de signe sur [a , a + ];


renvoyer (c)

Exemple 7.3.3 (Mthode de Heron)

La mthode de Heron pour le calcul de a nest rien dautre que la mthode de Newton applique
la fonction x 7 x2 a. La relation de rcurrence est alors :


a
1
xn +
.
xn+1 =
2
xn
Avertissement 7.3.4
Comme pour la mthode de la scante, la mthode de Newton peut tre mal dfinie (impossible
itrer).
Pour assurer la convergence, il faut donc se placer, comme pour la mthode de la scante, suffisamment
prs du zro recherch.

124

CHAPITRE 7. RSOLUTION NUMRIQUE DQUATIONS

Thorme 7.3.5 (Convergence locale de la mthode de Newton)


Soit f de classe C 2 sannulant en x. Supposons |f | > m1 et |f | 6 M2 sur B(x, ), et x0 B(x, ) tel
2
que |x x0 | M
m1 < 1. Alors :
2
pour tout n N, |xn+1 x| 6 |xn x|2 M
m1
n
il existe a ]0, 1[ tel que pour tout n assez grand, |xn x| 6 a2 .
En particulier, la mthode de Newton est dordre 2 : on double le nombre de dcimales correctes
chaque itration.

La mthode de Newton assure donc une convergence trs rapide, meilleure que la mthode de la scante.
Nous donnons un critre simple, frquemment vrifi (au moins aprs restriction), permettant dassurer
la convergence globale de la mthode de Newton.
Thorme 7.3.6 (Cas simple de convergence globale de la mthode de Newton)
Soit f une fonction de classe C 2 sur un intervalle [a, b], convexe et croissante, telle que f (a) < 0 < f (b).
Alors la mthode de Newton initialise par un point quelconque de [a, b] est convergente, et les valeurs
approches (xn ) successives calcules forment une suite dcroissante partir du rang 1 (et mme
partir du rang 0 si x0 vrifie f (x0 ) > 0, par exemple x0 = b).
Un nonc similaire est valable en cas de dcroissance ou en cas de concavit (cela peut changer suivant
les cas la monotonie de (xn ), ainsi que le ct qui fournit la dcroissance partir du rang 0 ; on pourra
saider dun dessin).

Remarque 7.3.7 (Comparatif de la mthode de Newton)


Points forts :
Convergence extrmement rapide
Points faibles :
Mmes problmes dinstabilit que la mthode de la scante : il faut initialiser prs du zro
pour tre assur de la convergence.
Utilisation de la drive de f , ncessitant dtre fournie par lutilisateur, ou calcule numriquement (mais cela nest satisfaisant que pour une fonction nayant pas trop de microvariations).

IV

Le problme de la drivation numrique (HP)

La mthode de Newton ncessitant lutilisation dune drivation numrique, on tudie maintenant une
mthode de drivation numrique, en essayant doptimiser lerreur.
Mthode 7.4.1 (Drivation numrique)
On approche f (x) par

f (x+h)f (xh)
,
2h

o h est suffisamment petit.

Proposition 7.4.2
Lerreur dapproximation thorique est de lordre de h2 , et lerreur darrondi de lordre de
est lerreur lmentaire.

|f (x)|
|h| r,

o r

IV

Le problme de la drivation numrique (HP)

125

Corollaire 7.4.3 (Valeur optimale de h)


Sous lhypothse que f et des premires drives sont de lordre de grandeur de 1 (ni trop petit, ni trop
gros) la valeur optimale de h minimisant lerreur entre f (x) et la valeur calcule

lordre de 3 r, o r est lerreur lmentaire.

f (x+h)f (xh)
2h

est de

En effet, on peut montrer laide de la formule de Taylor-Young, applique entre x et x+h, puis entre x et
(xh)
x h, que f (x+h)f
diffre de f (x) dun terme de lordre de grandeur de h2 . De plus, les grandeurs
2h
1
qui interviennent dans ces calculs sont de lordre de grandeur de f (x)
h , donc de h . Lerreur darrondi sur
r
ces termes sera donc de lordre de h . Ainsi, en sommant lerreur darrondi et lerreur thorique, on a une
erreur de lordre de h2 + hr . En minimisant cette fonction en h (par une tude de fonction par exemple),

on se rend compte quelle admet un minimum en une quantit 3 r.


Dans cette estimation, on a nglig les erreurs darrondi sur le calcul de x + h et x h. Ces erreurs sont
peu prs rduites 0 si h est une puissance de 2 (cela revient juste changer une successions de bits
01 . . . 1 en 10 . . . 0, ce qui se fait de faon exacte, sauf si cela rajoute un chiffre dans lcriture binaire,
ce qui fait sauter le chiffre de poids minimal. Lerreur est donc trs petite, ngligeable devant les autres
termes. Ainsi, on a tout intrt considrer pour h une puissance de 2. En norme IEEE 754, la mantisse
tant constitue de 52 bits, lerreur lmentaire est de lordre de 252 , donc la valeur de h optimale est
de lordre de 217 (ce qui correspond 105 environ, mais comme on la expliqu, il est prfrable de
rester en puissances de 2).

126

CHAPITRE 7. RSOLUTION NUMRIQUE DQUATIONS

8
Rsolution numrique dquations
diffrentielles
Le but de ce chapitre est de rpondre au problme suivant : tant donne une quation diffrentielle crite
sous la forme
x I, u (x) = f (u(x), x),
et une initialisation u(x0 ) = y0 , calculer une approximation de la fonction u sur lintervalle I.
On admet le thorme de Cauchy-Lipschitz donnant lunicit de la solution ce problme sous certaines
conditions, quon supposera runies.
La question initiale qui peut se poser est alors la faon de reprsenter la fonction solution u. Il serait vain
de penser pouvoir en donner une expression par des fonctions usuelles, et une reprsentation purement
numrique ne pourra tre complte (puisquon ne peut renvoyer quun nombre fini de valeurs). On pourra
distinguer deux situations :
On est intress par une description globale de toute la fonction. Dans ce cas, on peut choisir
un pas p suffisamment petit, et calculer les valeurs de u intervalles rguliers de pas p. On peut
complter ensuite par interpolation linaire (ou reprsenter par un graphe, qui lui-mme sera trac
par interpolation linaire, par exemple sous Python).
On nest intress que par la valeur en x. Dans ce cas, on fait de mme pour lintervalle [x0 , x],
au lieu de lintervalle global. On obtient alors une valeur approche de u(x), sans avoir besoin de
faire dinterpolation linaire.
Dans les deux cas, lide est la mme : elle consiste progresser par petits pas, et calculer chaque
tape une valeur approche au pas suivant partir des valeurs dj obtenues.
Ainsi, partant dun intervalle [a, b], o a = x0 , on en considre une subdivision a = x0 < x1 < < xn =
b, et on cherche ensuite des approximations des u(xk ).
Assez souvent, mais pas systmatiquement, on considrera pour (xk ) la subdivision rgulire dfinie pour
ba
est le pas constant de la subdivision.
tout k [[0, n]] par xk = a + kh, o h =
n
Notre but est de donner plusieurs mthodes dapproximation des valeurs u(xk ), et dtudier, pour la
plus simple des mthodes, la convergence des valeurs approches vers les valeurs exactes lorsque n tend
vers linfini. Le problme de la convergence se pose essentiellement pour les valeurs lointaines de x0 . En
effet les approximations aux points successifs tant calcules laide des approximations prcdentes, les
erreurs sajoutent de pas en pas : plus on sloigne de x0 , plus lapproximation obtenue va tre mauvaise.
Comme toujours en analyse numrique, les questions qui se posent sont les suivantes :
Rechercher des algorithmes donnant une erreur acceptable, en un temps raisonnable
Contrler prcisment lerreur
Trouver un compris entre temps de calcul et prcision.

128

CHAPITRE 8. RSOLUTION NUMRIQUE DQUATIONS DIFFRENTIELLES

Nous ne prtendons pas rpondre exhaustivement ces questions dans ce cours, dont le point de vue
se veut essentiellement descriptif et intuitif. Par exemple, le contrle prcis de lerreur est un problme
dpassant les techniques dont nous disposons.
Enfin, remarquons que mme si on expose les mthodes pour a < b (donc pour des valeurs de x suprieures
la valeur dinitialisation), tout ce quon dit est valable aussi lorsque b < a, en considrant lintervalle
[b, a]. Dans ce cas, le pas est ngatif, et on progresse vers larrire.

Mthode dEuler

Dans ce qui suit, on se donne une subdivision (xk )06k6n de lintervalle [a, b], et on note h son pas :
h=

max

k[[0,n1]]

xk+1 xk .

ba
Dans le cas dune subdivision rgulire, les valeurs xk+1 xk sont toutes gales ba
n , donc h = n .
La mthode dEuler est base sur une ide trs simple :
Lquation diffrentielle u = f (u, x) et la connaissance de u(x0 ) nous fournissent la connaissance
de u (x0 ), donc de la tangente la courbe en x0 .
On approche alors localement la courbe de u par sa tangente. Pour un pas suffisamment petit, on
peut considrer que cette approximation est valable sur tout lintervalle [x0 , x1 ].
On en dduit alors une valeur approche u
(x1 ) de u(x1 ).
On fait comme si cette valeur approche tait la valeur exacte : en utilisant lquation diffrentielle,
on en dduit une valeur approche u (x1 ) de u (x1 ).
On approche nouveau la courbe de u par sa tangente, elle-mme approche par la droite calcule
laide des valeurs approches calcules de u(x1 ) et u (x1 ). Cest cette droite qui approche la
tangente quon prend comme nouvelle approximation pour le calcul de u(x2 ).
On continue de la sorte.
La construction est illustre par la figure 8.1. On se rend vite compte quon accumule les erreurs et que
pour des valeurs loignes de x0 , lapproximation risque de ne pas tre trs bonne. Vous illustrerez ces
problmes de divergence en TP.
Remparquons aussi que si u est dfinie sur un intervalle semi-infini (du type [0, +[ par exemple), on
ne peut pas dfinir le pas en fonction de la longueur de lintervalle total : on considre dans ce cas une
subdivision suffisamment petite, et on progresse jusquaux valeurs de la variable qui nous intresse. Il
faut faire attention au fait quen gnral, quelle que soit la valeur h > 0 du pas quon se donne, lorsque le
nombre de pas effectus tend vers linfini, la solution approche obtenue sloigne fortement de la solution
thorique.

Mthode 8.1.1 (Mthode dEuler)


Conformment aux explications prcdentes, la mthode dEuler consiste approcher u(xk ) par la
valeur uk = u(xk ), calcule par la rcurrence suivante :
u 0 = y0

et

k [[0, n 1]], uk+1 = f (uk , xk )(xk+1 xk ) + uk .

Si la subdivision est rgulire, de pas constant h =

ba
n ,

on peut rcrire la relation de rcurrence :

k [[0, n 1]], uk+1 = hf (uk , xk ) + uk .


Proposition 8.1.2 (Majoration de lerreur pour le calcul de u1 )
Soit u une fonction de classe C 2 sur [a, b], et M2 un majorant de |u |. Alors, si h dsigne le pas de la
subdivision (non ncessairement rgulire), cest--dire h = max(xk+1 xk ), alors
|u1 u(x1 )| 6

M2 2
h .
2

Mthode dEuler

129

tangente thorique en x2
Courbe thorique de u
tangente avec pente approche en x2
tangente approche en x2
tangente thorique en x1
tangente avec pente approche en x1
tangente approche en x1

u(x3 )

u
(x3 )
u(x2 )

tangente en x0

u
(x2 )
u(x1 )
u
(x1 )
u(x0 )
|

x0

x1

x2

x3

Figure 8.1 Mthode dEuler

Dans le cas dune subdivision rgulire en n intervalles, cela donne :


|u1 u(x1 )| 6

M2 (b a)2
.
2
n2

Proposition 8.1.3 (Ingalit de rcurrence pour lerreur)


Soit f de classe C 2 sur [a, b] et M2 comme ci-dessus. Supposons que f est L-lipschitzienne par rapport
sa premire variable. En notant, pour tout k [[0, n]], ek = |u(xk ) uk |, on a :
k [[0, n]], ek+1 6 (hL + 1)ek +

M2 2
h .
2

Corollaire 8.1.4 (Majoration de lerreur)


Sous les mmes hypothses sur f , en ngligeant les erreurs darrondi dans les calculs, lerreur faite sur
le calcul de u(xk ) vrifie :
k N, ek 6


M2 h
M2 h
(1 + hL)k 1 6 ekhL
.
2L
2L

Cette majoration reste valable mme pour des valeurs de k dpassant n, si on poursuit la mthode
dEuler au-del de la valeur b, condition que M2 soit un majorant de |u | sur lintervalle idoine, mais
dans ce cas, on a un contrle exponentiel divergent, donc trs mauvais (ce qui explique la possibilit
dune divergence forte par rapport la solution thorique).

130

CHAPITRE 8. RSOLUTION NUMRIQUE DQUATIONS DIFFRENTIELLES

Si on reste dans lintervalle compact [a, b], on obtient une majoration uniforme de lerreur :
k [[0, n]], ek 6

M h (ba)L
e
.
2L

Nous tudions maintenant lexemple particulier de lquation diffrentielle u = au, avec u(0) = 1.
videmment, la solution thorique est bien connue, il sagit de lexponentielle : x 7 eax . La connaissance
de la solution thorique va nous permettre de dterminer de faon plus prcise lerreur faite par la
rsolution par la mthode dEuler, dans ce cas particulier. Notre but par ltude de cet exemple est de
montrer quen gnral, on ne peut pas avoir un meilleur contrle en + (lorsquon continue la mthode
au-del du point b) que ce contrle exponentiel obtenu dans le corollaire qui prcde.
On considre ici le pas h = n1 . Implicitement, cela revient considrer lintervalle initial dtude [0, 1],
puis prolonger le calcul linfini.
On montre qualors, on a, pour tout k N,

a k
uk = 1 +
n

On vrifie dailleurs la cohrence de ce rsultat au point 1 correspondant k = n, lexpression trouve


tant de limite ea (calcul classique et facile).
Lerreur sexprime alors de faon exacte :


 
ak 

k
k
a k



n
u k = e 1 +
ea n .
ek = u
n
n k+

Ainsi, pour tout pas


sur cet exemple.

1
n

fix, la mthode dEuler prolonge linfini donne une divergence exponentielle

Remarque 8.1.5 (Mthode dEuler pour f indpendante de u)


Si f ne dpend que de x, lquation rsoudre est y = f (x). Il sagit dune primitivation, donc dun
calcul dintgrale. La relation de rcurrence sur les termes uk est alors simplement
yk+1 = yk + f (xk )h.
On se rend compte que la mthode dEuler applique cette situation correspond trs prcisment
la mthode des rectangles pour le calcul des intgrales, dont on connait bien la lenteur et le manque
defficacit...

II

Notion dordre dune mthode

De faon gnrale, lorsquon dispose dune mthode de rsolution approche dquations diffrentielles, on
veut pouvoir estimer son efficacit, et en particulier lerreur dapproximation faite par cette mthode. Les
calculs exacts sont parfois durs mener : majorer de faon exacte lerreur dans le cas de la mthode particulirement simple dEuler a dj demand beaucoup de travail. Pour des mthodes plus sophistiques,
cela relve quasiment de lexploit !
On opre alors une hypothse simplificatrice pour le calcul de lerreur, en ngligeant lerreur faite sur la
pente lors du calcul de la tangente approche. Ainsi, notant fk lerreur induite par ltape k, lerreur total
au rang k est
k
X
fi .
ek =
i=1

ek+1

ek

fk+1
.

Pour tout k [[1, n 1]], on a donc


= +
Par ailleurs, on fait la supposition, pour le calcul de lerreur la k-ime tape que la valeur calcule u(xk )
est la valeur exacte. Ainsi, lerreur approche fk faite la k-ime tape se calcule de la mme manire que

II

Notion dordre dune mthode

131

celle de la premire tape, lorsquon dispose des valeurs exactes (figure 8.2). Lerreur totale ainsi obtenue
est alors
n
X
ek =
fk .
i=1

u(xk+1 )
fk
ek+1
ek
uk+1
u(xk )
ek
uk
|

xk

xk+1

Figure 8.2 Erreurs pour la mthode dEuler


On dfinit alors lerreur de consistance par :
Dfinition 8.2.1 (Erreur de consistance)
Lerreur de consistance dune mthode de rsolution dED est la quantit :
e(h) =

n
X

k=1

|uk u(xk )|,

o h = ba
n , et uk est la valeur approche quon obtiendrait par la mthode utilise, en prenant comme
point de dpart (xk , y(xk )) (donc la valeur thorique).

Dfinition 8.2.2 (Ordre dune mthode)


Lordre dune mthode de rsolution numrique dED est lordre de la puissance de h contrlant lerreur
de consistance.
Exemple 8.2.3 (Ordre de la mthode dEuler)
Le calcul de |u1 u(t1 )| effectu plus haut pour la mthode dEuler est valable plus gnralement pour
le calcul de |uk u(xk )|. On obtient alors lerreur de consistance :
e(h) 6

n
X
M2

k=1

Ainsi, la mthode dEuler est dordre 1.

h2 =

M2 (b a)
h.
2

132

CHAPITRE 8. RSOLUTION NUMRIQUE DQUATIONS DIFFRENTIELLES

Remarques 8.2.4
1. La majoration de lexemple prcdent ne donne stricto sensu pas lordre de la mthode, mais
seulement une minoration de lordre. Pour justifier que lordre est exactement 1, il faut montrer
quon ne peut pas obtenir une meilleure convergence en exhibant un cas particulier dans lequel
on sait calculer lerreur de consistance de faon exacte. On pourrait reprendre lexemple de
lexponentielle et calculer lerreur de consistance dans ce cas particulier afin de conclure.
2. Trs souvent, on peut obtenir une majoration uniforme |uk u(xk )| 6 M ha , valable sur tout
lintervalle [a, b] (cest--dire pour tout k [[1, n]]). Lordre de la mthode est dans ce cas (au
moins) a 1.

III

quations diffrentielles dordre suprieur

On admet que la mthode dEuler reste valable pour des fonctions vectorielles U : R Rp , et f :
Rp R Rp vrifiant U (t) = f (U (t), t). On pourra alors ramener une quation diffrentielle linaire
dordre p cette situation, aprs mise sous forme normale :
u(p) (t) = F (u(t), u (t), , u(p1) (t), t).
Il suffit pour cela de poser la fonction vectorielle

u(t)

u (t)

.
U : t 7
..

.
u(p1) (t)

u0
.

En notant U =
.. , cette fonction vectorielle est alors solution de lquation diffrentielle
up1

u1 (t)

..

.
.
U (t) =

up1 (t)

F (u0 (t), . . . , up1 (t), t)

Il suffit donc de dfinir F par


f (x0 , . . . , xp1 , t) = (x1 , . . . , xp1 , F (x0 , . . . , xp1 , t)).
Cette manipulation peut aussi tre faite en vue dutiliser la fonction odeint (ODE pour Ordinary Differential Equation) du module scipy.integrate, prenant en argument une fonction f , une valeur initiale
y0 et un tableau T de temps (la subdivision de lintervalle en laquelle calculer les valeurs de u), et revoyant
sous forme dun tableau les valeurs de u aux temps de T . La fonction f peut tre vectorielle ; dans ce
cas, les donnes vectorielles de Rp doivent tre rentres sous forme dune liste de coordonnes (ou dun
tableau numpy).
La fonction odeint ci-dessus est base sur la mthode de Runge-Kutta dordre 4. Mme si les mthodes
de Runge et Kutta sont hors programme, nous les voquons ci-dessous (dun point de vue purement
descriptif), afin de comprendre comment est dfinie cette fonction odeint. Il sagit de mthodes bases
sur le mme principe que la mthode dEuler (qui en est dailleurs un cas particulier).

IV

IV

Mthode de Runge-Kutta, HP

133

Mthode de Runge-Kutta, HP

La mthode de Runge-Kutta a t mise au point au tout dbut du 20e sicle par Carl Runge et Martin
Wilhelm Kutta, deux mathmaticiens allemands.
Lide est grossirement la mme que pour la mthode dEuler : on subdivise lintervalle dtude, et on
approche chaque tape la courbe par une certaine droite, dont la pente est choisie judicieusement. Dans
la mthode dEuler, la pente choisie est la pente de la tangente au point initial de lintervalle. La mthode
de Runge-Kutta consiste prendre comme pente une meilleure valeur approche de la pente moyenne
entre xk et xk+1 : cette pente moyenne nous donnerait alors la valeur exacte de u(xk+1 ) (si on part de la
valeur exacte de u(xk )). Plus on sapproche de cette pente, plus lerreur va tre petite.
Lide est alors de faire une moyenne des pentes en diffrents points rpartis de faon dtermine sur
lintervalle [xk , xk+1 ] (figure 8.3). Ces pentes en des points intermdiaires seront elles mme calcules de
faon approche par une mthode de type Euler. Les diffrentes mthodes de Runge-Kutta correspondent
alors au choix du nombre de points intermdiaires pour le calcul de la pente moyenne approche, et au
choix de leur rpartition dans lintervalle [xk , xk+1 ].

p5
pente moyenne thorique
pente calcule (moyenne des pi )

u(xk+1 )

p4

p3

u(xk )
|

xk

xk+1

p1

p2

Figure 8.3 Pente moyenne sur un intervalle [xk , xk+1 ]

Soit s un entier (correspondant au nombre de points intermdiaires pour le calcul de la moyenne des
pentes). Soit 1 6 6 s des rels de [0, 1] donnant la rpartition des points q1 , . . . , qs dans [xk , xk+1 ],
(les i correspondent une paramtrisation linaire par [0, 1] de lintervalle [xk , xk+1 ]). Ainsi :
qi = xk + i h,
o h = xk+1 xk est le pas de la subdivision, suppose rgulire. Soit ensuite (1 , . . . , s ) un s-uplet de
rels de [0, 1] tels que
1 + + s = 1.

u(xk+1 ) u(xk )
On approche la pente moyenne p =
sur lintervalle [xk+1 , xk ] par la moyenne pondre
h
par les i des pentes thoriques aux points qi , savoir :
p

s
X

i f (u(qi ), qi ).

i=1

Comme on ne connat pas prcisment u(qi ), on utilise une approximation des u(qi ), calcule suivant le
mme procd que dans la mthode dEuler, par approximations successives.

134

CHAPITRE 8. RSOLUTION NUMRIQUE DQUATIONS DIFFRENTIELLES

Mthode 8.4.1 (calcul dune valeur approche de la pente moyenne sur [x0 , x1 ])
Pour expliquer la construction, plaons-nous sur lintervalle [x0 , x1 ]. Ainsi, u(x0 ) = y0 est connu. En
notant pi la pente calcule au point qi , on procde de la sorte :
On calcule p1 par la mthode dEuler en partant de xk . On commence par dterminer une valeur
approche v1 de u(q1 ) :
v1 = u(x0 ) + (q1 x0 )f (u(x0 ), x0 ).
On dfinit alors p1 = f (v1 , q1 )
On calcule p2 en repartant du dbut de lintervalle (en x0 ), mais en approchant cette fois la
courbe par la droite de pente p1 calcule dans ltape prcdente, et issue du point (x0 , u(x0 )).
Une approximation de u(q2 ) est alors :
v2 = u(x0 ) + (q2 x0 )p1

et

p2 = f (v2 , q2 ).

De faon plus gnrale, pk tant dtermin, pk+1 est calcul en repartant de x0 et en approchant
la courbe par une droite de pente pk issue de (x0 , u(x0 )) :
vk+1 = u(x0 ) + (qk+1 x0 )pk

et

pk+1 = f (vk+1 , qk+1 ).

Les pi tant tous dtermins ainsi, on approche p la pente moyenne sur [x0 , x1 ] (cest--dire le
taux daccroissement) par
s
X
i pi .
p
i=1

Mthode 8.4.2 (Mthode de Runge-Kutta)


Les i (donc la rpartition des qi dans un intervalle [xk , xk+1 ]) et les poids i tant donns, la mthode
de Runge Kutta sopre de la faon suivante : on calcule successivement des valeurs approches uk de
u(xk ). Supposant uk dtermin, on dtermine uk+1 ainsi :
on calcule une approximation p de la pente sur [xk , xk+1 ] comme expliqu ci-dessus, en considrant quon peut remplacer dans les calculs la valeur exacte u(xk ) par la valeur approche
uk .
On calcule uk+1 en approchant u sur [xk , xk+1 ] par la droite issue de (xk , uk ), de pente p :
uk+1 = uk + hp.

Nous explicitons ci-dessous les trois cas les plus frquents (mthodes Runge-Kutta dordre 1, 2 et 4),
obtenues pour certains choix de s, des rpartitions i et des pondrations i .
Dfinition 8.4.3 (Mthode de Runge-Kutta dordre 1, RK1)
La mthode de Runge-Kutta dordre 1 consiste en le choix de s = 1 (un seul point pour obtenir
lapproximation), 1 = 1 et 1 = 0 (pour faire la moyenne, on considre la pente au bord gauche de
lintervalle)

On reconnait videmment une mthode dj tudie !


Proposition 8.4.4 (RK1 = Euler)
La mthode de Runge-Kutta dordre 1 nest autre que la mthode dEuler. Cela justifie son ordre 1.

IV

Mthode de Runge-Kutta, HP

135

u(xk+1 )

uk+1
u(xk )

p1 = p
|

xk+1

xk

Figure 8.4 Runge-Kutta dordre 1

Dfinition 8.4.5 (Mthode de Runge-Kutta dordre 2, RK2)


La mthode de Runge-Kutta dordre 2 consiste en le choix de s = 1, 1 = 1 et 1 = 21 .

u(xk+1 )

uk+1
p1
p1

u(q1 )
u(xk )
|

xk

q1

xk+1

Figure 8.5 Runge-Kutta dordre 2


Ainsi, dans cette mthode, la pente moyenne est approche par la pente au point mdian. Graphiquement,
ce choix semble bien meilleur (figure 8.5). Dailleurs, on a dj rencontr une mthode danalyse numrique
dans laquelle le choix du point mdian tait judicieux. Les deux situations ne sont dailleurs pas sans
rapport lune avec lautre :
Remarque 8.4.6 (RK2 et mthode du point milieu)
La mthode RK2 pour la rsolution de y = f (x) nest autre que le calcul intgral par la mthode du
point milieu.

136

CHAPITRE 8. RSOLUTION NUMRIQUE DQUATIONS DIFFRENTIELLES

Mthode 8.4.7 (Calcul des approximations successives par RK2)


Suivant la description gnrale, uk tant connu, on obtient uk+1 par la mthode RK2 de la faon
suivante :
h
h
p = f (v, xk + )
uk+1 = uk + hp.
v = uk + f (uk , xk )
2
2

Thorme 8.4.8 (ordre de RK2)


Comme son nom lindique, la mthode RK2 est une mthode dordre 2 (si f est lipschitzienne).

On prsente maintenant lalgorithme de Runge-Kutta classique, appel algorithme de Runge-Kutta


dordre 4, pour une raison que je vous laisse deviner. Cest lalgorithme de rsolution numrique dED le
plus frquemment employ, du fait quil allie simplicit de programmation (une fois quon a compris la
mthode) et rapidit de convergence. Cette rapidit de convergence est aussi ce qui assure la fiabilit du
calcul, puisquelle permet dviter une trop grande accumulation derreurs darrondi.
Dfinition 8.4.9 (Mthode de Runge-Kutta dordre 4, RK4)
La mthode de Runge-Kutta dordre 4 consiste en le choix de s = 4, de la rpartition (1 , 2 , 3 , 4 ) =

(0, 21 , 12 , 1), et des pondrations (1 , 2 , 3 , 4 ) = 16 , 26 , 26 , 16 .
Le fait de choisir deux fois le mme point nest pas redondant : en notant q ce point milieu, on commence
par trouver une premire approximation de la valeur de u(q), donc une premire approximation de la
pente p en q, puis, on en recalcule une nouvelle approximation (quon espre meilleure, ou au moins
compensant lerreur prcdente) en utilisant cette fois pour le calcul la nouvelle pente choisie (voir figure
8.6).

p4
u(xk+1 )
uk+1

p moyen

p3
p2
p2

u(q1 )
p1

u(xk )
|

xk = q1

q2 = q3

xk+1 = q4

Figure 8.6 Runge-Kutta dordre 4

Mthode 8.4.10 (Calcul des approximations successives par RK4)


Suivant la description gnrale, uk tant connu, on obtient uk+1 par la mthode RK4 par lenchanement
suivant de calculs :
v1 = uk

IV

Mthode de Runge-Kutta, HP

137

p1 = f (v1 , xk )
v2 = uk + h2 p1
p2 = f (v2 , xk + h2 )
v3 = uk + h2 p2
p3 = f (v3 , xk + h2 )
v4 = uk + hp3
p4 = f (v4 , xk + h)
p = 61 (p1 + 2p2 + 2p3 + p4 )
uk+1 = uk + ph.

Le choix des pondrations 1, 2, 2, 1, les deux points du milieu tant confondus, nous rappelle la pondration
1, 4, 1 de la mthode de Simpson. Ici aussi, la mthode de Simpson peut tre vue comme un cas particulier
de la mthode RK4 :
Remarque 8.4.11 (RK4 et mthode de Simpson)
La mthode RK4 applique la rsolution de y = f (x) nest autre que la mthode de Simpson.

Cette constatation peut nous faire esprer une trs bonne convergence et efficacit de la mthode RK4 !
En effet, on obtient, sans suprise vu le nom donn la mthode :
Thorme 8.4.12 (Ordre de la mthode RK4, admis)
La mthode RK4 est dordre 4.

138

CHAPITRE 8. RSOLUTION NUMRIQUE DQUATIONS DIFFRENTIELLES

9
Rsolution numrique de systmes
linaires
Le but de ce chapitre est ltude de mthodes algorithmiques de rsolutions de systmes AX = B, o
A Mn,p (R) et B Mn,1 (R), linconnue X tant un lment de Mp,1 (R). On peut bien sr aussi
travailler avec des coefficients complexes (en utilisant un langage manipulant des complexes, ce qui est
le cas de Python), ou dans tout autre corps (si le langage connait les oprations dans ce corps, quelles
soient implmentes initialement, ou quelles aient t programmes par la suite).
Savoir rsoudre de tels systmes est dune importance capitale dans de nombreux domaines, par exemple
en physique, en ingnirie, ou encore dans toute limagerie vectorielle (limage pixlise est reprsente
par une matrice ; de nombreuses oprations sur les images ncessitent alors des rsolutions de systmes
de taille importante). Dans ces domaines, les systmes rencontrs sont souvent de trs grande taille. Il
est donc essentiel de savoir les rsoudre de la faon la plus efficace possible. Nous nous contentons dans
ce chapitre de rappeler la mthode du pivot, de tester laspect numrique, et dtudier rapidement sa
complexit. Nous introduisons galement la dcomposition A = LU dune matrice (Lower-Upper), donc
en produit dune matrice triangulaire infrieure et triangulaire suprieure : cela permet de ramener la
rsolution dun systme la rsolution de 2 systmes triangulaires. Enfin, nous traitons de problmes
dinstabilit numriques, quon peut rencontrer dans le cas o le rsultat dun systme est trs sensible
une petite variation du second membre. Nous introduisons la notion de conditionnement, permettant de
mesurer cette sensibilit, mais sans pour autant entrer dans une tude approfondie de cette notion.

Structures de donnes adaptes en Python

Pour tout travail sur des donnes vectorielles et matricielles, nous utiliserons le module numpy de Python.
Nous le supposerons import sous lalias np.
Le module numpy dfinit en particulier un type array, sur lequel sont dfinies certaines oprations matricielles usuelles. Nous renvoyons au chapitre 2 pour une description plus complte de ce module et des
possibilits offertes. Nous renvoyons laide de Python pour une description exhaustive.
Linstruction permettant de construire un tableau est np.array. Elle transforme une liste simple dobjets
de mme type numrique en tableau une ligne.
>>> A = np.array([1,3,7,9])
>>> A
array([1, 3, 7, 9])
>>> type(A)
<class numpy.ndarray>
>>> np.array([1,3,7,a])

140

CHAPITRE 9. RSOLUTION NUMRIQUE DE SYSTMES LINAIRES


array([1, 3, 7, a],
dtype=<U1)

Le deuxime exemple ci-dessus montre la ncessit de lhomognit des lments du tableau, qui doivent
tous tre de mme type : les donnes numriques sont converties en chanes de caractres (linverse ntant
pas possible). Le dtype indique un code pour le type des donnes (ici un texte en unicode)
Une liste de listes sera transforme en tableau bi-dimensionnel, chaque liste interne tant une des lignes
de ce tableau. Il est videmment ncessaire que toutes les listes internes aient la mme taille. Dans le cas
contraire, lobjet cr sera un tableau unidimensionnel, dont les attributs sont de type list. Linstruction
rank donne la dimension spatiale du tableau (donc le degr dimbrication) : 1 pour un tableau ligne, 2
pour une matrice, etc.
>>> A = np.array([[1,2,3],[3,6,7]])
>>> A
array([[1, 2, 3],
[3, 6, 7]])
>>> type(A)
<class numpy.ndarray>
>>> np.rank(A)
2
>>> B = np.array([[1,2,3],[3,6]])
>>> B
array([[1, 2, 3], [3, 6]], dtype=object)
>>> np.rank(B)
1
Le deuxime exemple illuste le fait que du point de vue de Python, B nest pas bidimentionnel, mais est
un tableau ligne, dont chaque donne est une liste.
On peut bien sr crer des objets de dimension plus grande :
>>> C =
np.array([[[[1,2],[3,4]],[[5,6],[7,8]]],[[[9,10],[11,12]],[[13,14],
[15,16]]]])
>>> C
array([[[[ 1, 2],
[ 3, 4]],
[[ 5, 6],
[ 7, 8]]],

[[[ 9, 10],
[11, 12]],
[[13, 14],
[15, 16]]]])
>>> np.rank(C)
4
La dimension spatiale est suggre par les sauts de ligne.
On peut rcuprer le format (nombre de lignes, de colonnes, etc) grce la fonction shape :
>>> np.shape(A)

Structures de donnes adaptes en Python

141

(2, 3)
>>> np.shape(B)
(2,)
>>> np.shape(C)
(2, 2, 2, 2)

Remarque 9.1.1 (tuple de taille 1)


Notez la syntaxe particulire pour le format de B. Cette syntaxe permet de diffrencier lentier 2 du
tuple (2, ) constitu dune unique coordonne. La virgule est ncessaire, car les rgles de parenthsage
ne permettent pas de diffrencier 2 et (2). Nous retrouverons cette syntaxe par la suite.
Comme les listes, les tableaux sont des objets mutables. Il faut donc faire attention la dpendance
possible entre plusieurs copies dun tableau :
>>> D = A
>>> D
array([[1, 2, 3],
[3, 6, 7]])
>>> A[1,1]= 8
>>> A
array([[1, 2, 3],
[3, 8, 7]])
>>> D
array([[1, 2, 3],
[3, 8, 7]])
On peut viter ce dsagrment en utilisant la fonction np.copy, quivalent de deepcopy pour les tableaux :
>>> D = np.copy(A)
>>> A[1,1]=10
>>> A
array([[ 1, 2, 3],
[ 3, 10, 7]])
>>> D
array([[1, 2, 3],
[3, 8, 7]])

Remarque 9.1.2 (Diffrences entre un tableau numpy et une liste)


Toutes les entres doivent tre de mme type
Le format est immuable, et dfini la cration du tableau : on ne peut pas modifier ce format en
place (suppression ou ajout de ligne...), moins de dfinir une nouvelle variable. En particulier,
cela ncessite de dfinir ds le dbut un tableau de la bonne taille, par exemple rempli de 0 ou
de 1. Il existe des fonctions permettant de le faire sans effort.

# Cration dun tableau de 0


>>> np.zeros(5)
array([ 0., 0., 0., 0., 0.])
>>> np.zeros((5,3))
array([[ 0., 0., 0.],
[ 0., 0., 0.],

142

CHAPITRE 9. RSOLUTION NUMRIQUE DE SYSTMES LINAIRES


[ 0., 0., 0.],
[ 0., 0., 0.],
[ 0., 0., 0.]])
# Cration dun tableau de 1
>>> np.ones(3)
array([ 1., 1., 1.])
>>> np.ones((3,8))
array([[ 1., 1., 1., 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1., 1., 1., 1.]])
# Cration de la
>>> np.eye(3)
array([[ 1., 0.,
[ 0., 1.,
[ 0., 0.,

matrice identit I (prononcez langlaise!)


0.],
0.],
1.]])

# Cration dune matrice diagonale:


>>> np.diag([1,3,2,7])
array([[1, 0, 0, 0],
[0, 3, 0, 0],
[0, 0, 2, 0],
[0, 0, 0, 7]])
# Cration dune matrice (f(i,j,k,...))
>>> def f(i,j):
...
return i+j
...
>>> np.fromfunction(f,(3,4))
array([[ 0., 1., 2., 3.],
[ 1., 2., 3., 4.],
[ 2., 3., 4., 5.]])
>>> np.fromfunction(lambda x: x**2 ,(6,))
array([ 0., 1., 4., 9., 16., 25.])
Remarquez dans la dernire fonction lutilisation du tuple (6, ) pour dsigner le format dun tableau ligne.
On peut aussi crer des tableaux de valeurs uniformment espaces :
# Cration dun tableau de valeurs rgulirement espaces entre a et b
# en imposant le nombre de valeurs
# Attention au fait que a et b sont comptabiliss dans les n valeurs.
>>> np.linspace(5,9,10)
array([ 5.
, 5.44444444, 5.88888889, 6.33333333, 6.77777778,
7.22222222, 7.66666667, 8.11111111, 8.55555556, 9.
])
>>> np.linspace(5,9,11)
array([ 5. , 5.4, 5.8, 6.2, 6.6, 7. , 7.4, 7.8, 8.2, 8.6, 9. ])
# Cration dun tableau de valeurs rgulirement espaces entre a et b
# en imposant le pas
# Attention au fait que la borne b est prise au sens strict.
>>> np.arange(5,10,0.5)

II

Rappels sur la mthode du pivot de Gauss

143

array([ 5. , 5.5, 6. , 6.5, 7. , 7.5, 8. , 8.5, 9. , 9.5])


>>> np.arange(5,10,0.7)
array([ 5. , 5.7, 6.4, 7.1, 7.8, 8.5, 9.2, 9.9])
De nombreuses oprations matricielles sont dfinies. Attention aux faux amis cependant. Comme on la
vu, np.rank ne correspond pas au rang de la matrice, mais sa dimension spatiale. Autre faux ami :
le produit A B nest pas le produit matriciel usuel, mais le produit de Schur (produit coordonne par
coordonne). Le produit matriciel est donn par la fonction np.dot
>>> A = np.array([[1,2],[3,4]])
>>> B = np.array([[2,2],[0,3]])
# Produit de Schur
>>> A*B
array([[ 2, 4],
[ 0, 12]])
# Produit matriciel
>>> np.dot(A,B)
array([[ 2, 8],
[ 6, 18]])
# Autre syntaxe possible, par suffixe:
>>> A.dot(B)
array([[ 2, 8],
[ 6, 18]])
Les fonctions les plus utiles sont dcrites dans le chapitre 2. Retenons en particulier (puisque cest ce qui
nous intresse dans ce chapitre) la fonction np.linalg.solve pour la rsolution dun systme AX = B
(le vecteur B doit tre donn sous forme dun tableau ligne, ou dune liste)
>>> np.linalg.solve(np.array([[1,3],[2,-3]]),[1,4])
array([ 1.66666667, -0.22222222])
Cette fonction ne rsout que les systmes de Cramer :
>>> np.linalg.solve(np.array([[1,3],[2,6]]),[1,2])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/usr/lib64/python3.3/site-packages/numpy/linalg/linalg.py",
line 328, in solve
raise LinAlgError(Singular matrix)
numpy.linalg.linalg.LinAlgError: Singular matrix

II

Rappels sur la mthode du pivot de Gauss

La mthode du pivot est une mthode dchelonnement dune matrice donne, par oprations admissibles
(cest--dire rversibles) sur les lignes. Ces oprations prservent le noyau, donc les solutions du systme
homogne. Si on effectue les mmes oprations sur la matrice colonne B du second membre, on obtient
le mme espace affine de solutions.
On rappelle que les oprations admissibles sont :
Li Lj : lchange de deux lignes (permutation)
Li Li : la multiplication dune ligne par un scalaire non nul (dilatation)
Li Li + Lj : lajout une ligne dune autre, multiplie par un scalaire (transvection).
On rappelle que ces oprations correspondent matriciellement la multiplication gauche par certaines
matrices de codage (voir le cours de mathmatiques).

144

CHAPITRE 9. RSOLUTION NUMRIQUE DE SYSTMES LINAIRES

On rappelle les grandes lignes de lalgorithme dchelonnement de Gauss :


Mthode 9.2.1 (chelonnement par la mthode du pivot)
On cherche un lment non nul dans la premire colonne ;
Le choix du pivot est important. Pour des raisons de prcision numrique, il est judicieux
de choisir le pivot de valeur absolue maximale. On fera aussi attention au test 0, faire
sous forme dune ingalit, et non dune galit stricte, si on ne veut pas avoir de surprises
dsagrables.
Si on nen trouve pas, on passe la colonne suivante, et on recommence de mme.
Si on en trouve, on le positionne en haut par un change. Cest notre premier pivot. On annule
tous les autres coefficients de la premire colonne laide de celui-ci, par des oprations de
transvection, puis on passe la colonne suivante, mais en ne touchant plus la premire
ligne (contenant le premier pivot). En particulier, la recherche dun pivot suivant ne se fera
pas sur la premire ligne, et ce pivot ne sera remont que sur la deuxime ligne.
On continue de la sorte jusqu puisement des colonnes de A. Les diffrents pivots se positionnent sur les lignes successives.
Quitte faire des oprations de dilatation, on peut sarranger pour qu lissue du calcul, tous
les pivots soit gaux 1.

Mthode 9.2.2 (Pivot remontant)


Quitte conserver en mmoire la liste des indices de colonne des pivots, on retrouve facilement
la position et la valeur des pivots. On peut alors, par des oprations de tranvection, annuler
tous les coefficients situs au dessus des pivots, de sorte ce que les pivots soient les seuls
composantes non nuls de leurs colonnes.
On fera attention a tre conome en calcul pour cette tape : commencer par le dernier pivot
vite de manipuler trop de termes non nuls (et donc daccumuler des erreurs sur des termes qui
nous intressent). Par ailleurs, il est inutile de faire les oprations sur les colonnes prcdant le
pivot (oprations triviales, mais qui prennent du temps informatiquement parlant).
Dans le cas de la rsolution dun systme AX = B, en faisant en parallle les mmes oprations sur B,
on obtient donc un systme quivalent A X = B , o A est chelonne, de pivots tous gaux 1, les
lments situs en-dessous, et au-dessus des pivots tant nuls. Notons j1 < j2 < < jr les colonnes des
r pivots (on remarquera que r est le rang de A). On obtient alors facilement unesolution
particulire,

b1
.

ainsi quune base de lespace des solutions de lquation homogne. On note B = ..


.
bn
Mthode 9.2.3

Si le systme est compatible (cest le cas ssi bi = 0 pour tout i > r), une solution particulire
est le vecteur X0 = (xi )16i6p , tel que
xi =

bk
0

si i = jk , k [[1, r]]
sinon

Une base est obtenue en numrant les vecteurs Xj obtenus, pour j [[1, p]] \ {j1 , . . . , jr } par la
construction suivante :
les coordonnes de Xj distinctes de j et des jk sont nulles
la j-ime coordonne de Xj est gale 1
la colonne extraite de Xj en ne conservant que les lignes j1 , . . . , jr est gale Cj , o Cj
est la j-ime colonne de A , tronque au-del de la r-ime coordonne.

III

Dcomposition LU

145

Ainsi, en notant, pour un k-uplet (1 , . . . , k ), p1 ,...,k la projection de Rn dans Rk dfinie par


p1 ,...,k (x1 , . . . , xn ) = (x1 , . . . , xk ),
et en identifiant les vecteurs colonnes des lments de Rk , le vecteur Xj est dfini par :
pj1 ,...,jr (Xj ) = Cj ,

pj (Xj ) = 1,

et

p[[1,N ]]\{j,j1 ,...,jr } = 0.

Thorme 9.2.4 (Complexit de la mthode du pivot)


La mthode du pivot sur une matrice de M(n, p) est en O(np2 ). En particulier, elle est cubique sur des
matrices carres.

Comme on la vu en cours de mathmatiques, la mthode du pivot peut tre adapte de diffrentes


manires :
Mthode 9.2.5 (Adaptations de la mthode du pivot)
Calcul du rang : on se contente dun premier passage (chelonnement simple), en comptant
le nombre de pivots utiliss, ce qui donnera le rang.
Calcul de linverse : on effectue un chelonnement double, en remarquant que dans la premire
tape (descente), si on ne trouve pas de pivot admissible sur une colonne, la matrice nest pas
inversible (on obtiendra au bout une matrice triangulaire dont certains coefficients diagonaux
sont nuls) : on peut donc interrompre lalgorithme dans ce cas. Lchelonnement double de la
matrice, avec normalisation des pivots, nous donne alors, en cas dinversibilit, la matrice In . On
effectue en parallle les mmes oprations sur la matrice initiale In , on obtient en fin dalgorithme
la matrice A1 .
Calcul de la matrice de passage de lchelonnement, cest--dire de P telle que P A = A :
cest une gnralisation de la mthode de calcul de linverse, en suivant exactement le mme
principe : P est le produit des matrices de codage des oprations, donc obtenu en effectuant sur
In les oprations correspondantes. On trouve donc P en effectuant en parallle sur In les mmes
oprations que sur A pour obtenir A .

III

Dcomposition LU

Dfinition 9.3.1 (Dcomposition LU )


Une dcomposition LU dune matrice carre A est une dcomposition de A en un produit A = LU
dune matrice triangulaire infrieure L (Lower) et dune matrice triangulaire suprieure (Upper).

On peut obtenir, sous certaines conditions, une dcomposition LU en adaptant la dernire variante de la
mthode du pivot expose ci-dessus. Au lieu de rechercher P tel que P A = A , on recherche Q GLn (K)
tel que A = QA . On pourrait se dire quil suffit dinverser P , mais cela oblige faire 2 pivots (un premier
pour rduire A, lautre pour inverser P ), ce nest pas trs optimal. On adapte alors la mthode prcdente,
en remarquant que si P = Pk P1 , o les Pi codent les oprations successives, alors
Q = P11 Pk1 = In P11 Pk1 .

146

CHAPITRE 9. RSOLUTION NUMRIQUE DE SYSTMES LINAIRES

Mthode 9.3.2 (Trouver Q telle que A = QA )


On trouve Q en effectuant sur In les oprations sur les colonnes correspondant aux matrices inverses des
matrices de codage des oprations sur les lignes effectues sur A pour obtenir A . Plus explicitement,
chaque opration sur les lignes de A, on effectue une opration correspondante sur les colonnes de In :
Li Li correspond Ci 1 Ci
Li Lj correspond Ci Cj
Li Li + Lj correspond Cj Cj Ci .
On obtient alors une dcomposition LU en remarquant que beaucoup de matrices doprations sont
triangulaires : il suffit donc de se limiter aux oprations pour lesquelles la matrice associe (donc son
inverse) est triangulaire infrieure : cest le cas des oprations de dilatation et de transvection Li Li +
Lj lorsque i > j. Or, sil ny a pas besoin de faire dchanges de lignes, le pivot de Gauss peut seffectuer
avec ces seules oprations. De plus, les oprations de dilatation ne sont pas strictement ncessaires, et les
matrices triangulaires en jeu ont alors toutes une diagonale de 1. On obtient alors, sous une hypothse
nous assurant quon naura pas dchange de ligne faire :
Thorme 9.3.3 (Dcomposition LU)
Soit A GLn (R), telle que pour tout k [[1, n]], la sous-matrice carres obtenue par extraction des k
premires lignes et des k premires colonnes soit inversible. Alors A admet une dcomposition LU . On
peut de plus imposer que L soit diagonale gale 1.

Cette dcomposition se trouve explicitement par la mthode suivante :


Mthode 9.3.4 (Trouver une dcomposition LU)
Rduire A en une matrice chelonne U , en nutilisant ni change de ligne, ni dilatation (si on veut L
de diagonale 1). Cette matrice chelonne est triangulaire suprieure. On effectue sur In les oprations
sur les colonnes correspondant aux oprations sur les lignes dans le sens dcrit plus haut, cela fournit
la matrice L.

Remarque 9.3.5 (Intrt de la dcomposition LU)


Cette dcomposition est intressante notamment dans le cas o on a un grand nombre de systmes AX = Bi rsoudre, associs la mme matrice A. Plutt que de refaire tout le calcul
depuis le dbut pour chaque vecteur Bi , on fait le calcul de la dcomposition une fois pour
toutes : on est ramen la rsolution de 2 systmes triangulaires LU X = B. On obtient dabord
U X par rsolution du systme de matrice L, puis X par rsolution du systme de matrice U .
Il pourra tre avantageux de programmer explicitement un algorithme spcifique de rsolution
des systmes triangulaires infrieurs et suprieurs, afin doptimiser au maximum les temps de
calcul, en omettant les oprations avec les coefficients quon sait tre nuls.
Cette mthode est plus avantageuse que de calculer A1 jusquau bout puis de faire les calculs
de A1 Bi . En effet, si les rsolutions des systmes linaires triangulaires sont bien programms,
elles ne sont pas plus coteuses que le calcul de A1 Bi , cela permet donc dviter la phase finale
du calcul de A1 .
Cette mthode possde tout de mme des inconvnient notables, comme pas exemple le fait que lon ne
peut pas choisir le pivot. Cela peut ventuellement diminuer la prcision de calcul. On peut pallier ce
problme en dcomposant A sous une forme un peu plus complexe.

IV

Problmes de conditionnement

147

Proposition 9.3.6 (Dcomposition PLU)


Toute matrice A GL(R) se dcompose sous la forme P LU , o P est une matrice de permutation, L
une matrice triangulaire infrieure diagonale 1, U une matrice triangulaire suprieure.

Exercice 16
Dmontrer la proprit prcdente. Comment contruire P pour optimiser la prcision numrique ?

IV

Problmes de conditionnement

On part de lexemple suivant :


Hn =

1
i+j1

16i,j6n

Cette matrice est appele matrice de Hilbert. On observe sur des exemples que la rsolution de Hn X = B
est problmatique :
>>> np.linalg.solve(H,[1,1,1,1])
array([ -4., 60., -180., 140.])
>>> np.linalg.solve(H,[1.01,0.99,1.01,0.99])
array([ 1.16, 3. , -43.8 , 51.8 ])
Cet exemple illustre la trs grande variabilit du rsultat en fonction du second membre B : une toute
petite variation sur B fournit de trs grosses variations sur la solution du systme. Cela peut engendrer
de grosses imprcisions sur les calculs, du fait que toute erreur darrondi sur B sera beaucoup amplifie
lors de la rsolution du systme.
Il ny a pas grand chose faire, sinon savoir dtecter quelles sont les matrices qui vont nous donner des
situations similaires, de sorte pouvoir valider la prcision des calculs dans les autres cas. Pour cela, on
utilise une quantit permettant de mesurer lamplification dune variation sur B lors de la rsolution du
systme.
Dfinition 9.4.1 (Norme matricielle)
La norme (euclidienne canonique) de X Mn,1 (R) est dfinie par

x
1
q
.

kXk = x21 + + x2n , o X =


.. .
xn

On dfinit alors la norme dune matrice M Mn (R) par :


kAk =

sup
XRn \{0}

kAXk
.
kXk

Cette quantit est bien dfinie du fait que


sup
XRn \{0}

kAXk
= sup kAXk,
kXk
XB(0,1)

(provenant de linvariance par dilatation de X), en utilisant la compacit de B(0, 1) et la continuit de


la norme dun vecteur de Rn .

148

CHAPITRE 9. RSOLUTION NUMRIQUE DE SYSTMES LINAIRES

Proposition 9.4.2
A 7 kAk est une norme sur Mn (R) :

(i) kAk = 0 si et seulement si A = 0

(ii) pour tout R, kAk = || kAk,

(iii) pour tout A, B, kA + Bk 6 kAk + kBk (ingalit triangulaire)


De plus, il sagit dune norme matricielle, cest--dire :
(iv) pour tout A, B Mn (R), kABk 6 kAk kBk.
Pour le dernier point, on pourra utiliser le lemme suivant :
Lemme 9.4.3
Soit A Mn (R) et X Mn,1 (R). On a :
kAXk 6 kAk kXk.
On dfinit alors le conditionnement par :
Dfinition 9.4.4 (Conditionnement dune matrice)
Soit A GLn (R). Le conditionnement de A est :
cond(A) = kAk kA1 k.
Proposition 9.4.5
On a toujours cond(A) > 1.
Nous allons voir que le conditionnement permet de contrler les variations de la solution X du systme
en fonction des variations de B. Plus cond(A) est proche de 1, plus ce contrle va tre bon. Si cond(A) est
grand, ce contrle va tre mauvais ; Cest ce quil se passe pour les matrices de Hilbert (on peut montrer
que cond(H4 ) = 15514). Ainsi, un conditionnement proche de 1 est une garantie de fiabilit tdu rsultat.
Thorme 9.4.6
Soit B et B + B deux colonnes de Rn , et X et X + X les solutions obtenues pour le systme de
matrice A, associ ces deux seconds membres. On a alors :
kXk
kBk
6 cond(A)
.
kXk
kBk
Ce thorme affirme que les variations relatives sur B sont amplifies sur la solution du systme par
un facteur au plus gal cond(A). Assez logiquement, on ne peut pas esprer un meilleur contrle de
lerreur sur X que sur B (car cond(A) > 1), et une grande valeur de cond(A) nous donne un trs mauvais
contrle.
Dfinition 9.4.7 (Bon et mauvais conditionnement)
Si cond(A) nest pas trop grand par rapport 1, on dit que A est bien conditionn. Si A est grand par
rapport 1, on dit que A est mal conditionn.
Cest une notion qui reste trs subjective, on ne quantifie pas la valeur seuil passant de lune lautre
des deux situations.

10
Bases de donnes relationnelles
Un des grands dfis du XXIe sicle, rendu possible par lmergence dinternet la fin du XXe sicle, est de
regrouper, dordonner, et de mettre disposition un grand nombre de donnes, en vue dune utilisation
par des experts (tudes statistiques...) ou des particuliers (renseignements...). Cette immense mise en
commun de donnes parpilles ncessite des structures spciales : outre la mmoire ncessaire pour le
stockage des donnes, il faut aussi pouvoir structurer ces donnes de faon pouvoir en extraire facilement
ce qui nous intresse : extraire par exemple dune base de donne musicale les oeuvres de compositeurs
russes, ou les sonates pour flte crites entre 1700 et 1750. Il faut donc une structure permettant de
dgager rapidement les principales caractristiques dune oeuvre (compositeur, date, pays, instruments,
type doeuvre, etc).
La structure de base de donne (BDD) relationnelle rpond cette question. Nous nous proposons dans
ce chapitre dtudier le faon intuitive cette structure de BDD relationnelle, avant den proposerons une
formalisation algbrique. Nous verrons dans le chapitre suivant un langage adapt la manipulation de
ces bases de donnes (SQL), ainsi que les diffrentes oprations algbriques possibles en vue de faire des
requtes (extraire les informations prcises qui nous intressent).
Nous illustrons ce chapitre et le suivant par la cration dune base de donne musicale.

Environnement client / serveur

Le principe-mme dune base de donnes impose que de nombreuses personnes peuvent y avoir accs.
Cependant, il est peu souhaitable que tout le monde ait un accs direct cette base, afin dviter les
accidents de manipulation qui pourraient faire perdre des donnes de la base. Pour cette raison, on opre
en gnral une sparation stricte entre la machine (ou machine virtuelle) sur laquelle est stocke la base,
et les machines des utilisateurs. Les utilisateurs nont en fait accs la base (et la machine qui la contient)
que via des requtes dont la syntaxe et linoffensivit sont bien contrles. Par ailleurs, les utilisateurs
ont des droits bien tablis : la plupart dentre eux nont quun droit de consultation ; les utilisateurs ayant
un droit dajout ou de modification sont en petit nombre et souvent superviss par un superutilisateur
unique (root).
Cette sparation nette entre la base elle-mme et les utilisateurs conduit la notion denvironnement
client/serveur, ou larchitecture 3-tiers qui en est une variante amliore. Dans une telle structure, les
logiciels sont scinds en 2 : une partie lgre du cot du client, et une partie lourde (le traitement) du
ct du serveur.

I.1

Le serveur informatique

150

CHAPITRE 10. BASES DE DONNES RELATIONNELLES

Dfinition 10.1.1 (Serveur informatique)


Le serveur informatique est un dispositif informatique offrant des services des clients.
Ces services peuvent tre de diffrents types suivant la nature du serveur :
partage de fichiers ;
partages de donnes (BDD) ;
hbergeurs web : accs au Web, stockage de pages webs ;
serveurs de courrier lectronique : stockage et envoi de messages ;
rseaux locaux : mise en commun au sein dune entreprise des ressources informatiques, que ce
soit matrielles (imprimantes...) ou logicielles (cela vite davoir intaller les logiciels lourds sur
toutes les machines) ;
serveur local un ordinateur : gre les diffrents utilisateurs de lordinateur ;
cloud computing : offre aux clients une grande puissance de calcul. Cela permet de mutualiser la
puissance : plutt que daugmenter individuellement leur capacit de calcul par lachat de matriel
neuf, les clients payent le droit de se servir des ressources calculatoires mises disposition par un
fournisseur.
Un serveur est en communication avec plusieurs clients, gnralement un grand nombre (figure 10.1). La
communication entre le serveur et les clients se fait suivant un certain protocole de communication strict
et scuris, dans la mesure o la scurit et lintgrit du serveur sont bien assures par ce protocole.
Client 3
Client 4

Client 2

rsultats
Client 5

Serveur

Client 1
requtes

Client 6

Client 8
Client 7

Figure 10.1 Architecture client-serveur


Les caractristiques dmandes un serveur sont :
la rapidit de communication (dbit)
la rapidit de traitement
la capacit dadaptation la demande (augmentation de la taille en mmoire, du nombre de
requtes simultanes...)
la disponibilit 24h sur 24.
Les serveurs sont donc trs souvent des machines beaucoup plus puissantes que la moyenne, et trs fiables
(afin dviter les pannes matrielles).

Environnement client / serveur

I.2

151

Le client

Dfinition 10.1.2 (Client)


Le client est un matriel logiciel ou informatique, permettant lenvoi de requtes un serveur donn,
et la rception des rponses.

Il sagit donc dune interface lgre grant de faon conviviale la communication avec un serveur, traduisant les requtes de lutilisateur de faon adquate.
Les logiciels associs une architecture client-serveur sont organiss en trois couches :
la gestion du stockage de linformation ;
le traitement des requtes, donc la partie calculatoire ;
le client : linterface avec lutilisateur (entre des requtes, affichage des rsultats).

La premire est essentiellement destine au maintien et la mise jour du serveur. La seconde est souvent
la partie lourde du logiciel ; quant la troisime, elle nest quune interface lgre de communication. Les
deux premires couches sont installes sur le serveur lui-mme, alors que la troisime couche (le client)
est installe chez tous les utilisateurs. Cela prsente une conomie logicielle (seule une interface lgre est
installe en plusieurs exemplaires), ainsi quune scurit, puisque lutilisateur na pas un accs physique
direct au serveur, mais ne peut communiquer avec lui que par lintermdiaire de linterface client, qui ne
transmet que des requtes inoffensives.

I.3

Architecture 3-tiers

Dfinition 10.1.3 (Architecture 3-tiers)


Il sagit dune volution de larchitecture client-serveur, dans laquelle les trois couches logicielles exposes ci-dessus sont physiquement spares. Ainsi, le serveur lui-mme est scind en deux serveurs :
serveur 1 : stockage de linformation
serveur 2 : serveur mtier, i.e. serveur effectuant la gestion logicielle.
La terminologie provient de langlais tier signifiant couche .

Le client communique avec le serveur mtier qui lui-mme communique avec le serveur de stockage
(figure 10.2) : le client est davantage spar du serveur de stockage, ce qui minimise les risques de pertes
de donnes suite des erreurs (involontaires ou malveillantes) de manipulation.
Les bases de donnes actuelles sont contruites sur ce schma (figure 10.3). Le serveur mtier sappelle le
systme de gestion de base de donne (SGBD).
On peut voir plusieurs intrts une telle dissociation :
dissociation BDD-SGBD : il ny a pas de communication directe entre le client et la base : la
passage obligatoire par le serveur de gestion, contrl rigoureusement par un superutilisateur, est
une garantie supplmentaire de scurit pour la base. Ce superutilisateur (administrateur de la
base de donne) est en thorie lunique personne pouvant modifier la base. Cest elle qui attribue
des droits aux clients (droits de consultation, de modification, dajout...)
dissociation client-BDD : outre la scurit, cette dissociation permet un enrichissement de la base
indpendante des utilisateurs.
dissociation client-SGBD : de mme, les logiciels de gestion peuvent tre actualiss indpendamment du client : ainsi, une amlioration logicielle peut se faire uniquement au niveau du serveur, et
ne ncessite pas une actualisation au niveau de chaque client. Par ailleurs, seule une interface lgre
est ncessaire du ct client, ce qui ne ncessite pas une machine particulirement performante.

152

CHAPITRE 10. BASES DE DONNES RELATIONNELLES

Couche 1 : stockage des donnes

serveur de stockage

Couche 2 : gestion logicielle

serveur de gestion

Cl 1

Couche 3 : clients

Cl 2

Cl 3

Cl 4

Cl 3

Cl 4

Figure 10.2 Architecture 3-tiers


Couche 1 : stockage

BDD

Couche 2 : gestion logicielle

SGBD

Cl 1

Couche 3 : clients

Cl 2

Figure 10.3 Architecture 3-tiers pour une BDD

II
II.1

Bases de donnes
Prsentation intuitive

Il sagit de stocker des donnes de faon adapte, de sorte :


pouvoir facilement faire des recherches
prendre le moins de place possible en mmoire.
Imaginons par exemple que nous souhaitions faire une base de donne musicale avec les types de donnes
suivantes :
Compositeur
Dates de naissance et de mort
Pays
Titre de loeuvre
Date de composition
Type doeuvre (symphonie, concerto...)
instrumentation (orchestre, choeur, soliste, ensemble de chambre...)

II

Bases de donnes

153

Instruments solistes
Famille des instruments solistes (vents, cordes...)
La premire ide pouvant venir lesprit est une prsentation linaire sous forme dun tableau (figure
10.4).
On se rend compte assez rapidement que cette prsentation assez simpliste prsente un certain nombre
dinconvnients, comme par exemple les redondances (on indique les dates et pays des compositeurs autant
de fois quil y a doeuvre deux dans la base !), ainsi que les entres multiples (dans linstrumentation ou
les solistes par exemple), qui compliquent les recherches.
On peut alors penser sparer les donnes en plusieurs tableaux. Par exemple un tableau des compositeurs, un tableau des oeuvres et un tableau des instruments (figure 10.5)
Les redondances ne sont pas compltement supprimes : par exemple indiquer dans linstrumentation
quil y a des solistes est redondant avec la colonne soliste, qui nest remplie que dans ce cas. On peut
supprimer cette information. Par ailleurs, il reste le problme des entres multiples. Ce problme-l nest
pas trs dur rgler : il suffit de dupliquer la ligne autant de fois quil y a dentre de lattribut multiple.
Mais cela au risque de crer de nouvelles redondances quil faudra supprimer (tableau 10.6, on ny indique
que le tableau OEUVRES, les autres tant inchanges)
Pour supprimer les redondances ainsi apparues, on scinde nouveau le tableau :
un premier tableau identifiera loeuvre (on peut y mettre aussi la date, dtermine entirement
et de faon unique par loeuvre, ainsi que le type). On crera un identifiant de loeuvre, construit
par exemple sur les premires lettres du compositeur puis une numrotation, de faon ce que la
donne de cet identifiant caractrise de faon unique loeuvre.
Un deuxime tableau donnera les ensembles instrumentaux utiliss (orchestre, choeur, quatuor...)
pour chacune des oeuvres, identifies par lidentifiant du premier tableau.
Un troisime donne les instruments solistes.
Cela nous donne les tableaux de la figure 10.7.
videmment, les lignes des deux derniers tableaux comportant une entre NIL sont inutiles. La nonprsence de ces lments dans le tableau suffit retrouver cette information. On peut donc supprimer
toutes ces lignes. Par ailleurs, si lon veut par la suite pouvoir faire des rfrences prcises ces tableaux,
il faut pouvoir identifier chacune des lignes de ces tableaux de faon unique et non quivoque. Pour cette
raison, on a souvent recours un identifiant (une numrotation, qui peut tre purement utilitaire et ne
pas avoir de smantique particulire).
Enfin, comme il est plus facile de crer la structure de la base de donne initialement que de faire des
modifications par la suite (surtout si de nombreuses donnes sont rentres initialement), on rflchit
attentivement toutes les contraintes et possibilits lies aux attributs, de faon limiter le nombre de
dpendances pouvant apparatre par la suite, ou la rupture dun identifiant. Nous illustrons ces propos
par deux exemples :
Supposons que nous voulions ajouter Haendel notre liste de compositeurs. Quel pays mettre ?
LAllemagne ou lAngleterre ? Il serait prfrable de pouvoir mettre les deux. Ainsi, le compositeur
ne dtermine pas le pays, et on a une entre multiple. Comme dans le cas des instrumentations,
cela peut inciter scinder le tableau des compositeurs, en sparant les nationalits. Ce cas nest
pas unique, on peut aussi songer Scarlatti (Italie ou Espagne ?), Rossini (Italie ou France ?),
Stravinski (Russie ou France ?), Rachmaninov (Russie ou USA ?) ou encore Johann-Christian Bach
(Allemagne, Italie ou Angleterre ?). Cela dpend aussi de savoir si on veut indiquer dans cette
colonne la nationalit administrative, ou le pays daccueil. Si cest cette dernire interprtation
quon choisit, il convient galement de reconsidrer le cas de Beethoven.
Le cas Bach soulve un autre problme : le patronyme ne caractrise pas le compositeur, et ne
peut pas servir didentifiant. Ainsi, nombreuses sont les familles musiciennes dans lhistoire de
la musique : la prolifique famille Bach, bien entendu, mais galement les Couperin, les Scarlatti,
les Mozart, ou plus rcemment les Strauss ou les Alain ; sans compter les homonymes non familiaux (comme Johann et Richard Strauss). Le prnom mme ne suffit pas rgler le problme

154

naissance
1668
1685
1685
1685
1685
1756
1756
1756
1756
1756
1770
1770
1770
1770
1770
1770

mort
1733
1750
1750
1750
1750
1791
1791
1791
1791
1791
1827
1827
1827
1827
1827
1827

pays
France
Allemagne
Allemagne
Allemagne
Allemagne
Autriche
Autriche
Autriche
Autriche
Autriche
Allemagne
Allemagne
Allemagne
Allemagne
Allemagne
Allemagne

titre
Messe des couvents
Variations Goldberg
Lart de la fugue
Le clavier bien tempr I
Messe en si mineur
Don Giovanni
Die Zauberflte
Concerto pour flte et harpe
Messe du couronnement
Requiem
Symphonie no 5
Symphonie no 9
Quatuor no 13
Grande Fugue
Sonate no 29
Sonate pour violon et piano no 5

date
1690
1740
1750
1722
1748
1787
1791
1778
1779
1791
1808
1824
1825
1825
1818
1801

type
messe
variations
recueil
recueil
messe
opra
opra
concerto
messe
messe
symphonie
symphonie
quatuor
quatuor
sonate
sonate

instrumentation
soliste
soliste
soliste
soliste
orchestre, choeur, chanteurs
orchestre, choeur, chanteurs
orchestre, choeur, chanteurs
orchestre, solistes
orchestre, choeur, chanteurs
orchestre, choeur, solistes
orchestre
orchestre, choeur, chanteurs
quatuor cordes
quatuor cordes
soliste
solistes

solistes
orgue
clavecin
clavecin
clavecin

famille
claviers
claviers
claviers
claviers

flte, harpe

bois, cordes
voix

piano
violon, piano

claviers
cordes, claviers

CHAPITRE 10. BASES DE DONNES RELATIONNELLES

Figure 10.4 Tableau des donnes brutes

Nom
Couperin
Bach
Bach
Bach
Bach
Mozart
Mozart
Mozart
Mozart
Mozart
Beethoven
Beethoven
Beethoven
Beethoven
Beethoven
Beethoven
etc

II

Bases de donnes

Nom
Couperin
Bach
Mozart
Beethoven

Nom
Couperin
Bach
Bach
Bach
Bach
Mozart
Mozart
Mozart
Mozart
Mozart
Beethoven
Beethoven
Beethoven
Beethoven
Beethoven
Beethoven

155

COMPOSITEURS
naissance mort
pays
1668
1733
France
1685
1750 Allemagne
1756
1791
Autriche
1770
1827 Allemagne

titre
Messe des couvents
Variations Goldberg
Lart de la fugue
Le clavier bien tempr I
Messe en si mineur
Don Giovanni
Die Zauberflte
Concerto pour flte et harpe
Messe du couronnement
Requiem
Symphonie no 5
Symphonie no 9
Quatuor no 13
Grande Fugue
Sonate no 29
Sonate pour violon et piano no 5

INSTRUMENTS
instrument famille
orgue
claviers
claviers
clavecin
flte
bois
harpe
cordes
claviers
piano
violon
cordes

OEUVRES
date
type
1690
messe
1740 variations
1750
recueil
1722
recueil
1748
messe
1787
opra
1791
opra
1778
concerto
1779
messe
1791
messe
1808 symphonie
1824 symphonie
1825
quatuor
1825
quatuor
1818
sonate
1801
sonate

instrumentation
soliste
soliste
soliste
soliste
orchestre, choeur, chanteurs
orchestre, choeur, chanteurs
orchestre, choeur, chanteurs
orchestre, solistes
orchestre, choeur, chanteurs
orchestre, choeur, chanteurs
orchestre
orchestre, choeur, chanteurs
quatuor cordes
quatuor cordes
soliste
solistes

solistes
orgue
clavecin
clavecin
clavecin

flte, harpe

piano
violon, piano

Figure 10.5 Premire repartition des donnes


(comme lindique le problme des Johann Strauss pre et fils). Ainsi, l aussi, il faut crer un
identifiant. Prendre comme identifiant les 3 premires lettres du nom nest pas suffisant (problme
dhomonymie, ou plus gnralement, de noms commenant de la mme faon, comme Chopin et
Chostakovitch, ou Schubert et Schumann). On peut par exemple prendre les 3 premires lettres,
suivies dun numro pour distinguer les homonymes.
On arrive au final au schma de la figure 10.8, comportant 6 tableaux.

156

Nom
Couperin
Bach
Bach
Bach
Bach
Bach
Bach
Mozart
Mozart
Mozart
Mozart
Mozart
Mozart
Mozart
Mozart
Mozart
Mozart
Mozart
Mozart
Mozart
Mozart
Beethoven
Beethoven
Beethoven
Beethoven
Beethoven
Beethoven
Beethoven
Beethoven
Beethoven

CHAPITRE 10. BASES DE DONNES RELATIONNELLES

OEUVRES
titre
date
Messe des couvents
1690
Variations Goldberg
1740
Lart de la fugue
1750
Le clavier bien tempr I
1722
Messe en si mineur
1748
Messe en si mineur
1748
Messe en si mineur
1748
Don Giovanni
1787
Don Giovanni
1787
Don Giovanni
1787
Die Zauberflte
1791
Die Zauberflte
1791
Die Zauberflte
1791
Concerto pour flte et harpe
1778
Concerto pour flte et harpe
1778
Messe du couronnement
1779
Messe du couronnement
1779
Messe du couronnement
1779
Requiem
1791
Requiem
1791
Requiem
1791
Symphonie no 5
1808
o
Symphonie n 9
1824
Symphonie no 9
1824
o
Symphonie n 9
1824
Quatuor no 13
1825
Grande Fugue
1825
o
Sonate n 29
1818
Sonate pour violon et piano no 5 1801
Sonate pour violon et piano no 5 1801

type
messe
variations
recueil
recueil
messe
messe
messe
opra
opra
opra
opra
opra
opra
concerto
concerto
messe
messe
messe
messe
messe
messe
symphonie
symphonie
symphonie
symphonie
quatuor
quatuor
sonate
sonate
sonate

instrumentation
soliste

orchestre
choeur
chanteurs
orchestre
choeur
chanteurs
orchestre
choeur
chanteurs
orchestre
orchestre
orchestre
choeur
chanteurs
orchestre
choeur
chanteurs
orchestre
choeur
chanteurs
orchestre
quatuor cordes
quatuor cordes

Figure 10.6 Tableau sans entre multiple

solistes
orgue
clavecin
clavecin
clavecin

flte
harpe

piano
violon
piano

II

Bases de donnes

IdOeuvre
COU 1-1
BAC 1-1
BAC 1-2
BAC 1-3
BAC 1-4
MOZ 1-1
MOZ 1-2
MOZ 1-3
MOZ 1-4
MOZ 1-5
BEE 1-1
BEE 1-2
BEE 1-3
BEE 1-4
BEE 1-5
BEE 1-6

Compositeur
Couperin
Bach
Bach
Bach
Bach
Mozart
Mozart
Mozart
Mozart
Mozart
Beethoven
Beethoven
Beethoven
Beethoven
Beethoven
Beethoven

157

OEUVRES
Titre
Messe des couvents
Variations Goldberg
Lart de la fugue
Le clavier bien tempr I
Messe en si mineur
Don Giovanni
Die Zauberflte
Concerto pour flte et harpe
Messe du couronnement
Requiem
Symphonie no 5
Symphonie no 9
Quatuor no 13
Grande Fugue
Sonate no 29
Sonate pour violon et piano no 5

INSTRUMENTATION
IdOeuvre formation intrumentale
COU 1-1
NIL
BAC 1-1
NIL
NIL
BAC 1-2
BAC 1-3
NIL
orchestre
BAC 1-4
BAC 1-4
choeur
BAC 1-4
chanteurs
orchestre
MOZ 1-1
MOZ 1-1
choeur
MOZ 1-1
chanteurs
MOZ 1-2
orchestre
choeur
MOZ 1-2
MOZ 1-2
chanteurs
MOZ 1-3
orchestre
orchestre
MOZ 1-4
MOZ 1-4
choeur
chanteurs
MOZ 1-4
MOZ 1-5
orchestre
choeur
MOZ 1-5
chanteurs
MOZ 1-5
BEE 1-1
orchestre
BEE 1-2
orchestre
BEE 1-2
choeur
chanteurs
BEE 1-2
BEE 1-3
quatuor cordes
quatuor cordes
BEE 1-4
BEE 1-5
NIL
NIL
BEE 1-6

Date
1690
1740
1750
1722
1748
1787
1791
1778
1779
1791
1808
1824
1825
1825
1818
1801

Type
messe
variations
recueil
recueil
messe
opra
opra
concerto
messe
messe
symphonie
symphonie
quatuor
quatuor
sonate
sonate

SOLISTES
IdOeuvre instrument soliste
COU 1-1
clavecin
clavecin
BAC 1-1
clavecin
BAC 1-2
NIL
BAC 1-3
MOZ 1-1
NIL
NIL
MOZ 1-2
MOZ 1-3
flte
harpe
MOZ 1-3
MOZ 1-4
NIL
MOZ 1-5
NIL
BEE 1-1
NIL
BEE 1-2
NIL
NIL
BEE 1-3
BEE 1-4
NIL
piano
BEE 1-5
BEE 1-6
violon
piano
BEE 1-6

Figure 10.7 Tableau sans les redondances pour les oeuvres

158

IdOeuvre
COU 1-1
BAC 1-1
BAC 1-2
BAC 1-3
BAC 1-4
MOZ 1-1
MOZ 1-2
MOZ 1-3
MOZ 1-4
MOZ 1-5
BEE 1-1
BEE 1-2
BEE 1-3
BEE 1-4
BEE 1-5
BEE 1-6

IdComp
COU 1
BAC 1
MOZ 1
BEE 1
HAE 1
STR 1
BAC 2

IdSol
1
2
3
4
5
6
7
8

CHAPITRE 10. BASES DE DONNES RELATIONNELLES

Compositeur
COU 1
BAC 1
BAC 1
BAC 1
BAC 1
M0Z 1
MOZ 1
MOZ 1
MOZ 1
MOZ 1
BEE 1
BEE 1
BEE 1
BEE 1
BEE 1
BEE 1

Nom
Couperin
Bach
Mozart
Beethoven
Haendel
Stravinski
Bach

OEUVRES
Titre
Messe des couvents
Variations Goldberg
Lart de la fugue
Le clavier bien tempr I
Messe en si mineur
Don Giovanni
Die Zauberflte
Concerto pour flte et harpe
Messe du couronnement
Requiem
Symphonie no 5
Symphonie no 9
Quatuor no 13
Grande Fugue
Sonate no 29
Sonate pour violon et piano no 5

COMPOSITEURS
Prnom
Franois
Johann Sebastian
Wolfgang Amadeus
Ludwig (van)
Georg Friedrich
Igor
Johann Christian

SOLISTES
IdOeuvre instrument soliste
COU 1-1
clavecin
BAC 1-1
clavecin
BAC 1-2
clavecin
MOZ 1-3
flte
MOZ 1-3
harpe
BEE 1-5
piano
BEE 1-6
violon
BEE 1-6
piano

naissance
1668
1685
1756
1770
1685
1882
1735

Date
1690
1740
1750
1722
1748
1787
1791
1778
1779
1791
1808
1824
1825
1825
1818
1801

mort
1733
1750
1791
1827
1759
1971
1782

INSTRUMENTS
instrument famille
orgue
claviers
clavecin
claviers
bois
flte
harpe
cordes
claviers
piano
violon
cordes

NATIONALIT
IdNat IdComp
pays
1
COU 1
France
2
BAC 1
Allemagne
MOZ 1
Autriche
3
4
BEE 1
Allemagne
BEE 1
Autriche
5
6
HAE 1 Allemagne
7
HAE 1 Angleterre
8
STR 1
Russie
9
STR 1
France
BAC 2
Allemagne
10
11
BAC 2
Italie
BAC 2
Angleterre
12

Type
messe
variations
recueil
recueil
messe
opra
opra
concerto
messe
messe
symphonie
symphonie
quatuor
quatuor
sonate
sonate

IdInstr
BAC 1-4-1
BAC 1-4-2
BAC 1-4-3
MOZ 1-1-1
MOZ 1-1-2
MOZ 1-1-3
MOZ 1-2-1
MOZ 1-2-2
MOZ 1-2-3
MOZ 1-3-1
MOZ 1-4-1
MOZ 1-4-2
MOZ 1-4-3
MOZ 1-5-1
MOZ 1-5-2
MOZ 1-5-3
BEE 1-1-1
BEE 1-2-1
BEE 1-2-2
BEE 1-2-3
BEE 1-3-1
BEE 1-4-1

INSTRUMENTATION
IdOeuvre formation intrumentale
BAC 1-4
orchestre
BAC 1-4
choeur
BAC 1-4
chanteurs
MOZ 1-1
orchestre
MOZ 1-1
choeur
MOZ 1-1
chanteurs
MOZ 1-2
orchestre
MOZ 1-2
choeur
MOZ 1-2
chanteurs
MOZ 1-3
orchestre
MOZ 1-4
orchestre
MOZ 1-4
choeur
MOZ 1-4
chanteurs
MOZ 1-5
orchestre
MOZ 1-5
choeur
MOZ 1-5
chanteurs
BEE 1-1
orchestre
BEE 1-2
orchestre
BEE 1-2
choeur
BEE 1-2
chanteurs
BEE 1-3
quatuor cordes
BEE 1-4
quatuor cordes

Figure 10.8 Structure finale de la base de donne

II

Bases de donnes

II.2

159

Dpendances et redondances

Pour supprimer les redondances, on peut commencer par tudier les dpendances entre les diffrentes
entres. Par exemple, la date de naissance dun compositeur ne dpend que du compositeur, et non de
loeuvre. De mme, la famille instrumentale ne dpend que de linstrument, et non de loeuvre.
Dfinition 10.2.1 (Attribut)
Un attribut est lune des caractristiques des donnes saisir. Il sagit donc du titre des colonnes.
Ainsi, dans notre exemple, on dispose des attributs COMPOSITEUR, NAISSANCE, MORT, PAYS,
TITRE...

Dfinition 10.2.2 (Dpendance fonctionnelle)


On dit quil existe une dpendance fonctionnelle de lattribut A vers lattribut B si la valeur de lattribut B ne dpend de rien dautre que de la valeur de lattribut A. Autrement dit, toutes les entres
possdant la mme valeur de lattribut A possdent galement une mme valeur de lattribut A. Une
telle dpendance sera note A B.
On peut tendre la dfinition aux sous-ensembles dattribut : il existe une dpendance fonctionnelle dun
sous-ensemble A dattributs vers un sous-ensemble dattributs B si les valeurs donnes aux diffrents
attributs de A dterminent entirement les valeurs des attributs de B.
Cette dfinition dpend des entres de la base : plus la base est fournie, plus la diversit des cas particuliers
est susceptible de briser une dpendance fonctionnelle. Pour ltude des dpendances fonctionnelles, on
supposera la base remplie de toutes les entres imaginables en rapport avec le thme de la base, afin
de prendre en considration lensemble des cas possibles. Ainsi, dans notre exemple, nous avons les
dpendances fonctionnelles suivantes :

IDOEUVRE NOM, PRNOM, MORT, NAISSANCE, PAYS, DATE, TYPE


IDCOMP MORT, NAISSANCE, NOM, PRNOM
INSTRUMENT FAMILLE
loeuvre dtermine un sous-ensemble de formations instrumentales, mais pas une formation instrumentale. Identifier sparment tous les couples (oeuvre/formation instrumentale) permet de
traduire cela par la dpendance :
IDINSTR OEUVRE, FORMATION
IDSOL OEUVRE, INSTRUMENT de la mme manire.
IDNAT PAYS, COMPOSITEUR
En revanche, on na pas de dpendance fonctionnelle de NOM vers PRNOM, comme le montre
lexemple de la famille Bach, ni entre NOM, PRNOM et PAYS, comme le montre lexemple de
Haendel.
On peut aussi sinterroger sur la dpendance NOM, PRNOM IDCOMP, qui nest valable
que sil ny a pas dhomonyme. Lexemple de Johann Strauss montre que ce point est discutable.
Quant au TITRE dune oeuvre, il ne dtermine pas grand chose : nombreux sont les compositeurs
ayant compos une symphonie no 5. On ne peut mme pas en dduire la formation instrumentale
(pensez aux symphonies pour orgue de Widor par exemple).

Remarquez que si une famille A dtermine un attribut B, mais aucun sous-ensemble strict de A, on peut
toujours se ramener au cas o B est dtermin par un unique attribut, en crant un nouvel attribut A,
identifiant de lensemble des donnes fournies par A. Cest ce quon a fait en introduisant lindentifiant
IDCOMP, permettant dexprimer de faon plus lmentaire les dpendances induites par le groupe NOM,
PRNOM.
On a de faon vidente :

160

CHAPITRE 10. BASES DE DONNES RELATIONNELLES

Proposition 10.2.3 (Dpendances composes)


Si A B, B B et B C, alors A C.
Ainsi, la dpendance fonctionnelle IDOEUVRE NOM peut se retrouver en composant les dpendances
IDOEUVRE IDCOMP et IDCOMP NOM.
Dfinition 10.2.4 (Dpendances lmentaires)
Une dpendance A B est lmentaire, si elle ne scrit pas comme composition non triviale de
dpendances.
Ainsi, dans lexemple ci-dessus, IDOEUVRE IDCOMP est une dpendance lmentaire, mais pas
IDOEUVRE NOM.
Dfinition 10.2.5 (Graphe ADF)
Le graphe ADF (graphe des attributs et des dpendances fonctionnelles) est le graphe dont les sommets
sont les attributs et les artes orientes indiquent les dpendances lmentaires.
Ainsi, dans notre exemple, on obtient le graphe de la figure 10.9.
Nom
Prnom
IdComp

Naissance
Mort

IdNat
IdOeuvre

Pays

Titre
Date
Type

IdInstr
IdSol

Formation
Soliste

Famille

Figure 10.9 Graphe ADF

Remarque 10.2.6
Un graphe ADF linaire A1 A2 An est telle que la donne de A1 dtermine
successivement les donnes de A2 , , An . Cela ne signifie pas que les entres ne sont pas
redondantes. En effet, suivant les valeurs de A1 , A2 peut prendre plusieurs fois la mme valeur,
et les attributs suivants sont alors tous rpts.
Un graphe ADF arborescent orient de hauteur 1 (donc constitu uniquement de la racine A et
de fils directs B1 , . . . , Bn , ces derniers nayant pas de fils) est tel que A1 dtermine B1 , . . . , Bn
indpendamment. Le tableau dont les entres sont les attributs B1 , . . . , Bn est donc sans redondance.

III

Algbre relationnelle

161

Mthode 10.2.7 (Trouver la structure de la BDD partir du graphe ADF)


Nous supposons ici que le graphe (non orient) ADF est arborescent (connexe, sans cycle), non rduit
un sommet. Un sommet duquel part au moins une flche est appel noeud, sinon il est appel feuille.
On appelle fils dun noeud A tout sommet accessible de A en une tape, en suivant une arte oriente
convenablement. Toute feuille est fils dau moins un noeud.
La remarque prcdente nous permet de retrouver assez rapidement la structure finale de notre
base de donne : chaque noeud A va correspondre une table TA , dont les attributs seront
ce noeud et ses fils (mais pas les descendants suivants). Ainsi chaque sous-graphe ADF de ces
tables sera un graphe de hauteur 1, donc sera non redondant.
Chacune de ces tables TA aura un identifiant, cest dire une colonne dont lentre dterminera
toutes les autres. Cet identifiant est la colonne correspondant la racine du sous-graphe ADF
(donc au noeud considr lors de sa construction)

Remarque 10.2.8
Il y a des contraintes imposes sur la compatibilit des tableaux. Ainsi, si le fils B de A est
lui-mme un noeud, lattribut B apparat la fois dans TA et dans TB , et sert didentifiant la
table TB , mais pas la table TA : une entre possible pour B peut apparatre plusieurs fois ou
pas du tout dans TA ; mais si elle apparat au moins une fois, elle doit tre prsente aussi dans
TB (la table TB est voir comme une dfinition et prcision de toutes les valeurs de lattribut
B quon peut trouver dans les autres tables). Pour un attribut C dune table T , notons T (C)
lensemble des valeurs prises par lattribut C dans la table T . La contrainte ci-dessus sexprime
de la faon suivante : TA (B) TB (B) (contrainte dinclusion). De plus, on a une contrainte
dunicit pour la colonne B de TB , formalisant la notion didentifiant : chaque valeur possible
de B dans ce tableau napparat quune fois.
Ce sont ces contraintes qui dfinissent la notion de cl : lattribut B de TB constitue une cl
primaire (un identifiant auquel on peut se rfrer dans une autre table, avec contrainte dunicit).
Lattribut B de TA constitue une cl trangre (il est accompagn dune rfrence une cl
primaire, donc un attribut dune autre table, avec contrainte dinclusion).

Remarque 10.2.9
La structure ADF nest pas ncessairement arborescente. Pouvez-vous imaginer un exemple de structure
contenant une boucle ?

III
III.1

Algbre relationnelle
Schma relationnel et relation

Nous formalisons maintenant le concept de base de donne.


Dfinition 10.3.1 (Attribut)
Un attribut dune base de donne est une des caractristiques dont on souhaite enregistrer la valeur, lors
dune entre. Ainsi, il sagit du nom des colonnes des diffrentes tables ci-dessus. On note A lensemble
des attributs.

Exemple 10.3.2
Dans lexemple ci-dessus, les attributs sont NOM, PRNOM, NAISSANCE, MORT, TITRE etc.

162

CHAPITRE 10. BASES DE DONNES RELATIONNELLES

Dfinition 10.3.3 (Domaine dun attribut)


Le domaine dun attribut est lensemble des valeurs possibles pour cet attribut. Le domaine de lattribut
A sera not dom(A).

Exemple 10.3.4
Nayant aucune restriction autre que lutilisation de lalphabet pour dsigner les noms des compositeurs, en notant L lalphabet latin (avec les lettres accentues, lapostrophe et lespace) donc
lensemble de toutes les lettres, et L le monode libre engendr par L (donc tous les mots quon
peut former avec cet alphabet), on a dom(NOM) = L
On a dom(NAISSANCE) = Z (mme sil est assez peu probable que notre base contienne des
compositeurs ns avant lan 1).
On peut restreindre certains domaines : par exemple dom(TYPE) peut tre restreint un certain
nombre de types, par exemple :
dom(TYPE) = { opra, symphonie, sonate, trio, quatuor, messe, etc. },
en catgorisant les types doeuvres tels quon le souhaite.
De mme, dom(INSTRUMENT) ou dom(FAMILLE) peuvent tre dfinis comme des ensembles
finis dtermins ( condition de lister tous les instruments, et toutes les familles dinstrument).
Dans la pratique, on dfinit souvent un domaine en imposant un format particulier pour les
entres (une chane de caractres de longueur infrieure 10 par exemple, ou une chane de
longueur fixe, constitue de chiffres ou lettres en positions spcifies...)

Dfinition 10.3.5 (Schma relationnel)


Un schma relationnel (ou schma de relation) est une application f : A D, o A est un ensemble
dattributs, D est un ensemble de domaines (donc un ensemble densembles). La fonction f est la
fonction associant A son domaine. Ainsi, f (A) = dom(A).

Par exemple, en notant M lensemble de tous les caractres, on peut prendre pour D lensemble P(M ),
mais cela ne donne aucune contrainte sur le format des entres. On peut imposer que les entres soient
des chanes de caractres alphabtiques quelconques, ou des chanes de caractres de longueur borne, ou
impose, ou des mots dune certaine langue, ou que ce soient des entiers, ou des dates sous un certain
format (JJ/MM/AAAA), ou des lments dun ensemble fini etc.
Si A = {A1 , . . . , An }, on parlera simplement du schma relationnel S = (A1 , . . . , An ), la donne des domaines dom(Ai ) tant implicite. Avec cette convention, les attributs du schma relationnel sont ordonns.
Dfinition 10.3.6 (Relation, valeur, enregistrement)
1. Une relation R (ou R(S)) associe un schma relationnel S = (A1 , . . . , An ) est un ensemble
fini de n-uplets de dom(A1 ) dom(An ).

2. Les lments de R sont appels valeurs (ou enregistrements) de la relation.

3. |R| est appel cardinal de la relation, et est gnralement not R.

On reprsente souvent une relation sous forme dune table, comme nous lavons fait prcdemment. Ainsi,
le schma relationnel dfinit les noms des colonnes dune table, et le type des entres de chaque colonne,
alors que la relation est lensemble des donnes entres dans la table. Un enregistrement (ou une valeur)
correspond une ligne de la table. Le cardinal de la relation est le nombre de lignes dans la table.

III

Algbre relationnelle

III.2

163

Cls

Comme nous lavons constat sur des exemples, en gnral, les donnes stockes dans une base de donne
vont tre rparties dans plusieurs tables. Ainsi, une base de donne sera dfinie par plusieurs schmas
relationnels et plusieurs tables. Certaines colonnes dune table renvoient des colonnes dautres tables.
Ce sont ces rfrences qui permettront ensuite de faire des recherches croises sur les diffrentes tables
simultanment. La formalisation de ces rfrences est faite par la notion de cl, intimement lie celle
didentifiant.
Dfinition 10.3.7 (Identifiant)
Un identifiant dune table est un ensemble dattributs (pouvant tre rduit un unique attribut) tel
que les valeurs prises par ces attributs dterminent toutes les autres valeurs de lenregistrement (donc
dterminent toute la ligne).
Ainsi, la donne des valeurs prises sur les attributs constituant lidentifiant dtermine sans ambigut
(donc identifient ) la ligne laquelle on fait rfrence : 2 lignes diffrentes ont des valeurs diffrentes de
ces attributs. Il sagit donc dune contrainte dunicit : toute valeur de lidentifiant ne peut apparatre
quune fois dans la table (si elle apparaissait deux fois, ces deux occurrences dtermineraient la mme
ligne, ce qui nest pas possible, les entres dune table (la relation) tant dfinies par une structure
densemble, donc sans rptition).
Remarque 10.3.8
1. Un identifiant peut tre constitu de plusieurs colonnes. Par exemple, dans la table OEUVRE,
lensemble { IDOEUVRE, COMPOSITEUR, TITRE } constitue un identifiant, mais cet identifiant nest pas minimal.
2. Par dfinition, { IDOEUVRE } est encore une identifiant. Si le singleton {A} est un identifiant,
on dira simplement que A est un identifiant de la table.
3. Par dfinition, une relation est un ensemble denregistrements : il ne peut donc pas y avoir
denregistrements multiples (plusieurs fois la mme ligne). Ainsi, toute table possde au moins
un identifiant qui est lensemble de tous ses attributs.
4. Tout ensemble dattribut I tel quil existe I I tel que I soit un identifiant est lui aussi un
identifiant. Une table possde donc en gnral plusieurs identifiants.

Dfinition 10.3.9 (Identifiant minimal)


Un identifiant est minimal ds lors quter un attribut de cet identifiant supprime le caractre identifiant.

Exemple 10.3.10
{ IDOEUVRE, COMPOSITEUR, OEUVRE } nest pas un identifiant minimal
IDOEUVRE est un identifiant minimal
{ COMPOSITEUR, OEUVRE } est aussi un identifiant minimal. En effet COMPOSITEUR
nest pas un identifiant (la plupart des compositeurs ont crit plus dune oeuvre, mme ceux
dont la notorit est base sur une unique oeuvre). OEUVRE nest pas non plus un identifiant,
puisque plusieurs compositeurs peuvent avoir compos une symphonie no 5.
Ainsi, il peut y avoir plusieurs identifiants minimaux. Certains identifiants minimaux peuvent
tre contitus de plusieurs attributs. Il nexiste pas toujours didentifiant minimal constitu dun
unique attribut, mais on peut toujours sarranger pour que ce soit le cas, quitte rajouter un
attribut (cest ce que nous avons fait en ajoutant lattribut IDOEUVRE).

164

CHAPITRE 10. BASES DE DONNES RELATIONNELLES

Remarque 10.3.11
La notion didentifiant prend tout son sens lorsque la table est suffisamment remplie et contient tous les
cas de figure possibles. En effet, si la table OEUVRE nest pas plus remplie que dans lexemple donne,
lattribut OEUVRE constitue galement un identifiant, mais videmment, cela na pas beaucoup de
pertinence puisquon voit facilement que le caractre identifiant a de fortes chances dtre bris en
grossissant la base de donne (ce qui est la vocation dune BDD !) Ainsi, la recherche dun identifiant
acceptable ne se fait pas simplement de faon automatique en regardant les donnes dj entres, mais
en considrant tous les cas de figures envisageables, mme sils ne se sont pas encore prsents dans la
base.
Remarque 10.3.12
On peut toujours se ramener la situation o la table possde au moins un identifiant constitu dun
unique attribut. Il suffit pour cela de partir dun identifiant (constitu de plusieurs attributs), dajouter
un nouvel attribut ID, et de numroter de faon artificielle les diffrentes valeurs possibles prises par
les attributs identifiants. Cest ce que nous avons fait en introduisant IDOEUVRE ou IDINSTR ou
IDSOL. Pour les deux premiers, nous avons essay de garder une numrotation significative, pour le
dernier, cest une numrotation qui ne possde en soi pas tellement de sens, et dont le seul intrt est
le caractre identifiant.
Par commodit, on supposera (sans perte de gnralit) que toutes les tables que nous considrerons ont
au moins un identifiant rduit un attribut.
Dfinition 10.3.13 (Cl primaire Primary Key)
Une cl primaire dune relation R est le choix dun attribut AP K (primary key) identifiant la relation.
On pourrait dfinir une cl primaire comme un ensemble dattributs identifiant, mais la remarque prcdente nous permet de faire cette simplification sans perte de gnralit.
Exemple 10.3.14
De faon naturelle, on peut choisir les cls primaires suivantes :
IDOEUVRE pour la table OEUVRES
IDNAT pour la table NATIONALIT
IDCOMP pour la table COMPOSITEURS
IDSOL pour la table SOLISTES
IDINSTR pour la table INSTRUMENTATION
INSTRUMENT pour la table INSTRUMENT
Certaines colonnes de ces tables renvoient alors des identifiants : ainsi, IDCOMP de la table
NATIONALIT renvoie lidentifiant IDCOMP de la table compositeur.
Cette rfrence peut se faire avec des noms de colonnes distincts, ce qui impose de dfinir
explicitement la rfrence : par exemple la colonne COMPOSITEUR de la table OEUVRE
renvoie la colonne IDCOMP de la table COMPOSITEUR. Ceci nous amne la notion de cl
trangre.

Dfinition 10.3.15 (Cl trangre Foreign Key)


Soit R(S) une relation. Une cl trangre est la donne dun coupe (AF K , R (S )) constitu dun
attribut AF K de S et dun schma relationnel S muni dune cl primaire AP K , et telle que R(AF K )
R (AP K ) (contrainte dinclusion, ou contrainte rfrentielle), o R(AF K ) dsigne lensemble des valeurs
prises par AF K dans la table.

III

Algbre relationnelle

165

Ainsi, les entres de la table R correspondant lattribut AF K renvoient aux entres de la table R
correspondant lattribut AP K , et toute valeur prise par AF K doit aussi tre prise par AP K (donc avoir
t dfinies dans le tableau rfrent).
Ces notions peuvent tre dfinies uniquement sur le schma relationnel, en imposant alors des contraintes
sur les entres venir de la base (contrainte dunicit pour la cl primaire, contrainte rfrentielle pour
la cl trangre) : le SGBD peut refuser une entre dans la BDD si elle ne respecte par ces contraintes,
afin de prserver lintgrit des cls.
On pourra donc se contenter de reprsenter ces notions sur les schmas relationnels. Un schma relationnel
sera reprsent par un tableau listant ses attributs, par exemple :
COMPOSITEUR
IDCOMP
NOM
PRNOM
NAISSANCE
MORT
Dans ce tableau, la cl primaire sera indique en la soulignant, comme on la fait ci-dessus. Une cl
tangre entre un attribut dune table et une autre table sera reprsente en reliant par une flche
lattribut correspondant et la table rfrente :
COMPOSITEUR

OEUVRE

IDCOMP

IDOEUVRE

NOM

COMPOSITEUR

PRNOM

TITRE

NAISSANCE

DATE

MORT

TYPE

Dans cette reprsentation, il ny a pas dambigut pour savoir quelle colonne du premier tableau rfre
la flche (la rfrence se fait vers lidentifiant dclar, donc la cl primaire).

III.3

Schma de base de donne

Dfinition 10.3.16 (Schma de BDD)


Un schma de BDD est un ensemble
E = {T = (S, AP K , {(AF K,i ; Si ), i I})}.
dont les lments sont des triplets forms de :
un schma relationnel S
une cl primaire AP K associe au schma relationnel S
un ensemble de cls trangres (AF K,i ; Si ) dattributs de S vers des schmas relationnels Si , tels
quil existe Ti dans E dont la premire coordonne est Si .
Il sagit donc de la donne de la structure mme dune base de donne. Chaque triplet lment de E est
la donne dune table de la base de donne, de son identifiant (donc on impose que chaque table ait un
identifiant), et des rfrences ventuelles vers une ou plusieurs autres tables de la base (par la donne des
cls trangres).

166

CHAPITRE 10. BASES DE DONNES RELATIONNELLES

On peut facilement tendre cette dfinition au cas o les cls sont donnes par des ensembles dattributs
plutt quun attribut unique.
Dfinition 10.3.17 (Base de donne)
Soit E un schma de BDD. Une BDD de schma E est un ensemble {RT , T E} de relations (tables),
chaque RT tant une relation associe au schma relationnel T , ces relations vrifiant les contraintes
dunicit et les contraintes rfrentielles lies aux cls primaires et trangres dfinies par E.
On verra dans le prochain chapitre comment effectuer des oprations sur une telle structure. Toutes les requtes (recherches) peuvent se faire partir de combinaisons de contructions algbriques simples (algbre
relationnelle). Nous tudierons ces requtes au travers du langage SQL (Structured Query Language),
actuellement prdominant dans ce domaine. La force de cette approche des bases de donne, et de ce
langage, vient du fait que les oprations de lalgbre relationnelle peuvent alors toutes scrire avec une
seule instruction : SELECT.

IV

Exercices

Exercice 17
Dcrire sous forme dun diagramme avec des flches la structure complte du schma de BDD dfini
par lexemple dvelopp tout au long de ce chapitre.

Exercice 18
Imaginer comment enrichir la structure de cette base de donne en y incluant la possibilit de rpertorier
les enregistrements que lon possde (il faut donc inclure la diversit des interprtations, et des supports
musicaux, et la possibilit davoir plusieurs oeuvres sur un mme support)

Exercice 19
Dfinir un schma de BDD dont le but est de stocker les informations suivantes relatives aux classes
prparatoires scientifiques au lyce : lves et renseignements divers sur les lves, professeurs et renseignements divers, matires, types de classe (PCSI, MPSI...), classes.

Exercice 20
Enrichir lexemple de lexercice prcdent en y incluant lemploi du temps et les salles (et leur capacit,
ou dautres caractristiques)...

Exercice 21
Comment grer un htel compos de 3 btiments, et de chambres de capacits diverses et prix divers ?

11
SQL : Cration dune BDD et
requtes
Dans ce chapitre, nous voyons comment crer et interroger une base de donnes. Le langage qui sest
impos pour cela est le langage SQL (Structured Query Language). La plupart des SGBD actuels utilisent
ce langage, avec ventuellement quelques variantes. Ceux ne lutilisant pas (ACCESS par exemple) ont
en gnral une interface de traduction permettant lutilisateur dentrer ses requtes en SQL.
Le langage SQL est utilis tout aussi bien pour la cration, le rmplissage et linterrogation de la base. En
ce sens, les 3 instructions principales sont :
CREATE pour crer une table
INSERT pour ajouter des donnes
SELECT ... FROM ... WHERE ... pour interroger la base (requte)
ces trois instructions, on peut ajouter ALTER permettant des modifications sur la structure de la base
de donne, et UPDATE permettant des modifications sur les enregistrements dj prsents (mises jour).
Nous utiliserons Python pour crer et manipuler les bases de donnes. Pour cela, nous utilisons la bibliothque sqlite3. Le principe est ensuite de crer une connection sur une BDD avec la fonction connect,
puis de crer un curseur sur cette connection. Grce ce curseur, on peut ensuite excuter sur la base
des instructions SQL, grce la mthode execute() applicable au curseur cr. On passe en paramtre
de cette mthode linstruction SQL sous forme dune chane de caractres (par exemple raw string pour
viter tout problme dutilisation des guillemets, apostrophes et retours la ligne).
La connection doit tre ferme en fin de programme.
Par exemple, pour crer une table compositeur dans une base de donnes, linstruction SQL est :
CREATE TABLE IF NOT EXISTS compositeur (
idcomp varchar(6) NOT NULL,
nom varchar(30) NOT NULL,
prenom varchar(30) NOT NULL,
naissance int(4),
mort int(4),
PRIMARY KEY (idcomp)
);
Si on veut crer cette base dans un SGBD muni dune interface graphique conviviale, il est possible de
rentrer directement cette instruction telle quelle, voire de faon encore plus simple, suivant linterface.
Pour crer cette table via Python, on crit :
import sqlite3

168

CHAPITRE 11. SQL: CRATION DUNE BDD ET REQUTES


connection = sqlite3.connect(musique.db)
cur = connection.cursor()
cur.execute("""CREATE TABLE IF NOT EXISTS compositeur (
idcomp varchar(6) NOT NULL,
nom varchar(30) NOT NULL,
prenom varchar(30) NOT NULL,
naissance int(4),
mort int(4),
PRIMARY KEY (idcomp)
);""")
connection.commit()
connection.close()

De mme, chaque requte doit ensuite tre envoye via linstruction cur.execute("""requte""").
Le rsultat parvient sous forme dun objet itrable, les objets (sous format tuple) pouvant tre numrs
laide de for. Par exemple, la fonction suivante crer laffichage des objets de litrable cur, employer
lissue dune requte.
def affiche(curseur):
for L in curseur:
print(L)
Chaque ligne L du rsultat de la requte est affich sous forme dun tuple.
Un des intrts de lutilisation dun langage de programmation (par exemple Python) pour linterrogation
des bases de donnes est de pouvoir facilement utiliser, et donc traiter informatiquement, le rsultat de
la requte.

I
I.1

Cration dune base de donnes


Cration des tables

Nous ne nous tendrons pas trop sur la cration dune base de donnes. La cration dune table se fait
avec linstruction CREATE.
Si on veut recrer une base dj existante (par exemple obtenue lors dune tentative prcdente qui ne
nous satisfait pas), on peut commencer par effacer les tables existantes, laide de DROP TABLE. Pour ne
pas faire derreur, on peut ajouter une option IF EXISTS :
DROP TABLE IF EXISTS compositeur;
On crer une nouvelle table avec CREATE TABLE. Loption IF NOT EXISTS permet de ne pas retourner
derreur au cas o la table existe dj (dans ce cas, il ny a pas de nouvelle table cre)
Lorsquon cre une table, il faut prciser :
1. son nom
2. pour chacun des attributs : son nom, son format et dventuelles contraintes sur lesquelles nous ne
nous tendons pas. La seule que nous mentionnons (en plus des contraintes lies aux cls) est la
contrainte NOT NULL, imposant quune valeur soit ncessairement donne cet attribut lors dun
enregitrement dune donne.
3. la donne de la cl primaire, et eventuellement des cls tangres.
Par exemple, pour crer une table oeuvre (la table compositeur tant dfinie comme plus haut) :

Cration dune base de donnes

169

CREATE TABLE IF NOT EXISTS oeuvre (


idoeuvre varchar(10) NOT NULL,
compositeur varchar(6) NOT NULL,
oeuvre varchar(128) NOT NULL,
datecomp int(4) NOT NULL,
type varchar(20) NOT NULL,
FOREIGN KEY (compositeur) REFERENCES compositeur,
PRIMARY KEY (idoeuvre));
La cl tangre renvoie la table compositeur. Lidentification se fait sur la cl primaire de cette table.
Une autre syntaxe possible pour la dclaration des cls est :
CREATE TABLE IF NOT EXISTS oeuvre (
idoeuvre varchar(10) NOT NULL PRIMARY KEY,
compositeur varchar(6) NOT NULL REFERENCES compositeur,
oeuvre varchar(128) NOT NULL,
datecomp int(4) NOT NULL,
type varchar(20) NOT NULL);
Les formats classiques des attributs sont varchar(n), int(n), decimal(n,m), pour des chanes de caractres, des entiers ou des dcimaux. Le paramtre n indique le nombre maximal de caractres, et m
indique le nombre de chiffres aprs la virgule. Dautres types existent (par exemple date). dcouvrir
soi-mme.
On peut dfinir des contraintes beaucoup plus prcises sur les diffrents attributs (notamment des
contraintes dunicit). Ceci dpasse les objectifs de ce chapitre dintroduction.
Il existe galement des instructions permettant de modifier des tables existantes, en particulier ALTER
TABLE. On peut laide de cette instruction modifier le nom dun attribut, les contraintes, ajouter ou
enlever des cls... L encore, cela va au-del des objectifs de ce chapitre.

I.2

Entre des donnes

Entrer une ligne dans une table se fait avec linstruction INSERT INTO ... VALUES ... , suivant la
syntaxe suivante :
INSERT INTO compositeur (idcomp, nom, prenom, naissance, mort) VALUES
(BAC 1, Bach, Johann Sebastian, 1685, 1750),
(MOZ 1, Mozart, Wolfgang Amadeus, 1756, 1791),
(BEE 1, Beethoven, Ludwig (van), 1770, 1827),
(BOU 1, Boulez, Pierre, 1925, 2016);
On indique donc le nom de la table, les attributs quon souhaite remplir, dans un ordre dtermin, et
les n-uplets que lon souhaite dfinir, spars par une virgule. On termine la liste par un point-virgule.
Comme le montre la dernire ligne entre, certains attributs peuvent rester non dfinis, ce qui revient
leur attribuer la valeur NULL. Ceci est possible si lattribut na pas t dfini avec la contrainte NOT NULL
lors de la cration de la table.
En nindiquant quun sous-ensemble des attributs de la table, on peut ne remplir que quelques colonnes.
Les autres seront alors compltes par la valeur NULL :
INSERT INTO compositeur (idcomp, nom, prenom) VALUES
(RAC 1, Rachmaninov, Serge),
(DVO 1, Dvorak, Antonin);
On peut aussi modifier des donnes dj rentres avec UPDATE ... SET ... :

170

CHAPITRE 11. SQL : CRATION DUNE BDD ET REQUTES

UPDATE compositeur SET naissance = 1873, mort = 1943 WHERE idcomp = RAC 1

II

Interrogation dune BDD (Requtes)

Nous abordons ici laspect principal de lutilisation dune base de donnes, savoir la rdaction de requtes
en langage SQL afin dextraire dune base de donnes les informations qui nous intressent.
Pour rdiger une requte, il est indispensable de connatre prcisment la structure de la base
(les noms des tables, les noms des attributs, les cls primaires et trangres). Ainsi, la premire tape est
souvent de rechercher et comprendre cette structure.
Ensuite, les requtes sont toutes effectues laide de linstruction SELECT ... FROM ... WHERE ...,
et de constructions algbriques effectues sur les tables, en particulier de jointures (JOIN ON).
Une requte consiste en une demande dextraction dun ensemble dattributs, vrifiant une certaine proprit.
Les attributs demands peuvent tre pris dans diffrentes tables (ncessite des jointures ou produits
cartsiens)
Les conditions peuvent porter sur les attributs demands, ou sur dautres attributs, des mmes
tables, ou non.
La rponse consiste en lensemble des donnes des attributs selectionns, tels que les entres (compltes) associes vrifient les conditions souhaites.
Lensemble des requtes donnes en exemple ici porte sur une base de donne musicale respectant la
structure de BDD expose dans le chapitre prcdent, lexception des formations musicales, laisses de
ct. Ainsi, en plus des deux tables compositeur et oeuvre dj cres dans les exemples prcdents,
nous avons aussi les tables suivantes crer :
CREATE TABLE IF NOT EXISTS nationalit (
idnat int(3) NOT NULL,
compositeur varchar(6) NOT NULL,
pays varchar(30) NOT NULL,
PRIMARY KEY (idnat),
FOREIGN KEY (compositeur) REFERENCES compositeur );
CREATE TABLE IF NOT EXISTS soliste (
idsol int(5) NOT NULL,
oeuvre varchar(10) NOT NULL,
instrument varchar(30) NOT NULL,
PRIMARY KEY (idsol),
FOREIGN KEY (instrument) REFERENCES instrument,
FOREIGN KEY (oeuvre) REFERENCES oeuvre );
CREATE TABLE IF NOT EXISTS instrument (
instrument varchar(30) NOT NULL,
famille varchar(30) NOT NULL,
PRIMARY KEY (instrument) );
Il est important de noter que la syntaxe utilise ici est celle dfinie dans la bibliothque
SQLITE de Python, qui scarte parfois de la syntaxe standard. De manire gnrale, dune
version lautre de SQL, il existe souvent des petites variantes dans la syntaxe.

II

Interrogation dune BDD (Requtes)

II.1

171

Requtes simples

Dfinition 11.2.1 (Requte simple)


Une requte simple est une requte portant sur lextraction dattributs dune mme table, la condition
dextraction sexprimant uniquement laide des attributs de cette mme table.
Ainsi, tout se passe dans une unique table. Linstruction incontournable est :
SELECT Att1, Att2, ...
FROM nom_table
WHERE conditions
Remarque 11.2.2
La slection SELECT est voir comme une projection sur un sous-ensemble des colonnes (on ne conserve
que certaines colonnes), alors que la condition WHERE est voir comme une projection sur un sousensemble de lignes (on ne garde que les lignes vrifiant les conditions requises)
La clause WHERE est optionnelle. Si on ne lutilise pas, il sagit de lextraction des colonnes souhaites,
sans restriction :
SELECT instrument
FROM instrument
retourne lensemble des instruments solistes prsents dans la base, savoir :
(luth,)
(violoncelle,)
(violon,)
(viole de gambe,)
(clavecin,)
(piano,)
(orgue,)
(flte,)
(hautbois,)
(baryton,)
(soprano,)
(clarinette,)
(cor,)
(basson,)
(haute-contre,)
Formellement, il sagit dune projection sur lensemble des coordonnes selectionnes. Si le tableau sappelle TAB, et les attributs selectionns Ai1 , . . . , Aik , on notera formellement TAB[Ai1 , . . . , Aik ].
Linstruction suivante :
SELECT instrument
FROM instrument
WHERE famille = claviers
renvoie quand elle uniquement les instruments clavier :
(clavecin,)
(piano,)
(orgue,)

172

CHAPITRE 11. SQL: CRATION DUNE BDD ET REQUTES

Remarquez que pour obtenir lensemble des familles dinstruments, on formule assez logiquement la
requte :
SELECT famille
FROM instrument
On reoit la rponse suivante, peu satisfaisante :
(cordes pinces,)
(cordes frottes,)
(cordes frottes,)
(claviers,)
(claviers,)
(claviers,)
(bois,)
(bois,)
(voix,)
(voix,)
(bois,)
(cuivre,)
(bois,)
(voix,)
Ainsi, SELECT ne supprime pas les redondances dans les rponses. On peut le forcer le faire en ajoutant
loption DISTINCT :
--Requte:
SELECT DISTINCT famille
FROM instrument
--Rponse:
(cordes pinces,)
(cordes frottes,)
(claviers,)
(bois,)
(voix,)
(cuivre,)
Enfin, on peut remplacer la liste des attributs par * si on veut selectionner lensemble des attributs de la
table :
--Requte:
SELECT *
FROM compositeur
WHERE naissance = 1685
--Rponse:
(BAC 1, Bach, Johann Sebastian, 1685, 1750)
(HAE 1, Haendel, Georg Friedrich, 1685, 1759)
(SCA 1, Scarlatti, Domenico, 1685, 1757)
Voici une liste non exhaustive de tests possibles pour exprimer les conditions :
-- TESTS POSSIBLES POUR LA CONDITION WHERE...

II

Interrogation dune BDD (Requtes)

173

= > < <> <= >= -- comparaisons sur des nombres ou chanes de caractres.
-- Attention, Z<a
IS NULL
-- teste si la valeur na pas t attribue
IN (A1,A2,...) -- teste lappartenance une liste
BETWEEN a AND b -- appartenance un intervalle (nombre ou chane)
LIKE _1
-- compare une chane de caractres o _ reprsente
-- un caractre quelconque
LIKE %1
-- compare une chane de caractres o % reprsente
-- une chane (ventuellement vide) quelconque
AND OR NOT
-- oprations boolennes usuelles, parenthser bien
Par ailleurs, on peut utiliser des oprations sur les attributs, soit pour exprimer des tests, soit pour
former de nouvelles colonnes. Former de nouvelles colonnes se fait en indiquant dans la clause SELECT
les oprations faire partir des autres attributs pour crer cette colonne.
-- OPRATIONS SUR LES ATTRIBUTS
+ * - /
-- Oprations arithmtiques usuelles
LENGTH(t)
-- longueur de la chane de caractres t
ch1 || ch2
-- concatnation
REPLACE(attribut,ch1,ch2) -- remplace dans lattribut les sous-chanes
-- ch1 par ch2
LOWER(ch)
-- met en minuscules
UPPER(ch)
-- met en majuscules
SUBSTR(ch,a,b)
-- extrait la sous-chane des indices a b
-- SUBSTRING dans de nombreuses versions
Voici quelques exemples :
-- Requte: compositeurs dont le nom a 6 lettres
SELECT nom
FROM compositeur
WHERE LENGTH(nom) = 6
--Rponse:
(Mozart,)
(Rameau,)
(Marais,)
(Chopin,)
(Brahms,)
(Wagner,)
(Boulez,)
(Dvorak,)
-- Requte: retourner Prnom Nom sous forme dune unique chane, pour
-les compositeurs dont le nom commence par B
SELECT prenom || || nom
FROM compositeur
WHERE nom LIKE B%
-- Rponse:

174

CHAPITRE 11. SQL: CRATION DUNE BDD ET REQUTES


(Johann Sebastian Bach,)
(Ludwig (van) Beethoven,)
(Johann Christian Bach,)
(Johannes Brahms,)
(Pierre Boulez,)
-- Requte: NOM en majuscules, prnom en minuscules, pour les
-compositeurs morts entre 1820 et 1830
SELECT UPPER(nom), LOWER(prenom)
FROM compositeur
WHERE mort BETWEEN 1820 AND 1830
-- Rponse:
(BEETHOVEN, ludwig (van))
(SCHUBERT, franz)
-- Requte: les 3 premires lettres du nom des compositeurs ns avant
-1600
SELECT UPPER(SUBSTR(nom,1,3))
FROM compositeur
WHERE naissance < 1600
-- Rponse:
(DOW,)
(HAL,)

Certaines oprations mathmatiques portant sur lensemble des valeurs dun attribut sont possibles (fonctions agrgatives) :
-- FONCTIONS AGRGATIVES
COUNT(*)
COUNT(ATTR)
AVG(ATTR)
SUM(ATTR)
MIN(ATTR)
MAX(ATTR)

-------

nombre de lignes
nombre de lignes remplies pour cet attribut
moyenne
somme
minimum
maximum

Les fonctions agratives servent dfinir de nouvelles colonnes, mais ne peuvent pas tre utilises dans
une condition. Un exemple :
-- Requte: ge du composteur mort le plus vieux
SELECT idcomp, MAX(mort - naissance)
FROM compositeur
-- Rponse:
93
Les fonctions agrgatives peuvent sutiliser avec linstruction GROUP BY Att HAVING Cond permettant de
calculer les fonctions agrgatives sur des paquets de donnes prenant la mme valeur pour lattribut Att,
en ne gardant que les lignes vrifiant la condition Cond.

II

Interrogation dune BDD (Requtes)

175

-- Date de la premire sonate pour des compositeurs avant N dans


-- lordre alphabtique.
SELECT compositeur, MIN(datecomp)
FROM oeuvre
GROUP BY compositeur, type
HAVING (compositeur < N) AND (type = sonate)
-- Rsultat:
(BAC 1, 1720)
(BEE 1, 1795)
(BRA 1, 1852)
(CHO 1, 1839)
(HAE 1, 1710)
(MOZ 1, 1774)

Remarque 11.2.3
Linstruction HAVING effectue une selection sur la table obtenue aprs calcul de la fonction
agrgative.
On peut aussi utiliser linstruction WHERE, se plaant alors avant GROUP BY. Ceci permet deffectuer une selection avant calcul de la fonction agrgative.
Attention, les champs slectionns doivent en thorie respecter le groupement dans le sens o
la valeur du champ doit tre la mme pour toutes les entres groupes dans une part. Dans
notre exemple, cest le cas puisquon selectionne un champ group compositeur. Toute autre
slection est incorrecte en SQL strict, mais tolre dans certaines variantes (SQLite utilis sous
Python par exemple). On peut parfois sen sortir, notamment pour le maximum, en utilisant
une structure ORDER BY ... LIMIT ... explicite ci-dessous.
Dans notre exemple, la selection peut seffectuer avant ou aprs calcul de la fonction agrgative (puisque
la selection se fait sur des paquets denregistrement de mme compositeur et mme type). Ainsi, on aurait
pu crire :
SELECT compositeur, titre, MIN(datecomp)
FROM oeuvre
WHERE (compositeur < N) AND (type = sonate)
GROUP BY compositeur, type
Dans le cas o la selection peut se faire avant comme ici, cest prfrable, car plus conome en calcul (la
fonction agrgative nest calcule que sur la selection faite)
Certaines selections ne peuvent tre effectues quavant (lorsquelles ne sont pas faites sur des paquets
respectant le groupement). Par exemple, extraire de la base la moyenne dge des compositeurs ns entre
1800 et 1900 (ici, il ny a pas de groupement faire, mais on pourrait imaginer par exemple un groupement
par nationalit, en cherchant cette information dans une autre table, avec la syntaxe quon verra plus
loin) :
SELECT AVG(mort - naissance)
FROM compositeur
WHERE naissance BETWEEN 1800 AND 1900
Certaines selections ne peuvent tre effectues quaprs, notamment celles qui utilisent le rsultat du
calcul. Pour accder la valeur de la fonction agrgative pour pouvoir lutiliser dans un test, il faut

176

CHAPITRE 11. SQL: CRATION DUNE BDD ET REQUTES

au passage renommer la colonne correspondante, ce qui se fait avec AS. Par exemple, pour rcuprer la
premire sonate des compositeurs avant N dans lordre alphabtique, mais seulement si celle-ci est crite
aprs 1800, on peut crire :
SELECT compositeur, titre, MIN(datecomp) AS dt
FROM oeuvre
WHERE (compositeur < N) AND (type = sonate)
GROUP BY compositeur, type
HAVING dt >= 1800
En revanche, la syntaxe suivante renvoie une erreur :
SELECT compositeur, titre, MIN(datecomp) AS dt
FROM oeuvre
WHERE (compositeur < N) AND (type = sonate) AND (dt >= 1800)
GROUP BY compositeur, type
En effet, la colonne dt na pas encore t calcule au moment du test qui lutilise.
On aurait pu penser crire :
SELECT compositeur, titre, MIN(datecomp) AS dt
FROM oeuvre
WHERE (compositeur < N) AND (type = sonate) AND (datecomp >= 1800)
GROUP BY compositeur, type
mais leffet de cette selection est un peu diffrent.
Exercice 22
Comprendre la diffrence entre cette requte et la prcdente.

Enfin, notons quil est possible dordonner les rsultats par ordre croissant (numrique ou alphabtique)
grce ORDER BY :
-- Compositeurs ns entre 1870 et 1890, par ordre de naissance
SELECT nom, naissance, mort
FROM compositeur
WHERE naissance BETWEEN 1870 AND 1890
ORDER BY naissance
-- Rsultat:
(Rachmaninov, 1873, 1943)
(Ives, 1874, 1954)
(Ravel, 1875, 1937)
(Stravinsky, 1882, 1971)
La structure ORDER BY peut sutiliser avec une clause LIMIT n o n est un entier. Dans ce cas, on rcupre
uniquement les n premiers rsultats aprs classement. Dans lexemple ci-dessus, on peut modifier la
requte de sorte rcuprer les 2 premires lignes uniquement :
-- Compositeurs ns entre 1870 et 1890, par ordre de naissance
SELECT nom, naissance, mort
FROM compositeur
WHERE naissance BETWEEN 1870 AND 1890

II

Interrogation dune BDD (Requtes)

177

ORDER BY naissance
LIMIT 2
-- Rsultat:
(Rachmaninov, 1873, 1943)
(Ives, 1874, 1954)
Cette structure peut tre intressant pour obtenir une ligne ralisant le maximum dun de ses attributs
(avec LIMIT 1). Mais cela se retourne quune des ventuelles plusieurs lignes ralisant le maximum de cet
attribut.

II.2

Sous-requtes

Dfinition 11.2.4 (Sous-requte)


Une sous-requte est une requte portant sur lextraction dattributs dune mme table, la condition
sexprimant laide dattributs dune autre table. Plus prcisment, on extrait les attributs A1 , Ak ,
et on exprime sur A1 une condition portant sur les attributs de la table T1 , telle que (A1 , T1 ) soit une
cl trangre. On peut combiner grce aux oprations boolennes, plusieurs tests, pour les diffrents
Ai , impliquant plusieurs tables Ti , en suivant les cls trangres.
La syntaxe suivre est la suivante :
SELECT A1, A2, ..., Ak
FROM T
WHERE A1 IN (SELECT B1
FROM T1
WHERE condition)
Ici, B1 est la cl primaire de T1 , donc lattribut vers lequel rfre la cl trangre (A1 , T1 ). On exprime
dons la condition sur B1 , en extrayant de T1 lattribut B1 , lorsque la condition requise est satisfaite. On
teste ensuite lappartenance de A1 la liste des admissibles ainsi obtenue.
Remarque 11.2.5
Il est important de remarquer que le rsultat dune requte SELECT a le mme format quune
table, et peut donc tre rutilis dans une autre requte SELECT comme toute table. On peut
donc imbriquer des instructions SELECT les unes dans les autres.
On peut aussi remonter les cls trangres : dans ce cas, la cl trangre est (B1 , T ), et A1 est
la cl primaire de T .
Un exemple :
-- Les compositeurs de la base ayant crit au moins une musique de film:
SELECT nom, prenom
FROM compositeur
WHERE idcomp in (SELECT DISTINCT compositeur
FROM oeuvre
WHERE type = film)
-- Rponse:
(Chostakovitch, Dimitri)
(Prokofiev, Serge)

178

CHAPITRE 11. SQL : CRATION DUNE BDD ET REQUTES


-- Les oeuvres avec hautbois:
SELECT compositeur, titre
FROM oeuvre
WHERE idoeuvre in (SELECT DISTINCT oeuvre
FROM soliste
WHERE instrument = hautbois)
-- Rponse:
(MIL 1, La chemine du roi Ren)
(POU 1, Sonate pour hautbois et piano)
(VIV 1, 12 concertos pour violon et hautbois op 7)

On peut enchaner de la sorte des sous-requtes en suivant les cls trangres, si la condition porte sur
une table accessible en plusieurs tapes :
-- Oeuvres de compositeur franais utilisant un instrument soliste
-- dans la famille des cordes frottes
SELECT compositeur, titre
FROM oeuvre
WHERE (idoeuvre in (SELECT DISTINCT oeuvre
FROM soliste
WHERE instrument IN
(SELECT instrument
FROM instrument
WHERE famille = cordes frottes)))
AND
(compositeur in (SELECT idcomp
FROM compositeur
WHERE idcomp IN
(SELECT compositeur
FROM nationalit
WHERE pays = France)))
(MAR
(MAR
(MAR
(MAR
(MAR

1,
1,
1,
1,
1,

Pices une et deux violes, premier livre)


Deuxime livre de pices de viole)
Pices de viole, troisime livre)
Pices une et trois violes, quatrime livre)
Pices de viole, cinquime livre)

Le principe de la sous-requte permet aussi dutiliser le rsultats de fonctions agrgatives dans un test :
-- Compositeurs morts 20 ans avant lge moyen des compositeurs de la
-- base
SELECT nom, prenom, naissance, mort
FROM compositeur
WHERE mort - naissance +20 < (SELECT AVG(mort-naissance)
FROM compositeur)
(Mozart, Wolfgang Amadeus, 1756, 1791)
(Schubert, Franz, 1797, 1828)
(Chopin, Frdric, 1810, 1849)
(Moussorgski, Modeste, 1839, 1881)
(Purcell, Henry, 1659, 1685)

II

Interrogation dune BDD (Requtes)

II.3

179

Constructions ensemblistes

Lorsquon veut extraire des attributs de plusieurs tables, il faut utiliser des constructions ensemblistes permettant de combiner plusieurs tables. Nous introduisons ici lunion, lintersection et le produit cartsien.
Cest partir de cette dernire construction quon construira des jointures permettant des requtes
complexes sur plusieurs tables. Nous isolons cette dernire construction dans le paragraphe suivant.
Dfinition 11.2.6 (Intersection)
Lintersection de deux extractions de deux tables peut se faire condition que les attributs extraits des
deux tables soient de mme format. Gnralement, elle se fait sur les attributs relis par une cl (lun
deux tant une cl primaire). Le rsultat est alors lensemble des valeurs de cet (ou ces) attribut(s)
commun aux deux tables. Chacune des deux tables peut elle-mme tre le rsultat dune extraction
prcdente.
La syntaxe utilise INTERSECT. Sur un exemple :
-- Identifiants de compositeurs ns entre 1700 et 1800 et ayant crit
-- une sonate.
SELECT idcomp FROM compositeur
WHERE naissance BETWEEN 1700 AND 1800
INTERSECT
SELECT DISTINCT compositeur FROM oeuvre
WHERE type = sonate
(BEE 1,)
(MOZ 1,)
(SCH 1,)
Une intersection peut souvent se reexprimer plus simplement avec une sous-requte et une opration
boolenne AND. Cela peut tre efficace lorsquon veut croiser deux tables compltes (par exemple deux
tables de clients de deux filiales) :
SELECT * FROM table1
INTERSECT
SELECT * FROM table2

Dfinition 11.2.7 (Union)


Lunion de deux tables est possible si les attributs sont en mme nombre et de mme type. Il sagit
des enregistrements prsents dans lune ou lautre de ces tables. Lunion ne conserve que les attributs
distincts.
Par exemple pour fusionner deux tables :
SELECT * FROM table1
UNION
SELECT * FROM table2
Ici encore, il est souvent possible de remplacer avantageusement une union par une opration boolenne
OR.
On peut aussi faire des exceptions A \ B, sur des tables de mme type :
SELECT instrument FROM instrument
WHERE famille = bois

180

CHAPITRE 11. SQL : CRATION DUNE BDD ET REQUTES


EXCEPT
SELECT instrument FROM soliste
WHERE oeuvre in
(SELECT idoeuvre FROM oeuvre WHERE compositeur IN
(SELECT idcomp FROM compositeur
WHERE idcomp in
(SELECT compositeur FROM nationalit
WHERE pays = Allemagne)))

Exercice 23
Que fait la requte ci-dessus ?
La dernire opration ensembliste est le produit cartsien.
Dfinition 11.2.8 (Produit cartsien de deux tables)
Le produit cartsien de deux tables R1 et R2 est lensemble des n + p-uplets (x1 , . . . , xn , y1 , . . . , yp ),
pour toutes les (x1 , . . . , xn ) R1 et (y1 , . . . , yp ) R2 , sans proccupation de concordance des attributs
de R1 et R2 qui pourraient tre relis.
Le produit cartsien se fait en extrayant simultanment les colonnes des deux tables :
SELECT * FROM tab1, tab2
On peut faire le produit cartsien dextractions de deux tables. Dans ce cas, on liste les attributs garder
aprs SELECT, en prcisant dans quelle table lattribut se trouve par une notation suffixe. Si lattribut
(sous le mme nom) napparat pas dans les deux tables, on peut omettre la notation suffixe (il ny a pas
dambigut) :
SELECT tab1.Att1, Att2, tab2.Att3 FROM tab1, tab2
Dans cet exemple, lattribut Att2 est suppos nexister que dans lune des deux tables.
Pour viter des lourdeurs dcriture (dans les conditions), et pouvoir rfrer plus simplement aux diffrents
attributs (cest utile aussi lorsquun attribut est obtenu par un calcul et non directement), on peut donner
un alias aux attributs selectionns
SELECT tab1.Att1 AS B1, Att2*Att4 AS B2 , tab2.Att3 AS B3 FROM tab1, tab2
Ici, on suppose que Att2 et Att4 sont deux attributs numriques. On pourra utiliser les valeurs des
attributs de la nouvelle table via les alias B1, B2, et B3.
Le produit cartsien est une opration coteuse et peu pertinente en pratique si elle nest pas utilise en
parallle avec une opration de slection des lignes. En effet, on associe le plus souvent des lignes nayant
rien voir, par exemple une ligne consacre une oeuvre de Mozart et une ligne consacre aux donnes
personnelles de Stravinsky. Mais cette opration est le point de dpart de la notion de jointure.

II.4

Jointure

La technique de la jointure permet de former une table laide dune selection dattributs provenant de
deux tables diffrentes :
Dfinition 11.2.9 (Jointure)
Une jointure de deux tables consiste considrer le produit cartsien de ces deux tables (ou dextractions), en identifiant deux colonnes (une de chaque table, typiquement dun ct une cl trangre vers

II

Interrogation dune BDD (Requtes)

181

lautre table, de lautre la cl primaire), de sorte ne garder dans le produit cartsien que les n-uplets
tels que les valeurs soient les mmes pour ces deux attributs.
En dautre terme, une jointure revient une instruction de slection sur le produit cartsien. Par exemple,
pour slectionner des attributs de deux tables en faisant une jointure en identifiant lattribut Att4 de la
table 2 et lattribut Att1 de la table 1 :
SELECT T1.Att1, T1.Att2, T2.Att1
FROM T1, T2
WHERE T1.Att1 = T2.Att4
Un exemple concret :
SELECT nom, prenom, titre FROM compositeur, oeuvre
WHERE idcomp = compositeur
-- Rsultat partiel:
(Weill, Kurt, Aufstieg und Fall der Stadt Mahagony)
(Weill, Kurt, Die Dreigroschenoper)
Une autre syntaxe parfois plus commode (notamment pour itrer le procder en oprant des jointures
successives) se fait avec INNER JOIN ... ON ... (le terme INNER tant facultatif) :
SELECT nom, prenom, titre
FROM compositeur JOIN oeuvre ON idcomp = compositeur
On peut combiner cette jointure avec une slection conditionnelle WHERE :
-- Oeuvres crites par un compositeur moins de 18 ans.
SELECT nom, prenom, titre
FROM compositeur JOIN oeuvre ON idcomp = compositeur
WHERE datecomp - naissance <= 18
ORDER BY nom
(Dowland, John, A dream)
(Dowland, John, Dowland s First Gaillard)
(Dowland, John, Captain Candish s Gaillard)
(Mozart, Wolfgang Amadeus, Sonate pour piano
(Mozart, Wolfgang Amadeus, Sonate pour piano
(Mozart, Wolfgang Amadeus, Sonate pour piano
(Mozart, Wolfgang Amadeus, Sonate pour piano
(Mozart, Wolfgang Amadeus, Sonate pour piano
(Mozart, Wolfgang Amadeus, Sonate pour piano
(Mozart, Wolfgang Amadeus, Symphonie 6 K43)
(Rachmaninov, Serge, Concerto pour piano 1)
(Schubert, Franz, Erlknig)

1
2
3
4
5
7

K279)
K280)
K281)
K282)
K283)
K309)

On peut faire des jointures successives si on veut des attributs de tableaux plus loigns, ou si on veut
extraire des donnes de plus de deux tables :
SELECT nom, prenom, titre, soliste.instrument
FROM compositeur
JOIN oeuvre ON idcomp = compositeur
JOIN soliste ON oeuvre = idoeuvre

182

CHAPITRE 11. SQL : CRATION DUNE BDD ET REQUTES


JOIN instrument ON instrument.instrument = soliste.instrument
WHERE famille = bois
ORDER BY nom
(Bach, Johann Sebastian, Sonate pour flte et clavecin BWV 1030, flte)
(Boulez, Pierre, Dialogue de l ombre double, clarinette)
(Haendel, Georg Friedrich, Sonate pour flte bec HWV 358, flte)
(Haendel, Georg Friedrich, Sonate pour flte bec HWV 365, flte)
(Milhaud, Darius, La chemine du roi Ren, flte)
(Milhaud, Darius, La chemine du roi Ren, hautbois)
(Milhaud, Darius, La chemine du roi Ren, clarinette)
(Milhaud, Darius, La chemine du roi Ren, basson)
(Poulenc, Francis, Sonate pour hautbois et piano, hautbois)
(Poulenc, Francis, Sonate pour clarinette et piano, clarinette)
(Vivaldi, Antonio, 12 concertos pour violon et hautbois op 7, hautbois)

Exercice 24
Que fait cette requte ?

II.5

Algbre relationnelle

Il sagit de la formalisation algbrique des constructions tudies prcdemment. On rappelle quune relation R (cest--dire une table) est la donne dun ensemble de k-uplets, vrifiant certaines contraintes lies
un schma relationnel S. On dfinit alors formellement les constructions tudies dans les paragraphes
prcdents.
Dfinition 11.2.10 (Union, intersection, exception, produit cartsien)
Les constructions dunion, intersection, exception correspondent prcisment aux constructions algbriques usuelles sur les relations : R1 R2 , R1 R2 , (R1 R2 ) \ R2 et R1 R2 .
Dfinition 11.2.11 (Projection)
Lopration de projection de la relation R sur les attributs Ai1 , . . . , Aik consiste en lextraction sans
rptition des attributs Ai1 , . . . , Aik de la relation R. Il sagit donc de limage de R par la projection
(Ai1 ,...,Aik ) : dom(A1 ) dom(An ) dom(Ai1 ) dom(Aik ).
La nouvelle relation obtenue par projection est donc note juste titre (Ai1 ,...,Aik ) (R).
En SQL, la projection correspond donc linstruction :
SELECT DISTINCT Ai1, ..., Aik FROM R
Dfinition 11.2.12 (Slection)
Soit R une relation, et E une expression logique exprimant une condition sur les attributs de R. La
selection, note E (R) est la nouvelle relation obtenue de R en ne conservant que les enregistrements
vrifiant la condition E. Ainsi, en notant E(x) lexpression boolenne gale True si et seulement si
lenregistrement x vrifie la condition E, la selection est dfinie par :
E (R) = {x R | E(x)}

II

Interrogation dune BDD (Requtes)

183

En SQL, il sagit donc de linstruction :


SELECT * FROM R WHERE E

Dfinition 11.2.13 (Renommage)


Le renommage consiste donner un nouveau nom un attribut dune table. Il ne sagit pas ncessairement dune modification dfinitive de la base (possible avec ALTER dans certains SGBD), mais dune
modification locale, rsultat dune requte. Le rsultat du renommage de lattribut A en B se note
AB (R).
En SQL, on effectue un renommage avec AS :
SELECT A1, ..., Ak AS B, ... An FROM R

Dfinition 11.2.14 (Jointure)


Soient R1 et R2 deux tables, et A et B deux attributs, lun de R1 , lautre de R2 . La jointure de R1
et R2 sur lexpression A = B est la table obtenue en conservant tous les attributs de R1 et de R2 ,
recolles sur les attributs A et B : ainsi, les attributs A et B sont confondus (ne forment quun attribut
de la nouvelle table), et les enregistrements sont forms de la concatnation des valeurs des attributs
de R1 et de R2 , respectant la condition A = B. La jointure est note R1
A=B R2 .
Formellement, elle peut tre dcrite par :
R1
A=B R2 = (A1 ,...,An ,B1 ,...,B,...,B
(A=B (R1 R2 )),

n)
signifie quon a t lattribut B de la liste.
o la notation B
En SQL, la jointure R1
A=B R2 seffectue de la faon suivante :
SELECT * FROM R1 JOIN R2 ON A=B

Exercice 25
Exprimer les rsultats de toutes les requtes de ce chapitre nutilisant pas de fonctions agrgatives de
faon formelle, laide des oprations de lalgbre relationnelle.