From 0616b792ba4115fe3bb79c446c2c6383db434490 Mon Sep 17 00:00:00 2001
From: Guido van Rossum <guido@python.org>
Date: Fri, 31 Aug 2007 03:25:11 +0000
Subject: Tutorial update for 3.0 by Paul Dubois.

I had to fix a few markup issues in controlflow.rst and modules.rst.

There's a unicode issue on line 448 in introduction.rst that someone else needs to fix.
---
 Doc/tutorial/classes.rst        |  27 ++---
 Doc/tutorial/controlflow.rst    | 131 ++++++++++++++-------
 Doc/tutorial/datastructures.rst | 247 +++++++++++++++++++---------------------
 Doc/tutorial/errors.rst         |  57 +++++-----
 Doc/tutorial/floatingpoint.rst  |   5 +-
 Doc/tutorial/inputoutput.rst    |  22 ++--
 Doc/tutorial/interactive.rst    |   2 +
 Doc/tutorial/introduction.rst   | 160 +++++++++++---------------
 Doc/tutorial/modules.rst        |  58 +++++-----
 Doc/tutorial/stdlib.rst         |   8 +-
 Doc/tutorial/stdlib2.rst        |   8 +-
 Doc/tutorial/whatnow.rst        |   5 +
 12 files changed, 378 insertions(+), 352 deletions(-)

diff --git a/Doc/tutorial/classes.rst b/Doc/tutorial/classes.rst
index b733e1e..09cc0e1 100644
--- a/Doc/tutorial/classes.rst
+++ b/Doc/tutorial/classes.rst
@@ -14,7 +14,8 @@ multiple base classes, a derived class can override any methods of its base
 class or classes, and a method can call the method of a base class with the same
 name.  Objects can contain an arbitrary amount of private data.
 
-In C++ terminology, all class members (including the data members) are *public*,
+In C++ terminology, normally class members (including the data members) are 
+*public* (except see below :ref:`tut-private`),
 and all member functions are *virtual*.  There are no special constructors or
 destructors.  As in Modula-3, there are no shorthands for referencing the
 object's members from its methods: the method function is declared with an
@@ -273,7 +274,7 @@ code will print the value ``16``, without leaving a trace::
    x.counter = 1
    while x.counter < 10:
        x.counter = x.counter * 2
-   print x.counter
+   print(x.counter)
    del x.counter
 
 The other kind of instance attribute reference is a *method*. A method is a
@@ -308,7 +309,7 @@ object, and can be stored away and called at a later time.  For example::
 
    xf = x.f
    while True:
-       print xf()
+       print(xf())
 
 will continue to print ``hello world`` until the end of time.
 
@@ -621,11 +622,11 @@ following code will print B, C, D in that order::
        try:
            raise c()
        except D:
-           print "D"
+           print("D")
        except C:
-           print "C"
+           print("C")
        except B:
-           print "B"
+           print("B")
 
 Note that if the except clauses were reversed (with ``except B`` first), it
 would have printed B, B, B --- the first matching except clause is triggered.
@@ -644,15 +645,15 @@ By now you have probably noticed that most container objects can be looped over
 using a :keyword:`for` statement::
 
    for element in [1, 2, 3]:
-       print element
+       print(element)
    for element in (1, 2, 3):
-       print element
+       print(element)
    for key in {'one':1, 'two':2}:
-       print key
+       print(key)
    for char in "123":
-       print char
+       print(char)
    for line in open("myfile.txt"):
-       print line
+       print(line)
 
 This style of access is clear, concise, and convenient.  The use of iterators
 pervades and unifies Python.  Behind the scenes, the :keyword:`for` statement
@@ -699,7 +700,7 @@ returns an object with a :meth:`__next__` method.  If the class defines
            return self.data[self.index]
 
    >>> for char in Reverse('spam'):
-   ...     print char
+   ...     print(char)
    ...
    m
    a
@@ -724,7 +725,7 @@ create::
            yield data[index]
 
    >>> for char in reverse('golf'):
-   ...     print char
+   ...     print(char)
    ...
    f
    l
diff --git a/Doc/tutorial/controlflow.rst b/Doc/tutorial/controlflow.rst
index caea301..0d9a21d 100644
--- a/Doc/tutorial/controlflow.rst
+++ b/Doc/tutorial/controlflow.rst
@@ -19,13 +19,13 @@ example::
    >>> x = int(input("Please enter an integer: "))
    >>> if x < 0:
    ...      x = 0
-   ...      print 'Negative changed to zero'
+   ...      print('Negative changed to zero')
    ... elif x == 0:
-   ...      print 'Zero'
+   ...      print('Zero')
    ... elif x == 1:
-   ...      print 'Single'
+   ...      print('Single')
    ... else:
-   ...      print 'More'
+   ...      print('More')
    ... 
 
 There can be zero or more :keyword:`elif` parts, and the :keyword:`else` part is
@@ -45,7 +45,6 @@ to avoid excessive indentation.  An  :keyword:`if` ... :keyword:`elif` ...
 
 .. index::
    statement: for
-   statement: for
 
 The :keyword:`for` statement in Python differs a bit from what you may be used
 to in C or Pascal.  Rather than always iterating over an arithmetic progression
@@ -62,7 +61,7 @@ they appear in the sequence.  For example (no pun intended):
    >>> # Measure some strings:
    ... a = ['cat', 'window', 'defenestrate']
    >>> for x in a:
-   ...     print x, len(x)
+   ...     print(x, len(x))
    ... 
    cat 3
    window 6
@@ -87,30 +86,40 @@ The :func:`range` Function
 ==========================
 
 If you do need to iterate over a sequence of numbers, the built-in function
-:func:`range` comes in handy.  It generates lists containing arithmetic
-progressions::
+:func:`range` comes in handy.  It generates arithmetic progressions::
+
+
+    >>> for i in range(5):
+    ...     print(i)
+    ...
+    0
+    1
+    2
+    3
+    4
+    
 
-   >>> range(10)
-   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
 The given end point is never part of the generated list; ``range(10)`` generates
-a list of 10 values, the legal indices for items of a sequence of length 10.  It
+10 values, the legal indices for items of a sequence of length 10.  It
 is possible to let the range start at another number, or to specify a different
 increment (even negative; sometimes this is called the 'step')::
 
-   >>> range(5, 10)
-   [5, 6, 7, 8, 9]
-   >>> range(0, 10, 3)
-   [0, 3, 6, 9]
-   >>> range(-10, -100, -30)
-   [-10, -40, -70]
+    range(5, 10)          
+       5 through 9
+
+    range(0, 10, 3)       
+       0, 3, 6, 9
+
+    range(-10, -100, -30) 
+      -10, -40, -70
 
 To iterate over the indices of a sequence, combine :func:`range` and :func:`len`
 as follows::
 
    >>> a = ['Mary', 'had', 'a', 'little', 'lamb']
    >>> for i in range(len(a)):
-   ...     print i, a[i]
+   ...     print(i, a[i])
    ... 
    0 Mary
    1 had
@@ -118,6 +127,27 @@ as follows::
    3 little
    4 lamb
 
+A strange thing happens if you just print a range::
+
+   >>> print(range(10))
+   range(0, 10)
+
+In many ways the object returned by :func:`range` behaves as if it is a list,
+but in fact it isn't. It is an object which returns the successive items of 
+the desired sequence when you iterate over it, but it doesn't really make 
+the list, thus saving space. 
+
+We say such an object is *iterable*, that is, suitable as a target for 
+functions and constructs that expect something from which they can 
+obtain successive items until the supply is exhausted. We have seen that
+the :keyword:`for` statement is such an *iterator*. The function :func:`list`
+is another; it creates lists from iterables::
+
+
+   >>> list(range(5))
+   [0, 1, 2, 3, 4]
+
+Later we will see more functions that return iterables and take iterables as argument.
 
 .. _tut-break:
 
@@ -139,11 +169,11 @@ following loop, which searches for prime numbers::
    >>> for n in range(2, 10):
    ...     for x in range(2, n):
    ...         if n % x == 0:
-   ...             print n, 'equals', x, '*', n/x
+   ...             print(n, 'equals', x, '*', n/x)
    ...             break
    ...     else:
    ...         # loop fell through without finding a factor
-   ...         print n, 'is a prime number'
+   ...         print(n, 'is a prime number')
    ... 
    2 is a prime number
    3 is a prime number
@@ -180,8 +210,9 @@ boundary::
    ...     """Print a Fibonacci series up to n."""
    ...     a, b = 0, 1
    ...     while b < n:
-   ...         print b,
+   ...         print(b,end=' ')
    ...         a, b = b, a+b
+   ...     print()
    ... 
    >>> # Now call the function we just defined:
    ... fib(2000)
@@ -237,7 +268,7 @@ This value is called ``None`` (it's a built-in name).  Writing the value
 ``None`` is normally suppressed by the interpreter if it would be the only value
 written.  You can see it if you really want to::
 
-   >>> print fib(0)
+   >>> print(fib(0))
    None
 
 It is simple to write a function that returns a list of the numbers of the
@@ -299,7 +330,7 @@ defined to allow.  For example::
            if ok in ('n', 'no', 'nop', 'nope'): return False
            retries = retries - 1
            if retries < 0: raise IOError, 'refusenik user'
-           print complaint
+           print(complaint)
 
 This function can be called either like this: ``ask_ok('Do you really want to
 quit?')`` or like this: ``ask_ok('OK to overwrite the file?', 2)``.
@@ -313,7 +344,7 @@ The default values are evaluated at the point of function definition in the
    i = 5
 
    def f(arg=i):
-       print arg
+       print(arg)
 
    i = 6
    f()
@@ -329,9 +360,9 @@ arguments passed to it on subsequent calls::
        L.append(a)
        return L
 
-   print f(1)
-   print f(2)
-   print f(3)
+   print(f(1))
+   print(f(2))
+   print(f(3))
 
 This will print ::
 
@@ -358,10 +389,10 @@ Functions can also be called using keyword arguments of the form ``keyword =
 value``.  For instance, the following function::
 
    def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
-       print "-- This parrot wouldn't", action,
-       print "if you put", voltage, "volts through it."
-       print "-- Lovely plumage, the", type
-       print "-- It's", state, "!"
+       print("-- This parrot wouldn't", action, end= ' ')
+       print("if you put", voltage, "volts through it.")
+       print("-- Lovely plumage, the", type)
+       print("-- It's", state, "!")
 
 could be called in any of the following ways::
 
@@ -401,13 +432,13 @@ list.  (``*name`` must occur before ``**name``.) For example, if we define a
 function like this::
 
    def cheeseshop(kind, *arguments, **keywords):
-       print "-- Do you have any", kind, '?'
-       print "-- I'm sorry, we're all out of", kind
+       print("-- Do you have any", kind, '?')
+       print("-- I'm sorry, we're all out of", kind)
        for arg in arguments: print arg
-       print '-'*40
+       print('-'*40)
        keys = keywords.keys()
        keys.sort()
-       for kw in keys: print kw, ':', keywords[kw]
+       for kw in keys: print(kw, ':', keywords[kw])
 
 It could be called like this::
 
@@ -446,6 +477,20 @@ arguments may occur. ::
    def fprintf(file, format, *args):
        file.write(format % args)
 
+ 
+Normally, these ``variadic`` arguments will be last in the list of formal
+parameters, because they scoop up all remaining input arguments that are 
+passed to the function. Any formal parameters which occur after the ``*args``
+parameter are 'keyword-only' arguments, meaning that they can only be used as 
+keywords rather than positional arguments.::
+ 
+   >>> def concat(*args, sep="/"):
+   ...    return sep.join(args)
+   ...
+   >>> concat("earth", "mars", "venus")
+   'earth/mars/venus'
+   >>> concat("earth", "mars", "venus", sep=".")
+   'earth.mars.venus'
 
 .. _tut-unpacking-arguments:
 
@@ -459,19 +504,19 @@ arguments.  For instance, the built-in :func:`range` function expects separate
 function call with the  ``*``\ -operator to unpack the arguments out of a list
 or tuple::
 
-   >>> range(3, 6)             # normal call with separate arguments
+   >>> list(range(3, 6))            # normal call with separate arguments
    [3, 4, 5]
    >>> args = [3, 6]
-   >>> range(*args)            # call with arguments unpacked from a list
+   >>> list(range(*args))            # call with arguments unpacked from a list
    [3, 4, 5]
 
 In the same fashion, dictionaries can deliver keyword arguments with the ``**``\
 -operator::
 
    >>> def parrot(voltage, state='a stiff', action='voom'):
-   ...     print "-- This parrot wouldn't", action,
-   ...     print "if you put", voltage, "volts through it.",
-   ...     print "E's", state, "!"
+   ...     print("-- This parrot wouldn't", action,end=' ')
+   ...     print("if you put", voltage, "volts through it.", end=' ')
+   ...     print("E's", state, "!")
    ...
    >>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
    >>> parrot(**d)
@@ -512,8 +557,8 @@ Documentation Strings
    single: documentation strings
    single: strings, documentation
 
-There are emerging conventions about the content and formatting of documentation
-strings.
+Here are some conventions about the content and formatting of documentation
+strings. 
 
 The first line should always be a short, concise summary of the object's
 purpose.  For brevity, it should not explicitly state the object's name or type,
@@ -547,7 +592,7 @@ Here is an example of a multi-line docstring::
    ...     """
    ...     pass
    ... 
-   >>> print my_function.__doc__
+   >>> print(my_function.__doc__)
    Do nothing, but document it.
 
        No, really, it doesn't do anything.
diff --git a/Doc/tutorial/datastructures.rst b/Doc/tutorial/datastructures.rst
index d65e55b..77088f3 100644
--- a/Doc/tutorial/datastructures.rst
+++ b/Doc/tutorial/datastructures.rst
@@ -7,6 +7,71 @@ 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:
 
@@ -73,7 +138,7 @@ objects:
 An example that uses most of the list methods::
 
    >>> a = [66.25, 333, 333, 1, 1234.5]
-   >>> print a.count(333), a.count(66.25), a.count('x')
+   >>> print(a.count(333), a.count(66.25), a.count('x'))
    2 1 0
    >>> a.insert(2, -1)
    >>> a.append(333)
@@ -146,71 +211,47 @@ the queue, use :meth:`pop` with ``0`` as the index.  For example::
    ['Michael', 'Terry', 'Graham']
 
 
-.. _tut-functional:
-
-Functional Programming Tools
-----------------------------
-
-There are two built-in functions that are very useful when used with lists:
-:func:`filter` and :func:`map`.
+List Comprehensions
+-------------------
 
-``filter(function, sequence)`` returns a sequence consisting of those items from
-the sequence for which ``function(item)`` is true. If *sequence* is a
-:class:`string` or :class:`tuple`, the result will be of the same type;
-otherwise, it is always a :class:`list`. For example, to compute some primes::
+List comprehensions provide a concise way to create lists from sequences.
+Common applications are to make lists where each element is the result of
+some operations applied to each member of the sequence, or to create a 
+subsequence of those elements that satisfy a certain condition.
 
-   >>> def f(x): return x % 2 != 0 and x % 3 != 0
-   ...
-   >>> filter(f, range(2, 25))
-   [5, 7, 11, 13, 17, 19, 23]
 
-``map(function, sequence)`` calls ``function(item)`` for each of the sequence's
-items and returns a list of the return values.  For example, to compute some
-cubes::
-
-   >>> def cube(x): return x*x*x
-   ...
-   >>> map(cube, range(1, 11))
-   [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
+Each list comprehension consists of an expression followed by a :keyword:`for`
+clause, then zero or more :keyword:`for` or :keyword:`if` clauses.  The result
+will be a list resulting from evaluating the expression in the context of the
+:keyword:`for` and :keyword:`if` clauses which follow it.  If the expression
+would evaluate to a tuple, it must be parenthesized. 
 
-More than one sequence may be passed; the function must then have as many
-arguments as there are sequences and is called with the corresponding item from
-each sequence (or ``None`` if some sequence is shorter than another).  For
-example::
+Here we take a list of numbers and return a list of three times each number::
 
-   >>> seq = range(8)
-   >>> def add(x, y): return x+y
-   ...
-   >>> map(add, seq, seq)
-   [0, 2, 4, 6, 8, 10, 12, 14]
+   >>> vec = [2, 4, 6]
+   >>> [3*x for x in vec]
+   [6, 12, 18]
 
-.. versionadded:: 2.3
+Now we get a little fancier::
 
+   >>> [[x,x**2] for x in vec]
+   [[2, 4], [4, 16], [6, 36]]
 
-List Comprehensions
--------------------
-
-List comprehensions provide a concise way to create lists without resorting to
-use of :func:`map`, :func:`filter` and/or :keyword:`lambda`. The resulting list
-definition tends often to be clearer than lists built using those constructs.
-Each list comprehension consists of an expression followed by a :keyword:`for`
-clause, then zero or more :keyword:`for` or :keyword:`if` clauses.  The result
-will be a list resulting from evaluating the expression in the context of the
-:keyword:`for` and :keyword:`if` clauses which follow it.  If the expression
-would evaluate to a tuple, it must be parenthesized. ::
+Here we apply a method call to each item in a sequence::
 
    >>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
    >>> [weapon.strip() for weapon in freshfruit]
    ['banana', 'loganberry', 'passion fruit']
-   >>> vec = [2, 4, 6]
-   >>> [3*x for x in vec]
-   [6, 12, 18]
+
+Using the if-clause we can filter the stream::
+
    >>> [3*x for x in vec if x > 3]
    [12, 18]
    >>> [3*x for x in vec if x < 2]
    []
-   >>> [[x,x**2] for x in vec]
-   [[2, 4], [4, 16], [6, 36]]
+
+Tuples can often be created without their parentheses, but not here::
+
    >>> [x, x**2 for x in vec]	# error - parens required for tuples
      File "<stdin>", line 1, in ?
        [x, x**2 for x in vec]
@@ -218,6 +259,9 @@ would evaluate to a tuple, it must be parenthesized. ::
    SyntaxError: invalid syntax
    >>> [(x, x**2) for x in vec]
    [(2, 4), (4, 16), (6, 36)]
+
+Here are some nested for's and other fancy behavior::
+
    >>> vec1 = [2, 4, 6]
    >>> vec2 = [4, 3, -9]
    >>> [x*y for x in vec1 for y in vec2]
@@ -227,8 +271,7 @@ would evaluate to a tuple, it must be parenthesized. ::
    >>> [vec1[i]*vec2[i] for i in range(len(vec1))]
    [8, 12, -54]
 
-List comprehensions are much more flexible than :func:`map` and can be applied
-to complex expressions and nested functions::
+List comprehensions can be applied to complex expressions and nested functions::
 
    >>> [str(round(355/113.0, i)) for i in range(1,6)]
    ['3.1', '3.14', '3.142', '3.1416', '3.14159']
@@ -264,71 +307,6 @@ Referencing the name ``a`` hereafter is an error (at least until another value
 is assigned to it).  We'll find other uses for :keyword:`del` later.
 
 
-.. _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-sets:
 
@@ -340,12 +318,19 @@ with no duplicate elements.  Basic uses include membership testing and
 eliminating duplicate entries.  Set objects also support mathematical operations
 like union, intersection, difference, and symmetric difference.
 
+Curly braces or the :func:`set` function can be use to create sets. Note:
+To create an empty set you have to use set(), not {}; the latter creates
+an empty dictionary, a data structure that we discuss in the next section.
+
 Here is a brief demonstration::
 
-   >>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
+   >>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
+   >>> print(basket)
+   {'orange', 'bananna', 'pear', 'apple'}
+   >>> fruit = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
    >>> fruit = set(basket)               # create a set without duplicates
    >>> fruit
-   set(['orange', 'pear', 'apple', 'banana'])
+   {'orange', 'pear', 'apple', 'banana'}
    >>> 'orange' in fruit                 # fast membership testing
    True
    >>> 'crabgrass' in fruit
@@ -356,15 +341,17 @@ Here is a brief demonstration::
    >>> a = set('abracadabra')
    >>> b = set('alacazam')
    >>> a                                  # unique letters in a
-   set(['a', 'r', 'b', 'c', 'd'])
+   {'a', 'r', 'b', 'c', 'd'}
    >>> a - b                              # letters in a but not in b
-   set(['r', 'd', 'b'])
+   {'r', 'd', 'b'}
    >>> a | b                              # letters in either a or b
-   set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
+   {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
    >>> a & b                              # letters in both a and b
-   set(['a', 'c'])
+   {'a', 'c'}
    >>> a ^ b                              # letters in a or b but not both
-   set(['r', 'd', 'b', 'm', 'z', 'l'])
+   {'r', 'd', 'b', 'm', 'z', 'l'}
+
+
 
 
 .. _tut-dictionaries:
@@ -441,6 +428,8 @@ keyword arguments::
 
 
 .. _tut-loopidioms:
+.. % 
+   Find out the right way to do these DUBOIS
 
 Looping Techniques
 ==================
@@ -450,7 +439,7 @@ retrieved at the same time using the :meth:`iteritems` method. ::
 
    >>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
    >>> for k, v in knights.iteritems():
-   ...     print k, v
+   ...     print(k, v)
    ...
    gallahad the pure
    robin the brave
@@ -459,7 +448,7 @@ When looping through a sequence, the position index and corresponding value can
 be retrieved at the same time using the :func:`enumerate` function. ::
 
    >>> for i, v in enumerate(['tic', 'tac', 'toe']):
-   ...     print i, v
+   ...     print(i, v)
    ...
    0 tic
    1 tac
@@ -471,7 +460,7 @@ with the :func:`zip` function. ::
    >>> questions = ['name', 'quest', 'favorite color']
    >>> answers = ['lancelot', 'the holy grail', 'blue']
    >>> for q, a in zip(questions, answers):
-   ...     print 'What is your %s?  It is %s.' % (q, a)
+   ...     print('What is your %s?  It is %s.' % (q, a))
    ...	
    What is your name?  It is lancelot.
    What is your quest?  It is the holy grail.
@@ -481,7 +470,7 @@ To loop over a sequence in reverse, first specify the sequence in a forward
 direction and then call the :func:`reversed` function. ::
 
    >>> for i in reversed(range(1,10,2)):
-   ...     print i
+   ...     print(i)
    ...
    9
    7
@@ -494,7 +483,7 @@ returns a new sorted list while leaving the source unaltered. ::
 
    >>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
    >>> for f in sorted(set(basket)):
-   ...     print f
+   ...     print(f)
    ... 	
    apple
    banana
diff --git a/Doc/tutorial/errors.rst b/Doc/tutorial/errors.rst
index 2f2719a..e3c631f 100644
--- a/Doc/tutorial/errors.rst
+++ b/Doc/tutorial/errors.rst
@@ -1,4 +1,4 @@
-.. _tut-errors:
+. _tut-errors:
 
 *********************
 Errors and Exceptions
@@ -17,9 +17,9 @@ Syntax Errors
 Syntax errors, also known as parsing errors, are perhaps the most common kind of
 complaint you get while you are still learning Python::
 
-   >>> while True print 'Hello world'
+   >>> while True print('Hello world')
      File "<stdin>", line 1, in ?
-       while True print 'Hello world'
+       while True print('Hello world')
                       ^
    SyntaxError: invalid syntax
 
@@ -45,7 +45,7 @@ programs, however, and result in error messages as shown here::
    >>> 10 * (1/0)
    Traceback (most recent call last):
      File "<stdin>", line 1, in ?
-   ZeroDivisionError: integer division or modulo by zero
+   ZeroDivisionError: int division or modulo by zero
    >>> 4 + spam*3
    Traceback (most recent call last):
      File "<stdin>", line 1, in ?
@@ -53,7 +53,7 @@ programs, however, and result in error messages as shown here::
    >>> '2' + 2
    Traceback (most recent call last):
      File "<stdin>", line 1, in ?
-   TypeError: cannot concatenate 'str' and 'int' objects
+   TypeError: coercing to Unicode: need string or buffer, int found
 
 The last line of the error message indicates what happened. Exceptions come in
 different types, and the type is printed as part of the message: the types in
@@ -90,7 +90,7 @@ is signalled by raising the :exc:`KeyboardInterrupt` exception. ::
    ...         x = int(input("Please enter a number: "))
    ...         break
    ...     except ValueError:
-   ...         print "Oops!  That was no valid number.  Try again..."
+   ...         print("Oops!  That was no valid number.  Try again...")
    ...     
 
 The :keyword:`try` statement works as follows.
@@ -132,12 +132,11 @@ the exception (allowing a caller to handle the exception as well)::
        s = f.readline()
        i = int(s.strip())
    except IOError as e:
-       (errno, strerror) = e
-       print "I/O error(%s): %s" % (e.errno, e.strerror)
+       print("I/O error(%s): %s" % (e.errno, e.strerror))
    except ValueError:
-       print "Could not convert data to an integer."
+       print("Could not convert data to an integer.")
    except:
-       print "Unexpected error:", sys.exc_info()[0]
+       print("Unexpected error:", sys.exc_info()[0])
        raise
 
 The :keyword:`try` ... :keyword:`except` statement has an optional *else
@@ -149,9 +148,9 @@ example::
        try:
            f = open(arg, 'r')
        except IOError:
-           print 'cannot open', arg
+           print('cannot open', arg)
        else:
-           print arg, 'has', len(f.readlines()), 'lines'
+           print(arg, 'has', len(f.readlines()), 'lines')
            f.close()
 
 The use of the :keyword:`else` clause is better than adding additional code to
@@ -178,9 +177,9 @@ desired. ::
    >>> try:
    ...    raise Exception('spam', 'eggs')
    ... except Exception as inst:
-   ...    print type(inst)     # the exception instance
-   ...    print inst.args      # arguments stored in .args
-   ...    print inst           # __str__ allows args to printed directly
+   ...    print(type(inst))    # the exception instance
+   ...    print(inst.args)     # arguments stored in .args
+   ...    print(inst)          # __str__ allows args to be printed directly
    ...    x, y = inst          # __getitem__ allows args to be unpacked directly
    ...    print 'x =', x
    ...    print 'y =', y
@@ -204,7 +203,7 @@ indirectly) in the try clause. For example::
    >>> try:
    ...     this_fails()
    ... except ZeroDivisionError as detail:
-   ...     print 'Handling run-time error:', detail
+   ...     print('Handling run-time error:', detail)
    ... 
    Handling run-time error: integer division or modulo by zero
 
@@ -234,7 +233,7 @@ re-raise the exception::
    >>> try:
    ...     raise NameError, 'HiThere'
    ... except NameError:
-   ...     print 'An exception flew by!'
+   ...     print('An exception flew by!')
    ...     raise
    ...
    An exception flew by!
@@ -331,7 +330,7 @@ example::
    >>> try:
    ...     raise KeyboardInterrupt
    ... finally:
-   ...     print 'Goodbye, world!'
+   ...     print('Goodbye, world!')
    ... 
    Goodbye, world!
    Traceback (most recent call last):
@@ -353,11 +352,11 @@ the same :keyword:`try` statement works as of Python 2.5)::
    ...     try:
    ...         result = x / y
    ...     except ZeroDivisionError:
-   ...         print "division by zero!"
+   ...         print("division by zero!")
    ...     else:
-   ...         print "result is", result
+   ...         print("result is", result)
    ...     finally:
-   ...         print "executing finally clause"
+   ...         print("executing finally clause")
    ...
    >>> divide(2, 1)
    result is 2
@@ -393,20 +392,20 @@ succeeded or failed. Look at the following example, which tries to open a file
 and print its contents to the screen. ::
 
    for line in open("myfile.txt"):
-       print line
+       print(line)
 
 The problem with this code is that it leaves the file open for an indeterminate
-amount of time after the code has finished executing. This is not an issue in
-simple scripts, but can be a problem for larger applications. The
-:keyword:`with` statement allows objects like files to be used in a way that
-ensures they are always cleaned up promptly and correctly. ::
+amount of time after this part of the code has finished executing. 
+This is not an issue in simple scripts, but can be a problem for larger 
+applications. The :keyword:`with` statement allows objects like files to be 
+used in a way that ensures they are always cleaned up promptly and correctly. ::
 
    with open("myfile.txt") as f:
        for line in f:
-           print line
+           print(line)
 
 After the statement is executed, the file *f* is always closed, even if a
-problem was encountered while processing the lines. Other objects which provide
-predefined clean-up actions will indicate this in their documentation.
+problem was encountered while processing the lines. Objects which, like files,
+provide predefined clean-up actions will indicate this in their documentation.
 
 
diff --git a/Doc/tutorial/floatingpoint.rst b/Doc/tutorial/floatingpoint.rst
index cbf7008..ab68723 100644
--- a/Doc/tutorial/floatingpoint.rst
+++ b/Doc/tutorial/floatingpoint.rst
@@ -136,7 +136,10 @@ display of your final results to the number of decimal digits you expect.
 Python's ``%`` format operator: the ``%g``, ``%f`` and ``%e`` format codes
 supply flexible and easy ways to round float results for display.
 
-
+If you are a heavy user of floating point operations you should take a look
+at the Numerical Python package and many other packages for mathematical and
+statistical operations supplied by the SciPy project. See <http://scipy.org>.
+ 
 .. _tut-fp-error:
 
 Representation Error
diff --git a/Doc/tutorial/inputoutput.rst b/Doc/tutorial/inputoutput.rst
index 9c302af..a58b92a 100644
--- a/Doc/tutorial/inputoutput.rst
+++ b/Doc/tutorial/inputoutput.rst
@@ -15,7 +15,7 @@ Fancier Output Formatting
 =========================
 
 So far we've encountered two ways of writing values: *expression statements* and
-the :keyword:`print` statement.  (A third way is using the :meth:`write` method
+the :func:`print` function.  (A third way is using the :meth:`write` method
 of file objects; the standard output file can be referenced as ``sys.stdout``.
 See the Library Reference for more information on this.)
 
@@ -61,12 +61,12 @@ Some examples::
    >>> x = 10 * 3.25
    >>> y = 200 * 200
    >>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
-   >>> print s
+   >>> print(s)
    The value of x is 32.5, and y is 40000...
    >>> # The repr() of a string adds string quotes and backslashes:
    ... hello = 'hello, world\n'
    >>> hellos = repr(hello)
-   >>> print hellos
+   >>> print(hellos)
    'hello, world\n'
    >>> # The argument to repr() may be any Python object:
    ... repr((x, y, ('spam', 'eggs')))
@@ -78,9 +78,9 @@ Some examples::
 Here are two ways to write a table of squares and cubes::
 
    >>> for x in range(1, 11):
-   ...     print repr(x).rjust(2), repr(x*x).rjust(3),
-   ...     # Note trailing comma on previous line
-   ...     print repr(x*x*x).rjust(4)
+   ...     print(repr(x).rjust(2), repr(x*x).rjust(3),end=' ')
+   ...     # Note use of 'end' on previous line
+   ...     print(repr(x*x*x).rjust(4))
    ...
     1   1    1
     2   4    8
@@ -94,7 +94,7 @@ Here are two ways to write a table of squares and cubes::
    10 100 1000
 
    >>> for x in range(1,11):
-   ...     print '%2d %3d %4d' % (x, x*x, x*x*x)
+   ...     print('%2d %3d %4d' % (x, x*x, x*x*x))
    ... 
     1   1    1
     2   4    8
@@ -108,7 +108,7 @@ Here are two ways to write a table of squares and cubes::
    10 100 1000
 
 (Note that in the first example, one space between each column was added by the
-way :keyword:`print` works: it always adds spaces between its arguments.)
+way :func:`print` works: it always adds spaces between its arguments.)
 
 This example demonstrates the :meth:`rjust` method of string objects, which
 right-justifies a string in a field of a given width by padding it with spaces
@@ -165,6 +165,8 @@ shown here::
 This is particularly useful in combination with the new built-in :func:`vars`
 function, which returns a dictionary containing all local variables.
 
+The :mod:`string` module contains a class Template which offers yet another way
+to substitute values into strings.
 
 .. _tut-files:
 
@@ -183,7 +185,7 @@ arguments: ``open(filename, mode)``.
 ::
 
    >>> f=open('/tmp/workfile', 'w')
-   >>> print f
+   >>> print(f)
    <open file '/tmp/workfile', mode 'w' at 80a0960>
 
 The first argument is a string containing the filename.  The second argument is
@@ -254,7 +256,7 @@ An alternate approach to reading lines is to loop over the file object. This is
 memory efficient, fast, and leads to simpler code::
 
    >>> for line in f:
-           print line,
+           print(line, end='')
 
    This is the first line of the file.
    Second line of the file
diff --git a/Doc/tutorial/interactive.rst b/Doc/tutorial/interactive.rst
index 8eeca2a..11a970f 100644
--- a/Doc/tutorial/interactive.rst
+++ b/Doc/tutorial/interactive.rst
@@ -158,6 +158,8 @@ token is required next).  The completion mechanism might use the interpreter's
 symbol table.  A command to check (or even suggest) matching parentheses,
 quotes, etc., would also be useful.
 
+.. %
+   Do we mention IPython? DUBOIS
 
 .. rubric:: Footnotes
 
diff --git a/Doc/tutorial/introduction.rst b/Doc/tutorial/introduction.rst
index e209bfc..798bee2 100644
--- a/Doc/tutorial/introduction.rst
+++ b/Doc/tutorial/introduction.rst
@@ -59,11 +59,30 @@ operators ``+``, ``-``, ``*`` and ``/`` work just like in most other languages
    >>> 2+2  # and a comment on the same line as code
    4
    >>> (50-5*6)/4
-   5
+   5.0
+   >>> 8/5 # Fractions aren't lost when dividing integers
+   1.6000000000000001
+
+Note: You might not see exactly the same result; floating point results can 
+differ from one machine to another.  We will say more later about controlling
+the appearance of floating point output; what we see here is the most
+informative display but not as easy to read as we would get with::
+
+   >>> print(8/5)
+   1.6
+
+For clarity in this tutorial we will show the simpler floating point output
+unless we are specifically discussing output formatting, and explain later
+why these two ways of displaying floating point data come to be different.
+See :ref:`tut-fp-issues` for a full discussion.
+
+To do integer division and get an integer result, 
+discarding any fractional result, there is another operator, ``//``::
+   
    >>> # Integer division returns the floor:
-   ... 7/3
+   ... 7//3
    2
-   >>> 7/-3
+   >>> 7//-3
    -3
 
 The equal sign (``'='``) is used to assign a value to a variable. Afterwards, no
@@ -176,6 +195,13 @@ several ways.  They can be enclosed in single quotes or double quotes::
    >>> '"Isn\'t," she said.'
    '"Isn\'t," she said.'
 
+The interpreter prints the result of string operations in the same way as they
+are typed for input: inside quotes, and with quotes and other funny characters
+escaped by backslashes, to show the precise value.  The string is enclosed in
+double quotes if the string contains a single quote and no double quotes, else
+it's enclosed in single quotes.  Once again, the :func:`print` function
+produces the more readable output.
+
 String literals can span multiple lines in several ways.  Continuation lines can
 be used, with a backslash as the last character on the line indicating that the
 next line is a logical continuation of the line::
@@ -185,7 +211,7 @@ next line is a logical continuation of the line::
        Note that whitespace at the beginning of the line is\
     significant."
 
-   print hello
+   print(hello)
 
 Note that newlines still need to be embedded in the string using ``\n``; the
 newline following the trailing backslash is discarded.  This example would print
@@ -203,7 +229,7 @@ the example::
    hello = r"This is a rather long string containing\n\
    several lines of text much as you would do in C."
 
-   print hello
+   print(hello)
 
 would print::
 
@@ -214,11 +240,11 @@ Or, strings can be surrounded in a pair of matching triple-quotes: ``"""`` or
 ``'''``.  End of lines do not need to be escaped when using triple-quotes, but
 they will be included in the string. ::
 
-   print """
+   print("""
    Usage: thingy [OPTIONS] 
         -h                        Display this usage message
         -H hostname               Hostname to connect to
-   """
+   """)
 
 produces the following output::
 
@@ -226,12 +252,6 @@ produces the following output::
         -h                        Display this usage message
         -H hostname               Hostname to connect to
 
-The interpreter prints the result of string operations in the same way as they
-are typed for input: inside quotes, and with quotes and other funny characters
-escaped by backslashes, to show the precise value.  The string is enclosed in
-double quotes if the string contains a single quote and no double quotes, else
-it's enclosed in single quotes.  (The :keyword:`print` statement, described
-later, can be used to write strings without quotes or escapes.)
 
 Strings can be concatenated (glued together) with the ``+`` operator, and
 repeated with ``*``::
@@ -258,7 +278,7 @@ with two literals, not with arbitrary string expressions::
 
 Strings can be subscripted (indexed); like in C, the first character of a string
 has subscript (index) 0.  There is no separate character type; a character is
-simply a string of size one.  Like in Icon, substrings can be specified with the
+simply a string of size one.  As in Icon, substrings can be specified with the
 *slice notation*: two indices separated by a colon. ::
 
    >>> word[4]
@@ -282,11 +302,11 @@ position in the string results in an error::
    >>> word[0] = 'x'
    Traceback (most recent call last):
      File "<stdin>", line 1, in ?
-   TypeError: object doesn't support item assignment
+   TypeError: 'str' object doesn't support item assignment
    >>> word[:1] = 'Splat'
    Traceback (most recent call last):
      File "<stdin>", line 1, in ?
-   TypeError: object doesn't support slice assignment
+   TypeError: 'str' object doesn't support slice assignment
 
 However, creating a new string with the combined content is easy and efficient::
 
@@ -371,31 +391,28 @@ The built-in function :func:`len` returns the length of a string::
 .. seealso::
 
    :ref:`typesseq`
-      Strings, and the Unicode strings described in the next section, are
-      examples of *sequence types*, and support the common operations supported
-      by such types.
+      Strings are examples of *sequence types*, and support the common 
+      operations supported by such types.
 
    :ref:`string-methods`
-      Both strings and Unicode strings support a large number of methods for
+      Strings support a large number of methods for
       basic transformations and searching.
 
    :ref:`string-formatting`
-      The formatting operations invoked when strings and Unicode strings are the
+      The formatting operations invoked when strings are the
       left operand of the ``%`` operator are described in more detail here.
 
 
 .. _tut-unicodestrings:
 
-Unicode Strings
----------------
+About Unicode
+-------------
 
 .. sectionauthor:: Marc-Andre Lemburg <mal@lemburg.com>
 
 
-Starting with Python 2.0 a new data type for storing text data is available to
-the programmer: the Unicode object. It can be used to store and manipulate
-Unicode data (see http://www.unicode.org/) and integrates well with the existing
-string objects, providing auto-conversions where necessary.
+Starting with Python 3.0 all strings support Unicode. 
+(See http://www.unicode.org/) 
 
 Unicode has the advantage of providing one ordinal for every character in every
 script used in modern and ancient texts. Previously, there were only 256
@@ -405,19 +422,12 @@ confusion especially with respect to internationalization (usually written as
 ``i18n`` --- ``'i'`` + 18 characters + ``'n'``) of software.  Unicode solves
 these problems by defining one code page for all scripts.
 
-Creating Unicode strings in Python is just as simple as creating normal
-strings::
-
-   >>> u'Hello World !'
-   u'Hello World !'
-
-The small ``'u'`` in front of the quote indicates that a Unicode string is
-supposed to be created. If you want to include special characters in the string,
+If you want to include special characters in a string,
 you can do so by using the Python *Unicode-Escape* encoding. The following
 example shows how::
 
-   >>> u'Hello\u0020World !'
-   u'Hello World !'
+   >>> 'Hello\u0020World !'
+   'Hello World !'
 
 The escape sequence ``\u0020`` indicates to insert the Unicode character with
 the ordinal value 0x0020 (the space character) at the given position.
@@ -428,59 +438,17 @@ Latin-1 encoding that is used in many Western countries, you will find it
 convenient that the lower 256 characters of Unicode are the same as the 256
 characters of Latin-1.
 
-For experts, there is also a raw mode just like the one for normal strings. You
-have to prefix the opening quote with 'ur' to have Python use the
-*Raw-Unicode-Escape* encoding. It will only apply the above ``\uXXXX``
-conversion if there is an uneven number of backslashes in front of the small
-'u'. ::
-
-   >>> ur'Hello\u0020World !'
-   u'Hello World !'
-   >>> ur'Hello\\u0020World !'
-   u'Hello\\\\u0020World !'
-
-The raw mode is most useful when you have to enter lots of backslashes, as can
-be necessary in regular expressions.
-
 Apart from these standard encodings, Python provides a whole set of other ways
 of creating Unicode strings on the basis of a known encoding.
 
-.. index:: builtin: unicode
-
-The built-in function :func:`unicode` provides access to all registered Unicode
-codecs (COders and DECoders). Some of the more well known encodings which these
-codecs can convert are *Latin-1*, *ASCII*, *UTF-8*, and *UTF-16*. The latter two
-are variable-length encodings that store each Unicode character in one or more
-bytes. The default encoding is normally set to ASCII, which passes through
-characters in the range 0 to 127 and rejects any other characters with an error.
-When a Unicode string is printed, written to a file, or converted with
-:func:`str`, conversion takes place using this default encoding. ::
-
-   >>> u"abc"
-   u'abc'
-   >>> str(u"abc")
-   'abc'
-   >>> u"äöü"
-   u'\xe4\xf6\xfc'
-   >>> str(u"äöü")
-   Traceback (most recent call last):
-     File "<stdin>", line 1, in ?
-   UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)
-
-To convert a Unicode string into an 8-bit string using a specific encoding,
-Unicode objects provide an :func:`encode` method that takes one argument, the
+To convert a string into a sequence of bytes using a specific encoding,
+string objects provide an :func:`encode` method that takes one argument, the
 name of the encoding.  Lowercase names for encodings are preferred. ::
 
-   >>> u"äöü".encode('utf-8')
-   '\xc3\xa4\xc3\xb6\xc3\xbc'
-
-If you have data in a specific encoding and want to produce a corresponding
-Unicode string from it, you can use the :func:`unicode` function with the
-encoding name as the second argument. ::
-
-   >>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
-   u'\xe4\xf6\xfc'
+   >>> "äÃ\u0020Ã".encode('utf-8')
+   b'A*A A'
 
+.. % above example needs beefing up by a unicode dude
 
 .. _tut-lists:
 
@@ -561,7 +529,10 @@ example::
    [2, 3]
    >>> p[1][0]
    2
-   >>> p[1].append('xtra')     # See section 5.1
+
+You can add something to the end of the list::
+
+   >>> p[1].append('xtra')    
    >>> p
    [1, [2, 3, 'xtra'], 4]
    >>> q
@@ -584,7 +555,7 @@ series as follows::
    ... # the sum of two elements defines the next
    ... a, b = 0, 1
    >>> while b < 10:
-   ...       print b
+   ...       print(b)
    ...       a, b = b, a+b
    ... 
    1
@@ -620,26 +591,29 @@ This example introduces several new features.
   completion (since the parser cannot guess when you have typed the last line).
   Note that each line within a basic block must be indented by the same amount.
 
-* The :keyword:`print` statement writes the value of the expression(s) it is
+* The :func:`print` function writes the value of the expression(s) it is
   given.  It differs from just writing the expression you want to write (as we did
-  earlier in the calculator examples) in the way it handles multiple expressions
+  earlier in the calculator examples) in the way it handles multiple 
+  expressions, floating point quantities, 
   and strings.  Strings are printed without quotes, and a space is inserted
   between items, so you can format things nicely, like this::
 
      >>> i = 256*256
-     >>> print 'The value of i is', i
+     >>> print('The value of i is', i)
      The value of i is 65536
 
-  A trailing comma avoids the newline after the output::
+   The keyword end can be used to avoid the newline after the output::
 
      >>> a, b = 0, 1
      >>> while b < 1000:
-     ...     print b,
+     ...     print(b, ' ', end='')
      ...     a, b = b, a+b
      ... 
+     >>> print()
      1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
 
-  Note that the interpreter inserts a newline before it prints the next prompt if
-  the last line was not completed.
+ Note that nothing appeared after the loop ended, until we printed
+ a newline.
+
 
 
diff --git a/Doc/tutorial/modules.rst b/Doc/tutorial/modules.rst
index 0b0dabd..cd91376 100644
--- a/Doc/tutorial/modules.rst
+++ b/Doc/tutorial/modules.rst
@@ -30,7 +30,7 @@ called :file:`fibo.py` in the current directory with the following contents::
    def fib(n):    # write Fibonacci series up to n
        a, b = 0, 1
        while b < n:
-           print b,
+           print(b, end=' ')
            a, b = b, a+b
 
    def fib2(n): # return Fibonacci series up to n
@@ -102,6 +102,9 @@ There is even a variant to import all names that a module defines::
    1 1 2 3 5 8 13 21 34 55 89 144 233 377
 
 This imports all names except those beginning with an underscore (``_``).
+In most cases Python programmers do not use this facility since it introduces 
+an unknown set of names into the interpreter, possibly hiding some things 
+you have already defined.
 
 
 .. _tut-modulesasscripts:
@@ -162,6 +165,8 @@ the same name as a standard module, or Python will attempt to load the script as
 a module when that module is imported. This will generally be an error.  See
 section :ref:`tut-standardmodules` for more information.
 
+.. %
+    Do we need stuff on zip files etc. ? DUBOIS
 
 "Compiled" Python files
 -----------------------
@@ -218,7 +223,10 @@ Some tips for experts:
 * The module :mod:`compileall` can create :file:`.pyc` files (or :file:`.pyo`
   files when :option:`-O` is used) for all modules in a directory.
 
-  .. % 
+* If using Python in a parallel processing system with a shared file system,
+  you need to patch python to disable the creation of the compiled files 
+  because otherwise the multiple Python interpreters will encounter race 
+  conditions in creating them. 
 
 
 .. _tut-standardmodules:
@@ -250,7 +258,7 @@ prompts:
    >>> sys.ps2
    '... '
    >>> sys.ps1 = 'C> '
-   C> print 'Yuck!'
+   C> print('Yuck!')
    Yuck!
    C>
 
@@ -308,31 +316,27 @@ want a list of those, they are defined in the standard module
 
    >>> import __builtin__
    >>> dir(__builtin__)
-   ['ArithmeticError', 'AssertionError', 'AttributeError', 'DeprecationWarning',
-    'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',
-    'FloatingPointError', 'FutureWarning', 'IOError', 'ImportError',
-    'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt',
-    'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented',
-    'NotImplementedError', 'OSError', 'OverflowError', 
-    'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError',
-    'RuntimeWarning', 'StopIteration', 'SyntaxError',
-    'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True',
-    'TypeError', 'UnboundLocalError', 'UnicodeDecodeError',
-    'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError',
-    'UserWarning', 'ValueError', 'Warning', 'WindowsError',
-    'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__',
-    '__name__', 'abs', 'basestring', 'bool', 'buffer',
-    'chr', 'classmethod', 'cmp', 'compile',
-    'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod',
-    'enumerate', 'eval', 'exec', 'exit', 'filter', 'float',
-    'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex',
-    'id', 'input', 'int', 'isinstance', 'issubclass', 'iter',
-    'len', 'license', 'list', 'locals', 'map', 'max', 'min',
-    'object', 'oct', 'open', 'ord', 'pow', 'property', 'quit', 'range',
-    'repr', 'reversed', 'round', 'set',
-    'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super',
-    'tuple', 'type', 'vars', 'zip']
 
+   ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'Buffer
+   Error', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Excep   
+   tion', 'False', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError   
+   ', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'KeyError',   
+    'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImp   
+   lemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecatio   
+   nWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning', 'StopIteration',   
+   'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True',   
+    'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', '   
+   UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueE   
+   rror', 'Warning', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__'   
+   , '__import__', '__name__', 'abs', 'all', 'any', 'basestring', 'bin', 'bool', 'b   
+   uffer', 'bytes', 'chr', 'chr8', 'classmethod', 'cmp', 'compile', 'complex', 'cop   
+   yright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'ex   
+   ec', 'exit', 'filter', 'float', 'frozenset', 'getattr', 'globals', 'hasattr', 'h   
+   ash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', '   
+   len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'o   
+   bject', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr   
+   ', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'st   
+   r', 'str8', 'sum', 'super', 'trunc', 'tuple', 'type', 'vars', 'zip']   
 
 .. _tut-packages:
 
diff --git a/Doc/tutorial/stdlib.rst b/Doc/tutorial/stdlib.rst
index dcd6659..a474975 100644
--- a/Doc/tutorial/stdlib.rst
+++ b/Doc/tutorial/stdlib.rst
@@ -67,7 +67,7 @@ instance the following output results from running ``python demo.py one two
 three`` at the command line::
 
    >>> import sys
-   >>> print sys.argv
+   >>> print(sys.argv)
    ['demo.py', 'one', 'two', 'three']
 
 The :mod:`getopt` module processes *sys.argv* using the conventions of the Unix
@@ -138,6 +138,8 @@ The :mod:`random` module provides tools for making random selections::
    >>> random.randrange(6)    # random integer chosen from range(6)
    4   
 
+The SciPy project <http://scipy.org> has many other modules for numerical
+computations.
 
 .. _tut-internet-access:
 
@@ -151,7 +153,7 @@ and :mod:`smtplib` for sending mail::
    >>> import urllib2
    >>> for line in urllib2.urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
    ...     if 'EST' in line or 'EDT' in line:  # look for Eastern Time
-   ...         print line
+   ...         print(line)
 
    <BR>Nov. 25, 09:43:32 PM EST
 
@@ -259,7 +261,7 @@ documentation::
    def average(values):
        """Computes the arithmetic mean of a list of numbers.
 
-       >>> print average([20, 30, 70])
+       >>> print(average([20, 30, 70]))
        40.0
        """
        return sum(values, 0.0) / len(values)
diff --git a/Doc/tutorial/stdlib2.rst b/Doc/tutorial/stdlib2.rst
index 0ce2757..bd1a225 100644
--- a/Doc/tutorial/stdlib2.rst
+++ b/Doc/tutorial/stdlib2.rst
@@ -184,14 +184,14 @@ tasks in background while the main program continues to run::
            f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)
            f.write(self.infile)
            f.close()
-           print 'Finished background zip of: ', self.infile
+           print('Finished background zip of: ', self.infile)
 
    background = AsyncZip('mydata.txt', 'myarchive.zip')
    background.start()
-   print 'The main program continues to run in foreground.'
+   print('The main program continues to run in foreground.')
 
    background.join()    # Wait for the background task to finish
-   print 'Main program waited until background was done.'
+   print('Main program waited until background was done.')
 
 The principal challenge of multi-threaded applications is coordinating threads
 that share data or other resources.  To that end, the threading module provides
@@ -309,7 +309,7 @@ tree searches::
    >>> from collections import deque
    >>> d = deque(["task1", "task2", "task3"])
    >>> d.append("task4")
-   >>> print "Handling", d.popleft()
+   >>> print("Handling", d.popleft())
    Handling task1
 
    unsearched = deque([starting_node])
diff --git a/Doc/tutorial/whatnow.rst b/Doc/tutorial/whatnow.rst
index 599fcbd..69fa9c3 100644
--- a/Doc/tutorial/whatnow.rst
+++ b/Doc/tutorial/whatnow.rst
@@ -48,6 +48,11 @@ More Python resources:
   Particularly notable contributions are collected in a book also titled Python
   Cookbook (O'Reilly & Associates, ISBN 0-596-00797-3.)
 
+* http://scipy.org: The Scientific Python project includes modules for fast
+  array computations and manipulations plus a host of packages for such 
+  things as linear algebra, Fourier transforms, non-linear solvers, 
+  random number distributions, statistical analysis and the like.
+
 For Python-related questions and problem reports, you can post to the newsgroup
 :newsgroup:`comp.lang.python`, or send them to the mailing list at
 python-list@python.org.  The newsgroup and mailing list are gatewayed, so
-- 
cgit v0.12