Summary  
This chapter covers using `break`, `continue`, and `pass` to control the flow of `while` loops, enabling early exit, skipping iterations, or placeholder logic.  

General domain of usage  
List traversal and element search

The `break` and `continue` statements are powerful tools for controlling the flow of a `while` loop:

- `break`: immediately exits the loop when a specific condition is met;
- `continue`: skips the rest of the current iteration and moves to the next one.

Additionally, the `pass` statement is used as a placeholder and does nothing when executed, which can be useful for incomplete logic or avoiding errors in empty blocks.

Let's use a while loop to search for a specific city in the `travel_list`. If the city is found, the loop will terminate using `break`.

travel_list = ['Monako', 'Luxemburg', 'Liverpool', 'Barcelona', 'Munchen']

# Initialize the index
i = 0

# Search for "Barcelona"
while i < len(travel_list):
    if travel_list[i] == 'Barcelona':
        print('Found Barcelona!')
        break
    print(travel_list[i])
    i += 1

- The index `i` starts at `0`, pointing to the first city in the list;
- The `while` loop continues as long as `i` is less than the length of `travel_list`;
- If the current city is `"Barcelona"`, the message is printed, and the loop exits using `break` and `"Munchen"` is never reached by the loop;
- If `"Barcelona"` is not found, the current city is printed, and `i` is incremented to move to the next city.  

Now, let's count how many times `"Barcelona"` appears in the `travel_list`, skipping cities that don't match using `continue`.

travel_list = ['Monako', 'Barcelona', 'Liverpool', 'Barcelona', 'Munchen', 'Barcelona']

# Initialize variables
i = 0
counter = 0

# Count occurrences of "Barcelona"
while i < len(travel_list):
    if travel_list[i] != 'Barcelona':
        i += 1
        continue
    else:
        counter += 1
    i += 1

print('Total occurrences of Barcelona:', counter)

- The index `i` starts at 0, and `counter` is set to 0 to track occurrences of `'Barcelona'`;  
- The `while` loop runs as long as `i` is less than the length of `travel_list`; 
- If the current city is not `'Barcelona'`, the loop skips the remaining code for that iteration using `continue` and increments `i`;
- For each occurrence of `'Barcelona'`, `counter` is incremented, and the loop continues until all cities are checked.  

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_selected_is_declared(self):
        try:
            user_code = importlib.import_module("user_code")
            _ = user_code.selected
            _dynamic_test(self, True, "The `selected` list is declared.", "")
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `selected` to be declared.")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

    def test_selected_contains_correct_values(self):
        try:
            user_code = importlib.import_module("user_code")
            expected_selected = [country for country in user_code.countries if country.startswith("S")][:3]
            _dynamic_test(
                self,
                user_code.selected == expected_selected,
                "The `selected` list contains the first 3 valid countries.",
                f"Expected `selected` to be `{expected_selected}`, but got `{user_code.selected}`."
            )
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `selected` to be declared.")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

if __name__ == "__main__":
    unittest.main()

test_main.py

Build confidence in mastering Python loops! Start with the basics of for and while loops and progress to advanced concepts like nested loops, control statements, and dynamic conditions. With hands-on practice and real-world examples, gain the skills to write efficient, clean, and powerful code. Perfect for beginners and anyone looking to sharpen their Python expertise!

Master how to iterate through sequences with for loop, use range() effectively, explore conditions with if/else, and control loops with break and continue. Get ready to write efficient, clean, and practical code as you tackle fun challenges!

Get hands-on experience with the while loop! Learn how to handle conditions, avoid infinite loops, control flow with break and continue, and even combine else with your loops. Master when to use while loops effectively in real-world scenarios and sharpen your problem-solving skills!

Learn how to combine loops effectively, use if/else conditions, and master break and continue statements to control flow. By the end, you'll be able to solve complex problems with ease and precision.

Streamline your Python code with list and dictionary comprehensions! Learn how to create lists and dictionaries in a concise and elegant way while improving readability and performance. Master practical examples and discover how to simplify complex tasks, from filtering data to transforming it, all in a single line of code.

Loop Control Statements in a while Loop

Solution