Tuples, like lists, are ordered collections of items. But different than lists, tuples are immutable – their contents cannot be modified.
Think of a tuple as a package which wraps some items: to change the items you need to ‘unwrap’ the package first, and then wrap the items again in a new package.
Tuples are usually delimited by parentheses:
>>> aTuple = (1, 2, 'Hi') >>> type(aTuple)
Tuples can also be written without the parentheses. As long as there is a comma, a sequence of items will be interpreted as a tuple:
>>> anotherTuple = 3, 4, 'Hello', 5 >>> type(anotherTuple)
Items in tuples can be accessed by their index, just like lists:
However, unlike lists, items in tuples cannot be modified directly. Lists are mutable, but tuples are not.
For that reason, assigning a value to an item doesn’t work:
>>> aTuple = 'bye'
Traceback (most recent call last): File "<untitled>", line 5, in <module> TypeError: 'tuple' object does not support item assignment
To modify a tuple it is necessary to set all items as a package:
>>> aTuple = (1, 2, 'bye') >>> aTuple
(1, 2, 'bye')
Tuples with only one item require a comma to be recognized as a tuple. For example, this is not a tuple:
>>> aTuple = ('oops') >>> type(aTuple)
To define a tuple with only one item we need to use a comma:
>>> aTuple = 'hi', >>> type(aTuple)
Forgetting the comma in one-item tuples is a common beginner’s mistake.
Packing and unpacking tuples
Tuples are useful for wrapping a group of values into a single ‘thing’. For example, a color can be expressed as a tuple of
(R, G, B) values, a position as a tuple of
(x, y) coordinates, and so on. Since tuples are immutable, these values are kept together with some integrity.
Here’s an example of packing values into a tuple:
>>> color = 0, 255, 255 >>> color
(0, 255, 255)
If we need to use the values individually, we can do the opposite operation and unpack a tuple into variables:
>>> r, g, b = color >>> r, g, b
(0, 255, 255)
Unpacking a tuple only works if the amount of variables to the left of the equality matches the amount of items in the tuple.
Here we have less variable names than values:
>>> x, y = color
Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: too many values to unpack (expected 2)
…and here we have more variable names than values. Notice how the error messages are different:
>>> k, l, m, n = color
Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: not enough values to unpack (expected 4, got 3)