Summary  
Demonstrates how to control flow in nested loops by using a break statement to exit the inner loop early when a condition is met.

General domain of usage  
Travel expense processing

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 seuil budgétaire spécifique, 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` interrompt 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

Gagnez en confiance dans la maîtrise des boucles Python ! Commencez par les bases des boucles for et while et progressez vers des concepts avancés tels que les boucles imbriquées, les instructions de contrôle et les conditions dynamiques. Avec des exercices pratiques et des exemples concrets, acquérez les compétences pour écrire un code efficace, propre et puissant. Parfait pour les débutants et toute personne souhaitant affiner son expertise en Python !

Maîtrisez l'itération à travers les séquences avec la boucle for, utilisez efficacement range(), explorez les conditions avec if/else, et contrôlez les boucles avec break et continue. Préparez-vous à écrire un code efficace, propre et pratique en relevant des défis amusants !

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 même à combiner else avec vos boucles. Maîtrisez l'utilisation efficace des boucles while dans des scénarios réels et affinez 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. À la fin, vous serez capable de résoudre des problèmes complexes avec aisance et précision.

Rationalisez 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, de la filtration des données à leur transformation, le tout en une seule ligne de code.

Break/Continue dans une Boucle Imbriquée

Solution