Tuples as Immutable Records and Hashable Keys

15 min · Beginner

While lists are designed for homogeneous collections of changing length, tuples represent fixed, immutable records. Because tuples cannot change, Python optimizes their memory footprint and allows them to serve as hashable keys in sets and dictionaries.

Tuples vs Lists: Memory Layout

Tuple is an ordered, fixed-length collection of items. Once it is created, you cannot add, remove or replace its items.

Tuples have zero over-allocation slack space. Their pointer array matches the exact element count.

Python

import syst = (1, 2, 3)l = [1, 2, 3]print("Tuple size:", sys.getsizeof(t))print("List size: ", sys.getsizeof(l))

Lists have slack capacity slots for dynamic growth; tuples are exact and compact.

Example 1 · List and tuple size

Python

1import sys2
3marks_list = [72, 85, 91]4marks_tuple = (72, 85, 91)5print("list :", sys.getsizeof(marks_list), "bytes")6print("tuple:", sys.getsizeof(marks_tuple), "bytes")

Sample output

list : 88 bytes
tuple: 64 bytes

What this code does

The tuple is smaller because it has no spare slots.
Exact byte counts depend on the Python version, so treat them as a sample.

Tuples consume significantly less RAM and are allocated via a freelist in CPython, making small tuple creation exceptionally fast.

Tuples as Composite Dictionary Keys

Hashable describes a value with a fixed hash number that never changes, so it can be a dictionary key or a set member.

Because lists are unhashable, you cannot use a list as a dictionary key. Tuples (containing hashable elements) are hashable and ideal for multidimensional coordinates and composite keys.

Python

1# Grid coordinate mapping2grid = {}3grid[(0, 0)] = "Start"4grid[(4, 5)] = "Treasure"5grid[(9, 9)] = "Goal"6
7print("Target at (4, 5):", grid[(4, 5)])

Example 2 · Price list by product and region

Python

1prices = {2    ("laptop", "IN"): 55000,3    ("laptop", "US"): 799,4    ("phone", "IN"): 18000,5}6key = ("laptop", "US")7print(prices[key])8print(("tablet", "IN") in prices)

Output

799
False

What this code does

Each key is a (product, region) pair, so one dictionary holds two dimensions.
in checks the whole tuple key in O(1) on average.

This pattern is widely used in graph algorithms, spatial grids, and multi-column database caching.

Extended Star Unpacking

Unpacking assigns the items of a tuple or list to separate names in one statement, such as lat, lon = coords.

Python allows unpacking arbitrary segments of tuples using the star * operator.

Python

record = ("IND", 2026, 95.5, "Aarav", "Verified")country, year, score, *rest = recordprint(f"{country} ({year}): score {score} | Extra: {rest}")

Example 3 · Drop the best and worst marks

Python

marks = [88, 92, 75, 60, 95]first, *middle, last = marksprint(first, middle, last)print("Middle total:", sum(middle))

Output

88 [92, 75, 60] 95
Middle total: 227

What this code does

*middle collects everything between the first and last values into a list.
Unpacking works on any sequence, not only tuples.

*rest gathers any remaining elements into a clean list.

Structured Records with namedtuple

namedtuple is a factory in the collections module that builds a tuple type whose positions also have names.

collections.namedtuple assigns names to each position, giving you tuple memory efficiency with attribute access.

Python

1from collections import namedtuple2
3Point2D = namedtuple("Point2D", ["x", "y"])4pt = Point2D(10, 25)5print(f"X: {pt.x}, Y: {pt.y}")6print(pt[0])  # Still accessible by index!

Example 4 · A record with names

Python

1from collections import namedtuple2
3City = namedtuple("City", ["name", "country", "population"])4bengaluru = City("Bengaluru", "India", 13.6)5print(f"{bengaluru.name} ({bengaluru.country}): {bengaluru.population}M")6print("Is tuple:", isinstance(bengaluru, tuple))

Output

Bengaluru (India): 13.6M
Is tuple: True

What this code does

City creates a namedtuple subclass.
Attributes are accessible via .name or [0].
Instances inherit full tuple immutability and hashability.

Namedtuples combine readability with the immutability and speed of tuples.

Immutable, but only one level deep

Shallow immutability means a tuple never changes which objects it holds, but a mutable object inside it can still change.

A tuple fixes its pointers, not the objects behind them. A list inside a tuple can still change, and that also makes the tuple unhashable.

Python

1record = ("A-1", [3, 4])2record[1].append(5)3print(record)4
5try:6    hash(record)7except TypeError as error:8    print("Cannot hash:", error)

Example 5 · Hashing a record

Python

1safe = ("A-1", 3)2risky = ("A-1", [3])3print(hash(safe) == hash(("A-1", 3)))4try:5    hash(risky)6except TypeError as error:7    print("Unhashable:", error)

Output

True
Unhashable: unhashable type: 'list'

What this code does

Equal tuples of immutable items give equal hashes.
A list inside the tuple makes the whole tuple unhashable.

Use only immutable items (numbers, strings, other tuples) inside a tuple that must act as a dictionary key.

Next step

Check your understanding

10 quick questions

Tuples as Composite Dictionary Keys

Hashable describes a value with a fixed hash number that never changes, so it can be a dictionary key or a set member.

Because lists are unhashable, you cannot use a list as a dictionary key. Tuples (containing hashable elements) are hashable and ideal for multidimensional coordinates and composite keys.

1from collections import namedtuple2 3City = namedtuple("City", ["name", "country", "population"])4bengaluru = City("Bengaluru", "India", 13.6)5print(f"{bengaluru.name} ({bengaluru.country}): {bengaluru.population}M")6print("Is tuple:", isinstance(bengaluru, tuple))