Tutoriel Python : les instructions imbriquées

Table des matières

Introduction

1. Rappel des structures conditionnelles et boucles

1.1 Les structures conditionnelles

1.2 Les boucles

2. Les instructions imbriquées

2.1 Définition

3. Les structures conditionnelles imbriquées
4. Les boucles imbriquées
5. Conditions & boucles imbriquées
6. Exercices

Correction des exercices

Conclusion

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.

1.2 Les boucles :

 Petit rappel indispensable sur la syntaxe des boucles :

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    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 :

1. Si la première condition est vérifiée alors le bloc Instruction1 est exécuté
2. 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 :

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 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 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 print ("C'est du liquide")
  else:
  print ("C'est de la vapeur !")

Résultat de l’exécution :

 Exemple :

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 while j  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 :

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

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_demandeif 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_demandeif 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_demandeif 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 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 !