DESCRIPTION.

Exécute le script du bloc qui suit l'instruction if si l'expression est évalué à True (vrai / 1).

SYNTAXE.

if expression : 

if ⇨ appel de l’instruction [ OBLIGATOIRE ]

expression ⇨ expression à évaluer [ OBLIGATOIRE ]

: ⇨ début de la partie du script à exécuter si expression est True [ OBLIGATOIRE ]

elif expression : 

elif ⇨ appel de l’instruction [ OBLIGATOIRE ]

expression ⇨ expression à évaluer [ OBLIGATOIRE ]

: ⇨ début de la partie du script à exécuter si expression est True [ OBLIGATOIRE ]

else : 

else ⇨ appel de l’instruction [ OBLIGATOIRE ]

: ⇨ début de la partie du script à exécuter si expression est True [ OBLIGATOIRE ]

PRÉSENTATION GÉNÉRALE D'UN TEST CONDITIONNEL.

if expressionA : (effectuer le test, si expression A est true faire ligne A1 sinon faire elif) 

ligne A1 (partie du script à exécuter si le expression A est évalué à true) 

ligne A2

ligne An (après cette ligne de code sortie du test, reprendre l'exécution à ligne S1 ) 

elif expressionB : (effectuer le test, si expression B est true faire ligne B1 sinon faire elif) 

ligne B1 (partie du script à exécuter si le expression B est évalué à true) 

ligne B2

ligne Bn (après cette ligne de code sortie du test, reprendre l'exécution à ligne S1 ) 

elif expressionC : (effectuer le test, si expression C est true faire ligne C1 sinon faire elif) 

ligne C1 (partie du script à exécuter si le expression C est évalué à true) 

ligne C2

ligne Cn (après cette ligne de code sortie du test, reprendre l'exécution à ligne S1 ) 

else :  (toutes les expressions ont été évalué à false donc faire ligne E1) 

ligne E1 (partie du script à exécuter si toutes les expressions ont été évalué à false ) 

ligne E2

ligne En (après cette ligne de code sortie du test, reprendre l'exécution à ligne S1 ) 

ligne S1 (suite du script) 

ligne S2

ligne Sn

REMARQUES.

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

Les clauses elif et else sont facultatives. Mais si on peut effectuer autant de tests elif que l'on souhaite, on ne peut placer qu'une seule clause else par instruction if.

Il est possible d'écrire un test if sur une seul ligne si elle ne doit être suivie que d'une instruction. Par exemple :

if A == B : C = "une affectation"

if "abc" in LST_Liste : FNC_Fonction ( ) 

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 instance 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 distincts ;

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, dite de précision 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 if, elif ou white. 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

A noter 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 ; 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.