Summary  
This chapter explains how to create and work with nested lists in Python, demonstrating how to combine and organize multi-level list structures.  

General domain of usage  
Organizing geographic data (e.g., grouping cities by continent)

Elemente innerhalb einer Liste in Python können ebenfalls Listen sein. Dies wird als "verschachtelte Liste" oder "Listen in Listen" bezeichnet. Verschachtelte Listen sind leistungsfähig bei der Organisation komplexer Datenstrukturen, da Sie mehrstufige Daten innerhalb einer einzigen Liste speichern können.

Beispielsweise kann eine Liste sowohl einzelne Werte als auch weitere Listen als Elemente enthalten. Hier ein einfaches Beispiel:

cities = ["London", ["Paris", "Madrid"], "Rome", ["Bangkok", ["New York", "Los Angeles"]]]

print(cities)

### Verwendung von Variablen für verschachtelte Listen
Dieses Beispiel zeigt eine verschachtelte Liste, in der das zweite und vierte Element ebenfalls Listen sind, wobei das vierte Element sogar eine weitere verschachtelte Liste enthält.

Sie können verschachtelte Listen auch erstellen, indem Sie Listen, die in Variablen gespeichert sind, miteinander verketten. Dies kann dazu beitragen, Ihren Code übersichtlicher zu gestalten. Zum Beispiel:

europe_cities = ["Paris", "Berlin", "Rome"]
asia_cities = ["Tokyo", "Seoul", "Bangkok"]
america_cities = ["New York", "Los Angeles", "Chicago"]

world_cities = [europe_cities, asia_cities, america_cities]

print(world_cities)

Hier definieren wir zunächst drei unabhängige Listen für Städte in Europa, Asien und Amerika. Anschließend kombinieren wir die Listen zu einer einzigen Liste, `world_cities`, die eine verschachtelte Liste bildet.

Das Beispiel zeigt, dass eine verschachtelte Liste eine geeignete Methode ist, um zusammengehörige Daten, wie beispielsweise Städte verschiedener Kontinente, auf natürliche, intuitive und organisierte Weise zu strukturieren.

import unittest
from contextlib import redirect_stdout
import io
import importlib
import user_code

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 test_first_city_list_is_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'first_city'),
            "The `first_city` list is declared.",
            "Expected `first_city` to be declared."
        )

    def test_second_city_list_is_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'second_city'),
            "The `second_city` list is declared.",
            "Expected `second_city` to be declared."
        )

    def test_third_city_list_is_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'third_city'),
            "The `third_city` list is declared.",
            "Expected `third_city` to be declared."
        )

    def test_first_city_of_type_list(self):
        _dynamic_test(
            self,
            isinstance(user_code.first_city, list),
            "The `first_city` is of type `list`.",
            f"Expected `first_city` to be of type `list`, but got {type(user_code.first_city)}."
        )

    def test_second_city_of_type_list(self):
        _dynamic_test(
            self,
            isinstance(user_code.second_city, list),
            "The `second_city` is of type `list`.",
            f"Expected `second_city` to be of type `list`, but got {type(user_code.second_city)}."
        )

    def test_third_city_of_type_list(self):
        _dynamic_test(
            self,
            isinstance(user_code.third_city, list),
            "The `third_city` is of type `list`.",
            f"Expected `third_city` to be of type `list`, but got {type(user_code.third_city)}."
        )

    def test_first_list_element_types(self):
        _dynamic_test(
            self,
            all([isinstance(user_code.first_city[0], str),
                 isinstance(user_code.first_city[1], str),
                 isinstance(user_code.first_city[2], (int, float))]),
            "Elements of `first_city` are of types (str, str, int/float).",
            "Expected elements of `first_city` to be of types (str, str, int/float)."
        )

    def test_second_list_element_types(self):
        _dynamic_test(
            self,
            all([isinstance(user_code.second_city[0], str),
                 isinstance(user_code.second_city[1], str),
                 isinstance(user_code.second_city[2], (int, float))]),
            "Elements of `second_city` are of types (str, str, int/float).",
            "Expected elements of `second_city` to be of types (str, str, int/float)."
        )

    def test_third_list_element_types(self):
        _dynamic_test(
            self,
            all([isinstance(user_code.third_city[0], str),
                 isinstance(user_code.third_city[1], str),
                 isinstance(user_code.third_city[2], (int, float))]),
            "Elements of `third_city` are of types (str, str, int/float).",
            "Expected elements of `third_city` to be of types (str, str, int/float)."
        )

    def test_travel_wishlist_is_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'travel_wishlist'),
            "The `travel_wishlist` is declared.",
            "Expected `travel_wishlist` to be declared."
        )

    def test_travel_wishlist_is_list(self):
        _dynamic_test(
            self,
            isinstance(user_code.travel_wishlist, list),
            "The `travel_wishlist` is of type `list`.",
            f"Expected `travel_wishlist` to be of type `list`, but got {type(user_code.travel_wishlist)}."
        )

    def test_travel_wishlist_contains_nested_lists(self):
        travel_wishlist = user_code.travel_wishlist
        _dynamic_test(
            self,
            len(travel_wishlist) >= 3,
            "The `travel_wishlist` contains at least 3 nested lists.",
            f"Expected `travel_wishlist` to contain at least 3 nested lists, but got {len(travel_wishlist)}."
        )

        for i, sublist in enumerate(travel_wishlist):
            _dynamic_test(
                self,
                isinstance(sublist, list),
                f"Element {i+1} of `travel_wishlist` is a list.",
                f"Expected element {i+1} of `travel_wishlist` to be a list."
            )
            _dynamic_test(
                self,
                len(sublist) == 3,
                f"Nested list {i+1} contains exactly 3 elements.",
                f"Expected nested list {i+1} to contain exactly 3 elements."
            )
            _dynamic_test(
                self,
                all([isinstance(sublist[0], str), isinstance(sublist[1], str), isinstance(sublist[2], (int, float))]),
                f"Nested list {i+1} elements are of types (str, str, int/float).",
                f"Expected elements of nested list {i+1} to be of types (str, str, int/float)."
            )

if __name__ == '__main__':
    unittest.main()

test_main.py

Erkunden Sie die grundlegenden Datenstrukturen der Programmiersprache Python, einschließlich Listen, Dictionaries, Tupel und Sets, und erfahren Sie, wie Sie diese effektiv zur Lösung praxisnaher Programmieraufgaben einsetzen können.

Was ist eine Liste? Eine Liste ist eine geordnete Sammlung, die verändert werden kann. Sie erlaubt außerdem doppelte Elemente.

Was ist ein Dictionary? Ein Dictionary ist eine geordnete, veränderbare Sammlung, die keine doppelten Einträge zulässt. Es besteht aus Schlüssel:Wert-Paaren, die zur Optimierung seiner Struktur verwendet werden.

Was ist ein Tupel? Ein Tupel ist eine geordnete Sammlung, die nicht verändert werden kann. Es kann doppelte Elemente enthalten. Obwohl es einer Liste ähnelt, können die Werte in einem Tupel beliebigen Typs sein und werden durch Ganzzahlen indiziert. Es ist zwar nicht zwingend erforderlich, aber üblich, die Werte eines Tupels in Klammern zu setzen, um sie in Python leichter verständlich zu machen.

Was ist eine Menge? In Python ist eine Menge eine ungeordnete Sammlung, die sowohl iterierbar als auch veränderbar ist und keine doppelten Elemente enthält. Obwohl die Reihenfolge der Elemente in einer Menge nicht festgelegt ist, kann sie verschiedene Elemente umfassen. Ein wesentlicher Vorteil der Verwendung von Mengen gegenüber Listen ist die äußerst effiziente Methode zur Überprüfung, ob ein Element in der Menge vorhanden ist.

Arbeiten mit Verschachtelten Listen in Python

Verwendung von Variablen für verschachtelte Listen

Lösung