Summary  
This chapter demonstrates how break exits a while loop immediately, continue skips to the next iteration, and pass serves as a no-op placeholder to control loop execution flow.

General domain of usage  
Iterating over a list to search for or count specific items.

Watch this video for a clear explanation and live demonstration of using break, continue, and pass statements in Python while loops. See how each control statement affects loop behavior and learn practical techniques for managing loop execution in real-world scenarios.

Les instructions `break` et `continue` sont des outils puissants pour contrôler le flux d'une boucle `while` :

- `break` : quitte immédiatement la boucle lorsqu'une condition spécifique est remplie ;
- `continue` : ignore le reste de l'itération en cours et passe à la suivante.

De plus, l'instruction `pass` est utilisée comme un espace réservé et n'effectue aucune action lorsqu'elle est exécutée, ce qui peut être utile pour une logique incomplète ou pour éviter des erreurs dans des blocs vides.

Utilisation d'une boucle while pour rechercher une ville spécifique dans la `travel_list`. Si la ville est trouvée, la boucle se termine avec `break`.

travel_list = ['Monako', 'Luxemburg', 'Liverpool', 'Barcelona', 'Munchen']

# Initialize the index
i = 0

# Search for "Barcelona"
while i < len(travel_list):
    if travel_list[i] == 'Barcelona':
        print('Found Barcelona!')
        break
    print(travel_list[i])
    i += 1

- L'index `i` commence à `0`, pointant vers la première ville de la liste ;
- La boucle `while` continue tant que `i` est inférieur à la longueur de `travel_list` ;
- Si la ville courante est `"Barcelona"`, le message est affiché et la boucle se termine avec `break` ; `"Munchen"` n'est alors jamais atteinte par la boucle ;
- Si `"Barcelona"` n'est pas trouvée, la ville courante est affichée et `i` est incrémenté pour passer à la ville suivante.  

Comptage du nombre d'occurrences de `"Barcelona"` dans `travel_list`, en sautant les villes qui ne correspondent pas à l'aide de `continue`.

travel_list = ['Monako', 'Barcelona', 'Liverpool', 'Barcelona', 'Munchen', 'Barcelona']

# Initialize variables
i = 0
counter = 0

# Count occurrences of "Barcelona"
while i < len(travel_list):
    if travel_list[i] != 'Barcelona':
        i += 1
        continue
    else:
        counter += 1
    i += 1

print('Total occurrences of Barcelona:', counter)

- L'index `i` commence à 0, et `counter` est initialisé à 0 pour compter les occurrences de `'Barcelona'` ;  
- La boucle `while` s'exécute tant que `i` est inférieur à la longueur de `travel_list` ; 
- Si la ville courante n'est pas `'Barcelona'`, la boucle passe à l'itération suivante grâce à `continue` et incrémente `i` ;
- Pour chaque occurrence de `'Barcelona'`, `counter` est incrémenté, et la boucle continue jusqu'à ce que toutes les villes soient vérifiées.  

import unittest
import importlib

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):

    def test_selected_is_declared(self):
        try:
            user_code = importlib.import_module("user_code")
            _ = user_code.selected
            _dynamic_test(self, True, "The `selected` list is declared.", "")
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `selected` to be declared.")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

    def test_selected_contains_correct_values(self):
        try:
            user_code = importlib.import_module("user_code")
            expected_selected = [country for country in user_code.countries if country.startswith("S")][:3]
            _dynamic_test(
                self,
                user_code.selected == expected_selected,
                "The `selected` list contains the first 3 valid countries.",
                f"Expected `selected` to be `{expected_selected}`, but got `{user_code.selected}`."
            )
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `selected` to be declared.")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

if __name__ == "__main__":
    unittest.main()

test_main.py

Renforcez votre confiance dans la maîtrise des boucles Python ! Commencez par les bases des boucles for et while, puis progressez vers des concepts avancés tels que les boucles imbriquées, les instructions de contrôle et les conditions dynamiques. Grâce à des exercices pratiques et des exemples concrets, acquérez les compétences nécessaires pour écrire un code efficace, clair et performant. Idéal pour les débutants et toute personne souhaitant perfectionner son expertise en Python !

Maîtrisez l'itération à travers des séquences avec la boucle for, l'utilisation efficace de range(), l'exploration des conditions avec if/else, et le contrôle des boucles avec break et continue. Préparez-vous à écrire un code efficace, clair et pratique en relevant des défis ludiques.

Acquérez une expérience pratique avec la boucle while.
Apprenez à gérer les conditions, à éviter les boucles infinies, à contrôler le flux avec break et continue, et à combiner else avec vos boucles.
Maîtrisez l'utilisation efficace des boucles while dans des scénarios réels et développez vos compétences en résolution de problèmes.

Apprenez à combiner efficacement les boucles, à utiliser les conditions if/else et à maîtriser les instructions break et continue pour contrôler le flux d'exécution. À la fin, vous serez capable de résoudre des problèmes complexes avec aisance et précision.

Optimisez votre code Python avec les compréhensions de listes et de dictionnaires. Apprenez à créer des listes et des dictionnaires de manière concise et élégante tout en améliorant la lisibilité et les performances. Maîtrisez des exemples pratiques et découvrez comment simplifier des tâches complexes, du filtrage à la transformation des données, le tout en une seule ligne de code.

Instructions de Contrôle de Boucle dans une Boucle While

Solution