Changed code environment into \bcode and \ecode macros.
Small lay-out improvements.
Took out a ref or two to "python -s".
diff --git a/Doc/tut.tex b/Doc/tut.tex
index 58d1575..5ef65de 100644
--- a/Doc/tut.tex
+++ b/Doc/tut.tex
@@ -1,7 +1,7 @@
% Format this file with latex.
-\documentstyle[palatino,11pt,myformat]{article}
-%\documentstyle[11pt,myformat]{article}
+%\documentstyle[palatino,11pt,myformat]{article}
+\documentstyle[11pt,myformat]{article}
\title{\bf
Python Tutorial \\
@@ -144,9 +144,9 @@
{\tt /usr/local}
in your \UNIX\ shell's search path makes it possible to start it by
typing the command
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
python
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
to the shell.
Since the choice of the directory where the interpreter lives is an
installation option, other places instead of
@@ -237,34 +237,17 @@
{\tt PYTHONPATH} or from the installation-dependent default.
See the section on Standard Modules later.
}
-The built-in module
-{\tt stdwin},
-if supported at all, is only available if the interpreter is started
-with the
-{\bf --s}
-flag.
-If this flag is given, stdwin is initialized as soon as the interpreter
-is started, and in the case of X11 stdwin certain command line arguments
-(like
-{\bf --display} )
-are consumed by stdwin.
On BSD'ish \UNIX\ systems, \Python\ scripts can be made directly executable,
like shell scripts, by putting the line
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
#! /usr/local/python
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
(assuming that's the name of the interpreter) at the beginning of the
script and giving the file an executable mode.
(The
{\tt \#!}
must be the first two characters of the file.)
-For scripts that use the built-in module
-{\tt stdwin},
-use
-\begin{code}\begin{verbatim}
-#! /usr/local/python -s
-\end{verbatim}\end{code}
\subsection{Interactive Input Editing and History Substitution}
@@ -312,15 +295,15 @@
be customized by placing commands in an initialization file called
{\tt \$HOME/.initrc}.
Key bindings have the form
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
key-name: function-name
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
and options can be set with
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
set option-name value
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
# I prefer vi-style editing:
set editing-mode vi
# Edit using a single line:
@@ -328,13 +311,13 @@
# Rebind some keys:
Meta-h: backward-kill-word
Control-u: universal-argument
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Note that the default binding for TAB in \Python\ is to insert a TAB
instead of Readline's default filename completion function.
If you insist, you can override this by putting
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
TAB: complete
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
in your
{\tt \$HOME/.inputrc}.
(Of course, this makes it hard to type indented continuation lines.)
@@ -374,7 +357,7 @@
work just as in most other languages (e.g., Pascal or C); parentheses
can be used for grouping.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> # This is a comment
>>> 2+2
4
@@ -385,48 +368,46 @@
>>> 7/3
2
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
As in C, the equal sign ({\tt =}) is used to assign a value to a variable.
The value of an assignment is not written:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> width = 20
>>> height = 5*9
>>> width * height
900
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
There is some support for floating point, but you can't mix floating
point and integral numbers in expression (yet):
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> 10.0 / 3.3
3.0303030303
>>>
-\end{verbatim}\end{code}
-
+\end{verbatim}\ecode
Besides numbers, \Python\ can also manipulate strings, enclosed in single
quotes:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> 'foo bar'
'foo bar'
>>> 'doesn\'t'
'doesn\'t'
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Strings are written inside quotes and with quotes and other funny
characters escaped by backslashes, to show the precise value.
(There is also a way to write strings without quotes and escapes.)
Strings can be concatenated (glued together) with the
{\tt +}
-operator, and repeated with
-{\tt *}:
-\begin{code}\begin{verbatim}
+operator, and repeated with~{\tt *}:
+\bcode\begin{verbatim}
>>> word = 'Help' + 'A'
>>> word
'HelpA'
>>> '<' + word*5 + '>'
'<HelpAHelpAHelpAHelpAHelpA>'
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Strings can be subscripted; as in C, the first character of a string has
subscript 0.
There is no separate character type; a character is simply a string of
@@ -434,7 +415,7 @@
As in Icon, substrings can be specified with the
{\em slice}
notation: two subscripts (indices) separated by a colon.
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> word[4]
'A'
>>> word[0:2]
@@ -450,11 +431,11 @@
>>> word[:3] + word[3:]
'HelpA'
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Degenerate cases are handled gracefully: an index that is too large is
replaced by the string size, an upper bound smaller than the lower bound
returns an empty string.
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> word[1:100]
'elpA'
>>> word[10:]
@@ -462,11 +443,11 @@
>>> word[2:1]
''
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Slice indices (but not simple subscripts) may be negative numbers, to
start counting from the right.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> word[-2:] # Take last two characters
'pA'
>>> word[:-2] # Drop last two characters
@@ -475,7 +456,7 @@
>>> word[-0:] # (since -0 equals 0)
'HelpA'
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The best way to remember how slices work is to think of the indices as
pointing
{\em between}
@@ -485,13 +466,13 @@
characters has index
{\tt n},
for example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The first row of numbers gives the position of the indices 0...5 in the
string; the second row gives the corresponding negative indices.
For nonnegative indices, the length of a slice is the difference of the
@@ -503,13 +484,12 @@
Finally, the built-in function {\tt len()} computes the length of a
string:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34
>>>
-\end{verbatim}\end{code}
-
+\end{verbatim}\ecode
\Python\ knows a number of
{\em compound}
data types, used to group together other values.
@@ -517,42 +497,42 @@
{\em list},
which can be written as a list of comma-separated values between square
brackets:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> a = ['foo', 'bar', 100, 1234]
>>> a
['foo', 'bar', 100, 1234]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
As for strings, list subscripts start at 0:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> a[0]
'foo'
>>> a[3]
1234
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Lists can be sliced and concatenated like strings:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> a[1:3]
['bar', 100]
>>> a[:2] + ['bletch', 2*2]
['foo', 'bar', 'bletch', 4]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Unlike strings, which are
{\em immutable},
it is possible to change individual elements of a list:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> a
['foo', 'bar', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['foo', 'bar', 123, 1234]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Assignment to slices is also possible, and this may even change the size
of the list:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> # Replace some items:
>>> a[0:2] = [1, 12]
>>> a
@@ -566,13 +546,13 @@
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The built-in function {\tt len()} also applies to lists:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> len(a)
4
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsection{Tuples and Sequences}
@@ -585,7 +565,7 @@
For instance, we can write an initial subsequence of the
{\em Fibonacci}
series as follows:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> # Fibonacci series:
>>> # the sum of two elements defines the next
>>> a, b = 0, 1
@@ -605,7 +585,7 @@
55
89
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
This example introduces several new features.
\begin{itemize}
\item
@@ -661,14 +641,14 @@
expressions and strings.
Strings are written without quotes and a space is inserted between
items, so you can format things nicely, like this:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> i = 256*256
>>> print 'The value of i is', i
The value of i is 65536
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
A trailing comma avoids the newline after the output:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> a, b = 0, 1
>>> while b < 1000:
... print b,
@@ -676,7 +656,7 @@
...
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Note that the interpreter inserts a newline before it prints the next
prompt if the last line was not completed.
\end{itemize}
@@ -691,7 +671,7 @@
Perhaps the most well-known statement type is the {\tt if} statement.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> if x < 0:
... x = 0
... print 'Negative changed to zero'
@@ -702,7 +682,7 @@
... else:
... print 'More'
...
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
There can be zero or more {\tt elif} parts, and the {\tt else} part is
optional.
The keyword `{\tt elif}' is short for `{\tt else if}', and is useful to
@@ -719,7 +699,7 @@
and step (as C), \Python's {\tt for} statement iterates over the items
of any sequence (e.g., a list or a string).
For example (no pun intended):
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> # Measure some strings:
>>> a = ['cat', 'window', 'defenestrate']
>>> for x in a:
@@ -729,7 +709,7 @@
window 6
defenestrate 12
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsubsection{The {\tt range()} Function}
@@ -737,17 +717,17 @@
function {\tt range()} comes in handy.
It generates lists containing arithmetic progressions,
e.g.:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The given end point is never part of the generated list;
{\tt range(10)} generates a list of 10 values,
exactly 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):
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> range(5, 10)
[5, 6, 7, 8, 9]
>>> range(0, 10, 3)
@@ -755,10 +735,10 @@
>>> range(-10, -100, -30)
[-10, -40, -70]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
To iterate over the indices of a sequence, combine {\tt range()}
and {\tt len()} as follows:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> a = ['Mary', 'had', 'a', 'little', 'boy']
>>> for i in range(len(a)):
... print i, a[i]
@@ -769,7 +749,7 @@
3 little
4 boy
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsubsection{Break Statements and Else Clauses on Loops}
@@ -781,7 +761,7 @@
terminated by a {\tt break} statement.
This is exemplified by the following loop, which searches for a list
item of value 0:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> for n in range(2, 10):
... for x in range(2, n):
... if n % x = 0:
@@ -799,7 +779,7 @@
8 equals 2 * 4
9 equals 3 * 3
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsubsection{Pass Statements}
@@ -807,11 +787,11 @@
It can be used when a statement is required syntactically but the
program requires no action.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> while 1:
... pass # Busy-wait for keyboard interrupt
...
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsubsection{Conditions Revisited}
@@ -821,7 +801,7 @@
We can create a function that writes the Fibonacci series to an
arbitrary boundary:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> def fib(n): # write Fibonacci series up to n
... a, b = 0, 1
... while b <= n:
@@ -832,7 +812,7 @@
>>> fib(2000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The keyword
{\tt def}
introduces a function
@@ -872,14 +852,14 @@
This value can be assigned to another name which can then also be used
as a function.
This serves as a general renaming mechanism:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> fib
<function object at 10042ed0>
>>> f = fib
>>> f(100)
1 1 2 3 5 8 13 21 34 55 89
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
You might object that
{\tt fib}
is not a function but a procedure.
@@ -891,14 +871,14 @@
Writing the value {\tt None} is normally suppressed by the interpreter
if it would be the only value written.
You can see it if you really want to:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> print fib(0)
None
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
It is simple to write a function that returns a list of the numbers of
the Fibonacci series, instead of printing it:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> def fib2(n): # return Fibonacci series up to n
... result = []
... a, b = 0, 1
@@ -911,7 +891,7 @@
>>> f100 # write the result
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
This example, as usual, demonstrates some new \Python\ features:
\begin{itemize}
\item
@@ -963,7 +943,7 @@
Sorts the elements of the list.
\end{description}
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> a = [10, 100, 1, 1000]
>>> a.insert(2, -1)
>>> a
@@ -977,7 +957,7 @@
>>> b
['Mary', 'a', 'boy', 'had', 'little']
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsection{Modules}
@@ -1010,7 +990,7 @@
For instance, use your favorite text editor to create a file called
{\tt fibo.py}
in the current directory with the following contents:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
# Fibonacci numbers module
def fib(n): # write Fibonacci series up to n
@@ -1026,33 +1006,33 @@
ret.append(b)
a, b = b, a+b
return ret
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Now enter the \Python\ interpreter and import this module with the
following command:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> import fibo
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
This does not enter the names of the functions defined in
{\tt fibo}
directly in the symbol table; it only enters the module name
{\tt fibo}
there.
Using the module name you can access the functions:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
If you intend to use a function often you can assign it to a local name:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> fib = fibo.fib
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsubsection{More on Modules}
@@ -1090,23 +1070,23 @@
statement that imports names from a module directly into the importing
module's symbol table.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
This does not introduce the module name from which the imports are taken
in the local symbol table (so in the example, {\tt fibo} is not
defined).
There is even a variant to import all names that a module defines:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
This imports all names except those beginning with an underscore
({\tt \_}).
@@ -1130,7 +1110,7 @@
and
{\tt sys.ps2}
define the strings used as primary and secondary prompts:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> import sys
>>> sys.ps1
'>>> '
@@ -1140,7 +1120,7 @@
C> print 'Yuck!'
Yuck!
C>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
These two variables are only defined if the interpreter is in
interactive mode.
@@ -1154,11 +1134,11 @@
{\tt PYTHONPATH}
is not set.
You can modify it using standard list operations, e.g.:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> import sys
>>> sys.path.append('/ufs/guido/lib/python')
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsection{Errors and Exceptions}
@@ -1173,14 +1153,14 @@
Syntax errors, also known as parsing errors, are perhaps the most common
kind of complaint you get while you are still learning \Python:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> while 1 print 'Hello world'
Parsing error: file <stdin>, line 1:
while 1 print 'Hello world'
^
Unhandled exception: run-time error: syntax error
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The parser repeats the offending line and displays a little `arrow'
pointing at the earliest point in the line where the error was detected.
The error is caused by (or at least detected at) the token
@@ -1194,7 +1174,7 @@
Even if a statement or expression is syntactically correct, it may cause
an error when an attempt is made to execute it:
-\begin{code}\begin{verbatim}
+\bcode\small\begin{verbatim}
>>> 10 * (1/0)
Unhandled exception: run-time error: integer division by zero
Stack backtrace (innermost last):
@@ -1208,7 +1188,7 @@
Stack backtrace (innermost last):
File "<stdin>", line 1
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Errors detected during execution are called
{\em exceptions}
and are not unconditionally fatal: you will soon learn how to handle
@@ -1261,7 +1241,7 @@
It is possible to write programs that handle selected exceptions.
Look at the following example, which prints a table of inverses of
some floating point numbers:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> numbers = [0.3333, 2.5, 0.0, 10.0]
>>> for x in numbers:
... print x,
@@ -1275,7 +1255,7 @@
0 *** has no inverse ***
10 0.1
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The {\tt try} statement works as follows.
\begin{itemize}
\item
@@ -1306,10 +1286,10 @@
clause, not in other handlers of the same {\tt try} statement.
An except clause may name multiple exceptions as a parenthesized list,
e.g.:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
... except (RuntimeError, TypeError, NameError):
... pass
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The last except clause may omit the exception name(s), to serve as a
wildcard.
Use this with extreme caution!
@@ -1321,7 +1301,7 @@
For exception types which have an argument, the except clause may
specify a variable after the exception name (or list) to receive the
argument's value, as follows:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> try:
... foo()
... except NameError, x:
@@ -1329,7 +1309,7 @@
...
name foo undefined
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
If an exception has an argument, it is printed as the third part
(`detail') of the message for unhandled exceptions.
@@ -1346,7 +1326,7 @@
The string is printed as the second part of the message for unhandled
exceptions.
Their names and values are:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
EOFError 'end-of-file read'
KeyboardInterrupt 'keyboard interrupt'
MemoryError 'out of memory' *
@@ -1354,7 +1334,7 @@
RuntimeError 'run-time error' *
SystemError 'system error' *
TypeError 'type error' *
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The meanings should be clear enough.
Those exceptions with a {\tt *} in the third column have an argument.
@@ -1362,7 +1342,7 @@
immediately in the try clause, but also if they occur inside functions
that are called (even indirectly) in the try clause.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> def this_fails():
... x = 1/0
...
@@ -1373,20 +1353,20 @@
...
Handling run-time error: domain error or zero division
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsubsection{Raising Exceptions}
The {\tt raise} statement allows the programmer to force a specified
exception to occur.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> raise NameError, 'Hi There!'
Unhandled exception: undefined name: Hi There!
Stack backtrace (innermost last):
File "<stdin>", line 1
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The first argument to {\tt raise} names the exception to be raised.
The optional second argument specifies the exception's argument.
@@ -1395,7 +1375,7 @@
Programs may name their own exceptions by assigning a string to a
variable.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> my_exc = 'nobody likes me!'
>>> try:
... raise my_exc, 2*2
@@ -1408,7 +1388,7 @@
Stack backtrace (innermost last):
File "<stdin>", line 7
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Many standard modules use this to report errors that may occur in
functions they define.
@@ -1417,7 +1397,7 @@
The {\tt try} statement has another optional clause which is intended to
define clean-up actions that must be executed under all circumstances.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> try:
... raise KeyboardInterrupt
... finally:
@@ -1428,7 +1408,7 @@
Stack backtrace (innermost last):
File "<stdin>", line 2
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The
{\em finally\ clause}
must follow the except clauses(s), if any.
@@ -1489,7 +1469,7 @@
representing a (finite) mathematical set with operations to add and
remove elements, a membership test, and a request for the size of the
set.
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
class Set():
def new(self):
self.elements = []
@@ -1507,7 +1487,7 @@
return e in self.elements
def size(self):
return len(self.elements)
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Note that the class definition looks like a big compound statement,
with all the function definitons indented repective to the
{\tt class}
@@ -1518,7 +1498,7 @@
is the only contents of the module file
{\tt SetClass.py}.
We can then use it in a \Python\ program as follows:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> from SetClass import Set
>>> a = Set().new() # create a Set object
>>> a.add(2)
@@ -1538,7 +1518,7 @@
>>>
now a has 2 elements
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
From the example we learn in the first place that the functions defined
in the class (e.g.,
{\tt add})
diff --git a/Doc/tut/tut.tex b/Doc/tut/tut.tex
index 58d1575..5ef65de 100644
--- a/Doc/tut/tut.tex
+++ b/Doc/tut/tut.tex
@@ -1,7 +1,7 @@
% Format this file with latex.
-\documentstyle[palatino,11pt,myformat]{article}
-%\documentstyle[11pt,myformat]{article}
+%\documentstyle[palatino,11pt,myformat]{article}
+\documentstyle[11pt,myformat]{article}
\title{\bf
Python Tutorial \\
@@ -144,9 +144,9 @@
{\tt /usr/local}
in your \UNIX\ shell's search path makes it possible to start it by
typing the command
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
python
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
to the shell.
Since the choice of the directory where the interpreter lives is an
installation option, other places instead of
@@ -237,34 +237,17 @@
{\tt PYTHONPATH} or from the installation-dependent default.
See the section on Standard Modules later.
}
-The built-in module
-{\tt stdwin},
-if supported at all, is only available if the interpreter is started
-with the
-{\bf --s}
-flag.
-If this flag is given, stdwin is initialized as soon as the interpreter
-is started, and in the case of X11 stdwin certain command line arguments
-(like
-{\bf --display} )
-are consumed by stdwin.
On BSD'ish \UNIX\ systems, \Python\ scripts can be made directly executable,
like shell scripts, by putting the line
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
#! /usr/local/python
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
(assuming that's the name of the interpreter) at the beginning of the
script and giving the file an executable mode.
(The
{\tt \#!}
must be the first two characters of the file.)
-For scripts that use the built-in module
-{\tt stdwin},
-use
-\begin{code}\begin{verbatim}
-#! /usr/local/python -s
-\end{verbatim}\end{code}
\subsection{Interactive Input Editing and History Substitution}
@@ -312,15 +295,15 @@
be customized by placing commands in an initialization file called
{\tt \$HOME/.initrc}.
Key bindings have the form
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
key-name: function-name
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
and options can be set with
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
set option-name value
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
# I prefer vi-style editing:
set editing-mode vi
# Edit using a single line:
@@ -328,13 +311,13 @@
# Rebind some keys:
Meta-h: backward-kill-word
Control-u: universal-argument
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Note that the default binding for TAB in \Python\ is to insert a TAB
instead of Readline's default filename completion function.
If you insist, you can override this by putting
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
TAB: complete
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
in your
{\tt \$HOME/.inputrc}.
(Of course, this makes it hard to type indented continuation lines.)
@@ -374,7 +357,7 @@
work just as in most other languages (e.g., Pascal or C); parentheses
can be used for grouping.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> # This is a comment
>>> 2+2
4
@@ -385,48 +368,46 @@
>>> 7/3
2
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
As in C, the equal sign ({\tt =}) is used to assign a value to a variable.
The value of an assignment is not written:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> width = 20
>>> height = 5*9
>>> width * height
900
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
There is some support for floating point, but you can't mix floating
point and integral numbers in expression (yet):
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> 10.0 / 3.3
3.0303030303
>>>
-\end{verbatim}\end{code}
-
+\end{verbatim}\ecode
Besides numbers, \Python\ can also manipulate strings, enclosed in single
quotes:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> 'foo bar'
'foo bar'
>>> 'doesn\'t'
'doesn\'t'
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Strings are written inside quotes and with quotes and other funny
characters escaped by backslashes, to show the precise value.
(There is also a way to write strings without quotes and escapes.)
Strings can be concatenated (glued together) with the
{\tt +}
-operator, and repeated with
-{\tt *}:
-\begin{code}\begin{verbatim}
+operator, and repeated with~{\tt *}:
+\bcode\begin{verbatim}
>>> word = 'Help' + 'A'
>>> word
'HelpA'
>>> '<' + word*5 + '>'
'<HelpAHelpAHelpAHelpAHelpA>'
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Strings can be subscripted; as in C, the first character of a string has
subscript 0.
There is no separate character type; a character is simply a string of
@@ -434,7 +415,7 @@
As in Icon, substrings can be specified with the
{\em slice}
notation: two subscripts (indices) separated by a colon.
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> word[4]
'A'
>>> word[0:2]
@@ -450,11 +431,11 @@
>>> word[:3] + word[3:]
'HelpA'
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Degenerate cases are handled gracefully: an index that is too large is
replaced by the string size, an upper bound smaller than the lower bound
returns an empty string.
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> word[1:100]
'elpA'
>>> word[10:]
@@ -462,11 +443,11 @@
>>> word[2:1]
''
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Slice indices (but not simple subscripts) may be negative numbers, to
start counting from the right.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> word[-2:] # Take last two characters
'pA'
>>> word[:-2] # Drop last two characters
@@ -475,7 +456,7 @@
>>> word[-0:] # (since -0 equals 0)
'HelpA'
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The best way to remember how slices work is to think of the indices as
pointing
{\em between}
@@ -485,13 +466,13 @@
characters has index
{\tt n},
for example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
+---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0 1 2 3 4 5
-5 -4 -3 -2 -1
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The first row of numbers gives the position of the indices 0...5 in the
string; the second row gives the corresponding negative indices.
For nonnegative indices, the length of a slice is the difference of the
@@ -503,13 +484,12 @@
Finally, the built-in function {\tt len()} computes the length of a
string:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34
>>>
-\end{verbatim}\end{code}
-
+\end{verbatim}\ecode
\Python\ knows a number of
{\em compound}
data types, used to group together other values.
@@ -517,42 +497,42 @@
{\em list},
which can be written as a list of comma-separated values between square
brackets:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> a = ['foo', 'bar', 100, 1234]
>>> a
['foo', 'bar', 100, 1234]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
As for strings, list subscripts start at 0:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> a[0]
'foo'
>>> a[3]
1234
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Lists can be sliced and concatenated like strings:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> a[1:3]
['bar', 100]
>>> a[:2] + ['bletch', 2*2]
['foo', 'bar', 'bletch', 4]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Unlike strings, which are
{\em immutable},
it is possible to change individual elements of a list:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> a
['foo', 'bar', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['foo', 'bar', 123, 1234]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Assignment to slices is also possible, and this may even change the size
of the list:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> # Replace some items:
>>> a[0:2] = [1, 12]
>>> a
@@ -566,13 +546,13 @@
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The built-in function {\tt len()} also applies to lists:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> len(a)
4
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsection{Tuples and Sequences}
@@ -585,7 +565,7 @@
For instance, we can write an initial subsequence of the
{\em Fibonacci}
series as follows:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> # Fibonacci series:
>>> # the sum of two elements defines the next
>>> a, b = 0, 1
@@ -605,7 +585,7 @@
55
89
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
This example introduces several new features.
\begin{itemize}
\item
@@ -661,14 +641,14 @@
expressions and strings.
Strings are written without quotes and a space is inserted between
items, so you can format things nicely, like this:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> i = 256*256
>>> print 'The value of i is', i
The value of i is 65536
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
A trailing comma avoids the newline after the output:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> a, b = 0, 1
>>> while b < 1000:
... print b,
@@ -676,7 +656,7 @@
...
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Note that the interpreter inserts a newline before it prints the next
prompt if the last line was not completed.
\end{itemize}
@@ -691,7 +671,7 @@
Perhaps the most well-known statement type is the {\tt if} statement.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> if x < 0:
... x = 0
... print 'Negative changed to zero'
@@ -702,7 +682,7 @@
... else:
... print 'More'
...
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
There can be zero or more {\tt elif} parts, and the {\tt else} part is
optional.
The keyword `{\tt elif}' is short for `{\tt else if}', and is useful to
@@ -719,7 +699,7 @@
and step (as C), \Python's {\tt for} statement iterates over the items
of any sequence (e.g., a list or a string).
For example (no pun intended):
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> # Measure some strings:
>>> a = ['cat', 'window', 'defenestrate']
>>> for x in a:
@@ -729,7 +709,7 @@
window 6
defenestrate 12
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsubsection{The {\tt range()} Function}
@@ -737,17 +717,17 @@
function {\tt range()} comes in handy.
It generates lists containing arithmetic progressions,
e.g.:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The given end point is never part of the generated list;
{\tt range(10)} generates a list of 10 values,
exactly 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):
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> range(5, 10)
[5, 6, 7, 8, 9]
>>> range(0, 10, 3)
@@ -755,10 +735,10 @@
>>> range(-10, -100, -30)
[-10, -40, -70]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
To iterate over the indices of a sequence, combine {\tt range()}
and {\tt len()} as follows:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> a = ['Mary', 'had', 'a', 'little', 'boy']
>>> for i in range(len(a)):
... print i, a[i]
@@ -769,7 +749,7 @@
3 little
4 boy
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsubsection{Break Statements and Else Clauses on Loops}
@@ -781,7 +761,7 @@
terminated by a {\tt break} statement.
This is exemplified by the following loop, which searches for a list
item of value 0:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> for n in range(2, 10):
... for x in range(2, n):
... if n % x = 0:
@@ -799,7 +779,7 @@
8 equals 2 * 4
9 equals 3 * 3
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsubsection{Pass Statements}
@@ -807,11 +787,11 @@
It can be used when a statement is required syntactically but the
program requires no action.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> while 1:
... pass # Busy-wait for keyboard interrupt
...
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsubsection{Conditions Revisited}
@@ -821,7 +801,7 @@
We can create a function that writes the Fibonacci series to an
arbitrary boundary:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> def fib(n): # write Fibonacci series up to n
... a, b = 0, 1
... while b <= n:
@@ -832,7 +812,7 @@
>>> fib(2000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The keyword
{\tt def}
introduces a function
@@ -872,14 +852,14 @@
This value can be assigned to another name which can then also be used
as a function.
This serves as a general renaming mechanism:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> fib
<function object at 10042ed0>
>>> f = fib
>>> f(100)
1 1 2 3 5 8 13 21 34 55 89
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
You might object that
{\tt fib}
is not a function but a procedure.
@@ -891,14 +871,14 @@
Writing the value {\tt None} is normally suppressed by the interpreter
if it would be the only value written.
You can see it if you really want to:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> print fib(0)
None
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
It is simple to write a function that returns a list of the numbers of
the Fibonacci series, instead of printing it:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> def fib2(n): # return Fibonacci series up to n
... result = []
... a, b = 0, 1
@@ -911,7 +891,7 @@
>>> f100 # write the result
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
This example, as usual, demonstrates some new \Python\ features:
\begin{itemize}
\item
@@ -963,7 +943,7 @@
Sorts the elements of the list.
\end{description}
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> a = [10, 100, 1, 1000]
>>> a.insert(2, -1)
>>> a
@@ -977,7 +957,7 @@
>>> b
['Mary', 'a', 'boy', 'had', 'little']
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsection{Modules}
@@ -1010,7 +990,7 @@
For instance, use your favorite text editor to create a file called
{\tt fibo.py}
in the current directory with the following contents:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
# Fibonacci numbers module
def fib(n): # write Fibonacci series up to n
@@ -1026,33 +1006,33 @@
ret.append(b)
a, b = b, a+b
return ret
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Now enter the \Python\ interpreter and import this module with the
following command:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> import fibo
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
This does not enter the names of the functions defined in
{\tt fibo}
directly in the symbol table; it only enters the module name
{\tt fibo}
there.
Using the module name you can access the functions:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
If you intend to use a function often you can assign it to a local name:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> fib = fibo.fib
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsubsection{More on Modules}
@@ -1090,23 +1070,23 @@
statement that imports names from a module directly into the importing
module's symbol table.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
This does not introduce the module name from which the imports are taken
in the local symbol table (so in the example, {\tt fibo} is not
defined).
There is even a variant to import all names that a module defines:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
This imports all names except those beginning with an underscore
({\tt \_}).
@@ -1130,7 +1110,7 @@
and
{\tt sys.ps2}
define the strings used as primary and secondary prompts:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> import sys
>>> sys.ps1
'>>> '
@@ -1140,7 +1120,7 @@
C> print 'Yuck!'
Yuck!
C>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
These two variables are only defined if the interpreter is in
interactive mode.
@@ -1154,11 +1134,11 @@
{\tt PYTHONPATH}
is not set.
You can modify it using standard list operations, e.g.:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> import sys
>>> sys.path.append('/ufs/guido/lib/python')
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsection{Errors and Exceptions}
@@ -1173,14 +1153,14 @@
Syntax errors, also known as parsing errors, are perhaps the most common
kind of complaint you get while you are still learning \Python:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> while 1 print 'Hello world'
Parsing error: file <stdin>, line 1:
while 1 print 'Hello world'
^
Unhandled exception: run-time error: syntax error
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The parser repeats the offending line and displays a little `arrow'
pointing at the earliest point in the line where the error was detected.
The error is caused by (or at least detected at) the token
@@ -1194,7 +1174,7 @@
Even if a statement or expression is syntactically correct, it may cause
an error when an attempt is made to execute it:
-\begin{code}\begin{verbatim}
+\bcode\small\begin{verbatim}
>>> 10 * (1/0)
Unhandled exception: run-time error: integer division by zero
Stack backtrace (innermost last):
@@ -1208,7 +1188,7 @@
Stack backtrace (innermost last):
File "<stdin>", line 1
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Errors detected during execution are called
{\em exceptions}
and are not unconditionally fatal: you will soon learn how to handle
@@ -1261,7 +1241,7 @@
It is possible to write programs that handle selected exceptions.
Look at the following example, which prints a table of inverses of
some floating point numbers:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> numbers = [0.3333, 2.5, 0.0, 10.0]
>>> for x in numbers:
... print x,
@@ -1275,7 +1255,7 @@
0 *** has no inverse ***
10 0.1
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The {\tt try} statement works as follows.
\begin{itemize}
\item
@@ -1306,10 +1286,10 @@
clause, not in other handlers of the same {\tt try} statement.
An except clause may name multiple exceptions as a parenthesized list,
e.g.:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
... except (RuntimeError, TypeError, NameError):
... pass
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The last except clause may omit the exception name(s), to serve as a
wildcard.
Use this with extreme caution!
@@ -1321,7 +1301,7 @@
For exception types which have an argument, the except clause may
specify a variable after the exception name (or list) to receive the
argument's value, as follows:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> try:
... foo()
... except NameError, x:
@@ -1329,7 +1309,7 @@
...
name foo undefined
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
If an exception has an argument, it is printed as the third part
(`detail') of the message for unhandled exceptions.
@@ -1346,7 +1326,7 @@
The string is printed as the second part of the message for unhandled
exceptions.
Their names and values are:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
EOFError 'end-of-file read'
KeyboardInterrupt 'keyboard interrupt'
MemoryError 'out of memory' *
@@ -1354,7 +1334,7 @@
RuntimeError 'run-time error' *
SystemError 'system error' *
TypeError 'type error' *
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The meanings should be clear enough.
Those exceptions with a {\tt *} in the third column have an argument.
@@ -1362,7 +1342,7 @@
immediately in the try clause, but also if they occur inside functions
that are called (even indirectly) in the try clause.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> def this_fails():
... x = 1/0
...
@@ -1373,20 +1353,20 @@
...
Handling run-time error: domain error or zero division
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
\subsubsection{Raising Exceptions}
The {\tt raise} statement allows the programmer to force a specified
exception to occur.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> raise NameError, 'Hi There!'
Unhandled exception: undefined name: Hi There!
Stack backtrace (innermost last):
File "<stdin>", line 1
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The first argument to {\tt raise} names the exception to be raised.
The optional second argument specifies the exception's argument.
@@ -1395,7 +1375,7 @@
Programs may name their own exceptions by assigning a string to a
variable.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> my_exc = 'nobody likes me!'
>>> try:
... raise my_exc, 2*2
@@ -1408,7 +1388,7 @@
Stack backtrace (innermost last):
File "<stdin>", line 7
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Many standard modules use this to report errors that may occur in
functions they define.
@@ -1417,7 +1397,7 @@
The {\tt try} statement has another optional clause which is intended to
define clean-up actions that must be executed under all circumstances.
For example:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> try:
... raise KeyboardInterrupt
... finally:
@@ -1428,7 +1408,7 @@
Stack backtrace (innermost last):
File "<stdin>", line 2
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
The
{\em finally\ clause}
must follow the except clauses(s), if any.
@@ -1489,7 +1469,7 @@
representing a (finite) mathematical set with operations to add and
remove elements, a membership test, and a request for the size of the
set.
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
class Set():
def new(self):
self.elements = []
@@ -1507,7 +1487,7 @@
return e in self.elements
def size(self):
return len(self.elements)
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
Note that the class definition looks like a big compound statement,
with all the function definitons indented repective to the
{\tt class}
@@ -1518,7 +1498,7 @@
is the only contents of the module file
{\tt SetClass.py}.
We can then use it in a \Python\ program as follows:
-\begin{code}\begin{verbatim}
+\bcode\begin{verbatim}
>>> from SetClass import Set
>>> a = Set().new() # create a Set object
>>> a.add(2)
@@ -1538,7 +1518,7 @@
>>>
now a has 2 elements
>>>
-\end{verbatim}\end{code}
+\end{verbatim}\ecode
From the example we learn in the first place that the functions defined
in the class (e.g.,
{\tt add})