next up previous
Next: Customization Up: IPython An enhanced Interactive Previous: Command-line use

Subsections

Interactive use

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.


Magic command system

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 your ipython configuration directory, typically $HOME/.ipython/:


"""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. 5.3 for information on the '?' system) to get information about any particular magic function you are interested in.

Magic commands

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.

@Pprint: Toggle pretty printing on/off.

@abort: Raise a SystemExit exception.

In a normal IPython session this just exits IPython, but if IPython is running embedded inside other Python code, the SystemExit exception may propagate all the way up and fully exit the enclosing program.

@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.

@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'

@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.

@doc: Print the docstring for an object.

If the given object is a class, it will print both the class and the constructor docstrings.

@env: List environment variables.

@file: View the source file for an object through a pager.

The file opens at the line 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.

@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 '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):
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:

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` will re-execute all this code in one pass.

The macro is a simple object which holds its value in an attribute, but the printing system checks for macros and executes them as code instead of printing them.

@magic: Print information about the magic function system.

@mkdir: Alias to the system command 'mkdir'

@mv: Alias to the system command 'mv'

@oinfo: Provide detailed information about an object.

oinfo object is just a synonym for object? or ?object.

@p: Just a short alias for Python's 'print'.

@pdb: Toggle the calling of the pdb interactive debugger.

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.

@pfile: Same as @file.

In Python 2.2 file() is now a builtin, so with automagic on, 'file' doesn't work anymore. This alias is provided for convenience.

@popd: Change to directory popped off the top of the stack.

@profile: Print your currently active profile.

@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.

@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] 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.

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 start in.

If the -n option is used, __name__ is NOT set to '__main__'. This allows running scripts and reloading the definitions in them without triggering a call to testing routines which are often wrapped in an 'if __name__=="__main__" clause.

@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.

@source: Show the source code for an object.

@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, Verbose.

If called without arguments, acts as a toggle.

Access to the standard Python help

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. 2.3, you need to properly configure your environment variable PYTHONDOCS for this feature to work correctly.


Dynamic object information

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:

Note that the dynamic object information functions (?/??, @doc, @file, @pdef, @source) give you access to documentation even on things which are not really defined as separate identifiers. Try for example typing {}.get? or after doing import os, type os.path.abspath??. This feature can be extremely useful.

Readline-based features

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.

Command line completion

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.

Search command history

IPython provides two ways for searching through previous input and thus reduce the need for repetitive typing:

  1. Start typing, and then use Ctrl-p (previous,up) and Ctrl-n (next,down) to search through only the history items that match what you've typed so far. If you use Ctrl-p/Ctrl-n at a blank prompt, they just behave like normal arrow keys.
  2. Hit Ctrl-r: opens a search prompt. Begin typing and the system searches your history for lines that contain what you've typed so far, completing as much as it can.

Persistent command history across sessions

IPython will save your input history when it leaves and reload it next time you restart it.

Customizing readline behavior

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 will find the default values along with a corresponding detailed explanation in your ipythonrc file.

Session logging and restoring

You can log all input from a session either by starting IPython with the command line switches -log or -logfile (see sec. 4.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):

The @logoff and @logon functions allow you to temporarily stop and resume logging to a file which had previously been started with @logstart. They will fail (with an explanation) if you try to use them before logging has been started.

System shell access

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.

System command aliases

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.

Recursive reload

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.

Verbose and colored exception traceback printouts

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.

Input caching system

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.

Additionally, global variables named _i<n> are dynamically created (<n> being the prompt counter), such that
_i<n> == _ih[<n>]

For example, what you typed at prompt 14 is available as _i14 and _ih[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).

You can re-execute multiple lines of input easily by assigning a macro name to them (which also allows you to build a macro out of any number of input lines even if they weren't contiguous in the first place). Type @macro? or see sec. 5.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. Note that inputs which contain magic functions (@) appear in the history with a prepended comment. This is because they aren't really valid Python code, so you can't exec them.

Output caching system

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!):

Additionally, global variables named _<n> are dynamically created (<n> being the prompt counter), such that the result of output <n> is always available as _<n> (don't use the angle brackets, just the number, e.g. _21)

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 system is completely disabled and the prompts revert to the classic '>>>' of normal Python.

Directory history

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.

Automatic parentheses and quotes

These features were adapted from Nathan Gray's LazyPython. They are meant to allow less typing for common situations.

Automatic parentheses

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)]

Automatic quoting

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

Notes on usage of these two features

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.


next up previous
Next: Customization Up: IPython An enhanced Interactive Previous: Command-line use
Fernando Perez 2002-04-29