Summary  
This chapter demonstrates how to use the range() function to control index-based loops by specifying start, end, and step values, enabling both forward and reverse traversal of sequences.

General domain of usage  
List iteration and processing

Imagine you have a list of travel destinations and you want to work with only a specific part of it. For example, you might want to visit just the first three cities or print destinations in reverse order. Python's `range()` function can help you iterate over the **indices** of the list easily!

- The `range()` function is useful when working with list indices;
- It allows you to control the **start**, **end**, and **step** of iteration;
- Instead of iterating directly over the items, you iterate over the positions of items in a sequence.

The format of the `range()` function is:

``` python
range(start, end, step)
```

- `start`: the starting index of the range (default is **0** if omitted);
- `end`: the ending index (**exclusive**);
- `step`: the increment between indices (default is **1**).

Suppose we have a list of cities we want to visit. Let's print the first **three** destinations using `range()`:

# List of travel destinations
travel_list = ['Monako', 'Luxemburg', 'Liverpool', 'Barcelona', 'Munchen']

# Printing the first three destinations
for i in range(3):
    print(i, ':', travel_list[i])

- `range(3)` generates numbers from `0` to `2` (end value `3` is **exclusive**);
- Inside the loop, `travel_list[i]` accesses the destination at index `i`.

Let's print the travel destinations in reverse order:

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

# Printing travel destinations in reverse
# Start at last index, end at -1, step -1
for i in range(len(travel_list) - 1, -1, -1): 
    print(i, ':', travel_list[i])

- `len(travel_list)` calculates the number of items in the list (**5** in this case).  
- `range(len(travel_list) - 1, -1, -1)` generates indices from **4** to **0**, allowing iteration in reverse order.  
- The loop prints each index and its corresponding destination from `travel_list`, displaying the locations in reverse.

Often, we don't know the length of a list in advance. To handle this, we calculate the length of the list using the `len()` function.
<br><br>Since Python's list indexing starts at `0`, the last element's index is always `len(list) - 1`. For example, if a list has 5 elements, the last element is at index `4` (not 5).

Note

import unittest
import importlib

# Helper function to dynamically generate test names and assertions
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)

EXPECTED_COUNTRIES = [
    'Wales', 'Denmark', 'Belgium', 'Japan', 'South Korea', 'South Africa', 'Indonesia',
    'Singapore', 'Australia', 'India', 'Saudi Arabia', 'Mexico', 'Turkey', 'Greece',
    'Netherlands', 'Finland', 'Monako', 'United Arab Emirates', 'Egypt', 'Morocco',
    'Brazil', 'Argentina', 'Ireland', 'Portugal', 'Chile', 'Spain', 'Czech Republic',
    'Sweden', 'Switzerland', 'Thailand', 'Luxemburg', 'New Zealand', 'France', 'Italy',
    'Germany', 'China', 'Canada', 'Hungary', 'Scotland', 'Norway', 'Austria', 'Ukraine',
    'Poland'
]

class TestUserCode(unittest.TestCase):

    def test_your_travel_list_is_declared(self):
        try:
            user_code = importlib.import_module("user_code")
            _ = user_code.your_travel_list
            _dynamic_test(self, True, "The `your_travel_list` variable is declared.", "")
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `your_travel_list` to be declared.")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

    def test_your_travel_list_is_list(self):
        try:
            user_code = importlib.import_module("user_code")
            _dynamic_test(
                self,
                isinstance(user_code.your_travel_list, list),
                "The `your_travel_list` is of type `list`.",
                "Expected `your_travel_list` to be of type `list`."
            )
        except AttributeError:
            _dynamic_test(self, False, "", "The `your_travel_list` variable is not declared.")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

    def test_countries_list_is_declared(self):
        try:
            user_code = importlib.import_module("user_code")
            _ = user_code.countries
            _dynamic_test(self, True, "The `countries` variable is declared.", "")
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `countries` to be declared.")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

    def test_countries_list_matches_expected(self):
        try:
            user_code = importlib.import_module("user_code")
            _dynamic_test(
                self,
                user_code.countries == EXPECTED_COUNTRIES,
                "The `countries` list matches the expected countries.",
                f"Expected `countries` to be `{EXPECTED_COUNTRIES}`, but got `{user_code.countries}`."
            )
        except AttributeError as e:
            _dynamic_test(self, False, "", f"Missing variable: {e}")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

    def test_your_travel_list_contains_every_second_country_starting_from_first(self):
        try:
            user_code = importlib.import_module("user_code")
            expected_travel_list = EXPECTED_COUNTRIES[::2]  # indices 0,2,4,...
            _dynamic_test(
                self,
                user_code.your_travel_list == expected_travel_list,
                "The `your_travel_list` contains every second country starting from the first.",
                f"Expected `your_travel_list` to be `{expected_travel_list}`, but got `{user_code.your_travel_list}`."
            )
        except AttributeError as e:
            _dynamic_test(self, False, "", f"Missing variable: {e}")
        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!

Iterating with range() Function

解答