Contrôler votre programme avec l’instruction « if » en Python

Lors de l’élaboration de vos programmes vous aurez besoin de créer des boucles de contrôle. Ces boucles vont permettront d’orienter les choix du programme pour faire une tâche A ou une tâche B. Pour réaliser ces contrôles vous devrez alors définir des critères de comparaison pour définir si oui ou non telle condition est respectée.

Dans un premier temps, pour comprendre comment fonctionne ces comparaisons, nous allons décrire les variables booléennes. Nous avons déjà vu dans cet article comment les déclarer. Maintenant, nous allons voir comment les utiliser.

Les variables booléennes pour le contrôle de votre programme en Python

Les variables booléennes contrairement aux autres variables ne peuvent prendre que deux valeurs : True ou False. Pour définir une variable booléenne en Python il faut lui assigner soit la valeur « True » soit « False » et Python interprètera automatiquement la variable comme booléenne. De plus, la lettre en capitale est importante. Il faut savoir qu’il y a quelques mots clés qui ne peuvent pas être utilisés pour des noms de variables en Python. True et False en font partie.

check = True # Initialisation de la variable check avec la valeur True
check
>>> True
False = 1     # Vous aurez une erreur car False et True ne sont disponible en Python
>>> SyntaxError: cannot assign to True

Comparer les variables en Python

Maintenant que vous avez compris l’utilisation des variables booléennes, voici la liste des opérations de comparaison en Python :

x == y  # x est égal à y
x != y  # x est différent de y
x > y   # x est supérieur strictement à y
x < y   # x est inférieur strictement à y
x >= y  # x est supérieur ou égal à y
x <= y  # x est inférieur ou égal à y

Ensuite, testons ces opérateurs :

3 == 5
>>> False

3 != 5
>>> True

check = 3 == 5 # Pas très lisible mais ça marche, on assigne le résultat de la comparaison dans la variable check
check
>>> False

Nous avons ici comparé des valeurs numériques mais vous pouvez tout à fait réaliser la même opérations sur des chaînes de caractères. J’attire votre attention sur ce point car lorsque vous récupérez des valeurs à partir d’un fichier texte, il faut vous assurer que le bon type soit utilisé. Très souvent, on pense récupérer une valeur numérique et en réalité le code considère la variable comme une chaîne de caractère. Si vous comparez une chaîne de caractère à un nombre, le résultat sera toujours faux.

x = 10
y = '10'
x == y
>>> False

x = 10; y = 10.  # Vous noterez la présence du point. Cela permet de définir un type "float". 
type(x), type(y)
>>> (int, float)

x == y # Python considère bien la valeur numérique malgré la différence de type
>>> True

Il arrive qu’on se trouve entre le symbole « = » et « == » pour comparer des variables. L’opérateur « = » est utilisé pour assigner une valeur à une variable alors que l’opérateur « == » permet de comparer deux variables. Un moyen de s’en souvenir est de penser à l’opérateur « != », différent de, qui utilise deux symboles. Pour l’opérateur « égal à », c’est pareil, il faut deux caractères.

Les opérateurs booléens

Les opérateurs booléens permettent de cumuler les comparaisons. Deux choix s’offrent à vous, l’opérateur AND et l’opérateur OR. Ces opérateurs permettent de contrôler votre programme avec plusieurs conditions afin de rentrer ou non dans un bloc. Les conditions renvoient des valeurs True ou False mais que se passe-t-il lorsqu’on les combine avec des opérateurs booléens ? Voici le résultat de la combinaison avec l’opérateur OR :

True or True
>>> True
True or False
>>> True
False or True
>>> True
False or False
>>> False

On voit donc que la combinaison avec « OR » est très permissive car il suffit qu’une seule condition soit vraie pour que le résultat le soit également. La prochain exemple concerne la combinaison avec l’opérateur AND :

True and True
>>> True
True and False
>>> False
False and True
>>> False
False and False
>>> False

L’opérateur « AND » est quant à lui beaucoup plus restrictif. En effet, pour que le résultat final soit vrai, il faut impérativement que les deux conditions soient remplies.

Enfin, il y a également l’opérateur NOT. Il permet d’évaluer la valeur opposée au résultat de l’opération booléenne donnée. Suivant la logique de votre programme, vous voudrez mettre une condition que vous ne voulez pas. Cela peut permettre une meilleure lisibilité de votre code ou qu’il soit plus facilement compréhensible.

not True
>>> False

not False
>>> True

not 5 < 2 # 5 n'est pas inférieur à 2 => False => not False = True
True

En règle générale, si vous écrivez la condition opposée, vous pourrez vous en passer. J’attire particulièrement votre attention sur les conditions « <« , « > », « <= » et « >= ». Le contraire de « inférieur ou égal à » est « strictement supérieur » et non pas « supérieur ou égal à ».

Voici un cas pratique pour la combinaison des opérations booléennes :

x = 5; y = 12
(x > 2) and (x < 10)
>>> True

(x > 2) and (y < 10)
>>> False

(x > 2) or (y < 10)
>>> True

L’utilisation de l’instruction « if » en Python

La définition d’un bloc en Python

Maintenant que nous avons vu les variables booléennes et comment les utiliser avec des instructions de comparaison, nous allons voir comment les insérer dans un bloc condition avec l’instruction « if ».

Un bloc de contrôle commence tout d’abord par une condition. Cette condition renvoie « True » ou « False ». C’est ce que nous avons vu précédemment. Ensuite, si la condition est remplie, nous rentrons alors dans le bloc de contrôle pour exécuter le code à l’intérieur.

Revenons tout d’abord sur la notion de bloc. En python, toutes vos lignes de code peuvent être regroupées en bloc. Cela permet de hiérarchiser votre code dans son exécution. Chaque bloc est identifié par une indentation. « Indenta…quoi ??? » 🙂 L’indentation représente le décalage (souvent une tabulation) qui est opéré lorsque vous rentrez dans le bloc. Voici un exemple :

debut_bloc1
  instruction  bloc1 # première indentation
  debut bloc2
    instruction bloc2 # deuxième indentation
    etc ...
  #fin bloc2
#fin bloc1

Le bloc se ferme automatiquement lorsque le code renvient au niveau précédent. Il n’y a pas besoin de mot clé pour le fermer d’où mes commentaires pour illustrer la fin des blocs dans le code.

Comme vous avez pu le voir, dans un bloc, on peut retrouver d’autres blocs imbriqués. Le nouveau bloc commence avec une indentation supplémentaire et se termine lorsque l’indentation recule. Voici un exemple de blocs imbriqués utilisant l’instruction « if else ».

utilisateur = 'Henry'
mot_de_passe = 'jaimepython'
if utilisateur == 'Henry':
  print('Bienvenue Henry!')
  if mot_de_passe == 'jaimepython'
    print('Mot de passe correct, connexion en cours.')
  else:
    print('Mot de passe incorrect !')

La structure de l’instruction « if » en Python

L’instruction « if » simple permet d’évaluer une condition. Si celle-ci est remplie alors l’instruction à l’intérieur du bloc sera exécutée. Si la condition n’est pas respectée, le programme continue son chemin sans rentrer dans le bloc.

L’instruction « if else » permet quant à elle d’exécuter une instruction quoi qu’il se passe. Si la condition est respectée c’est donc le bloc sous le « If » qui est exécuté. Dans tous les autres cas, c’est donc le bloc d’instruction sous le « else » qui sera utilisé.

L’instruction « if elif » permet d’enchaîner les conditions. « Elif » est la contraction de « Else if ». C’est donc un bloc « if else » enchaîné par un autre.

Voici le diagramme de flux qui représente les différentes instructions :

On peut rajouter autant de bloc « elif » que l’on souhaite. Cependant, plus il y en aura et plus votre code sera difficile à lire. Enfin, voici quelques exemples :

marque_velo = "Giant"
taille = "XL"

# Instruction if simple
# On affiche le message si la condition est respectée et c'est tout
if marque_velo == "Giant":   
  print("La marque de ce vélo est Giant !")
>>> La marque de ce vélo est Giant !

# Instruction if else
# Si la condition n'est pas remplie, l'instruction sous le "else" sera toujours exécutée
if marque_velo == "Giant":   
  print("La marque de ce vélo est Giant !")
else:
  print("Je ne connais pas la marque ce vélo.")
>>> La marque de ce vélo est Giant !

# Instruction if elif else
# Le programme va tester les conditions jusqu'à en trouver une vrai ou jusqu'au bloc "else"
if (marque_velo == "Giant") and (taille == "S"):   
  print("J'ai un petit vélo Giant")
elif (marque_velo) == "Giant" and (taille == "XL"):
  print("Mon vélo est un grand Giant")
else:
  print("Je n'aime pas ce vélo.")
>>> Mon vélo est un grand Giant

# Instructions "if" imbriquées
if marque_velo == "Giant":
  if taille == "XL":
    print("Mon vélo est un grand Giant")
  else:
    print("J'ai un vélo Giant à la mauvaise taille")
elif taille == "XL":
  print("J'ai un vélo de la bonne taille")
else:
  print("J'ai un vélo")
>>> Mon vélo est un grand Giant

Conseils pratiques

Je vous invite à faire bien attention à l’ordre de vos conditions. Dans le dernier exemple avec les « if » imbriqués, vous remarquerez que la condition dans l’instruction « elif » est vraie pour la taille « XL ». Cependant, comme la première condition est également vraie, le programme rentre donc le premier bloc et le second ne sera jamais exécuté. Quand vous avez plusieurs blocs conditionnels imbriqués, je vous conseille de faire attention et de vérifier tous les cas de figure. Voici un exemple où l’ordre est très important :

taille = 300 # La taille de la personne en centimètres

if taille < 150:
  print("Tu es petit")
elif taille > 220:
  print("Tu es un extraterrestre !")
elif taille > 180:
  print("Tu devrais faire du basket !")
else:
  print("Tu as une taille normale")
  
>>> Tu es un extraterrestre !

Maintenant, nous allons Inverser les deux conditions pour savoir si c’est un extraterrestre ou s’il devrait faire du basket :

taille = 300
if taille < 150:
  print("Tu es petit")
elif taille > 180:
  print("Tu devrais faire du basket !")
elif taille > 220:
  print("Tu es un extraterestre !")
else:
  print("Tu as une taille normale")
>>> Tu devrais faire du basket !

Le résultat n’est pas le même. L’ordre dans lequel vous allez réaliser vos blocs conditionnels est donc très important !

Un autre point important est la typographie. En effet, adopter les bonnes règles de typographie vous donnera un code espacé, clair et lisible. Dans notre cas, je vous conseille de mettre un espace entre les opérateurs comme on peut le voir sur les exemples présentés. Vous pouvez aussi utiliser les parenthèses pour regrouper les opérations et ainsi bien délimiter les conditions. Des normes existent pour Python concernant la typographie. Si vous souhaitez approfondir le sujet, vous pouvez aller consulter la norme PEP8 (Python Enhancement Proposals).

Enfin, le dernier conseil que je vous donnerai est de faire les choses simplement. Si votre code devient trop complexe, c’est qu’il y a un problème. Egalement, il faut abuser des commentaires, cela vous permettra de comprendre plus rapidement pourquoi vous avez choisi telle solution par rapport à une autre.