#3525: 3.0 exception changes in tutorial.

Doc/tutorial/classes.rst

@@ -671,7 +671,7 @@ class or a base class thereof (but not the other way around --- an except clause
 listing a derived class is not compatible with a base class).  For example, the
 following code will print B, C, D in that order::
 
-   class B:
+   class B(Exception):
        pass
    class C(B):
        pass

Doc/tutorial/errors.rst

@@ -1,4 +1,4 @@
-. _tut-errors:
+.. _tut-errors:
 
 *********************
 Errors and Exceptions
@@ -131,8 +131,8 @@ the exception (allowing a caller to handle the exception as well)::
        f = open('myfile.txt')
        s = f.readline()
        i = int(s.strip())
-   except IOError as (errno, strerror):
+   except IOError as err:
-       print("I/O error({0}): {1}".format(errno, strerror))
+       print("I/O error: {0}".format(err))
    except ValueError:
        print("Could not convert data to an integer.")
    except:
@@ -162,25 +162,21 @@ When an exception occurs, it may have an associated value, also known as the
 exception's *argument*. The presence and type of the argument depend on the
 exception type.
 
-The except clause may specify a variable after the exception name (or tuple).
+The except clause may specify a variable after the exception name.  The
-The variable is bound to an exception instance with the arguments stored in
+variable is bound to an exception instance with the arguments stored in
 ``instance.args``.  For convenience, the exception instance defines
-:meth:`__getitem__` and :meth:`__str__` so the arguments can be accessed or
+:meth:`__str__` so the arguments can be printed directly without having to
-printed directly without having to reference ``.args``.
+reference ``.args``.  One may also instantiate an exception first before
-
+raising it and add any attributes to it as desired. ::
-But use of ``.args`` is discouraged.  Instead, the preferred use is to pass a
-single argument to an exception (which can be a tuple if multiple arguments are
-needed) and have it bound to the ``message`` attribute.  One may also
-instantiate an exception first before raising it and add any attributes to it as
-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 be printed directly
+   ...    print(inst)          # __str__ allows args to be printed directly,
-   ...    x, y = inst          # __getitem__ allows args to be unpacked directly
+   ...                         # but may be overridden in exception subclasses
+   ...    x, y = inst.args     # unpack args
    ...    print('x =', x)
    ...    print('y =', y)
    ...
@@ -190,7 +186,7 @@ desired. ::
    x = spam
    y = eggs
 
-If an exception has an argument, it is printed as the last part ('detail') of
+If an exception has arguments, they are printed as the last part ('detail') of
 the message for unhandled exceptions.
 
 Exception handlers don't just handle exceptions if they occur immediately in the
@@ -202,10 +198,10 @@ indirectly) in the try clause. For example::
    ... 
    >>> try:
    ...     this_fails()
-   ... except ZeroDivisionError as detail:
+   ... except ZeroDivisionError as err:
-   ...     print('Handling run-time error:', detail)
+   ...     print('Handling run-time error:', err)
    ... 
-   Handling run-time error: integer division or modulo by zero
+   Handling run-time error: int division or modulo by zero
 
 
 .. _tut-raising: