Introduction `a l`algorithmique avec Python

Introduction `a l’algorithmique avec Python
PROT Olivier
13 novembre 2009
Table des mati`eres
1 Introduction `a Python 1
1.1 Syntaxe .................................................... 1
1.1.1 Ex´ecution d’un programme Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.2 Variables, op´erations et typage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.3 Fonctions ............................................... 2
1.1.4 BouclesFORetWHILE....................................... 3
1.1.5 Instructions conditionnelles : IF - ELIF - ELSE . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.6 Illustration - Calcul d’une moyenne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2 Algorithmes pour le calcul de π4
2.1 M´ethoded’Archim`ede ............................................ 4
2.1.1 ´ Etudedel’algorithme ........................................ 5
2.1.2 Algorithmecorrig´e.......................................... 6
2.1.3 Erreursnum´eriques.......................................... 7
2.1.4 Lam´ethodedeVi`ete......................................... 8
2.1.5 Le vrai algorithme d’Archim`ede . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2 M´ethode des fl´echettes (Monte-Carlo) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.1 Construction de l’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.2 ´ Etude de la convergence au sens des probabilit´es . . . . . . . . . . . . . . . . . . . . . . . . . 10
1 Introduction `a Python
Python (www.python.org) est un langage de programmation moderne, favorisant la programmation structur´ee
(`a l’aide de fonctions) et orient´e-objet. C’est ´egalement un logiciel libre pouvant s’installer sur la plupart des
ordinateurs.
Python est ce que l’on appelle un langage interpr´et´e, cela signifie qu’un programme est traduit en langage-
machine au moment de son ex´ecution. Lorsque l’on ouvre une session Python, chaque ligne de programme saisie
est imm´ediatement traduite et ex´ecut´ee. On peut bien sˆur, sauver le programme dans un fichier afin de l’ex´ecuter
ult´erieurement, mais `a chaque appel le programme est toujours traduit avant d’ˆetre ex´ecut´e. Ceci est en opposition
avec les langages compil´es (par exemple FORTRAN,Cou C++) o`u le programme est traduit en langage machine une
fois pour toutes.
Enfin, Python est ce que l’on appelle un langage haut-niveau, il permet de faire simplement des op´erations
complexes et cela implique que son fonctionnement soit assez ´eloign´e de celui de la machine. Au contraire, un
langage bas-niveau (par exemple le C) est un langage dont les op´erations sont assez proches de ce que fait la
machine et qui par cons´equent ne permet pas de faire des op´erations complexes de mani`ere simple. L’avantage
de l’utilisation d’un langage haut-niveau est qu’il permet d’´ecrire des programmes plus rapidement en ´evitant les
erreurs.
1.1 Syntaxe
1.1.1 Ex´ecution d’un programme Python
Comme signal´e plus haut, il est possible d’ex´ecuter un programme Python en tapant les lignes de code une `a
une dans l’interpr´eteur. Cela est fastidieux car pour r´e-ex´ecuter le programme il faut re-taper tout le code en entier
1

`a chaque fois. Une meilleure solution consiste `a ouvrir un programme d’´edition de texte et de sauver le programme
dans un fichier. Par convention les fichiers de programme Python utilisent l’extension ’.py’, comme par exemple
’prog1.py’. Pour ´editer du code Python de mani`ere efficace il existe d’excellents logiciels libres :
–Emacs et Vim sont certainement les ´editeurs de texte les plus puissants mais ils sont ´egalement difficiles `a
prendre en main.
– Il y a ´egalement Gedit sous GNOME ou Kate sous KDE.
– Il existe des ´editeurs d´edi´es `a Python : DrPython, Eric3, SPE.
– Enfin, sous windows, et si aucun des ´editeurs de texte cit´es ci-dessus n’est install´e, vous pouvez utiliser le
bloc-notes.
Une fois le programme tap´e et sauvegard´e dans un fichier nomm´e prog.py par exemple, il suffit pour l’ex´ecuter de
saisir la commande execfile(’prog.py’) dans l’interpr´eteur Python .
1.1.2 Variables, op´erations et typage
Voici un petit exemple permettant de faire une introduction aux variables et au typage sous Python. Les lignes
commen¸cant par ’#’ sont des commentaires qui sont ignor´es par Python, le but des commentaires est de rendre le
code plus lisible et plus clair.
# definition d’un entier valant 1
a=1
b=a/2
print b
# definition d’un nombre r´eel
a=1.1
b=a/2
print b
Ce programme illustre le fait que Python est orient´e-objet. En effet l’instruction a=1 d´efinit dans la m´emoire
un entier avalant 1, alors que l’instruction a=1.1 d´efinit un nombre r´eel avalant 1.1. Ainsi, Python d´etecte
automatiquement le type des variables et cela `a de grandes cons´equences dans la suite du programme :
– lorsque aest un entier l’op´eration b=a/2 calcule la division euclidienne sur les entiers de 1 par 2, le r´esultat
est donc 0.
– lorsque aest un r´eel l’op´eration effectu´ee est la division classique sur les r´eels.
Les op´erations classiques +,−,×, /, de Python sont donc diff´erentes suivant le type des variables utilis´es. En python,
l’op´eration puissance se note **, la racine carr´ee sqrt().
1.1.3 Fonctions
Python favorise la programmation structur´ee, c’est pourquoi la d´efinition de fonction se fait de mani`ere tr`es
simple avec Python via le mot cl´e def. Voici un exemple o`u nous d´efinissons une fonction qui prend en entr´ee
un xet qui retourne x2+x/2, le mot cl´e de retour en Python est return. Le type de xn’est pas d´efini dans la
d´eclaration de fonction, le calcul effectu´e sera donc diff´erent suivant le type de x.
# d´efinition de la fonction
def myfunction(x):
r=x*x+x/2
return r
# calcul pour un r´eel
a=1.2
b1=myfunction(a)
# puis pour un entier
a=1
b2=myfunction(a)
# affichage des r´esultats
2

print "nombre reel:", b1
print "nombre entier", b2
Les tabulations dans la d´efinition de la fonction sont obligatoires pour que Python sache o`u se termine la
d´efinition de cette fonction. De mani`ere g´en´erale avec Python, la tabulation sert `a d´elimiter les blocs de code. Le
d´ebut d’un bloc d’instruction est signal´e avec le symbole :.
1.1.4 Boucles FOR et WHILE
Nous souhaitons tracer la courbe repr´esentative de la fonction x#→ x2+x/2 sur [0,9]. Nous allons demander
`a Python de calculer les valeurs de cette fonction pour x=0,···,9 et de les afficher. L’instruction for est tr`es
pratique pour cela :
# Boucle FOR
for i in range(0,10):
print "i=", i, "f(i)=", myfunction(i)
La variable iest le compteur de la boucle for ; au cours des it´erations de la boucle, il va prendre toutes les valeurs
comprises entre 0 et 9 (cet intervalle de valeur ´etant d´ecrit par l’instruction range(0,10)).
Une autre mani`ere de cr´eer une boucle est d’utiliser le mot cl´e while. Cette instruction n´ecessite de tester une
condition, le programme ex´ecute le bloc de la boucle seulement si la condition est vraie.
# Exemple boucle WHILE
# d´efinition d’un compteur
k=0
condition=True
while condition:
print "i=", k, "f(i)=", myfunction(k)
# mise `a jour du compteur
k = k+1
# arr^et si k>9
condition = (k < 10)
Ce programme fait la mˆeme chose que le pr´ec´edent, cela montre qu’il existe plusieurs fa¸cons d’´ecrire un programme.
Exercice 1
1. A l’aide d’une boucle FOR ou WHILE, calculer la somme des 1000 premiers entiers
2. Mˆeme question pour la somme des 100 premiers entiers au carr´e.
1.1.5 Instructions conditionnelles : IF - ELIF - ELSE
Nous voulons programmer une fonction qui prend les valeurs xsi x<0, 1 si x≥0 et x<1, et x2sinon. Voici
comment impl´ementer cette fonction avec les instructions if,elif,else
def fonction2(x):
if (x<0):
y=x
elif (x<1):
y=1
else:
y=x*x
return y
Une mani`ere de bien comprendre ce programme est de remplacer if par ’si’, elif par ’ou si’ et else par ’sinon’.
Il est possible, apr`es un IF de tester autant de conditions que l’on souhaite avec des elif. Par contre il ne peut
y avoir qu’un seul else `a la fin. Pour tester des conditions plus ´elabor´ees, il est pratique d’utiliser les op´erations
logiques ET, OU, ainsi que la n´egation. En Python ces op´erations se notent ’&’, ’|’, et ’not’.
3

1.1.6 Illustration - Calcul d’une moyenne
# programme Exemple - Calcul d’une moyenne
def moy(L):
# calcule le nombre d’´el´ements dans la liste L
l=len(L)
# calcul de la moyenne
# calcul de la somme des ´el´ements de L
m=0.0;
for i in range(0,l):
m=m+L[i]
# on divise par le nombre d’´el´ements
m=m/l
# m est donc la moyenne arithm´etique
return m
# d´efinition d’une liste vide
L=list()
OK=True
while OK:
# demande un nombre au clavier
a=input("rentrer un nombre = ")
# V´erifions que a est bien un nombre
if ((isinstance(a,int)) | (isinstance(a,float))):
# ajout du nombre dans L
L.append(a)
print "La moyenne est : ", moy(L)
else:
print "Fin du programme"
OK=False
2 Algorithmes pour le calcul de π
2.1 M´ethode d’Archim`ede
La m´ethode d’Archim`ede pour calculer une ´evaluation du nombre πest bas´ee sur l’utilisation de polygones
r´eguliers comme approximation du cercle. Nous allons nous en inspirer pour ´etablir un algorithme d’´evaluation du
nombre π, en approchant la surface du disque unit´e par celle d’un polygone. L’algorithme est le suivant :
Algorithm 1 Calcul de πpar la m´ethode d’Archim`ede
Initialisation. Choisir k0∈.
loop
1. Construire un polygone r´egulier Pnavec kncot´es, dont l’aire est une ´evaluation de celle du disque unit´e.
2. Calculer l’aire andu polygone Pn.
3. Multiplier le nombre de cot´es par 2, kn+1 =2kn
end loop
L’algorithme 1 est une ´ebauche et est inutilisable tel quel pour calculer une approximation de π`a l’aide d’un
ordinateur. La suite (an)n∈g´en´er´ee par l’algorithme est clairement issue d’une r´ecurrence. Choisissons k0= 4,
le polygone P0est donc un carr´e que nous choisissons comme dans la Figure 2.1 (Gauche). D’apr`es cette figure
4

α
R=1
h
C
α
R=1 h
C
Fig. 1 – Gauche : Polygone P0. Droite : Polygone P1
nous voyons que le polygone est constitu´e de quatre triangles isoc`eles. Etant donn´e que l’angle αvaut π
4, que
h=Rcos(α) et que C=2Rsin(α), nous en d´eduisons
a0=k0R2cos(α) sin(α) = 2 sin(2α) = 2
ce qui est une mauvaise ´evaluation de π!
Passons `a l’´etape suivante k1= 8, le polygone est donc un octogone, comme le montre la Figure 2.1 (Droite).
Pour calculer son aire nous proc´edons comme pr´ec´edemment, nous le d´ecoupons en 8 triangles, l’angle αnous
permettant de calculer l’aire de chacun des triangles. Ainsi, comme α=π
8, nous obtenons
a1=k0R2cos(α) sin(α) = 4 sin(2α)=2
√2≈2.8284
ce qui est d´ej`a un peu mieux.
Nous pouvons poursuivre cette r´ecurrence pour calculer la valeur des aires (ai)i∈suivantes, cela conduit `a
l’´ecriture de l’algorithme 2. Cet algorithme est plus pr´ecis, mais il est compl`etement inutile ´etant donn´e qu’il est
n´ecessaire d’initialiser l’angle α`a la valeur π/4, alors que le but de l’algorithme est de calculer π! Nous remarquons
aussi qu’il ne dispose pas de condition d’arrˆet et g´en`ere donc une suite infinie de nombres (an)n∈. Plusieurs
questions math´ematiques se posent : la suite (an)n∈converge-t-elle ? Est-ce qu’elle converge vers le nombre π
comme nous le souhaitions ? Enfin, l’algorithme est il un “bon” moyen de calculer une approximation de π?
Algorithm 2 Calcul de πpar la m´ethode d’Archim`ede - II
Initialisation de l’angle : α←π
4
Initialisation du nombre de cot´es : k←4
loop
a←k
2sin(2α)
k←2k
α←α
2
end loop
2.1.1 ´ Etude de l’algorithme
D’apr`es la d´efinition de l’algorithme 2, les suites (αn) et (kn) sont g´eom´etriques. Nous en d´eduisons
∀n∈,αn=π
22+n,k
n=2
2+n
5