Instructions conditionnelles et boucles

Les instructions conditionnelles

Le if

L'instruction if (« si ») permet d'exécuter un bloc de code uniquement si une condition est vraie :

age = int(input("Ton âge : "))
if age >= 18:
    print("Tu es majeur.")

Attention à l'indentation ! En Python, le bloc de code à l'intérieur d'un if doit être indenté (décalé de 4 espaces).

Le if … else

On peut ajouter un bloc else (« sinon ») exécuté lorsque la condition est fausse :

note = float(input("Ta note : "))
if note >= 10:
    print("Bravo, tu as la moyenne !")
else:
    print("Courage, il faut réviser.")

Le if … elif … else

Pour tester plusieurs conditions en chaîne, on utilise elif (contraction de « else if ») :

note = float(input("Ta note : "))
if note >= 16:
    print("Très bien !")
elif note >= 14:
    print("Bien !")
elif note >= 10:
    print("Assez bien.")
else:
    print("Il faut retravailler.")

Les conditions sont évaluées de haut en bas. Dès qu'une condition est vraie, le bloc correspondant s'exécute et les autres sont ignorés.

---

Les opérateurs de comparaison

Opérateur	Signification	Exemple
==	Égal à	x == 5
!=	Différent de	x != 0
<	Strictement inférieur	x < 10
>	Strictement supérieur	x > 0
<=	Inférieur ou égal	x <= 20
>=	Supérieur ou égal	x >= 10

Les opérateurs logiques

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

age = 16
if age >= 12 and age < 18:
    print("Tu es adolescent.")

Opérateur	Signification
and	Vrai si les deux conditions sont vraies
or	Vrai si au moins une condition est vraie
not	Inverse la condition

---

La boucle for (boucle bornée)

La boucle for répète un bloc d'instructions un nombre déterminé de fois.

La fonction range()

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

Appel	Valeurs produites
range(n)	$0, 1, 2, \ldots, n-1$
range(a, b)	$a, a+1, \ldots, b-1$
range(a, b, pas)	$a, a+\text{pas}, a+2\text{pas}, \ldots$ (tant que < $b$)

Exemple : calcul d'une somme

Calculons $S = 1 + 2 + 3 + \cdots + 100$ :

S = 0
for i in range(1, 101):
    S = S + i
print(f"La somme vaut {S}")   # 5050

On retrouve la formule : $S = \frac{n(n+1)}{2} = \frac{100 \times 101}{2} = 5050$.

---

La boucle while (boucle non bornée)

La boucle while (« tant que ») répète un bloc tant qu'une condition est vraie. On ne connaît pas à l'avance le nombre de répétitions.

n = 1
while n <= 10:
    print(n)
    n = n + 1

⚠️ Il faut s'assurer que la condition finira par devenir fausse, sinon le programme tourne indéfiniment (boucle infinie).

Exemple : recherche du plus petit $n$ tel que $2^n > 1000$

n = 0
while 2 ** n <= 1000:
    n = n + 1
print(f"Le plus petit n tel que 2^n > 1000 est n = {n}")
# Résultat : n = 10 (car 2^10 = 1024 > 1000)

---

Les fonctions

Définir une fonction

Une fonction regroupe un bloc d'instructions que l'on peut appeler plusieurs fois :

def saluer(prenom):
    print(f"Bonjour {prenom} !")

saluer("Alice")    # Affiche : Bonjour Alice !
saluer("Bob")      # Affiche : Bonjour Bob !

Le mot-clé return

Une fonction peut renvoyer une valeur grâce à return :

def carre(x):
    return x ** 2

resultat = carre(7)
print(resultat)   # 49

Après un return, l'exécution de la fonction s'arrête immédiatement.

Fonction à plusieurs paramètres

def aire_rectangle(longueur, largeur):
    return longueur * largeur

print(aire_rectangle(5, 3))   # 15

---

Algorithmes classiques

Recherche du maximum dans une liste

def maximum(liste):
    maxi = liste[0]
    for element in liste:
        if element > maxi:
            maxi = element
    return maxi

notes = [12, 17, 8, 15, 20, 11]
print(f"La meilleure note est {maximum(notes)}")   # 20

Test de primalité

Un nombre $n \geq 2$ est premier s'il n'est divisible que par 1 et par lui-même :

def est_premier(n):
    if n < 2:
        return False
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

print(est_premier(17))   # True
print(est_premier(15))   # False

---

À retenir

• if / elif / else : exécuter du code selon une condition.
• for i in range(n): : répéter $n$ fois (boucle bornée).
• while condition: : répéter tant que la condition est vraie (boucle non bornée).
• def / return : définir une fonction réutilisable.
• Toujours penser à indenter le code à l'intérieur des blocs.