Partie 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 :

1. Est-ce que la variable testée dans la condition est modifiée dans la boucle ?
2. 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.

---