Copyright 1993, 1994 Guido van Rossum. Unchanged electronic redistribution of this FAQ is allowed. Printed redistribution only with permission of the author. No warranties.
Author's address:The latest version of this FAQ is available by anonymous ftp (here). It will also be posted regularly to the newsgroups comp.answers and comp.lang.python.
Guido van Rossum
CWI, dept. CST
Kruislaan 413
P.O. Box 94079
1090 GB Amsterdam
The Netherlands
Email: guido@cwi.nl
Many FAQs, including this one, are available by anonymous ftp from rtfm.mit.edu in the directory pub/usenet/news.answers. The name under which a FAQ is archived appears in the Archive-name line at the top of the article. This FAQ is archived as python-faq/part1.
There's a mail server on that machine which will send you files from the archive by e-mail if you have no ftp access. You send an e-mail message to mail-server@rtfm.mit.edu containing the single word help in the message body to receive instructions.
To find out more, the best thing to do is to start reading the tutorial from the documentation set (see a few questions further down).
The following sites keep mirrors of the Python distribution:
Site IP address Directory gatekeeper.dec.com 16.1.0.2 /pub/plan/python/cwi ftp.uu.net 192.48.96.9 /languages/python ftp.wustl.edu 128.252.135.4 /graphics/graphics/sgi-stuff/python ftp.funet.fi 128.214.6.100 /pub/languages/python (old?) ftp.fu-berlin.de 130.133.4.50 /pub/unix/languages/python (*python* only)Or try archie on e.g. python1.0 to locate the nearest copy of that version...
Guido van Rossum and Jelke de Boer, ``Interactively Testing Remote Servers Using the Python Programming Language'', CWI Quarterly, Volume 4, Issue 4 (December 1991), Amsterdam, pp 283-303.
LaTeX source for this paper is available as part of the Python source distribution.
A more recent high-level description of Python is:
Guido van Rossum, ``An Introduction to Python for UNIX/C Programmers'', in the proceedings of the NLUUG najaarsconferentie 1993 (dutch UNIX users group meeting november 1993).
PostScript for this paper and for the slides used for the accompanying presentation can be found in the ftp directory mentioned a few questions earlier, with filenames nluug-paper.ps and nluug-slides.ps, respectively.
The University of Virginia uses Python to control a virtual reality
engine. Contact: Matt Conway
See also the next question.
Individuals at many other companies are using Python for
internal development (witness their contributions to the Python
mailing list or newsgroup).
Python has also been elected as an extension language by MADE, a
consortium supported by the European Committee's ESPRIT program and
consisting of Bull, CWI and some other European companies. Contact:
Ivan Herman
Once you have installed the library, you need to point sys.path to it.
Assuming the library is in C:\misc\python\lib, the following commands
will point your Python interpreter to it (note the doubled backslashes
-- you can also use single forward slashes instead):
Regarding the same question for the PC, Kurt Wm. Hemr writes:
Are there any commercial projects going on using Python?
A. Several companies have revealed to me that they are planning or
considering to use Python in a future product. The furthest is
Sunrise Software, who already have a product out using Python -- they
use Python for a GUI management application and an SNMP network
manangement application. Contact: How stable is Python?
A. Very stable. While the current version number (1.0.2) would
suggest it is in the early stages of development, in fact new, stable
releases (numbered 0.9.x) have been coming out roughly every 3 to 6
months for the past four years. What new developments are expected for Python in the future?
A. Without warranty that any of this will actually be realized: I am
currently thinking about mechanisms for built-in on-line help and a
switch/case statement. There have been some discussions on hierarchical
module names which might solve the problem of the development of large
packages. A pthreads interface has been contributed which I would like to
merge into the latest release. The X interface needs improving. There are
also some people (independently) working on a windowing interface based on
STDWIN but with the power and ease of use of the average modern widget set.
I still hope to get some help in producing a Windows version. It would be
nice if there were a window-based class browser (Someone at CWI has
contributed one using Motif but it needs some work). Also: improved support
for embedding Python in other applications, e.g. by renaming most global
symbols to have a "Py" prefix and providing more documentation and threading
support. Building Python
Is there a test set?
A. Yes, simply do "import testall" (or "import autotest" if you aren't
interested in the output). The standard modules whose name begins
with "test" together comprise the test. The test set doesn't test
*all* features of Python but it goes a long way to confirm that a new
port is actually working. The Makefile contains an entry "make test"
which runs the autotest module.
When running the test set, I get complaints about floating point
operations, but when playing with floating point operations I cannot
find anything wrong with them.
A. The test set makes occasional unwarranted assumptions about the
semantics of C floating point operations. Until someone donates a
better floating point test set, you will have to comment out the
offending floating point tests and execute similar tests manually.
Link errors building Python with STDWIN on SGI IRIX.
A. Rebuild STDWIN, specifying "CC=cc -cckr" in the Makefile. Link errors after rerunning the configure script.
A. It is generally necessary to run "make clean" after a configuration
change. The python interpreter complains about options passed to a
script (after the script name).
A. You are probably linking with GNU getopt, e.g. through -liberty.
Don't. (If you are using this because you link with -lreadline, use
the readline distributed with Python instead.) When building on the SGI, make tries to run python to create
glmodule.c, but python hasn't been built or installed yet.
A. Comment out the line mentioning glmodule.c in Setup and build a
python without gl first; install it or make sure it is in your $PATH,
then edit the Setup file again to turn on the gl module, and make
again. You don't need to do "make clean"; you do need to run "make
Makefile" in the Modules subdirectory (or just run "make" at the
toplevel). Other trouble building Python 1.0.2 on platform X.
A. Please email the details to Programming in Python
Is there a source code level debugger with breakpoints, step,
etc.?
A. Yes. Check out module pdb; pdb.help() prints the documentation (or
you can read it as Lib/pdb.doc). If you use the STDWIN option,
there's also a windowing interface, wdb. You can write your own
debugger by using the code for pdb or wdb as an example. Can I create an object class with some methods implemented in
C and others in Python (e.g. through inheritance)? (Also phrased as:
Can I use a built-in type as base class?)
A. No, but you can easily create a Python class which serves as a
wrapper around a built-in object, e.g. (for dictionaries):
# A user-defined class behaving almost identical
# to a built-in dictionary.
class UserDict:
def __init__(self): self.data = {}
def __repr__(self): return repr(self.data)
def __cmp__(self, dict):
if type(dict) == type(self.data):
return cmp(self.data, dict)
else:
return cmp(self.data, dict.data)
def __len__(self): return len(self.data)
def __getitem__(self, key): return self.data[key]
def __setitem__(self, key, item): self.data[key] = item
def __delitem__(self, key): del self.data[key]
def keys(self): return self.data.keys()
def items(self): return self.data.items()
def values(self): return self.data.values()
def has_key(self, key): return self.data.has_key(key)
Is there a curses/termcap package for Python?
A. No, but you can use the "alfa" (== character cell) version of STDWIN. (STDWIN == Standard
Windows, a portable windowing system interface by the same author.) This
will also prepare your program for porting to windowing environments such as
X11 or the Macintosh. Is there an equivalent to C's onexit() in Python?
A. Yes, if you import sys and assign a function to sys.exitfunc, it
will be called when your program exits, is killed by an unhandled
exception, or (on UNIX) receives a SIGHUP or SIGTERM signal. When I define a function nested inside another function, the
nested function seemingly can't access the local variables of the
outer function. What is going on? How do I pass local data to a
nested function?
A. Python does not have arbitrarily nested scopes. When you need to
create a function that needs to access some data which you have
available locally, create a new class to hold the data and return a
method of an instance of that class, e.g.:
class MultiplierClass:
def __init__(self, factor):
self.factor = factor
def multiplier(self, argument):
return argument * self.factor
def generate_multiplier(factor):
return MultiplierClass(factor).multiplier
twice = generate_multiplier(2)
print twice(10)
# Output: 20
How do I iterate over a sequence in reverse order?
A. If it is a list, the fastest solution is
list.reverse()
try:
for x in list:
"do something with x"
finally:
list.reverse()
This has the disadvantage that while you are in the loop, the list
is temporarily reversed. If you don't like this, you can make a copy.
This appears expensive but is actually faster than other solutions:
rev = list[:]
rev.reverse()
for x in rev:
If it isn't a list, a more general but slower solution is:
i = len(list)
while i > 0:
i = i-1
x = list[i]
A more elegant solution, is to define a class which acts as a sequence
and yields the elements in reverse order (solution due to Steve
Majewski):
class Rev:
def __init__(self, seq):
self.forw = seq
def __len__(self):
return len(self.forw)
def __getitem__(self, i):
return self.forw[-(i + 1)]
You can now simply write:
for x in Rev(list):
Unfortunately, this solution is slowest of all, due the the method
call overhead... My program is too slow. How do I speed it up?
A. That's a tough one, in general. There are many tricks to speed up
Python code; I would consider rewriting parts in C only as a last
resort. One thing to notice is that function and (especially) method
calls are rather expensive; if you have designed a purely OO interface
with lots of tiny functions that don't do much more than get or set an
instance variable or call another method, you may consider using a
more direct way, e.g. directly accessing instance variables. Also see
the standard module "profile" (described in the file
"python/lib/profile.doc") which makes it possible to find out where
your program is spending most of its time (if you have some patience
-- the profiling itself can slow your program down by an order of
magnitude). When I have imported a module, then edit it, and import it
again (into the same Python process), the changes don't seem to take
place. What is going on?
A. For efficiency reasons, Python only reads the module file on the
first time a module is imported (otherwise a program consisting of
many modules, each of which imports the same basic module, would read
the basic module over and over again). To force a changed module
being read again, do this:
import modname
reload(modname)
Warning: this technique is not 100% fool-proof. In particular,
modules containing statements like
from modname import some_objects
will continue to work with the old version of the objects imported
thus. I have a module in which I want to execute some extra code when it
is run as a script. How do I find out whether I am running as a
script?
A. A module can find out its own module name by alooking at the
(predefined) global variable __name__. If this has the value
'__main__' you are running as a script. E.g. if you put the following
on the last line of your module, main() is called only when your
module is running as a script:
if __name__ == '__main__': main()
Extending Python
Can I create my own functions in C?
A. Yes, you can create built-in modules containing functions,
variables, exceptions and even new types in C. This is explained in
the document "Extending and Embedding the Python Interpreter" (the
LaTeX file Doc/ext.tex). Also read the chapter on dynamic loading. Can I create my own functions in C++?
A. Yes, using the C-compatibility features found in C++. Basically
you place extern "C" { ... } around the Python include files and put
extern "C" before each function that is going to be called by the
Python interpreter. Global or static C++ objects with constructors
are probably not a good idea. Python's design
Why isn't there a generic copying operation for objects in
Python?
A. Hmm. Maybe there should be one, but it's difficult to assign a
useful meaning to copying of open files, sockets and windows, or
recursive data structures. As long as you design all your classes
yourself you are of course free to define a standard base class that
defines an overridable copying operation for all the objects you care
about. (One practical point: it would have to be a built-in function,
not a standard method name, since not all built-in object types have
methods; e.g. strings, integers and tuples don't.) Why isn't there a generic way to implement persistent objects
in Python? (Persistent == automatically saved to and restored from
disk.)
A. Hmm, hmm. Basically for the same reasons as why there is no
generic copying operation. Why isn't there a switch or case statement in Python?
A. You can do this easily enough with a sequence of
if... elif... elif... else. There have been some proposals for switch
statement syntax, but there is no concensus (yet) on whether and how
to do range tests. Using Python on non-UNIX platforms
Is there a Mac version of Python?
A. Yes. It is on most ftp sites carrying Python as python.sea.hqx --
this is a self-extracting archive containing the application binary as
well as the Lib modules. Is there a DOS version of Python?
A. Yes. More than one, actually: 16python.exe runs in standard DOS
mode on 186 CPUs or higher; 32python.exe uses a DOS extender and only
runs on a 386 or higher CPUs. Although 16python.exe does not pass the
test set because test_grammar is too big for the parser, it actually
has about 270 kbyte of allocatable heap space, which is sufficient for
fairly large programs. 32python.exe is distributed as a tar file
containing the required DOS extended and 387 emulator. Both are on
most ftp sites carrying Python. Is there a Windows version of Python?
A. Yes. Use qwpython.exe. The only problem with it: ^C
unconditionally kills the entire program -- it does not raise
KeyboardInterrupt. You can also run 16python.exe or 32python.exe in a
"DOS box", but qwpython.exe appears to be slightly faster. Is there a Windows NT version of Python?
A. Yes. Use ntpython.exe. This is for Intel CPUs. If you want a
Windows user interface, use qwpython.exe. I have the DOS or Windows version but it appears to be only a
binary. Where's the library?
A. You still need to copy the files from the distribution directory
"python/Lib" to your system. If you don't have the full distribution,
you can get the file pythonlib1.0.2.tar.gz from most ftp sites carrying
Python; this is a subset of the distribution containing just those
file.
>>> import sys
>>> sys.path.insert(0, 'C:\\misc\\python\\lib')
>>>
For a more permanent effect, set the environment variable PYTHONPATH,
as follows (talking to a DOS prompt):
C> SET PYTHONPATH=C:\misc\python\lib
Where's the documentation for the Mac or PC version?
A. There isn't any. The documentation for the Unix version also
applies to the Mac and PC versions. Where applicable, differences
are indicated in the text. The Mac (PC) version doesn't seem to have any facilities for
creating or editing programs apart from entering it interactively, and
there seems to be no way to save code that was entered interactively.
How do I create a Python program on the Mac (PC)?
A. Use an external editor. On the Mac, I am quite happy with the Desk
Accessory called Sigma Edit; this doesn't require Multifinder or
System 7. I work like this: start the interpreter; edit a module file
using Sigma Edit; import and test it in the interpreter; edit again in
Sigma Edit; then use the built-in function reload() to re-read the
imported module; etc.
While anyone with a pulse could certainly figure out how to do
the same on MS-Windows, I would recommend the NotGNU Emacs clone for
MS-Windows. Not only can you easily resave and "reload()" from Python after
making changes, but since WinNot auto-copies to the clipboard any text you
select, you can simply select the entire procedure (function) which you
changed in WinNot, switch to QWPython, and shift-ins to reenter the changed
program unit.