if-else Python : voici comment com­prendre et utiliser l’ins­truc­tion

L’ins­truc­tion if-else en Python (en français : « si-(alors)-sinon ») est un bran­che­ment con­di­tion­nel et donc une structure de contrôle de base. L’uti­li­sa­tion d’un bran­che­ment con­di­tion­nel permet de suivre des chemins de code dif­fé­rents en fonction d’une condition ren­con­trée à l’exécution. Nous ex­pli­quons comment if-else fonc­tionne et est utilisé dans Python.

L’ins­truc­tion if-else est un bran­che­ment con­di­tion­nel. On peut se l’imaginer comme un ai­guil­lage : en présence d’un élément de com­mu­ta­tion, un seul des deux chemins possibles est emprunté. Python est un langage in­ter­prété ; l’in­ter­pré­teur lit les lignes du code source de haut en bas. Dans le cas le plus simple, il en résulte un flux de programme stric­te­ment linéaire : toutes les lignes sont lues, in­ter­pré­tées et exécutées les unes après les autres.

En suivant ce schéma simple, il n’est toutefois pas possible de réaliser des pro­grammes complexes. Ce n’est qu’en utilisant des struc­tures de contrôle que l’on obtient la va­ria­bi­lité du code exécuté né­ces­saire dans la pratique. Un bran­che­ment permet l’exécution con­di­tion­nelle de certaines parties de code. Les autres struc­tures de contrôle utilisées sont notamment les boucles Python for et les boucles Python while, qui per­met­tent l’exécution répétée de parties de code.

En général, l’ins­truc­tion if-else fonc­tionne en Python de la même manière que dans les autres langages. Il y a cependant quelques par­ti­cu­la­ri­tés spé­ci­fiques à Python. Voyons en détail comment fonc­tionne l’ins­truc­tion if-else en Python et comment elle se comporte par rapport aux autres langages.

La syntaxe générale de l’ins­truc­tion if-else peut être exprimée di­rec­te­ment en code Python. Nous dé­fi­nis­sons une condition et, dans le corps de l’ins­truc­tion if, nous dé­fi­nis­sons par exemple un appel de fonction comme chemin de code à suivre lorsque la condition devient vraie. Nous dé­fi­nis­sons également dans le corps else un chemin de code à suivre dans le cas contraire :

La condition définie peut être soit vraie (True) soit fausse (False). Nous il­lus­trons le modèle en ins­cri­vant un littéral True ou False di­rec­te­ment comme condition. Il en résulte un flux de programme statique dans lequel il est garanti qu’un seul des deux chemins est emprunté à la fois :

Bien entendu, ce modèle n’est pas pratique, il sert uni­que­ment à illustrer. Au lieu d’une valeur True/False statique, une ex­pres­sion est utilisée comme condition. L’ex­pres­sion est évaluée lors de l’exécution du programme. On dit que l’ex­pres­sion est « évaluée ». Lors de l’éva­lua­tion de l’ex­pres­sion, une valeur de vérité est obtenue. Selon que la valeur de vérité est True ou False, le programme se branche dans l’une ou l’autre direction.

Il est important de com­prendre que la partie else est fa­cul­ta­tive. Le code contenu dans le corps else n’est exécuté que si la condition ne s’applique pas. Cela n’est toutefois pas obli­ga­toire. Souvent, une ins­truc­tion if seule est suf­fi­sante :

Une petite remarque sur la no­men­cla­ture : nous avons utilisé les termes « ins­truc­tion » et « ex­pres­sion » sans les expliquer. Il est pourtant important de com­prendre ce que l’on entend par là. Car ces deux notions fon­da­men­tales se re­trou­vent dans tous les langages de pro­gram­ma­tion. Voici un aperçu de la sig­ni­fi­ca­tion de ces termes :

Outre la célèbre ins­truc­tion if-else en Python, il existe une ins­truc­tion elif ap­pa­ren­tée. Une ins­truc­tion if est suivie de plusieurs ins­truc­tions elif op­tion­nelles, suivies d’un bloc else optionnel. Une ins­truc­tion elif n’est exécutée que si aucune des con­di­tions pré­cé­dentes n’est vraie. Cela garantit que seul un chemin de code unique défini est suivi :

Voici les règles de cons­truc­tion d’une branche if elif else enchaînée :

L’ins­truc­tion if-else est une fonc­tion­na­lité de base en Python et dans d’autres langages. Na­tu­rel­le­ment, il existe de nom­breuses pos­si­bi­li­tés d’uti­li­sa­tion. Nous vous pré­sen­tons des exemples courants, ainsi que les meil­leures pratiques et les anti-patterns.

Regardons d’abord comment fonc­tionne la condition d’une ins­truc­tion de bran­che­ment. La condition est in­ter­pré­tée comme une ex­pres­sion booléenne qui évalue à l’une des valeurs de vérité True ou False. Il est donc inutile de tester ex­pli­ci­te­ment l’égalité avec un littéral booléen :

Même si la com­pa­rai­son explicite avec True n’est pas une véritable erreur, le code ne fait pas pro­fes­sion­nel. Les pro­gram­meurs ex­pé­ri­men­tés écrivent à la place :

Examinons l’anti-pattern à l’aide d’un exemple. Supposons qu’une fonction is_odd() renvoie True pour un nombre si le nombre est impair. Dans le cas contraire, la fonction is_odd renvoie False. Nous utilisons la fonction dans une ins­truc­tion if et affichons un texte cor­res­pon­dant :

Imaginons ce qui se passe lors du passage du bran­che­ment avec un nombre impair. D’abord, l’ex­pres­sion 'is_odd(number) == True' évalue en 'True == True'. Cette dernière évalue à son tour en 'True' ; le corps if est exécuté. Il est plus judicieux d’utiliser di­rec­te­ment la valeur booléenne renvoyée par la fonction is_odd comme condition :

Imaginons la situation suivante : nous avons un bloc de code avec une certaine fonction. Les lignes sont exécutées les unes après les autres. Cependant, un élément du code ne doit pas être exécuté à chaque fois, mais uni­que­ment lorsqu’une condition est remplie. Pour mettre en œuvre ce modèle, nous avons sim­ple­ment besoin d’une ins­truc­tion if. Illustrée ici par l’exemple d’une routine d’en­re­gis­tre­ment d’uti­li­sa­teur :

Souvent, les pro­grammes doivent dis­tin­guer deux cas qui s’excluent mu­tuel­le­ment. S’il est lo­gi­que­ment évident qu’il ne peut pas y avoir d’autres cas, il est judicieux d’utiliser une ins­truc­tion if-else. A titre d’exemple, nous testons si une personne a atteint un certain âge et affichons à chaque fois un résultat approprié :

S’il y a plus de deux cas mu­tuel­le­ment exclusifs que nous voulons dis­tin­guer, nous utilisons des ins­truc­tions elif en­chaî­nées. Un else final sert à attraper la variante inconnue. Nous at­tri­buons les noms de pays aux codes de pays cor­res­pon­dants :

Dans la mesure où la chaîne elif se trouve à l’intérieur d’une fonction, il est parfois pré­fé­rable d’utiliser plusieurs ins­truc­tions if in­dé­pen­dantes. Ainsi, nous évitons l’af­fec­ta­tion dans le corps elif. L’ins­truc­tion return permet de quitter la fonction si l’une des con­di­tions est remplie. Au lieu du else final, on utilise une ins­truc­tion return placée en dernier, qui n’est atteinte que si aucune des con­di­tions n’est True :

Les ins­truc­tions elif en­chaî­nées sont un modèle bien connu des anciens langages. En Python, il est souvent plus direct d’utiliser un « Dic­tio­nary Lookup ». Nous dé­fi­nis­sons di­rec­te­ment la cor­res­pon­dance entre les codes et les noms de pays et nous extrayons le nom à partir du code. Au lieu du else final, nous utilisons la méthode get intégrée, qui prend une valeur par défaut comme deuxième paramètre :

Python est un langage à typage dynamique. Au lieu d’être liés à des variables, les types sont liés à des valeurs. Selon l’uti­li­sa­tion, des con­ver­sions im­pli­cites entre types peuvent avoir lieu. Dans le contexte des ex­pres­sions boo­léennes, on parle également de « truthy » et de « falsy » par extension des valeurs de vérité True et False.

Cela signifie que la condition d’une ins­truc­tion if en Python n’a pas besoin d’être ex­pli­ci­te­ment évaluée en True ou False. Au contraire, des valeurs d’autres types peuvent être utilisées comme condition. Celles-ci sont in­ter­pré­tées comme des valeurs boo­léennes selon certaines règles.

Nous utilisons ce modèle pour vérifier si un objet contient des données. Comme le texte suivant est vide, un message cor­res­pon­dant est affiché :

Les objets suivants sont évalués comme False dans un contexte booléen et sont donc appelés « falsy » :

Un autre exemple avec une liste vide :

Tous les autres objets sont évalués comme True :

Une ins­truc­tion if-else en Python est également utilisée pour passer d’un état à l’autre de manière exclusive. Le principe ressemble à un in­ter­rup­teur de lumière et est appelé « toggle » en anglais. Nous dé­fi­nis­sons une fonction qui inverse l’état d’une lumière :

Vous le voyez peut-être déjà : c’est encore plus simple. Si l’état n’est pas re­pré­senté par une chaîne de ca­rac­tères, mais par une valeur booléenne, il est possible de renoncer com­plè­te­ment à l’ins­truc­tion if. Au lieu de cela, nous utilisons l’opérateur logique NON pour inverser la valeur booléenne :

Dans la pratique, il est courant d’exécuter certains codes lorsque plusieurs con­di­tions sont vraies en même temps. Pour les pro­gram­meurs inex­pé­ri­men­tés, cela conduit ra­pi­de­ment à des ins­truc­tions if im­bri­quées. Il s’agit toutefois d’un mauvais style. En effet, il est difficile d’avoir une vue d’ensemble des ra­mi­fi­ca­tions pro­fon­dé­ment im­bri­quées et de les en­tre­te­nir.

Prenons un exemple : nous écrivons une fonction qui indique si une personne peut voter. Nous vérifions d’abord si la personne possède une pièce d’identité. Ensuite, nous vérifions si la personne a déjà atteint l’âge de voter. Une première im­plé­men­ta­tion de la fonction contient des ins­truc­tions if im­bri­quées :

Un problème immédiat de cette im­plé­men­ta­tion est que plus les con­di­tions sont testées, plus le code le plus important est décalé. Pour résoudre les ins­truc­tions if im­bri­quées, nous utilisons la meilleure pratique du « Early Return ». Nous vérifions au début de la fonction si les dif­fé­rentes con­di­tions sont remplies. Si une condition n’est pas remplie, nous nous arrêtons et quittons la fonction en utilisant l’ins­truc­tion return.

Nous re­for­mu­lons notre fonction pour utiliser Early Return. Souvent, cela nécessite d’inverser les con­di­tions définies pré­cé­dem­ment. Pour cela, il est utile de com­prendre les opé­ra­teurs booléens de Python. Si aucune des con­di­tions négatives ne s’applique, le code pertinent est exécuté :

Comme nous l’avons déjà vu, il est souvent né­ces­saire de tester la réa­li­sa­tion de plusieurs con­di­tions. La plupart du temps, il n’est pas optimal d’utiliser des ins­truc­tions if im­bri­quées pour tester plusieurs con­di­tions. Prenons l’exemple d’un code qui détermine si une personne peut voter :

La condition enchaînée peut être mieux re­pré­sen­tée en utilisant des opé­ra­teurs logiques. Comme nous voulons tester si les deux con­di­tions s’ap­pli­quent si­mul­ta­né­ment, nous utilisons l’opérateur logique ET. Ainsi, nous n’avons besoin que d’une seule ins­truc­tion if :

Voici un aperçu des opé­ra­teurs logiques de base en Python :

En plus de la liaison d’opérandes dans des con­di­tions, les opé­ra­teurs logiques sont utilisés pour remplacer certaines ins­truc­tions if. Il s’agit en l’oc­cur­rence de définir des valeurs par défaut.

Prenons un exemple : imaginons qu’un uti­li­sa­teur puisse définir une devise pour un calcul financier. Pour des raisons de con­vi­via­lité, ce choix doit être fa­cul­ta­tif. Si l’uti­li­sa­teur ne choisit pas de devise, EUR doit être utilisé comme valeur par défaut. Le code suivant illustre ce principe :

En utilisant l’opérateur logique OU, l’ins­truc­tion if peut être résolue. Nous réé­cri­vons le code ; lorsqu’il est exécuté, la variable « currency » contient la valeur 'EUR' :

Que se passe-t-il ici exac­te­ment ? Dans la dernière ligne, une nouvelle valeur est attribuée à la variable 'cur­ren­cy'. Pour ce faire, l’ex­pres­sion 'currency or 'EUR' est d’abord évaluée à droite du signe égal. L’opérateur logique OU évalue d’abord l’ex­pres­sion de gauche, dans ce cas 'cur­ren­cy'. Comme celle-ci contient 'None' dans l’exemple et est donc 'falsy', l’ex­pres­sion de droite 'EUR' est évaluée et utilisée comme valeur de retour pour l’af­fec­ta­tion.

En plus du bran­che­ment con­di­tion­nel, les mots clés if-else en Python ont une autre utilité. Il s’agit de l’opérateur con­di­tion­nel, également connu sous le nom d’opérateur « ternaire ». L’opérateur con­di­tion­nel est vo­lon­tiers utilisé pour faire la dis­tinc­tion entre deux valeurs possibles dans les af­fec­ta­tions.

Con­si­dé­rons d’abord un exemple utilisant l’ins­truc­tion if-else en Python. Le code suivant définit Celsius ou Fah­ren­heit comme unité pour une mesure de tem­pé­ra­ture en fonction du système de mesure choisi :

En utilisant l’opérateur con­di­tion­nel, le code peut être simplifié en une seule ins­truc­tion :

Comme son nom l’indique, l’opérateur ternaire prend trois opérandes : les deux valeurs possibles et une ex­pres­sion comme condition.

L’ins­truc­tion match-case a été in­tro­duite avec la sortie de la version 3.10 de Python. Celle-ci rappelle l’ins­truc­tion switch-case d’autres langages. Dans ce cas, switch-case est utilisé pour briser les grandes cons­truc­tions if-elif-else.

Réputé pour être sujet aux erreurs, switch-case n’a jamais existé en Python. L’ins­truc­tion match-case en Python est plutôt une fonc­tion­na­lité de « Struc­tu­ral Pattern Matching » inspirée des langages fonc­tion­nels comme Haskell. Son utilité va bien au-delà de celle de switch-case.

Il­lus­trons le principe de match-case par un exemple : imaginons que nous voulions traiter des données de personnes dans dif­fé­rents formats. Une personne peut être re­pré­sen­tée soit sous la forme d’un nom unique, soit sous la forme d’un dic­tion­naire avec le nom et éven­tuel­le­ment l’âge, soit sous la forme d’un tuple de prénoms et de noms. Nous sou­hai­tons également traiter le nom exact « Jack » de manière par­ti­cu­lière :

Regardons d’abord une fonction qui accueille une personne dans l’un des formats. Nous utilisons une chaîne if-elif-else et la fonction isins­tance pour dis­tin­guer les dif­fé­rents formats. Nous utilisons également des con­di­tions en­chaî­nées avec l’opérateur ET et une ins­truc­tion if-else imbriquée. Le code final n’est pas très explicite :

Le code peut être construit plus joliment avec l’ins­truc­tion match-case. Nous décrivons di­rec­te­ment la structure des dif­fé­rents formats ; les valeurs in­di­vi­duelles peuvent être extraites en tant que variables. Le code est plus clair, moins complexe et plus lisible :