Chapitre 2 : Conditions et boucles¶

Programme officiel (B.O.)¶

B.O. spécial n° 1 du 22 janvier 2019 - SNT Seconde

Contenus	Capacités attendues
Affectations, variables	Écrire et développer des programmes avec des variables.
Séquences d'instructions	Comprendre et écrire une suite ordonnée d'instructions.
Instructions conditionnelles (`if`, `elif`, `else`)	Programmer des choix dans un algorithme.
Boucles bornées (`for`) et non bornées (`while`)	Programmer des répétitions.
Définitions et appels de fonctions	Décomposer un programme en fonctions réutilisables.

5. Instructions conditionnelles¶

Les instructions conditionnelles permettent au programme de prendre des décisions : exécuter un bloc de code seulement si une condition est vraie.

5.1. Le `if` simple¶

age = int(input("Quel âge as-tu ? "))

if age >= 18:
    print("Tu es majeur(e).")
    print("Tu peux passer le permis.")

Structure :

if condition:
    instruction(s) à exécuter si la condition est vraie

L'indentation est OBLIGATOIRE

En Python, le bloc de code à l'intérieur du if est indenté (décalé vers la droite). C'est l'indentation (4 espaces) qui définit quelles lignes font partie du bloc - pas des accolades {} comme dans d'autres langages.

if age >= 18:
print("Majeur")     # ❌ IndentationError: expected an indented block

if age >= 18:
    print("Majeur") # ✅ Correct (4 espaces d'indentation)

Oubli du deux-points :

if age >= 18         # ❌ SyntaxError: expected ':'
    print("Majeur")

if age >= 18:        # ✅ Le deux-points est obligatoire
    print("Majeur")

5.2. Le `if / else`¶

Pour exécuter un bloc si la condition est vraie, et un autre bloc si elle est fausse :

age = int(input("Quel âge as-tu ? "))

if age >= 18:
    print("Tu es majeur(e).")
else:
    print("Tu es mineur(e).")

5.3. Le `if / elif / else`¶

Pour tester plusieurs conditions enchaînées :

note = float(input("Ta note sur 20 : "))

if note >= 16:
    print("Très bien !")
elif note >= 14:
    print("Bien !")
elif note >= 12:
    print("Assez bien.")
elif note >= 10:
    print("Tu as la moyenne.")
else:
    print("Il faut réviser...")

elif est la contraction de « else if ». Python teste les conditions dans l'ordre : dès qu'une condition est vraie, il exécute le bloc correspondant et ignore tous les suivants.

Variante : même résultat, écriture différente

Le même programme peut s'écrire avec des if séparés, mais le comportement est différent :

# Avec elif : UNE SEULE branche est exécutée
note = 17
if note >= 16:
    print("Très bien")    # ✅ Exécuté
elif note >= 14:
    print("Bien")         # Ignoré (une branche a déjà été choisie)
elif note >= 12:
    print("Assez bien")   # Ignoré

# Avec des if séparés : TOUTES les conditions sont testées
note = 17
if note >= 16:
    print("Très bien")    # ✅ Exécuté
if note >= 14:
    print("Bien")         # ✅ Aussi exécuté (17 >= 14 est vrai !)
if note >= 12:
    print("Assez bien")   # ✅ Aussi exécuté (17 >= 12 est vrai !)

5.4. Conditions imbriquées¶

On peut mettre un if à l'intérieur d'un autre if :

age = int(input("Ton âge : "))
a_carte = input("As-tu une carte de réduction ? (oui/non) : ")

if age < 18:
    if a_carte == "oui":
        print("Tarif jeune avec réduction : 5 €")
    else:
        print("Tarif jeune : 8 €")
else:
    if a_carte == "oui":
        print("Tarif adulte avec réduction : 10 €")
    else:
        print("Tarif plein : 15 €")

Variante : aplatir avec and

On peut souvent éviter l'imbrication avec des opérateurs logiques :

if age < 18 and a_carte == "oui":
    print("Tarif jeune avec réduction : 5 €")
elif age < 18:
    print("Tarif jeune : 8 €")
elif a_carte == "oui":
    print("Tarif adulte avec réduction : 10 €")
else:
    print("Tarif plein : 15 €")

5.5. Les opérateurs de comparaison¶

Opérateur	Signification	Exemple	Résultat
`==`	Égal à	`5 == 5`	`True`
`!=`	Différent de	`5 != 3`	`True`
`<`	Strictement inférieur	`3 < 5`	`True`
`>`	Strictement supérieur	`5 > 3`	`True`
`<=`	Inférieur ou égal	`5 <= 5`	`True`
`>=`	Supérieur ou égal	`5 >= 6`	`False`

Piège : = vs ==

if age = 18:     # ❌ SyntaxError! C'est une affectation, pas une comparaison
if age == 18:    # ✅ Correct : c'est bien une comparaison

Comparaisons chaînées (spécificité de Python)

Python permet d'écrire des comparaisons enchaînées, comme en mathématiques :

# Au lieu de :
if age >= 12 and age <= 17:

# On peut écrire directement :
if 12 <= age <= 17:

# Cela fonctionne aussi avec d'autres combinaisons :
if 0 <= note <= 20:
if a < b < c:

5.6. Les opérateurs logiques¶

On peut combiner plusieurs conditions avec and, or et not :

Opérateur	Signification	Exemple
`and`	ET logique (les deux conditions doivent être vraies)	`age >= 12 and age <= 17`
`or`	OU logique (au moins une condition doit être vraie)	`jour == "samedi" or jour == "dimanche"`
`not`	NON logique (inverse la condition)	`not inscrit`

# AND : les deux conditions doivent être vraies
age = 16
a_carte = True
if age >= 12 and a_carte:
    print("Tarif réduit.")

# OR : au moins une condition doit être vraie
temperature = 35
if temperature < 0 or temperature > 40:
    print("Température extrême !")

# NOT : inverse vrai et faux
inscrit = False
if not inscrit:
    print("Veuillez vous inscrire.")

Table de vérité :

`a`	`b`	`a and b`	`a or b`	`not a`
`True`	`True`	`True`	`True`	`False`
`True`	`False`	`False`	`True`	`False`
`False`	`True`	`False`	`True`	`True`
`False`	`False`	`False`	`False`	`True`

5.7. L'expression conditionnelle (en une ligne)¶

Pour les cas simples, Python permet d'écrire un if/else en une seule ligne :

age = 20

# Forme classique
if age >= 18:
    statut = "majeur"
else:
    statut = "mineur"

# Forme condensée (expression conditionnelle)
statut = "majeur" if age >= 18 else "mineur"

# Utile dans un print
print("Accès autorisé" if age >= 18 else "Accès refusé")

À utiliser avec modération

L'expression conditionnelle en une ligne est pratique pour les cas simples, mais pour des conditions complexes, la forme classique reste plus lisible.

6. Les boucles¶

Les boucles permettent de répéter un bloc d'instructions plusieurs fois, ce qui évite de dupliquer du code.

6.1. La boucle `for` (boucle bornée)¶

La boucle for répète un bloc de code un nombre déterminé de fois :

# Afficher les nombres de 0 à 4
for i in range(5):
    print(i)
# Affiche : 0, 1, 2, 3, 4

Les variantes de `range()`¶

Appel	Valeurs générées	Nombre de valeurs
`range(5)`	0, 1, 2, 3, 4	5
`range(1, 6)`	1, 2, 3, 4, 5	5
`range(0, 10, 2)`	0, 2, 4, 6, 8	5
`range(10, 0, -1)`	10, 9, 8, ..., 1	10
`range(5, 0, -2)`	5, 3, 1	3
`range(3, 3)`	(rien)	0

Piège : la borne supérieure est EXCLUE

# Pour afficher 1, 2, 3, 4, 5 :
for i in range(5):       # ❌ Affiche 0, 1, 2, 3, 4
    print(i)

for i in range(1, 5):    # ❌ Affiche 1, 2, 3, 4 (5 est exclu !)
    print(i)

for i in range(1, 6):    # ✅ Affiche 1, 2, 3, 4, 5
    print(i)

Parcourir une chaîne de caractères¶

# Deux façons de parcourir les caractères d'un mot :

# Méthode 1 : directement (plus simple et plus « pythonique »)
mot = "Python"
for lettre in mot:
    print(lettre)

# Méthode 2 : par indice (utile quand on a besoin de la position)
mot = "Python"
for i in range(len(mot)):
    print(f"Caractère n°{i} : {mot[i]}")

Parcourir une liste¶

fruits = ["pomme", "banane", "cerise"]

# Méthode 1 : parcourir les éléments
for fruit in fruits:
    print(fruit)

# Méthode 2 : parcourir avec l'indice (enumerate)
for i, fruit in enumerate(fruits):
    print(f"{i} : {fruit}")
# 0 : pomme
# 1 : banane
# 2 : cerise

Le patron « accumulateur »¶

C'est un schéma de programmation très courant : on initialise une variable, puis on la modifie à chaque tour de boucle :

# Somme des entiers de 1 à 100
somme = 0
for i in range(1, 101):
    somme = somme + i    # ou somme += i
print(f"La somme vaut {somme}")  # 5050

# Compter les voyelles d'un mot
mot = "programmation"
compteur = 0
for lettre in mot:
    if lettre in "aeiouy":
        compteur += 1
print(f"Nombre de voyelles : {compteur}")  # 5

# Construire une chaîne lettre par lettre
resultat = ""
for i in range(1, 6):
    resultat += str(i) + " "
print(resultat)  # "1 2 3 4 5 "

6.2. La boucle `while` (boucle non bornée)¶

La boucle while répète un bloc tant qu'une condition est vraie. On l'utilise quand on ne connaît pas à l'avance le nombre de répétitions :

# Deviner un nombre
secret = 42
proposition = int(input("Devinez le nombre : "))

while proposition != secret:
    if proposition < secret:
        print("C'est plus !")
    else:
        print("C'est moins !")
    proposition = int(input("Nouvel essai : "))

print("Bravo, c'est bien 42 !")

Boucle infinie

Si la condition du while ne devient jamais fausse, le programme tourne indéfiniment. C'est une boucle infinie - il faut alors forcer l'arrêt avec Ctrl+C.

# ❌ Boucle infinie : x ne change jamais !
x = 1
while x > 0:
    print(x)
# Le programme ne s'arrête JAMAIS

# ✅ Correction : modifier x dans la boucle
x = 10
while x > 0:
    print(x)
    x -= 1    # x diminue à chaque tour → finit par atteindre 0

Comment vérifier qu'une boucle while va bien s'arrêter ?

Posez-vous ces deux questions :

Est-ce que la variable testée dans la condition est modifiée dans la boucle ?
Est-ce que cette modification rapproche la condition du False ?

Si la réponse aux deux est oui, la boucle s'arrêtera.

Valider une saisie utilisateur :

# Méthode 1 : saisie avant la boucle
note = float(input("Note entre 0 et 20 : "))
while note < 0 or note > 20:
    print("Erreur ! La note doit être entre 0 et 20.")
    note = float(input("Note entre 0 et 20 : "))

# Méthode 2 : avec un « drapeau » (flag)
valide = False
while not valide:
    note = float(input("Note entre 0 et 20 : "))
    if 0 <= note <= 20:
        valide = True
    else:
        print("Erreur ! La note doit être entre 0 et 20.")

6.3. `break` et `continue`¶

Ces deux instructions modifient le comportement normal d'une boucle :

break : sort immédiatement de la boucle
continue : saute au tour suivant de la boucle

# break : arrêter la boucle quand on trouve ce qu'on cherche
for i in range(1, 100):
    if i * i > 50:
        print(f"Le plus petit entier dont le carré dépasse 50 est {i}")
        break
# Affiche : Le plus petit entier dont le carré dépasse 50 est 8

# continue : sauter certains tours
for i in range(1, 11):
    if i % 3 == 0:
        continue    # On saute les multiples de 3
    print(i)
# Affiche : 1, 2, 4, 5, 7, 8, 10

Utilisation de break avec while True

Un patron courant est de créer une boucle infinie avec while True et d'en sortir avec break :

while True:
    reponse = input("Tapez 'quit' pour quitter : ")
    if reponse == "quit":
        break
    print(f"Vous avez tapé : {reponse}")
print("Au revoir !")

Cette approche est parfois plus lisible que de répéter le input() avant et dans la boucle.

6.4. Boucles imbriquées¶

On peut mettre une boucle à l'intérieur d'une autre :

# Table de multiplication
for i in range(1, 6):
    for j in range(1, 6):
        print(f"{i} × {j} = {i * j:2d}", end="   ")
    print()  # Saut de ligne après chaque ligne du tableau

# Triangle d'étoiles
n = 5
for i in range(1, n + 1):
    print("*" * i)
# *
# **
# ***
# ****
# *****

6.5. `for` ou `while` ? Comment choisir¶

Situation	Boucle à utiliser	Exemple
On connaît le nombre de répétitions	`for`	Afficher 10 fois « Bonjour »
On répète jusqu'à une condition	`while`	Attendre un mot de passe correct
On parcourt une collection	`for`	Parcourir les lettres d'un mot
On attend une saisie correcte	`while`	Redemander jusqu'à obtenir un nombre valide
On cherche un seuil	`while`	Trouver n tel que la somme dépasse 1000

Astuce : tout for peut s'écrire en while (mais pas l'inverse)

# Avec for
for i in range(5):
    print(i)

# Équivalent avec while
i = 0
while i < 5:
    print(i)
    i += 1

Le for est plus court et plus sûr (pas de risque de boucle infinie), donc on le préfère quand c'est possible.