Programmation Python — Séance 3 : Contrôle du flux

Une condition exécute un bloc de code seulement si un test est vrai.
Télécharger le notebook Ouvrir dans Colab Les sorties sont celles enregistrées dans le notebook : rien n'est réexécuté.

DMI · FST · UCAD

On sait stocker des données. Cette séance apprend à décider (if/elif/else) et à répéter (for, while), puis à parcourir intelligemment avec enumerate et zip, et à contrôler une boucle avec break/continue. Exécutez chaque cellule avec Maj + Entrée. Les cellules À vous sont à compléter.

1. Les conditions : if / else

Une condition exécute un bloc de code seulement si un test est vrai. Le test est un booléen (rappel de la Séance 1). La syntaxe repose sur deux points : et sur l’indentation (le décalage) : le bloc décalé appartient au if.

note = 12
if note >= 10:
    print("Admis")
else:
    print("Recale")
Admis

À vous. Avec temperature = 34, affichez "Chaud" si la température dépasse 30, sinon "Doux".

# À vous : si temperature > 30 afficher "Chaud", sinon "Doux"

Pour distinguer plusieurs cas, on enchaîne avec elif (sinon si). Python teste les conditions dans l’ordre et s’arrête à la première vraie.

note = 14
if note >= 16:
    mention = "Tres bien"
elif note >= 14:
    mention = "Bien"
elif note >= 10:
    mention = "Passable"
else:
    mention = "Insuffisant"
print(mention)
Bien

À vous. Avec age = 25, affichez "Enfant" si l’âge est inférieur à 18, "Adulte" s’il est inférieur à 65, sinon "Senior".

# À vous : if age < 18 "Enfant", elif age < 65 "Adulte", else "Senior"

On peut combiner des conditions avec and, or, not (Séance 1). Le bloc n’est indenté qu’une fois — l’oubli des deux points : ou de l’indentation est l’erreur la plus fréquente ici.

note = 15
assiduite = True
if note >= 10 and assiduite:
    print("Valide")
else:
    print("A revoir")
Valide

2. La boucle for

Une boucle for répète un bloc pour chaque élément d’une collection. À chaque tour, la variable de boucle prend la valeur de l’élément courant.

villes = ["Dakar", "Louga", "Mbour"]
for ville in villes:
    print(ville)
Dakar
Louga
Mbour

À vous. Créez une liste prenoms de trois prénoms et affichez chacun avec une boucle for.

# À vous : parcourez prenoms avec une boucle for et affichez chaque prenom

Pour répéter un nombre fixé de fois, on utilise range(). range(n) produit les entiers de 0 à n-1 ; range(a, b) va de a à b exclu.

for i in range(5):
    print(i)
0
1
2
3
4
for i in range(1, 4):
    print("tour", i)
tour 1
tour 2
tour 3

À vous. Affichez les nombres de 1 à 10 avec range().

# À vous : affichez les nombres de 1 a 10 avec range(1, 11)

Le motif le plus utile est l’accumulation : on prépare une variable avant la boucle, puis on la met à jour à chaque tour. Ici, on calcule une somme.

notes = [12, 15, 9, 18]
total = 0
for note in notes:
    total = total + note
print("total :", total)
print("moyenne :", total / len(notes))
total : 54
moyenne : 13.5

Même principe pour compter : on incrémente un compteur quand une condition est remplie.

villes = ["Dakar", "Saint-Louis", "Mbour", "Ziguinchor"]
grandes = 0
for ville in villes:
    if len(ville) > 5:
        grandes = grandes + 1
print("villes de plus de 5 lettres :", grandes)
villes de plus de 5 lettres : 2

À vous. Avec prix = [500, 1200, 300, 800], calculez la somme totale par accumulation, puis affichez-la.

# À vous : total = 0 puis accumulez chaque valeur de prix dans une boucle for

3. Parcourir intelligemment : enumerate et zip

enumerate() donne à la fois l’indice et la valeur de chaque élément — pratique pour numéroter.

villes = ["Dakar", "Louga", "Mbour"]
for i, ville in enumerate(villes):
    print(i, ville)
0 Dakar
1 Louga
2 Mbour

À vous. Affichez chaque prénom de prenoms = ["Fatou", "Awa", "Cheikh"] précédé de son indice, avec enumerate.

# À vous : parcourez prenoms avec enumerate et affichez  indice, prenom

zip() parcourt deux listes en parallèle, élément par élément — idéal pour associer des données qui se correspondent.

villes = ["Dakar", "Thies", "Kaolack"]
population = [1200000, 320000, 240000]
for ville, hab in zip(villes, population):
    print(ville, ":", hab)
Dakar : 1200000
Thies : 320000
Kaolack : 240000

À vous. Avec prenoms = ["Fatou", "Awa"] et ages = [30, 25], affichez chaque prénom suivi de son âge, avec zip.

# À vous : parcourez prenoms et ages en parallele avec zip et affichez  prenom, age

4. La boucle while

Une boucle while répète un bloc tant qu’une condition reste vraie. Il faut absolument faire évoluer cette condition à l’intérieur de la boucle, sinon elle ne s’arrête jamais.

compteur = 0
while compteur < 3:
    print("compteur =", compteur)
    compteur = compteur + 1
print("fin")
compteur = 0
compteur = 1
compteur = 2
fin

Piège — la boucle infinie. Si la condition ne devient jamais fausse (par exemple si on oublie compteur = compteur + 1), la boucle tourne sans fin. Vérifiez toujours qu’une variable avance vers la sortie. On interrompt une boucle emballée avec le bouton Interrupt du noyau.

À vous. Avec une boucle while, affichez le compte à rebours 5, 4, 3, 2, 1 (partez de 5 et décrémentez).

# À vous : n = 5 puis while n >= 1 : afficher n et decrementer n

5. Contrôler une boucle : break et continue

break arrête complètement la boucle ; continue saute au tour suivant sans exécuter la suite du bloc.

for n in [1, 2, 3, 4, 5]:
    if n == 3:
        break
    print(n)
1
2

Ici la boucle s’arrête dès que n vaut 3. Avec continue, au contraire, on saute certains éléments mais on continue :

for n in [1, 2, 3, 4, 5]:
    if n % 2 == 0:
        continue
    print(n)
1
3
5

À vous. Parcourez valeurs = [4, 7, -2, 9, -5] et arrêtez la boucle (break) au premier nombre négatif, après avoir affiché les précédents.

# À vous : parcourez valeurs, affichez chaque nombre, et break au premier nombre negatif

6. Retour sur les compréhensions

Une compréhension de liste (Séance 2) est simplement une boucle for écrite de façon compacte. Les deux versions ci-dessous produisent exactement le même résultat.

# Version longue : boucle for + append
carres = []
for n in [1, 2, 3, 4]:
    carres.append(n * n)
print(carres)

# Version compacte : comprehension
carres2 = [n * n for n in [1, 2, 3, 4]]
print(carres2)
[1, 4, 9, 16]
[1, 4, 9, 16]

Récapitulatif

  • Conditions : if / elif / else ; le bloc est indenté après les deux points :.
  • Boucle for : for element in collection: répète pour chaque élément ; range(n) répète n fois.
  • Accumulation : préparer une variable avant la boucle, la mettre à jour à chaque tour (somme, compteur).
  • enumerate : indice + valeur. zip : deux listes en parallèle.
  • Boucle while : while condition: répète tant que c’est vrai ; faire évoluer la condition (piège : boucle infinie).
  • break arrête la boucle ; continue saute au tour suivant.
  • Une compréhension est un for compact.

Prochaine séance — S4 : les fonctions, les modules, la lecture de fichiers et les exceptions.

Retour au sommet