Tuples — immutability, use cases — Coding notes

WHAT is a tuple?

Definition Tuple

A tuple is an ordered, immutable collection of values, written with parentheses and comma-separated items:

point = (3, 4)
rgb   = (255, 128, 0)
single = (42,)      # one-element tuple NEEDS the trailing comma
empty  = ()

Ordered → items have fixed positions (point[0] is 3).
Immutable → after creation you cannot change, add, or delete elements.
Heterogeneous → may hold mixed types: ("Asha", 21, 5.6).

Common mistake "The parentheses make a tuple."

Why it feels right: we see (3, 4) and assume () is what matters. The truth: it's the comma that builds a tuple, not the parentheses!

a = (3)     # this is just the int 3  (parens = grouping)
b = (3,)    # THIS is a 1-tuple
c = 3, 4    # also a tuple! → (3, 4)

Fix: for a single-element tuple always add the trailing comma.

WHY does immutability exist? (first-principles reasoning)

Programming languages give us two flavours of collection on purpose:

Lists — when data changes over time (a growing to-do list).
Tuples — when data should not change (a fixed coordinate, a date).

Deriving "why tuples can be dict keys but lists cannot"

A dictionary stores a key by computing a number from it called a hash. The rule is:

$\text{equal objects} \implies \text{equal hashes, forever}$

HOW the logic flows (derive it):

A dict finds a key by its hash, then checks equality.
If a key's contents could change, its hash would change too.
Then the dict would "lose" the entry — you'd never find it again.
Therefore Python only allows hashable (effectively immutable) keys.
Tuples (of immutable items) are immutable → hashable → ✅ valid keys.
Lists are mutable → unhashable → ❌ TypeError.

d = {(0, 0): "origin"}     # works
d = {[0, 0]: "origin"}     # TypeError: unhashable type: 'list'

HOW tuples behave — the operations you can and cannot do

Figure — Tuples — immutability, use cases

Formula What you CAN do (read-only access)

Operation	Example	Result
Index	`t[0]`	first item
Slice	`t[1:3]`	a new tuple
Length	`len(t)`	count
Membership	`5 in t`	bool
Concatenate	`t1 + t2`	new tuple
Repeat	`t * 3`	new tuple
Unpack	`x, y = t`	assign to vars
Count/Index	`t.count(4)`, `t.index(4)`	the only 2 methods

Worked example Immutability in action — Why this step?

t = (1, 2, 3)
t[0] = 99          # ❌ TypeError

Why this step? Assignment to an index asks Python to overwrite slot 0. Tuples forbid slot writes → error. This is the defining behaviour to remember.

Common mistake "Immutable means deeply frozen."

Why it feels right: "you can't change a tuple" sounds total. The truth: immutability is shallow. The tuple's slots are fixed, but if a slot holds a mutable object (a list), that object can still change.

t = (1, [2, 3])
t[1].append(4)     # ✅ works! t is now (1, [2, 3, 4])
t[1] = [9]         # ❌ still TypeError (can't replace the slot)

Fix: "tuple immutable" = which objects each slot points to is fixed, not the objects themselves.

Worked Examples

Worked example 1. Returning multiple values from a function

def min_max(nums):
    return min(nums), max(nums)   # packs into a tuple
 
lo, hi = min_max([4, 1, 9, 2])    # unpacks
print(lo, hi)   # 1 9

Why this step? return a, b is the classic, idiomatic use of tuples — Python packs the values, the caller unpacks them. Cleaner than building a list you'd never modify.

Worked example 2. Swapping variables (no temp needed)

a, b = 10, 20
a, b = b, a      # right side becomes (20, 10), then unpacks
print(a, b)      # 20 10

Why this step? The right-hand side b, a forms a temporary tuple (20, 10) before assignment, so no helper variable is required.

Worked example 3. Using tuples as dictionary keys (grid)

board = {}
board[(0, 0)] = "X"
board[(1, 2)] = "O"
print(board[(0, 0)])   # X

Why this step? Coordinates are a fixed pair that should never change identity → perfect immutable key. A list [0,0] would crash here.

Worked example 4. Counting & finding (the only tuple methods)

t = (5, 3, 5, 8, 5)
print(t.count(5))   # 3
print(t.index(8))   # 3  (position of first 8)

Why this step? Tuples expose only count and index because every other list method (append, sort, remove...) would mutate — and that's forbidden.

Tuple vs List — when to pick which (80/20)

	Tuple	List
Syntax	`()`	`[]`
Mutable?	No	Yes
Hashable?	Yes (if items are)	No
Speed	Slightly faster/leaner	More overhead
Methods	`count`, `index`	many (`append`…)

Active Recall

Recall Forecast-then-Verify (predict before you read the answer)

What does type((5)) print? → <class 'int'> (no comma ⇒ not a tuple).
Can (1, [2]) be a dict key? → No — it contains a list, so it's unhashable.
Does t + (1,) modify t? → No — builds a new tuple.
What two methods do tuples have? → count and index.

Recall Feynman: explain to a 12-year-old

Imagine a row of glued-together lockers. You labelled each locker and put a toy inside. Because they're glued, you can't add a new locker or yank one out — that's a tuple: ordered and locked. A list is lockers on wheels you can rearrange anytime. Now, if you put an open box of crayons inside a glued locker, you can't move the locker, but you can still drop more crayons in the box — that's why a tuple holding a list can still have that list changed.

Connections

Lists — mutability, methods — the mutable counterpart; choose between them.
Dictionaries — keys and values — tuples shine as immutable keys.
Sets — hashing & uniqueness — only hashable (tuple-like) items allowed.
Functions — return values — multiple returns are really tuples.
Mutable vs Immutable objects — the parent concept (int, str, tuple vs list, dict, set).
Hashing in Python — why immutability enables dict keys.

What syntactically defines a tuple — parentheses or the comma?

The comma; parentheses are optional grouping. 3, 4 is a tuple, (3) is just an int.

How do you write a one-element tuple?

With a trailing comma: (42,).

Why can tuples be dictionary keys but lists cannot?

Tuples are immutable → hashable (stable hash), lists are mutable → unhashable, so they'd break the dict's lookup.

What error do you get from t[0] = 5 on a tuple?

TypeError — tuples don't support item assignment.

Is tuple immutability deep or shallow?

Shallow — the slots are fixed, but a mutable object stored inside (e.g. a list) can still be modified.

Name the only two tuple methods.

count and index.

Does t = t + (9,) mutate the original tuple?

No — it creates a new tuple and rebinds the name t.

How does swapping a, b = b, a work internally?

The right side b, a is packed into a temporary tuple, then unpacked into a and b.

When should you prefer a tuple over a list (80/20 rule)?

For fixed records, dict/set keys, and data that must not change accidentally.

What does a function return min(x), max(x) actually return?

A tuple (min, max) that the caller can unpack.

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Socho tuple ek sealed envelope hai aur list ek open box. Tuple ko () aur commas se banate hain — par yaad rakho asli cheez comma hai, parentheses nahi. (3) toh sirf integer 3 hai, lekin (3,) ek tuple hai. Tuple ke andar items ka order fixed hota hai aur ek baar bana lo toh tum unhe change, add ya delete nahi kar sakte — isi ko immutability kehte hain. List me ye sab allowed hai.

Immutability ka faayda kya hai? Kyunki tuple kabhi badalta nahi, isko dictionary ki key ya set ka element banaya ja sakta hai. Reason simple hai: dict key ko hash number se dhoondhta hai, aur agar value badal jaaye toh hash bhi badal jaayega aur entry kho jaayegi. Isliye Python sirf immutable (hashable) cheezon ko key banane deta hai — tuple chalega, list TypeError degi. Grid ya coordinates (x, y) store karne ke liye tuple perfect hai.

Ek important trap: immutability shallow hoti hai. Agar tuple ke andar ek list rakhi hai, jaise t = (1, [2, 3]), toh t[1].append(4) chal jaayega! Slot fixed hai, lekin slot jis list ko point kar raha hai woh badal sakti hai. Lekin t[1] = [9] phir bhi error dega.

Practical use: functions se ek saath multiple values return karna (return min, max) actually tuple hi hota hai, aur a, b = b, a se variable swap bhi tuple packing-unpacking se hota hai. Rule of thumb (80/20): fixed record ya key chahiye → tuple; data badalta rahega → list.

Tuples — immutability, use cases

WHAT is a tuple?

WHY does immutability exist? (first-principles reasoning)

Deriving "why tuples can be dict keys but lists cannot"

HOW tuples behave — the operations you can and cannot do

Worked Examples

Tuple vs List — when to pick which (80/20)

Active Recall

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — Introduction to Programming (Python)

Connections