Summary  
This chapter explains nested loops: using a loop inside another loop to iterate through multiple sequences or dimensions, enabling you to print every combination of elements (for example, pairing each item in one list with every item in another) or traverse lists of lists.  

General domain of usage  
Inventory management

Geneste lussen **vergroten de mogelijkheden van eenvoudige lussen** door het uitvoeren van herhaalde acties **over meerdere dimensies** mogelijk te maken. Dit is essentieel voor het afhandelen van complexere taken in een supermarkt, zoals het organiseren van **gelaagde voorraadgegevens** of het coördineren van roosters tussen verschillende afdelingen.

Bekijk hoe Alex laat zien hoe geneste lussen kunnen worden ingezet om de efficiëntie te verhogen en complexe scenario's in onze supermarkt te beheren:


Geneste lussen zijn **uitermate handig** in programmeren wanneer je **door meerdere reeksen tegelijk moet lopen**. Door een lus binnen een andere te plaatsen, kun je over elementen in twee of meer dimensies itereren, zoals bij een lijst van lijsten:


# List of lists representing stock in different departments
department_stocks = [
    ["Apples", "Bananas", "Cherries"],  # Fruits
    ["Milk", "Cheese", "Butter"],       # Dairy
    ["Bread", "Bagels", "Muffins"]      # Bakery
]

print("Inventory Check:")
for department in department_stocks:
    print(department) # For each iteration of the outer loop, the entire sublist is accessed
    # The inner loop then iterates over the items in that sublist
    for item in department:
        print(f" - {item}")
    print("")  # Add a line break for clarity

Let op hoe de **buitenste lus door elke sublijst** in `department_stocks` loopt, waarbij elke sublijst een andere afdeling vertegenwoordigt. De **binnenste lus doorloopt vervolgens alle items** binnen elke sublijst. De buitenste lus gaat pas naar de volgende sublijst wanneer de binnenste lus klaar is met het doorlopen van alle items in de huidige sublijst.


import unittest
import importlib
import io
from contextlib import redirect_stdout

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 TestSimpleNestedLists(unittest.TestCase):
    def test_groceries_structure(self):
        import user_code
        importlib.reload(user_code)
        groceries = getattr(user_code, 'groceries', None)
        expected = [["Tomatoes", "Lettuce"], ["Milk", "Cheese"]]
        _dynamic_test(
            self,
            groceries == expected,
            "groceries is correctly combined",
            f"Expected groceries = {expected}, but got {groceries}"
        )
        
    def test_output_items(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = f.getvalue().strip().splitlines()
        expected = ["Tomatoes", "Lettuce", "Milk", "Cheese"]
        found_all = all(any(word in line for line in output) for word in expected)
        _dynamic_test(
            self,
            found_all,
            "All expected item names are present in the output lines",
            f"Not all expected item names found in output lines. Expected words: {expected}, got lines: {output}"
        )
         
    def test_nested_loops_used(self):
        import user_code
        import inspect
        source = inspect.getsource(user_code)
        for_count = source.count('for')
        _dynamic_test(
            self,
            for_count >= 2,
            "At least two for loops (nested) are used in the code",
            f"Expected at least two for loops, found {for_count}"
        )
if __name__ == '__main__':
    unittest.main()


test_main.py

Python is een high-level, geïnterpreteerde, general-purpose programmeertaal. In tegenstelling tot talen zoals HTML, CSS en JavaScript, die voornamelijk worden gebruikt voor webontwikkeling, onderscheidt Python zich door zijn veelzijdigheid in meerdere domeinen, waaronder softwareontwikkeling, data science en back-end ontwikkeling. Deze cursus leidt je door de fundamentele concepten van Python en voorziet je van de vaardigheden om aan het einde van het programma je eigen functies te creëren.

In deze sectie maak je kennis met de basisprincipes van Python, raak je vertrouwd met je werkomgeving, voer je eenvoudige wiskundige bewerkingen uit en toon je je bevindingen.

In deze sectie ontdekt u hoe u items zoals getallen en tekst in het computergeheugen kunt opslaan en deze kunt ophalen via hun naam. Daarnaast krijgt u een introductie tot tekstmanipulatie in Python.

In deze sectie maak je kennis met het booleaanse gegevenstype en leer je hoe dit wordt gebruikt om programma's te ontwikkelen die reageren op bepaalde voorwaarden.

In deze sectie leert u verder over gegevenstypen en ontdekt u hoe u verschillende attributen in één variabele kunt organiseren met behulp van lijsten, tuples en woordenboeken.

In deze sectie leert u hoe u lussen maakt in Python — een essentiële vaardigheid voor het itereren door lijsten, tuples en woordenboeken.

Ter afsluiting van deze inleidende cursus maak je kennis met enkele ingebouwde functies en begin je met het ontwikkelen van eigen functies.

Geneste Lussen

Oplossing