[Python-3000-checkins] r63165 - python/branches/py3k/Doc/tutorial/datastructures.rst

georg.brandl python-3000-checkins at python.org
Mon May 12 18:33:12 CEST 2008

Author: georg.brandl
Date: Mon May 12 18:33:11 2008
New Revision: 63165

Remove duplicated paragraph.


Modified: python/branches/py3k/Doc/tutorial/datastructures.rst
--- python/branches/py3k/Doc/tutorial/datastructures.rst	(original)
+++ python/branches/py3k/Doc/tutorial/datastructures.rst	Mon May 12 18:33:11 2008
@@ -7,72 +7,6 @@
 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
-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

More information about the Python-3000-checkins mailing list