tuple()

tuple() is Python’s built-in immutable sequence constructor — it creates a new tuple from any iterable (strings ? characters, lists/ranges ? elements, sets/dicts ? keys, generators ? consumed values), or an empty tuple when called with no arguments. Tuples are ordered, hashable (if elements are hashable), and memory-efficient, making them ideal as dictionary keys, set elements, function returns, and fixed records. In 2026, tuple() remains essential in data science (converting pandas/Polars/Dask results, multi-index creation), software engineering (immutable records, unpacking, caching), and performance-critical code — offering O(1) access, hashability, and zero-copy views when possible.

Here’s a complete, practical guide to using tuple() in Python: creation patterns, common conversions, real-world patterns (earthquake event records, coordinate tuples, unique keys), and modern best practices with type hints, performance, immutability, and integration with pandas/Polars/Dask/NumPy/dataclasses.

Creating tuples — from iterables or empty.


# Empty tuple
empty = tuple()
print(empty)  # ()

# From string ? characters
chars = tuple("Hello")
print(chars)  # ('H', 'e', 'l', 'l', 'o')

# From list/range ? elements
nums = tuple([1, 2, 3, 4])
print(nums)   # (1, 2, 3, 4)

range_tuple = tuple(range(5))
print(range_tuple)  # (0, 1, 2, 3, 4)

# From set/dict ? keys (order not guaranteed)
unique = tuple({1, 2, 2, 3})
print(unique)  # e.g. (1, 2, 3)

keys = tuple({"a": 1, "b": 2})
print(keys)    # e.g. ('a', 'b')

# From generator (consumes it)
gen = (x**2 for x in range(5))
squares = tuple(gen)
print(squares)  # (0, 1, 4, 9, 16)

Real-world pattern: earthquake event records — immutable tuples for keys, coordinates, and fixed data.


import pandas as pd

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

# Create immutable event keys for deduplication
df['event_key'] = df.apply(
    lambda row: tuple([row['time'], row['latitude'], row['longitude']]), axis=1
)

deduped = df.drop_duplicates(subset='event_key')
print(f"Original: {len(df)}, Deduped: {len(deduped)}")

# Coordinate tuples for spatial indexing
df['coords'] = df.apply(
    lambda row: tuple([row['latitude'], row['longitude']]), axis=1
)

# Group by coordinates (hashable tuples)
grouped = df.groupby('coords')['mag'].mean()
print(grouped.head())

# Polars: tuple column creation
import polars as pl
pl_df = pl.from_pandas(df)
pl_df = pl_df.with_columns(
    pl.struct(['latitude', 'longitude']).alias('coords')
)
print(pl_df['coords'].head())

Best practices for tuple() in Python & data workflows. Prefer tuple literals (...) — for static tuples; use tuple() for dynamic creation or conversion. Modern tip: use Polars pl.struct(...) — for structured columns; Dask for distributed tuples. Use tuples as dict keys — immutable & hashable. Use tuples for fixed records — event = (time, mag, place). Add type hints — from typing import Tuple; def get_coords(row) -> Tuple[float, float]: .... Use tuple() to exhaust generators — tuple(gen) consumes it. Avoid tuple() on large generators — memory explosion; use lazy iteration instead. Use tuple(df.itertuples(index=False)) — pandas rows as tuples. Use tuple(ddf.to_delayed()) — Dask partitions as tuples. Use tuple(zip(a, b)) — pairwise tuples. Use tuple(enumerate(seq)) — indexed tuples. Use tuple(sorted(seq)) — sorted immutable sequence. Use tuple(set(seq)) — unique elements (order not preserved). Use tuple(map(func, seq)) — transformed immutable sequence. Use tuple(filter(pred, seq)) — filtered immutable sequence. Use tuple(reversed(seq)) — reversed immutable sequence. Use tuple() for unpacking safety — a, b = tuple(lst) enforces length. Use tuple() in caching — hashable arguments for @cache. Use tuple() with namedtuple — for readable records. Use tuple() in pandas MultiIndex.from_tuples() — hierarchical indexing. Use tuple() in Polars pl.struct(...).to_list() — convert struct to tuple.

tuple(iterable) converts any iterable to an immutable tuple — ordered, hashable, memory-efficient, perfect for fixed records, dictionary keys, and function returns. In 2026, use for immutability, deduplication keys, coordinate storage, and integrate with pandas/Polars/Dask for structured data. Master tuple(), and you’ll handle ordered, unchangeable sequences cleanly and efficiently in any Python workflow.

Next time you need an immutable sequence — use tuple(). It’s Python’s cleanest way to say: “Lock these elements in order — unchangeable, hashable, and ready to use as keys.”

Generating content...