Remove duplicated paragraph.
This commit is contained in:
parent
2b2b44dc2c
commit
dce26da49c
|
@ -7,72 +7,6 @@ Data Structures
|
|||
This chapter describes some things you've learned about already in more detail,
|
||||
and adds some new things as well.
|
||||
|
||||
.. _tut-tuples:
|
||||
|
||||
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 (see
|
||||
:ref:`typesseq`). 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 always 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
|
||||
>>> 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::
|
||||
|
||||
>>> x, y, z = t
|
||||
|
||||
This is called, appropriately enough, *sequence unpacking*. Sequence unpacking
|
||||
requires the list of variables on the left to 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.
|
||||
|
||||
.. % XXX Add a bit on the difference between tuples and lists.
|
||||
|
||||
|
||||
.. _tut-morelists:
|
||||
|
||||
More on Lists
|
||||
|
|
Loading…
Reference in New Issue