10. Utiliser les expressions conditionnelles (expressions if-else)

Dans le chapitre 8, nous avons appris à prendre des décisions dans nos programmes à l’aide des instructions if. Ces instructions nous permettent d’exécuter différents blocs de code en fonction de conditions. Cependant, parfois, nous devons choisir entre deux valeurs plutôt qu’entre deux blocs de code. Python propose une syntaxe spéciale pour cette situation fréquente : les expressions conditionnelles.

Les expressions conditionnelles (aussi appelées expressions ternaires ou opérateur ternaire dans d’autres langages) nous permettent d’écrire un code de décision compact lorsque nous devons simplement sélectionner une valeur ou une autre en fonction d’une condition. Elles sont particulièrement utiles pour les affectations et lors de la construction d’expressions plus grandes.

10.1) Ce que sont les expressions conditionnelles

Une expression conditionnelle est une expression unique qui s’évalue en l’une des deux valeurs selon une condition. Contrairement à une instruction if, qui contrôle quel bloc de code s’exécute, une expression conditionnelle produit une valeur qui peut être utilisée immédiatement.

Regardons un scénario courant. Supposons que nous écrivions un programme pour catégoriser des élèves selon leur âge :

# Utiliser une instruction if (ce que nous connaissons déjà)
age = 16
if age >= 18:
    category = "adult"
else:
    category = "minor"
print(f"Category: {category}")  # Output: Category: minor

Cela fonctionne parfaitement, mais remarquez que nous ne faisons en réalité que choisir entre deux valeurs de chaînes de caractères. La structure est un peu verbeuse pour une décision aussi simple. Voici la même logique en utilisant une expression conditionnelle :

# Utiliser une expression conditionnelle
age = 16
category = "adult" if age >= 18 else "minor"
print(f"Category: {category}")  # Output: Category: minor

Les deux versions produisent des résultats identiques, mais l’expression conditionnelle est plus compacte. Elle affecte directement l’une des deux valeurs à category en fonction de la condition.

Comprendre la différence fondamentale

La distinction clé est que les expressions conditionnelles sont des expressions, pas des instructions :

• Une expression est quelque chose qui s’évalue en une valeur. Vous pouvez l’utiliser partout où une valeur est attendue : dans des affectations, comme arguments de fonction, à l’intérieur d’autres expressions, etc.
• Une instruction est une consigne complète qui effectue une action mais ne produit pas de valeur.

# Ceci est une expression - elle produit une valeur
result = 10 if True else 20
 
# Ceci est une instruction - elle effectue des actions mais n'est pas une valeur en soi
if True:
    result = 10
else:
    result = 20

Parce que les expressions conditionnelles produisent des valeurs, elles sont plus flexibles dans certaines situations. Cependant, cela ne signifie pas qu’elles sont toujours meilleures : nous verrons plus loin dans ce chapitre quand utiliser chaque approche.

10.2) Syntaxe de l’expression if–else

La syntaxe d’une expression conditionnelle suit ce modèle :

value_if_true if condition else value_if_false

Décomposons chaque composant :

1. value_if_true : L’expression qui est évaluée et renvoyée si la condition est True
2. if : Le mot-clé qui introduit la condition
3. condition : Une expression booléenne qui détermine quelle valeur est renvoyée
4. else : Le mot-clé qui introduit la valeur alternative
5. value_if_false : L’expression qui est évaluée et renvoyée si la condition est False

Remarquez que l’ordre peut sembler inhabituel si vous connaissez d’autres langages de programmation. En Python, la valeur pour le cas « vrai » vient en premier, puis la condition, puis la valeur pour le cas « faux ». Cet ordre se lit un peu comme de l’anglais naturel : « Donnez-moi X si la condition est vraie, sinon donnez-moi Y. »

Voyons plusieurs exemples avec différents types de valeurs :

# Exemple 1 : choisir entre des nombres
temperature = 25
comfort_level = "warm" if temperature > 20 else "cool"
print(comfort_level)  # Output: warm
 
# Exemple 2 : choisir entre des calculs
score = 85
bonus = 10 if score >= 90 else 5
print(f"Bonus points: {bonus}")  # Output: Bonus points: 5
 
# Exemple 3 : choisir entre des valeurs booléennes
has_permission = True
access = "granted" if has_permission else "denied"
print(f"Access: {access}")  # Output: Access: granted
 
# Exemple 4 : la condition peut être n'importe quelle expression booléenne
username = "admin"
role = "administrator" if username == "admin" else "regular user"
print(f"Role: {role}")  # Output: Role: administrator

Notes importantes sur la syntaxe

La partie else est obligatoire dans une expression conditionnelle. Contrairement à une instruction if où else est optionnel, vous devez fournir les deux alternatives :

# Ceci est INVALIDE - else manquant
# result = "yes" if True  # SyntaxError
 
# Ceci est VALIDE - les deux branches sont fournies
result = "yes" if True else "no"

Cette exigence est logique, car une expression doit toujours produire une valeur. Si la condition est False et qu’il n’y a pas de clause else, quelle valeur l’expression doit-elle produire ? Python exige que vous soyez explicite sur les deux possibilités.

10.3) Comment les expressions conditionnelles sont évaluées

Comprendre comment Python évalue les expressions conditionnelles vous aide à écrire du code correct et à prévoir ce que feront vos programmes. L’évaluation suit une séquence spécifique et prévisible.

Le processus d’évaluation

Python évalue une expression conditionnelle dans cet ordre :

1. Évaluer la condition (l’expression booléenne après if)
2. Selon le résultat :
   • Si la condition est True, évaluer et renvoyer value_if_true
   • Si la condition est False, évaluer et renvoyer value_if_false

Point crucial : Python n’évalue qu’une des deux expressions de valeur, pas les deux. On appelle cela l’évaluation en court-circuit et c’est similaire au fonctionnement des opérateurs and et or (que nous avons abordés au chapitre 9).

# Seule la branche pertinente est évaluée
x = 10
result = x * 2 if x > 5 else x / 2
# Puisque x > 5 est True, Python évalue x * 2 (ce qui donne 20)
# et n'évalue jamais x / 2
print(result)  # Output: 20

Pourquoi l’évaluation en court-circuit est importante

L’évaluation en court-circuit peut éviter des erreurs et améliorer l’efficacité :

# Exemple 1 : éviter une division par zéro
denominator = 0
result = "undefined" if denominator == 0 else 100 / denominator
print(result)  # Output: undefined
# La division 100 / denominator n'est jamais tentée parce que
# la condition est True, donc nous évitons un ZeroDivisionError

# Exemple 2 : éviter des opérations sur None
data = None
length = 0 if data is None else len(data)
print(length)  # Output: 0
# len(data) n'est jamais appelé parce que data est None,
# ce qui évite un TypeError

Valeurs de vérité dans les expressions conditionnelles

Comme avec les instructions if (chapitre 8), la condition dans une expression conditionnelle utilise les règles de « truthiness » de Python. Toute valeur peut être utilisée comme condition :

# Une chaîne vide est falsy
name = ""
greeting = f"Hello, {name}" if name else "Hello, guest"
print(greeting)  # Output: Hello, guest
 
# Une chaîne non vide est truthy
name = "Alice"
greeting = f"Hello, {name}" if name else "Hello, guest"
print(greeting)  # Output: Hello, Alice
 
# Zéro est falsy, une valeur non nulle est truthy
items = 0
message = "You have items" if items else "Your cart is empty"
print(message)  # Output: Your cart is empty
 
items = 3
message = "You have items" if items else "Your cart is empty"
print(message)  # Output: You have items

Évaluation imbriquée

Les valeurs d’une expression conditionnelle peuvent elles-mêmes être des expressions, y compris d’autres expressions conditionnelles. Python les évalue de l’intérieur vers l’extérieur :

# value_if_true est lui-même un calcul
age = 25
price = age * 2 if age < 18 else age * 3
print(price)  # Output: 75
# Étapes : age < 18 → False → évaluer age * 3 → 75
 
# La condition est une expression complexe
score = 85
grade = 90
status = "excellent" if score >= 80 and grade >= 85 else "good"
print(status)  # Output: excellent
# Étapes : score >= 80 → True, grade >= 85 → True
#        True and True → True → renvoyer "excellent"

10.4) Utiliser les expressions conditionnelles dans les affectations

L’un des usages les plus courants des expressions conditionnelles est dans les affectations, lorsque nous voulons définir une variable à l’une des deux valeurs selon une condition. Ce schéma apparaît fréquemment dans le code du monde réel.

Schémas d’affectation simples

Regardons des exemples pratiques où les expressions conditionnelles rendent les affectations plus propres :

# Exemple 1 : définir une remise selon l'adhésion
is_member = True
discount = 0.15 if is_member else 0.05
print(f"Discount: {discount * 100}%")  # Output: Discount: 15.0%
 
# Exemple 2 : déterminer les frais de livraison
order_total = 45.00
shipping = 0 if order_total >= 50 else 5.99
print(f"Shipping: ${shipping:.2f}")  # Output: Shipping: $5.99
 
# Exemple 3 : définir une valeur par défaut
user_input = ""  # Simulation d'une saisie vide
page_size = int(user_input) if user_input else 10
print(f"Items per page: {page_size}")  # Output: Items per page: 10

Comparaison avec les instructions if

Voyons les mêmes affectations écrites avec des instructions if afin d’apprécier la différence :

# Utiliser une instruction if (plus verbeux)
is_member = True
if is_member:
    discount = 0.15
else:
    discount = 0.05
 
# Utiliser une expression conditionnelle (plus compact)
is_member = True
discount = 0.15 if is_member else 0.05

Les deux approches fonctionnent correctement, mais l’expression conditionnelle est plus concise lorsque vous ne faites que choisir entre deux valeurs. La version avec instruction if nécessite quatre lignes et répète le nom de variable discount deux fois, tandis que l’expression conditionnelle fait la même chose en une seule ligne.

Affectations multiples avec une logique cohérente

Lorsque vous devez faire plusieurs affectations basées sur la même condition, vous avez des choix :

# Approche 1 : plusieurs expressions conditionnelles
is_premium = True
price = 99.99 if is_premium else 149.99
features = "all" if is_premium else "basic"
support = "priority" if is_premium else "standard"
 
# Approche 2 : une instruction if pour plusieurs affectations
is_premium = True
if is_premium:
    price = 99.99
    features = "all"
    support = "priority"
else:
    price = 149.99
    features = "basic"
    support = "standard"

Dans ce cas, l’approche avec instruction if (Approche 2) est souvent plus lisible, car elle regroupe des affectations liées et rend claire la relation entre elles. L’approche par expressions conditionnelles (Approche 1) fonctionne mais répète la condition trois fois, ce qui peut être plus difficile à maintenir si la condition doit changer.

10.5) Utiliser les expressions conditionnelles à l’intérieur d’expressions plus grandes

Parce que les expressions conditionnelles produisent des valeurs, elles peuvent être intégrées dans des expressions plus grandes. Cela permet d’obtenir un code puissant et compact, même si cela demande de la prudence pour préserver la lisibilité.

Expressions conditionnelles en arithmétique

Vous pouvez utiliser des expressions conditionnelles comme opérandes dans des opérations arithmétiques :

# Addition conditionnelle
base_score = 80
bonus_eligible = True
final_score = base_score + (10 if bonus_eligible else 0)
print(f"Final score: {final_score}")  # Output: Final score: 90

Expressions conditionnelles dans le formatage de chaînes

Les expressions conditionnelles fonctionnent parfaitement avec les f-strings et d’autres opérations sur les chaînes :

# Exemple 1 : pluriel dans les messages
item_count = 1
message = f"You have {item_count} {'item' if item_count == 1 else 'items'}"
print(message)  # Output: You have 1 item
 
item_count = 3
message = f"You have {item_count} {'item' if item_count == 1 else 'items'}"
print(message)  # Output: You have 3 items
 
# Exemple 2 : salutation conditionnelle selon l'heure
hour = 14
greeting = f"Good {'morning' if hour < 12 else 'afternoon'}, user!"
print(greeting)  # Output: Good afternoon, user!

Expressions conditionnelles imbriquées

Vous pouvez imbriquer des expressions conditionnelles pour gérer plusieurs conditions, même si cela doit être fait avec parcimonie :

# Exemple 1 : classification à trois niveaux
score = 85
grade = "A" if score >= 90 else ("B" if score >= 80 else "C")
print(f"Grade: {grade}")  # Output: Grade: B
 
# Traçons l'exécution :
# score >= 90 ? Non (85 < 90)
# Donc évaluer la partie else : ("B" if score >= 80 else "C")
# score >= 80 ? Oui (85 >= 80)
# Renvoyer "B"
 
# Exemple 2 : classification de la température
temp = 15
category = "hot" if temp > 25 else ("warm" if temp > 15 else "cold")
print(f"Category: {category}")  # Output: Category: cold
 
# Exemple 3 : tarification selon l'âge avec plusieurs paliers
age = 65
price = 0 if age < 5 else (8 if age < 18 else (12 if age < 65 else 8))
print(f"Ticket price: ${price}")  # Output: Ticket price: $8

Note importante sur l’imbrication : Bien que les expressions conditionnelles imbriquées soient possibles, elles peuvent rapidement devenir difficiles à lire. Le troisième exemple ci-dessus est techniquement correct, mais difficile à comprendre. Nous verrons de meilleures alternatives dans la section 10.7.

Expressions conditionnelles dans les comparaisons

Vous pouvez utiliser des expressions conditionnelles au sein d’opérations de comparaison :

# Exemple 1 : comparer avec une valeur conditionnelle
base_value = 10
threshold = 15
is_large = True
result = base_value > (threshold if is_large else 5)
print(result)  # Output: False
# Évalue : base_value > 15 → 10 > 15 → False
 
# Exemple 2 : test d'égalité conditionnel
user_role = "admin"
required_role = "admin" if True else "user"
has_access = user_role == required_role
print(has_access)  # Output: True

10.6) Expression conditionnelle vs instruction if (Expression vs Instruction)

Comprendre quand utiliser une expression conditionnelle plutôt qu’une instruction if est crucial pour écrire un code clair et maintenable. La distinction revient à la différence fondamentale entre expressions et instructions en Python.

Expressions vs instructions : la différence centrale

Clarifions ces termes avec précision :

• Une expression est une combinaison de valeurs, de variables, d’opérateurs et d’appels de fonction que Python évalue pour produire une valeur. Exemples : 2 + 3, "hello".upper(), x if x > 0 else 0

• Une instruction est une consigne complète qui effectue une action. Les instructions ne produisent pas de valeurs : elles font des choses. Exemples : if x > 0: print("positive"), x = 5, for i in range(10): print(i)

# Ceci est une expression - elle produit une valeur (7)
result = 3 + 4
 
# Ceci est une instruction - elle effectue une action (affiche)
print("Hello")
 
# Une expression conditionnelle est une expression
value = "yes" if True else "no"  # Produit "yes"
 
# Une instruction if est une instruction
if True:
    value = "yes"
else:
    value = "no"
# Effectue une affectation mais le if lui-même ne produit pas de valeur

Quand utiliser les expressions conditionnelles

Les expressions conditionnelles sont idéales lorsque :

1. Vous choisissez entre deux valeurs pour une affectation :

# Bon usage d'une expression conditionnelle
age = 16
status = "adult" if age >= 18 else "minor"
 
# Moins concis avec une instruction if
age = 16
if age >= 18:
    status = "adult"
else:
    status = "minor"

2. Vous avez besoin d’une valeur en ligne dans une expression plus grande :

# Bon usage - valeur nécessaire dans une f-string
items = 1
print(f"You have {items} {'item' if items == 1 else 'items'}")
# Output: You have 1 item
 
# Malcommode avec une instruction if - nécessite une affectation préalable
items = 1
if items == 1:
    word = "item"
else:
    word = "items"
print(f"You have {items} {word}")

3. La logique est simple et l’expression reste lisible :

# Bon usage - logique simple et claire
discount = 0.15 if is_member else 0.05
max_value = a if a > b else b
sign = "positive" if x > 0 else "non-positive"

Quand utiliser les instructions if

Utilisez des instructions if lorsque :

1. Vous devez exécuter plusieurs instructions dans chaque branche :

# Utiliser une instruction if - plusieurs actions par branche
if score >= 90:
    grade = "A"
    message = "Excellent work!"
    bonus_points = 10
else:
    grade = "B"
    message = "Good job!"
    bonus_points = 5
 
# Les expressions conditionnelles seraient malcommodes ici :
# grade = "A" if score >= 90 else "B"
# message = "Excellent work!" if score >= 90 else "Good job!"
# bonus_points = 10 if score >= 90 else 5
# (Répète la condition inutilement)

2. Vous avez plus de deux branches (elif) :

# Utiliser une instruction if - plusieurs branches
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"
 
# Les expressions conditionnelles imbriquées deviennent difficiles à lire :
# grade = "A" if score >= 90 else ("B" if score >= 80 else ("C" if score >= 70 else "F"))

3. L’une des branches ne doit rien faire :

# Utiliser une instruction if - la branche else ne fait rien
if error_occurred:
    print("An error occurred")
    log_error(error_message)
# Pas de else nécessaire
 
# Une expression conditionnelle exige les deux branches :
# result = handle_error() if error_occurred else None  # Malcommode

Comparaison côte à côte

Voyons la même logique implémentée des deux façons :

# Scénario : définir des frais de livraison
 
# Version 1 : expression conditionnelle (bien pour un choix simple de valeur)
order_total = 45.00
shipping = 0 if order_total >= 50 else 5.99
 
# Version 2 : instruction if (plus verbeuse mais plus claire pour certains)
order_total = 45.00
if order_total >= 50:
    shipping = 0
else:
    shipping = 5.99
 
# Les deux produisent le même résultat
print(f"Shipping: ${shipping:.2f}")  # Output: Shipping: $5.99

Pour ce cas simple, l’expression conditionnelle est plus concise et tout aussi claire. Mais considérez un scénario plus complexe :

# Scénario : traiter une commande en plusieurs étapes
 
# Version 1 : instruction if (adaptée pour plusieurs actions)
order_total = 45.00
if order_total >= 50:
    shipping = 0
    discount = 0.10
    message = "Free shipping applied!"
else:
    shipping = 5.99
    discount = 0
    message = "Add $5 more for free shipping"
 
# Version 2 : expressions conditionnelles (malcommodes et répétitives)
order_total = 45.00
shipping = 0 if order_total >= 50 else 5.99
discount = 0.10 if order_total >= 50 else 0
message = "Free shipping applied!" if order_total >= 50 else "Add $5 more for free shipping"

La version avec instruction if est plus claire ici, car elle regroupe la logique liée et ne répète pas la condition.

10.7) Quand les expressions conditionnelles améliorent la lisibilité (et quand ce n’est pas le cas)

Les expressions conditionnelles sont un outil puissant, mais comme tout outil, elles peuvent être mal utilisées. L’objectif est toujours d’écrire un code qui n’est pas seulement correct, mais aussi clair et facile à maintenir. Explorons des recommandations pour utiliser efficacement les expressions conditionnelles.

Quand les expressions conditionnelles améliorent la lisibilité

1. Choix simples et clairs entre deux valeurs

Les expressions conditionnelles excellent lorsque la logique est simple :

# Excellent usage - parfaitement clair
discount = 0.20 if is_member else 0.10
 
# Excellent usage - signification évidente
status = "active" if user_logged_in else "inactive"
 
# Excellent usage - choix booléen simple
can_vote = True if age >= 18 else False
# Même si cela pourrait être encore plus simple : can_vote = age >= 18

2. Sélection de valeur en ligne dans des expressions

Quand vous avez besoin d’une valeur en ligne et que l’extraire serait malcommode :

# Excellent usage - pluriel naturel
print(f"Found {count} {'result' if count == 1 else 'results'}")
 
# Excellent usage - ajustement de calcul en ligne
total = base_price * (0.9 if is_sale else 1.0)
 
# Excellent usage - formatage conditionnel
output = f"Status: {status.upper() if is_error else status.lower()}"

3. Définir des valeurs par défaut

Les expressions conditionnelles fonctionnent bien pour fournir des valeurs de repli :

# Excellent usage - schéma de valeur par défaut
display_name = username if username else "Guest"
 
# Excellent usage - configuration avec valeurs par défaut
page_size = user_preference if user_preference else 25
 
# Excellent usage - division sûre
result = total / count if count > 0 else 0

Quand les expressions conditionnelles nuisent à la lisibilité

1. Expressions conditionnelles imbriquées

L’imbrication d’expressions conditionnelles crée un code difficile à lire :

# Lisibilité médiocre - expressions conditionnelles imbriquées
grade = "A" if score >= 90 else ("B" if score >= 80 else ("C" if score >= 70 else "F"))
 
# Beaucoup mieux - utiliser une instruction if-elif-else
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"

La version if-elif-else est immédiatement compréhensible. L’expression conditionnelle imbriquée exige une analyse attentive pour comprendre la logique.

2. Conditions complexes

Quand la condition elle-même est complexe, les expressions conditionnelles deviennent difficiles à lire :

# Lisibilité médiocre - condition complexe
result = "eligible" if age >= 18 and income > 30000 and credit_score > 650 and not has_bankruptcy else "not eligible"
 
# Mieux - utiliser une instruction if avec une structure claire
if age >= 18 and income > 30000 and credit_score > 650 and not has_bankruptcy:
    result = "eligible"
else:
    result = "not eligible"
 
# Encore mieux - décomposer la condition
meets_age_requirement = age >= 18
meets_income_requirement = income > 30000
meets_credit_requirement = credit_score > 650
has_clean_record = not has_bankruptcy
 
if meets_age_requirement and meets_income_requirement and meets_credit_requirement and has_clean_record:
    result = "eligible"
else:
    result = "not eligible"

3. Plusieurs expressions conditionnelles sur une seule ligne

Combiner plusieurs expressions conditionnelles sur une seule ligne :

# Lisibilité médiocre - trop sur une seule ligne
price = base * (0.9 if is_member else 1.0) * (0.85 if is_sale else 1.0) + (0 if free_shipping else 5.99)
 
# Mieux - décomposer en étapes
member_multiplier = 0.9 if is_member else 1.0
sale_multiplier = 0.85 if is_sale else 1.0
shipping_cost = 0 if free_shipping else 5.99
price = base * member_multiplier * sale_multiplier + shipping_cost
 
# Ou utiliser une instruction if si la logique est complexe
if is_member:
    price = base * 0.9
else:
    price = base
 
if is_sale:
    price = price * 0.85
 
if free_shipping:
    shipping_cost = 0
else:
    shipping_cost = 5.99
 
price = price + shipping_cost

L’essentiel

Utilisez les expressions conditionnelles quand elles rendent votre code plus clair et plus concis. Utilisez des instructions if lorsque vous avez besoin de :

• Plusieurs instructions par branche
• Plus de deux branches (elif)
• Des conditions ou une logique complexes
• Des effets de bord ou des actions plutôt qu’une sélection de valeur

En cas de doute, privilégiez la clarté plutôt que l’astuce. Le code est lu bien plus souvent qu’il n’est écrit, donc optimisez pour le lecteur.

Les expressions conditionnelles constituent un ajout précieux à votre boîte à outils Python. Elles vous permettent d’écrire un code concis et élégant lorsque vous choisissez entre deux valeurs. En comprenant quand elles améliorent la lisibilité et quand ce n’est pas le cas, vous pouvez prendre des décisions éclairées sur le moment où les utiliser.

Les principes clés à retenir :

1. Les expressions conditionnelles produisent des valeurs et peuvent être utilisées partout où une valeur est nécessaire
2. La syntaxe est value_if_true if condition else value_if_false
3. Python n’évalue que la branche pertinente (évaluation en court-circuit)
4. Elles sont idéales pour des choix simples de valeur dans des affectations et des expressions
5. Utilisez des instructions if pour plusieurs actions, une logique complexe, ou plus de deux branches
6. Priorisez la lisibilité : si une expression conditionnelle est difficile à comprendre, utilisez plutôt une instruction if

Au fur et à mesure que vous poursuivez votre apprentissage de Python, vous développerez une intuition sur le moment où les expressions conditionnelles améliorent votre code. Entraînez-vous à les utiliser d’abord dans des cas simples, et progressivement vous reconnaîtrez les schémas où elles excellent. Dans le prochain chapitre, nous explorerons les boucles while (while loop), qui nous permettent de répéter des actions selon des conditions — en nous appuyant sur les compétences de prise de décision que nous avons développées dans cette partie du livre.