Locked Boxes — Tuples

By the end of this lesson you can:

• Create a tuple with round brackets ( ) and read items back by index.
• Explain "immutable" in plain words and predict what crashes when you try to change a tuple.
• Pick between a list and a tuple based on whether the data should ever change.

Think of two real-world "collections":

• A shopping basket — items go in, items come out, the contents change every minute.
• Your date of birth — three numbers (day, month, year) that should never change once they're set.

Both are collections. But the second one shouldn't allow .append() at all — that's a bug waiting to happen. Today we'll see the tool Python gives us for "locked" data.

Predict the output:

birthday = (12, 8, 2014)
print(birthday[0])
print(len(birthday))

12
3

Building one

Use round brackets ( ) instead of square brackets:

point     = (10, 20)
birthday  = (12, 8, 2014)
colours   = ("red", "green", "blue")
empty     = ()

Python also accepts a comma-only form — the brackets are optional when there's no ambiguity. These two lines are identical:

a = (1, 2, 3)
b = 1, 2, 3
print(a == b)   # → True

not_a_tuple = (5)        # this is just the number 5
one_tuple   = (5,)       # this is a tuple of one item
print(type(not_a_tuple)) # → <class 'int'>
print(type(one_tuple))   # → <class 'tuple'>

Reading from a tuple

Everything you learned about reading lists also works on tuples:

birthday = (12, 8, 2014)
print(birthday[0])   # → 12   (the day)
print(birthday[-1])  # → 2014 (the year)
print(len(birthday)) # → 3
for n in birthday:
    print(n)

What you can't do

Try any of these and Python crashes with TypeError: 'tuple' object does not support item assignment:

birthday = (12, 8, 2014)
birthday[0] = 13        # ❌ can't reassign
birthday.append(5)      # ❌ no .append()
birthday.remove(8)      # ❌ no .remove()
del birthday[0]         # ❌ no del

The tuple is locked. To "change" it, you build a brand-new one:

birthday = (12, 8, 2014)
birthday = (12, 8, 2015)     # not edited — replaced
print(birthday)

Why bother with locked data?

Three good reasons:

• Safety. If a value should never change — coordinates, RGB colours, dates of birth — using a tuple turns a sneaky bug into an immediate crash. Better a crash than wrong data.
• Speed. Tuples are a tiny bit faster than lists, because Python knows they can't grow.
• Talking shape. Functions love to return tuples to hand back several values at once. We'll see that in PY-L2-04.

List vs tuple — when to use which

Use a LIST when…           Use a TUPLE when…
- the contents will change  - the data is fixed
- you need .append()        - the order/positions have meaning
- it's "a bag of things"    - it's "one combined value"
  (orders, students, tags)    (a point, an RGB colour, a row)

The story

You're building a map of the school's sports day. Each event has a fixed location on the field (an x, y coordinate) and a fixed team colour (an R, G, B triple).

Locations and colours shouldn't change once the day starts — so we model them as tuples. The list of events, on the other hand, will grow as new ones are added — that's a list of tuples.

Save as sports_day.py:

Code

# sports_day.py — fixed coordinates and colours

# Each event = (name, location-tuple, colour-tuple)
events = [
    ("100m Sprint",   (50, 10), (255,   0,   0)),
    ("Long Jump",     (80, 30), (  0, 200,   0)),
    ("Tug of War",    (10, 60), (  0,   0, 255)),
]

for name, loc, rgb in events:
    print(name)
    print("  Location:", loc)
    print("  Colour  :", rgb)
    print()

Output

100m Sprint
  Location: (50, 10)
  Colour  : (255, 0, 0)

Long Jump
  Location: (80, 30)
  Colour  : (0, 200, 0)

Tug of War
  Location: (10, 60)
  Colour  : (0, 0, 255)

What the loop is doing

That for name, loc, rgb in events line is doing two things at once:

1. Walking through the list of events — like every for loop.
2. Unpacking each three-item tuple into three named variables. We'll spend all of PY-L2-04 on unpacking — for now, just notice that we get three clean names instead of having to write events[0][0], events[0][1], etc.

The locked-data demo

Add this at the bottom of the file and run it:

first_event = events[0]
print(first_event)
# Try to change the colour to yellow:
first_event[2][0] = 255    # this changes the inner tuple? Let's see…
# TypeError: 'tuple' object does not support item assignment

Python refuses. The colour is a tuple — locked. If we'd used a list [255, 0, 0] instead, the change would have gone through silently and our "red event" would be a different red on the next page. Better the crash.

Three quick exercises. Type each one in a fresh file.

dob = (12, 8, 2014)
print("Day  :", dob[0])
print("Month:", dob[1])
print("Year :", dob[-1])
print("Items:", len(dob))

dob = (12, 8, 2014)
dob[2] = 2015
# TypeError: 'tuple' object does not support item assignment

a = (7)
b = (7,)
print(type(a))   # → <class 'int'>
print(type(b))   # → <class 'tuple'>
# Brackets alone don't make a tuple — only the comma does.

A tuple is an ordered collection like a list, but locked at creation. You build it with round brackets — or just commas — and you read from it with the same square-bracket indexing you already know. You can't append, remove or reassign items; Python crashes if you try. Use a tuple whenever the data shouldn't change: coordinates, colours, dates, anything that represents one combined value.