Subsections
One of Python's most useful features is its interactive interpreter.
This system allows very fast testing of ideas without the overhead
of creating test files as is typical in most programming languages.
However, the interpreter supplied with the standard Python distribution
is somewhat limited for extended interactive use.
IPython is a free software project (released under the BSD license)
which tries to:
- Provide an interactive shell superior to Python's default. IPython
has many features for object introspection, system shell access, and
its own special command system for adding functionality when working
interactively. It tries to be a very efficient environment both for
Python code development and for exploration of problems using Python
objects (in situations like data analysis).
- Serve as an embeddable, ready to use interpreter for your own programs.
IPython can be started with a single call from inside another program,
providing access to the current namespace. This can be very useful
both for debugging purposes and for situations where a blend of batch-processing
and interactive exploration are needed.
- Offer a flexible framework which can be used as the base environment
for other systems with Python as the underlying language. Specifically
scientific environments like Mathematica, IDL and Matlab inspired
its design, but similar ideas can be useful in many fields.
- Allow interactive testing of threaded graphical toolkits. IPython
has support for interactive, non-blocking control of GTK, Qt and WX
applications via special threading flags. The normal Python shell
can only do this for Tkinter applications.
- Dynamic object introspection. One can access docstrings, function
definition prototypes, source code, source files and other details
of any object accessible to the interpreter with a single keystroke
(`?', and using `??' provides additional detail).
- Searching through modules and namespaces with `*' wildcards,
both when using the `?' system and via the %psearch
command.
- Completion in the local namespace, by typing TAB at the prompt. This
works for keywords, methods, variables and files in the current directory.
This is supported via the readline library, and full access to configuring
readline's behavior is provided.
- Numbered input/output prompts with command history (persistent across
sessions and tied to each profile), full searching in this history
and caching of all input and output.
- User-extensible `magic' commands. A set of commands prefixed with
% is available for controlling IPython itself and provides
directory control, namespace information and many aliases to common
system shell commands.
- Alias facility for defining your own system aliases.
- Complete system shell access. Lines starting with ! are passed directly
to the system shell, and using !! captures shell output into python
variables for further use.
- Background execution of Python commands in a separate thread. IPython
has an internal job manager called jobs, and a conveninence
backgrounding magic function called %bg.
- The ability to expand python variables when calling the system shell.
In a shell command, any python variable prefixed with $
is expanded. A double $$ allows passing a literal $
to the shell (for access to shell and environment variables like $PATH).
- Filesystem navigation, via a magic %cd command, along with
a persistent bookmark system (using %bookmark) for fast
access to frequently visited directories.
- A lightweight persistence framework via the %store command,
which allows you to save arbitrary Python variables. These get restored
automatically when your session restarts.
- Automatic indentation (optional) of code as you type (through the
readline library).
- Macro system for quickly re-executing multiple lines of previous input
with a single name. Macros can be stored persistently via %store
and edited via %edit.
- Session logging (you can then later use these logs as code in your
programs). Logs can optionally timestamp all input, and also store
session output (marked as comments, so the log remains valid Python
source code).
- Session restoring: logs can be replayed to restore a previous session
to the state where you left it.
- Verbose and colored exception traceback printouts. Easier to parse
visually, and in verbose mode they produce a lot of useful debugging
information (basically a terminal version of the cgitb module).
- Auto-parentheses: callable objects can be executed without parentheses:
`sin 3' is automatically converted to `sin(3)'.
- Auto-quoting: using `,' or `;' as the first character
forces auto-quoting of the rest of the line: `,my_function
a b' becomes automatically `my_function("a","b")',
while `;my_function a b' becomes `my_function("a
b")'.
- Extensible input syntax. You can define filters that pre-process user
input to simplify input in special situations. This allows for example
pasting multi-line code fragments which start with `>>>'
or `...' such as those from other python sessions or the
standard Python documentation.
- Flexible configuration system. It uses a configuration file which
allows permanent setting of all command-line options, module loading,
code and file execution. The system allows recursive file inclusion,
so you can have a base file with defaults and layers which load other
customizations for particular projects.
- Embeddable. You can call IPython as a python shell inside your own
python programs. This can be used both for debugging code or for providing
interactive abilities to your programs with knowledge about the local
namespaces (very useful in debugging and data analysis situations).
- Easy debugger access. You can set IPython to call up an enhanced version
of the Python debugger (pdb) every time there is an uncaught
exception. This drops you inside the code which triggered the exception
with all the data live and it is possible to navigate the stack to
rapidly isolate the source of a bug. The %run magic command
-with the -d option- can run any script under pdb's
control, automatically setting initial breakpoints for you. This version
of pdb has IPython-specific improvements, including tab-completion
and traceback coloring support.
- Profiler support. You can run single statements (similar to profile.run())
or complete programs under the profiler's control. While this is possible
with standard cProfile or profile modules, IPython
wraps this functionality with magic commands (see `%prun'
and `%run -p') convenient for rapid interactive work.
Python requirements: IPython requires with Python version
2.3 or newer. If you are still using Python 2.2 and can not upgrade,
the last version of IPython which worked with Python 2.2 was 0.6.15,
so you will have to use that.
IPython is developed under Linux, but it should work in any
reasonable Unix-type system (tested OK under Solaris and the *BSD
family, for which a port exists thanks to Dryice Liu).
Mac OS X: it works, apparently without any problems (thanks
to Jim Boyle at Lawrence Livermore for the information). Thanks to
Andrea Riciputi, Fink support is available.
CygWin: it works mostly OK, though some users have reported
problems with prompt coloring. No satisfactory solution to this has
been found so far, you may want to disable colors permanently in the
ipythonrc configuration file if you experience problems.
If you have proper color support under cygwin, please post to the
IPython mailing list so this issue can be resolved for all users.
Windows: it works well under Windows XP/2k, and I suspect
NT should behave similarly. Section 2.3 describes
installation details for Windows, including some additional tools
needed on this platform.
Windows 9x support is present, and has been reported to work fine
(at least on WinME).
Note, that I have very little access to and experience with Windows
development. However, an excellent group of Win32 users (led by Ville
Vainio), consistently contribute bugfixes and platform-specific enhancements,
so they more than make up for my deficiencies on that front. In fact,
Win32 users report using IPython as a system shell (see Sec. 12
for details), as it offers a level of control and features which the
default cmd.exe doesn't provide.
IPython is generously hosted at http://ipython.scipy.org by
the Enthought, Inc and the SciPy project. This site offers downloads,
subversion access, mailing lists and a bug tracking system. I am very
grateful to Enthought (http://www.enthought.com) and all of
the SciPy team for their contribution.
Fernando Perez
2007-05-09