Summary  
This chapter covers using Python’s built-in `enumerate()` function to iterate over a sequence while accessing both each element’s index and its value in a loop.

General domain of usage  
Displaying numbered lists (e.g., printing items with their positions)

The `enumerate()` function is incredibly useful when you need to access both the value and its index in a sequence, such as a list or a string. This allows you to work with items while keeping track of their position in the sequence.

In Python, lists are ordered data structures, meaning each item has a unique index. The `enumerate()` function makes it easy to retrieve both the index and the value simultaneously.



The syntax for using `enumerate()` is:

``` python
for index, value in enumerate(sequence):
    # Your code here
```

- `index`: refers to the position of an element in the list. Python uses 0-based indexing, meaning the first element has an index of 0;
- `value`: refers to the actual element at a given index.

Let's apply `enumerate()` to our `travel_list` to print each city along with its index:

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

# Printing all cities with their indexes
for index, city in enumerate(travel_list):
    print(str(index) + ' ' + city)

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 setUp(self):
        try:
            self.user_code = importlib.import_module("user_code")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

    def test_travel_rankings_is_declared(self):
        try:
            _ = self.user_code.travel_rankings
            _dynamic_test(self, True, "The `travel_rankings` list is declared.", "")
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `travel_rankings` to be declared.")

    def test_travel_rankings_is_list(self):
        _dynamic_test(
            self,
            isinstance(self.user_code.travel_rankings, list),
            "`travel_rankings` is a list.",
            "`travel_rankings` must be a list."
        )

    def test_travel_rankings_has_correct_length(self):
        _dynamic_test(
            self,
            len(self.user_code.travel_rankings) == len(self.user_code.countries),
            "`travel_rankings` has the same length as `countries`.",
            f"`travel_rankings` should have {len(self.user_code.countries)} elements, found {len(self.user_code.travel_rankings)}."
        )

    def test_travel_rankings_correct_format(self):
        expected = [f"Destination {i + 1}: {country}" for i, country in enumerate(self.user_code.countries)]
        _dynamic_test(
            self,
            self.user_code.travel_rankings == expected,
            "`travel_rankings` elements follow the correct format.",
            f"`travel_rankings` values incorrect. Expected {expected}, got {self.user_code.travel_rankings}."
        )

    def test_first_and_last_items(self):
        try:
            expected_first = f"Destination 1: {self.user_code.countries[0]}"
            expected_last = f"Destination {len(self.user_code.countries)}: {self.user_code.countries[-1]}"
            actual_first = self.user_code.travel_rankings[0]
            actual_last = self.user_code.travel_rankings[-1]
            _dynamic_test(
                self,
                actual_first == expected_first and actual_last == expected_last,
                "First and last items in `travel_rankings` are correct.",
                f"Expected first: '{expected_first}', got '{actual_first}'. Expected last: '{expected_last}', got '{actual_last}'."
            )
        except IndexError:
            self.fail("`travel_rankings` or `countries` list is empty.")
    def test_travel_rankings_is_declared(self):
        try:
            user_code = importlib.import_module("user_code")
            _ = user_code.travel_rankings
            _dynamic_test(self, True, "The `travel_rankings` list is declared.", "")
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `travel_rankings` to be declared.")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

    def test_travel_rankings_contains_correct_values(self):
        try:
            user_code = importlib.import_module("user_code")
            expected_rankings = [f"Destination {index + 1}: {country}" for index, country in enumerate(user_code.countries)]
            _dynamic_test(
                self,
                user_code.travel_rankings == expected_rankings,
                "The `travel_rankings` list contains the correct formatted values.",
                f"Expected `travel_rankings` to be `{expected_rankings}`, but got `{user_code.travel_rankings}`."
            )
        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!

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.

The enumerate() Function

Solution

Awesome!

The enumerate() Function

Solution

Awesome!