Summary  
This chapter covers how to use Python’s built-in enumerate function to iterate over a sequence while automatically retrieving both each element’s index and its value, and demonstrates how to customize the starting index.  

General domain of usage  
Generating numbered lists of items in output.

Get a clear, visual walkthrough of the `enumerate()` function in Python. This video covers what `enumerate()` does, how it works with lists, and why it is useful for accessing both indexes and values in a loop. See the syntax in action, watch a step-by-step example labeling a travel list, and get guidance for completing the hands-on task that follows. Perfect for understanding how to combine indexes and values efficiently in your Python code.

Die Funktion `enumerate()` ist äußerst nützlich, wenn sowohl auf den Wert als auch auf dessen Index in einer Sequenz, wie einer Liste oder einem String, zugegriffen werden muss. Dadurch kann mit Elementen gearbeitet werden, während gleichzeitig deren Position in der Sequenz verfolgt wird.

In Python sind Listen geordnete Datenstrukturen, das heißt, jedes Element besitzt einen eindeutigen Index. Die Funktion `enumerate()` erleichtert das gleichzeitige Abrufen von Index und Wert.



Die Syntax für die Verwendung von `enumerate()` lautet:

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

- `index`: Bezeichnung für die Position eines Elements in der Liste. Python verwendet 0-basierte Indizierung, das bedeutet, das erste Element hat den Index 0;
- `value`: Bezeichnung für das tatsächliche Element an einem bestimmten Index.

Im Folgenden wird `enumerate()` auf die `travel_list` angewendet, um jede Stadt zusammen mit ihrem Index auszugeben:

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

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

Mit `str()` kann eine Zahl in Text umgewandelt werden, bevor sie mit einer Zeichenkette kombiniert wird.

Hinweis

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=3):
    """Show only the first few items of a list."""
    if isinstance(lst, list):
        preview = lst[:max_items]
        return preview + (["..."] if len(lst) > max_items else [])
    return lst

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, "
            f"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.",
            (
                "The numbering or format of destinations seems incorrect. "
                f"Expected first 3 examples: {_short_preview(expected)} "
                f"But your list starts as: {_short_preview(self.user_code.travel_rankings)}. "
                "Hint: Make sure destination numbering starts at 1, not 0."
            )
        )

    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.",
                (
                    "Incorrect numbering or formatting detected at the start or end of the list. "
                    f"Expected first: '{expected_first}', got '{actual_first}'. "
                    f"Expected last: '{expected_last}', got '{actual_last}'. "
                    "Hint: Ensure numbering starts at 1 and increments correctly through the list."
                )
            )
        except IndexError:
            self.fail("`travel_rankings` or `countries` list is empty.")

    def test_travel_rankings_contains_correct_values(self):
        try:
            expected_rankings = [f"Destination {i + 1}: {country}" for i, country in enumerate(self.user_code.countries)]
            _dynamic_test(
                self,
                self.user_code.travel_rankings == expected_rankings,
                "The `travel_rankings` list contains the correct formatted values.",
                (
                    "The list elements do not match the expected pattern. "
                    f"Expected first 3 examples: {_short_preview(expected_rankings)} "
                    f"But your list starts as: {_short_preview(self.user_code.travel_rankings)}. "
                    "Hint: Check your string formatting and numbering."
                )
            )
        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

Stärken Sie Ihr Selbstvertrauen im Umgang mit Python-Schleifen! Beginnen Sie mit den Grundlagen von for- und while-Schleifen und vertiefen Sie Ihr Wissen zu fortgeschrittenen Konzepten wie verschachtelten Schleifen, Kontrollanweisungen und dynamischen Bedingungen. Mit praxisnahen Übungen und Beispielen aus der realen Welt erwerben Sie die Fähigkeiten, effizienten, sauberen und leistungsstarken Code zu schreiben. Ideal für Einsteiger und alle, die ihre Python-Kenntnisse vertiefen möchten!

Beherrschen Sie das Iterieren durch Sequenzen mit der for-Schleife, den effektiven Einsatz von range(), das Anwenden von Bedingungen mit if/else sowie die Steuerung von Schleifen mit break und continue. Bereiten Sie sich darauf vor, effizienten, sauberen und praxisnahen Code zu schreiben, während Sie spannende Herausforderungen meistern.

Praktische Erfahrung mit der while-Schleife. Bedingungen behandeln, Endlosschleifen vermeiden, Steuerfluss mit break und continue kontrollieren sowie else mit Schleifen kombinieren. Effektiver Einsatz von while-Schleifen in realen Szenarien und Verbesserung der Problemlösungsfähigkeiten.

Erfahren Sie, wie Schleifen effektiv kombiniert, if/else-Bedingungen verwendet und break- sowie continue-Anweisungen zur Steuerung des Programmablaufs eingesetzt werden. Am Ende sind Sie in der Lage, komplexe Probleme mit Leichtigkeit und Präzision zu lösen.

Optimierung von Python-Code durch Listen- und Dictionary-Comprehensions. Vermittlung effizienter Methoden zur Erstellung von Listen und Dictionaries in prägnanter und eleganter Form zur Verbesserung von Lesbarkeit und Performance. Beherrschung praxisnaher Beispiele und Vereinfachung komplexer Aufgaben wie Datenfilterung und -transformation in einer einzigen Codezeile.

Die Funktion Enumerate()

Lösung