In dieser Anleitung erfahren Sie, wie Sie die Python-Funktion enumerate() optimal nutzen können.
Die Funktion enumerate() in Python bietet eine elegante Methode, um auf die Elemente einer iterierbaren Struktur zusammen mit ihren jeweiligen Indizes zuzugreifen.
Wir beginnen mit der Betrachtung herkömmlicher Schleifenmethoden, um Elemente und Indizes zu erhalten, und wechseln dann zur detaillierten Untersuchung der enumerate()-Syntax von Python. Ergänzende Codebeispiele werden die Erklärungen veranschaulichen.
Starten wir nun mit der Erläuterung.
Iteration mit der for-Schleife in Python
Jedes Python-Objekt, das iterierbar ist und dessen Elemente einzeln abgerufen werden können, wird als iterierbar bezeichnet. So sind beispielsweise Listen, Tupel, Wörterbücher und Zeichenketten in Python alle iterierbar.
Betrachten wir eine Einkaufsliste als Beispiel, wie im folgenden Codeabschnitt definiert:
shopping_list = ["Obst", "Kekse", "Müsli", "Proteinriegel", "Haftnotizen"]
In Python können Sie die for-Schleife verwenden, um durch jede iterierbare Struktur zu navigieren. Die allgemeine Struktur hierfür lautet:
for element in <iterable>:
# Anweisung mit dem Element
# element: Schleifenvariable
# <iterable>: Jede iterierbare Python-Struktur: Liste, Tupel, Wörterbuch, Zeichenkette usw.
Wenden wir diese Syntax auf unsere Einkaufsliste an, um auf jedes Element zuzugreifen:
for element in shopping_list: print(element) # Ausgabe Obst Kekse Müsli Proteinriegel Haftnotizen
Diese Methode ermöglicht einen direkten Zugriff auf die Elemente. Jedoch ist es manchmal zusätzlich erforderlich, neben dem Element auch auf den zugehörigen Index zuzugreifen.
Sie können eine Indexvariable verwenden und diese innerhalb der Schleife inkrementieren, wie unten dargestellt:
index = 0
for element in shopping_list:
print(f"Index: {index}, {element}")
index += 1
# Ausgabe
Index: 0, Obst
Index: 1, Kekse
Index: 2, Müsli
Index: 3, Proteinriegel
Index: 4, Haftnotizen
Dies ist allerdings nicht die effizienteste Methode. Wenn Sie vergessen, den Index zu erhöhen, kann dies zu unerwartetem Verhalten führen.
index = 0
for element in shopping_list:
print(f"Index: {index}, {element}")
# Keine Aktualisierung des Index innerhalb der Schleife
# Der Index wird nicht aktualisiert und ist immer 0
# Ausgabe
Index: 0, Obst
Index: 0, Kekse
Index: 0, Müsli
Index: 0, Proteinriegel
Index: 0, Haftnotizen
Eine weitere typische Verwendung der for-Schleife ist die Kombination mit der range()-Funktion. Dies werden wir im nächsten Abschnitt untersuchen.
Verwendung der range()-Funktion für den Indexzugriff
Die integrierte Python-Funktion len() gibt die Länge eines jeden Python-Objekts zurück. Sie können len() auf die Einkaufsliste anwenden, um ihre Länge zu erhalten (in diesem Fall 5).
len(shopping_list) # Ausgabe: 5
Die range()-Funktion erzeugt ein Range-Objekt, das für Schleifen verwendet werden kann. Wenn Sie range(stop) durchlaufen, werden die Indizes 0, 1, 2, …, stop-1 generiert.
Wenn Sie stop = len(list) setzen, erhalten Sie eine Liste aller gültigen Indizes. Durch Verwendung der range()-Funktion können Sie sowohl auf den Index als auch auf das entsprechende Element zugreifen, wie unten veranschaulicht:
for index in range(len(shopping_list)):
print(f"Index: {index}, Element: {shopping_list[index]}")
# Ausgabe
Index: 0, Element: Obst
Index: 1, Element: Kekse
Index: 2, Element: Müsli
Index: 3, Element: Proteinriegel
Index: 4, Element: Haftnotizen
Dies ist allerdings nicht die in Python empfohlene Methode für den gleichzeitigen Zugriff auf Indizes und Elemente.
Syntax der Python enumerate()-Funktion
Die Funktion enumerate() ermöglicht es Ihnen, Elemente und ihre Indizes mit folgender grundlegender Syntax zu verwenden:
enumerate(<iterable>, start = 0)
In der oben genannten Syntax:
<iterable>ist ein erforderlicher Parameter, der jedes iterierbare Python-Objekt, wie Liste oder Tupel, sein kann.startist ein optionaler Parameter, der den Startindex für die Zählung angibt. Standardmäßig ist der Wert null, wenn nicht anders definiert.
Sie können enumerate() mit der shopping_list aufrufen, und es wird ein enumerate-Objekt zurückgegeben, wie im folgenden Codebeispiel zu sehen ist:
enumerate(shopping_list) <enumerate at 0x7f91b4240410>
Das Aufzählungsobjekt selbst ist nicht direkt durchlaufbar. Lassen Sie uns es daher in eine Python-Liste umwandeln:
list(enumerate(shopping_list)) # Ausgabe [(0, 'Obst'), (1, 'Kekse'), (2, 'Müsli'), (3, 'Proteinriegel'), (4, 'Haftnotizen')]
Eine andere Methode zum Zugriff auf die Elemente des Aufzählungsobjekts ist die Verwendung der next()-Funktion mit dem Aufzählungsobjekt als Argument. In Python gibt die next()-Funktion das nächste Element eines Iterators zurück.
Intern ruft die next()-Funktion die Methode __next__ des Iteratorobjekts auf, um die nachfolgenden Elemente abzurufen.
Weisen wir das Aufzählungsobjekt der Variablen shopping_list_enum zu.
shopping_list_enum = enumerate(shopping_list)
Wenn next() zum ersten Mal mit shopping_list_enum aufgerufen wird, erhalten Sie den Index Null und das Element am Index 0: das Tupel (0, ‚Obst‘).
Bei weiteren Aufrufen der next()-Funktion erhalten Sie die nachfolgenden Elemente mit ihren jeweiligen Indizes, wie unten gezeigt:
next(shopping_list_enum) # (0, 'Obst') next(shopping_list_enum) # (1, 'Kekse') next(shopping_list_enum) # (2, 'Müsli') next(shopping_list_enum) # (3, 'Proteinriegel') next(shopping_list_enum) # (4, 'Haftnotizen')
Was passiert, wenn Sie die next()-Funktion aufrufen, nachdem auf alle Elemente zugegriffen wurde und das Ende der Liste erreicht ist? Es wird ein StopIteration-Fehler auftreten.
next(shopping_list_enum) # --------------------------------------------------------------------------- # StopIteration Traceback (most recent call last) # <ipython-input-16-4220f68f6c7e> in <module>() # ----> 1 next(shopping_list_enum) # StopIteration:
Die enumerate()-Funktion liefert die nachfolgenden Indizes und Elemente nur bei Bedarf und berechnet sie nicht im Voraus. In Python-Projekten, in denen Speichereffizienz wichtig ist, können Sie die enumerate()-Funktion verwenden, wenn Sie durch große Iterables iterieren müssen.
Beispiele für die Python enumerate()-Funktion
Nachdem wir die Syntax der Verwendung von enumerate() behandelt haben, ändern wir die zuvor verwendete for-Schleife.
Aus dem vorherigen Abschnitt wissen wir, dass die Iteration durch das Aufzählungsobjekt ein Tupel mit dem Index und dem Element zurückgibt. Dieses Tupel können wir in zwei Variablen entpacken: index und element.
for index, element in enumerate(shopping_list):
print(f"Index: {index}, Element: {element}")
# Ausgabe
Index: 0, Element: Obst
Index: 1, Element: Kekse
Index: 2, Element: Müsli
Index: 3, Element: Proteinriegel
Index: 4, Element: Haftnotizen
Betrachten wir nun, wie man einen benutzerdefinierten Startwert angibt.
Verwendung von enumerate() mit einem benutzerdefinierten Startwert
In Python beginnt die Indizierung standardmäßig bei Null, d.h. der Standard-Startwert ist 0. Wenn Sie jedoch die Indizes in einer für Menschen lesbaren Form benötigen, beginnend mit 1 oder einem anderen von Ihnen gewählten Index, können Sie einen benutzerdefinierten Startwert angeben.
Um im Beispiel der Einkaufsliste mit der Zählung bei 1 zu beginnen, setzen Sie start = 1.
for index, element in enumerate(shopping_list, 1):
print(f"Index: {index}, Element: {element}")
# Ausgabe
Index: 1, Element: Obst
Index: 2, Element: Kekse
Index: 3, Element: Müsli
Index: 4, Element: Proteinriegel
Index: 5, Element: Haftnotizen
Bei der Angabe eines benutzerdefinierten Startwerts müssen Sie diesen unbedingt als zweites positionsgebundenes Argument angeben.
Wenn Sie die Reihenfolge des iterierbaren Objekts und des Startwerts versehentlich vertauschen, tritt ein Fehler auf, wie im folgenden Codebeispiel zu sehen ist:
for index, element in enumerate(1, shopping_list):
print(f"Index: {index}, Element: {element}")
# Ausgabe
# ---------------------------------------------------------------------------
# TypeError Traceback (most recent call last)
# <ipython-input-12-5dbf7e2749aa> in <module>()
# ----> 1 for index, element in enumerate(1,shopping_list):
# 2 print(f"Index:{index}, Element:{element}")
# TypeError: 'list' object cannot be interpreted as an integer
Um derartige Fehler zu vermeiden, können Sie start als Schlüsselwortargument angeben, wie unten dargestellt:
for index, element in enumerate(shopping_list, start = 1):
print(f"Index: {index}, Element: {element}")
# Ausgabe
Index: 1, Element: Obst
Index: 2, Element: Kekse
Index: 3, Element: Müsli
Index: 4, Element: Proteinriegel
Index: 5, Element: Haftnotizen
Bisher haben Sie die Verwendung von enumerate() mit Python-Listen kennengelernt. Die enumerate()-Funktion kann auch für Python-Strings, -Wörterbücher und -Tupel verwendet werden.
Verwendung der enumerate()-Funktion mit Python-Tupeln
Nehmen wir an, shopping_list ist ein Tupel. In Python sind Tupel ebenfalls Kollektionen – ähnlich wie Python-Listen, aber sie sind unveränderlich. Daher können sie nicht verändert werden, und der Versuch, dies zu tun, führt zu Fehlern.
Der folgende Code-Ausschnitt initialisiert shopping_list als Tupel.
shopping_list = ("Obst", "Kekse", "Müsli", "Proteinriegel", "Haftnotizen")
type(shopping_list)
# Tupel
Wenn Sie versuchen, das erste Element im Tupel zu ändern, erhalten Sie eine Fehlermeldung, da ein Python-Tupel eine unveränderliche Sammlung ist.
shopping_list[0] = 'Gemüse' # Ausgabe # --------------------------------------------------------------------------- # TypeError Traceback (most recent call last) # <ipython-input-2-ffdafa961600> in <module>() # ----> 1 shopping_list[0] = 'Gemüse' # TypeError: 'tuple' object does not support item assignment
▶ Führen Sie nun den folgenden Code-Ausschnitt aus, um zu prüfen, ob die enumerate()-Funktion wie erwartet mit Tupeln arbeitet.
shopping_list = ("Obst", "Kekse", "Müsli", "Proteinriegel", "Haftnotizen")
for index, element in enumerate(shopping_list):
print(f"Index: {index}, Element: {element}")
Verwendung der enumerate()-Funktion mit Python-Strings
Sie können auch die Python enumerate()-Funktion verwenden, um durch Strings zu iterieren und gleichzeitig auf die Zeichen und ihre Indizes zuzugreifen.
Hier ein Beispiel.
py_str="Schmetterling"
for index, char in enumerate(py_str):
print(f"Index {index}: {char}")
# Ausgabe
Index 0: S
Index 1: c
Index 2: h
Index 3: m
Index 4: e
Index 5: t
Index 6: t
Index 7: e
Index 8: r
Index 9: l
Index 10: i
Index 11: n
Index 12: g
Aus der obigen Ausgabe ist ersichtlich, dass die Zeichen zusammen mit ihren Indizes (0-12) ausgegeben wurden.
Fazit👩🏽💻
Hier eine Zusammenfassung dessen, was Sie gelernt haben.
- Sie können
for-Schleifen verwenden, um auf Elemente zuzugreifen und eine separate Zähler- oder Indexvariable zu verwalten. - Optional können Sie die
range()-Funktion verwenden, um die gültigen Indizes zu erhalten und auf die Elemente zuzugreifen, indem Sie die Liste indizieren. - Als empfohlene Python-Methode können Sie die
enumerate()-Funktion mit der Syntaxenumerate(iterable)verwenden. Standardmäßig beginnt die Zählung oder der Index bei 0. - Sie können einen benutzerdefinierten Startwert mit der Syntax
enumerate(iterable, start)angeben, um den Index ab dem Wert vonstartzusammen mit den entsprechenden Elementen abzurufen. - Sie können die Aufzählungsfunktion verwenden, wenn Sie mit Tupeln, Strings, Wörterbüchern und im Allgemeinen mit allen iterierbaren Objekten in Python arbeiten.
Ich hoffe, diese Anleitung zur enumerate()-Funktion war hilfreich. Als Nächstes lernen Sie, wie Sie den Index eines Elements in Python-Listen finden. Viel Spaß beim Programmieren!