The video is a French‑language instructional lesson on Python’s iterative structures, focusing on the while loop. The instructor begins by distinguishing iterative structures from conditional ones and explains that Python provides two main loop constructs: while and for, with while preferred when the number of repetitions is not known in advance. He then walks through a series of concrete examples: a basic while loop that prints numbers 1‑10, adding a counter and increment to avoid an infinite loop; using an if statement with the modulo operator to print only odd numbers; optimizing the odd‑number loop by incrementing the counter by two; reversing the loop to count down from 10 to 1; demonstrating early termination with the break keyword and discussing where to place break relative to print and increment statements; showing how to build an input‑validation loop with while True and break to ensure a non‑zero divisor before performing division; illustrating the continue keyword to skip a specific iteration (e.g., omitting the number 5) and explaining the pitfalls that can cause an infinite loop if the increment is misplaced, along with the necessary adjustments to the initial value and loop condition; and finally noting that while loops can be nested but for loops are usually preferred for readability. Throughout, the instructor emphasizes common errors such as infinite loops, proper indentation, and the strategic placement of control‑flow statements. The lesson ends with a brief invitation to explore more advanced topics in a later video.
Chapters
Bonjour à tous et bienvenue dans cette nouvelle leçon sur le langage de programmation Python. Aujourd'hui, nous allons voir les structures itératives connues aussi sous le nom de boucles. Dans la vidéo consacrée aux structures conditionnelles, nous avons vu que parfois on est amené à exécuter un traitement ou bloc d'instructions et ignorer un autre bloc, selon la condition énoncée, mais dans tous les cas, le bloc d'instructions en question sera exécuté une seule fois. Or, dans certains problèmes, nous sommes tenus de réexécuter un bloc d'instructions plusieurs fois. Mais au lieu d'écrire le même bloc autant de fois que l'on souhaite qu'il soit exécuté, on va plutôt l'écrire une seule fois, mais on va ordonner au programme de le réexécuter en boucle. D'ailleurs, on appelle ce genre de structures des structures itératives ou des boucles. En Python, il y a 2 boucles principales: la boucle while et la boucle for. Cela ne veut pas dire que ce sont les 2 formes de boucles existantes dans ce langage, mais il en existe d'autres, sauf qu'elles sont dédiées à des cas très particuliers et on aura l'occasion de les traiter plus loin dans ce cours. La boucle While et la boucle For font exactement la même chose: automatiser la répétition d'un bloc d'instructions un certain nombre de fois. Dans mon cours d'algorithmique, j'ai consacré des leçons à part à chacune de ces boucles-là, et en guise de rappel, on préfère souvent utiliser la boucle While si le nombre de répétitions, dites itérations, n'est pas connu à l'avance. Alors que la boucle For est préférée si l'on connaît ce nombre-là. Notez bien que j'ai dit on préfère et non pas on doit. Donc, on peut toujours utiliser l'une ou l'autre boucle quel que soit le scénario, sauf que le code sera plus ou moins optimisé selon les cas. Pour ne pas avoir une vidéo trop longue, je vais traiter chacune de ces boucles dans une leçon à part et nous commençons par la boucle While. Imaginez que l'on souhaite écrire une suite de nombres de 1 à 10 à l'aide de la fonction Print. Mais au lieu d'écrire print, print, etc., nous allons plutôt utiliser la boucle While comme ceci: D'abord, il faut initialiser une variable que l'on nommera i à la valeur 1. Une telle variable est appelée le compteur de la boucle, et elle a pour mission de compter combien de fois la boucle a été exécutée. Notez que l'initialisation de la boucle se fait avant d'entrer dans la structure itérative. Maintenant, on va programmer notre boucle qui a la forme suivante: En effet, tant que la condition est vraie, alors le bloc d'instructions appartenant à la boucle sera exécuté. Dans notre cas, nous avons placé la condition i≤ 10, c'est-à-dire tant que i est inférieur ou égal à 10 alors la boucle s'exécutera. On place 2 points comme pour les conditions, puis on retourne à la ligne pour écrire notre bloc d'instructions qui sera indenté de la même façon. Dans la boucle, nous allons placer le traitement souhaité. Dans notre cas, on va juste afficher la variable i. Si on laisse le code comme ça, alors nous allons tomber dans ce que l'on appelle une boucle infinie. Il s'agit d'une erreur de programmation très courante et qui est souvent due au manque d'attention de la part du programmeur. En effet, notre boucle tourne tant que i est inférieur ou égal à 10, ce qui est toujours le cas, car i a été initialisé à 1 au tout début de notre programme. Sauf qu'on n'a jamais changé sa valeur, donc il restera toujours égal à 1 et la condition de la boucle sera toujours vraie, d'où la boucle infinie. Pour que notre code soit correct, nous allons changer la valeur de i de telle sorte à ce que la condition finisse par devenir fausse à un moment donné. On imagine donc que l'on va incrémenter la variable i. La valeur d'incrémentation dépend de ce que vous voulez faire. Souvenez-vous que notre objectif est d'afficher les valeurs 1, 2, 3 jusqu'à 10. Donc nous allons incrémenter i de 1 comme ceci: i= i+ 1 ou tout simplement i+= 1, comme on l'a vu dans la vidéo sur les opérateurs. N'oublie pas qu'il faut placer l'instruction de l'incrémentation dans la boucle. Donc, quand i sera égal à 11, la condition ne sera plus vraie et la boucle s'arrêtera. On dit alors qu'on est sorti de la boucle et on peut par conséquent poursuivre l'exécution du reste des instructions s'il y en a. Imaginez maintenant que l'on veut afficher les nombres impairs compris entre 1 et 10. Notre code deviendra comme ceci: On garde l'initialisation de la variable i ainsi que la condition de la boucle. Dans celle-ci, on va vérifier la parité à l'aide de la condition if comme ceci: if i modulo 2 est différent de 0, c'est-à-dire si i n'est pas divisible par 2, ce qui signifie qu'il est impair, alors dans ce cas on l'affiche. Encore une fois, remarquez l'indentation supplémentaire. L'incrémentation de la variable i sera faite dans tous les cas, donc on la place en dehors de la condition, c'est pour ça qu'elle est indentée au même niveau que if. On peut réussir ce programme autrement. En effet, on sait que i commence à 1, donc le prochain nombre impair est 3, puis 5, etc. C'est-à-dire, au lieu d'ajouter la condition qui vérifie si i est impair, nous allons juste incrémenter i de 2, comme ceci. De la même façon, si cette fois on veut afficher les nombres dans l'ordre décroissant, c'est-à-dire de 10 à 1, notez qu'on veut afficher tous les nombres et pas que les nombres impairs. Alors nous allons initialiser la variable i à 10, puisque c'est la valeur de départ. Ensuite on spécifie la condition de la boucle While comme ceci: While i supérieur ou égal à 1. On affiche i puis on la décrémente de 1. Dans ce cas, la valeur de i sera réduite de 1 à chaque itération jusqu'à ce qu'elle soit inférieure à 1, ce qui rendra notre condition fausse, donc mettra fin à la boucle. Figurez-vous qu'on peut réussir cet affichage de plusieurs façons différentes. Donc le code proposé n'est qu'un exemple parmi tant d'autres qui auraient donné le même résultat. Reprenons notre premier exemple où l'on affiche les nombres de 1 à 10. Imaginez que l'on souhaite arrêter notre boucle prématurément, c'est-à-dire avant que i n'arrive à la valeur 10. Disons par exemple qu'on veut afficher 5 puis on sort de la boucle. Bien entendu, la méthode la plus simple consiste à changer la condition de la boucle. Au lieu de mettre while i<= 10, on met while i<= 5. Mais l'idée est de laisser la condition telle qu'elle est et on va plutôt arrêter la boucle de l'intérieur quand i atteint la valeur 5. Pour cela, on fait appel au mot-clé Break. Break est une instruction qui s'applique à l'intérieur des boucles et qui interrompt celle-ci quand elle est appelée. Dans notre exemple, nous allons placer la condition: If i= 5 Break. Cela signifie qu'au moment où i atteint la valeur 5, on sort immédiatement de la boucle. Soyez attentifs à l'emplacement où l'on doit mettre ces instructions. Si on veut que la valeur 5 s'affiche aussi, alors on place Break après la fonction Print, mais avant l'instruction de l'incrémentation du compteur i. Et si on veut que la dernière valeur affichée est 4, alors on place Break avant Print. Comme ça, on sort de la boucle avant l'affichage du i courant qui vaut 5. On peut aussi placer Break après l'incrémentation de i. Cela veut dire que la dernière valeur affichée est 4, On incrémente i qui devient 5 et qui correspond à la condition. On exécute break et on quitte la boucle. Donc 5 ne sera pas affiché. Notez que l'utilisation de break est très courante en programmation, pas qu'en Python mais aussi dans d'autres langages de programmation. Son utilisation s'avère utile quand on prévoit de répéter un traitement un certain nombre de fois, mais entre-temps il se peut qu'un événement survienne, ce qui rend inutile de continuer d'exécuter les itérations restantes. Donc on interrompt la boucle à l'aide du mot-clé break. Nous aurons l'occasion de voir ceci dans des exemples par la suite. On peut également changer la condition du dernier code et mettre while True. En effet, la condition de la boucle est toujours vraie, ce qui signifie qu'en temps normal nous aurons une boucle infinie, mais à l'intérieur de la boucle on décide d'interrompre celle-ci en plaçant le mot-clé break. Le cas le plus courant où l'on utilise cette méthode est quand on demande à l'utilisateur de saisir quelque chose. Et on insiste sur le fait qu'il entre une valeur qui correspond à un certain critère. On appelle généralement cette opération filtrage de l'entrée. Cela nous rappelle l'exemple de la division où le diviseur ne doit pas être nul. Modifions cet exemple-là en utilisant While True. Nous commençons par demander la valeur de la variable A qui représente le dividende. Ce nombre peut être nul, donc nous n'allons pas insister dessus. Ensuite, nous programmons notre boucle avec la condition While True. À l'intérieur de celle-ci, on demande la valeur de la variable B. Puisque B est le diviseur, alors il doit être différent de 0. Donc, si l'utilisateur saisit une valeur non nulle, à ce moment-là on quitte la boucle puis on exécute l'opération de la division. Sinon, alors on retourne dans la boucle et on demande B. Vous constatez que la boucle tournera tant que B est nul, et en plus, on ne sait pas combien de fois l'utilisateur saisira 0, donc on ne peut pas placer la condition qui dépend du compteur de la boucle devant While. C'est pour cette raison que l'on a programmé une boucle infinie qui risque de s'exécuter un grand nombre de fois et elle s'arrête uniquement quand le diviseur renseigné est non nul. Maintenant, imaginez que l'on veut exécuter les itérations de la boucle sauf une. À titre d'exemple, on souhaite afficher les valeurs de 1 à 10 excepté 5. Dans ce cas, on fait appel au mot-clé Continue. L'instruction Continue permet d'interrompre l'itération courante et passer à l'itération suivante immédiatement. Notre code devient comme ceci: Mais attention, en faisant cela, nous tombons dans une boucle infinie. En effet, quand i devient égal à 5, on exécute Continue, donc on passe à l'itération suivante sans exécuter le reste des instructions de la boucle dont l'instruction de l'incrémentation de i, ce qui signifie que i restera bloqué à la valeur 5 et ne changera jamais. Ainsi, la condition i<= 10 de la boucle While sera toujours vraie. On doit donc faire en sorte d'incrémenter i avant d'exécuter Continue. Essayons cette version. Là encore, et bien que la boucle finisse par s'arrêter, on constate que la valeur 5 a été affichée, et c'est normal, car l'instruction d'affichage Print est placée avant l'instruction Continue, ce qui ne sert pratiquement à rien. Donc, on doit plutôt placer Continue entre l'incrémentation et l'affichage. Notez que l'incrémentation doit être placée avant l'affichage. Le problème c'est que i est incrémenté avant qu'il soit affiché, donc la première valeur à afficher est 2 et non pas 1, et la dernière est 11 et non pas 10. Nous allons arranger cela en changeant la valeur d'initialisation de 1 à 0, et la condition de la boucle deviendra i< ou i< 10. Il serait mieux d'essayer tout cela par vous-même pour mieux comprendre la logique derrière. Sinon, vous pouvez toujours faire un saut sur mon cours d'algorithmique consacré exclusivement à la logique de programmation. Notez qu'il est également possible d'imbriquer les boucles While les unes dans les autres, mais ce genre d'imbrication est surtout fait avec la boucle For car sa syntaxe est plus simple et plus lisible que celle de la boucle While. On se contente de ça pour cette leçon. Merci pour votre attention et à la vidéo prochaine.
