--- rest25/library/collections.rst	2008-12-19 16:58:07.000000000 +0900
+++ rest262/library/collections.rst	2009-04-05 05:02:09.000000000 +0900
@@ -1,123 +1,275 @@
 
 :mod:`collections` --- High-performance container datatypes
 ===========================================================
 
 .. module:: collections
    :synopsis: High-performance datatypes
 .. moduleauthor:: Raymond Hettinger <python@rcn.com>
 .. sectionauthor:: Raymond Hettinger <python@rcn.com>
 
-
 .. versionadded:: 2.4
 
-This module implements high-performance container datatypes.  Currently, there
-are two datatypes, deque and defaultdict. Future additions may include balanced
-trees and ordered dictionaries.
+.. testsetup:: *
+
+   from collections import *
+   import itertools
+   __name__ = '<doctest>'
+
+This module implements high-performance container datatypes.  Currently,
+there are two datatypes, :class:`deque` and :class:`defaultdict`, and
+one datatype factory function, :func:`namedtuple`.
 
 .. versionchanged:: 2.5
-   Added defaultdict.
+   Added :class:`defaultdict`.
+
+.. versionchanged:: 2.6
+   Added :func:`namedtuple`.
+
+The specialized containers provided in this module provide alternatives
+to Python's general purpose built-in containers, :class:`dict`,
+:class:`list`, :class:`set`, and :class:`tuple`.
+
+Besides the containers provided here, the optional :mod:`bsddb`
+module offers the ability to create in-memory or file based ordered
+dictionaries with string keys using the :meth:`bsddb.btopen` method.
+
+In addition to containers, the collections module provides some ABCs
+(abstract base classes) that can be used to test whether a class
+provides a particular interface, for example, is it hashable or
+a mapping.
+
+.. versionchanged:: 2.6
+   Added abstract base classes.
+
+ABCs - abstract base classes
+----------------------------
+
+The collections module offers the following ABCs:
+
+=========================  =====================  ======================  ====================================================
+ABC                        Inherits               Abstract Methods        Mixin Methods
+=========================  =====================  ======================  ====================================================
+:class:`Container`                                ``__contains__``
+:class:`Hashable`                                 ``__hash__``
+:class:`Iterable`                                 ``__iter__``
+:class:`Iterator`          :class:`Iterable`      ``__next__``            ``__iter__``
+:class:`Sized`                                    ``__len__``
+:class:`Callable`                                 ``__call__``
+
+:class:`Sequence`          :class:`Sized`,        ``__getitem__``         ``__contains__``. ``__iter__``, ``__reversed__``.
+                           :class:`Iterable`,                             ``index``, and ``count``
+                           :class:`Container`
+
+:class:`MutableSequence`   :class:`Sequence`      ``__setitem__``         Inherited Sequence methods and
+                                                  ``__delitem__``,        ``append``, ``reverse``, ``extend``, ``pop``,
+                                                  and ``insert``          ``remove``, and ``__iadd__``
+
+:class:`Set`               :class:`Sized`,                                ``__le__``, ``__lt__``, ``__eq__``, ``__ne__``,
+                           :class:`Iterable`,                             ``__gt__``, ``__ge__``, ``__and__``, ``__or__``
+                           :class:`Container`                             ``__sub__``, ``__xor__``, and ``isdisjoint``
+
+:class:`MutableSet`        :class:`Set`           ``add`` and             Inherited Set methods and
+                                                  ``discard``             ``clear``, ``pop``, ``remove``, ``__ior__``,
+                                                                          ``__iand__``, ``__ixor__``, and ``__isub__``
+
+:class:`Mapping`           :class:`Sized`,        ``__getitem__``         ``__contains__``, ``keys``, ``items``, ``values``,
+                           :class:`Iterable`,                             ``get``, ``__eq__``, and ``__ne__``
+                           :class:`Container`
+
+:class:`MutableMapping`    :class:`Mapping`       ``__setitem__`` and     Inherited Mapping methods and
+                                                  ``__delitem__``         ``pop``, ``popitem``, ``clear``, ``update``,
+                                                                          and ``setdefault``
+
+
+:class:`MappingView`       :class:`Sized`                                 ``__len__``
+:class:`KeysView`          :class:`MappingView`,                          ``__contains__``,
+                           :class:`Set`                                   ``__iter__``
+:class:`ItemsView`         :class:`MappingView`,                          ``__contains__``,
+                           :class:`Set`                                   ``__iter__``
+:class:`ValuesView`        :class:`MappingView`                           ``__contains__``, ``__iter__``
+=========================  =====================  ======================  ====================================================
+
+These ABCs allow us to ask classes or instances if they provide
+particular functionality, for example::
+
+    size = None
+    if isinstance(myvar, collections.Sized):
+        size = len(myvar)
+
+Several of the ABCs are also useful as mixins that make it easier to develop
+classes supporting container APIs.  For example, to write a class supporting
+the full :class:`Set` API, it only necessary to supply the three underlying
+abstract methods: :meth:`__contains__`, :meth:`__iter__`, and :meth:`__len__`.
+The ABC supplies the remaining methods such as :meth:`__and__` and
+:meth:`isdisjoint` ::
+
+    class ListBasedSet(collections.Set):
+         ''' Alternate set implementation favoring space over speed
+             and not requiring the set elements to be hashable. '''
+         def __init__(self, iterable):
+             self.elements = lst = []
+             for value in iterable:
+                 if value not in lst:
+                     lst.append(value)
+         def __iter__(self):
+             return iter(self.elements)
+         def __contains__(self, value):
+             return value in self.elements
+         def __len__(self):
+             return len(self.elements)
+
+    s1 = ListBasedSet('abcdef')
+    s2 = ListBasedSet('defghi')
+    overlap = s1 & s2            # The __and__() method is supported automatically
+
+Notes on using :class:`Set` and :class:`MutableSet` as a mixin:
+
+(1)
+   Since some set operations create new sets, the default mixin methods need
+   a way to create new instances from an iterable. The class constructor is
+   assumed to have a signature in the form ``ClassName(iterable)``.
+   That assumption is factored-out to an internal classmethod called
+   :meth:`_from_iterable` which calls ``cls(iterable)`` to produce a new set.
+   If the :class:`Set` mixin is being used in a class with a different
+   constructor signature, you will need to override :meth:`from_iterable`
+   with a classmethod that can construct new instances from
+   an iterable argument.
+
+(2)
+   To override the comparisons (presumably for speed, as the
+   semantics are fixed), redefine :meth:`__le__` and
+   then the other operations will automatically follow suit.
+
+(3)
+   The :class:`Set` mixin provides a :meth:`_hash` method to compute a hash value
+   for the set; however, :meth:`__hash__` is not defined because not all sets
+   are hashable or immutable.  To add set hashabilty using mixins,
+   inherit from both :meth:`Set` and :meth:`Hashable`, then define
+   ``__hash__ = Set._hash``.
+
+.. seealso::
+
+   * `OrderedSet recipe <http://code.activestate.com/recipes/576694/>`_ for an
+     example built on :class:`MutableSet`.
+
+   * For more about ABCs, see the :mod:`abc` module and :pep:`3119`.
 
 
 .. _deque-objects:
 
 :class:`deque` objects
 ----------------------
 
 
-.. function:: deque([iterable])
+.. class:: deque([iterable[, maxlen]])
 
-   Returns a new deque objected initialized left-to-right (using :meth:`append`)
-   with data from *iterable*.  If *iterable* is not specified, the new deque is
-   empty.
+   Returns a new deque object initialized left-to-right (using :meth:`append`) with
+   data from *iterable*.  If *iterable* is not specified, the new deque is empty.
 
    Deques are a generalization of stacks and queues (the name is pronounced "deck"
    and is short for "double-ended queue").  Deques support thread-safe, memory
    efficient appends and pops from either side of the deque with approximately the
-   same ``O(1)`` performance in either direction.
+   same O(1) performance in either direction.
 
    Though :class:`list` objects support similar operations, they are optimized for
-   fast fixed-length operations and incur ``O(n)`` memory movement costs for
+   fast fixed-length operations and incur O(n) memory movement costs for
    ``pop(0)`` and ``insert(0, v)`` operations which change both the size and
    position of the underlying data representation.
 
    .. versionadded:: 2.4
 
-Deque objects support the following methods:
+   If *maxlen* is not specified or is *None*, deques may grow to an
+   arbitrary length.  Otherwise, the deque is bounded to the specified maximum
+   length.  Once a bounded length deque is full, when new items are added, a
+   corresponding number of items are discarded from the opposite end.  Bounded
+   length deques provide functionality similar to the ``tail`` filter in
+   Unix. They are also useful for tracking transactions and other pools of data
+   where only the most recent activity is of interest.
 
+   .. versionchanged:: 2.6
+      Added *maxlen* parameter.
 
-.. method:: XXX Class.append(x)
+   Deque objects support the following methods:
 
-   Add *x* to the right side of the deque.
 
+   .. method:: append(x)
 
-.. method:: XXX Class.appendleft(x)
+      Add *x* to the right side of the deque.
 
-   Add *x* to the left side of the deque.
 
+   .. method:: appendleft(x)
 
-.. method:: XXX Class.clear()
+      Add *x* to the left side of the deque.
 
-   Remove all elements from the deque leaving it with length 0.
 
+   .. method:: clear()
 
-.. method:: XXX Class.extend(iterable)
+      Remove all elements from the deque leaving it with length 0.
 
-   Extend the right side of the deque by appending elements from the iterable
-   argument.
 
+   .. method:: extend(iterable)
 
-.. method:: XXX Class.extendleft(iterable)
+      Extend the right side of the deque by appending elements from the iterable
+      argument.
 
-   Extend the left side of the deque by appending elements from *iterable*.  Note,
-   the series of left appends results in reversing the order of elements in the
-   iterable argument.
 
+   .. method:: extendleft(iterable)
 
-.. method:: XXX Class.pop()
+      Extend the left side of the deque by appending elements from *iterable*.
+      Note, the series of left appends results in reversing the order of
+      elements in the iterable argument.
 
-   Remove and return an element from the right side of the deque. If no elements
-   are present, raises an :exc:`IndexError`.
 
+   .. method:: pop()
 
-.. method:: XXX Class.popleft()
+      Remove and return an element from the right side of the deque. If no
+      elements are present, raises an :exc:`IndexError`.
 
-   Remove and return an element from the left side of the deque. If no elements are
-   present, raises an :exc:`IndexError`.
 
+   .. method:: popleft()
 
-.. method:: XXX Class.remove(value)
+      Remove and return an element from the left side of the deque. If no
+      elements are present, raises an :exc:`IndexError`.
 
-   Removed the first occurrence of *value*.  If not found, raises a
-   :exc:`ValueError`.
 
-   .. versionadded:: 2.5
+   .. method:: remove(value)
 
+      Removed the first occurrence of *value*.  If not found, raises a
+      :exc:`ValueError`.
 
-.. method:: XXX Class.rotate(n)
+      .. versionadded:: 2.5
+
+
+   .. method:: rotate(n)
+
+      Rotate the deque *n* steps to the right.  If *n* is negative, rotate to
+      the left.  Rotating one step to the right is equivalent to:
+      ``d.appendleft(d.pop())``.
 
-   Rotate the deque *n* steps to the right.  If *n* is negative, rotate to the
-   left.  Rotating one step to the right is equivalent to:
-   ``d.appendleft(d.pop())``.
 
 In addition to the above, deques support iteration, pickling, ``len(d)``,
 ``reversed(d)``, ``copy.copy(d)``, ``copy.deepcopy(d)``, membership testing with
-the :keyword:`in` operator, and subscript references such as ``d[-1]``.
+the :keyword:`in` operator, and subscript references such as ``d[-1]``.  Indexed
+access is O(1) at both ends but slows to O(n) in the middle.  For fast random
+access, use lists instead.
+
+Example:
 
-Example::
+.. doctest::
 
    >>> from collections import deque
    >>> d = deque('ghi')                 # make a new deque with three items
    >>> for elem in d:                   # iterate over the deque's elements
-   ...     print elem.upper()	
+   ...     print elem.upper()
    G
    H
    I
 
    >>> d.append('j')                    # add a new entry to the right side
    >>> d.appendleft('f')                # add a new entry to the left side
    >>> d                                # show the representation of the deque
    deque(['f', 'g', 'h', 'i', 'j'])
 
    >>> d.pop()                          # return and remove the rightmost item
    'j'
    >>> d.popleft()                      # return and remove the leftmost item
@@ -150,198 +302,394 @@
    Traceback (most recent call last):
      File "<pyshell#6>", line 1, in -toplevel-
        d.pop()
    IndexError: pop from an empty deque
 
    >>> d.extendleft('abc')              # extendleft() reverses the input order
    >>> d
    deque(['c', 'b', 'a'])
 
 
 .. _deque-recipes:
 
-Recipes
-^^^^^^^
+:class:`deque` Recipes
+^^^^^^^^^^^^^^^^^^^^^^
 
 This section shows various approaches to working with deques.
 
 The :meth:`rotate` method provides a way to implement :class:`deque` slicing and
 deletion.  For example, a pure python implementation of ``del d[n]`` relies on
 the :meth:`rotate` method to position elements to be popped::
 
    def delete_nth(d, n):
        d.rotate(-n)
        d.popleft()
        d.rotate(n)
 
 To implement :class:`deque` slicing, use a similar approach applying
 :meth:`rotate` to bring a target element to the left side of the deque. Remove
 old entries with :meth:`popleft`, add new entries with :meth:`extend`, and then
 reverse the rotation.
-
 With minor variations on that approach, it is easy to implement Forth style
 stack manipulations such as ``dup``, ``drop``, ``swap``, ``over``, ``pick``,
 ``rot``, and ``roll``.
 
-A roundrobin task server can be built from a :class:`deque` using
-:meth:`popleft` to select the current task and :meth:`append` to add it back to
-the tasklist if the input stream is not exhausted::
-
-   def roundrobin(*iterables):
-       pending = deque(iter(i) for i in iterables)
-       while pending:
-           task = pending.popleft()
-           try:
-               yield task.next()
-           except StopIteration:
-               continue
-           pending.append(task)
-
-   >>> for value in roundrobin('abc', 'd', 'efgh'):
-   ...     print value
-
-   a
-   d
-   e
-   b
-   f
-   c
-   g
-   h
-
-
 Multi-pass data reduction algorithms can be succinctly expressed and efficiently
 coded by extracting elements with multiple calls to :meth:`popleft`, applying
-the reduction function, and calling :meth:`append` to add the result back to the
-queue.
+a reduction function, and calling :meth:`append` to add the result back to the
+deque.
 
 For example, building a balanced binary tree of nested lists entails reducing
-two adjacent nodes into one by grouping them in a list::
-
-   def maketree(iterable):
-       d = deque(iterable)
-       while len(d) > 1:
-           pair = [d.popleft(), d.popleft()]
-           d.append(pair)
-       return list(d)
+two adjacent nodes into one by grouping them in a list:
 
+   >>> def maketree(iterable):
+   ...     d = deque(iterable)
+   ...     while len(d) > 1:
+   ...         pair = [d.popleft(), d.popleft()]
+   ...         d.append(pair)
+   ...     return list(d)
+   ...
    >>> print maketree('abcdefgh')
    [[[['a', 'b'], ['c', 'd']], [['e', 'f'], ['g', 'h']]]]
 
+Bounded length deques provide functionality similar to the ``tail`` filter
+in Unix::
 
+   def tail(filename, n=10):
+       'Return the last n lines of a file'
+       return deque(open(filename), n)
 
 .. _defaultdict-objects:
 
 :class:`defaultdict` objects
 ----------------------------
 
 
-.. function:: defaultdict([default_factory[, ...]])
+.. class:: defaultdict([default_factory[, ...]])
 
    Returns a new dictionary-like object.  :class:`defaultdict` is a subclass of the
    builtin :class:`dict` class.  It overrides one method and adds one writable
    instance variable.  The remaining functionality is the same as for the
    :class:`dict` class and is not documented here.
 
    The first argument provides the initial value for the :attr:`default_factory`
    attribute; it defaults to ``None``. All remaining arguments are treated the same
    as if they were passed to the :class:`dict` constructor, including keyword
    arguments.
 
    .. versionadded:: 2.5
 
-:class:`defaultdict` objects support the following method in addition to the
-standard :class:`dict` operations:
+   :class:`defaultdict` objects support the following method in addition to the
+   standard :class:`dict` operations:
+
 
+   .. method:: defaultdict.__missing__(key)
 
-.. method:: XXX Class.__missing__(key)
+      If the :attr:`default_factory` attribute is ``None``, this raises a
+      :exc:`KeyError` exception with the *key* as argument.
 
-   If the :attr:`default_factory` attribute is ``None``, this raises an
-   :exc:`KeyError` exception with the *key* as argument.
+      If :attr:`default_factory` is not ``None``, it is called without arguments
+      to provide a default value for the given *key*, this value is inserted in
+      the dictionary for the *key*, and returned.
 
-   If :attr:`default_factory` is not ``None``, it is called without arguments to
-   provide a default value for the given *key*, this value is inserted in the
-   dictionary for the *key*, and returned.
+      If calling :attr:`default_factory` raises an exception this exception is
+      propagated unchanged.
 
-   If calling :attr:`default_factory` raises an exception this exception is
-   propagated unchanged.
+      This method is called by the :meth:`__getitem__` method of the
+      :class:`dict` class when the requested key is not found; whatever it
+      returns or raises is then returned or raised by :meth:`__getitem__`.
 
-   This method is called by the :meth:`__getitem__` method of the :class:`dict`
-   class when the requested key is not found; whatever it returns or raises is then
-   returned or raised by :meth:`__getitem__`.
 
-:class:`defaultdict` objects support the following instance variable:
+   :class:`defaultdict` objects support the following instance variable:
 
 
-.. data:: default_factory
+   .. attribute:: defaultdict.default_factory
 
-   This attribute is used by the :meth:`__missing__` method; it is initialized from
-   the first argument to the constructor, if present, or to ``None``,  if absent.
+      This attribute is used by the :meth:`__missing__` method; it is
+      initialized from the first argument to the constructor, if present, or to
+      ``None``, if absent.
 
 
 .. _defaultdict-examples:
 
 :class:`defaultdict` Examples
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Using :class:`list` as the :attr:`default_factory`, it is easy to group a
-sequence of key-value pairs into a dictionary of lists::
+sequence of key-value pairs into a dictionary of lists:
 
    >>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
    >>> d = defaultdict(list)
    >>> for k, v in s:
-           d[k].append(v)
-
+   ...     d[k].append(v)
+   ...
    >>> d.items()
    [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
 
 When each key is encountered for the first time, it is not already in the
 mapping; so an entry is automatically created using the :attr:`default_factory`
 function which returns an empty :class:`list`.  The :meth:`list.append`
 operation then attaches the value to the new list.  When keys are encountered
 again, the look-up proceeds normally (returning the list for that key) and the
 :meth:`list.append` operation adds another value to the list. This technique is
-simpler and faster than an equivalent technique using :meth:`dict.setdefault`::
+simpler and faster than an equivalent technique using :meth:`dict.setdefault`:
 
    >>> d = {}
    >>> for k, v in s:
-   	d.setdefault(k, []).append(v)
-
+   ...     d.setdefault(k, []).append(v)
+   ...
    >>> d.items()
    [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
 
 Setting the :attr:`default_factory` to :class:`int` makes the
 :class:`defaultdict` useful for counting (like a bag or multiset in other
-languages)::
+languages):
 
    >>> s = 'mississippi'
    >>> d = defaultdict(int)
    >>> for k in s:
-           d[k] += 1
-
+   ...     d[k] += 1
+   ...
    >>> d.items()
    [('i', 4), ('p', 2), ('s', 4), ('m', 1)]
 
 When a letter is first encountered, it is missing from the mapping, so the
 :attr:`default_factory` function calls :func:`int` to supply a default count of
-zero.  The increment operation then builds up the count for each letter. This
-technique makes counting simpler and faster than an equivalent technique using
-:meth:`dict.get`::
+zero.  The increment operation then builds up the count for each letter.
 
-   >>> d = {}
-   >>> for k in s:
-   	d[k] = d.get(k, 0) + 1
-
-   >>> d.items()
-   [('i', 4), ('p', 2), ('s', 4), ('m', 1)]
+The function :func:`int` which always returns zero is just a special case of
+constant functions.  A faster and more flexible way to create constant functions
+is to use :func:`itertools.repeat` which can supply any constant value (not just
+zero):
+
+   >>> def constant_factory(value):
+   ...     return itertools.repeat(value).next
+   >>> d = defaultdict(constant_factory('<missing>'))
+   >>> d.update(name='John', action='ran')
+   >>> '%(name)s %(action)s to %(object)s' % d
+   'John ran to <missing>'
 
 Setting the :attr:`default_factory` to :class:`set` makes the
-:class:`defaultdict` useful for building a dictionary of sets::
+:class:`defaultdict` useful for building a dictionary of sets:
 
    >>> s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
    >>> d = defaultdict(set)
    >>> for k, v in s:
-           d[k].add(v)
-
+   ...     d[k].add(v)
+   ...
    >>> d.items()
    [('blue', set([2, 4])), ('red', set([1, 3]))]
 
+
+.. _named-tuple-factory:
+
+:func:`namedtuple` Factory Function for Tuples with Named Fields
+----------------------------------------------------------------
+
+Named tuples assign meaning to each position in a tuple and allow for more readable,
+self-documenting code.  They can be used wherever regular tuples are used, and
+they add the ability to access fields by name instead of position index.
+
+.. function:: namedtuple(typename, field_names, [verbose])
+
+   Returns a new tuple subclass named *typename*.  The new subclass is used to
+   create tuple-like objects that have fields accessible by attribute lookup as
+   well as being indexable and iterable.  Instances of the subclass also have a
+   helpful docstring (with typename and field_names) and a helpful :meth:`__repr__`
+   method which lists the tuple contents in a ``name=value`` format.
+
+   The *field_names* are a single string with each fieldname separated by whitespace
+   and/or commas, for example ``'x y'`` or ``'x, y'``.  Alternatively, *field_names*
+   can be a sequence of strings such as ``['x', 'y']``.
+
+   Any valid Python identifier may be used for a fieldname except for names
+   starting with an underscore.  Valid identifiers consist of letters, digits,
+   and underscores but do not start with a digit or underscore and cannot be
+   a :mod:`keyword` such as *class*, *for*, *return*, *global*, *pass*, *print*,
+   or *raise*.
+
+   If *verbose* is true, the class definition is printed just before being built.
+
+   Named tuple instances do not have per-instance dictionaries, so they are
+   lightweight and require no more memory than regular tuples.
+
+   .. versionadded:: 2.6
+
+Example:
+
+.. doctest::
+   :options: +NORMALIZE_WHITESPACE
+
+   >>> Point = namedtuple('Point', 'x y', verbose=True)
+   class Point(tuple):
+           'Point(x, y)'
+   <BLANKLINE>
+           __slots__ = ()
+   <BLANKLINE>
+           _fields = ('x', 'y')
+   <BLANKLINE>
+           def __new__(cls, x, y):
+               return tuple.__new__(cls, (x, y))
+   <BLANKLINE>
+           @classmethod
+           def _make(cls, iterable, new=tuple.__new__, len=len):
+               'Make a new Point object from a sequence or iterable'
+               result = new(cls, iterable)
+               if len(result) != 2:
+                   raise TypeError('Expected 2 arguments, got %d' % len(result))
+               return result
+   <BLANKLINE>
+           def __repr__(self):
+               return 'Point(x=%r, y=%r)' % self
+   <BLANKLINE>
+           def _asdict(t):
+               'Return a new dict which maps field names to their values'
+               return {'x': t[0], 'y': t[1]}
+   <BLANKLINE>
+           def _replace(self, **kwds):
+               'Return a new Point object replacing specified fields with new values'
+               result = self._make(map(kwds.pop, ('x', 'y'), self))
+               if kwds:
+                   raise ValueError('Got unexpected field names: %r' % kwds.keys())
+               return result
+   <BLANKLINE>
+           def __getnewargs__(self):
+               return tuple(self)
+   <BLANKLINE>
+           x = property(itemgetter(0))
+           y = property(itemgetter(1))
+
+   >>> p = Point(11, y=22)     # instantiate with positional or keyword arguments
+   >>> p[0] + p[1]             # indexable like the plain tuple (11, 22)
+   33
+   >>> x, y = p                # unpack like a regular tuple
+   >>> x, y
+   (11, 22)
+   >>> p.x + p.y               # fields also accessible by name
+   33
+   >>> p                       # readable __repr__ with a name=value style
+   Point(x=11, y=22)
+
+Named tuples are especially useful for assigning field names to result tuples returned
+by the :mod:`csv` or :mod:`sqlite3` modules::
+
+   EmployeeRecord = namedtuple('EmployeeRecord', 'name, age, title, department, paygrade')
+
+   import csv
+   for emp in map(EmployeeRecord._make, csv.reader(open("employees.csv", "rb"))):
+       print emp.name, emp.title
+
+   import sqlite3
+   conn = sqlite3.connect('/companydata')
+   cursor = conn.cursor()
+   cursor.execute('SELECT name, age, title, department, paygrade FROM employees')
+   for emp in map(EmployeeRecord._make, cursor.fetchall()):
+       print emp.name, emp.title
+
+In addition to the methods inherited from tuples, named tuples support
+three additional methods and one attribute.  To prevent conflicts with
+field names, the method and attribute names start with an underscore.
+
+.. method:: somenamedtuple._make(iterable)
+
+   Class method that makes a new instance from an existing sequence or iterable.
+
+.. doctest::
+
+      >>> t = [11, 22]
+      >>> Point._make(t)
+      Point(x=11, y=22)
+
+.. method:: somenamedtuple._asdict()
+
+   Return a new dict which maps field names to their corresponding values::
+
+      >>> p._asdict()
+      {'x': 11, 'y': 22}
+
+.. method:: somenamedtuple._replace(kwargs)
+
+   Return a new instance of the named tuple replacing specified fields with new
+   values:
+
+::
+
+      >>> p = Point(x=11, y=22)
+      >>> p._replace(x=33)
+      Point(x=33, y=22)
+
+      >>> for partnum, record in inventory.items():
+      ...     inventory[partnum] = record._replace(price=newprices[partnum], timestamp=time.now())
+
+.. attribute:: somenamedtuple._fields
+
+   Tuple of strings listing the field names.  Useful for introspection
+   and for creating new named tuple types from existing named tuples.
+
+.. doctest::
+
+      >>> p._fields            # view the field names
+      ('x', 'y')
+
+      >>> Color = namedtuple('Color', 'red green blue')
+      >>> Pixel = namedtuple('Pixel', Point._fields + Color._fields)
+      >>> Pixel(11, 22, 128, 255, 0)
+      Pixel(x=11, y=22, red=128, green=255, blue=0)
+
+To retrieve a field whose name is stored in a string, use the :func:`getattr`
+function:
+
+    >>> getattr(p, 'x')
+    11
+
+To convert a dictionary to a named tuple, use the double-star-operator
+(as described in :ref:`tut-unpacking-arguments`):
+
+   >>> d = {'x': 11, 'y': 22}
+   >>> Point(**d)
+   Point(x=11, y=22)
+
+Since a named tuple is a regular Python class, it is easy to add or change
+functionality with a subclass.  Here is how to add a calculated field and
+a fixed-width print format:
+
+    >>> class Point(namedtuple('Point', 'x y')):
+    ...     __slots__ = ()
+    ...     @property
+    ...     def hypot(self):
+    ...         return (self.x ** 2 + self.y ** 2) ** 0.5
+    ...     def __str__(self):
+    ...         return 'Point: x=%6.3f  y=%6.3f  hypot=%6.3f' % (self.x, self.y, self.hypot)
+
+    >>> for p in Point(3, 4), Point(14, 5/7.):
+    ...     print p
+    Point: x= 3.000  y= 4.000  hypot= 5.000
+    Point: x=14.000  y= 0.714  hypot=14.018
+
+The subclass shown above sets ``__slots__`` to an empty tuple.  This keeps
+keep memory requirements low by preventing the creation of instance dictionaries.
+
+Subclassing is not useful for adding new, stored fields.  Instead, simply
+create a new named tuple type from the :attr:`_fields` attribute:
+
+    >>> Point3D = namedtuple('Point3D', Point._fields + ('z',))
+
+Default values can be implemented by using :meth:`_replace` to
+customize a prototype instance:
+
+    >>> Account = namedtuple('Account', 'owner balance transaction_count')
+    >>> default_account = Account('<owner name>', 0.0, 0)
+    >>> johns_account = default_account._replace(owner='John')
+
+Enumerated constants can be implemented with named tuples, but it is simpler
+and more efficient to use a simple class declaration:
+
+    >>> Status = namedtuple('Status', 'open pending closed')._make(range(3))
+    >>> Status.open, Status.pending, Status.closed
+    (0, 1, 2)
+    >>> class Status:
+    ...     open, pending, closed = range(3)
+
+.. seealso::
+
+   `Named tuple recipe <http://code.activestate.com/recipes/500261/>`_
+   adapted for Python 2.4.
