zip()

Einleitung

zip() ist Pythons Antwort auf das klassische „zwei parallele Listen mit gemeinsamem Index". Statt for i in range(len(a)): a[i], b[i] schreibt man for x, y in zip(a, b) — kürzer, lesbarer, und funktioniert auch mit Iteratoren, die kein len() haben.

Drei wichtige Eigenschaften:

1. Stoppt am kürzesten Iterable — übrige Elemente werden ignoriert.
2. Lazy — wertet ein Element pro Schritt aus, kein Pre-Materialize.
3. Keine Begrenzung der Argumentanzahl — zip(a, b, c, d, ...) funktioniert mit beliebig vielen Iterables.

Mit strict=True (Python 3.10+) erzeugt zip() einen ValueError, sobald die Iterables unterschiedlich lang sind — schützt vor versehentlichem Daten-Verlust.

zip(*matrix) ist außerdem ein eleganter Trick zum Transponieren einer Matrix.

Syntax

zip(*iterables, strict=False)

Rückgabewert

Ein zip-Iterator, der bei jedem Schritt ein Tupel mit je einem Element aus jedem Iterable liefert.

Beispiele

Standard-Verwendung

zip() macht parallele Iteration zur Einzeiler-Schleife — keine Index-Bookkeeping nötig:

names = ["Alice", "Bob", "Cleo"]
ages  = [17, 24, 31]
for name, age in zip(names, ages):
    print(f"{name} ist {age} Jahre alt")

Alice ist 17 Jahre alt
Bob ist 24 Jahre alt
Cleo ist 31 Jahre alt

Verschiedene Längen

Standardmäßig stoppt zip() beim kürzesten Iterable — überzählige Elemente fallen einfach weg:

a = [1, 2, 3, 4, 5]
b = ["a", "b", "c"]
print(list(zip(a, b)))

[(1, 'a'), (2, 'b'), (3, 'c')]

Mit strict=True (Python 3.10+)

Wenn unterschiedliche Längen ein Bug-Indikator sind, schützt strict=True vor stillem Daten-Verlust:

a = [1, 2, 3]
b = ["a", "b"]
try:
    list(zip(a, b, strict=True))
except ValueError as e:
    print(e)

zip() argument 2 is shorter than argument 1

Mehrere Iterables

zip() ist nicht auf zwei Iterables beschränkt — beliebig viele funktionieren parallel:

names    = ["Alice", "Bob", "Cleo"]
ages     = [17, 24, 31]
cities   = ["Berlin", "Wien", "Zürich"]
for name, age, city in zip(names, ages, cities):
    print(f"{name} ({age}) lebt in {city}")

Alice (17) lebt in Berlin
Bob (24) lebt in Wien
Cleo (31) lebt in Zürich

Praktische Beispiele

Dictionary aus zwei Listen bauen

dict(zip(keys, values)) ist die kanonische Form, eine Map aus parallelen Listen zu konstruieren:

keys = ["host", "port", "ssl"]
values = ["localhost", 8080, True]
config = dict(zip(keys, values))
print(config)

{'host': 'localhost', 'port': 8080, 'ssl': True}

Matrix transponieren mit zip(*matrix)

Mit Star-Unpacking lässt sich zip() zum eleganten Transponierer einer Matrix umfunktionieren — Zeilen werden zu Spalten:

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]
transposed = list(zip(*matrix))
for row in transposed:
    print(row)

(1, 4, 7)
(2, 5, 8)
(3, 6, 9)

Aufeinanderfolgende Paare aus einer Sequenz

Mit zip(seq, seq[1:]) (oder itertools.pairwise ab Python 3.10) lassen sich konsekutive Paare bilden — typisch für Differenz-Berechnungen:

prices = [100, 105, 102, 110, 108]
for prev, curr in zip(prices, prices[1:]):
    change = curr - prev
    symbol = "↑" if change > 0 else "↓"
    print(f"{prev} → {curr}  {symbol} {abs(change)}")

100 → 105  ↑ 5
105 → 102  ↓ 3
102 → 110  ↑ 8
110 → 108  ↓ 2

Unzip mit zip(*pairs)

Was beim Zippen reingeht, kann mit zip(*) wieder rauskommen — perfekt zum Splitten einer Liste von Tupeln:

pairs = [("Alice", 17), ("Bob", 24), ("Cleo", 31)]
names, ages = zip(*pairs)
print(names)
print(ages)

('Alice', 'Bob', 'Cleo')
(17, 24, 31)

Praktische Hinweise

• Lazy: zip() materialisiert nicht — bei sehr großen Iterables eine echte Speicher-Ersparnis.
• strict=True (Python 3.10+) ist die sichere Wahl, wenn ungleiche Längen ein Bug wären.
• itertools.zip_longest(*iters, fillvalue=...) ergänzt fehlende Elemente mit einem Default-Wert — Gegenteil von strict.
• zip(*matrix) zum Transponieren ist ein klassischer Trick — funktioniert sauber für rechteckige Matrizen.
• Verwandte Funktionen: enumerate() (Index + Wert), itertools.zip_longest() (gleicht aus), itertools.pairwise() (3.10+).