Tuples

What is a tuple?

point = (3, 4)                  # x and y
rgb = (255, 107, 53)            # a color
info = ("Ava", 15, 3.8, True)   # mixed types are fine
print(type(point))              # <class 'tuple'>

When a tuple is the natural choice

A tuple is like a form with a fixed set of boxes. Each position has a meaning that never changes:

• point = (3, 4): position 0 is always x, position 1 is always y.
• rgb = (255, 107, 53): red, green, blue, always in that order.
• birthday = (2010, 5, 17): year, month, day.

You would never "append" a fourth number to a color or a fifth part to a date. The size is part of what the data means, and that is a sign a tuple fits.

Special cases: empty, one item, and tuple()

Why the comma rule exists

Parentheses already have a job in Python: grouping math, like (2 + 3) * 4. So (5) must mean "the number 5, grouped." Python needed some other way to say "a tuple with one thing," and the trailing comma is it.

Check yourself: type((5)) is int, but type((5,)) is tuple. If a one-item tuple behaves like a number, look for a missing comma.

When would you have an empty or one-item tuple?

Usually when a tuple is built by a program, not typed by hand: for example, a search that finds zero or one matching result, or t + (4,) to add a single item to an existing tuple.

Indexing a tuple

days = ("Mon", "Tue", "Wed", "Thu", "Fri")
print(days[0])     # Mon
print(days[2])     # Wed
print(days[-1])    # Fri
print(len(days))   # 5
print(days[5])     # IndexError: tuple index out of range

Reading records by index

student = ("Ava", 15, "Period 3")
name = student[0]
age = student[1]
print(name, "is", age)    # Ava is 15

Indexing reads a tuple; it never changes it. That is why every indexing trick from lists (negative indexes, len(), a variable as the index) works on tuples without any problem.

Tip: when a tuple holds a record, unpacking (slide 9) is often clearer than indexes, because name says more than student[0].

Slicing a tuple

The result keeps the type

Slicing a tuple gives a tuple, slicing a list gives a list, and slicing a string gives a string. Even a slice with one item is still a tuple: days[0:1] is ('Mon',), not 'Mon'.

Out-of-range slices are still safe: days[3:100] gives ('Thu', 'Fri') with no error, and days[10:] gives the empty tuple ().

Tuples are immutable (unchangeable)

What t = t + (4,) really does

1. t + (4,) builds a brand new tuple (1, 2, 3, 4).
2. t = ... moves the name t to that new tuple.
3. The old (1, 2, 3) was never touched. If another name still points to it, that name still sees (1, 2, 3).

So the variable can change what it refers to, but the tuple itself never changes. That is the whole meaning of immutable.

Notice the error types: trying to assign or delete gives a TypeError. Trying a list method gives an AttributeError, which means "tuples don't have a tool by that name."

Why would we want something we cannot change?

Immutability prevents a whole kind of bug

Remember from the lists lesson that b = a gives one list two names, and a change through one name shows up in the other. With a tuple, that can never surprise you, because nothing can change it. You can share a tuple anywhere in your program and be sure it stays the same.

A quick decision test

• "Is this one thing described by several values?" (a point, a date, a student record) → tuple
• "Is this a collection of many similar things that may grow or be sorted?" (all the scores, all the students) → list

What you can do with a tuple

Notice what sorted() gives back

sorted() works on any sequence, but it always returns a list, because it has to build something new in a different order. If you need a sorted tuple, wrap it: tuple(sorted(t)) gives (2, 5, 5, 7, 9).

Tuples can be compared

Python compares tuples one element at a time, left to right, like alphabetizing words letter by letter. (1, 5) < (2, 0) is True because 1 < 2 decides it right away. Only when the first elements tie does Python look at the second.

Packing and unpacking

point = (3, 4)      # packing
x, y = point        # unpacking: x is 3, y is 4

a, b = 1, 2
a, b = b, a         # swap! a is 2, b is 1

q, r = divmod(17, 5)   # divmod gives a tuple: (3, 2)

How the swap works

a, b = b, a looks like magic, but it follows the normal rule: the right side runs first.

1. b, a packs the current values into a tuple: (2, 1).
2. Then the tuple is unpacked: a gets 2 and b gets 1.

In many other languages you need a third "temp" variable to swap. Python's packing and unpacking do it in one line.

Collecting the rest with *

If you only want the first item and everything else together, put a * on one name: first, *rest = (1, 2, 3) makes first 1 and rest the list [2, 3].

Tuples versus lists

Examples to sort out

Converting between tuples and lists

days = ("Mon", "Tue", "Wed")
temp = list(days)        # ['Mon', 'Tue', 'Wed']
temp[0] = "Sun"
temp.append("Thu")
days = tuple(temp)       # ('Sun', 'Tue', 'Wed', 'Thu')

Why the round trip works

list(days) does not change the tuple. It reads every item and puts them into a new list. You change that list freely, then tuple(temp) reads the list and builds a new tuple. At no point is a tuple modified.

A shortcut for adding: to add just one or two items, you do not need to convert. days = days + ("Thu",) does it directly.

Tuples inside a list

students = [("Ava", 92), ("Ben", 85)]
students.append(("Cy", 77))     # OK: the list can grow
print(students[1])              # ('Ben', 85)
print(students[1][0])           # Ben
for name, score in students:    # unpack each tuple
    print(name, score)

Working with a list of records

Because each record is a tuple and the collection is a list, you get the best of both: the list can grow and be sorted, and each record stays intact.

students = [("Ava", 92), ("Ben", 85), ("Cy", 77)]
total = 0
for name, score in students:
    total += score
print("Average:", total / len(students))   # Average: 84.66...

Sorting records: sorted(students) sorts by the first element (the name), because tuples compare left to right. To change a score, replace the whole record: students[0] = ("Ava", 95).

Lists inside a tuple

student = ("Ava", [90, 85])
student[1].append(77)       # OK! the LIST changes
print(student)              # ('Ava', [90, 85, 77])
student[1] = [100]          # TypeError!

Think of slots and arrows

A tuple is a row of locked slots. Each slot holds an arrow pointing to a value. The arrows can never be moved, but if an arrow points to a list, you can still walk down the arrow and change that list.

• student[1].append(77) follows the arrow in slot 1 and changes the list: allowed.
• student[1] = [100] tries to move the arrow in slot 1 to a different list: TypeError.

One consequence: a tuple containing a list cannot be a dictionary key. Python checks everything inside, and a list inside makes the whole tuple "unhashable."

Memory Viewer: tuples and lists

Pick an example and click Step. Tuples are labeled "locked" and drawn with a dashed border; lists are labeled "changeable." Arrow tags show which object a name or slot points to. Nothing is recorded.

What to look for

• Every time a line uses + with a tuple, watch for a new tuple box appearing, while the old one stays the same.
• When a list sits inside a tuple, changing the list changes the drawing inside the list box, but the tuple's arrows stay where they were.
• Two names with the same tag share one object. With a tuple that is always safe; with a list, a change shows up for both names.

Common mistakes

Fixing tuple errors

• TypeError ... item assignment / deletion: you tried to change a tuple. Build a new tuple, or ask yourself whether this data should be a list.
• AttributeError ... has no attribute: you used a list method. Tuples only have count and index.
• ValueError ... unpack: count the names on the left and the items on the right; they must match.
• A "tuple" acting like a number: you are missing the comma in a one-item tuple.

Check yourself

Choose an answer, then click Check. This is practice only. Nothing is graded or recorded.

Cheat sheet

point = (3, 4)
single = (5,)
empty = ()
t = tuple([1, 2, 3])
point[0]      # 3
point[-1]     # 4
t[1:]         # (2, 3)
x, y = point  # unpack

# tuples in a list
students = [("Ava", 92), ("Ben", 85)]
students[1][0]       # 'Ben'
for name, score in students:
    print(name, score)

# a list in a tuple
rec = ("Ava", [90, 85])
rec[1].append(77)    # OK

Remember:

• The comma makes a tuple: (5,) is a tuple, (5) is not
• Indexing and slicing work exactly like lists; a slice of a tuple is a tuple
• Will the data change? Use a list. Is it one fixed record? Use a tuple
• A tuple's slots are locked, but a list inside a tuple can still change

Key words to know

tuple · element · immutable / mutable · packing · unpacking · swap · record · heterogeneous / homogeneous · nesting · dictionary key