Tuples

4. Data Structures: Tuples

Tuples

The #\color{#4271ae} {\mathtt{\text{tuple}}}# is another object that is an ordered collection of objects. It is very similar to a #\color{#4271ae} {\mathtt{\text{list}}}# object, but unlike lists tuples are immutable. Once a #\color{#4271ae} {\mathtt{\text{tuple}}}# is defined it cannot be changed. A tuple is defined by specifying comma-separated sequence of objects enclosed in parentheses.

Declaring a tuple

#\mathtt{(}\textit{object}_\textit{0},\textit{object}_\textit{1}, \dots, \textit{object}_\textit{n}\mathtt{)}#

#\color{#4271ae} {\mathtt{tuple}}\mathtt{(}\textit{iterable}\mathtt{)}#

Like lists, tuples also support any type of Python object as element, including more complex ones, such as lists. When you define a comma-separated sequence without any type of brackets, Python will interpret the sequence as a tuple. Syntax like this is very common in #\color{#8959A8} {\mathtt{\text{return}}}# statements and when assigning values to multiple variables on one line.

>>> 1, 2, 3

(1, 2, 3)

>>> x, y = 1, 2
>>> x

Because parentheses are also used for other purposes, a special syntax is required to define a tuple with one element.

>>> (1)

>>> (1,)

(1,)

Why even use a #\color{#4271ae} {\mathtt{\text{tuple}}}# when you can use a #\color{#4271ae} {\mathtt{\text{list}}}#? There are several reasons to choose tuples over lists. First, since tuples are immutable, operations on them are faster. Second, when in need of a constant iterable, you might prefer a data type that cannot be changed so that it can't be modified accidentally. Another reason is that some data structures only support immutable objects, in that case, you'll have to use a #\color{#4271ae} {\mathtt{\text{tuple}}}# instead.

Naturally, #\color{#4271ae} {\mathtt{\text{tuple}}}# functionality is going to be very similar to that of a #\color{#4271ae} {\mathtt{\text{list}}}#, except for all syntax and methods that allow you to change the contents of a #\color{#4271ae} {\mathtt{\text{list}}}#, which a #\color{#4271ae} {\mathtt{\text{tuple}}}# does not support.

Tuple functionality

Like lists and strings, tuples also support the same syntax for indexing and slicing.

>>> t = (1, 2, 3, 4, 5)
>>> t[2]

>>> t = (1, 2, 3, 4, 5)
>>> t[2:5]

(3, 4, 5)

Operators

Both addition and multiplication work the same as they do for the iterables discussed thus far.

>>> (1, 2, 3) + (4, 5, 6)

(1, 2, 3, 4, 5, 6)

>>> (0,) * 10

(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

So do the comparison operators.

>>> (1, 2, 3) < (1, 5, 10)

True

Methods

Since tuples cannot be modified, tuples only support two methods, #\mathtt{\color{#4271ae} {\text{count}}\text{()}}# and #\mathtt{\color{#4271ae} {\text{index}}\text{()}}#, which do work the same as they do for the other iterables discussed.

>>> t = (100, 101, 101, 102, 102, 102)
>>> t.count(102)

>>> t.index(102)

Keywords

Membership of certain items can be tested with the #\color{#8959A8} {\mathtt{\text{in}}}# keyword.

>>> t = (1, 2, 3)
>>> 3 in t

True

>>> 4 in t

False

Iterating over the items within the tuple can be accomplished using the same #\color{#8959A8} {\mathtt{\text{for}}}# loop syntax as the other iterables.

>>> for item in t:
>>> print(item)

1
2
3

Like lists, we can also perform a tuple comprehension, however unlike lists, we'll have to use casting when using a comprehension, since Python won't recognise parentheses without commas as tuples.

>>> (i for i in range(10))

>>> tuple(i for i in range(10))

(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

Packing/Unpacking

The process of assigning a tuple to a single variable is referred to as tuple packing.

>>> numbers = 1, 2, 3
>>> print(numbers)

(1, 2, 3)

Splitting a tuple into multiple variables, is referred to as tuple unpacking.

>>> one, two, three = numbers
>>> print(one, two, three)

1 2 3

The shorthand for defining multiple variables on a single line is a case of tuple unpacking where the tuple is not packed beforehand.

>>> one, two, three = 1, 2, 3
>>> print(one, two, three)

1 2 3

Additionally, the #\color{#3e999f}{\mathtt{\text{*}}}# operator allows for more leeway when unpacking larger tuples. Using it with a variable results in the variable automatically being filled with the values that are not explicitly unpacked. Beware, if this is more than one value the result will be a #\color{#4271ae}{\mathtt{\text{list}}}#.

>>> numbers = 1, 2, 3, 4, 5, 6, 7, 8, 9
>>> one, *rest, nine = numbers
>>> print(rest)

[2, 3, 4, 5, 6, 7, 8]

Swapping

A very useful result of the packing and unpacking feature is that it offers a very convenient way of swapping variable values. This syntax allows you to swap variable values without the use of a temporary variable, which is the standard in most programming languages.