Summary  
This chapter explains nested for loops, showing how an inner loop executes fully for each iteration of its outer loop and enabling traversal of structured or multidimensional data.

General domain of usage  
Working with multidimensional data structures such as grids or matrices.

Watch this video for a clear visual explanation of how nested for loops work in Python. You'll see step-by-step demonstrations of how the outer and inner loops interact, how data is processed in a structured format, and practical examples like printing triangle patterns and iterating through nested lists. This visual guide will help you understand the flow and logic behind nested for loops so you can confidently apply them to your own Python projects. The visual guide should be presented horizontally and distance between blocks should be small. Each example should be short and the output should be shown on the right.

Eine **verschachtelte Schleife** ist eine Schleife, die innerhalb des Rumpfes einer anderen Schleife ausgeführt wird. In dieser Struktur wird die innere Schleife für jede Iteration der äußeren Schleife vollständig ausgeführt. Es können verschiedene Schleifentypen (z. B. eine `while`-Schleife mit einer `for`-Schleife) kombiniert werden, um unterschiedliche Ergebnisse zu erzielen.

Definition

Wir verwenden eine verschachtelte Schleife, um jede Stadt mehrfach in einem strukturierten Format auszugeben, das einem **Dreiecksmuster** ähnelt.

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

# Outer loop for controlling rows
for i in range(1, len(travel_list) + 1):
    # Inner loop for controlling columns
    for j in range(i):
        print(travel_list[j], end=' ')  # Print cities in a row
    print('')  # Move to the next line after each row

- **Äußere Schleife**:
die `for`-Schleife mit `range(1, len(travel_list) + 1)` bestimmt die **Anzahl der Zeilen**. Jede Iteration steht für eine Zeile. `i` steuert, wie viele Städte in der aktuellen Zeile ausgegeben werden;
- **Innere Schleife:**
die `for`-Schleife mit `range(i)` durchläuft die Städte, die in der aktuellen Zeile ausgegeben werden sollen.
`j` greift auf die Stadtnamen in der `travel_list` bis zum aktuellen Zeilenindex zu;
- **Ausgabe:**
das `print(travel_list[j], end=' ')` sorgt dafür, dass die Städte in derselben Zeile ausgegeben werden.
`print('')` springt nach jeder Zeile in die nächste Zeile.

Mit einer geschachtelten Schleife kann eine verschachtelte Liste durchlaufen und mit jedem ihrer Elemente interagiert werden.

# Define a nested list containing sublists with words starting with 'A' and 'T'
nested_list = [
    ["Apple", "Avocado", "Apricot"],
    ["Tomato", "Tangerine", "Tea"],
    ["Almond", "Thyme", "Tuna"]
]

# Iterate through each sublist in the nested list
for sublist in nested_list:
    # Iterate through each item in the current sublist
    for item in sublist:
        # Convert the item to lowercase and print it
        print(item.lower(), end=' ')

Die **`capitalize()`-Methode** wandelt das erste Zeichen eines Strings in einen Großbuchstaben um und ändert alle anderen Zeichen in Kleinbuchstaben. Dies ist nützlich, um Strings korrekt zu formatieren.

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)

class TestUserCode(unittest.TestCase):

    def test_countries_is_declared(self):
        try:
            user_code = importlib.import_module("user_code")
            _ = user_code.countries
            _dynamic_test(self, True, "The `countries` list 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_contains_correct_values(self):
        try:
            user_code = importlib.import_module("user_code")
            expected_countries = sorted({country.capitalize() for trip in user_code.trips for country in trip})
            _dynamic_test(
                self,
                sorted(user_code.countries) == expected_countries,
                "The `countries` list contains all countries from `trips` with correct capitalization.",
                f"Expected `countries` to be `{expected_countries}`, but got `{user_code.countries}`."
            )
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `countries` to be declared.")
        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.

Verschachtelte For-Schleife

Lösung