In der Python-Programmierung ist das Verständnis und die effektive Nutzung von Iterables eine Grundvoraussetzung für eine kompetente Programmierung. Iterables sind Objekte, durch die du iterieren oder eine Schleife durchlaufen kannst. Sie unterstützen das sequentielle Durchlaufen von Elementen in ihnen und sind damit ein wichtiges Werkzeug für den Zugriff auf und die Bearbeitung von Elementen in Objekten oder Datenstrukturen.

In diesem Artikel geht es um die richtige Verwendung von Python-Iterablen, wobei wir uns auf die in der Sprache eingebauten iterablen Datentypen konzentrieren: Listen, Tupel, Wörterbücher, Strings und Sets. Außerdem wird erklärt, wie man benutzerdefinierte iterable Typen implementiert und erweiterte Operationen durchführt.

Schleifen durch Python-Iterables

In Python kannst du mit einer for Schleife durch verschiedene iterierbare Typen iterieren. So kannst du durch Sequenzen navigieren und Operationen an einzelnen Elementen in Listen, Mengen und Wörterbüchern durchführen.

Das Schlüsselwort for in Python weicht von seinem Nutzen in anderen objektorientierten Sprachen wie Java ab. Python for Schleifen funktionieren eher wie Iterator-Methoden. Hier sind Beispiele, die Schleifen in Iterables demonstrieren:

1. Schleifen durch eine Liste

Listen sind geordnete Sammlungen von Elementen, die sich mit einer for Schleife leicht durchlaufen lassen.

fruits_list = ["Apple", "Mango", "Peach", "Orange", "Banana"]

for fruit in fruits_list:
    print(fruit)

Im obigen Code dient fruit als Iterator, mit dem die Schleife jedes Listenelement durchläuft und gleichzeitig ausgibt. Die Schleife endet, nachdem sie das letzte Element der Liste ausgewertet hat. Der obige Code sollte die folgende Ausgabe liefern:

Apple
Mango
Peach
Orange
Banana

2. Iterieren durch ein Tupel

Tupel sind ähnlich wie Listen, aber unveränderbar. Du kannst sie genauso durchlaufen wie Listen.

fruits_tuple = ("Apple", "Mango", "Peach", "Orange", "Banana")

for fruit in fruits_tuple:
	print(fruit)

In diesem Beispiel durchläuft die Schleife for das Tupel, und bei jedem Durchlauf nimmt die Variable fruit den Wert des aktuellen Elements im Tupel an. Der Code sollte die folgende Ausgabe liefern:

Apple
Mango
Peach
Orange
Banana

3. Schleife durch Sets

Sets sind ungeordnete Sammlungen von eindeutigen Elementen. Du kannst sie mit einer for Schleife durchlaufen.

fruits_set = {"Apple", "Mango", "Peach", "Orange", "Banana"}

for fruit in fruits_set:
	print(fruit)

In diesem Beispiel durchläuft die for Schleife das Set. Da Sets jedoch ungeordnet sind, muss die Reihenfolge der Iteration nicht mit der Reihenfolge übereinstimmen, in der die Elemente in dem Set definiert wurden. Bei jeder Iteration nimmt die Variable fruit den Wert des aktuellen Elements in dem Set an. Der Code sollte eine ähnliche Ausgabe wie die folgende liefern (die Reihenfolge kann variieren):

Mango
Banana
Peach
Apple
Orange

4. Iteration durch Zeichenketten

Zeichenketten sind Zeichenfolgen, die du Zeichen für Zeichen in einer Schleife durchlaufen kannst.

string = "Kinsta"

for char in string:
	print(char)

Der obige Code iteriert durch die Zeichenkette „Kinsta“ und gibt jedes Zeichen in einer neuen Zeile aus. Bei jeder Iteration nimmt die Variable char den Wert des aktuellen Zeichens in der Zeichenkette an. Der Code sollte die folgende Ausgabe liefern:

K
i
n
s
t
a

5. Durchlaufen eines Wörterbuchs

Die for Schleife ist bei Listen, Sets, Tupeln und Strings ähnlich, aber bei Wörterbüchern ist sie anders, da sie Schlüssel-Wert-Paare zum Speichern von Elementen verwenden. Wörterbücher sind ein einzigartiger Fall für eine Schleife, da du sie mit verschiedenen Ansätzen wiederholen kannst. Hier sind die verschiedenen Ansätze, die du verwenden kannst, um ein Python-Wörterbuch zu durchlaufen:

  • Iterieren durch Schlüssel: 
    countries_capital = {
    "USA": "Washington D.C.",
    "Australia": "Canberra",
    "France": "Paris",
    "Egypt": "Cairo",
    "Japan": "Tokyo"
}

for country in countries_capital.keys():
    print(country)

    Der obige Code definiert ein Wörterbuch namens countries_capital, in dem die Ländernamen die Schlüssel und die jeweiligen Hauptstädte die Werte sind. Die Schleife for iteriert mit der Methode keys() durch die Schlüssel des Wörterbuchs countries_capital. Diese Methode gibt ein View-Objekt zurück, das eine Liste der Schlüssel im Wörterbuch anzeigt, so dass es einfach ist, eine Schleife durch alle Schlüssel zu ziehen. Bei jeder Iteration nimmt die Variable country den Wert des aktuellen Schlüssels an. Dieser Code sollte die folgende Ausgabe liefern:

    USA
Australia
France
Egypt
Japan
  • Iteration durch Werte: 
    countries_capital = {
    "USA": "Washington D.C.",
    "Australia": "Canberra",
    "France": "Paris",
    "Egypt": "Cairo",
    "Japan": "Tokyo"
}

for capital in countries_capital.values():
    print(capital)

    Im obigen Code iteriert for mit der Methode values() durch die Werte des Wörterbuchs countries_capital. Diese Methode gibt ein View-Objekt zurück, das eine Liste der Werte im Wörterbuch anzeigt, so dass es einfach ist, eine Schleife durch alle Werte zu ziehen. Bei jeder Iteration nimmt die Variable capital den Wert des aktuellen Wertes in der Liste an. Dieser Code sollte die folgende Ausgabe liefern:

    Washington D.C.
Canberra
Paris
Cairo
Tokyo
  • Iteration durch Schlüssel-Wert-Paare: 
    countries_capital = {
    "USA": "Washington D.C.",
    "Australia": "Canberra",
    "France": "Paris",
    "Egypt": "Cairo",
    "Japan": "Tokyo"
}

for country, capital in countries_capital.items():
    print(country, ":", capital)

    Der obige Code zeigt, wie man mit der Methode items() durch die Schlüssel und Werte des Wörterbuchs countries_capital iteriert. Die Methode items() gibt ein View-Objekt zurück, das eine Liste der Schlüssel-Wert-Tupel des Wörterbuchs anzeigt. In der Schleife for wird bei jeder Iteration ein Schlüssel-Wert-Paar aus dem aktuellen Element der Liste ausgepackt. Den Variablen country und capital wird der entsprechende Schlüssel bzw. Wert zugewiesen. Dieser Code sollte die folgende Ausgabe liefern:

    USA : Washington D.C.
Australia : Canberra
France : Paris
Egypt : Cairo
Japan : Tokyo

Erweiterte Iteration mit enumerate() in Python

Eine weitere Möglichkeit, über Python-Iterablen zu iterieren und dabei sowohl den Index als auch den entsprechenden Wert der Elemente zurückzugeben, ist die Funktion enumerate(). Schau dir dieses Beispiel an:

fruits_list = ["Apple", "Mango", "Peach", "Orange", "Banana"]

for index, fruit in enumerate(fruits_list):
    print(fruit, index)

Hier ist die Ausgabe:

Apple 0
Mango 1
Peach 2
Orange 3
Banana 4

Mit der Funktion enumerate kannst du neben 0 auch den Startindex für die Iterationsoperation angeben. Du kannst das obige Beispiel wie folgt abändern:

fruits_list = ["Apple", "Mango", "Peach", "Orange", "Banana"]
for index, fruit in enumerate(fruits_list, start = 2):
    print(fruit, index)

Hier ist die Ausgabe:

Apple 2
Mango 3
Peach 4
Orange 5
Banana 6

Beachte, dass dieses Beispiel zwar den Startindex der Aufzählung angibt, enumerate aber keine nullbasierte Indizierung auf die Iterable anwendet, wie es bei nativen Listen der Fall ist. Der Startwert wird einfach an das erste Element der Liste angehängt, und zwar bis zum letzten Element.

Wie man Python-Generatoren implementiert

Generatoren sind spezielle Python-Iterablen, mit denen du Generatorobjekte erstellen kannst, ohne explizit eingebaute Typen wie Listen, Sets oder Wörterbücher zu erstellen. Du kannst Generatoren verwenden, um Werte auf der Grundlage der Generierungslogik zu erzeugen.

Generatoren verwenden die Anweisung yield, um die erzeugten Werte nacheinander zurückzugeben. Hier ist ein Beispiel für Generator-Iterables:

def even_generator(n):
    counter = 0
    while counter <= n:
        if counter % 2 == 0:
            yield counter
        counter += 1

for num in even_generator(20):
    print(num)

Der angegebene Code definiert eine Funktion even_generator, die mit der Anweisung yield eine Folge von geraden Zahlen von 0 bis zu einem bestimmten n erzeugt. Sie verwendet eine Schleife, um diese Werte zu erzeugen und iteriert das Ergebnis mit dem num Iterator, um sicherzustellen, dass alle Werte innerhalb des angegebenen Bereichs ausgewertet werden. Dieser Code gibt eine Liste mit geraden Zahlen von 0 bis 20 aus, wie unten dargestellt:

0
2
4
6
8
10
12
14
16
18
20

Bei der Arbeit mit Generatorausdrücken kannst du noch mehr Prägnanz erreichen. Du kannst zum Beispiel eine Generatorfunktion entwerfen, die auch eine Schleifenlogik enthält:

cube = (num ** 3 for num in range(1, 6))
for c in cube:
    print(c)

In diesem Fall weist du die Variable cube dem Ergebnis einer Funktion zu, die den Würfel der Werte im Bereich von 1 bis 6 berechnet. Dann durchläuft die Funktion eine Schleife durch die Werte innerhalb des angegebenen Bereichs und gibt das Ergebnis der Berechnung nacheinander aus. Die Ausgabe sieht folgendermaßen aus:

1
8
27
64
125

Wie man benutzerdefinierte Iterables erstellt

Mit Python kannst du Iterabilitätsoperationen weiter anpassen, indem du Iteratoren verwendest. Iterator-Objekte implementieren das Iterator-Protokoll und enthalten 2 Methoden: __iter__() und __next__(). Die Methode __iter__() gibt ein Iterator-Objekt zurück, während __next__() den nächsten Wert in einem Iterable-Container zurückgibt. Hier ist ein Beispiel für Iteratoren in Python:

even_list = [2, 4, 6, 8, 10]
my_iterator = iter(even_list)
print(next(my_iterator)) # Prints 2
print(next(my_iterator)) # Prints 4
print(next(my_iterator)) # Prints 6

In diesem Beispiel verwendest du die Methode iter(), um ein Iterator-Objekt (my_iterator) aus der Liste zu erstellen. Um auf die einzelnen Elemente der Liste zuzugreifen, verpackst du das Iterator-Objekt mit der Methode next(). Da Listen geordnete Sammlungen sind, gibt der Iterator die Elemente der Reihe nach zurück.

Benutzerdefinierte Iteratoren sind ideal für Operationen mit großen Datensätzen, die du nicht gleichzeitig in den Speicher laden kannst. Da Speicher teuer ist und nur begrenzt Platz zur Verfügung steht, kannst du einen Iterator verwenden, um Datenelemente einzeln zu verarbeiten, ohne den gesamten Datensatz in den Speicher zu laden.

Iterable-Funktionen

Python verwendet Funktionen, um Listenelemente zu durchlaufen, zu manipulieren und zu überprüfen. Einige gängige Listenfunktionen sind:

  • sum – Gibt die Summe einer gegebenen Iterable zurück, sofern die Sammlung aus numerischen Typen besteht (Ganzzahlen, Fließkommazahlen und komplexe Zahlen)
  • any – Gibt true zurück, wenn eines der iterierbaren Elemente wahr ist. Andernfalls gibt sie false zurück.
  • all – Gibt true zurück, wenn alle Elemente der Iterable wahr sind. Andernfalls gibt sie false zurück.
  • max – Gibt den Maximalwert einer gegebenen iterierbaren Sammlung zurück
  • min – Gibt den Mindestwert einer gegebenen iterierbaren Sammlung zurück
  • len – Gibt die Länge einer gegebenen Iterablen-Sammlung zurück
  • append – Fügt einen Wert an das Ende einer iterierbaren Liste an

Das folgende Beispiel demonstriert diese Funktionen anhand einer Liste:

even_list = [2, 4, 6, 8, 10]

print(sum(even_list))
print(any(even_list))
print(max(even_list))
print(min(even_list))
even_list.append(14) # Add 14 to the end of the list
print(even_list)
even_list.insert(0, 0) # Insert 0 and specified index [0]
print(even_list)
print(all(even_list)) # Return true only if ALL elements in the list are true
print(len(even_list)) # Print the size of the list

Hier ist die Ausgabe:

30
True
10
2
[2, 4, 6, 8, 10, 14]
[0, 2, 4, 6, 8, 10, 14]
False
7

Im obigen Beispiel fügt die Funktion append einen einzelnen Parameter (14) an das Ende der Liste an. Bei der Funktion insert kann der Index für das Einfügen angegeben werden. Daher fügt even_list.insert(0, 0) 0 beim Index [0] ein.
Die Anweisung print(all(even_list)) gibt false zurück, weil es in der Liste einen Wert 0 gibt, der als false interpretiert wird. Schließlich gibt print(len(even_list)) die Länge der Iterable aus.

Erweiterte Iterabilitätsoperationen

Python bietet fortgeschrittene Funktionen, die die Prägnanz von Iterabilitätsoperationen erhöhen. Nachfolgend sind einige von ihnen aufgeführt.

1. List Comprehensions

Mit List Comprehensions kannst du neue Listen erstellen, indem du eine Funktion auf jedes Element einer bestehenden Liste anwendest. Hier ist ein Beispiel:

my_numbers = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
even_number_list = [num for num in my_numbers if num%2 == 0]
print(even_number_list)

In diesem Codeschnipsel wird eine Liste mit dem Namen my_numbers erstellt, die ganze Zahlen von 11 bis 20 enthält. Ziel ist es, eine neue Liste, even_number_list, zu erstellen, die nur gerade ganze Zahlen enthält. Um das zu erreichen, wendest du ein Listenverständnis an, das eine ganze Zahl aus my_numbers nur dann zurückgibt, wenn sie gerade ist. Die Anweisung if enthält die Logik, die die geraden Zahlen zurückgibt.

Hier ist die Ausgabe:

[12, 14, 16, 18, 20]

2. Zip

Die Funktion zip() von Python fasst mehrere Iterables zu Tupeln zusammen. Tupel speichern mehrere Werte in einer Variablen und sind unveränderbar. Hier erfährst du, wie du Iterables mit zip() kombinieren kannst:

fruits = ["apple", "orange", "banana"]
rating = [1, 2, 3]

fruits_rating = zip(rating, fruits)
print(list(fruits_rating))

In diesem Beispiel paart fruits_rating jede Bewertung mit einer Frucht und erstellt so eine einzige Iterable. Die Ausgabe ist:

[(1, 'apple'), (2, 'orange'), (3, 'banana')]

Dieser Code funktioniert wie ein Bewertungssystem für verschiedene Früchte, wobei die erste Liste (fruits) die Früchte und die zweite Liste die Bewertungen auf einer Skala von 1 bis 3 darstellt.

3. Filter

Eine weitere fortschrittliche Funktion, filter, benötigt 2 Argumente – eine Funktion und eine Iterable. Sie wendet die Funktion auf jedes Element in der Iterable an und gibt dann eine neue Iterable zurück, die nur die Elemente enthält, für die die Funktion einen true Wert liefert. Das folgende Beispiel filtert eine Liste mit ganzzahligen Werten innerhalb eines bestimmten Bereichs und gibt nur die geraden Werte zurück:

def is_even(n):
    return n%2 == 0

nums_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_list = filter(is_even, nums_list)
print(list(even_list))

Im obigen Code definierst du zunächst eine Funktion, is_even, die eine gerade Zahl berechnet, die ihr übergeben wird. Dann erstellst du eine Liste mit ganzzahligen Werten zwischen 1 und 10 – nums_list. Schließlich definierst du eine neue Liste, even_list, die die Funktion filter() verwendet, um die benutzerdefinierte Methode auf die ursprüngliche Liste anzuwenden und nur die geraden Listenelemente zurückzugeben. Hier ist das Ergebnis:

[2, 4, 6, 8, 10]

4. Map

Wie filter() nimmt auch die Funktion map() von Python eine Iterable und eine Funktion als Argumente an. Anstatt jedoch Elemente aus der ursprünglichen Iterable zurückzugeben, gibt sie eine neue Iterable zurück, die das Ergebnis der Funktion enthält, die auf jedes Element der ersten Iterable angewendet wurde. Um eine Liste von ganzen Zahlen zu quadrieren, verwendest du die Funktion map():

my_list = [2, 4, 6, 8, 10]
square_numbers = map(lambda x: x ** 2, my_list)
print(list(square_numbers))

In diesem Code ist x der Iterator, der die Liste durchläuft und sie durch die Quadratberechnung umwandelt. Die Funktion map() führt diese Operation aus, indem sie die ursprüngliche Liste als Argument neben einer Zuordnungsfunktion nimmt. Die Ausgabe ist wie folgt:

[4, 16, 36, 64, 100]

5. Sorted

Die Funktion sorted sortiert die Elemente einer gegebenen iterable in einer bestimmten Reihenfolge (aufsteigend oder absteigend) und gibt sie als Liste zurück. Sie nimmt maximal 3 Parameter an – iterable, reverse(optional) und key(optional). Der Standardwert von reverse ist False und wenn er auf True gesetzt wird, werden die Elemente in absteigender Reihenfolge sortiert. key ist eine Funktion, die einen Wert berechnet, um die Sortierreihenfolge der Elemente in einer Iterable zu bestimmen und der Standardwert ist None.

Hier ist ein Beispiel dafür, wie du die Funktion sorted auf verschiedene Iterables anwenden kannst:

# set
py_set = {'e', 'a', 'u', 'o', 'i'}
print(sorted(py_set, reverse=True))

# dictionary
py_dict = {'e': 1, 'a': 2, 'u': 3, 'o': 4, 'i': 5}
print(sorted(py_dict, reverse=True))

# frozen set
frozen_set = frozenset(('e', 'a', 'u', 'o', 'i'))
print(sorted(frozen_set, reverse=True))

# string
string = "kinsta"
print(sorted(string))

# list
py_list = ['a', 'e', 'i', 'o', 'u']
print(py_list)

So erhältst du die folgende Ausgabe:

['u', 'o', 'i', 'e', 'a']
['u', 'o', 'i', 'e', 'a']
['u', 'o', 'i', 'e', 'a']
['a', 'i', 'k', 'n', 's', 't']
['a', 'e', 'i', 'o', 'u']

Wie man mit Randfällen und Fehlern in Iterablen umgeht

Randfälle sind in vielen Programmierszenarien üblich, und du solltest sie in Iterablen vorhersehen können. Sehen wir uns ein paar Möglichkeiten an, auf die du stoßen könntest.

1. Leere Iterablen

Du kannst auf Probleme stoßen, wenn eine Iterable leer ist, aber eine Programmierlogik versucht, sie zu durchlaufen. Du kannst dies programmatisch angehen, um Ineffizienzen zu vermeiden. Hier ist ein Beispiel, in dem eine if not Anweisung verwendet wird, um zu prüfen, ob eine Liste leer ist:

fruits_list=[]
if not fruits_list:
    print("The list is empty")

Das ist das Ergebnis:

The list is empty

2. Verschachtelte Iterablen

Python unterstützt auch verschachtelte Iterablen, d.h. Iterabilitätsobjekte, die andere Iterabilitäten enthalten. Du kannst zum Beispiel eine Liste von Lebensmitteln haben, die verschachtelte Listen von Lebensmittelkategorien enthält, wie Fleisch, Gemüse und Getreide. Hier erfährst du, wie du ein solches Szenario mit verschachtelten Iterablen modellieren kannst:

food_list = [["kale", "broccoli", "ginger"], ["beef", "chicken", "tuna"], ["barley", "oats", "corn"]]
for inner_list in food_list:
    for food in inner_list:
        print(food)

Im obigen Code enthält die Variable food_list drei verschachtelte Listen, die verschiedene Lebensmittelkategorien darstellen. Die äußere Schleife (for inner_list in food_list:) durchläuft die primäre Liste, und die innere Schleife (for food in inner_list:) durchläuft jede verschachtelte Liste und gibt jedes Lebensmittel aus. Die Ausgabe sieht wie folgt aus:

kale
broccoli
ginger
beef
chicken
tuna
barley
oats
corn

3. Behandlung von Ausnahmen

In Python unterstützen Iterablen auch Operationen zur Behandlung von Ausnahmen. Du kannst zum Beispiel über eine Liste iterieren und auf IndexError stoßen. Dieser Fehler bedeutet, dass du versuchst, auf ein Element zu verweisen, das die Grenzen der Iterable überschreitet. Hier erfährst du, wie du eine solche Ausnahme mit einem try-except Block behandeln kannst:

fruits_list = ["apple", "mango", "orange", "pear"]
try:
    print(fruits_list[5])
except IndexError:
    print("The index specified is out of range.")

Im obigen Code enthält die fruits_list iterable fünf Elemente, die durch die Indizes 0 bis 5 in der Listensammlung abgebildet werden. Der try Satz enthält eine print Funktion, die versucht, den Wert am Index 5 der iterable anzuzeigen, der nicht existiert. Dies führt die except-Klausel aus und gibt die zugehörige Fehlermeldung zurück. Die Konsole meldet den Fehler:

The index specified is out of range.

Zusammenfassung

Die Beherrschung der Iteration in Python ist entscheidend für effizienten und lesbaren Code. Wenn du die verschiedenen Möglichkeiten der Iteration über verschiedene Datenstrukturen, die Verwendung von Comprehensions, Generatoren und die Nutzung eingebauter Funktionen verstehst, wirst du ein kompetenter Python-Programmierer.

Ganz gleich, ob du mit Listen, Wörterbüchern, Strings oder benutzerdefinierten Objekten arbeitest, die Kenntnis der Verwendung und Handhabung von Iterationen ist eine unverzichtbare Fähigkeit in der Python-Programmierung.

Wenn du deine Python-Anwendung fertiggestellt hast und sie online hosten möchtest, probiere das Anwendungs-Hosting von Kinsta aus. Deine ersten 20 Dollar gehen auf uns!

Haben wir in diesem Leitfaden etwas übersehen? Bitte teile es uns im Kommentarbereich unten mit!

Jeremy Holcombe Kinsta

Content & Marketing Editor at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems ;).