Summary  
This chapter covers using while loops for indefinite iteration by repeatedly executing a code block while a boolean condition remains True, and updating a counter or state variable within the loop to eventually make the condition False and stop the loop.

General domain of usage  
Processing a customer queue at a grocery store checkout

`while` loops are the key tool for handling **indefinite iteration**, which is useful in scenarios where the **number of iterations isn't known in advance**, like monitoring inventory levels **until** they meet a specific threshold.

Watch as Alex demonstrates how to use `while` loops to handle dynamic situations:

A `while` loop in Python continuously **runs a block of code** as long as a specified condition remains `True`.

### Syntax
To start a `while` loop, you define a **counter variable** and follow it with the `while` keyword and a **boolean condition**. The condition is followed by a colon `:`, which **indicates the start of the loop's code block**. 

A simple syntax looks like this: 


counter = 1
while counter <= 3:
    print(counter)
    counter += 1

The loop will execute repeatedly **until the condition becomes** `False`. Typically, the counter variable is updated **inside the loop** to eventually make the condition `False` and stop the loop.

Take this `while` loop for example:


# Handling a queue at a grocery store checkout
queue_length = 5  # Initial number of people in the queue
while queue_length > 0:  # Start the `while` loop as long as the queue isn't empty
    print(f"Current queue size: {queue_length}")
    
    # Simulate serving a customer
    print("Serving the next customer...")
    
    # Decrease the queue length by 1 as a customer leaves
    # The `-=` operator is a shortcut for `queue_length = queue_length - 1`
    queue_length -= 1

In this example, `queue_length` acts as our **counter variable**, starting at `5`. With each loop iteration, the value of `queue_length` decreases by `1` until it reaches `0`. At that point, the loop ends because the condition `0 > 0` evaluates to `False`.

It is crucial to **update the counter variable inside the loop** to eventually **meet the condition for stopping the loop**. Without this, the loop will run **infinitely**, preventing any further code from executing.

Note

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_stock_reaches_or_exceeds_goal(self):
        import user_code
        importlib.reload(user_code)
        stock = getattr(user_code, 'stock', None)
        restock_goal = getattr(user_code, 'restock_goal', None)
        _dynamic_test(
            self,
            isinstance(stock, int) and isinstance(restock_goal, int) and stock >= restock_goal,
            "Final stock is at least restock_goal",
            f"Expected stock >= restock_goal ({restock_goal}), got {stock}",
        )

    def test_stock_value_correct(self):
        import user_code
        importlib.reload(user_code)
        stock = getattr(user_code, 'stock', None)
        _dynamic_test(
            self,
            stock == 20,
            "Stock is correctly updated to 20",
            f"Expected stock to be 20, got {stock}",
        )

    def test_output_messages(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            normalize_text("Restocking complete!") in output,
            "Output contains 'Restocking complete!' message",
            f"Expected message 'Restocking complete!' not found in output: {output}",
        )
        _dynamic_test(
            self,
            normalize_text("20") in output,
            "Output contains the final stock value (20)",
            f"Expected final stock value '20' not found in output: {output}",
        )


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

Syntax

解答