Tutoriel Python : les instructions imbriquées
Table des matières
1.1 Les structures conditionnelles
- Les structures conditionnelles imbriquées
- Les boucles imbriquées
- Conditions & boucles imbriquées
- Exercices
Introduction
Bonjour et bienvenue dans un nouveau tutoriel Python ! Aujourd’hui, Nous allons nous intéresser à une nouvelle notion, il s’agit des instructions imbriquées en Python.
En effet, dans la programmation, certaines instructions sont peuvent être imbriquées. Cela veut dire qu’elles peuvent contenir d’autres instructions à l’intérieur, c’est le cas des instructions conditionnelles et des boucles ! Nous n’en dirons pas plus, on ne vous gâche pas la surprise !
Ceci dit, notre tutoriel va définir les structures imbriquées, leur importance, syntaxe et utilisation en Python. Nous accompagnerons tout cela avec des exemples et des exercices afin de vous initier à coder en Python !
Ce tutoriel nécessite une connaissance des structures conditionnelles et boucles en Python, mais ne vous inquiétez pas ! Nous allons mettre à votre disposition quelques rappels pour vous rafraichir la mémoire !
Nous pensons que tout est dit ! On attaque le tutoriel alors J
1. Rappel des structures conditionnelles et boucles :
1.1 Les structures conditionnelles :
Voici un tableau qui résume les différentes structures conditionnelles et leur syntaxe.
|
Structure |
Syntaxe |
|
If |
If condition : Instruction |
|
If….else |
If condition : Instruction1 Else : Instruction2 |
|
If…elif….else |
If condition1 : Intsrcution1 Elif condition2 : Instruction2 Else: Instruction3 |
1.2 Les boucles :
Petit rappel indispensable sur la syntaxe des boucles :
|
Structure |
Syntaxe |
|
Boucle for |
For condition : Instruction |
|
Boucle while |
While condition : Instruction |
2. Les instructions imbriquées :
2.1 Définition :
Les instructions imbriquées permettent d’écrire des instructions à l’intérieur d’instructions de base d’une structure.
Vous avez le droit de créer autant de structures imbriquées que vous voulez, mais il est indispensable de faire attention à l’indentation afin de déterminer l’ordre de priorité des conditions. Par exemple, voici la structure conditionnelle de base du elif :
If condition1 :
Instruction 1
Elif condition 2 :
Instruction 2
Else :
Instruction 3
Le principe des instructions imbriquées est que les instructions à l’intérieur de cette structure basique deviennent eux-mêmes des structures conditionnelles ou boucles :
If condition1 :
Sous-structure conditionnelle ou boucle
Elif condition 2 :
Sous-structure conditionnelle ou boucle
Else :
Sous-structure conditionnelle ou boucle
3. Les structures conditionnelles imbriquées :
Dans cette section, nous allons découvrir les différentes structures conditionnelles imbriquées possibles. En effet, on peut avoir autant d’instructions imbriquées que l’on souhaite !
- If à l’intérieur d’un if :
Syntaxe générale :
If condition 1 :
If condition 2 :
Instruction
Exemple :
On veut tester les deux conditions suivantes :
Si un nombre est strictement positif alors tester s’il est pair, afficher (‘le nombre est positif et pair ‘) si les deux conditions sont vérifiées.
Syntaxe :
a=2
if a> 0 :
if a%2==0:
print ("le nombre est positif et pair")
Résultat de l’exécution :
Exemple :
On veut tester les trois conditions suivantes :
Si un nombre est inférieur à 10 alors :
o tester s’il est strictement positif, si oui alors tester s’il est impair. Si toutes les conditions sont vérifiées afficher (« le nombre est positif, inférieur à 10 et impair »)
Syntaxe :
a= 7
if a<10 :
if a>0 :
if a%2!=0 :
print ("le nombre est positif, inférieur à 10 et impair")
Résultat de l’exécution :
- If else à l’intérieur d’un if else :
Syntaxe générale:
Voici la syntaxe générale de deux structures if else imbriquées:
If condition 1 alors :
Instruction1
else:
If condition 2 alors:
Instruction2
else :
Instruction3
Lors de l’exécution, l’ordre suivi par l’interpréteur est le suivant :
- Si la première condition est vérifiée alors le bloc Instruction1 est exécuté
- Sinon , autre manière de dire que la première condition n’est pas vérifiée :
2.1. soit la deuxième condition est vérifiée et le bloc instruction2 est exécuté
2.2. soit la deuxième condition n’est pas vérifiée, alors le bloc instruction 3 est réalisé.
À présent, nous allons passer à des exemples pour mieux comprendre cette structure imbriquée :
Exemple : Les états de l’eau
On veut écrire un programme qui teste la température d’eau et détermine son état (glace, liquide, vapeur) de tel manière que la structure suivante soit respectée :
Si température_eau =0 alors :
Afficher («c’est de la glace »)
Sinon :
Si température_eau>0 et <100
Afficher (« c’est du liquide »)
Sinon :
Afficher (« c’est de la vapeur »
Fin Si
Fin Si
Cas 1 : C’est du liquide
Syntaxe :
temperature_eau = 89
if temperature_eau==0:
print ("C'est de la glace !")
else:
if temperature_eau>0 and temperature_eau<100:
print ("C'est du liquide")
else:
print ("C'est de la vapeur !")
Résultat de l’exécution :
Comme l’exécution le montre, le programme a exécuté l’instruction du premier else, il s’est donc retrouvé dans une nouvelle structure if else où la condition du if est réalisée.
Cas 2 : C’est de la glace !
Syntaxe :
temperature_eau = 0
if temperature_eau==0:
print ("C'est de la glace !")
else:
if temperature_eau>0 and temperature_eau<100:
print ("C'est du liquide")
else:
print ("C'est de la vapeur !")
Résultat de l’exécution :
Cas 3 : c’est de la vapeur
Syntaxe :
temperature_eau = 100
if temperature_eau==0:
print ("C'est de la glace !")
else:
if temperature_eau>0 and temperature_eau<100:
print ("C'est du liquide")
else:
print ("C'est de la vapeur !")
Résultat de l’exécution :
Supposons que nous avons deux variables X=true et Y=false , nous voulons écrire un programme qui effectue les tâches suivantes :
Si X est vraie, il teste Y :
- Si Y est fausse :
- il affiche (‘la condition de Y est vérifiée ’)
- sinon :
- il affiche (‘la condition de Y n’est pas vérifiée).
Si X est fausse :
- il affiche (‘la condition de X n’est pas vérifiée).
Pseudocode du programme :
X=Vrai, Y=Faux
Si X est vrai alors :
Si Y est faux alors :
Afficher (‘la condition de Y est vérifiée’)
Sinon :
Afficher (‘la condition de Y n’est pas vérifiée’)
Sinon :
Afficher (‘X n’est pas vérifiée’)
Syntaxe :
X,Y=True, False
if X :
if not Y:
print ("les conditions de X et Y sont vérifiées"
else:
print ("la condition de Y n'est pas vérifiée")
else :
print ("la condition de X n'est pas vérifiée")
Le not Y est vrai puisque Y est faux et nous on teste toujours la véracité d’une condition. Donc si on a une valeur vraie et on veut la tester il suffit de taper if valeur par contre si on a une valeur fausse et on veut la tester il suffit de tester son NON qui doit être vraie en écrivant if not valeur.
Résultat de l’exécution :
Cas 2 : Y=Vrai et X=Vrai
Syntaxe :
X,Y=True, True
if X :
if not Y:
print ("les conditions de X et Y sont vérifiées"
else:
print ("la condition de Y n'est pas vérifiée")
else :
print ("la condition de X n'est pas vérifiée")
Résultat de l’exécution:
Cas 3 : X=False et Y=True
Syntaxe :
X,Y=False, True
if X :
if not Y:
print ("les conditions de X et Y sont vérifiées"
else:
print ("la condition de Y n'est pas vérifiée")
else :
print ("la condition de X n'est pas vérifiée")
Résultat de l’exécution :
4. Les boucles imbriquées :
Semblables aux précédentes structures, Les boucles peuvent aussi être imbriquées autant de fois que l’on veut.
- boucle for à l’intérieur d’une boucle for :
Syntaxe générale :
for condition1 :
for condition2 :
instruction
Exemple :
Dans cet exemple, nous allons créer deux boucles imbriquées. Voici comment le programme doit fonctionner :
La première boucle contient 4 itérations, la deuxième boucle à l’intérieur de la première contient elle aussi 4 itérations.
À la première itération de la première boucle, tant que la condition est vérifiée, le programme exécute l’instruction de cette boucle qui est une deuxième boucle !
Donc le programme ne pourra pas sortir de la deuxième boucle jusqu’à que la condition ne soit plus vérifiée ! Alors à chaque itération de la première boucle on aura la structure suivante :
Syntaxe :
for i in range(4):
for j in range(4):
print ("boucle 1 itération n :", i, "boucle 2 itération:", j)
Résultat de l’exécution :
Exemple :
Dans cet exemple, nous voulons écrire un programme qui retourne la somme de chacune des listes d’une liste.
Syntaxe :
liste= [ [1,3,4,2] , [1,4,6,2] ,[2,7,9,1] , [1,2,0,0] ]
for e in liste :
sum=0
for i in e:
sum=sum+i
print ( "la somme de" ,e, " est égal à:", sum)
Résultat de l’exécution :
- boucle while à l’intérieur d’une boucle while :
Exemple :
Dans cet exemple, on veut afficher les différentes itérations des deux while.
Syntaxe :
a=10
b=3
while a>0:
while b>0:
print(b,a)
b=b-1
a=a-1
Résultat de l’exécution :
Il est normal que l’exécution ne donne que le résultat de trois itérations car le print() se trouve dans le deuxième while qui est itéré 3 fois seulement.
Exemple :
On veut afficher tous les éléments de deux listes :
a=[1,2,4,9,10]
b=[1,3,10,11]
i=0
j=0
while i<len(a):
while j<len(b):
print ("l'élément n ",j," de b est:",b[j])
j=j+1
print ("------------------------------------")
print ("l'element n ", i," de a est:" ,a[i])
print ("------------------------------------")
i=i+1
Résultat de l’exécution :
5. Conditions et boucles imbriquées :
Dans cette dernière section du tutoriel, nous allons voir des structures imbriquées qui unissent les structures conditionnelles et les boucles :
- If imbriqué dans le while :
Syntaxe générale :
While condition :
If condition :
Instruction1
Else:
Instruction 2
Tant que le while est vérifié on exécute le if à l’intérieur.
Exemple :
Dans cet exemple, on veut écrire un programme qui retourne pour tous les nombres de 15 à 0 s’ils sont pairs ou impairs.
- la boucle while s’arrête quand le a devient négatif car à chaque itération le a décroit de un sinon la boucle ne s’arrêta jamais !
Syntaxe :
a=15
while a>0 :
if a%2==0:
print (a,"est pair ")
else:
print (a,"est impair ! ")
a=a-1
Résultat de l’exécution :
- If imbriqué dans un for :
Syntaxe générale :
for condition1:
if condition2 :
Instruction2
else :
Instruction3
Exemple :
Dans cet exemple on veut déterminer si les nombres d’une boucle allant de 1 à 10 sont pairs ou impairs.
Syntaxe :
for i in range(10):
if i%2==0:
print ("le nombre", i, "est pair ! ")
else :
print ("le nombre",i,"est impair ! ")
Résultat de l’exécution :
6. Exercices :
Exercice 1 :
Écrire un programme qui permet de tester si un profil est valable pour une candidature ou non selon trois critères : l’âge, le salaire demandé et le nombre d’année d’expérience. De sorte que les conditions suivantes soient vérifiées :
Si age>28 alors :
Si salaire_demandé<10000 :
Si nb_annee_experience>3 :
Afficher (« votre candidature sera prise en compte !»
Sinon :
Afficher (« le nombre d’année d’expérience est insuffisant pour ce poste ! »)
Sinon :
Afficher (« le salaire demandé est trop élevé pour ce poste »
Sinon :
Afficher (« votre age n’est pas valable pour ce poste »)
Pour les variables salaire_demandé, age et nb_annee_experience, choisissez des valeurs qui permettent de tester les 4 cas possibles comme ce que nous faisons dans les exemples. À vous de jouer !
Exercice 2 :
Dans ce deuxième exercice, on veut compter le nombre total d’heures de travail de trois ouvriers. Nous allons vous fournir le pseudocode du programmer et à vous de le programmer en Python ! Attention vous n’avez pas droit à l’erreur il suffit juste de traduire en Python J
Ouvrier1= [10,8,8,6,4,8,2]
Ouvrier2= [2,8,6,6,8,4,8]
Ouvrier3= [4,6,2,2,10,10,10]
Liste_heures= [ouvrier1, ouvrier2, ouvrier3]
Pour e dans liste_heures_ouvriers :
Somme=0
Pour i dans e :
Somme->Somme+i
Afficher (la somme des heures de travail de l’ouvrier est : Somme)
Correction des exercices:
Exercice 1 :
Cas 1 : candidature approuvée
Syntaxe :
age=29
salaire_demande=7500
nb_annee_exp=5
if age>28:
if salaire_demande<10000:
if nb_annee_exp>3:
print ("votre candidature sera prise en compte")
else:
print ("le nombre d'année d'expérience est insuffisant pour ce poste !")
else:
("le salaire demandé est élevé pour ce poste")
else:
print ("votre age n'est pas valable pour ce poste")
Résultat de l’éxecution :
Cas 2 : nombre d’année d’expérience insuffisant !
Syntaxe :
age=29
salaire_demande=7500
nb_annee_exp=2
if age>28:
if salaire_demande<10000:
if nb_annee_exp>3:
print ("votre candidature sera prise en compte")
else:
print ("le nombre d'année d'expérience est insuffisant pour ce poste !")
else:
print ("le salaire demandé est élevé pour ce poste")
else:
print ("votre age n'est pas valable pour ce poste")
Résultat de l’exécution :
Cas 3 : salaire demandé trop élevé !
Syntaxe :
age=30
salaire_demande=15000
nb_annee_exp=2
if age>28:
if salaire_demande<10000:
if nb_annee_exp >3:
print ("votre candidature sera prise en compte")
else:
print (" le nombre d'année d'expérience est insuffisant pour ce poste ! ")
else:
print ("le salaire demandé est élevé pour ce poste")
else :
print ("votre age n'est pas valable pour ce poste")
Résultat de l’exécution :
Cas 4 : âge insuffisant
Syntaxe :
age=22
salaire_demande=15000
nb_annee_exp=2
if age>28:
if salaire_demande <10000 :
if nb_annee_exp >3:
print (" votre candidature sera prise en compte ")
else:
print (" le nombre d'année d'expérience est insuffisant pour ce poste ! ")
else:
print ("le salaire demandé est incompatible avec ce poste")
else:
print (" votre age n'est pas valable pour ce poste ")
Résultat de l’exécution :
Exercice 2 :
Syntaxe :
ouvrier1 = [10,8,8,6,4,8,2]
ouvrier2 = [2,8,6,6,8,4,8]
ouvrier3 = [4,6,2,2,10,10,10]
liste_heures_ouvriers = [ouvrier1,ouvrier2,ouvrier3]
for e in liste_heures_ouvriers:
sum=0
for i in e:
sum=sum+i
print ("la somme des heures de travail de l'ouvrier est «, "est égal à:", sum)
Résultat de l’exécution :
Conclusion
Nous voici arrivés à la fin de ce tutoriel ! Un long voyage n’est-ce pas ? En tout cas nous pouvons vous assurer que vous êtes sur le bon chemin ! Ce tutoriel vous a permis d’acquérir une notion parmi les plus importantes en programmation.
Cependant, il est fortement conseillé de refaire les exemples de ce tutoriel et essayer de coder de nouveaux exercices encore plus complexes.
Bon, la route est encore longue ! Vous allez découvrir pleins d’autres notions intéressantes dans ce langage. Bon courage et à un prochain tutoriel !