« Programmation Python/Structures de contrôle » : différence entre les versions

Contenu supprimé Contenu ajouté
m →‎top : Soulagement de la version imprimable avec AWB
Aucun résumé des modifications
Ligne 1 :
<noinclude>{{Programmation Python}}</noinclude>
 
== Notion de bloc, instruction pass ==
Dans notre premier chapitre, nous avons vu que l'activité essentielle d'un analyste-programmeur est la résolution de problèmes. Or, pour résoudre un problème informatique, il faut toujours effectuer une série d'''actions'' dans un certain ''ordre''. La description structurée de ces actions et de l'ordre dans lequel il convient de les effectuer s'appelle un ''algorithme''.
De manière générale, un bloc contient tout le code avec une même indentation.
<source lang=python>
ceci est le bloc principal
if condition:
bloc 2
if condition2:
bloc 3
fin du bloc 2
fin du bloc 1
</source>
 
Si à un endroit on a syntaxiquement besoin d'un bloc mais qu'il n'y a rien à faire, on peut utiliser l'instruction <code>pass</code>, qui justement ne fait rien
Les ''structures de contrôle'' sont les groupes d'instructions qui déterminent l'ordre dans lequel les actions sont effectuées. En programmation moderne, il en existe seulement trois : la ''séquence''<ref>Tel qu'il est utilisé ici, le terme de séquence désigne donc une série d'instructions qui se suivent. Nous préférerons dans la suite de cet ouvrage réserver ce terme à un concept Python précis, lequel englobe les chaînes de caractères, les tuples et les listes (voir plus loin).</ref> et la ''sélection'', que nous allons décrire dans ce chapitre, et la répétition que nous aborderons au chapitre suivant.
<source lang=python>
if condition:
pass
else:
instruction ...
</source>
 
== Séquence dL'instructionsinstruction "if" ==
 
On utilise très souvent cette structure de contrôle. Sa syntaxe est très simple :
{{remarque|Sauf mention explicite, les instructions d'un programme s'exécutent les unes après les autres, dans l'ordre où elles ont été écrites à l'intérieur du script.}}
 
<source lang=python>
Le « chemin » suivi par Python à travers un programme est appelé un ''flux d'instructions'', et les constructions qui le modifient sont appelées des ''instructions de contrôle de flux''.
if condition:
instructions
...
</source>
 
L'indentation après le ":" est obligatoire.
Python exécute normalement les instructions de la première à la dernière, sauf lorsqu'il rencontre une ''instruction conditionnelle'' comme l'instruction <tt>if</tt> décrite ci-après (nous en rencontrerons d'autres plus loin, notamment à propos des boucles de répétition). Une telle instruction va permettre au programme de suivre différents chemins suivant les circonstances.
 
Cette structure de contrôle permet de tester une condition et de n'exécuter les instructions que si cette condition est vérifiée. Exemple :
== Sélection ou exécution conditionnelle ==
<source lang="python">
a = 11
if a > 10 :
print ("a est plus grand que dix")
</source>
 
"if" veut dire "si" en français.
Si nous voulons pouvoir écrire des applications véritablement utiles, il nous faut des techniques permettant d'aiguiller le déroulement du programme dans différentes directions, en fonction des circonstances rencontrées. Pour ce faire, nous devons disposer d'instructions capables de ''tester une certaine condition'' et de modifier le comportement du programme en conséquence.
 
En exécutant ce programme, on voit "a est plus grand que dix" apparaître à l'écran. On peut perfectionner le programme pour prendre en compte le cas ou a est plus petit que dix :
La plus simple de ces instructions conditionnelles est l'instruction if. Pour expérimenter son fonctionnement, veuillez entrer dans votre éditeur Python les deux lignes suivantes :
<source lang="python">
if a > 10 :
print ("a est plus grand que dix")
else:
print ("a n'est pas plus grand que dix")
</source>
 
"else" veut dire "sinon" en français.
<pre>
>>> a = 150
>>> if (a > 100):
...
</pre>
 
On utilise aussi parfois elif (contraction de "else if") :
La première commande affecte la valeur 150 à la variable a. Jusqu'ici rien de nouveau.
<source lang="python">
Lorsque vous finissez d'entrer la seconde ligne alors , par contre, vous constatez que Python réagit d'une nouvelle manière. En effet, et à moins que vous n'ayez oublié le caractère « : » à la fin de la ligne, vous constatez que le ''prompt principal'' (>>>) est maintenant remplacé par un prompt secondaire constitué de trois points<ref>Dans certaines versions de l'éditeur Python pour ''Windows'', le prompt secondaire n'apparaît pas.</ref>.
if a > 10 :
print ("a est plus grand que dix")
elif a == 10:
print ("a est égal à dix")
else:
print ("a est plus petit que dix")
</source>
 
== L'instruction "while" ==
Si votre éditeur ne le fait pas automatiquement, vous devezcomme vous voulez à présent effectuer une tabulation (ou entrer 4 espaces) avant d'entrer la ligne suivante, de manière à ce que celle-ci soit ''indentée'' (c'est-à-dire en retrait) par rapport à la précédente. Votre écran devrait se présenter maintenant comme suit :
 
permet d'exécuter des commandes '''tant qu''''une ou plusieurs conditions sont vraies.
<pre>
>>> a = 150
>>> if (a > 100):
... print "a dépasse la centaine"
...
</pre>
 
<source lang=python>
Frappez encore une fois <Enter>. Le programme s'exécute, et vous obtenez :
while condition:
commandes
</source>
 
par exemple :
<pre>
a dépasse la centaine
</pre>
 
<source lang=python>
Recommencez le même exercice, mais avec <code>a = 20</code> en guise de première ligne : cette fois Python n'affiche plus rien du tout.
i=0
while i<5:
i=i+1
print i,
</source>
 
donne à l'exécution :
L'expression que vous avez placée entre parenthèses est ce que nous appellerons désormais une condition. L'instruction if permet de tester la validité de cette condition. Si la condition est vraie, alors l'instruction que nous avons indentée après le « : » est exécutée. Si la condition est fausse, rien ne se passe. Notez que les parenthèses utilisées ici sont optionnelles sous Python. Nous les avons utilisées pour améliorer la lisibilité. Dans d'autres langages, il se peut qu'elles soient obligatoires.
 
<source lang=python>
Recommencez encore, en ajoutant deux lignes comme indiqué ci-dessous. Veillez bien à ce que la quatrième ligne débute tout à fait à gauche (pas d'indentation), mais que la cinquième soit à nouveau indentée (de préférence avec un retrait identique à celui de la troisième) :
1 2 3 4 5
</source>
 
== L'instruction "for" ==
<pre>
Exemple de la boucle en C for (i=0; i<5 ; i++ )
>>> a = 20
<source lang=python>
>>> if (a > 100):
for i in range(5) :
... print "a dépasse la centaine"
commandes
... else:
</source>
... print "a ne dépasse pas cent"
...
</pre>
 
Pour le "foreach" :
Frappez <Enter> encore une fois. Le programme s'exécute, et affiche cette fois :
<source lang=python>
for champ in ['champ1', 'champ2', 'champ3']:
commandes
</source>
 
== Les instructions "break", "continue" ==
<pre>
L'instruction break permet d'arrêter une boucle avant sa fin. L'instruction continue est similaire, mais au lieu d'interrompre la boucle, elle permet de passer à l'itération suivante.
a ne dépasse pas cent
<source lang=python>
</pre>
for i in range(5):
if i==3:
break
print i
</source>
affichera
<source lang=python>
0 1 2
</source>
tandis que
<source lang=python>
for i in range(5):
if i==3:
continue
print i
</source>
affichera
<source lang=python>
0 1 2 4
</source>
 
== Exception ==
Comme vous l'aurez certainement déjà compris, l'instruction <tt>else</tt> (« sinon », en anglais) permet de programmer une exécution alternative, dans laquelle le programme doit choisir entre deux possibilités. On peut faire mieux encore en utilisant aussi l'instruction <tt>elif</tt> (contraction de « else if ») :
{{Exemple|Exemple|Exemple de gestion d'exception|
<source lang=python>
try:
# Code pouvant générer une exception
except MonException:
# Code en cas d'exception
else:
# Code en cas de non exception
#code dans tous les cas
</source>
}}
 
----
<pre>
<noinclude>
>>> a = 0
{{lienDePage|Programmation Python|Exercices Base du langage|Type de données complexe}}
>>> if a > 0 :
[[Catégorie:Structures de contrôle|Python]]
... print "a est positif"
</noinclude>
... elif a < 0 :
... print "a est négatif"
... else:
... print "a est nul"
...
</pre>
 
== Opérateurs de comparaison ==
 
La condition évaluée après l'instruction if peut contenir les opérateurs de comparaison suivants :
 
<pre>
x == y # x est égal à y
x != y # x est différent de y
x > y # x est plus grand que y
x < y # x est plus petit que y
x >= y # x est plus grand que, ou égal à y
x <= y # x est plus petit que, ou égal à y
</pre>
 
Exemple :
 
<pre>
>>> a = 7
>>> if (a % 2 == 0):
... print "a est pair"
... print "parce que le reste de sa division par 2 est nul"
... else:
... print "a est impair"
...
</pre>
 
Notez bien que l'opérateur de comparaison pour l'égalité de deux valeurs est constitué de deux signes « égale » et non d'un seul<ref>Rappel : l'opérateur % est l'opérateur modulo : il calcule le reste d'une division entière. Ainsi par exemple, a % 2 fournit le reste de la division de a par 2.</ref>. (Le signe « égale » utilisé seul est un opérateur d'affectation, et non un opérateur de comparaison. Vous retrouverez le même symbolisme en ''[[Programmation C C plus plus Le langage|C++]]'' et en ''[[Programmation Java|Java]]'').
 
== Instructions composées – Blocs d'instructions ==
 
La construction que vous avez utilisée avec l'instruction <tt>if</tt> est votre premier exemple d'instruction composée. Vous en rencontrerez bientôt d'autres. Sous Python, toutes les instructions composées ont toujours la même structure : une ligne d'en-tête terminée par un double point, suivie d'une ou de plusieurs instructions indentées sous cette ligne d'en-tête. Exemple :
 
<pre>
Ligne d'en-tête:
première instruction du bloc
... ...
... ...
dernière instruction du bloc
</pre>
 
S'il y a plusieurs instructions indentées sous la ligne d'en-tête, ''elles doivent l'être exactement au même niveau'' (comptez un décalage de 4 caractères, par exemple). Ces instructions indentées constituent ce que nous appellerons désormais un ''bloc d'instructions''. Un bloc d'instructions est une suite d'instructions formant un ensemble logique, qui n'est exécuté que dans certaines conditions définies dans la ligne d'en-tête. Dans l'exemple du paragraphe précédent, les deux lignes d'instructions indentées sous la ligne contenant l'instruction if constituent un même bloc logique : ces deux lignes ne sont exécutées - toutes les deux - que si la condition testée avec l'instruction <tt>if</tt> se révèle vraie, c'est-à-dire si le reste de la division de a par 2 est nul.
 
== Instructions imbriquées ==
 
Il est parfaitement possible d'imbriquer les unes dans les autres plusieurs instructions composées, de manière à réaliser des structures de décision complexes. Exemple :
 
<pre>
if embranchement == "vertébrés": # 1
if classe == "mammifères": # 2
if ordre == "carnivores": # 3
if famille == "félins": # 4
print "c'est peut-être un chat" # 5
print "c'est en tous cas un mammifère" # 6
elif classe == 'oiseaux': # 7
print "c'est peut-être un canari" # 8
print "la classification des animaux est complexe" # 9
</pre>
 
Analysez cet exemple. Ce fragment de programme n'imprime la phrase « c'est peut-être un chat » que dans le cas où les quatre premières conditions testées sont vraies.
 
Pour que la phrase « c'est en tous cas un mammifère » soit affichée, il faut et il suffit que les deux premières conditions soient vraies. L'instruction d'affichage de cette phrase (ligne 6) se trouve en effet au même niveau d'indentation que l'instruction : <code>if ordre == "carnivores":</code> (ligne 3). Les deux font donc partie d'un même bloc, lequel est entièrement exécuté si les conditions testées aux lignes 1 & 2 sont vraies.
 
Pour que la phrase « c'est peut-être un canari » soit affichée, il faut que la variable embranchement contienne « vertébrés », et que la variable classe contienne « oiseaux ».
 
Quant à la phrase de la ligne 9, elle est affichée dans tous les cas, parce qu'elle fait partie du même bloc d'instructions que la ligne 1.
 
== Quelques règles de syntaxe Python ==
 
Tout ce qui précède nous amène à faire le point sur quelques règles de syntaxe :
 
=== Les limites des instructions et des blocs sont définies par la mise en page ===
 
Dans de nombreux langages de programmation, il faut terminer chaque ligne d'instructions par un caractère spécial (souvent le point-virgule). Sous Python, c'est le caractère de fin de ligne<ref>Ce caractère n'apparaît ni à l'écran, ni sur les listings imprimés. Il est cependant bien présent, à un point tel qu'il fait même problème dans certains cas, parce qu'il n'est pas encodé de la même manière par tous les systèmes d'exploitation. Nous en reparlerons plus loin, à l'occasion de notre étude des fichiers texte {{todo}}.</ref> qui joue ce rôle. (Nous verrons plus loin comment outrepasser cette règle pour étendre une instruction complexe sur plusieurs lignes). On peut également terminer une ligne d'instructions par un commentaire. Un commentaire Python commence toujours par le caractère spécial <tt>#</tt>. Tout ce qui est inclus entre ce caractère et le saut à la ligne suivant est complètement ignoré par le compilateur.
 
Dans la plupart des autres langages, un bloc d'instructions doit être délimité par des symboles spécifiques (parfois même par des instructions, telles que <tt>begin</tt> et <tt>end</tt>). En ''C++'' et en ''Java'', par exemple, un bloc d'instructions doit être délimité par des accolades. Cela permet d'écrire les blocs d'instructions les uns à la suite des autres, sans se préoccuper d'indentation ni de sauts à la ligne, mais cela peut conduire à l'écriture de programmes confus, difficiles à relire pour les pauvres humains que nous sommes. On conseille donc à tous les programmeurs qui utilisent ces langages de se servir ''aussi'' des sauts à la ligne et de l'indentation pour bien délimiter visuellement les blocs.
 
Avec Python, ''vous devez'' utiliser les sauts à la ligne et l'indentation, mais en contrepartie vous n'avez pas à vous préoccuper d'autres symboles délimiteurs de blocs. En définitive, Python vous force donc à écrire du code lisible, et à prendre de bonnes habitudes que vous conserverez lorsque vous utiliserez d'autres langages.
 
=== Les espaces et les commentaires sont normalement ignorés ===
 
A part ceux qui servent à l'indentation, en début de ligne, les espaces placés à l'intérieur des instructions et des expressions sont presque toujours ignorés (sauf s'ils font partie d'une chaîne de caractères). Il en va de même pour les commentaires : ceux-ci commencent toujours par un caractère dièse (#) et s'étendent jusqu'à la fin de la ligne courante.
 
=== Instruction composée = En-tête , double point , bloc d'instructions indenté ===
 
Nous aurons de nombreuses occasions d'approfondir le concept de « bloc d'instructions » et de faire des exercices à ce sujet, dès le chapitre suivant.
 
Le schéma ci-contre en résume le principe.
 
[[Image:Apprendre à programmer avec Python 6.png|right|200px]]
* Les blocs d'instructions sont toujours associés à une ligne d'en-tête contenant une instruction bien spécifique (<tt>if</tt>, <tt>elif</tt>, <tt>else</tt>, <tt>while</tt>, <tt>def</tt>, ...) ''se terminant par un double point''.
 
* ''Les blocs sont délimités par l'indentation'' : toutes les lignes d'un même bloc doivent être indentées exactement de la même manière (c'est-à-dire décalées vers la droite d'un même nombre d'espaces<ref>Vous pouvez aussi indenter à l'aide de tabulations, mais alors vous devrez faire très attention à ne pas utiliser tantôt des espaces, tantôt des tabulations pour indenter les lignes d'un même bloc. En effet, et même si le résultat paraît identique à l'écran, espaces et tabulations sont des codes binaires distincts : Python considérera donc que ces lignes indentées différemment font partie de blocs différents. Il peut en résulter des erreurs difficiles à déboguer.
En conséquence, la plupart des programmeurs préfèrent se passer des tabulations. Si vous utilisez un éditeur "intelligent", vous pouvez escamoter le problème en activant l'option "Remplacer les tabulations par des espaces".</ref>). Le nombre d'espaces à utiliser pour l'indentation est quelconque, mais la plupart des programmeurs utilisent des multiples de 4.
 
* Notez que le code du bloc le plus externe (bloc 1) ne peut pas lui-même être écarté de la marge de gauche (Il n'est imbriqué dans rien).
 
== Notes ==
{{références}}
 
[[Catégorie:Apprendre à programmer avec Python (livre)|Controle du flux]]