Plan du site  
français  English
pixel
pixel

Articles - Étudiants SUPINFO

Chapitre 02 - Structures conditionnelles et itératives

Structures de contrôle

Nous allons présenter dans cette partie les opérations possibles sur les variables booléennes et voir leurs utilités dans le contrôle de l'ordre dans lequel les instructions d'un algorithme sont exécutées.

Motivation

Il est facile de comprendre qu'un programme n’est pas nécessairement qu’une succession d’instructions exécutées les unes à la suite des autres. On peut avoir besoin de choisir telle ou telle instruction pour s’adapter à telle ou telle situation. Ou encore devoir répéter plusieurs fois le même type d’instructions. Les commandes qui permettront cela sont appelées de façon savante des structures de contrôle.

Par exemple, si l’on veut résoudre une équation du second degré, les calculs ne seront pas les mêmes selon que le discriminant soit positif ou négatif. Ou si l’on souhaite afficher des tables de multiplication, on sera amené à répéter des calculs qui se ressemblent fortement.

Ces choix et répétitions seront régis par ce que l’on appelle une conditionnelle.

Conditionnelle

Une conditionnelle est une expression booléenne dont la valeur va déterminer les actions réalisées dans la suite d'un programme.

En Python, une conditionnelle vaut donc soit True soit False.

C’est le résultat d’une comparaison, ou de plusieurs comparaisons reliées entre elles par des opérateurs logiques.

Opérateurs de comparaison

Voici la liste des opérateurs de comparaison entre deux termes : <, <=, >, >=, ==, !=.

[Note]

L'égalité entre deux termes se teste avec un "double égal" contrairement aux mathématiques. En effet l'opérateur = est réservé en Python aux affectations.

Ces comparaisont doivent s'effectuer entre deux nombres ou entre deux chaînes. La comparaison de deux chaînes se fera selon l’ordre lexicographique établi à l’aide des codes unicodes des caractères.

[Note]

Rappelons que le typage est fort, on ne peut donc comparer par exemple un entier avec un caractère en espérant que ce dernier soit converti en entier en utilisant sa valeur unicode.

Example 1.1. Quelques comparaisons

>>> 2 == 2.0
True
>>> 3.5 < 2
False
>>> "comparer" < "comparaison"
False
>>> '*' < '+'
True

Opérateurs logiques

Un opérateur logique relie entre elles plusieurs expressions booléennes pour en former une nouvelle.

Il y a deux opérateurs binaires or et and, qui correspondent aux OU et ET de la logique mathématique, et un opérateur unaire not, qui lui correspond au NON.

[Note]

Voir le cours de théorie des ensembles 1SET pour des compléments à propos de la logique mathématique.

Ces opérateurs s’appliquent en théorie sur des booléens. L'interpréteur Python permet toutefois de les utiliser avec des valeurs numériques, tout nombre non nul valant True et 0 valant False.

Voici les tables de vérité des deux opérateurs binaires or et and :

a b a or b a and b
False False False False
False True True False
True False True False
True True True True

Et voici celle de l'opérateur unaire not :

a not a
False True
True False

Example 1.2. Quelques opérations logiques

>>> not 3 == 3.0
False
>>> 2 == 3 and 3 == 3
False
>>> 2 == 3 or 3 == 3
True
>>> 3 == 2 and 3 == 3 or 'e' != 'é'
True

[Note]

On a pu constater sur cet exemple que le and était prioritaire sur le or. Dans le cas contraire la dernière ligne vaudrait False. En cas de doutes et pour améliorer la lisibilité du code, il est cependant préférable d’utiliser des parenthèses.

Structures conditionnelles

Dans cette partie, on va étudier comment faire réagir notre programme selon la valeur d'une ou plusieurs conditionnelles.

Test simple

L’idée de base est la volonté de pouvoir réaliser une ou plusieurs actions selon la vérification d’une condition. Cela correspond au SI ... ALORS ... du langage courant. En mathématiques on utilise également le terme d’implication.

Voici la syntaxe générale d'un test simple en Python :

if conditionnelle:
    bloc d’instructions à exécuter si la conditionnelle est vraie

On rencontre ici pour la première fois une des particularités importantes du langage Python, la façon dont sont délimités les blocs d'instructions :

  1. La ligne les précédant se termine par un double point :

  2. L’intégralité du bloc est indenté par rapport aux instructions qui le précèdent et le suivent.

[Note]

Le débutant en programmation verra au fil du temps que dans la plupart des langages la délimitation des blocs se fait de façon beaucoup moins simple. Par son indentation obligatoire, le python force naturellement à l’écriture de codes lisibles.

Cette indentation sera réalisée à l’aide de la touche de tabulation ou de 4 espaces.

Example 1.3. Un test simple

On remplace un nombre par sa valeur absolue :

x = eval(input("Saisir une valeur de x : "))
if x<0:
    x = -x
print(x)
Saisir une valeur de x : -66.6
66.6

Test avec alternative(s)

Cette fois-ci, on souhaite avoir une ou plusieurs alternatives à la conditionnelle si cette dernière n’est pas vérifiée. On va donc simuler des raisonnements de la forme :

SI ... ALORS ...

SINON SI ... ALORS ...

SINON ...

[Note]

On pourra bien sûr avoir plus de deux alternatives.

Voici la syntaxe générale d'un test avec une alternative en Python :

if conditionnelle:
    bloc d’instructions à exécuter si la conditionnelle est vraie
else:
    bloc d’instructions à exécuter si la conditionnelle est fausse
[Note]

Là encore et comme dans toute la suite les blocs sont délimités par des : et une indentation.

Example 1.4. Un test avec une alternative

On détermine si un nombre est pair ou non :

n = eval(input("Saisir un entier : "))
if n%2 == 0:
    print("le nombre saisi est pair")
else:
    print("le nombre saisi est impair")
Saisir un entier : 666
le nombre saisi est pair
Saisir un entier : 667
le nombre saisi est impair

Voici maintenant la syntaxe générale d'un test avec plusieurs alternatives en Python :

if conditionnelle:
    bloc d’instructions à exécuter si la conditionnelle est vraie
elif autre_conditionnelle:
    bloc d’instructions à exécuter si la seconde conditionnelle est vraie
else:
    bloc d’instructions à exécuter si les premières conditionnelles sont fausses
[Note]

Même remarque que précédemment, on pourra avoir plus de deux alternatives.

Example 1.5. Un test avec plusieurs alternatives

On indique le signe (au sens strict) d'un nombre :

x = eval(input("Saisir un nombre : "))
if x < 0:
    print("le nombre saisi est strictement négatif")
elif x > 0:
    print("le nombre saisi est strictement positif")
else:
    print("le nombre saisi est nul")

Imbrication de tests

L’imbrication de structures conditionnelles est non seulement possible mais souvent fort utile. Cela peut éviter le recours à une succession de tests simples et donc rendre les codes plus lisibles.

Example 1.6. Un test imbriqué dans un autre

Résolution d'une équation du premier degré ax + b = 0 :

a,b = eval(input("Saisir a : ")),eval(input("Saisir b : "))
if a == 0:
    if b == 0:
        print("infinité de solutions")
    else:
        print("pas de solution")
else:
    print("unique solution :",-b/a)

Opérateur ternaire

Cet opérateur offre dans certains cas une syntaxe plus compacte que celle d’un test avec une alternative. Néanmoins son usage est beaucoup plus limité puisque les blocs à exécuter selon que la conditionnelle soit vraie ou fausse ne doivent comporter qu’une seule instruction. Plus exactement les deux alternatives doivent être le calcul d’une expression.

La syntaxe générale de cet opérateur est la suivante :

expression_1 if conditionnelle else expression_2

Si la conditionnelle est vraie cette expression vaudra expression_1 sinon elle vaudra expression_2.

Example 1.7. Utilisations de l'opérateur ternaire

On suppose que l'on dispose d'une variable entière "âge".

On réalise ici une affectation selon la valeur de "âge" :

statut = "mineur" if age<18 else "majeur"

Là il s'agit d'un affichage :

print("mineur") if age<18 else print("majeur")

Exercices

On propose ici au lecteur deux petits exercices d'applications immédiates de ces structures conditionnelles afin qu'il puisse tester sa bonne compréhension des bases.

Exercice corrigé : maximum et minimum

1.1.

Ecrire un programme calculant le maximum et le minimum de deux nombres.

Première version : on utilise un test avec une alternative.

x,y = eval(input("Saisir la valeur de x : ")),eval(input("Saisir la valeur de y : "))
if x>y:
    mini,maxi = y,x
else:
    mini,maxi = x,y
print("minimum :",mini,", maximum :",maxi)

Seconde version : on utilise juste un test simple cette fois.

x,y = eval(input("Saisir la valeur de x : ")),eval(input("Saisir la valeur de y : "))
mini, maxi = x, y
if x>y:
    mini, maxi = y, x
print("minimum :",mini,", maximum :",maxi)

Exercice corrigé : test de l'admission au Bac

1.1.

Ecrire un programme qui en fonction de la moyenne aux écrits du Bac indique si le lycéen en question est admis, recalé ou au rattrapage.

On utilise un test avec deux alternatives.

note = eval(input("Saisir la note : "))
if note < 8:
    print("recalé")
elif note < 10:
    print("rattrapage")
else:
    print("admis")

Structures itératives

On va s'intéresser aux différentes structures permettant de répéter plusieurs fois un bloc d'instructions.

Notion d'itération

Dans certaines situations, on est donc amené à exécuter plusieurs fois des actions identiques ou du moins de même nature.

Dans ce contexte, une itération est alors une séquence d’instructions destinée à être exécutée plusieurs fois.

Selon que le nombre de répétitions soit connu à l’écriture du programme ou pas, on utilisera une structure for ou une structure while. Cette distinction est vraiment sémantique, on la respectera donc fidèlement.

[Note]

Comme on va vite le constater, ces structures sont moins intuitives pour le débutant que les structures conditionnelles.

La structure "for"

La structure for réalise un nombre d’itérations fixe et connu.

Elle utilise une variable dont la valeur va parcourir une certaine plage au fil des itérations. C’est cette variable qui contrôlera le nombre d’itérations. Cette plage de valeurs va être construite grâce à la fonction range.

[Note]

Que les puristes du Python se rassurent, on verra d’autres champs d’applications de la structure for dans les prochains chapitres de ce cours.

Voici dans un premier temps la syntaxe générale de la fonction range :

range(debut,fin,pas)

Cette fonction produit donc une plage de valeurs allant de début (inclus) à fin (non inclus) avec un certain pas.

À noter que par défaut début et pas valent respectivement 0 et 1. Cela signifie que si l'on ne renseigne pas nous mêmes leurs valeurs, c'est 0 et 1 qui leurs seront affectés.

Si l’on ne passe que deux paramètres à cette fonction, ils sont nécessairement affectés à début et fin. Le pas sera alors obligatoirement de 1.

[Note]

On laisse pas mal de poussières sous le tapis... On reviendra plus précisément plus tard sur le fonctionnement de cette fonction et sur ce qu’elle produit réellement. Pour l'instant, ce qui vient d'être dit suffit largement à nos besoins actuels.

Example 1.8. Quelques utilisations de la fonction range

  • range(6) produira la plage de valeurs 0, 1, 2, 3, 4, 5

  • range(3,6) produira la plage de valeurs 3, 4, 5

  • range(3,10,2) produira la plage de valeurs 3, 5, 7, 9

  • range(6,0,-1) produira la plage de valeurs 6, 5, 4, 3, 2, 1


On est maintenant en mesure de présenter la syntaxe de la structure for :

for var in range(debut,fin,pas):
    bloc d’instructions à répéter pendant que var prend
    les valeurs de la plage définie par range
[Note]

On retrouve la délimitation du bloc par un : et par de l’indentation. Maintenant cela doit être de l’ordre du réflexe. Nous n'insisterons plus sur ce point dans la suite du cours d'ailleurs.

Voici quelques explications complémentaires sur le fonctionnement de cette structure for :

  • Au fil des itérations, la variable var prendra successivement toutes les valeurs de la plage créée par la fonction range.

  • Le nombre d’itérations sera donc le nombre d’éléments de la plage créée par la fonction range.

  • En pratique, comme nous le verrons sur des exemples, on se servira également très souvent des valeurs de la variable var.

Example 1.9. Une première utilisation de la structure for

On affiche la table de multiplication d'un entier saisi par l'utilisateur :

n = eval(input("Saisir un entier : "))
for i in range(1,11):
    print(i,'*',n,'=',n*i)
Saisir un entier : 9
1 * 9 = 9
2 * 9 = 18
3 * 9 = 27
4 * 9 = 36
5 * 9 = 45
6 * 9 = 54
7 * 9 = 63
8 * 9 = 72
9 * 9 = 81
10 * 9 = 90

Voici comment s'est déroulé le programme :

  • L'utilisateur a saisi la valeur 9 pour la variable n.

  • La plage de valeur créée par la fonction range est 1, 2, 3, 4, 5, 6, 7, 8, 9, 10.

  • À la première itération la variable i vaut 1, il est donc affiché 1 * 9 = 9.

  • À la seconde itération la variable i vaut 2, il est donc affiché 2 * 9 = 18.

  • etc.


Example 1.10. Une seconde utilisation de la structure for

On affiche les nombres pairs compris entre 20 et 0 sur une seule ligne :

for i in range(20,-1,-2):
    print(i, end=" ")
20 18 16 14 12 10 8 6 4 2 0 

La structure "while"

La structure while réalise un nombre d’itérations non nécessairement connu à l’écriture du programme.

Ce nombre dépend d’une conditionnelle qui sera évaluée avant chaque itération. C'est pour cela qu'on la qualifie aussi d'itération conditionnelle.

Voici la syntaxe de la structure while :

while conditionnelle:
    bloc d’instructions à répéter tant que la conditionnelle est vraie

On exécute donc le bloc d’instructions tant que la conditionnelle est vraie.

Example 1.11. Une utilisation de la structure while

On effectue le calcul de la partie entière d’un réel positif, qui est rappelons le le plus grand entier inférieur ou égal à ce réel :

x = eval(input("Saisir un réel positif : "))
n = 0
while n+1<=x:
    n+=1
print("la partie entière de",x,"est",n)
Saisir un réel positif : 2.57
la partie entière de 2.57 est 2

Voici comment s'est déroulé le programme :

  • L'utilisateur a saisi la valeur 2.57 pour la variable x.

  • Avant les itérations, la variable n est initialisée à 0.

  • La conditionnelle est alors vraie donc on réalise la première itération, et n vaut maintenant 1.

  • La conditionnelle est encore vraie donc on réalise la seconde itération, et n vaut maintenant 2.

  • Cette fois-ci la conditionnelle est fausse et l’on stoppe les itérations.

  • On peut alors afficher la valeur de la partie réelle, c'est-à-dire n.


[Warning]

Dans le bloc d'instructions à répéter, il est nécessaire de modifier la valeur de la conditionnelle pour ne pas risquer d’avoir une infinité d’itérations. En effet, si l'on ne la modifie pas et qu'elle est vraie alors elle le restera...

Example 1.12. Une boucle infinie

La conditionnelle i<3 est ici toujours vraie car i vaut initialement 0 et l'on ne modifie pas sa valeur ensuite :

i = 2
while i<3:
    print("coucou")

On rentre ainsi dans la boucle pour ne jamais en sortir. Pas la peine de dire au lecteur qu'il s'agit donc d'un exemple à ne pas suivre...


[Note]

Dans beaucoup d'autres langages on disposera d'une autre structure itérative conditionnelle, où cette fois la conditionnelle est évaluée après chaque itération. Voir cours 1GCC par exemple.

Imbrication de structures itératives

L’imbrication de structures itératives est non seulement possible mais souvent fort utile comme nous allons le voir sur un exemple.

À noter que l’on peut également imbriquer structures itératives et structures conditionnelles.

Example 1.13. Deux structures for imbriquées l'une dans l'autre

On affiche cette fois les tables de multiplications de tous les entiers entre 1 et 10 :

for i in range(1,11):
    print("table de",i)
    for j in range(1,11):
        print("\t",j,"*",i,"=",j*i)
table de 1
	 1 * 1 = 1
	 2 * 1 = 2
	 3 * 1 = 3
	 4 * 1 = 4
	 5 * 1 = 5
	 6 * 1 = 6
	 7 * 1 = 7
	 8 * 1 = 8
	 9 * 1 = 9
	 10 * 1 = 10
table de 2
	 1 * 2 = 2
	 2 * 2 = 4
	 3 * 2 = 6
	 4 * 2 = 8
...

L'affichage console précédent a bien sûr été tronqué.

Voici comment s'est déroulé le programme :

  • A la première itération de la boucle la plus externe la variable i vaut 1. La variable j prend alors toutes les valeurs de 1 à 10.

  • A la seconde itération de la boucle la plus externe la variable i vaut 2. La variable j prend de nouveau toutes les valeurs de 1 à 10.

  • etc.


Sorties de boucles

Dans certains cas marginaux on peut avoir besoin d'interrompre le déroulement d'une structure itérative avant sa fin normalement prévue. On dispose pour faire cela de deux instructions :

  • break : cette commande permet la sortie définitive de la structure itérative for ou while qui la contient.

  • continue : cette commande permet de passer directement à l’itération suivante dans la structure for ou while qui la contient.

[Note]

Dans le cas de structures itératives imbriquées, ces instructions ne concernent que la boucle la plus interne les contenant.

Example 1.14. Une utilisation de break

On félicite l’utilisateur s’il saisit un ‘x’ en au plus 10 tentatives et on arrête alors ses saisies :

for i in range(9):
    if input("Saisir quelque chose : ")=='x':
        print("quel talent")
        break
Saisir quelque chose : 666
Saisir quelque chose : Mick
Saisir quelque chose : x
quel talent

Example 1.15. Une utilisation de continue

On affiche tous les nombres de 10 à 20 sauf le nombre 13, le tout sur une seule ligne :

for i in range(10,21):
    if i == 13:
        continue
    print(i,end=" ")
10 11 12 14 15 16 17 18 19 20

[Note]

Ces commandes sont à utiliser avec modération, rares sont les cas où elles sont réellement nécessaires. Leur usage traduit souvent un mauvais choix de structure, for à la place du while en général, ou alors une mauvaise rédaction de la conditionnelle d’un while.

On les a essentiellement mentionnées par soucis de complétude.

Ajout d'une clause "else" dans une boucle

Les structures for et while peuvent contenir une clause else qui sera exécutée à la fin des itérations, à la condition que la sortie de la boucle se soit effectuée de façon normale, c’est-à-dire sans break.

[Note]

Cette clause est bien sûr optionnelle. On peut même la qualifier de rare. Mais bon, comme nous l’avons déjà dit, soyons complet.

Voici la syntaxe de cette clause else dans une structure for :

for var in range(debut,fin,pas):
    bloc d’instructions à répéter pendant que var prend
    les valeurs de la plage définie par range
else:
    bloc d’instructions à exécuter (une fois) quand var a pris
    toutes les valeurs de la plage définie par range
[Note]

La clause else sera directement exécutée si la plage de valeurs définie par la fonction range est vide.

Présentons maintenant la syntaxe de cette clause else dans une structure while :

while conditionnelle:
    bloc d’instructions à répéter tant que la conditionnelle est vraie
else:
    bloc d’instruction à exécuter (une fois) si la conditionnelle est fausse
[Note]

Ce type de clause est propre au Python, on ne la retrouvera pas dans la plupart des langages.

Example 1.16. Une clause else dans une boucle for

On veut savoir si un nombre n saisi par l’utilisateur est un nombre premier ou non :

n = eval(input("Saisir un entier : "))
for i in range(2,n):
    if n%i == 0:
        premier = False
        break
else:
    premier = True

Rappelons qu’un nombre premier est un nombre qui possède exactement deux diviseurs, 1 et lui même. L’importance de ces nombres est capitale, comme on le constatera dans le cours d’arithmétique et cryptographie 1ARI.


Exercices

On propose ici au lecteur deux petits exercices d'applications immédiates de ces structures itératives afin qu'il puisse tester sa bonne compréhension des bases.

Exercice corrigé : somme des n premiers entiers

1.1.

Ecrire un programme calculant la somme des premiers entiers naturels jusqu’à un entier positif saisi par l’utilisateur.

On utilise une structure for car on connaît le nombre d'itérations, il s'agit de l'entier saisi par l'utilisateur.

n = -1
while n < 0:
    n = eval(input("Saisir un entier positif : "))
somme = 0
for i in range(n+1):
    somme += i
print("la somme des",n,"premiers entiers vaut",somme)

La première boucle n’est là que pour s’assurer que le nombre saisi est positif. Retenez cette petite astuce. L’initialisation de n à -1 permet juste d’y rentrer.

[Note]

Cette technique de calcul de somme est ultra-classique et surtout totalement élémentaire. À partir de maintenant elle doit être naturelle.

En résumé, on initialise une variable à 0 et à chaque itération on ajoute le terme voulu.

Exercice corrigé

1.1.

Ecrire un programme calculant la somme d’une suite d’entiers saisie par l’utilisateur se terminant par 0 (exemple 5, 4, 9, 0 renverra 18).

On utilise une structure while car on ne connaît pas a priori le nombre d'itérations, il dépend en effet des saisies de l'utilisateur.

somme,n = 0,1
while n != 0:
    n = eval(input("Saisir un entier : "))
    somme += n
print("la somme des entiers saisis vaut",somme)

L'initialisation de n à 1 permet juste de rentrer dans la boucle.

A propos de SUPINFO | Contacts & adresses | Enseigner à SUPINFO | Presse | Conditions d'utilisation & Copyright | Respect de la vie privée | Investir
Logo de la société Cisco, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société IBM, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Sun-Oracle, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Apple, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Sybase, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Novell, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Intel, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Accenture, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société SAP, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo de la société Prometric, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management Logo du IT Academy Program par Microsoft, partenaire pédagogique de SUPINFO, la Grande École de l'informatique, du numérique et du management

SUPINFO International University
Ecole d'Informatique - IT School
École Supérieure d'Informatique de Paris, leader en France
La Grande Ecole de l'informatique, du numérique et du management
Fondée en 1965, reconnue par l'État. Titre Bac+5 certifié au niveau I.
SUPINFO International University is globally operated by EDUCINVEST Belgium - Avenue Louise, 534 - 1050 Brussels