Summary  
Nested loops let you run a loop inside another to iterate over multiple sequences or dimensions, enabling you to process each element of an inner collection for every element of an outer collection.

General domain of usage  
Inventory management

Nested loops **extend the power of simple loops** by allowing you to perform repeated actions **across multiple dimensions**. This is crucial for handling more complex tasks in a grocery store environment, such as organizing **multi-layered inventory data** or coordinating schedules across different departments.

Watch as Alex showcases how nested loops can be utilized to enhance efficiency and manage complex scenarios in our grocery store setting:


Nested loops are **incredibly useful** in programming when you need to **loop through multiple sequences** at the same time. By placing one loop inside another, you can iterate over elements in two or more dimensions, such as a list of lists: 


# 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

Notice how the **outer loop iterates through each sublist** in `department_stocks`, where each sublist represents a different department. The **inner loop then iterates through all the items** within each sublist. The outer loop does not proceed to the next sublist until the inner loop has finished iterating through all items in the current sublist.


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 a high-level, interpreted, general-purpose programming
language. Distinguished from languages such as HTML, CSS, and JavaScript, which are mainly
utilized in web development, Python boasts versatility across multiple domains, including
software development, data science, and back-end development. This course will guide you
through Python's fundamental concepts, equipping you with the skills to create your own
functions by the conclusion of the program.

In this section, you will explore the fundamentals of Python, get acquainted
with your workspace, perform simple math operations, and display your findings.

In this section, you'll discover how to save items such as numbers and text
in computer memory and retrieve them by name. Additionally, you'll gain an introduction to text
manipulation in Python.

In this section, you'll explore the boolean data type and learn how it is used
to develop programs that react to certain conditions.

In this section, you will continue learning about data types and discover
how to organize various attributes in a single variable using lists, tuples, and dictionaries.

In this section, you'll learn how to create loops in Python — an essential skill
for iterating through lists, tuples, and dictionaries.

To conclude this introductory course, you will explore some built-in
functions and then begin to develop your own!

Nested Loops

解答