Docs: minor tweaks

Author: edschofield

docs/dict_object.rst

@@ -22,8 +22,8 @@ stick with standard Python 3 code in your Py2/3 compatible codebase::
     for value in d.values():
         # code here
 
-In this case there will be memory overhead of list creation for each call to
-``items``, ``values`` or ``keys``.
+In this case there will be memory overhead of list creation on Py2 for each
+call to ``items``, ``values`` or ``keys``.
 
 For improved efficiency, ``future.builtins`` (aliased to ``builtins``) provides
 a Python 2 ``dict`` subclass whose :func:`keys`, :func:`values`, and
@@ -70,7 +70,7 @@ The memory-efficient (and CPU-efficient) alternatives are:
 - to construct a dictionary from an iterator. The above line could use a
   generator like this::
 
-      d = dict((i, i**2) for i in range(10**7)
+      d = dict((i, i**2) for i in range(10**7))
 
 - to construct an empty dictionary with a ``dict()`` call using
   ``builtins.dict`` (rather than ``{}``) and then update it;

docs/isinstance.rst

@@ -69,7 +69,7 @@ the types from ``future`` to their native superclasses on Py2.
 The ``native`` function in ``future.utils`` is provided for this. Here is how
 to use it. (The output showing is from Py2)::
 
-    >>> from builtins import *
+    >>> from builtins import int, bytes, str
     >>> from future.utils import native
 
     >>> a = int(10**20)     # Py3-like long int

docs/open_function.rst

@@ -10,10 +10,10 @@ contents as (unicode) strings unless the binary (``b``) flag is passed, as in::
 
 in which case its methods like :func:`read` return Py3 :class:`bytes` objects.
 
-On Py2, ``future.builtins`` (and ``builtins``) provides an ``open`` function
-that is mostly compatible with that on Python 3 (e.g. it offers keyword
-arguments like ``encoding``). This maps to the ``open`` backport available in
-the standard library :mod:`io` module on Py2.6 and Py2.7.
+On Py2 with ``future`` installed, the :mod:`builtins` module provides an
+``open`` function that is mostly compatible with that on Python 3 (e.g. it
+offers keyword arguments like ``encoding``). This maps to the ``open`` backport
+available in the standard library :mod:`io` module on Py2.6 and Py2.7.
 
 One difference to be aware of between the Python 3 ``open`` and
 ``future.builtins.open`` on Python 2 is that the return types of methods such

docs/quickstart.rst

@@ -40,7 +40,8 @@ The easiest way is to start each new module with these lines::
     from builtins import *
 
 Then write standard Python 3 code. The :mod:`future` package will
-provide support for running your code on Python 2.6 and 2.7 mostly unchanged.
+provide support for running your code on Python 2.6, 2.7, and 3.3+ mostly
+unchanged.
 
 - For explicit import forms, see :ref:`explicit-imports`.
 - For more details, see :ref:`what-else`.