zip()

zip() is Python’s built-in function for parallel iteration — it takes multiple iterables and returns an iterator of tuples, where each tuple contains one element from each iterable at the same position. It stops at the shortest iterable (by default), making it perfect for combining lists, transposing matrices, pairing data with indices, or merging columns in data processing. In 2026, zip() remains essential in data science (pandas/Polars/Dask column pairing, multi-source alignment), software engineering (parallel loops, dictionary creation), and functional programming — now enhanced with strict=True (Python 3.10+) for length mismatch errors, and tight integration with comprehensions, unpacking, and itertools.

Here’s a complete, practical guide to using zip() in Python: basic pairing, strict mode, unpacking, real-world patterns (earthquake lat/lon pairing, multi-column processing, matrix transpose), and modern best practices with type hints, performance, strict checking, and integration with pandas/Polars/Dask/NumPy.

Basic zip(*iterables, strict=False) — pair elements from multiple iterables.


names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
cities = ['Paris', 'Tokyo', 'Berlin']

# Pair names with ages
for name, age in zip(names, ages):
    print(f"{name} is {age} years old")
# Alice is 25 years old
# Bob is 30 years old
# Charlie is 35 years old

# Pair all three (stops at shortest)
zipped = zip(names, ages, cities)
print(list(zipped))
# [('Alice', 25, 'Paris'), ('Bob', 30, 'Tokyo'), ('Charlie', 35, 'Berlin')]

# Different lengths ? stops at shortest
short = [1, 2]
long = [10, 20, 30, 40]
print(list(zip(short, long)))  # [(1, 10), (2, 20)]

Strict mode (Python 3.10+) — raises ValueError if iterables have unequal lengths.


try:
    list(zip(names, ages, [1, 2], strict=True))
except ValueError as e:
    print(e)  # zip() argument 3 is shorter than argument 1

Real-world pattern: earthquake data pairing & multi-column processing — zip columns for combined features.


import pandas as pd

df = pd.read_csv('earthquakes.csv')

# Zip lat/lon into coordinate tuples
coords = list(zip(df['latitude'], df['longitude']))
print(coords[:3])  # [(lat1, lon1), (lat2, lon2), ...]

# Zip mag with place for formatted strings
reports = [f"Mag {m:.1f} at {p}" for m, p in zip(df['mag'], df['place'])]
print(reports[:3])

# Polars: zip columns into struct
import polars as pl
pl_df = pl.from_pandas(df)
pl_df = pl_df.with_columns(
    pl.struct([pl.col('latitude'), pl.col('longitude')]).alias('coords')
)
print(pl_df['coords'].head())

# Dask: zip with map_partitions
import dask.dataframe as dd
ddf = dd.from_pandas(df, npartitions=4)
ddf['coords'] = ddf.map_partitions(lambda df: list(zip(df['latitude'], df['longitude'])))
print(ddf['coords'].head())

Best practices for zip() in Python & data workflows. Prefer zip() with strict=True — when lengths must match (catches bugs early). Modern tip: use Polars pl.struct(...) — for typed column pairing; Dask ddf.assign(coords=...) for parallel. Use zip() with enumerate() — for i, (x, y) in enumerate(zip(a, b)). Add type hints — from typing import Iterable, Tuple; def pair_data(a: Iterable[T], b: Iterable[U]) -> Iterable[Tuple[T, U]]: return zip(a, b). Use zip(*lists) — to transpose matrix: list(zip(*matrix)). Use dict(zip(keys, values)) — create dict from two lists. Use zip() in comprehensions — [f(x, y) for x, y in zip(a, b)]. Use zip_longest() from itertools — pad shorter iterables. Use zip() with generators — zip(gen1, gen2) lazy pairing. Use zip() in pandas — df.assign(new_col=list(zip(df.col1, df.col2))). Use zip() with map() — map(func, *zip(a, b)) for multi-arg mapping. Use zip() with filter() — filter(pred, zip(a, b)) for paired filtering. Use zip() in unpacking — a, b = zip(*pairs) to unzip. Use zip() with sorted() — sorted(zip(scores, names), reverse=True) for ranked pairs. Use zip() in progress bars — tqdm(zip(a, b)). Use zip() with itertools.starmap() — starmap(func, zip(a, b)) for unpacked args. Use zip() with itertools.tee() — duplicate zipped iterator. Use zip() in parallel loops — for x, y in zip(a, b): process(x, y). Use zip() with range(len()) — zip(range(len(lst)), lst) (prefer enumerate). Use zip() in matrix operations — transpose with zip(*matrix).

zip(*iterables, strict=False) pairs elements from multiple iterables into tuples — stops at shortest, raises error with strict=True. In 2026, use for parallel iteration, column pairing, transposition, and integrate with pandas/Polars/Dask for multi-source alignment. Master zip(), and you’ll combine data streams cleanly and efficiently in any Python workflow.

Next time you need to process multiple sequences in parallel — use zip(). It’s Python’s cleanest way to say: “Pair these iterables together — element by element, ready for processing.”

Generating content...