Summary  
This chapter covers how to use while loops with counters and boolean flags to repeatedly update variables until a threshold condition is met, and then printing the result once the loop terminates.

General domain of usage  
Inventory management

## Example Application

Imagine **you're managing the milk stock in a grocery store**. You need to ensure the stock doesn't drop below a certain level, and when it does, you should restock to maintain the stock level.

A `while` loop is useful in this situation because it allows you to restock milk **in increments over several iterations until the stock reaches the desired level**. Without a `while` loop, you'd need to calculate the exact amount of milk to restock all at once.

For instance, consider that a store worker **can only restock a fixed amount of milk in one trip** (e.g., `20` packs per restock). If the stock isn't fully replenished, the worker returns to the warehouse to bring another batch of milk.

# Initial amount of milk in stock
milk_stock = 15
# Minimum stock level before restocking is necessary
min_stock = 50
# Quantity a worker can restock at one time
restock_quantity = 20

# Start the loop to restock milk until the stock exceeds the minimum required level
while milk_stock < min_stock:
    # If the loop is running, the condition is `True`, indicating we need more milk
    print(f"Milk stock is low: {milk_stock} units remaining.")
    # Simulate the process of restocking milk
    print("Restocking milk...")
    # Increase the stock by the quantity the worker can bring in one trip
    milk_stock += restock_quantity
    
# Output the final stock level after restocking is complete
print(f"Milk stock updated: {milk_stock} units, which is now sufficient.")

`milk_stock += restock_quantity` is equivalent to `milk_stock = milk_stock + restock_quantity`. It's simply a more concise and readable way to express the same operation.

Note

The flowchart above illustrates the logic behind the `while` loop used for managing the milk inventory. Notice how the counter variable `milk_stock`, starting at `15`, is incremented by the `restock_quantity` with each loop iteration.

The loop keeps running **until** `milk_stock` **surpasses the** `min_stock` **threshold** of `50`, at which point it stops.

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)

def normalize_text(text):
    import re
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

class TestTask(unittest.TestCase):
    def test_final_stock_at_least_minimum(self):
        import user_code
        importlib.reload(user_code)
        apple_stock = getattr(user_code, 'apple_stock', None)
        _dynamic_test(
            self,
            isinstance(apple_stock, int) and apple_stock >= 40,
            "apple_stock is at least 40 after restocking",
            f"Expected apple_stock to be at least 40, got {apple_stock}",
        )
    def test_restocking_message_printed(self):
        import user_code
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        expected = normalize_text("Restocking apples...")
        _dynamic_test(
            self,
            expected in output,
            "Output contains restocking message",
            f"Expected restocking message not found in output: {output}",
        )
    def test_final_stock_printed(self):
        import user_code
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        expected = normalize_text("Apple stock is now: 42 units.")
        expected_alt = normalize_text("Apple stock is now: 40 units.")
        _dynamic_test(
            self,
            expected in output or expected_alt in output,
            "Final apple stock is printed correctly",
            f"Expected final stock message not found in output: {expected}",
        )
    def test_loop_logic(self):
        # Check that apple_stock increases in steps of restock_amount
        import user_code
        importlib.reload(user_code)
        code = ""
        with open("user_code.py", "r") as f:
            code = f.read()
        # Check that while loop and += are present
        _dynamic_test(
            self,
            "while" in code and "+=" in code,
            "Code uses a while loop and += for restocking",
            "Code does not use a while loop and += for restocking",
        )


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!

While Loops Practice

Example Application

解答