Because of these limitations, it is probably best to view icon clicks as a way to launch

programs after they have been debugged or have been instrumented to write their output
to a file. Especially when starting out, use other techniquessuch as system
command lines and IDLE (discussed further in the section The IDLE User Interface
on page 58)so that you can see generated error messages and view your
normal output without resorting to coding tricks. When we discuss exceptions later in
this book, youll also learn that it is possible to intercept and recover from errors so
that they do not terminate your programs. Watch for the discussion of the try statement
later in this book for an alternative way to keep the console window from closing on
errors.

Module Imports and Reloads

So far, Ive been talking about importing modules without really explaining what this
term means. Well study modules and larger program architecture in depth in Part V,
but because imports are also a way to launch programs, this section will introduce
enough module basics to get you started.
In simple terms, every file of Python source code whose name ends in a .py extension
is a module. Other files can access the items a module defines by importing that module;
import operations essentially load another file and grant access to that files contents.
The contents of a module are made available to the outside world through its attributes
(a term Ill define in the next section).
This module-based services model turns out to be the core idea behind program architecture
in Python. Larger programs usually take the form of multiple module files,
which import tools from other module files. One of the modules is designated as the
main or top-level file, and this is the one launched to start the entire program.
Well delve into such architectural issues in more detail later in this book. This chapter
is mostly interested in the fact that import operations run the code in a file that is being
loaded as a final step. Because of this, importing a file is yet another way to launch it.
For instance, if you start an interactive session (from a system command line, from the
Start menu, from IDLE, or otherwise), you can run the script1.py file you created earlier
with a simple import (be sure to delete the input line you added in the prior section
first, or youll need to press Enter for no reason):
C:\misc> c:\python30\python
>>> import script1
win32
1267650600228229401496703205376
Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam!

Version skew note: Python 3.0 moved the reload built-in function to the
imp standard library module. It still reloads files as before, but you must
import it in order to use it. In 3.0, run an import imp and use
imp.reload(M), or run a from imp import reload and use reload(M), as
shown here. Well discuss import and from statements in the next section,
and more formally later in this book.
If you are working in Python 2.6 (or 2.X in general), reload is available
as a built-in function, so no import is required. In Python 2.6, reload is
available in both formsbuilt-in and module functionto aid the transition
to 3.0. In other words, reloading is still available in 3.0, but an
extra line of code is required to fetch the reload call.
The move in 3.0 was likely motivated in part by some well-known issues
involving reload and from statements that well encounter in the next
section. In short, names loaded with a from are not directly updated by
a reload, but names accessed with an import statement are. If your
names dont seem to change after a reload, try using import and
module.attribute name references instead.

The Grander Module Story: Attributes

Imports and reloads provide a natural program launch option because import operations
execute files as a last step. In the broader scheme of things, though, modules serve

the role of libraries of tools, as youll learn in Part V. More generally, a module is mostly
just a package of variable names, known as a namespace. The names within that package
are called attributesan attribute is simply a variable name that is attached to a specific
object (like a module).
In typical use, importers gain access to all the names assigned at the top level of a
modules file. These names are usually assigned to tools exported by the module
functions, classes, variables, and so onthat are intended to be used in other files and
other programs. Externally, a module files names can be fetched with two Python
statements, import and from, as well as the reload call.
To illustrate, use a text editor to create a one-line Python module file called myfile.py
with the following contents:
title = "The Meaning of Life"

This may be one of the worlds simplest Python modules (it contains a single assignment
statement), but its enough to illustrate the point. When this file is imported, its code
is run to generate the modules attribute. The assignment statement creates a module
attribute named title.
By contrast, the basic import statement runs the file only once per process, and it makes
the file a separate module namespace so that its assignments will not change variables
in your scope. The price you pay for the namespace partitioning of modules is the need
to reload after changes.
Version skew note: Python 2.6 also includes an execfile('module.py')
built-in function, in addition to allowing the form
exec(open('module.py')), which both automatically read the files
content. Both of these are equivalent to the
exec(open('module.py').read()) form, which is more complex but
runs in both 2.6 and 3.0.
Unfortunately, neither of these two simpler 2.6 forms is available in 3.0,
which means you must understand both files and their read methods to
fully understand this technique today (alas, this seems to be a case of
aesthetics trouncing practicality in 3.0). In fact, the exec form in 3.0
involves so much typing that the best advice may simply be not to do
itits usually best to launch files by typing system shell command lines
or by using the IDLE menu options described in the next section. For
more on the 3.0 exec form, see Chapter 9.

The IDLE User Interface

So far, weve seen how to run Python code with the interactive prompt, system command
lines, icon clicks, and module imports and exec calls. If youre looking for something
a bit more visual, IDLE provides a graphical user interface for doing Python
development, and its a standard and free part of the Python system. It is usually referred
to as an integrated development environment (IDE), because it binds together various
development tasks into a single view.
In short, IDLE is a GUI that lets you edit, run, browse, and debug Python programs,
all from a single interface. Moreover, because IDLE is a Python program that uses the
tkinter GUI toolkit (known as Tkinter in 2.6), it runs portably on most Python platforms,
including Microsoft Windows, X Windows (for Linux, Unix, and Unix-like
platforms), and the Mac OS (both Classic and OS X). For many, IDLE represents an
easy-to-use alternative to typing command lines, and a less problem-prone alternative
to clicking on icons.

IDLE Basics
Lets jump right into an example. IDLE is easy to start under Windowsit has an entry
in the Start button menu for Python (see Figure 2-1, shown previously), and it can also
be selected by right-clicking on a Python program icon. On some Unix-like systems,

Other IDEs
Because IDLE is free, portable, and a standard part of Python, its a nice first development

tool to become familiar with if you want to use an IDE at all. Again, I recommend
that you use IDLE for this books exercises if youre just starting out, unless you are
already familiar with and prefer a command-line-based development mode. There are,
however, a handful of alternative IDEs for Python developers, some of which are substantially
more powerful and robust than IDLE. Here are some of the most commonly
used IDEs:
Eclipse and PyDev
Eclipse is an advanced open source IDE GUI. Originally developed as a Java IDE,
Eclipse also supports Python development when you install the PyDev (or a similar)
plug-in. Eclipse is a popular and powerful option for Python development, and it
goes well beyond IDLEs feature set. It includes support for code completion, syntax
highlighting, syntax analysis, refactoring, debugging, and more. Its downsides
are that it is a large system to install and may require shareware extensions for some
features (this may vary over time). Still, when you are ready to graduate from IDLE,
the Eclipse/PyDev combination is worth your attention.
Komodo
A full-featured development environment GUI for Python (and other languages),
Komodo includes standard syntax-coloring, text-editing, debugging, and other
features. In addition, Komodo offers many advanced features that IDLE does not,
including project files, source-control integration, regular-expression debugging,
and a drag-and-drop GUI builder that generates Python/tkinter code to implement
the GUIs you design interactively. At this writing, Komodo is not free; it is available
at http://www.activestate.com.
NetBeans IDE for Python
NetBeans is a powerful open-source development environment GUI with support
for many advanced features for Python developers: code completion, automatic
indentation and code colorization, editor hints, code folding, refactoring, debugging,
code coverage and testing, projects, and more. It may be used to develop both
CPython and Jython code. Like Eclipse, NetBeans requires installation steps beyond
those of the included IDLE GUI, but it is seen by many as more than worth
the effort. Search the Web for the latest information and links.
PythonWin
PythonWin is a free Windows-only IDE for Python that ships as part of ActiveStates ActivePython distribution (and may also be fetched separately from http://
www.python.org resources). It is roughly like IDLE, with a handful of useful
Windows-specific extensions added; for example, PythonWin has support for