DESCRIPTION.

Exécute un bloc de script en boucle tant qu'une expression témoin est True (vraie / 1). 

SYNTAXE.

while expression : 

while ⇨ appel de l’instruction [ OBLIGATOIRE ]

expression ⇨ expression à évaluer [ OBLIGATOIRE ]

PRÉSENTATION GÉNÉRALE D'UNE BOUCLE TANT QUE.

while expression : (Initialise la boucle while) 

Ligne W1 

Ligne W2 

if expressionC : continue (Si l'expression est true, nouveau cycle)

if expressionB : break (Si l'expression est true, aller à S1)

Ligne F3 

Ligne Fn

else : (a faire si la boucle n'a pas été interrompu par un break)

Ligne E1 

Ligne E2 

Ligne S1  (suite du programme) 

Ligne S2 

REMARQUES.

while est une instruction composée (de plusieurs lignes), ce qui implique le symbole : (2 points) terminant l'appel de while et l'indentation des lignes de script composant le bloc.

Les clauses break, continue et else sont facultatives. Mais si on peut utiliser autant de tests conditionnels contenant les clauses break ou continue que l'on souhaite, on ne peut placer qu'une seule clause else par boucle while. Si plusieurs clauses break ou continue sont présentes, seule la première occurrence rencontrée par le code sera exécutée.

Si une clause break est rencontrée et exécutée, le programme se poursuivra sur le code suivant la boucle sans exécuter le script de la clause else si elle présente. Une clause continue exécutée, retourne le programme à l'entête du bloc while, et vérifie si l'expression témoin est True pour commencer à nouveau le bloc d'instructions de la boucle while.

La clause else, si elle est présente, sera exécutée si aucune instruction break n'a été utilisée pour sortir de la boucle while.  Cela permet d'appliquer un traitement particulier si l'expression témoin est False, ce qui provoque la sortie normale (attendue) de la boucle while.

On imbriquer autant de boucle while que l'on souhaite.

EXEMPLES.

GBL_ValeurA = 0

GBL_ValeurB = 0

while GBL_ValeurA < 5 :

print ( f"Pour { GBL_ValeurA } on obtient : " , end = "" )

while GBL_ValeurB < 3 :

kproduit = GBL_ValeurB * GBL_ValeurA

print ( f"{ GBL_ValeurB } x { GBL_ValeurA } = { kproduit }." , end = "   "  )

GBL_ValeurB += 1

GBL_ValeurB = 0   

GBL_ValeurA += 1

print ( end = "\n" )

retourne

Pour 0 on obtient : 0 x 0 = 0.   1 x 0 = 0.   2 x 0 = 0.   

Pour 1 on obtient : 0 x 1 = 0.   1 x 1 = 1.   2 x 1 = 2.   

Pour 2 on obtient : 0 x 2 = 0.   1 x 2 = 2.   2 x 2 = 4.   

Pour 3 on obtient : 0 x 3 = 0.   1 x 3 = 3.   2 x 3 = 6.   

Pour 4 on obtient : 0 x 4 = 0.   1 x 4 = 4.   2 x 4 = 8. 

Les instructions continue, break peuvent être utilisées pour modifier le comportement de la boucle.

GBL_ValeurA = 0

GBL_ValeurB = 0

while GBL_ValeurA < 7 :

print ( end = "\n" )

GBL_ValeurB = 0   

GBL_ValeurA += 1    

print ( f"Pour { GBL_ValeurA } on obtient : " , end = "" )

if GBL_ValeurA == 3 : continue

if GBL_ValeurA == 5 : break

while GBL_ValeurB < 3 :

kproduit = GBL_ValeurB * GBL_ValeurA

print ( f"{ GBL_ValeurB } x { GBL_ValeurA } = { kproduit }." , end = "   "  )

GBL_ValeurB += 1

retourne

Pour 1 on obtient : 0 x 1 = 0.   1 x 1 = 1.   2 x 1 = 2.   

Pour 2 on obtient : 0 x 2 = 0.   1 x 2 = 2.   2 x 2 = 4.   

Pour 3 on obtient :

Pour 4 on obtient : 0 x 4 = 0.   1 x 4 = 4.   2 x 4 = 8.   

Pour 5 on obtient :

L'instructions break est particulièrement utile pour sortir d'une boucle infinie.

Une boucle infinie sert à répéter indéfiniment un programme, ou une partie du programme. Elle est introduite par la forme while True :

def FNC_Somme ( ) :

    ksomme = 0

    while True :

        kchoix = input ( 'Entrez un nombre ou "c" pour calculer la somme ...' )

        if kchoix  == "c" or kchoix  == "C" : break

        if kchoix.isnumeric ( ) : ksomme += int ( kchoix )

    return ksomme 

print ( FNC_Somme ( ) )

print ( "Au revoir." )

retourne :

Entrez un nombre ou "c" pour calculer la somme ...5

Entrez un nombre ou "c" pour calculer la somme ...4

Entrez un nombre ou "c" pour calculer la somme ...3

Entrez un nombre ou "c" pour calculer la somme ...2

Entrez un nombre ou "c" pour calculer la somme ...1

Entrez un nombre ou "c" pour calculer la somme ...

Entrez un nombre ou "c" pour calculer la somme ...c

15

Au revoir.

La clause else permet d'appliquer un traitement particulier la sortie d'une boucle while, donc le déroulement n'a pas été interrompu par l'exécution d'une clause break.

GBL_Controle = ""

while GBL_Controle.upper ( ) != "Q" :

GBL_Controle = input ( "Entrez une consonne (Q pour quittez) " )

if GBL_Controle.upper ( ) in "AEIOUY" : break

else :

print ( "Aucune voyelle entrée, c'est bien." )

print ( "Terminé." )

L'essais 1 retourne

Entrez une consonne (Q pour quittez) z

Entrez une consonne (Q pour quittez) k

Entrez une consonne (Q pour quittez) d

Entrez une consonne (Q pour quittez) q

Aucune voyelle entrée, c'est bien.

Terminé.

L'essais 2 retourne

Entrez une consonne (Q pour quittez) t

Entrez une consonne (Q pour quittez) g

Entrez une consonne (Q pour quittez) u

Terminé.

LES EXPRESSIONS.

Python teste si la condition n'est pas fausse (si elle n'est pas fausse, elle est vraie !).

Une expression est fausse si elle vaut False. Si elle n'est pas False elle est donc True.

Un test if (et/ou while) peut recevoir une simple variable, ou une occurrence d'un objet  comme expression. Dans se cas, c'est le contenu de l'objet qui est évalué. Sont considérés comme False (faux / 0) par Python :

- l'objet False (if False : ⇨ est évalué à False) ;

- l'objet None (if None : ⇨ est évalué à False) ;

- l'objet 0 (if 0 : ⇨ est évalué à False) ;

- l'objet "" ou '' (if "" : et if '' : ⇨ sont évalués à False) ;

- un objet vide, par exemple :

    - une liste vide (LST_Liste = [ ] ; if LST_Liste : et if [ ] : ⇨ est évalué à False) ;

    - un dictionnaire vide (DCT_Dico = { } ; if DCT_Dico : et if { } : ⇨ est évalué à False) ;

    - un tuple vide (TPL_Tuple = ( ) ; if TPL_Tuple : et if ( ) : ⇨ est évalué à False) ;

    - ...

Mais plus généralement le test consiste en une expression à évaluer.

if A == B : ⇨ vaut True si A et B sont équivalents ;

if A != B : ⇨ vaut True si A et B sont différents ;

if A > B : ⇨ vaut True si A est strictement supérieur à B ;

if A >= B : ⇨ vaut True si A est supérieur ou équivalent à B ;

if A < B : ⇨ vaut True si A est strictement inférieur à B ;

if A <= B : ⇨ vaut True si A est inférieur ou équivalent à B ;

if A < X < B : ⇨ vaut True si X est compris dans l'intervalle entre A et B ;

if A > X > B : ⇨ vaut True si X est compris dans l'intervalle entre B et A ;

if A in B : ⇨ vaut True si A est contenu dans à B ;

if A is B : ⇨ vaut True si A et B font références au même objet ;

if A is not B : ⇨ vaut True si A et B font références à des objets distinct ;

Notez bien que les variables A, B et X ne sont pas forcément des valeurs numériques ou des chaines de caractères. Ils peuvent être de n'importent quel type d'objet. De même les termes égal, supérieur, inférieur, ..., dépendent fortement de la nature des objets à évaluer. Enfin, si deux objets qui sont identiques (2 références au même objet) sont égaux, deux objets égaux ne sont pas forcément identiques. 

Particularité. Les valeurs numériques présentes dans les expressions à évaluer doivent impérativement être du même type. Python s'occupe de convertir, si besoin, des valeurs de types différents dans un type commun dans le sens complex ( ) vers float ( ) et/ou float ( ) vers int ( ). Des arrondis peuvent donc être générés et produire des évaluations inattendues. Il est préconisé, afin de compenser d'éventuels arrondis malheureux, de tester la valeur absolue, de la différence entre deux valeurs numériques, et une valeur fixe de référence, dite de précision, en particulier avec l'utilisation de variables calculées comparées et des valeurs fixes.

A = 1.1 + 2.2

A == 3.3 retourne False 

abs ( A - 3.3 ) <  .01 retourne True 

abs ( 3.3 - A ) <  .01 retourne True 

A et 3.3 sont deux objets différents pour Python, qui retourne donc False s'il doit les évaluer. Evaluer la différence des deux valeurs numériques de ces objets, avec une valeur de référence permet de constater que ces deux valeurs sont proches l'une de l'autre et peuvent donc être considérées comme égales.

Certaines méthodes sont spécialement conçus pour les expressions en retournant True ou False. Citons, entre autre, .isalnum ( ) , .isalpha ( ) , .isdecimal ( ) , .isdigit ( ) , .isidentifier ( ) , ... , qui sont des méthodes des objets str ( ) , int ( ) et float ( ), et qui évaluent si leur objet est d'une certaine "nature" et retournent True si c'est le cas, sinon False.

Les opérateurs logiques permettent d'évaluer un ensemble d'expressions dans un même test.

if A and B : vaut True si les expressions A et B sont évaluées à True (et logique) ;

if A or B : vaut True si l'expression A est évaluée à True ou si l'expression B est évaluée à True (ou inclusif logique) ;

if not A : vaut True si l'expression A est évaluée à False  (non logique) ;

Notez que Python ne possède pas, nativement, d'opérateur xor (ou exclusif), qui est vrai si une seul des expression est vraie. Pour pouvoir utiliser cet opérateur, et d'autres, vous devez d'abord importer le module operator (import operator) et appeler la méthode operator.xor ( a , b ), où a et b sont les 2 objets à évaluer.

import operator

Vrai_a = True

Vrai_b = True

Faux_c = False

Faux_d = False

print ( "Deux Vrai retournent" , operator.xor ( Vrai_a , Vrai_b ) )

print ( "Deux Faux retournent" , operator.xor ( Faux_c , Faux_d ) )

print ( "Vrai et Faux retournent" , operator.xor ( Vrai_a , Faux_d ) )

retourne

Deux Vrai retournent False

Deux Faux retournent False

Vrai et Faux retournent True

voir le module operator pour plus de détails.

Il est possible d'imbriquer plusieurs tests logiques dans un même test. mais attention aux priorités et à la compréhension de tels pratiques.

if A and B or C : ⇨ vaut True si l'expression A est évaluée à True et si l'expression B est évaluée à True ou si l'expression C est évaluée à True ;

if A or B and C : ⇨ vaut True si l'expression A est évaluée à True ou si l'expression B et l'expression C sont évaluées à True ;

Il est préférable dans ces cas d'utiliser des parenthèses pour bien optimiser le code, ou changer la priorité des évaluations.

if A and B or C : équivaut à if A and ( B or C ) : alors que

if ( A and B ) or C : change la priorité des évaluation

Notez comme il peut devenir difficile de comprendre des tests tel que !

if A and B or D and E and F or G : 

Python court-circuit l'évaluation de la deuxième expression (ou suivantes) si l'évaluation générale est déjà déterminée. Dans if A and B : B ne sera pas évaluée si A est False, car False et B donnera False de toute façon ; et dans if A or B : B ne sera pas évaluée si A est True, car True ou B donnera True de toute façon.