10
One of Python's most useful features is its interactive interpreter.
11
This system allows very fast testing of ideas without the overhead of
12
creating test files as is typical in most programming languages.
13
However, the interpreter supplied with the standard Python distribution
14
is somewhat limited for extended interactive use.
16
The goal of IPython is to create a comprehensive environment for
17
interactive and exploratory computing. To support this goal, IPython
18
has two main components:
20
* An enhanced interactive Python shell.
21
* An architecture for interactive parallel computing.
23
All of IPython is open source (released under the revised BSD license).
25
Enhanced interactive Python shell
26
=================================
28
IPython's interactive shell (:command:`ipython`), has the following goals,
31
1. Provide an interactive shell superior to Python's default. IPython
32
has many features for object introspection, system shell access,
33
and its own special command system for adding functionality when
34
working interactively. It tries to be a very efficient environment
35
both for Python code development and for exploration of problems
36
using Python objects (in situations like data analysis).
38
2. Serve as an embeddable, ready to use interpreter for your own
39
programs. IPython can be started with a single call from inside
40
another program, providing access to the current namespace. This
41
can be very useful both for debugging purposes and for situations
42
where a blend of batch-processing and interactive exploration are
43
needed. New in the 0.9 version of IPython is a reusable wxPython
46
3. Offer a flexible framework which can be used as the base
47
environment for other systems with Python as the underlying
48
language. Specifically scientific environments like Mathematica,
49
IDL and Matlab inspired its design, but similar ideas can be
50
useful in many fields.
52
4. Allow interactive testing of threaded graphical toolkits. IPython
53
has support for interactive, non-blocking control of GTK, Qt and
54
WX applications via special threading flags. The normal Python
55
shell can only do this for Tkinter applications.
57
Main features of the interactive shell
58
--------------------------------------
60
* Dynamic object introspection. One can access docstrings, function
61
definition prototypes, source code, source files and other details
62
of any object accessible to the interpreter with a single
63
keystroke (:samp:`?`, and using :samp:`??` provides additional detail).
65
* Searching through modules and namespaces with :samp:`*` wildcards, both
66
when using the :samp:`?` system and via the :samp:`%psearch` command.
68
* Completion in the local namespace, by typing :kbd:`TAB` at the prompt.
69
This works for keywords, modules, methods, variables and files in the
70
current directory. This is supported via the readline library, and
71
full access to configuring readline's behavior is provided.
72
Custom completers can be implemented easily for different purposes
73
(system commands, magic arguments etc.)
75
* Numbered input/output prompts with command history (persistent
76
across sessions and tied to each profile), full searching in this
77
history and caching of all input and output.
79
* User-extensible 'magic' commands. A set of commands prefixed with
80
:samp:`%` is available for controlling IPython itself and provides
81
directory control, namespace information and many aliases to
82
common system shell commands.
84
* Alias facility for defining your own system aliases.
86
* Complete system shell access. Lines starting with :samp:`!` are passed
87
directly to the system shell, and using :samp:`!!` or :samp:`var = !cmd`
88
captures shell output into python variables for further use.
90
* Background execution of Python commands in a separate thread.
91
IPython has an internal job manager called jobs, and a
92
convenience backgrounding magic function called :samp:`%bg`.
94
* The ability to expand python variables when calling the system shell. In a
95
shell command, any python variable prefixed with :samp:`$` is expanded. A
96
double :samp:`$$` allows passing a literal :samp:`$` to the shell (for access
97
to shell and environment variables like :envvar:`PATH`).
99
* Filesystem navigation, via a magic :samp:`%cd` command, along with a
100
persistent bookmark system (using :samp:`%bookmark`) for fast access to
101
frequently visited directories.
103
* A lightweight persistence framework via the :samp:`%store` command, which
104
allows you to save arbitrary Python variables. These get restored
105
automatically when your session restarts.
107
* Automatic indentation (optional) of code as you type (through the
110
* Macro system for quickly re-executing multiple lines of previous
111
input with a single name. Macros can be stored persistently via
112
:samp:`%store` and edited via :samp:`%edit`.
114
* Session logging (you can then later use these logs as code in your
115
programs). Logs can optionally timestamp all input, and also store
116
session output (marked as comments, so the log remains valid
119
* Session restoring: logs can be replayed to restore a previous
120
session to the state where you left it.
122
* Verbose and colored exception traceback printouts. Easier to parse
123
visually, and in verbose mode they produce a lot of useful
124
debugging information (basically a terminal version of the cgitb
127
* Auto-parentheses: callable objects can be executed without
128
parentheses: :samp:`sin 3` is automatically converted to :samp:`sin(3)`.
130
* Auto-quoting: using :samp:`,`, or :samp:`;` as the first character forces
131
auto-quoting of the rest of the line: :samp:`,my_function a b` becomes
132
automatically :samp:`my_function("a","b")`, while :samp:`;my_function a b`
133
becomes :samp:`my_function("a b")`.
135
* Extensible input syntax. You can define filters that pre-process
136
user input to simplify input in special situations. This allows
137
for example pasting multi-line code fragments which start with
138
:samp:`>>>` or :samp:`...` such as those from other python sessions or the
139
standard Python documentation.
141
* Flexible configuration system. It uses a configuration file which
142
allows permanent setting of all command-line options, module
143
loading, code and file execution. The system allows recursive file
144
inclusion, so you can have a base file with defaults and layers
145
which load other customizations for particular projects.
147
* Embeddable. You can call IPython as a python shell inside your own
148
python programs. This can be used both for debugging code or for
149
providing interactive abilities to your programs with knowledge
150
about the local namespaces (very useful in debugging and data
151
analysis situations).
153
* Easy debugger access. You can set IPython to call up an enhanced version of
154
the Python debugger (pdb) every time there is an uncaught exception. This
155
drops you inside the code which triggered the exception with all the data
156
live and it is possible to navigate the stack to rapidly isolate the source
157
of a bug. The :samp:`%run` magic command (with the :samp:`-d` option) can run
158
any script under pdb's control, automatically setting initial breakpoints for
159
you. This version of pdb has IPython-specific improvements, including
160
tab-completion and traceback coloring support. For even easier debugger
161
access, try :samp:`%debug` after seeing an exception. winpdb is also
162
supported, see ipy_winpdb extension.
164
* Profiler support. You can run single statements (similar to
165
:samp:`profile.run()`) or complete programs under the profiler's control.
166
While this is possible with standard cProfile or profile modules,
167
IPython wraps this functionality with magic commands (see :samp:`%prun`
168
and :samp:`%run -p`) convenient for rapid interactive work.
170
* Doctest support. The special :samp:`%doctest_mode` command toggles a mode
171
that allows you to paste existing doctests (with leading :samp:`>>>`
172
prompts and whitespace) and uses doctest-compatible prompts and
173
output, so you can use IPython sessions as doctest code.
175
Interactive parallel computing
176
==============================
178
Increasingly, parallel computer hardware, such as multicore CPUs, clusters and
179
supercomputers, is becoming ubiquitous. Over the last 3 years, we have
180
developed an architecture within IPython that allows such hardware to be used
181
quickly and easily from Python. Moreover, this architecture is designed to
182
support interactive and collaborative parallel computing.
184
The main features of this system are:
186
* Quickly parallelize Python code from an interactive Python/IPython session.
188
* A flexible and dynamic process model that be deployed on anything from
189
multicore workstations to supercomputers.
191
* An architecture that supports many different styles of parallelism, from
192
message passing to task farming. And all of these styles can be handled
195
* Both blocking and fully asynchronous interfaces.
197
* High level APIs that enable many things to be parallelized in a few lines
200
* Write parallel code that will run unchanged on everything from multicore
201
workstations to supercomputers.
203
* Full integration with Message Passing libraries (MPI).
205
* Capabilities based security model with full encryption of network connections.
207
* Share live parallel jobs with other users securely. We call this
208
collaborative parallel computing.
210
* Dynamically load balanced task farming system.
212
* Robust error handling. Python exceptions raised in parallel execution are
213
gathered and presented to the top-level code.
215
For more information, see our :ref:`overview <parallel_index>` of using IPython
216
for parallel computing.
218
Portability and Python requirements
219
-----------------------------------
221
As of the 0.9 release, IPython requires Python 2.4 or greater. We have
222
not begun to test IPython on Python 2.6 or 3.0, but we expect it will
223
work with some minor changes.
225
IPython is known to work on the following operating systems:
228
* Most other Unix-like OSs (AIX, Solaris, BSD, etc.)
230
* Windows (CygWin, XP, Vista, etc.)
232
See :ref:`here <install_index>` for instructions on how to install IPython.
b'\\ No newline at end of file'
added
removed
docs/dist/html/_sources/overview.txt
