Summary  
This chapter explains how to use the built-in `enumerate()` function to retrieve both an item’s index and its value while iterating over a sequence.

General domain of usage  
Printing numbered lists from a collection.

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 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`: Bezieht sich auf die Position eines Elements in der Liste. Python verwendet 0-basierte Indizierung, das bedeutet, das erste Element hat den Index 0;
- `value`: Bezieht sich auf das tatsächliche Element an einem bestimmten Index.

Wenden wir `enumerate()` auf unsere `travel_list` an, 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 einem String 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

Gewinnen Sie Vertrauen im Umgang mit Python-Schleifen! Beginnen Sie mit den Grundlagen von for- und while-Schleifen und gehen Sie zu fortgeschrittenen Konzepten wie verschachtelten Schleifen, Kontrollanweisungen und dynamischen Bedingungen über. Mit praktischen Übungen und realen Beispielen erwerben Sie die Fähigkeiten, effizienten, sauberen und leistungsstarken Code zu schreiben. Perfekt für Anfänger und alle, die ihre Python-Kenntnisse vertiefen möchten!

Meistern Sie, wie Sie mit der for-Schleife durch Sequenzen iterieren, verwenden Sie range() effektiv, erkunden Sie Bedingungen mit if/else und steuern Sie Schleifen mit break und continue. Machen Sie sich bereit, effizienten, sauberen und praktischen Code zu schreiben, während Sie sich unterhaltsamen Herausforderungen stellen!

Sammeln Sie praktische Erfahrungen mit der while-Schleife! Lernen Sie, wie Sie Bedingungen handhaben, Endlosschleifen vermeiden, den Kontrollfluss mit break und continue steuern und sogar else mit Ihren Schleifen kombinieren. Meistern Sie, wann Sie while-Schleifen effektiv in realen Szenarien einsetzen und schärfen Sie Ihre Problemlösungsfähigkeiten!

Lernen Sie, wie Sie Schleifen effektiv kombinieren, if/else-Bedingungen verwenden und break- und continue-Anweisungen meistern, um den Ablauf zu steuern. Am Ende werden Sie in der Lage sein, komplexe Probleme mit Leichtigkeit und Präzision zu lösen.

Vereinfachen Sie Ihren Python-Code mit Listen- und Wörterbuchverständnissen! Lernen Sie, wie Sie Listen und Wörterbücher auf eine prägnante und elegante Weise erstellen können, während Sie die Lesbarkeit und Leistung verbessern. Meistern Sie praktische Beispiele und entdecken Sie, wie Sie komplexe Aufgaben vereinfachen können, vom Filtern von Daten bis zur Transformation, alles in einer einzigen Codezeile.

Die Funktion Enumerate()

Lösung