Warning: IPython relies on the existence of a global variable called __IP which controls the shell itself. If you redefine __IP to anything, bizarre behavior will quickly occur.
Other than the above warning, IPython is meant to work as a drop-in replacement for the standard interactive interpreter. As such, any code which is valid python should execute normally under IPython (cases where this is not true should be reported as bugs). It does, however, offer many features which are not available at a standard python prompt. What follows is a list of these.
IPython will treat any line whose first character is a @ as a special call to a 'magic' function. These allow you to control the behavior of IPython itself, plus a lot of system-type features. They are all prefixed with a @ character, but parameters are given without parentheses or quotes.
Example: typing '@cd mydir' (without the quotes) changes you working directory to 'mydir', if it exists.
If you have 'automagic' enabled (in your ipythonrc file, via the command line option -automagic or with the @automagic function), you don't need to type in the @ explicitly. IPython will scan its internal list of magic functions and call one if it exists. With automagic on you can then just type 'cd mydir' to go to directory 'mydir'. The automagic system has the lowest possible precedence in name searches, so defining an identifier with the same name as an existing magic function will shadow it for automagic use. You can still access the shadowed magic function by explicitly using the @ character at the beginning of the line.
An example (with automagic on) should clarify all this:
In [1]: cd ipython # @cd is called by automagic
/usr/local/home/fperez/ipython
In [2]: cd=1 # now cd is just a variable
In [3]: cd .. # and doesn't work as a function anymore
------------------------------
File "<console>", line 1
cd ..
SyntaxError: invalid syntax
In [4]: @cd .. # but @cd always works
/usr/local/home/fperez
In [5]: del cd # if you remove the cd variable
In [6]: cd ipython # automagic can work again
/usr/local/home/fperez/ipython
You can define your own magic functions to extend the system. The following is a snippet of code which shows how to do it. It is provided as file example-magic.py in the examples directory:
"""Example of how to define a magic function for extending IPython.
The name of the function *must* begin with magic_. IPython mangles it so
that magic_foo() becomes available as @foo.
The argument list must be *exactly* (self,parameter_s='').
The single string parameter_s will have the user's input. It is the magic
function's responsability to parse this string.
That is, if the user types
>>>@foo a b c
The followinng internal call is generated:
self.magic_foo(parameter_s='a b c').
To have any functions defined here available as magic functions in your
IPython environment, import this file in your configuration file with an
execfile = this_file.py statement. See the details at the end of the sample
ipythonrc file. """
# fisrt define a function with the proper form:
def magic_foo(self,parameter_s=''):
"""My very own magic!. (Use docstrings, IPython reads them)."""
print 'Magic function. Passed parameter is between < >: <'+parameter_s+'>'
print 'The self object is:',self
# Add the new magic function to the class dict:
from IPython.iplib import InteractiveShell
InteractiveShell.magic_foo = magic_foo
# And remove the global name to keep global namespace clean. Don't worry, the
# copy bound to IPython stays, we're just removing the global name.
del magic_foo
#********************** End of file <example-magic.py> ***********************
You can also define your own aliased names for magic functions. In your ipythonrc file, placing a line like:
execute __IP.magic_cl = __IP.magic_clear
will define @cl as a new name for @clear.
Type @magic for more information, including a list of all available magic functions at any time and their docstrings. You can also type @magic_function_name? (see sec. 6.3 for information on the '?' system) to get information about any particular magic function you are interested in.
The rest of this section is automatically generated for each release from the docstrings in the IPython code. Therefore the formatting is somewhat minimal, but this method has the advantage of having information always in sync with the code.
A list of all the magic commands available in IPython's default installation follows. This is similar to what you'll see by simply typing @magic at the prompt, but that will also give you information about magic commands you may have added as part of your personal customizations.
@Exit: Exit IPython without confirmation.
@Pprint: Toggle pretty printing on/off.
@Quit: Exit IPython without confirmation (like @Exit).
@alias: Define an alias for a system command.
'@alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
Then, typing '@alias_name params' will execute the system command 'cmd params' (from your underlying operating system).
You can also define aliases with parameters using %s specifiers (one per parameter):
In [1]: alias parts echo first %s second %s
In [2]: @parts A B
first A second B
In [3]: @parts A
Incorrect number of arguments: 2 expected.
parts is an alias to: 'echo first %s second %s'
If called with no parameters, @alias prints the current alias table.
@autocall: Make functions callable without having to type parentheses.
This toggles the autocall command line option on and off.
@autoindent: Toggle autoindent on/off (if available).
@automagic: Make magic functions callable without having to type the initial @.
Toggles on/off (when off, you must call it as @automagic, of course). Note that magic functions have lowest priority, so if there's a variable whose name collides with that of a magic fn, automagic won't work for that function (you get the variable instead). However, if you delete the variable (del var), the previously shadowed magic function becomes visible to automagic again.
@cat: Alias to the system command 'cat'
@cd: Change the current working directory.
This command automatically maintains an internal list of directories you visit during your IPython session, in the variable _dh. The command @dhist shows this history nicely formatted.
cd -<n> changes to the n-th directory in the directory history.
cd - changes to the last visited directory.
Note that !cd doesn't work for this purpose because the shell where !command runs is immediately discarded after executing 'command'.
@clear: Alias to the system command 'clear'
@color_info: Toggle color_info.
The color_info configuration parameter controls whether colors are used for displaying object details (by things like @psource, @pfile or the '?' system). This function toggles this value with each call.
Note that unless you have a fairly recent pager (less works better than more) in your system, using colored object information displays will not work properly. Test it and see.
@colors: Switch color scheme for the prompts and exception handlers.
Currently implemented schemes: NoColor, Linux, LightBG.
Color scheme names are not case-sensitive.
@config: Show IPython's internal configuration.
@dhist: Print your history of visited directories.
@dhist -> print full history
@dhist n -> print last n entries only
@dhist n1 n2 -> print entries between n1 and n2 (n1 not included)
This history is automatically maintained by the @cd command, and always available as the global list variable _dh. You can use @cd -<n> to go to directory number <n>.
@dirs: Return the current directory stack.
@ed: Alias to @edit.
@edit: Bring up an editor and execute the resulting code.
Usage: @edit [options] [args]
@edit will use the editor you have configured in your environment as the EDITOR variable. If this isn't found, it will default to vi under Linux/Unix and to notepad under Windows.
You can also set the value of this editor via the commmand-line option '-editor' or in your ipythonrc file. This is useful if you wish to use specifically for IPython an editor different from your typical default (and for Windows users who typically don't set environment variables).
This command allows you to conveniently edit multi-line code right in your IPython session.
If called without arguments, @edit opens up an empty editor with a temporary file and will execute the contents of this file when you close it (don't forget to save it!).
Options:
-p: this will call the editor with the same data as the previous time it was used, regardless of how long ago (in your current session) it was.
-x: do not execute the edited code immediately upon exit. This is mainly useful if you are editing programs which need to be called with command line arguments, which you can then do using @run.
Arguments:
If arguments are given, the following possibilites exist:
- The arguments are numbers or pairs of colon-separated numbers (like 1 4:8 9). These are interpreted as lines of previous input to be loaded into the editor. The syntax is the same of the @macro command.
- If the argument doesn't start with a number, it is evaluated as a variable and its contents loaded into the editor. You can thus edit any string which contains python code (including the result of previous edits).
- If the argument is the name of an object (other than a string), IPython will try to locate the file where it was defined and open the editor at the point where it is defined. You can use `@edit function` to load an editor exactly at the point where 'function' is defined, edit it and have the file be executed automatically.
Note: opening at an exact line is only supported under Unix, and some editors (like kedit and gedit) do not understand the '+NUMBER' parameter necessary for this feature. Good editors like (X)Emacs, vi, jed, pico and joe all do.
- If the argument is not found as a variable, IPython will look for a file with that name (adding .py if necessary) and load it into the editor. It will execute its contents with execfile() when you exit, loading any code in the file into your interactive namespace.
After executing your code, @edit will return as output the code you typed in the editor (except when it was an existing file). This way you can reload the code in further invocations of @edit as a variable, via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of the output.
Note that @edit is also available through the alias @ed.
This is an example of creating a simple function inside the editor and then modifying it. First, start up the editor:
In [1]: ed
Editing... done. Executing edited code...
Out[1]: 'def foo():
print "foo() was defined in an editing session"
'
We can then call the function foo(): In [2]: foo() foo() was defined in an editing session
Now we edit foo. IPython automatically loads the editor with the (temporary) file where foo() was previously defined. In [3]: ed foo Editing... done. Executing edited code...
And if we call foo() again we get the modified version: In [4]: foo() foo() has now been changed!
Here is an example of how to edit a code snippet successive times. First we call the editor:
In [8]: ed
Editing... done. Executing edited code...
hello
Out[8]: "print 'hello'"
Now we call it again with the previous output (stored in _):
In [9]: ed _
Editing... done. Executing edited code...
hello world
Out[9]: "print 'hello world'"
Now we call it with the output #8 (stored in _8, also as Out[8]):
In [10]: ed _8
Editing... done. Executing edited code...
hello again
Out[10]: "print 'hello again'"
@env: List environment variables.
@hist: Print input history (_i<n> variables), with most recent last.
@hist [-n] -> print at most 40 inputs (some may be multi-line)
@hist [-n] n -> print at most n inputs
@hist [-n] n1 n2 -> print inputs between n1 and n2 (n2 not included)
Each input's number <n> is shown, and is accessible as the automatically generated variable _i<n>. Multi-line statements are printed starting at a new line for easy copy/paste.
If option -n is used, input numbers are not printed. This is useful if you want to get a printout of many lines which can be directly pasted into a text editor.
This feature is only available if numbered prompts are in use.
@lc: Alias to the system command 'ls -F -o -color'
@ld: List (in color) things which are directories or links to directories.
@less: Alias to the system command 'less'
@lf: List (in color) things which are normal files.
@ll: List (in color) things which are symbolic links.
@logoff: Temporarily stop logging.
You must have previously started logging.
@logon: Restart logging.
This function is for restarting logging which you've temporarily stopped with @logoff. For starting logging for the first time, you must use the @logstart function, which allows you to specify an optional log filename.
@logstart: Start logging anywhere in a session.
@logstart [log_name [log_mode]]
If no name is given, it defaults to a file named 'ipython.log' in your current directory, in 'rotate' mode (see below).
'@logstart name' saves to file 'name' in 'backup' mode. It saves your history up to that point and then continues logging.
@logstart takes a second optional parameter: logging mode. This can be one
of (note that the modes are given unquoted):
over: overwrite existing log.
backup: rename (if exists) to name and start name.
append: well, that says it.
rotate: create rotating logs name.1 , name.2 , etc.
@logstate: Print the status of the logging system.
@ls: Alias to the system command 'ls -F'
@lsmagic: List currently available magic functions.
@lx: List (in color) things which are executable.
@macro: Define a set of input lines as a macro for future re-execution.
Usage:
@macro name n1:n2 n3:n4 ... n5 .. n6 ...
This will define a global variable called `name` which is a string made of joining the slices and lines you specify (n1,n2,... numbers above) from your input history into a single string. This variable acts like an automatic function which re-executes those lines as if you had typed them. You just type 'name' at the prompt and the code executes.
Note that the slices use the standard Python slicing notation (5:8 means include lines numbered 5,6,7).
For example, if your history contains (@hist prints it):
44: x=1
45: y=3
46: z=x+y
47: print x
48: a=5
49: print 'x',x,'y',y
you can create a macro with lines 44 through 47 (included) and line 49 called my_macro with:
In [51]: @macro my_macro 44:48 49
Now, typing `my_macro` (without quotes) will re-execute all this code in one pass.
You don't need to give the line-numbers in order, and any given line number can appear multiple times. You can assemble macros with any lines from your input history in any order.
The macro is a simple object which holds its value in an attribute, but IPython's display system checks for macros and executes them as code instead of printing them when you type their name.
You can view a macro's contents by explicitly printing it with:
'print macro_name'.
For one-off cases which DON'T contain magic function calls in them you can obtain similar results by explicitly executing slices from your input history with:
In [60]: exec In[44:48]+In[49]
@magic: Print information about the magic function system.
@mkdir: Alias to the system command 'mkdir'
@mv: Alias to the system command 'mv'
@p: Just a short alias for Python's 'print'.
@page: Pretty print the object and display it through a pager.
If no parameter is given, use _ (last output).
@pdb: Control the calling of the pdb interactive debugger.
Call as '@pdb on', '@pdb 1', '@pdb off' or '@pdb 0'. If called without argument it works as a toggle.
When an exception is triggered, IPython can optionally call the interactive pdb debugger after the traceback printout. @pdb toggles this feature on and off.
@pdef: Print the definition header for any callable object.
If the object is a class, print the constructor information.
@pdoc: Print the docstring for an object.
If the given object is a class, it will print both the class and the constructor docstrings.
@pfile: Print (or run through pager) the file where an object is defined.
The file opens at the line where the object definition begins. IPython will honor the environment variable PAGER if set, and otherwise will do its best to print the file in a convenient form.
If the given argument is not an object currently defined, IPython will try to interpret it as a filename (automatically adding a .py extension if needed). You can thus use @pfile as a syntax highlighting code viewer.
@pinfo: Provide detailed information about an object.
'@pinfo object' is just a synonym for object? or ?object.
@popd: Change to directory popped off the top of the stack.
@profile: Print your currently active IPyhton profile.
@prun: Run a statement through the python code profiler.
Usage:
@prun [options] statement
The given statement (which doesn't require quote marks) is run via the python profiler in a manner similar to the profile.run() function. Namespaces are internally managed to work correctly; profile.run cannot be used in IPython because it makes certain assumptions about namespaces which do not hold under IPython.
Options:
-l <limit>: you can place restrictions on what or how much of the profile gets printed. The limit value can be:
* A string: only information for function names containing this string is printed.
* An integer: only these many lines are printed.
* A float (between 0 and 1): this fraction of the report is printed (for example, use a limit of 0.4 to see the topmost 40% only).
You can combine several limits with repeated use of the option. For example, '-l __init__ -l 5' will print only the topmost 5 lines of information about class constructors.
-r: return the pstats.Stats object generated by the profiling. This object has all the information about the profile in it, and you can later use it for further analysis or in other functions.
Since magic functions have a particular form of calling which prevents
you from writing something like:
In [1]: p = @prun -r print 4 # invalid!
you must instead use IPython's automatic variables to assign this:
In [1]: @prun -r print 4
Out[1]: <pstats.Stats instance at 0x8222cec>
In [2]: stats = _
If you really need to assign this value via an explicit function call,
you can always tap directly into the true name of the magic function
with:
In [3]: stats = __IP.magic_prun('-r print 4')
-s <key>: sort profile by given key. You can provide more than one key by using the option several times: '-s key1 -s key2 -s key3...'. The default sorting key is 'stdname'.
The following is copied verbatim from the profile documentation referenced below:
When more than one key is provided, additional keys are used as secondary criteria when the there is equality in all keys selected before them.
Abbreviations can be used for any key names, as long as the abbreviation is unambiguous. The following are the keys currently defined:
Valid Arg Meaning
"calls" call count
"cumulative" cumulative time
"file" file name
"module" file name
"pcalls" primitive call count
"line" line number
"name" function name
"nfl" name/file/line
"stdname" standard name
"time" internal time
Note that all sorts on statistics are in descending order (placing most time consuming items first), where as name, file, and line number searches are in ascending order (i.e., alphabetical). The subtle distinction between "nfl" and "stdname" is that the standard name is a sort of the name as printed, which means that the embedded line numbers get compared in an odd way. For example, lines 3, 20, and 40 would (if the file names were the same) appear in the string order "20" "3" and "40". In contrast, "nfl" does a numeric compare of the line numbers. In fact, sort_stats("nfl") is the same as sort_stats("name", "file", "line").
-t <filename>: save profile results as shown on screen to a text file. The profile is still shown on screen.
-d <filename>: save (via dump_stats) profile statistics to given filename. This data is in a format understod by the pstats module, and is generated by a call to the dump_stats() method of profile objects. The profile is still shown on screen.
If you want to run complete programs under the profiler's control, use '@run -p [opts] filename.py [args to program]' and then any profile specific options as described here.
You can read the complete documentation for the profile module with: In [1]: import profile; profile.help()
@psource: Print (or run through pager) the source code for an object.
@pushd: Place the current dir on stack and change directory.
Usage:
@pushd ['dirname']
@pushd with no arguments does a @pushd to your home directory.
@pwd: Return the current working directory path.
@r: Repeat previous input.
If given an argument, repeats the previous command which starts with the same string, otherwise it just repeats the previous input.
Shell escaped commands (with ! as first character) are not recognized by this system, only pure python code and magic commands.
@reset: Resets the namespace by removing all names defined by the user.
Input/Output history are left around in case you need them.
@rm: Alias to the system command 'rm -i'
@rmdir: Alias to the system command 'rmdir'
@rmf: Alias to the system command 'rm -f'
@run: Run the named file inside IPython as a program.
Usage:
@run [-n -i -p [profile options]] file [args]
Parameters after the filename are passed as command-line arguments to the program (put in sys.argv). Then, control returns to IPython's prompt.
This is similar to running at a system prompt:
$ python file args
but has the advantage of giving you IPython's tracebacks, and of
loading all variables into your interactive namespace for further use
(unless -p is used, see below).
The file is executed in a namespace initially consisting only of __name__=='__main__' and sys.argv constructed as indicated. It thus sees its environment as if it were being run as a stand-alone program. But after execution, the IPython interactive namespace gets updated with all variables defined in the program (except for __name__ and sys.argv). This allows for very convenient loading of code for interactive work, while giving each program a 'clean sheet' to run in.
Options:
-n: __name__ is NOT set to '__main__', but to the running file's name without extension (as python does under import). This allows running scripts and reloading the definitions in them without calling code protected by an ' if __name__ == "__main__" ' clause.
-i: run the file in IPython's namespace instead of an empty one. This is useful if you are experimenting with code written in a text editor which depends on variables defined interactively.
-p: run program under the control of the Python profiler module (which prints a detailed report of execution times, function calls, etc).
You can pass other options after -p which affect the behavior of the profiler itself. See the docs for @prun for details.
In this mode, the program's variables do NOT propagate back to the IPython interactive namespace (because they remain in the namespace where the profiler executes them).
Internally this triggers a call to @prun, see its documentation for details on the options available specifically for profiling.
@runlog: Run files as logs.
Usage:
@runlog file1 file2 ...
Run the named files (treating them as log files) in sequence inside the interpreter, and return to the prompt. This is much slower than @run because each line is executed in a try/except block, but it allows running files with syntax errors in them.
Normally IPython will guess when a file is one of its own logfiles, so you can typically use @run even for logs. This shorthand allows you to force any file to be treated as a log file.
@save: Save a set of lines to a given filename.
Usage:
@save filename n1:n2 n3:n4 ... n5 .. n6 ...
This function uses the same syntax as @macro for line extraction, but instead of creating a macro it saves the resulting string to the filename you specify.
It adds a '.py' extension to the file if you don't do so yourself, and it asks for confirmation before overwriting existing files.
@who: Print all interactive variables, with some minimal formatting.
This excludes executed names loaded through your configuration file and things which are internal to IPython.
This is deliberate, as typically you may load many modules and the purpose of @who is to show you only what you've manually defined.
@who_ls: Return a list of all interactive variables.
@whos: Like @who, but gives some extra information about each variable.
For all variables, the type is printed. Additionally it prints:
- For ,[],(): their length.
- Everything else: a string representation, snipping their middle if
too long.
@xmode: Switch modes for the exception handlers.
Valid modes: Plain, Context and Verbose.
If called without arguments, acts as a toggle.
As of Python 2.1, a help system is available with access to object docstrings and the Python manuals. Simply type 'help' (no quotes) to access it. You can also type help(object) to obtain information about a given object, and help('keyword') for information on a keyword. As noted in sec. 3.1, you need to properly configure your environment variable PYTHONDOCS for this feature to work correctly.
Typing ?word or word? prints detailed information about an object. If certain strings in the object are too long (docstrings, code, etc.) they get snipped in the center for brevity. This system gives access variable types and values, full source code for any object (if available), function prototypes and other useful information.
Typing ??word or word?? gives access to the full information without snipping long strings. Long strings are sent to the screen through the less pager if longer than the screen and printed otherwise. On systems lacking the less command, IPython uses a very basic internal pager.
The following magic functions are particularly useful for gathering information about your working environment. You can get more details by typing @magic or querying them individually (use @function_name? with or without the @), this is just a summary:
These features require the GNU readline library, so they won't work if your Python lacks readline support (as is the case under Windows). We will first describe the default behavior IPython uses, and then how to change it to suit your preferences.
At any time, hitting TAB will complete any available python commands or variable names, and show you a list of the possible completions if there's no unambiguous one. It will also complete filenames in the current directory if no python names match what you've typed so far.
IPython provides two ways for searching through previous input and thus reduce the need for repetitive typing:
IPython will save your input history when it leaves and reload it next time you restart it.
IPython can recognize lines ending in ':' and indent the next line, while also un-indenting automatically after 'raise' or 'return'.
This feature uses the readline library, so it will honor your /.inputrc configuration (or whatever file your INPUTRC variable points to). Adding the following lines to your .inputrc file can make indenting/unindenting more convenient (M-i indents, M-u unindents):
$if Python
"\M-i": " "
"\M-u": "\d\d\d\d"
$endif
Note that there are 4 spaces between the quote marks after "M-i" above.
The feature is off by default because it can cause problems with pasting of indented code (the pasted code gets re-indented on each line). But a magic function @autoindent allows you to toggle it on/off at runtime. You can also set it permanently on in your ipythonrc file (set autoindent 1), and disable it only when needed via the magic function.
All these features are based on the GNU readline library, which has an extremely customizable interface. Normally, readline is configured via a file which defines the behavior of the library; the details of the syntax for this can be found in the readline documentation available with your system or on the Internet. IPython doesn't read this file (if it exists) directly, but it does support passing to readline valid options via a simple interface. In brief, you can customize readline by setting the following options in your ipythonrc configuration file (note that these options can not be specified at the command line):
You can log all input from a session either by starting IPython with the command line switches -log or -logfile (see sec. 5.1)or by activating the logging at any moment with the magic function @logstart.
Log files can later be reloaded with the -logplay option and IPython will attempt to 'replay' the log by executing all the lines in it, thus restoring the state of a previous session. This feature is not quite perfect, but can still be useful in many cases.
The log files can also be used as a way to have a permanent record of any code you wrote while experimenting. Log files are regular text files which you can later open in your favorite text editor to extract code or to 'clean them up' before using them to replay a session.
The @logstart function for activating logging in mid-session is used as follows:
@logstart [log_name [log_mode]]
If no name is given, it defaults to a file named 'log' in your IPYTHONDIR directory, in 'rotate' mode (see below).
'@logstart name' saves to file 'name' in 'backup' mode. It saves your history up to that point and then continues logging.
@logstart takes a second optional parameter: logging mode. This can be one of (note that the modes are given unquoted):
Any input line beginning with a ! character is passed verbatim (minus the !, of course) to the underlying operating system. For example, typing !ls will run 'ls' in the current directory.
The @alias magic function and the alias option in the ipythonrc configuration file allow you to define magic functions which are in fact system shell commands. These aliases can have parameters.
'@alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
Then, typing '@alias_name params' will execute the system command 'cmd params' (from your underlying operating system).
You can also define aliases with parameters using %s specifiers (one per parameter). The following example defines the @parts function as an alias to the command 'echo first %s second %s' where each %s will be replaced by a positional parameter to the call to @parts:
In [1]: alias parts echo first %s second %s
In [2]: @parts A B
first A second B
In [3]: @parts A
Incorrect number of arguments: 2 expected.
parts is an alias to: 'echo first %s second %s'
If called with no parameters, @alias prints the table of currently defined aliases.
The @dreload command does a recursive reload of a module: changes made to the module since you imported will actually be available without having to exit.
IPython provides the option to see very detailed exception tracebacks, which can be especially useful when debugging large programs. You can run any Python file with the @run function to benefit from these detailed tracebacks. Furthermore, both normal and verbose tracebacks can be colored (if your terminal supports it) which makes them much easier to parse visually.
See the magic xmode and colors functions for details (just type @magic).
These features are basically a terminal version of Ka-Ping Yee's cgitb module, now part of the standard Python library.
IPython offers numbered prompts (In/Out) with input and output caching. All input is saved and can be retrieved as variables (besides the usual arrow key recall).
The following GLOBAL variables always exist (so don't overwrite them!): _i: stores previous input. _ii: next previous. _iii: next-next previous. _ih : a list of all input _ih[n] is the input from line n and this list is aliased to the global variable In. If you overwrite In with a variable of your own, you can remake the assignment to the internal list with a simple 'In=_ih'.
Additionally, global variables named _i<n> are dynamically created (<n>
being the prompt counter), such that
_i<n> == _ih[<n>] == In[<n>].
For example, what you typed at prompt 14 is available as _i14, _ih[14] and In[14].
This allows you to easily cut and paste multi line interactive prompts by printing them out: they print like a clean string, without prompt characters. You can also manipulate them like regular variables (they are strings), modify or exec them (typing 'exec _i9' will re-execute the contents of input prompt 9, 'exec In[9:14]+In[18]' will re-execute lines 9 through 13 and line 18).
You can also re-execute multiple lines of input easily by using the magic @macro function (which automates the process and allows re-execution without having to type 'exec' every time). The macro system also allows you to re-execute previous lines which include magic function calls (which require special processing). Type @macro? or see sec. 6.1 for more details on the macro system.
A history function @hist allows you to see any part of your input history by printing a range of the _i variables.
For output that is returned from actions, a system similar to the input cache exists but using _ instead of _i. Only actions that produce a result (NOT assignments, for example) are cached. If you are familiar with Mathematica, IPython's _ variables behave exactly like Mathematica's % variables.
The following GLOBAL variables always exist (so don't overwrite them!):
These global variables are all stored in a global dictionary (not a list, since it only has entries for lines which returned a result) available under the names _oh and Out (similar to _ih and In). So the output from line 12 can be obtained as _12, Out[12] or _oh[12]. If you accidentally overwrite the Out variable you can recover it by typing 'Out=_oh' at the prompt.
This system obviously can potentially put heavy memory demands on your system, since it prevents Python's garbage collector from removing any previously computed results. You can control how many results are kept in memory with the option (at the command line or in your ipythonrc file) cache_size. If you set it to 0, the whole system is completely disabled and the prompts revert to the classic '>>>' of normal Python.
Your history of visited directories is kept in the global list _dh, and the magic @cd command can be used to go to any entry in that list. The @dhist command allows you to view this history.
These features were adapted from Nathan Gray's LazyPython. They are meant to allow less typing for common situations.
Callable objects (i.e. functions, methods, etc) can be invoked like this (notice the commas between the arguments):
>>> callable_ob arg1, arg2, arg3
and the input will be translated to this:
-> callable_ob(arg1, arg2, arg3)
You can force automatic parentheses by using '/' as the first character of a line. For example:
>>> /globals # becomes 'globals()'
Note that the '/' MUST be the first character on the line! This won't work:
>>> print /globals # syntax error
In most cases the automatic algorithm should work, so you should rarely need to explicitly invoke /. One notable exception is if you are trying to call a function with a list of tuples as arguments (the parenthesis will confuse IPython):
In [1]: zip (1,2,3),(4,5,6) # won't work
but this will work:
In [2]: /zip (1,2,3),(4,5,6)
---> zip ((1,2,3),(4,5,6))
Out[2]= [(1, 4), (2, 5), (3, 6)]
You can force automatic quoting of a function's arguments by using ',' as the first character of a line. For example:
>>> ,my_function /home/me # becomes my_function("/home/me")
Note that the ',' MUST be the first character on the line! This won't work:
>>> x = ,my_function /home/me # syntax error
1. IPython tells you that it has altered your command line by displaying the new command line preceded by ->. e.g.:
In [18]: callable list
----> callable (list)
2. Whitespace is more important than usual (even for Python!) Arguments to auto-quote functions cannot have embedded whitespace.
In [21]: ,string.split a b
----> string.split ("a", "b")
Out[21]= ['a'] # probably not what you wanted
In [22]: string.split 'a b'
----> string.split ('a b')
Out[22]= ['a', 'b'] # quote explicitly and it works.