Informatique - EMINES – Université Mohamed 6

P ython – Tests & B oucles

Som m aire
Python – Tests & Boucles ....................................................................................................................................... 1
1. Structures conditionnelles .......................................................................................................................... 2
1.1 Définition............................................................................................................................................... 2
1.2 Tests à plusieurs cas .............................................................................................................................. 2
1.3 Tests multiples ....................................................................................................................................... 3
2. Structures répétitives .................................................................................................................................. 3
2.1 Boucles for ............................................................................................................................................ 3
2.2 Boucles while ........................................................................................................................................ 4
3. Exercices .................................................................................................................................................... 5
 Informatique - EMINES – Université Mohamed 6

1. Structures conditionnelle s

1.1 D éfinition
Les tests (Structures conditionnelles) sont un élément essentiel à tout langage informatique si on
veut lui donner un peu de complexité car ils permettent à l’ordinateur de prendre des décisions si telle
ou telle condition est vraie ou fausse. Pour cela, Python utilise l’instruction if ainsi qu’une
comparaison que nous avons abordée au chapitre précédent. Voici un premier exemple :
>>> x = 2
>>> if x == 2:
... print("Le test est vrai !")
...
Le test est vrai !

et un second :
>>> x = "kamal"
>>> if x == "amine":
... print("Le test est vrai !")
...

R em arques :
 Dans le premier exemple, le test étant vrai, l’instruction print("Le test est vrai !") est
exécutée. Dans le second exemple, le test est faux et rien n’est affiché.
 Les blocs d’instruction dans les tests doivent forcément être indentés. L’indentation indique la
portée des instructions à exécuter si le test est vrai.
 L’instruction if se termine par le caractère :

1.2 Tests à plusieurs cas

Parfois, il est pratique de tester si la condition est vraie ou si elle est fausse dans une même
instruction if. Plutôt que d’utiliser deux instructions if, on peut se servir des instructions if et else :
>>> x = 2
>>> if x == 2:
... print("Le test est vrai !")
... else:
... print("Le test est faux !")
...
Le test est vrai !
>>> x = 3
>>> if x == 2:
... print("Le test est vrai !")
... else:
... print("Le test est faux !")
...
Le test est faux !

On peut utiliser une série de tests dans la même instruction if, notamment pour tester plusieurs
valeurs d’une même variable. Par exemple, on se propose de tirer au sort une base d’ADN puis
d’afficher le nom de cette dernière. Dans le code suivant, nous utilisons
l’instruction random .choice(liste) qui renvoie un élément choisi au hasard dans une liste.
>>> import random
>>> base = random.choice(["a", "t", "c", "g"])
>>> if base == "a":
... print("choix d'une adénine")
... elif base == "t":
... print("choix d'une thymine")
... elif base == "c":
... print("choix d'une cytosine")
... elif base == "g":
... print("choix d'une guanine")
...
 Informatique - EMINES – Université Mohamed 6

choix d'une cytosine

Dans cet exemple, Python teste la première condition, puis, si et seulement si elle est fausse, teste la
deuxième et ainsi de suite… Le code correspondant à la première condition vérifiée est exécuté puis
Python sort du if.

1.3 Tests m ultiples

En Python, on utilise le mot réservé and pour l’opérateur ET et le mot réservé or pour
l’opérateur OU . Respectez bien la casse des opérateurs and et or qui, en Python, s’écrivent en
minuscule. En voici un exemple d’utilisation :
>>> x = 2
>>> y = 2
>>> if x == 2 and y == 2:
... print("le test est vrai")
...
le test est vrai

Vous pouvez aussi tester directement l’effet de ces opérateurs à l’aide de True et False (attention à
respecter la casse).
>>> True or False
True

Enfin, on peut utiliser l’opérateur logique de négation not qui inverse le résultat d’une condition :
>>> not True
False
>>> not False
True
>>> not (True and True)
False

2. Structures répétitives

2.1 B oucles for

 Principe
En programmation, on est souvent amené à répéter plusieurs fois une instruction. Incontournables à
tout langage de programmation, les boucles vont nous aider à réaliser cette tâche de manière
compacte. Imaginez par exemple que vous souhaitiez afficher les éléments d’une liste les uns après les
autres. Dans l’état actuel de vos connaissances, il faudrait taper quelque chose du style :
employes = ['ali','amine','safa','kamal']
print(employes[0])
print(employes[1])
print(employes[2])
print(employes[3])

Si votre liste ne contient que quatre éléments, ceci est encore faisable mais imaginez qu’elle en
contienne 100 voire 1000 ! Pour remédier à cela, il faut utiliser les boucles. Regardez l’exemple suivant
:
>>> employes = ['ali','amine','safa','kamal']
>>> for employé in employes:
... print(employé)
...
ali
amine
safa
kamal

Également nous pouvons itérer sur une tranche (sous-liste) :

 Informatique - EMINES – Université Mohamed 6

>>> employes = ['ali','amine','safa','kamal']

>>> for employé in employes[1:3]:
... print(employé)
...
amine
safa

 Fonction range()
Python possède la fonction range() que nous avons rencontrée précédemment dans le chapitre sur
les Listes et qui est aussi bien commode pour faire une boucle sur une liste d’entiers de manière
automatique :
>>> for i in range(4):
... print(i)
...
0
1
2
3

Dans cet exemple nous pouvons faire plusieurs remarques importantes :

Contrairement à la génération de liste avec list(range(4)), la fonction range() peut être utilisée telle
quelle dans une boucle. Il n’est pas nécessaire de taper for i in list(range(4)):, même si cela
fonctionnerait également.

 Itération sur les indices

Revenons à la liste em ployes. Nous allons maintenant parcourir cette liste, mais cette fois par une
itération sur ses indices :
>>> employes = ['ali', 'amine', 'safa', 'kamal']
>>> for i in range(4):
... print(employes[i])
...
ali
amine
safa
kamal

Toutefois, il se peut qu’au cours d’une boucle vous ayez besoin des indices, auquel cas vous n’avez pas
le choix que d’itérer sur les indices. Par exemple :
>>> employes = ['ali','amine','safa','kamal']
>>> for i in range(len(employes)):
... print("L'employé {} est un(e) {}".format(i, employes[i]))
...
L'employé 0 est un(e) ali
L'employé 1 est un(e) amine
L'employé 2 est un(e) safa
L'employé 3 est un(e) kamal

2.2 B oucles w hile

Une autre alternative à l’instruction for couramment utilisée en informatique est la boucle while. Le
principe est simple. Une série d’instructions est exécutée tant qu’une condition est vraie. Par exemple :
>>> i = 1
>>> while i <= 4:
... print(i)
... i = i + 1
...
1
2
3
4
 Informatique - EMINES – Université Mohamed 6

Remarquez qu’il est encore une fois nécessaire d’indenter le bloc d’instructions correspondant au corps
de la boucle (ici 2 instructions).
Une boucle while nécessite généralement trois élém ents pour fonctionner correctement :
 l’initialisation de la variable de test avant la boucle ;
 le test de la variable associé à l’instruction while ;
 la mise à jour de la variable de test dans le corps de la boucle.
Faites bien attention aux tests et à l’incrémentation que vous utilisez car une erreur mène souvent à
des boucles infinies, c’est-à-dire qui ne s’arrêtent jamais. Vous pouvez néanmoins toujours stopper
l’exécution d’un script Python à l’aide de la combinaison de touches Ctrl-C. Par exemple :
i = 0
while i < 10:
print("Le python c'est cool !")

Ici nous avons omis de mettre à jour la variable i, ainsi la boucle ne s’arrêtera jamais (sauf en pressant
Ctrl-C) puisque la condition i < 10 sera toujours vraie.

3. Exercices

Exercice 1 :
1. Donner le résultat obtenu à l’exécution de ce code Python :
>>> a = 0
>>> while (a < 7): # (n'oubliez pas le double point !)
... a = a + 1 # (n'oubliez pas l'indentation !)
... print (a)

2. Lire le code suivant :

a = 0
if a > 0 :
print ("a est positif")
elif a < 0 :
print ("a est négatif")
else:
print ("a est nul")

Modifier le programme afin de lire la valeur de a à partir de clavier.

Exercice 2 : chaînes de caractères

1. Écrire un script qui détermine si une chaîne contient ou non le caractère « o ».
2. Écrire un script qui compte le nombre d’occurrences du caractère « o » dans une chaîne.

Exercice 3 : Tableau de m ultiplication

Ecrivez un programme qui affiche les 30 premiers termes de la table de multiplication par un nombre
lu au clavier.

Exercice 4 : C onversion des secondes

Ecrire un programme qui convertit un nombre entier de secondes fourni au départ en un nombre
d’années, de mois, de jours, de minutes et de secondes (utilisez l’opérateur modulo : %).

Exercice 5 : Triangle isocèle

Ecrire un programme qui affiche un triangle isocèle de n lignes :
>>> Combien de ligne ? 4
*
***
*****
*******