À la fin de ce module, vous saurez diriger le flux d'exécution de vos programmes en maîtrisant les instructions conditionnelles, les boucles, les instructions de contrôle de flux, et les fonctions lambda.
1. Instructions Conditionnelles : La Prise de Décision
1.1 Le Principe des Conditions
Les structures conditionnelles permettent à votre programme de prendre des décisions et d'adapter son comportement selon différentes situations. C'est ce qui transforme un simple script en un programme intelligent capable de réagir différemment selon les circonstances. Imaginez un programme comme un arbre de décisions où chaque branche représente un chemin différent que votre code peut emprunter.
En Python, les conditions reposent sur des expressions booléennes qui s'évaluent à True ou False). Selon le résultat, différents blocs de code seront exécutés. L'indentation est cruciale en Python : elle définit quelles lignes appartiennent à quel bloc conditionnel. Cette approche rend le code visuellement clair et force une structure lisible.
1.2 La Structure if, elif, else
La structure conditionnelle complète se compose de trois mots-clés : if pour la première condition, elif (contraction de "else if") pour les alternatives, et else pour le cas par défaut.
Le if teste une première condition. Si elle est vraie, son bloc de code s'exécute et les autres conditions sont ignorées. Si elle est fausse, Python passe au premier elif s'il existe. Vous pouvez enchaîner autant de elif que nécessaire, chacun testant une nouvelle condition. Finalement, si aucune condition n'est satisfaite, le bloc else s'exécute s'il est présent.
# Structure conditionnelle simple
age = int(input("Quel est votre âge ? "))
if age < 0:
print("Erreur : l'âge ne peut pas être négatif")
elif age < 18:
print("Vous êtes mineur")
annees_restantes = 18 - age
print(f"Il vous reste {annees_restantes} an(s) avant la majorité")
elif age < 65:
print("Vous êtes adulte")
if 18 <= age <= 25: # Condition imbriquée
print("Vous êtes un jeune adulte")
elif age < 120:
print("Vous êtes senior")
else:
print("Âge inhabituel, vérifiez votre saisie")
1.3 Conditions Complexes et Opérateur Ternaire
Python permet de combiner plusieurs conditions avec les opérateurs logiques and, or, et not pour créer des tests sophistiqués. L'opérateur ternaire offre une syntaxe concise pour les conditions simples qui assignent une valeur.
# Opérateur ternaire (if-else en une ligne)
# Syntaxe : valeur_si_vrai if condition else valeur_si_faux
age = 20
statut = "majeur" if age >= 18 else "mineur"
print(f"Statut légal : {statut}")
# Conditions en cascade avec 'in'
jour = input("Quel jour sommes-nous ? ").lower()
if jour in ["samedi", "dimanche"]:
print("C'est le weekend !")
elif jour in ["lundi", "mardi", "mercredi", "jeudi", "vendredi"]:
print("Jour de travail")
else:
print("Ce n'est pas un jour valide")
2. Boucles : L'Automatisation des Tâches
2.1 La Boucle for : Parcours Déterminé
La boucle for est idéale quand vous savez combien d'itérations vous devez effectuer ou quand vous voulez parcourir une séquence d'éléments. En Python, elle est particulièrement élégante grâce à sa capacité à itérer directement sur les éléments d'une collection.
La fonction range(debut, fin, pas) est votre alliée principale avec les boucles for. Elle génère une séquence de nombres selon trois paramètres optionnels : début (inclus), fin (exclue), et pas. Par défaut, range(n) génère les nombres de 0 à n-1.
# Parcours de chaînes de caractères
mot = "Python"
print(f"Lettres de '{mot}' :")
for lettre in mot:
print(f"- {lettre}")
# Parcours avec index et valeur (enumerate)
fruits = ["pomme", "banane", "orange"]
print("\nInventaire des fruits :")
for index, fruit in enumerate(fruits, start=1):
print(f"{index}. {fruit}")
2.2 La Boucle while : Répétition Conditionnelle
La boucle while continue tant qu'une condition reste vraie. Elle est parfaite quand vous ne connaissez pas à l'avance le nombre d'itérations nécessaires. Attention cependant aux boucles infinies : assurez-vous que la condition finira par devenir fausse !
# Validation de saisie utilisateur
mot_de_passe = ""
tentatives = 0
max_tentatives = 3
while mot_de_passe != "secret123" and tentatives < max_tentatives:
mot_de_passe = input(f"Entrez le mot de passe (tentative {tentatives + 1}/{max_tentatives}) : ")
tentatives += 1
if mot_de_passe == "secret123":
print("Accès autorisé !")
else:
print("Nombre maximum de tentatives atteint. Accès refusé.")
3. Contrôle de Flux dans les Boucles
3.1 L'instruction break : Sortie Immédiate
L'instruction break permet de quitter immédiatement une boucle, même si la condition de continuation est encore vraie. C'est utile quand vous cherchez quelque chose et voulez arrêter dès que vous l'avez trouvé, ou pour implémenter des conditions de sortie complexes.
# Recherche avec break
nombres = [4, 7, 2, 9, 15, 3, 21, 18]
cible = 15
for nombre in nombres:
if nombre == cible:
print(f"Trouvé ! {cible} est dans la liste.")
break
3.2 L'instruction continue : Passer à l'Itération Suivante
L'instruction continue saute le reste du code dans l'itération actuelle et passe directement à l'itération suivante. Elle est utile pour filtrer certains cas sans avoir à imbriquer tout votre code dans des conditions.
# Filtrage avec continue
print("Nombres non divisibles par 3 entre 1 et 10 :")
for i in range(1, 11):
if i % 3 == 0:
continue # Saute les multiples de 3
print(i, end=" ")
4. Fonctions Lambda : Les Fonctions Anonymes
4.1 Comprendre les Fonctions Lambda
Les fonctions lambda sont des fonctions anonymes et concises, définies en une seule ligne. Elles sont parfaites pour des opérations simples qui ne méritent pas une fonction complète avec def. Pensez-y comme des "fonctions jetables" utilisées là où vous avez besoin d'une fonction temporaire, souvent comme argument d'une autre fonction.
La syntaxe est simple : lambda arguments: expression. Les lambdas peuvent avoir plusieurs arguments mais ne peuvent contenir qu'une seule expression. Elles retournent automatiquement le résultat de cette expression.
# Comparaison fonction classique vs lambda
# Fonction traditionnelle
def carre(x):
return x * x
# Équivalent en lambda
carre_lambda = lambda x: x * x
print(f"Fonction classique : {carre(5)}") # 25
print(f"Lambda : {carre_lambda(5)}") # 25
# Lambda avec plusieurs arguments
somme = lambda a, b: a + b
produit = lambda a, b, c: a * b * c
print(f"Somme : {somme(3, 7)}") # 10
print(f"Produit : {produit(2, 3, 4)}") # 24
# Lambda avec conditions (opérateur ternaire)
est_pair = lambda n: "pair" if n % 2 == 0 else "impair"
print(f"10 est {est_pair(10)}") # pair
print(f"7 est {est_pair(7)}") # impair
# Lambda pour calculer des valeurs
tva = lambda prix: prix * 1.20
reduction = lambda prix, pourcentage: prix * (1 - pourcentage/100)
prix_base = 100
print(f"Prix TTC : {tva(prix_base)}€")
print(f"Prix avec 15% de réduction : {reduction(prix_base, 15)}€")
4.2 Lambdas avec les Fonctions Intégrées
Les lambdas brillent vraiment quand elles sont utilisées avec des fonctions comme sorted(), map(), et filter(). Ces combinaisons permettent d'écrire du code Python très expressif et concis.
# Tri personnalisé avec sorted() et lambda
employes = [("Alice", 30), ("Bob", 25), ("Charlie", 35)]
par_age = sorted(employes, key=lambda emp: emp[1])
print(f"Tri par âge : {par_age}")
# Map : appliquer une fonction à chaque élément
nombres = [1, 2, 3, 4, 5]
carres = list(map(lambda x: x**2, nombres))
print(f"Carrés : {carres}")
# Filter : garder seulement certains éléments
nombres = range(-5, 6)
positifs = list(filter(lambda x: x > 0, nombres))
print(f"Nombres positifs : {positifs}")
5. Exercices Pratiques
Exercice 1 : Système de Notes Avancé
Créez un programme qui calcule la moyenne pondérée d'un étudiant à partir de plusieurs notes et coefficients, puis détermine sa mention.
Développez un programme qui trouve tous les nombres premiers dans une plage donnée (par exemple, de 1 à 100).
Voir la solution
def trouver_premiers(limite):
print(f"Nombres premiers jusqu'à {limite} :")
for n in range(2, limite + 1):
est_premier = True
for diviseur in range(2, int(n**0.5) + 1):
if n % diviseur == 0:
est_premier = False
break # Optimisation
if est_premier:
print(n, end=" ")
print()
if __name__ == "__main__":
trouver_premiers(100)
6. Mini-Projet : Jeu du Pendu
Combinez toutes les notions du module pour créer un jeu du pendu complet. Le programme choisit un mot aléatoirement et l'utilisateur doit deviner les lettres.
Jeu du Pendu
# Le code complet du jeu du pendu est fourni ici
import random
def jeu_pendu():
mots = ["python", "programmation", "algorithme", "variable"]
mot_secret = random.choice(mots)
lettres_trouvees = []
tentatives = 6
print("=== JEU DU PENDU ===")
while tentatives > 0:
mot_affiche = ""
for lettre in mot_secret:
mot_affiche += lettre if lettre in lettres_trouvees else "_"
print(f"\nMot : {mot_affiche} | Tentatives restantes : {tentatives}")
if "_" not in mot_affiche:
print("Félicitations ! Vous avez gagné !")
break
lettre = input("Proposez une lettre : ").lower()
if len(lettre) != 1 or not lettre.isalpha():
print("Entrée invalide.")
continue
if lettre in lettres_trouvees:
print("Lettre déjà proposée.")
continue
lettres_trouvees.append(lettre)
if lettre in mot_secret:
print("Bien joué !")
else:
tentatives -= 1
print("Raté !")
else:
print(f"\nPerdu ! Le mot était : {mot_secret}")
if __name__ == "__main__":
jeu_pendu()
7. Points Clés à Retenir
L'indentation en Python définit les blocs de code.
La boucle for est idéale pour les parcours de séquences, while pour les répétitions conditionnelles.
break quitte une boucle, continue passe à l'itération suivante.
Les fonctions lambda sont utiles pour des opérations simples et courtes.