Der Typfehler “int object is not iterable” gehört zu den häufigsten Stolpersteinen in Python-Projekten, besonders wenn man mit Schleifen, Generators oder Funktionen arbeitet, die eine Sequenz erwarten. In diesem langen Leitfaden erklären wir, warum dieser Fehler überhaupt auftritt, welche Muster ihn auslösen und wie man ihn sowohl in bestehenden als auch in neuen Codes zuverlässig vermeidet. Dabei bleiben wir praxisnah, zeigen klare Beispiele und geben konkrete Handlungsschritte, damit du schnell wieder produktiv arbeiten kannst.
Was bedeutet der Fehler ‚int object is not iterable‘?
Auf den ersten Blick klingt der Fehlertext knapp und technisch, doch dahinter steckt eine klare Logik: In Python sind viele Strukturen wie Listen, Tupel, Strings oder Generatoren “iterierbar”. Das bedeutet, sie können in einer Schleife durchlaufen oder in einer Funktion, die eine Sequenz erwartet, verarbeitet werden. Ein Integer (int) hingegen ist eine Einzelgröße und besitzt keine Sequenz von Elementen, die nacheinander durchlaufen werden könnte. Wenn du also versuchst, über einen Integer zu iterieren, reagiert Python mit:
TypeError: 'int' object is not iterable
Dieser Fehler zeigt ganz konkret: Dort, wo eine Iteration erwartet wird, liegt kein iterierbares Objekt vor, sondern ein einzelner Zahlenwert. Die zentrale Erkenntnis lautet daher schlicht: Nicht jedes Objekt ist per se durch Iteration zugreifbar. Die Begriffe “iterierbar” bzw. “iterierbar” bezeichnen Objekte, von denen man einen Iterator erhalten kann, der die Elemente nacheinander liefert.
Int object is not iterable: Typische Ursachen im Alltag
Um den Fehler zu beheben, lohnt es sich, typische Muster zu kennen, die zu einer fälschlichen Annahme führen, dass ein Integer iterierbar sei. Hier sind die häufigsten Gründe, die in der Praxis auftreten:
1) Eine Variable wird fälschlich als Sequenz genutzt
Du nimmst eine Variable, die eigentlich nur eine Zahl speichert, und verwendest sie in einer Schleife oder in einer Funktion, die eine Sequenz erwartet. Das passiert oft, wenn man Code aus einer Vorversion übernimmt oder Parameter dynamisch weitergibt.
anzahl = 5
for x in anzahl: # Fehler, da 'int' nicht iterierbar ist
print(x)
2) Unpassende Nutzung von Funktionen, die List- oder Tuple-ähnliches Verhalten erwarten
Viele Funktionen akzeptieren Listen oder andere Sequenzen. Werden jedoch versehentlich einzelne Werte wie eine Zahl übergeben, tritt der Fehler auf.
def verarbeite_seed(seeds):
for s in seeds:
print(s)
verarbeite_seed(10) # TypeError: 'int' object is not iterable
3) Unkorrekte Entkopplung von Funktionen und Rückgabewerten
Manchmal wird ein Funktionsaufruf in einer Schleifenbedingung oder als Teil eines Konstruktionsprozesses verwendet, wobei der Rückgabewert eine Zahl ist, statt einer Liste oder Sequenz.
for item in get_items(): # get_items gibt versehentlich eine einzelne Zahl zurück
print(item)
4) Unvollständige oder fehlerhafte Datenstrukturen
In komplexeren Datentransformationen kann eine Struktur versehentlich eine einzige Zahl statt einer Sequenz enthalten. Das wird besonders bei JSON-Parsing, API-Abrufen oder dynamisch erzeugten Strukturen sichtbar.
daten = {'werte': 42} # Erwartung: eine Liste von Werten
for v in daten['werte']:
print(v) # TypeError: 'int' object is not iterable
Verständnis der Iterierbarkeit: Was ist wirklich iterierbar?
Um zu erklären, warum einige Objekte iterierbar sind und andere nicht, lohnt ein kurzer Blick auf das Python-Iterationsmodell. Objekte sind dann iterierbar, wenn sie einen Iterator bereitstellen können. Technisch bedeutet das, dass ein Objekt eine __iter__()-Methode implementiert oder zumindest so aussieht, dass es in einer Schleife verwendet werden kann. Beispiele für iterierbare Objekte sind Listen, Tupel, Strings, Dictionaries (Standarditeration über Keys), Sets und Generatoren.
Integer erfüllen diese Anforderungen nicht, weil sie keine Sequenz von Elementen enthalten. Sie sind eine einzelne Menge von Information, nicht eine Ansammlung von Teilen, die nacheinander abgearbeitet werden können. Der Fehler „int object is not iterable“ entsteht also genau an diesem Punkt, wenn der Code von einem iterierbaren Objekt erwartet, dass es eine Folge von Elementen liefert, das tatsächliche Objekt aber ein einzelner Integer ist.
Häufige Varianten des Fehlers und wie sie sich unterscheiden
Es gibt mehrere Varianten des TypeError, die sich formal ähneln, aber in der Praxis unterschiedliche Ursachen haben. Die zentrale Variante bleibt meist dieselbe, doch mit mehr Kontext oder unterschiedlichen Formulierungen:
„TypeError: ‚int‘ object is not iterable“
Dies ist die direkteste Form des Problems. Ein Objekt vom Typ int wird in einer Stelle verwendet, an der eine Sequenz erwartet wird. Typische Szenarien sind for-Schleifen, Listenkonstruktionen oder Funktionen, die Iteration verlangen.
„TypeError: cannot unpack non-iterable int object“
Diese Meldung taucht häufig beim Entpacken von Werten auf, z.B. wenn man versucht, eine Tuple-Struktur aus einer Funktion zu erhalten, aber stattdessen eine einzelne Zahl erhält. Der Kern bleibt gleich: Es geht um fehlende Iterierbarkeit im Kontext des Entpackens.
„TypeError: ‚int‘ object is not subscriptable“
Eine verwandte Fehlermeldung, die auftreten kann, wenn man versucht, über Indizes auf einen Integer zuzugreifen, z.B. mit einer Syntax wie obj[0] bei einem Integer.
Konkrete Code-Beispiele und wie du sie korrigierst
Praktische Beispiele zeigen, wie der Fehler entsteht und wie man ihn behebt. Die folgenden Fälle illustrieren gängige Muster und liefern direkt umsetzbare Lösungen.
Beispiel 1: Schleife über eine Zahl statt über eine Liste
zahlen = 7
for zahl in zahlen:
print(zahl)
Lösung:
zahlen = [0, 1, 2, 3, 4, 5, 6]
for zahl in zahlen:
print(zahl)
Beispiel 2: Falsche Nutzung einer Funktion, die eine Sequenz erwartet
def hole_alle():
return 5 # sollte eine Sequenz liefern
for item in hole_alle():
print(item)
Lösung:
def hole_alle():
return [5] # eine Sequenz zurückgeben
for item in hole_alle():
print(item)
Beispiel 3: Rückgabewert einer API, der eine Liste sein soll
ergebnisse = fetch_results() # Fehlerquelle: einzelne Zahl statt Liste
for r in ergebnisse:
verarbeite(r)
Lösung:
ergebnisse = fetch_results()
if isinstance(ergebnisse, list):
for r in ergebnisse:
verarbeite(r)
else:
verarbeite(ergebnisse) # oder konvertiere in eine Liste: [ergebnisse]
Beispiel 4: Fehler beim Entpacken von Rückgabewerten
def get_pair():
return 1, 2
a, b, c = get_pair() # Erwartet 3 Werte, erhält nur 2
Lösung:
a, b = get_pair() # Richtige Anzahl der Werte
Best Practices, um den Fehler von vornherein zu vermeiden
Prävention ist oft der beste Weg, um Typfehler wie „int object is not iterable“ zu vermeiden. Hier sind bewährte Methoden, die dir helfen, robusteren Code zu schreiben:
1) Explizite Typ-Checks und klare Schnittstellen
Nutze klare Funktionssignaturen und füge ggf. Typannotationen hinzu, um die erwarteten Typen sichtbar zu machen. Durch Typprüfungen lässt sich Fehlschaltungen früh erkennen.
def verarbeite_werte(werte: list[str] | list[int]) -> None:
for w in werte:
verarbeite(w)
2) Standardwerte und sinnvolle Rückgabewerte
Wenn Funktionen Sequenzen zurückgeben sollen, sichere Standardwerte ab und stelle sicher, dass Rückgabewerte konsistent sind (z. B. immer eine Liste oder ein Generator).
def hole_alle() -> list[int]:
# garantiert immer eine Liste zurückgeben
return [1, 2, 3]
3) Nutzung von isinstance und issubclass
Prüfe den Typ der Objektarten gezielt, bevor du eine Schleife darüber laufen lässt.
response = fetch_response()
if isinstance(response, (list, tuple)):
for item in response:
verarbeite(item)
else:
verarbeite([response])
4) Schreibe testspezifische Tests, die Fehlerfälle abdecken
Automatisierte Tests helfen, Typfehler früh zu erkennen. Schreibe Tests, die sicherstellen, dass Funktionen eine Sequenz zurückgeben, auch wenn die Eingaben variieren.
Wie du den Fehler intelligent debugst
Debugging-Strategien helfen, den Ursprung des Fehlers schnell zu lokalisieren und interpretierbar zu machen. Hier sind sinnvolle Schritte:
Schritt 1: Fehlermeldungen genau lesen
Notiere dir die Zeilennummer, an der der Fehler auftritt, und welche Variable iteriert werden soll. Oft genügt eine einfache Print-Ausgabe, um die Art des Objekts zu prüfen.
print(type(zielobjekt))
print(zielobjekt)
Schritt 2: Typ-Feststellungen an kritischen Stellen
Setze gezielte Assertions oder Checks, um sicherzustellen, dass die Werte den Erwartungen entsprechen.
assert isinstance(zielobjekt, (list, tuple, str)), "Zielobjekt muss iterierbar sein"
Schritt 3: Schrittweise Ausführung und Minifizierung
Führe den Code schrittweise aus oder isolierte Funktionsblöcke aus, um genau zu sehen, wo der Typfehler auftritt. Das reduziert Fehlinterpretationen.
Fortgeschrittene Konzepte rund um Iterierbarkeit
Wenn du tiefer in das Thema einsteigen willst, lohnt sich ein Blick auf einige fortgeschrittene Konzepte, die in der Praxis oft nützlich sind:
1) Iteratoren und Generators
Generatoren liefern Elemente on-the-fly, ohne eine komplette Liste im Speicher zu halten. Sie ermöglichen effiziente, speicherschonende Iterationen – ideal für große Datenmengen oder unendliche Sequenzen.
def zähle_unendlich():
i = 0
while True:
yield i
i += 1
2) Mapping von Funktionen auf Sequenzen
Funktionen wie map oder List-Comprehensions arbeiten auf iterierbaren Objekten. Achte darauf, dass der Eingabetyp tatsächlich iterierbar ist.
zahlen = [1, 2, 3]
quadrate = [x*x for x in zahlen]
3) Fehlertolerante Programmierung
Entwerfe Funktionen so, dass sie robust gegen unerwartete Eingaben sind, z. B. durch Umwandlung in eine Liste, falls nötig.
def sicher_als_liste(obj):
if isinstance(obj, list):
return obj
return [obj]
Häufige Fallstricke in der Praxis
Auch erfahrene Entwickler stolpern gelegentlich bei dieser Art von Fehlern. Hier sind einige typische Fallstricke, die oft unbemerkt bleiben:
1) Verwechslung von Eingangs- und Ausgangsdaten
Manchmal werden Parameter aus einer API oder Funktion falsch verstanden. Ein kurzer Blick auf die Spezifikation oder eine Typüberprüfung hilft hier enorm.
2) gemischt verwendete Datentypen
In größeren Codebasen kommen Lists, Tuples, Sets und Strings zusammen. Eine fehlerhafte Mischung von Typen führt schnell zu TypeErrors, besonders wenn dynamisch generierte Inhalte beteiligt sind.
3) Fehlende Dokumentation der Funktionen
Ohne klare Dokumentation über den erwarteten Typ der Rückgabewerte steigt die Wahrscheinlichkeit, in eine Falle zu geraten, in der ein int statt einer Sequenz geliefert wird.
Zusammenfassung: Wenn Int objects andauernd iterierbar sein sollen
Der Fehler «int object is not iterable» ist ein Signal dafür, dass an einer Stelle im Code eine Annahme über die Iterierbarkeit einer Variable falsch getroffen wurde. Diese Erkenntnis führt zu zwei einfachen Strategien: Entweder sicherstellen, dass die betreffenden Werte wirklich Sequenzen sind, oder den Code so umgestalten, dass er auch mit Einzelwerten funktioniert – z. B. durch Umwandlung in Listen oder die Prüfung des Typs, bevor eine Schleife gestartet wird. Mit klaren Schnittstellen, robusten Typprüfungen und konsequenter Fehlerbehandlung lässt sich dieser TypeError in den Griff bekommen und der Code wird insgesamt verlässlicher.
Weitere Ressourcen und Tipps für Entwickler
Abseits des praktischen Codes bietet es sich an, bewährte Lernressourcen zu nutzen, wenn du dein Verständnis rund um Iterierbarkeit vertiefen willst. Lesen, üben und experimentieren bleiben die drei Kernbausteine:
- Offizielle Python-Dokumentation zum Thema Iterierbarkeit und Iteratoren
- Interaktive Lernplattformen, die Typfehler gezielt abprüfen
- Open-Source-Beispiele mit Fokus auf robustes Fehlerhandling
Pflege dein Codebase: Wartung und Zukunftssicherheit
Bei der Wartung von Projekten ist es sinnvoll, Lehren aus dem Fehler „int object is not iterable“ in den Codestand zu übertragen. Fördere die Lesbarkeit mit klaren Variablennamen, dokumentiere die Erwartungen an Funktionen und verabschiede dich von übermäßig komplexen Verkettungen, die zu unklaren Datentypen führen könnten. Langfristig spart das Zeit, verhindert Fehler und verbessert die Teamproduktivität.
Schlussgedanken: Warum dieser Fehler so wichtig bleibt
Obwohl er einfach klingt, hat der Fehler „int object is not iterable“ eine große Bedeutung im täglichen Softwareentwicklungsprozess. Er erinnert daran, wach zu bleiben gegenüber den Datentypen, mit denen man arbeitet, und zeigt, wie wichtig es ist, klare Abstraktionen und stabile Schnittstellen zu definieren. Wer ihn versteht, trifft bessere Entscheidungen beim Design von Funktionen, Schleifen und Datentransformationen – und sorgt dafür, dass Python-Projekte robuster, wartbarer und langlebiger werden.