Initiation `a la programmation

Chapitre 2
Initiation `a la programmation
2.1 Notion d’algorithme
Python est un langage interpr´et´e. Ceci veut dire qu’`a chaque fois que Python rencontre un appui sur la
touche <Entree >, il ex´ecute l’instruction qu’on vient de lui fournir. L’ex´ecution de cette instruction est ef-
fectu´ee par l’interpr´eteur qui se charge de traduire l’instruction ´ecrite sous Python en ordres compr´ehensibles
par l’ordinateur, qui euxmˆemes se transformeront en signaux envoy´es aux circuits ´electroniques de l’ordinateur.
Le terme interpr´eteur peut prˆeter `a confusion. Python est incapable d’interpr´eter une instruction autrement
que comme un ordre imp´eratif. Il applique chaque instruction (c’est-`a-dire chaque ordre) sans aucun recul, sans
aucun ´etat d’ˆame, mˆeme si cela aboutit parfois `a un r´esultat tr`es ´eloign´e de ce que le programmateur avait en
tˆete. Incapable d’empathie avec le programmateur, un ordinateur ne r´einterpr`ete jamais un ordre de sa propre
initiative. C’est une machine qui fait exactement ce qu’on lui dit de faire, mais pas forc´ement ce qu’on voudrait
qu’il fasse. Ecrire un programme sous Python, c’est ´ecrire des instructions compr´ehensibles pour l’interpr´eteur
de Python. L’art de programmer, c’est agencer et imbriquer ces instructions de mani`ere judicieuse pour faire
calculer par l’ordinateur un r´esultat voulu. C’est `a la charge du programmateur de comprendre comment Python
effectue pr´ecis´ement chaque instruction pour pouvoir pr´evoir l’ex´ecution du programme.
Dans cette optique, il est fondamental de pouvoir ´ecrire en termes clairs une s´equence ou une imbrication d’ins-
tructions pour d´etailler un algorithme. Nous verrons essentiellement trois fa¸cons d’effectuer cette description :
M´ethode 1 : Ecrire le programme directement en Python. C’est une fa¸con rigoureuse de d´etailler un algorithme,
mais ce n’est pas forc´ement la fa¸con la plus intelligible, et elle n’est pas adapt´ee `a la description
succincte de gros programmes.
M´ethode 2 : le pseudocode. On d´etaille un algorithme avec des mots en fran¸cais, avec une syntaxe proche de
Python mais plus souple. La traduction du pseudocode en Python est relativement ais´ee, et il
est facile de traduire le pseudocode vers n’importe quel autre langage. Par ailleurs, quand il faut
´ecrire de gros programmes, le pseudocode peut s’adapter avec des mots qui d´ecrivent des parties
de programme plutˆot que des instructions. En pseudocode, on utilise les notations suivantes :
— Une affectation se note avec la fl`eche ←. Par exemple l’affectation a←5 se traduira en Python
par a= 5.
— Le test d’´egalit´e se note indiff´eremment = ou == (alors qu’en Python on le note ==).
M´ethode 3 : le graphe du flux des instructions. On repr´esente une instruction dans un rectangle si elle n’a
qu’une seule suite possible ; et dans un losange si elle ouvre la voie `a plusieurs possibilit´es de suite.
Des fl`eches repr´esentent l’ordre de d´eroulement des instructions. Nous verrons tr`es bientˆot ce genre
de repr´esentation. Un graphe de flux est un outil tr`es utile pour bien visualiser sur des exemples
de programmes courts le s´equen¸cage des instructions.
2.2 Instructions conditionnelles
Il est possible de r´ealiser des instructions seulement si une condition est v´erifi´ee
11

2.3. BOUCLES INCONDITIONNELLES CHAPITRE 2. INITIATION ` A LA PROGRAMMATION
>>> x = 0
>>> if 17%2 == 1 :
x=x+ 1
...
>>> x
1
Ici, une des particularit´es de Python entre en jeu. Pour indiquer `a Python le bloc d’instruction `a ex´ecuter si
la condition est v´erifi´ee, ce bloc d’instruction doit ˆetre indent´e, c’est-`a-dire ˆetre mis en retrait par rapport `a la
marge gauche. Il suffit pour cela de mettre au d´ebut de chaque ligne de ce bloc des espaces ou une tabulation
pour placer le nouveau bloc plus `a droite. On peut utiliser au choix un nombre fixe d’espaces ou une tabulation
mais il faut prendre garde `a conserver ce choix tout au long du bloc. Cette indentation se substitue aux blocs
begin...end de nombreux langages. Par exemple, ceci est valide :
>>> if 17%2 == 1 :
x+ = 1
x∗=x
mais ceci ne l’est pas :
>>> if 17%2 == 1 :
x+ = 1
x∗=x
On peut effectuer des instructions si la condition n’est pas v´erifi´ee grˆace `a l’instruction else qui doit se
trouver au mˆeme niveau que le if :
>>> if 17%2 == 1 :
x+ = 1
else :
x+ = 2
Il est ´egalement possible et mˆeme recommand´e d’abr´eger les tests imbriqu´es `a l’aide de elif. Ainsi, au lieu
d’´ecrire :
>>> if n%3 == 0 :
x+ = 1
else :
if n%3 == 1 :
x+ = 3
else :
x∗=x
on utilisera :
>>> if n%3 == 0 :
x+ = 1
elif n%3 == 1 :
x+ = 3
else :
x∗=x
Cette derni`ere version permet ainsi de placer tous les blocs d’instructions dans un mˆeme niveau d’indentation,
ce qui accroˆıt la lisibilit´e.
2.3 Boucles inconditionnelles
Lorsque l’on souhaite r´ep´eter un bloc d’instructions un nombre d´etermin´e de fois, on peut utiliser un comp-
teur actif, c’est-`a-dire une variable qui compte le nombre de r´ep´etitions et va donc conditionner la sortie de la
12

CHAPITRE 2. INITIATION ` A LA PROGRAMMATION 2.4. BOUCLES CONDITIONNELLES
boucle. Les boucles born´ees sont introduites par le mot-cl´e for.
Exemple classique : le calcul de la factorielle.
>>> n = 100
>>> r = 1
>>> for iin range(1, n+1) :
r∗=i
...
>>> r
9332621544394415268169923885626670049071596826438162146859296389521759999322991560894146397615651
8286253697920827223758251185210916864000000000000000000000000L
Remarquez la syntaxe : pour effectuer une it´eration born´ee de la variable i de a inclus `a b exclu, on dit que
i doit parcourir la liste range(a,b). Attention, range(a,b) est l’intervalle d’entiers [a,b[ ouvert `a droite, d’o`u le
n+1 dans le code ci-dessus.
Dans le programme pr´ec´edent, le pas d’incr´ementation n’´etant pas sp´ecifi´e, il est par d´efaut ´egal `a +1. Si
on d´esire un autre pas d’incr´ementation, on le pr´ecisera ainsi que le montre l’exemple suivant :
>>> n = 100
>>> r = 1
>>> for iin range(1, n+1,2) : # On a choisi un pas d’incr´ementation ´egal `a 2
r∗=i
...
>>> r
Ici , on a choisi un pas ´egal `a 2 . Au fait, que calcule le programme pr´ec´edent ?
On peut aussi it´erer sur une liste arbitraire :
>>> premiers = [2,3,5,7,11,13,17]
>>> prod = 1
>>> for xin premiers :
prod ∗=x
...
>>> prod
510510
ou sur une chaˆıne de caract`eres :
>>> for i in ’les caracteres’ :
print(i , end=’*’)
l*e*s* *c*a*r*a*c*t*e*r*e*s
2.4 Boucles conditionnelles
Cette structure permet d’executer un bloc d’instructions autant de fois qu’une condition est v´erifi´ee. On
r´ealise une boucle conditionnelle `a l’aide du mot-cl´e while suivi de la condition ponctu´ee d’un deux-points.
Vient alors le bloc d’instruction `a r´ep´eter, ce dernier ´etant d´elimit´e par l’indentation.
>>> n = 42
>>> while n! = 0 :
n/ = 2
...
Le d´eroulement de la boucle est alors le suivant :
— On teste la condition : ici, nest-il non nul ?
13

2.5. COMPL ´ EMENTS CHAPITRE 2. INITIATION ` A LA PROGRAMMATION
— Si la condition est v´erifi´ee, l’´evaluation de l’expression bool´eenne renvoie la valeurt True, Python effectue
les instructions et on revient au d´ebut de la boucle.
— Si elle n’est pas v´erifi´ee, l’´evaluation de l’expression bool´eenne renvoie la valeur False et on sort de la
boucle .
2.5 Compl´ements
Aussi bien dans les boucles for ou while, on peut utiliser ces deux instructions :
— break : interrompt la boucle.
— continue : termine le tour de boucle en cours et retourne au d´ebut de la boucle (avec it´eration suivante
pour une boucle for, ou test de la condition pour une boucle while).
Exemples :
PB1 : Que fait le programme suivant ?
>>> a = 0
>>> while (a >= 0) :
a+=1
if (a==5) :
continue
elif ( a==10) :
break
else :
print a
PB2 : Qu’affiche le programme suivant ?
>>> for i in range(11) :
if i % 2 :
continue
else :
print i
PB3 : Mˆeme question pour :
>>> l = [2,3,5,7]
>>> i = 0
>>> for nin l:
if i== n:
break
i+ = 1
...
>>> i
4
14

CHAPITRE 2. INITIATION ` A LA PROGRAMMATION 2.6. R ` EGLES DE BONNE PROGRAMMATION
2.6 R`egles de bonne programmation
Bien programmer, c’est d’abord r´efl´echir avant d’´ecrire. Avant de saisir un programme sur l’ordinateur, il faut
toujours, en s’armant d’un papier et d’un crayon :
1. Analyser le probl`eme `a r´esoudre.
2. D´eterminer les variables n´ecessaires `a sa r´esolution.
3. Elaborer un premier sch´ema d’algorithme.
Un programme doit pouvoir ˆetre lu et relu. Pour faciliter ces ´echanges, quelques r`egles s’imposent :
1. Utiliser des noms de variables et de fonctions explicites.
2. Commenter les diff´erentes ´etapes du programme avec le caract`ere #.
3. Documenter les fonctions (cf. Chapitre 4).
Enfin, quelques r`egles de pr´esentation sont `a respecter :
1. Placer un espace apr`es une virgule, un point-virgule ou deux-points ;
2. Ne pas placer d’espace avant une virgule, un point-virgule ou deux-points ;
3. Placer un espace de chaque cˆot´e d’un op´erateur ;
4. Ne pas placer d’espace entre le nom d’une fonction et sa liste d’arguments.
5. Indenter, c’est `a dire d´ecaler le texte par rapport `a la marge.
2.7 Exercices
Ex 1 : Quelle est la valeur de la variable yapr`es la suite d’instructions suivante ?
p= 1
d= 0
r= 0
h= 1
z= 0
f=pand (dor r)
g= not r
m= not pand not z
g=gand (dor hor m)
if for g:y= 1
else : y= 0
Ex 2 : Quelle est la valeur de la variable ok apr`es la suite d’instructions suivante ?
x= 2
y= 3
d= 5
h= 4
if x > 0 and x < d :
if y > 0 and y < h : ok = 1
else : ok = 0
else : ok = 3
Ex 3 : Quelle est la valeur de la variable yapr`es la suite d’instructions suivante ?
x= 3
y= -2
if x < y :y=y−x
elif x== y:y= 0
else : y=x−y
15