Expand a bit on dict views.

Doc/tutorial/datastructures.rst

@@ -154,6 +154,8 @@ the queue, use :meth:`pop` with ``0`` as the index.  For example::
    ['Michael', 'Terry', 'Graham']
 
 
+.. _tut-listcomps:
+
 List Comprehensions
 -------------------
 
@@ -401,7 +403,7 @@ Here is a brief demonstration::
    >>> a ^ b                              # letters in a or b but not both
    {'r', 'd', 'b', 'm', 'z', 'l'}
 
-Like for lists, there is a set comprehension syntax::
+Like :ref:`for lists <tut-listcomps>`, there is a set comprehension syntax::
 
    >>> a = {x for x in 'abracadabra' if x not in 'abc'}
    >>> a
@@ -438,9 +440,9 @@ value associated with that key is forgotten.  It is an error to extract a value
 using a non-existent key.
 
 Performing ``list(d.keys())`` on a dictionary returns a list of all the keys
-used in the dictionary, in arbitrary order (if you want it sorted, just apply
+used in the dictionary, in arbitrary order (if you want it sorted, just use
-the :meth:`sorted` function instead).  To check whether a single key is
+``sorted(d.keys())`` instead). [1]_  To check whether a single key is in the
-in the dictionary, use the :keyword:`in` keyword.
+dictionary, use the :keyword:`in` keyword.
 
 Here is a small example using a dictionary::
 
@@ -463,9 +465,8 @@ Here is a small example using a dictionary::
    >>> 'jack' not in tel
    False
 
-The :func:`dict` constructor builds dictionaries directly from lists of
+The :func:`dict` constructor builds dictionaries directly from sequences of
-key-value pairs stored as tuples.  When the pairs form a pattern, list
+key-value pairs stored as tuples. ::
-comprehensions can compactly specify the key-value list. ::
 
    >>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
    {'sape': 4139, 'jack': 4098, 'guido': 4127}
@@ -483,7 +484,6 @@ keyword arguments::
    {'sape': 4139, 'jack': 4098, 'guido': 4127}
 
 
-.. XXX Find out the right way to do these DUBOIS
 .. _tut-loopidioms:
 
 Looping Techniques
@@ -604,9 +604,9 @@ sequence is exhausted. If two items to be compared are themselves sequences of
 the same type, the lexicographical comparison is carried out recursively.  If
 all items of two sequences compare equal, the sequences are considered equal.
 If one sequence is an initial sub-sequence of the other, the shorter sequence is
-the smaller (lesser) one.  Lexicographical ordering for strings uses the ASCII
+the smaller (lesser) one.  Lexicographical ordering for strings uses the Unicode
-ordering for individual characters.  Some examples of comparisons between
+codepoint number to order individual characters.  Some examples of comparisons
-sequences of the same type::
+between sequences of the same type::
 
    (1, 2, 3)              < (1, 2, 4)
    [1, 2, 3]              < [1, 2, 4]
@@ -621,3 +621,10 @@ provided that the objects have appropriate comparison methods.  For example,
 mixed numeric types are compared according to their numeric value, so 0 equals
 0.0, etc.  Otherwise, rather than providing an arbitrary ordering, the
 interpreter will raise a :exc:`TypeError` exception.
+
+
+.. rubric:: Footnotes
+
+.. [1] Calling ``d.keys()`` will return a :dfn:`dictionary view` object.  It
+       supports operations like membership test and iteration, but its contents
+       are not independent of the original dictionary -- it is only a *view*.