Summary  
This chapter explains how the break and continue statements control the flow inside nested loops: break immediately exits the inner loop when a condition is met, while continue skips the rest of the current inner iteration and moves to the next one without affecting the outer loop.

General domain of usage  
Processing travel expense data

Watch this video for a visual walkthrough of how `break` and `continue` work inside nested loops in Python. You'll see step-by-step demonstrations using real travel expense data, showing how to efficiently filter and process lists with these control statements. This will help you understand exactly when and why to use `break` and `continue` to control the flow of your nested loops. All the diagrams should be small and horizontal

Appliquons les concepts de `break` et `continue` pour analyser les coûts de voyage de manière pratique. Nous allons combiner une boucle `while` et une boucle `for` afin de traiter les dépenses de plusieurs voyages.

Imaginez que vous avez plusieurs voyages, et que chaque voyage possède une liste de dépenses. Si une dépense dépasse un certain seuil budgétaire, nous arrêterons immédiatement le traitement de ce voyage.

# List of trips with their respective expenses
travel_costs = [
    [100, 150, 300, 50],   # Trip 1
    [200, 500, 100, 80],   # Trip 2
    [120, 180, 400, 150]   # Trip 3
]

# Budget threshold
budget = 200

# Outer while loop to iterate through trips
i = 0
while i < len(travel_costs):
    print(f"Processing expenses for Trip {i + 1}:")
    
    # Inner for loop to iterate through expenses
    for cost in travel_costs[i]:
        # If expense exceeds the budget
        if cost > budget:  
            print('Expense', cost, 'exceeds the budget. Stopping this trip.')
            break
        print('Expense:', cost)
    
    i += 1  # Move to the next trip
    print('')  # Add a new line for readability

- **Boucle extérieure** : parcourt la liste des voyages à l'aide de l'indice `i` ;
- **Boucle intérieure** : traite chaque dépense du voyage en cours ;
- `break` **dans la boucle intérieure** :
si une dépense dépasse le `budget`, l'instruction `break` arrête le traitement des dépenses pour le voyage en cours.

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_significant_expenses_is_declared(self):
        try:
            user_code = importlib.import_module("user_code")
            _ = user_code.significant_expenses
            _dynamic_test(self, True, "The `significant_expenses` list is declared.", "")
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `significant_expenses` to be declared.")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

    def test_significant_expenses_correct_values(self):
        try:
            user_code = importlib.import_module("user_code")
            expected_expenses = [
                next((cost for cost in trip if cost > 200), None)
                for trip in user_code.travel_costs
            ]
            _dynamic_test(
                self,
                user_code.significant_expenses == expected_expenses,
                "The `significant_expenses` list contains correctly identified values.",
                f"Expected `significant_expenses` to be `{expected_expenses}`, but got `{user_code.significant_expenses}`."
            )
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `significant_expenses` 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.

Break/Continue dans une Boucle Imbriquée

Solution