If / Elif / Else

De la condition à la décision

L’arithmétique évalue ; la comparaison décide ; mais un programme qui ne fait qu’évaluer parcourt une ligne droite de haut en bas. La vie n’est pas une ligne droite. Une note est une fonction par morceaux : sa formule change à certains seuils. En mathématiques vous écrivez

Le if/elif/else de Python est la transcription d’une formule par morceaux. Chaque morceau garde sa plage, et exactement un morceau se déclenche.

La fourche simple

La branche la plus simple exécute son corps seulement quand la condition est True :

score = 85
if score >= 60:
    print("Passing!")

La déclaration commence par if, puis la condition, puis les deux points, les deux points disent à Python qu’un bloc arrive. Tout ce qui est indenté en dessous appartient à cette branche et ne s’exécute que si la condition tenait.

La fourche double

else attrape tout ce que le if n’a pas :

score = 45
if score >= 60:
    print("Passing!")
else:
    print("Needs more work")

Une branche double est une partition des issues : la condition divise l’espace des valeurs en deux moitiés, et chaque cas atterrit dans exactement une.

La fourche multiple : elif

Les formules par morceaux réelles ont plus de deux morceaux. elif, contraction de « else if », ajoute d’autres conditions, vérifiées dans l’ordre, s’arrêtant à la première qui est True :

score = 78
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"
print(grade)  # B

Remarquez l’économie : chaque condition elif n’a besoin que d’une borne inférieure, car les cas au-dessus sont déjà tranchés. Avec $s = 85$, le premier morceau échoue et le second réussit, les branches suivantes ne s’exécutent jamais. Une seule branche peut se déclencher, ce qui en fait une vraie fonction.

Véracité : des valeurs comme conditions

La condition après if n’a pas besoin d’être une comparaison. Python demande : « cette valeur est-elle vraie ou fausse ? », et la réponse est uniforme :

# Tous ces éléments sont falsy — ils se comportent comme False dans une condition :
bool(0)       # False
bool(0.0)     # False
bool("")      # False
bool([])      # False
bool(None)    # False

# Tout le reste est truthy — il se comporte comme True :
bool(1)       # True
bool("hello") # True
bool([1, 2])  # True

La collection des valeurs falsy est délibérément petite : zéro, texte vide, conteneurs vides et None. Tout le reste compte. Cela achète des conditions concises qui se lisent comme une vérification en langage naturel :

name = ""
if not name:
    print("Name is empty")

items = [1, 2, 3]
if items:
    print("We have items")

Une chaîne vide est falsy, donc not name vaut True ; une liste non vide est truthy, donc if items se déclenche. Vous sautez le == "" et le != [] explicites, la vérification est le vide lui-même.

Imbriquer : quand une question dépend d’une autre

Certaines décisions sont séquentielles : d’abord, êtes-vous majeur ? ; ensuite, portez-vous une pièce d’identité ? Cela s’imbrique :

age = 25
has_id = True

if age >= 21:
    if has_id:
        print("Entry allowed")
    else:
        print("Need ID")
else:
    print("Too young")

L’imbrication fonctionne, mais chaque niveau double les chemins qu’un lecteur doit tenir en tête. Les chaînes elif plates se lisent comme la formule par morceaux elle-même ; prenez-les d’abord, et réservez l’imbrication aux questions réellement dépendantes.

Un exemple travaillé : le thermostat

Un thermostat est une fonction par morceaux à trois morceaux. La chaîne la transcrit directement :

temperature = 22

if temperature <= 10:
    state = "heating"
elif temperature >= 30:
    state = "cooling"
else:
    state = "steady"
print(state)  # steady

Il se lit comme la formule qu’il est. L’ordre des morceaux compte : chaque elif suppose que ceux au-dessus ont échoué, si bien qu’exactement une branche se déclenche et qu’exactement un état s’imprime.

Pièges courants

• Oublier les deux points après if, elif ou else, sans eux, le bloc ne commence jamais.
• = au lieu de ==. if score = 60 est une erreur de syntaxe, exprès.
• Sur-imbriquer quand une chaîne elif (ou un retour anticipé) exposerait la forme de la formule d’un seul regard.
• Le premier True gagne, pas la correspondance la plus spécifique. Dans if x > 5: ... elif x > 3: ..., un x = 4 entre dans la deuxième branche seulement si la première a déjà échoué, et une valeur sous 3 tombe dans else. Ordonner les morceaux du plus étroit au plus large est ce qui garde la formule correcte.