Les branchements du type “si condition alors… (sinon…)” servent à orienter le flux des instructions en fonction de la réponse (vraie ou fausse) à une condition.
Cette condition résulte le plus souvent de la comparaison de deux valeurs.
Pour Python, les valeurs “vrai” et “faux” sont respectivement représentées par les constantes True et False (qui sont d’ailleurs les deux seules valeurs du type bool) :
|
1 2 |
>>> type(True), type(False) (<class 'bool'>, <class 'bool'>) |
Mais toutes les valeurs numériques ont une traduction booléenne : 0 représente le “faux”, et toute valeur non nulle représente le “vrai” (inversement True et False sont synonymes des entiers 1 et 0). Plus généralement : tout objet non vide (chaîne de caractères, liste, etc.) est considéré comme “vrai”, les objets vides représentant donc la valeur “faux”.
Voici les opérateurs qui permettent de comparer des valeurs en Python :
| < (strictement inférieur à) | > (strictement supérieur à) |
| <= (inférieur ou égal à) | >= (supérieur ou égal à) |
| == (égal à) | ! = (différent de) |
On notera bien sûr la différence entre le test d’égalité == et l’instruction d’affectation =.
Voici maintenant les opérateurs qui permettent de combiner des valeurs booléennes entre elles :
or (ou logique) |
and (et logique) |
not (négation logique) |
Quand deux valeurs numériques de types différents (entier, flottant, nombre complexe) sont comparées, elles sont converties dans le type qui les contient toutes les deux (cela explique, comme on le voit dans l’exemple ci-après, que Python considère comme égaux l’entier 4 et le flottant 4.0, ou encore le flottant 0. et le nombre complexe 0j).
|
1 2 |
>>> 1 < 2, 3 <= 2, 4 != 5, 4 == 4., 0. == 0j (True, False, True, True, True) |
On peut enchaîner les comparaisons. Par exemple l’expression x < y < z signifie (x < y et y < z). De même, l’expression x < y > z ! = t signifie (x < y et y > z et z != t).
|
1 2 |
>>> 1 < 4 > 2 != 0 < 3 # ici il faut lire: (1 < 4) et (4 > 2) et (2 != 0) et 0 < 3 True |
Les chaînes de caractères sont comparées selon l’ordre lexicographique (mais les caractères eux-mêmes sont évalués en fonction de leur code numérique : les majuscules viennent donc avant les minuscules).
|
1 2 3 4 |
>>> 'A' < 'Z' < 'a' < 'z' True >>> 'ABC' < 'ABc' < 'AbC' < 'Abc' < 'aBC' < 'aBc' < 'abC' < 'abc' # huit chaînes différentes True |
Dans une répétition {b_1\ \mathrm{or}\ b_2\ \mathrm{or}\ \cdots\ \mathrm{or}\ b_n} de “ou” logiques, les valeurs booléennes {b_1,\ldots,b_n} sont évaluées de gauche à droite, et l’évaluation s’arrête si l’une d’elles vaut True (car alors toute l’expression vaut True). Il en est de même dans une répétition {b_1\ \mathrm{and}\ b_2\ \mathrm{and}\ \cdots\ \mathrm{and}\ b_n} de “et” logiques : l’évaluation s’arrête dès que l’une des valeurs {b_k} vaut False : c’est ce qu’on appelle l’évaluation paresseuse des booléens.
Dans l’exemple ci-dessous, les comparaisons 1/3 < 1/2 et 1/4 < 1/3 renvoient la valeur “vrai”, donc l’évaluation continue jusqu’à la comparaison 1/2 < 1/0 qui provoque une erreur :
|
1 2 3 |
>>> 1/3 < 1/2 and 1/4 < 1/3 and 1/2 < 1/0 <...> ZeroDivisionError: division by zero |
Au contraire, dans le deuxième exemple, la comparaison 1/3 < 1/4 renvoie la valeur “faux”, ce qui interrompt l’enchaînement des “et” successifs (donc évite la dernière évaluation qui aurait conduit à une erreur de division par 0). Dans le dernier exemple, c’est la comparaison vraie 1/4 < 1/3 qui arrête l’enchaînement des “ou” successifs :
|
1 2 3 4 |
>>> 1/3 < 1/2 and 1/3 < 1/4 and 1/2 < 1/0 False >>> 1/2 < 1/3 or 1/4 < 1/3 or 1/2 < 1/0 True |
Si x, y sont de types différents (l’une d’elle au moins étant non numérique) les comparaisons x == y et x ! = y sont possibles (et renvoient respectivement False et True). Les autres comparaisons (inégalités) renvoient une erreur de type :
|
1 2 3 4 5 |
>>> 123 == "123" # L'entier 123 et la chaîne "123", ça n'est pas la même chose False >>> 123 <= "123" # Mais de là à les comparer... <...> TypeError: unorderable types: int() <= str() |
Remarque : les opérateurs <, <=, >, >=, !=, == ont le même degré de priorité, plus faible que celui des opérateurs arithmétiques. Mais ils sont prioritaires devant not, lui-même prioritaire devant and, lui-même prioritaire devant or.
Par exemple x + y < z se lit (x + y) < z, et non pas x + (y < z) :
|
1 2 3 4 5 |
>>> x = 1; y = 3; z = 4 >>> x + y < z # ici, on teste si la somme x + y est strictement inférieure à z False >>> x + (y < z) # ici, y < z vaut True, c'est-à-dire 1, et donc on calcule x + 1 2 |