U.A.10: EXECUTION DES ALGORITHMES (partie 2/2)

## Structures de contrôle (2) ### Introduction Dans le cours précédent sur les structures de contrôle (1), nous avons exploré les séquences d'instructions et les structures conditionnelles (comme `if`, `elif`, `else`) qui permettent à un programme de prendre des décisions et de suivre différents chemins d'exécution. Aujourd'hui, nous allons approfondir notre compréhension des algorithmes en découvrant les structures de contrôle itératives, plus communément appelées **boucles**. Ces structures sont fondamentales pour exécuter un bloc d'instructions plusieurs fois, ce qui est essentiel pour automatiser des tâches répétitives et écrire des programmes efficaces. ### Concepts Clés #### Les boucles : Exécuter une action plusieurs fois Les boucles sont des structures de contrôle qui permettent de répéter un bloc de code un certain nombre de fois ou tant qu'une certaine condition est vraie. Elles sont indispensables pour éviter de copier-coller du code et pour traiter des collections de données. #### La boucle `while` (Tant que) La boucle `while` est utilisée lorsque l'on veut répéter un bloc d'instructions **tant qu'une condition donnée est vraie**. Le nombre de répétitions n'est pas forcément connu à l'avance. ##### Fonctionnement 1. La condition est évaluée. 2. Si la condition est vraie, le bloc d'instructions est exécuté. 3. Après l'exécution du bloc, la condition est à nouveau évaluée. 4. Ce processus se répète tant que la condition reste vraie. 5. Lorsque la condition devient fausse, la boucle s'arrête et le programme continue avec l'instruction suivant la boucle. ##### Syntaxe en Python ```python while condition: # Bloc d'instructions à répéter # ... ``` **Attention :** Il est crucial que la condition puisse devenir fausse à un moment donné, sinon la boucle ne s'arrêtera jamais (boucle infinie). #### La boucle `for` (Pour chaque / Pour un nombre de fois) La boucle `for` est utilisée lorsque l'on veut itérer sur une séquence (comme une liste, une chaîne de caractères, ou un `range` de nombres) ou lorsque le nombre de répétitions est **connu à l'avance**. ##### Fonctionnement 1. La boucle `for` parcourt les éléments d'une séquence un par un. 2. À chaque tour de boucle (itération), une variable prend la valeur de l'élément courant de la séquence. 3. Le bloc d'instructions est exécuté avec cette valeur. 4. La boucle s'arrête après avoir traité tous les éléments de la séquence. ##### Syntaxe en Python ```python for variable in sequence: # Bloc d'instructions à répéter # ... ``` ##### La fonction `range()` Souvent, on veut répéter une action un nombre précis de fois. La fonction `range()` est très utile avec la boucle `for` pour générer une séquence de nombres. * `range(n)` : génère les nombres de 0 à `n-1`. (n itérations) * `range(debut, fin)` : génère les nombres de `debut` à `fin-1`. * `range(debut, fin, pas)` : génère les nombres de `debut` à `fin-1` en avançant par `pas`. #### Boucles imbriquées Il est possible de placer une boucle à l'intérieur d'une autre boucle. On parle alors de **boucles imbriquées**. La boucle interne s'exécute entièrement pour chaque itération de la boucle externe. ### Vocabulaire * **Boucle (Loop)** : Structure de contrôle qui permet de répéter un bloc d'instructions. * **Itération (Iteration)** : Une exécution unique du corps d'une boucle. * **Condition d'arrêt (Termination condition)** : La condition qui doit être remplie pour qu'une boucle `while` s'arrête. * **Compteur (Counter)** : Variable utilisée pour suivre le nombre d'itérations effectuées, souvent dans les boucles `for` ou pour contrôler une boucle `while`. * **Séquence (Sequence)** : Un ensemble ordonné d'éléments sur lequel on peut itérer (ex: chaîne de caractères, liste, `range`). * **Boucle infinie (Infinite loop)** : Une boucle qui ne se termine jamais car sa condition d'arrêt n'est jamais remplie. ### Exemples #### Exemple 1 : Compter de 1 à 5 avec `while` ```python compteur = 1 while compteur <= 5: print(compteur) compteur = compteur + 1 print("Boucle terminée !") ``` **Explication :** La boucle continue tant que `compteur` est inférieur ou égal à 5. À chaque tour, `compteur` est affiché puis augmenté de 1. #### Exemple 2 : Afficher les éléments d'une liste avec `for` ```python fruits = ["pomme", "banane", "cerise"] for fruit in fruits: print(f"J'aime les {fruit}.") ``` **Explication :** La boucle parcourt chaque `fruit` dans la liste `fruits` et affiche une phrase pour chacun. #### Exemple 3 : Compter de 0 à 4 avec `for` et `range()` ```python for i in range(5): # i prendra les valeurs 0, 1, 2, 3, 4 print(f"Numéro : {i}") ``` **Explication :** `range(5)` génère la séquence `0, 1, 2, 3, 4`. La boucle s'exécute 5 fois. #### Exemple 4 : Table de multiplication avec boucles imbriquées ```python for i in range(1, 4): # Pour i de 1 à 3 for j in range(1, 4): # Pour j de 1 à 3 produit = i * j print(f"{i} x {j} = {produit}") ``` **Explication :** La boucle externe parcourt `i` de 1 à 3. Pour chaque valeur de `i`, la boucle interne parcourt `j` de 1 à 3, affichant le produit `i * j`. ### Exercices 1. **Prédiction :** Que va afficher le code suivant ? ```python nombre = 10 while nombre > 0: print(nombre) nombre = nombre - 2 ``` 2. **Écriture de code :** Écrivez une boucle `for` qui affiche tous les nombres pairs de 0 à 10 (inclus). 3. **Écriture de code :** Écrivez une boucle `while` qui demande à l'utilisateur de saisir un mot de passe. La boucle doit continuer tant que le mot de passe saisi n'est pas "secret". Une fois le bon mot de passe saisi, affichez "Accès autorisé !" . ### Devoir 1. **Boucle inversée :** Écrivez un programme qui utilise une boucle `for` et la fonction `range()` pour afficher un compte à rebours de 10 à 0, en affichant "Décollage !" à la fin. 2. **Somme des nombres :** Écrivez un programme qui demande à l'utilisateur un nombre entier `n`. Ensuite, utilisez une boucle `for` pour calculer et afficher la somme de tous les nombres de 1 à `n`. (Par exemple, si `n=3`, la somme est `1+2+3=6`). *Rappel mathématique :* La somme des premiers entiers naturels de 1 à \( n \) peut aussi se calculer avec la formule \[ S = \frac{n(n+1)}{2} \] Comparez votre résultat avec cette formule ! 3. **Carrés parfaits :** Écrivez un programme qui utilise une boucle `while` pour afficher les 5 premiers carrés parfaits (c'est-à-dire `1*1`, `2*2`, `3*3`, `4*4`, `5*5`). ### Résumé Dans cette leçon, nous avons exploré les **structures de contrôle itératives** : les boucles. * La boucle **`while`** répète un bloc d'instructions tant qu'une condition reste vraie. Elle est utile lorsque le nombre d'itérations n'est pas connu à l'avance. * La boucle **`for`** itère sur les éléments d'une séquence (comme une liste ou un `range()`). Elle est souvent utilisée lorsque le nombre d'itérations est prédéfini. * La fonction **`range()`** est essentielle avec `for` pour générer des séquences numériques. * Les **boucles imbriquées** permettent d'exécuter une boucle à l'intérieur d'une autre, ce qui est utile pour des tâches plus complexes comme le traitement de grilles ou de tables. La maîtrise de ces boucles est cruciale pour écrire des algorithmes efficaces et automatiser des tâches répétitives en programmation. ## Organigramme ### Introduction Dans le domaine de l'informatique, les algorithmes sont essentiels pour résoudre des problèmes. Un algorithme est une suite d'instructions claires et précises pour accomplir une tâche. Mais comment représenter ces instructions de manière visuelle et facile à comprendre? C'est là qu'interviennent les organigrammes. Un organigramme est un outil graphique qui permet de visualiser le déroulement d'un algorithme, rendant sa logique plus accessible et simple à suivre. ### Concepts Clés #### Qu'est-ce qu'un Organigramme? Un organigramme est un diagramme qui représente la séquence des opérations, des décisions et du flux de contrôle dans un algorithme ou un processus. Il utilise des symboles standardisés pour illustrer chaque étape. #### Pourquoi utiliser un Organigramme? * **Clarté**: Il rend la logique d'un algorithme plus facile à comprendre. * **Débogage**: Il aide à identifier les erreurs ou les inefficacités avant l'écriture du code. * **Communication**: C'est un excellent outil pour expliquer des processus complexes à d'autres personnes. * **Documentation**: Il sert de documentation visuelle pour un programme. #### Les Symboles Fondamentaux d'un Organigramme Chaque symbole a une signification spécifique: * **Ovale (Terminator)**: * Représente le début (Début) ou la fin (Fin) de l'algorithme. * Contient généralement les mots "Début" ou "Fin". * **Rectangle (Process)**: * Représente une action ou une instruction qui doit être exécutée (un calcul, une affectation de variable, etc.). * Exemples: `x = 5`, `calculer_moyenne`. * **Parallélogramme (Input/Output)**: * Représente les opérations d'entrée (lecture de données) ou de sortie (affichage de résultats). * Exemples: `Lire Nombre`, `Afficher Résultat`. * **Losange (Decision)**: * Représente une condition ou une question à laquelle on répond par "Oui" ou "Non" (Vrai/Faux). * Deux chemins de sortie sont possibles, un pour chaque réponse. * Exemple: `Nombre > 0?` * **Flèche (Flow Line)**: * Indique la direction du flux de l'algorithme, c'est-à-dire l'ordre d'exécution des étapes. * Elles connectent les symboles entre eux. * **Cercle (Connector)**: * Utilisé pour connecter des parties d'un organigramme sur la même page ou entre différentes pages, pour éviter d'avoir de trop longues flèches qui se croisent. #### Règles de Construction d'un Organigramme * Tous les organigrammes doivent commencer par un symbole "Début" et se terminer par un symbole "Fin". * Le flux doit généralement aller du haut vers le bas et de gauche à droite. * Chaque symbole doit contenir une description claire et concise de l'action ou de la décision qu'il représente. * Les losanges (décisions) doivent toujours avoir au moins deux sorties distinctes (par exemple, "Oui" et "Non"). ### Vocabulaire * **Algorithme**: Une série d'étapes ordonnées et non ambiguës pour résoudre un problème. * **Organigramme**: Une représentation graphique d'un algorithme ou d'un processus. * **Symbole Terminal**: Le symbole qui indique le début ou la fin d'un organigramme (ovale). * **Symbole de Processus**: Le symbole qui représente une action ou un calcul (rectangle). * **Symbole d'Entrée/Sortie**: Le symbole qui représente l'acquisition de données ou l'affichage de résultats (parallélogramme). * **Symbole de Décision**: Le symbole qui représente une condition logique à évaluer (losange). * **Flèche de flux**: Ligne qui indique la direction de l'exécution des étapes. ### Exemples #### Exemple 1: Calculer la somme de deux nombres ```mermaid graph TD A[Début] --> B(Lire Nombre1) B --> C(Lire Nombre2) C --> D[Somme = Nombre1 + Nombre2] D --> E(Afficher Somme) E --> F[Fin] ``` #### Exemple 2: Vérifier si un nombre est positif ```mermaid graph TD A[Début] --> B(Lire Nombre) B --> C{Nombre > 0?} C -- Oui --> D[Afficher "Positif"] C -- Non --> E[Afficher "Non positif"] D --> F[Fin] E --> F ``` ### Exercices Dessinez l'organigramme pour les situations suivantes: 1. **Allumer une lampe de chevet**: Imaginez les étapes depuis l'obscurité jusqu'à la lampe allumée. 2. **Déterminer si un élève a réussi un examen**: L'élève réussit si sa note est supérieure ou égale à 10. 3. **Calculer le produit de trois nombres**: Lire trois nombres, calculer leur produit, puis afficher le résultat. ### Devoirs Dessinez l'organigramme pour les situations suivantes: 1. **Préparer une tasse de thé**: Incluez les étapes de la bouilloire à l'ajout de sucre si désiré. 2. **Trouver le plus grand de deux nombres**: Lire deux nombres et afficher celui qui est le plus grand. 3. **Convertir des degrés Celsius en Fahrenheit**: Lisez une température en Celsius et affichez-la en Fahrenheit en utilisant la formule: \[ F = C \times 1.8 + 32 \]. ### Résumé Les organigrammes sont un outil puissant pour la conception et la compréhension des algorithmes. En utilisant des symboles standardisés comme l'ovale pour le début/fin, le rectangle pour les processus, le parallélogramme pour les entrées/sorties et le losange pour les décisions, nous pouvons visualiser le flux logique d'un programme. Ils améliorent la clarté, aident à la détection d'erreurs et facilitent la communication entre les développeurs. Maîtriser les organigrammes est une étape essentielle pour devenir un bon programmeur.