Comment utiliser l'opérateur ternaire de Python

Ce guide vous apprendra à utiliser l’opérateur ternaire en Python. Vous apprendrez la syntaxe et coderez plusieurs exemples pour comprendre son fonctionnement.

Nous commencerons par revoir le fonctionnement de l’instruction conditionnelle if-else, puis nous apprendrons à écrire une expression équivalente à l’aide de l’opérateur ternaire.

Ensuite, nous coderons quelques exemples et apprendrons à émuler le comportement de l’opérateur ternaire de Python en utilisant un tuple et un dictionnaire Python. Enfin, nous passerons en revue quelques cas d’utilisation pour lesquels vous devriez préférer utiliser l’opérateur ternaire.

Commençons !

L’instruction If-Else en Python : Une revue

Vous pouvez coder en démarrant une REPL Python ou dans l’éditeur Python en ligne de Geekflare.

La syntaxe générique de l’instruction if-else en Python est la suivante :

if condition :
    # faire ceci
else :
    # faire ceci

Dans l’extrait ci-dessus, condition désigne la condition à vérifier. Si la condition est évaluée à True, le bloc if est déclenché. Si la condition est évaluée à False, les instructions contenues dans le bloc else sont exécutées.

Voici un exemple dans lequel la variable game_over se voit attribuer une valeur booléenne selon que la valeur de l’énergie est inférieure ou égale à zéro.

Si energy <= 0, game_over est True.
Dans le cas contraire, game_over est False.

L’extrait de code suivant montre comment procéder à l’aide des instructions conditionnelles if-else :

énergie = -1

si énergie <= 0 :
    game_over = True
else :
    game_over = False

print(game_over)
# Vrai

Dans cet exemple, l’énergie est égale à -1, ce qui est inférieur à 0. Game_over est donc True.

Opérateur ternaire de Python : Syntaxe et exemples

Python dispose d’un opérateur ternaire qui fonctionne de la même manière que l’opérateur conditionnel ternaire dans des langages comme le C et le C . La syntaxe générale pour l’utiliser est la suivante :

expression1 if condition else expression2

Analysons la syntaxe ci-dessus :

condition: La condition à vérifier.
expression1: L’expression à évaluer si la condition est vraie.
expression2: L’expression à évaluer si la condition est False.

Nous allons maintenant identifier ce que doivent être l’expression1, l’expression2 et la condition dans la version if-else du code.

En combinant le tout, nous obtenons ce qui suit en utilisant l’opérateur ternaire de Python.

game_over = True if energy <= 0 else False
print(game_over)
# Vrai

Codons un autre exemple. Supposons que vous teniez une librairie et que vous offriez aux lecteurs une réduction sur leurs achats en fonction de la fréquence de leurs visites dans votre magasin au cours de l’année écoulée.

Soit numVisits le nombre de visites.

Si numVisits > 7, le pourcentage de remise, discount_perc, est de 20.
Sinon, discount_perc est égal à 5.

Nous utilisons l’opérateur ternaire pour attribuer une valeur à la variable discount_perc.

numVisits = 10

discount_perc = 20 if numVisits > 7 else 5

print(discount_perc)
# 20 (car numVisits = 10 qui est > 7)

Nous allons maintenant apprendre à émuler l’opérateur ternaire à l’aide d’un tuple Python et d’un dictionnaire.

Emulation de l’opérateur ternaire avec un tuple Python

Comme tous les itérables en Python, les tuples suivent l’indexation zéro. Ainsi, si vous avez deux éléments dans un tuple, tuple_name[0] désigne le premier élément du tuple et tuple_name[1] désigne le deuxième élément du tuple.

Les types de données de base en Python sont les suivants : entier, flottant, chaîne et booléen. Python prend en charge le moulage de type qui vous permet de représenter un type de données particulier par sa représentation équivalente dans un autre type de données.

Lancez une interface Python et exécutez les exemples suivants. Si vous essayez de convertir des entiers en booléens, vous remarquerez ce qui suit :

bool(0) est Faux.
bool(<tout entier non nul>) renvoie True.

>>> bool(0)
Faux
>>> bool(1)
Vrai
>>> bool(-1)
Vrai
>>> bool(10)
Vrai

De même, lorsque l’on transforme des booléens en entiers, on obtient ce qui suit :

>>> int(True)
1
>>> int(False)
0

En combinant la conversion de type et l’indexation, nous pouvons procéder comme suit :

Élément à l’index 0 dans le tuple : La valeur à utiliser lorsque la condition est False.
Élément à l’index 1 du tuple : La valeur à utiliser lorsque la condition est vraie.

En utilisant ce qui précède, nous obtenons ce qui suit :

>>> numVisits = 10
>>> discount_perc = (5,20)[numVisits > 7]
>>> discount_perc
# 20

Ici, la condition numVisits > 7 est True car numVisits est 10. Comme int(True) vaut 1, la valeur de discount_perc est 20, l’élément à l’index 1.

Emulation de l’opérateur ternaire avec le dictionnaire Python

Vous pouvez définir True et False comme clés du dictionnaire. Et vous pouvez définir expression1 et expression2 comme les valeurs correspondant aux clés True et False, respectivement.

some_dict = {True : expression1,
             Faux : expression2
            }

Que faites-vous ensuite ? Si vous utilisez some_dict[condition], l’expression1 correspondant à la clé True est évaluée si la condition est True. Et l’expression2 est évaluée lorsque la condition est False.

Codons l’exemple discount_perc (à nouveau), mais cette fois-ci en utilisant un dictionnaire Python.

>>> numVisits = 10
>>> discount_dict = {True : 20, False:5}
>>> discount_perc = discount_dict[numVisits > 7]
>>> discount_perc
# 20

Ici, numVisits = 10, ce qui est supérieur à 7. Par conséquent, la condition numVisits > 7 est vraie. Ainsi, discount_dict[numVisits > 7] s’évalue à discount_dict[True] qui est la valeur 20.

Faut-il toujours utiliser l’opérateur ternaire de Python ?

Should You Always Use the Python Ternary Operator

Jusqu’à présent, nous avons appris à utiliser l’opérateur ternaire. Mais devons-nous toujours utiliser l’opérateur ternaire ? L’opérateur ternaire n’est pas forcément le meilleur choix pour tous les cas d’utilisation. Cette section explique dans quels cas vous devez préférer l’opérateur ternaire aux instructions if-else. Nous verrons également dans quels cas il est préférable d’utiliser l’instruction if-else au lieu de l’opérateur ternaire.

Plus concis que les blocs If-Else

Comme nous l’avons mentionné, en Python, l’expression de l’opérateur ternaire est plus concise que l’instruction if-else. Vous pouvez donc l’utiliser pour vérifier des conditions et évaluer des expressions conditionnellement à la volée.

Dans l’exemple suivant, nums est une liste de 100 nombres entiers générés aléatoirement. Pour chacun des 100 nombres, nous vérifions s’il est pair ou impair. Cette évaluation se fait en ligne à l’intérieur de la chaîne f.

import random

nums = [random.choice(range(100)) for i in range(10)]

for num in nums :
    print(f"{num} is {'even' if num%2==0 else 'odd'}")

# exemple de sortie

0 est pair
56 est pair
6 est pair
53 est impair
62 est pair
7 est impair
8 est pair
77 est impair
41 est impair
94 est pair

L’opérateur ternaire nécessite la clause else

Lorsque vous utilisez les instructions conditionnelles if-else, la clause else est facultative. Prenons un exemple. La variable game_over prend la valeur True si l’énergie tombe à une valeur inférieure ou égale à zéro.

Cependant, si l’énergie est supérieure à zéro, la variable game_over n’est jamais initialisée. Vous rencontrerez donc des erreurs si vous essayez d’accéder à la variable game_over.

energy = 5
si énergie <= 0 :
    game_over = True

print(f "Le jeu est-il terminé ? {game_over}")

Traceback (dernier appel le plus récent) :
  Fichier "ternary_op.py", ligne 39, in <module>
    print(f "Le jeu est-il terminé ? {game_over}")
NameError : le nom 'game_over' n'est pas défini

Une façon de résoudre ce problème est de définir game_over à False initialement et de le mettre à True si le niveau d’énergie est inférieur ou égal à zéro.

énergie = 5
game_over = False
si énergie <= 0 :
    game_over1 = True

print(f "Le jeu est-il terminé ? {game_over}")

Cependant, lorsque vous utilisez l’équivalent de l’opérateur ternaire de Python, la clause else n’est pas facultative. L’opérateur ternaire exige que l’expression soit évaluée lorsque la condition est False.

game_over = True if energy <= 0 else False

Si vous remplacez l’expression ci-dessus par game_over = True if energy <= 0 en supprimant la partie else, vous rencontrerez une erreur de syntaxe, comme indiqué :

Fichier "ternary_op.py", ligne 42
    game_over = True if energy <= 0
                                  ^
SyntaxError : syntaxe non valide

Pour vérifier plusieurs conditions, utilisez les instructions If-Else

Prenons l’exemple suivant : Chaque question d’un ensemble de questions d’entretien de codage est associée à un score de difficulté. En fonction de ce score, nous attribuons l’un des trois niveaux de difficulté : facile, moyen ou difficile, à une question donnée. Supposons que nous ayons les données suivantes :

Score	Niveau de difficulté
Moins de 10	facile
Entre 10 et 20	moyen
Plus de 20	difficile

Étant donné le score de difficulté, vous pouvez obtenir son niveau de difficulté à l’aide de l’opérateur ternaire de Python, comme indiqué :

score = 12

niveau_de_difficulté = "facile" si score < 10 sinon "difficile" si score > 20 sinon "moyen"

print(niveau_de_difficulté)
# moyen

L’expression de l’opérateur ternaire dans le bloc de code ci-dessus est de la forme suivante :

expression1 if condition1 else expression2 if condition2 else expression3

Bien que concise, cette expression est un peu difficile à lire et à analyser. L’image suivante montre comment le flux de contrôle se produit dans ce cas.

L’extrait de code suivant montre une implémentation équivalente utilisant des instructions if-else. Comme vous pouvez le constater, le flux de contrôle est beaucoup plus facile à comprendre et le code est plus lisible.

if score < 10 :
    niveau_de_difficulté="facile"
elif score > 20 :
    niveau_de_difficulté="hard"
else :
    niveau de difficulté = "moyen"

print(niveau_de_difficulté)

Par conséquent, lorsque vous avez plusieurs conditions, vous devez utiliser les blocs if-else au lieu de l’opérateur ternaire. Cela garantit que le code est facile à lire et à comprendre.

De même, lorsque vous devez exécuter plusieurs instructions – selon que la condition est vraie ou fausse – vous devez envisager d’utiliser l’instruction if-else.

Conclusion

Voici un récapitulatif de ce que vous avez appris dans ce tutoriel.

En Python, l’opérateur ternaire peut être utilisé avec la syntaxe suivante : expression1 if condition else expression2.
Vous pouvez émuler le comportement de l’opérateur ternaire en utilisant les tuples et les dictionnaires Python.
Bien que l’opérateur ternaire puisse être une alternative plus concise aux blocs if-else, vous devez vous assurer que le code est lisible. Pour améliorer la lisibilité du code, vous pouvez utiliser les instructions if-else au lieu de l’opérateur ternaire, en particulier lorsque vous devez enchaîner plusieurs conditions.

Ensuite, apprenez à consulter le tutoriel sur les opérateurs égal et non égal en Python.

Bala Priya C
Contributeur
Bala Priya est une développeuse et rédactrice technique indienne qui a plus de trois ans d’expérience dans la rédaction de contenu technique. Elle partage ses connaissances avec la communauté des développeurs en rédigeant des tutoriels techniques, des guides pratiques, etc. Elle travaille actuellement comme rédactrice technique chez Geekflare. Elle contribue également activement à plusieurs autres publications techniques telles que freeCodeCamp et KDnuggets.