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

Laten we de concepten `break` en `continue` toepassen om reiskosten praktisch te analyseren. We combineren een `while`-lus en een `for`-lus om uitgaven over meerdere reizen te verwerken.

Stel je voor dat je meerdere reizen hebt en elke reis een lijst met uitgaven bevat. Als een uitgave een specifieke budgetdrempel overschrijdt, stoppen we direct met het verwerken van die reis.

# 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

- **Buitenste lus**: doorloopt de lijst met reizen met behulp van de index `i`;
- **Binnenste lus**: verwerkt elke uitgave in de huidige reis;
- `break` **in de binnenste lus**:
indien een uitgave het `budget` overschrijdt, stopt de `break`-instructie direct met het verwerken van uitgaven voor de huidige reis.

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

Bouw vertrouwen op in het beheersen van Python-lussen! Begin met de basis van for- en while-lussen en ga verder naar geavanceerde concepten zoals geneste lussen, controleverklaringen en dynamische voorwaarden. Met praktische oefeningen en voorbeelden uit de echte wereld, verwerf je de vaardigheden om efficiënte, schone en krachtige code te schrijven. Perfect voor beginners en iedereen die zijn Python-expertise wil aanscherpen!

Beheers hoe je door reeksen kunt itereren met de for-lus, gebruik range() effectief, verken voorwaarden met if/else, en beheer lussen met break en continue. Maak je klaar om efficiënte, schone en praktische code te schrijven terwijl je leuke uitdagingen aangaat!

Doe praktische ervaring op met de while-lus! Leer hoe je voorwaarden kunt afhandelen, oneindige lussen kunt vermijden, de stroom kunt regelen met break en continue, en zelfs else kunt combineren met je lussen. Beheers wanneer je while-lussen effectief kunt gebruiken in real-world scenario's en verscherp je probleemoplossende vaardigheden!

Leer hoe je lussen effectief kunt combineren, gebruik if/else-voorwaarden, en beheers break- en continue-instructies om de stroom te controleren. Aan het einde kun je complexe problemen met gemak en precisie oplossen.

Vereenvoudig je Python-code met lijst- en woordenboekbegrip! Leer hoe je lijsten en woordenboeken op een beknopte en elegante manier kunt maken, terwijl je de leesbaarheid en prestaties verbetert. Beheers praktische voorbeelden en ontdek hoe je complexe taken kunt vereenvoudigen, van het filteren van gegevens tot het transformeren ervan, allemaal in één regel code.

Break/Ga Door in een Geneste Lus

Oplossing