Summary  
This chapter covers loop control statements—break to exit loops early, continue to skip specific iterations, and pass as a no-op placeholder—to manage iteration flow.

General domain of usage  
Iterating over collections for searching and filtering data

When working with loops, the **break** and **continue** statements help manage the flow of iteration:

- `break`: exits the loop prematurely when a condition is met;
- `continue`: skips the current iteration and moves to the next one, allowing selective execution;
- `pass`: is a placeholder that does nothing when executed.



### Using `break` Keyword

Imagine searching for a specific city in a list. If we want to stop searching as soon as we find the city `"Barcelona"`, we can use the `break` statement.

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

# Searching for a specific city
for city in travel_list:
    if city == 'Barcelona':
        print('Found Barcelona!')
        break
    else:
        print(city, 'is not Barcelona')

- The loop iterates through each city in the `travel_list`;
- When it encounters `"Barcelona"`, the `break` statement is executed, and the loop stops immediately;
- Cities after `"Barcelona"` (like `"Munchen"`) are not processed.

### Using `continue` Keyword
Let's now count the cities in the `travel_list` that have names shorter than 8 characters while skipping others.

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

short_name_count = 0

for city in travel_list:
    if len(city) >= 8:
        continue  # Skip cities with names 8 or more characters long
    short_name_count += 1

print('Number of cities with names shorter than 8 characters:',  short_name_count)

- The loop iterates through each city in the `travel_list`;  
- If the length of the city's name is **8 characters or more**, the `if` condition evaluates to `True`, and the `continue` statement is executed. This skips the rest of the code for that iteration;  
- For cities with names **shorter than 8 characters**, the counter `short_name_count` is incremented by 1;  
- After the loop finishes, the final count is printed, showing how many cities have names shorter than 8 characters.

### The `pass` Keyword

The pass statement in Python is a placeholder that does nothing when executed. It's often used as a temporary placeholder for code you plan to write later, allowing the program to run without errors. Later, you can replace `pass` with actual logic.

travel_list = ['Monaco', 'Luxembourg', 'Liverpool', 'Barcelona', 'Munich']
already_visited = ['Barcelona', 'Monaco']

for city in travel_list:
    if city in already_visited:
        pass
    else:
        print('Going to visit', city)

To check if an element is present in a list, you can use the `in` keyword. This checks if the element exists in the list and returns a boolean value (`True` if found, `False` if not).

Note

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)

def _short_preview(lst, max_items=5):
    if isinstance(lst, list):
        preview = lst[:max_items]
        return preview + (["..."] if len(lst) > max_items else [])
    return lst

# Cities that must NOT be inside countries
FORBIDDEN_CITIES = {"Barcelona", "Tokyo", "Paris", "Liverpool", "New York", "Munchen"}

EXPECTED_VISA_REQUIRED = [
    'China', 'India', 'Saudi Arabia', 'Brazil',
    'United Arab Emirates', 'Egypt'
]

class TestUserCode(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.user_code = importlib.import_module("user_code")

    def test_countries_is_list(self):
        _dynamic_test(
            self,
            hasattr(self.user_code, "countries") and isinstance(self.user_code.countries, list),
            "The `countries` variable is declared and is a list.",
            "Expected `countries` to be declared and be a list."
        )

    def test_countries_contains_no_cities(self):
        countries = getattr(self.user_code, "countries", [])
        found = [x for x in countries if x in FORBIDDEN_CITIES]
        _dynamic_test(
            self,
            len(found) == 0,
            "The `countries` list contains no city names.",
            f"Remove city names from `countries`: {found}."
        )

    def test_travel_list_is_list(self):
        _dynamic_test(
            self,
            hasattr(self.user_code, "travel_list") and isinstance(self.user_code.travel_list, list),
            "The `travel_list` is declared and is of type `list`.",
            "Expected `travel_list` to be declared and be of type `list`."
        )

    def test_travel_list_limit(self):
        _dynamic_test(
            self,
            len(self.user_code.travel_list) <= 10,
            "The `travel_list` contains no more than 10 destinations.",
            f"The `travel_list` should include at most 10 destinations, but it has {len(self.user_code.travel_list)}."
        )

    def test_travel_list_contains_correct_countries(self):
        # Build expected using the user's countries (after validation), excluding visa_required, then take first 10.
        countries = getattr(self.user_code, "countries", [])
        visa_required = getattr(self.user_code, "visa_required", [])

        expected_travel_list = [c for c in countries if c not in visa_required][:10]
        actual = getattr(self.user_code, "travel_list", [])

        if actual == expected_travel_list:
            _dynamic_test(self, True, "The `travel_list` contains the correct visa-free destinations.", "")
        else:
            missing = [c for c in expected_travel_list if c not in actual]
            extra = [c for c in actual if c not in expected_travel_list]
            _dynamic_test(
                self,
                False,
                "",
                "The `travel_list` does not match expected visa-free destinations. "
                f"Expected first items: {_short_preview(expected_travel_list)} "
                f"Got first items: {_short_preview(actual)}. "
                f"Missing: {missing} Unexpected: {extra}"
            )

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

Using `break` Keyword

Using `continue` Keyword

The `pass` Keyword

Solution

Loop Control Statements

Using break Keyword

Using continue Keyword

The pass Keyword

Solution

Using `break` Keyword

Using `continue` Keyword

The `pass` Keyword