Programmation Python/Structures de contrôle

Un livre de Wikilivres.
Aller à : navigation, rechercher


Définition[modifier | modifier le wikicode]

Début d’un principe
Fin du principe


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 :

  1. la séquence (ex : chaînes de caractères, tuples et listes) ;
  2. la sélection ;
  3. la répétition.

Séquence d'instructions[modifier | modifier le wikicode]

 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.

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.

Python exécute normalement les instructions de la première à la dernière, sauf lorsqu'il rencontre une instruction conditionnelle comme l'instruction "if". Une telle instruction va permettre au programme de suivre différents chemins suivant les circonstances.

Sélection ou exécution conditionnelle[modifier | modifier le wikicode]

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.

La plus simple de ces instructions conditionnelles est l'instruction "if", qui permet de tester une condition et de n'exécuter les instructions que si cette condition est vérifiée. Exemple :

a = 11
if a > 10 :
    print("a est plus grand que dix")

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 :

if a > 10 :
    print("a est plus grand que dix")
else:
    print("a n'est pas plus grand que dix")

On utilise aussi parfois "elif" (contraction de "else if") :

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")


 en exécutant un "if" dans l'IDLE, on constate que le prompt principal (>>>) est maintenant remplacé par un prompt secondaire constitué de trois points (du moins sur Linux).
>>> if (a > 10):
...     

L'expression entre parenthèses est ce que nous appellerons désormais une condition. L'instruction "if" permet de tester la validité de cette condition, une expression contenant un opérateur de comparaison. 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.

Comme vous l'aurez certainement déjà compris, l'instruction "else" (« sinon », en anglais) permet de programmer une exécution alternative, dans laquelle le programme doit choisir entre deux possibilités. Mais on peut enchainer autant de conditions que nécessaires en utilisant avant l'instruction "elif" (contraction de « else if »).

Exemple :

>>> 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")
...

Dans cet exemple, 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 "if" se révèle vraie, c'est-à-dire si le reste de la division de "a" par "2" est nul.

Instructions imbriquées[modifier | modifier le wikicode]

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 :

1 if embranchement == "vertébrés":
2     if classe == "mammifères":
3         if ordre == "carnivores":
4             if famille == "félins":
5                 print "c'est peut-être un chat"
6         print "c'est en tous cas un mammifère"
7     elif classe == 'oiseaux':
8         print "c'est peut-être un canari"
9 print "la classification des animaux est complexe"

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 : if ordre == "carnivores": (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.

pass[modifier | modifier le wikicode]

De manière générale, un bloc contient tout le code avec une même indentation.

ceci est le bloc principal
if condition:
    bloc 2
    if condition2:
        bloc 3
    fin du bloc 2
fin du bloc 1

Si à un endroit on a syntaxiquement besoin d'un bloc mais qu'il n'y a rien à faire, on peut utiliser l'instruction pass, qui justement ne fait rien.

if condition:
    pass
else:
    instruction