7.3 Tuples and Sequences
We saw that lists and strings have many common properties, such as
indexing and slicing operations. They are two examples of
sequence data types. Since Python is an evolving language,
other sequence data types may be added. There is also another
standard sequence data type: the tuple.
A tuple consists of a number of values separated by commas, for
>>> t = 12345, 54321, 'hello!'
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
As you see, on output tuples are alway enclosed in parentheses, so
that nested tuples are interpreted correctly; they may be input with
or without surrounding parentheses, although often parentheses are
necessary anyway (if the tuple is part of a larger expression).
Tuples have many uses. For example: (x, y) coordinate pairs, employee
records from a database, etc. Tuples, like strings, are immutable: it
is not possible to assign to the individual items of a tuple (you can
simulate much of the same effect with slicing and concatenation,
though). It is also possible to create tuples which contain mutable
objects, such as lists.
A special problem is the construction of tuples containing 0 or 1
items: the syntax has some extra quirks to accommodate these. Empty
tuples are constructed by an empty pair of parentheses; a tuple with
one item is constructed by following a value with a comma
(it is not sufficient to enclose a single value in parentheses).
Ugly, but effective. For example:
>>> empty = ()
>>> singleton = 'hello', # <-- note trailing comma
t = 12345, 54321, 'hello!' is an example of
tuple packing: the values
'hello!' are packed together in a tuple. The reverse operation
is also possible:
>>> x, y, z = t
This is called, appropriately enough, sequence unpacking.
Sequence unpacking requires that the list of variables on the left
have the same number of elements as the length of the sequence. Note
that multiple assignment is really just a combination of tuple packing
and sequence unpacking!
There is a small bit of asymmetry here: packing multiple values
always creates a tuple, and unpacking works for any sequence.