GNU Info

(python2.1-tut.info)Tuples and Sequences

---

Next: Dictionaries Prev: del statement Up: Data Structures

---

Enter node , (file) or (file)node

Tuples and Sequences
====================

We saw that lists and strings have many common properties, e.g.,
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
instance:

     >>> t = 12345, 54321, 'hello!'
     >>> t[0]
     12345
     >>> t
     (12345, 54321, 'hello!')
     >>> # Tuples may be nested:
     ... u = t, (1, 2, 3, 4, 5)
     >>> u
     ((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, e.g., (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
     >>> len(empty)
     0
     >>> len(singleton)
     1
     >>> singleton
     ('hello',)

The statement `t = 12345, 54321, 'hello!'' is an example of _tuple
packing_: the values `12345', `54321' and `'hello!'' are packed
together in a tuple.  The reverse operation is also possible, e.g.:

     >>> 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.