Les structures de contrôle en Python

1 – Introduction

Les instructions ne s’exécutent pas toujours séquentiellement. En effet, il arrive qu’on veuille choisir entre deux ou plusieurs traitements à exécuter selon la situation au moment de l’exécution, les autres traitements seront alors ignorés. 

Il arrive également qu’un traitement doive se faire plusieurs fois mais on ne veut pas dupliquer cette partie du code car cela rendrait le programme très volumineux.

Dans cet article on va détailler les différentes structures de contrôle du flux d’exécution d’un programme.

2 – Les structures de contrôle

Il existe principalement deux types de structures de contrôle dans un programme : la structure alternative et les boucles (traitement répétitif).

2.1 – Structure alternative : « if » … « elif » … « else »

La structure alternative permet de faire en sorte qu’un traitement ne s’exécute que si une condition est vérifiée. Autrement dit, après évaluation de la condition, si cette dernière a pour valeur « True », le traitement sera exécuté, dans le cas contraire, le traitement est ignoré et on passe à la suite.

La syntaxe d’une structure alternative est :

if <condition 1> :
<traitement 1>
[
elif <condition 2> :
<traitement 2>
elif <condition 3> :
<traitement 3>
...
elif <condition n> :
<traitement n>
]
[
else :
<traitement else>
]

Voici quelques remarques concernant le code précédent :

  • La ligne qui précède un bloc de traitement se termine par deux points « : ».
  • Toutes les instructions d’un bloc de traitement sont décalées par rapport à la ligne qui introduit le bloc : l’indentation en python est très importante car c’est elle qui détermine le début et la fin d’un bloc.
  • Ce qui est entre crochets « [] » est facultatif. En effet, un « if » ne possède pas forcément des « elif » et un « else ».
  • Pour ce qui est des blocs « elif », on peut en mettre autant qu’on veut :  Il n’y a pas de limite.
  • Il n’y a qu’un seul bloc « else » au plus, et s’il est présent, il est mis à la fin.
  • Il n’y a qu’un seul traitement <traitement i> au plus qui sera exécuté, et cela dépend des conditions <condition i>. En effet, la première condition <condition i> à être évaluée (en commençant su haut vers le bas) à « True », le bloc correspondant <traitement i> sera exécuté.
  • S’il n’y a aucune condition qui est vraie, le bloc du « else » (s’il existe) sera exécuté.

Voici un exemple plus concret :

n = input("Entrer un nombre : ")
if n % 2 == 0:
print("pair")
else:
print("impair")

Le code précédent demande à l’utilisateur de saisir un nombre puis vérifie sa parité. S’il y est pair, il affiche « pair », sinon il affiche « impair ».

2.2 – Boucle « for »

Une boucle permet de définir un traitement itératif, c-à-d que c’est un bloc qui s’exécute 0 (zéro) ou plusieurs fois. On utilise le mot clé « for » pour définir une boucle dont le nombre d’itérations est connu à l’avance.

En python, pour écrire une boucle « for », on a besoin d’une variable itérable (C’est-à-dire une variable contenant plusieurs éléments et qu’on peut itérer). L’indice de la boucle va prendre les différentes valeurs des éléments contenus dans l’itérable au fil des itérations.

La syntaxe d’une boucle « for » est la suivante :

for x in <iterable>:
<traitement for>

Le bloc <traitement for> sera exécuté autant de fois que d’éléments dans <itérable>. À chaque itération, la variable « x » prend la valeur d’un élément de <itérable>.

Voici un exemple plus concret d’une boucle « for » :

for i in range(10):
print(i)

C’est une boucle « for » qui fait 10 itérations. la variable « i » prend les valeurs de 0 à 9.

2.3 – Boucle « while »

Le deuxième type de boucles c’est la boucle « while ». Comme la boucle « for », la boucle « while » permet de définir un traitement répétitif qui s’exécute 0 à plusieurs fois. Par contre, le nombre d’itération n’est pas connu à l’avance mais plutôt dépend d’une condition. En effet, la boucle  « while » définie une condition qui sera évaluer avant chaque début d’itération : Si la condition est vraie, le bloc s’exécute une fois de plus, sinon, la boucle se termine et l’exécution du programme continue à partir de l’instruction qui suit la boucle.

Quand il s’agit de la boucle « while », on parle souvent de condition d’arrêt. Cette dernière représente la condition pour que le programme sort de la boucle et continue en séquence. La condition d’arrêt est tout simplement la négation de la condition de boucle.

Voici la syntaxe d’une boucle « while » :

while <condition>:
<traitement while>

Voici un code python qui affiche les nombre de 0 à 9 avec une boucle « while » :

a = 0
while
a < 10:
    print(a)

3 – Conclusion

Dans cet article, nous avons vu les trois manières possibles de rompre la séquence en Python. on utilise la structure alternative « if … elif … else » pour effectuer un traitement particulier selon la valeur d’une ou plusieurs conditions.

On utilise les boucles « for » et « while » pour les traitements répétitifs (des traitements qui s’exécutent 0 ou plusieurs fois). Si on connait à l’avance le nombre d’itérations c’est la boucle « for » qui faut utiliser, dans le cas contraire, la boucle « while » est à utiliser.