Keywords: manual

Subsections

- Caution for Windows users
- Magic command system
  - Magic commands
- Access to the standard Python help
- Dynamic object information
- Readline-based features
  - Command line completion
  - Search command history
  - Persistent command history across sessions
  - Autoindent
  - Customizing readline behavior
- Session logging and restoring
- System shell access
  - Manual capture of command output
- System command aliases
- Recursive reload
- Verbose and colored exception traceback printouts
- Input caching system
- Output caching system
- Directory history
- Automatic parentheses and quotes
  - Automatic parentheses
  - Automatic quoting

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

## Caution for Windows users

Windows, unfortunately, uses the ``\`' character as a path separator. This is a terrible choice, because ``\`' also represents the escape character in most modern programming languages, including Python. For this reason, issuing many of the commands discussed below (especially magics which affect the filesystem) with ``\`' in them will cause strange errors.

A partial solution is to use instead the ``/`' character as a path separator, which Windows recognizes in most situations. However, in Windows commands ``/`' flags options, so you can not use it for the root directory. This means that paths beginning at the root must be typed in a contrived manner like:
`%copy \opt/foo/bar.txt \tmp`

There is no sensible thing IPython can do to truly work around this flaw in Windows3.

##
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

  /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

  /home/fperez

  In [5]: del cd # if you remove the cd variable

  In [6]: cd ipython # automagic can work again

  /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.4 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.

`%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).

Aliases have lower precedence than magic functions and Python normal variables, so if 'foo' is both a Python variable and an alias, the alias can not be executed until 'del foo' removes the Python variable.

You can use the `%l` specifier in an alias definition to represent the whole line when the alias is called. For example:

In [2]: alias all echo "Input in brackets: <`%l`>"
In [3]: all hello world
Input in brackets: <hello world>

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

Note that `%l` and `%s` are mutually exclusive. You can only use one or the other in your aliases.

Aliases expand Python variables just like system calls using ! or !! do: all expressions prefixed with '$' get expanded. For details of the semantic rules, see PEP-215: http://www.python.org/peps/pep-0215.html. This is the library used by IPython for variable expansion. If you want to access a true shell variable, an extra $ is necessary to prevent its expansion by IPython:

In [6]: alias show echo
In [7]: PATH='A Python string'
In [8]: show $PATH
A Python string
In [9]: show $$PATH
/usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...

You can use the alias facility to acess all of $PATH. See the `%rehash` and `%rehashx` functions, which automatically create aliases for the contents of your $PATH.

If called with no parameters, `%alias` prints the current alias table.

`%autocall`: Make functions callable without having to type parentheses.

Usage:

`%autocall` [mode]

The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the value is toggled on and off (remembering the previous state).

`%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.

`%bg`: Run a job in the background, in a separate thread.

For example,

`%bg` myfunc(x,y,z=1)

will execute 'myfunc(x,y,z=1)' in a background thread. As soon as the execution starts, a message will be printed indicating the job number. If your job number is 5, you can use

myvar = jobs.result(5) or myvar = jobs[5].result

to assign this result to variable 'myvar'.

IPython has a job manager, accessible via the 'jobs' object. You can type jobs? to get more information about it, and use jobs.<TAB> to see its attributes. All attributes not starting with an underscore are meant for public use.

In particular, look at the jobs.new() method, which is used to create new jobs. This magic `%bg` function is just a convenience wrapper around jobs.new(), for expression-based jobs. If you want to create a new job with an explicit function object and arguments, you must call jobs.new() directly.

The jobs.new docstring also describes in detail several important caveats associated with a thread-based model for background job execution. Type jobs.new? for details.

You can check the status of all jobs with jobs.status().

The jobs variable is set by IPython into the Python builtin namespace. If you ever declare a variable named 'jobs', you will shadow this name. You can either delete your global jobs variable to regain access to the job manager, or make a new name and assign it manually to the manager (stored in IPython's namespace). For example, to assign the job manager to the Jobs name, use:

Jobs = __builtins__.jobs

`%bookmark`: Manage IPython's bookmark system.

`%bookmark` <name> - set bookmark to current dir `%bookmark` <name> <dir> - set bookmark to <dir> `%bookmark` -l - list all bookmarks `%bookmark` -d <name> - remove bookmark `%bookmark` -r - remove all bookmarks

You can later on access a bookmarked folder with: `%cd` -b <name> or simply '`%cd` <name>' if there is no directory called <name> AND there is such a bookmark defined.

Your bookmarks persist through IPython sessions, but they are associated with each profile.

`%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.

Usage:

cd 'dir': changes to directory 'dir'.

cd -: changes to the last visited directory.

cd -<n>: changes to the n-th directory in the directory history.

cd -b <bookmark_name>: jump to a bookmark set by `%bookmark` (note: cd <bookmark_name> is enough if there is no directory <bookmark_name>, but a bookmark with the name exists.)

Options:

-q: quiet. Do not print the working directory after the cd command is executed. By default IPython's cd command does print this directory, since the default prompts do not display path information.

Note that !cd doesn't work for this purpose because the shell where !command runs is immediately discarded after executing 'command'.

`%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 prompts, info system and exception handlers.

Currently implemented schemes: NoColor, Linux, LightBG.

Color scheme names are not case-sensitive.

`%config`: Show IPython's internal configuration.

`%cpaste`: Allows you to paste & execute a pre-formatted code block from clipboard

You must terminate the block with '-' (two minus-signs) alone on the line. You can also provide your own sentinel with '`%paste` -s %%' ('%%' is the new sentinel for this operation)

The block is dedented prior to execution to enable execution of method definitions. The executed block is also assigned to variable named 'pasted_block' for later editing with '`%edit` pasted_block'.

You can also pass a variable name as an argument, e.g. '`%cpaste` foo'. This assigns the pasted block to variable 'foo' as string, without dedenting or executing it.

Do not be alarmed by garbled output on Windows (it's a readline bug). Just press enter and type - (and press enter again) and the block will be what was just pasted.

IPython statements (magics, shell escapes) are not supported (yet).

`%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` runs IPython's editor hook. The default version of this hook is set to call the __IPYTHON__.rc.editor command. This is read from your environment variable $EDITOR. If this isn't found, it will default to vi under Linux/Unix and to notepad under Windows. See the end of this docstring for how to change the editor hook.

You can also set the value of this editor via the command 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:

-n <number>: open the editor at a specified line number. By default, the IPython editor hook uses the unix syntax 'editor +N filename', but you can configure this by providing your own modified hook if your favorite editor supports line-number specifications with a different syntax.

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

-r: use 'raw' input. This option only applies to input taken from the user's history. By default, the 'processed' history is used, so that magics are loaded in their transformed version to valid Python. If this option is given, the raw input as typed as the command line is used instead. When you exit the editor, it will be executed by IPython's own processor.

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

If the object is a macro (see `%macro` for details), this opens up your specified editor with a temporary file containing the macro's data. Upon exit, the macro is reloaded with the contents of the file.

Note: opening at an exact line is only supported under Unix, and some editors (like kedit and gedit up to Gnome 2.8) 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():\n print "foo() was defined in an editing session"\n'

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'\n"

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'\n"

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'\n"

Changing the default editor hook:

If you wish to write your own editor hook, you can put it in a configuration file which you load at startup time. The default hook is defined in the IPython.hooks module, and you can use that as a starting example for further modifications. That file also has general instructions on how to set a new hook for use once you've defined it.

`%env`: List environment variables.

`%exit`: Exit IPython, confirming if configured to do so.

You can configure whether IPython asks for confirmation upon exit by setting the confirm_exit flag in the ipythonrc file.

`%hist`: Alternate name for `%history`.

`%history`: Print input history (_i<n> variables), with most recent last.

`%history` -> print at most 40 inputs (some may be multi-line)
`%history` n -> print at most n inputs
`%history` 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.

Options:

-n: do NOT print line numbers. 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.

-r: print the 'raw' history. IPython filters your input and converts it all into valid Python source before executing it (things like magics or aliases are turned into function calls, for example). With this option, you'll see the unfiltered history instead of the filtered version: '`%cd` /' will be seen as '`%cd` /' instead of '_ip.magic("`%cd` /")'.

`%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` [-o|-r|-t] [log_name [log_mode]]

If no name is given, it defaults to a file named 'ipython_log.py' 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):
append: well, that says it.
backup: rename (if exists) to name and start name.
global: single logfile in your home dir, appended to.
over : overwrite existing log.
rotate: create rotating logs name.1 , name.2 , etc.

Options:

-o: log also IPython's output. In this mode, all commands which generate an Out[NN] prompt are recorded to the logfile, right after their corresponding input line. The output lines are always prepended with a '#[Out]# ' marker, so that the log remains valid Python code.

Since this marker is always the same, filtering only the output from a log is very easy, using for example a simple awk call:

awk -F'#

# ' 'if($2) print $2' ipython_log.py

-r: log 'raw' input. Normally, IPython's logs contain the processed input, so that user lines are logged in their final form, converted into valid Python. For example, `%Exit` is logged as '_ip.magic("Exit"). If the -r flag is given, all input is logged exactly as typed, with no transformations applied.

-t: put timestamps before each input line logged (these are put in comments).

`%logstate`: Print the status of the logging system.

`%lsmagic`: List currently available magic functions.

`%macro`: Define a set of input lines as a macro for future re-execution.

Usage:
`%macro` [options] name n1-n2 n3-n4 ... n5 .. n6 ...

Options:

-r: use 'raw' input. By default, the 'processed' history is used, so that magics are loaded in their transformed version to valid Python. If this option is given, the raw input as typed as the command line is used instead.

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.

The notation for indicating number ranges is: n1-n2 means 'use line numbers n1,...n2' (the endpoint is included). That is, '5-7' means using the lines numbered 5,6 and 7.

Note: as a 'hidden' feature, you can also use traditional python slice notation, where N:M means numbers N through M-1.

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

`%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 by using the _ip.magic function:
In [3]: stats = _ip.magic('prun','-r print 4')

You can type _ip.magic? for more details.

-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 'time'.

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 [prof_opts] filename.py [args to program]' where prof_opts contains profiler specific options as described here.

You can read the complete documentation for the profile module with:
In [1]: import profile; profile.help()

`%psearch`: Search for object in namespaces by wildcard.

`%psearch` [options] PATTERN [OBJECT TYPE]

Note: ? can be used as a synonym for `%psearch`, at the beginning or at the end: both a*? and ?a* are equivalent to '`%psearch` a*'. Still, the rest of the command line must be unchanged (options come first), so for example the following forms are equivalent

`%psearch` -i a* function -i a* function? ?-i a* function

Arguments:

PATTERN

where PATTERN is a string containing * as a wildcard similar to its use in a shell. The pattern is matched in all namespaces on the search path. By default objects starting with a single _ are not matched, many IPython generated objects have a single underscore. The default is case insensitive matching. Matching is also done on the attributes of objects and not only on the objects in a module.

[OBJECT TYPE]

Is the name of a python type from the types module. The name is given in lowercase without the ending type, ex. StringType is written string. By adding a type here only objects matching the given type are matched. Using all here makes the pattern match all types (this is the default).

Options:

-a: makes the pattern match even objects whose names start with a single underscore. These names are normally ommitted from the search.

-i/-c: make the pattern case insensitive/sensitive. If neither of these options is given, the default is read from your ipythonrc file. The option name which sets this value is 'wildcards_case_sensitive'. If this option is not specified in your ipythonrc file, IPython's internal default is to do a case sensitive search.

-e/-s NAMESPACE: exclude/search a given namespace. The pattern you specifiy can be searched in any of the following namespaces: 'builtin', 'user', 'user_global','internal', 'alias', where 'builtin' and 'user' are the search defaults. Note that you should not use quotes when specifying namespaces.

'Builtin' contains the python module builtin, 'user' contains all user data, 'alias' only contain the shell aliases and no python objects, 'internal' contains objects used by IPython. The 'user_global' namespace is only used by embedded IPython instances, and it contains module-level globals. You can add namespaces to the search with -s or exclude them with -e (these options can be given more than once).

Examples:

`%psearch` a* -> objects beginning with an a `%psearch` -e builtin a* -> objects NOT in the builtin space starting in a `%psearch` a* function -> all functions beginning with an a `%psearch` re.e* -> objects beginning with an e in module re `%psearch` r*.e* -> objects that start with e in modules starting in r `%psearch` r*.* string -> all strings in modules beginning with r

Case sensitve search:

`%psearch` -c a* list all object beginning with lower case a

Show objects beginning with a single _:

`%psearch` -a _* list objects beginning with a single underscore

`%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.

`%pycat`: Show a syntax-highlighted file through a pager.

This magic is similar to the cat utility, but it will assume the file to be Python source and will show it with syntax highlighting.

`%quickref`: Show a quick reference sheet

`%quit`: Exit IPython, confirming if configured to do so (like `%exit`)

`%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.

`%rehash`: Update the alias table with all entries in $PATH.

This version does no checks on execute permissions or whether the contents of $PATH are truly files (instead of directories or something else). For such a safer (but slower) version, use `%rehashx`.

`%rehashx`: Update the alias table with all executable files in $PATH.

This version explicitly checks that every entry in $PATH is a file with execute access (os.X_OK), so it is much slower than `%rehash`.

Under Windows, it checks executability as a match agains a '|'-separated string of extensions, stored in the IPython config variable win_exec_ext. This defaults to 'exe|com|bat'.

`%reset`: Resets the namespace by removing all names defined by the user.

Input/Output history are left around in case you need them.

`%run`: Run the named file inside IPython as a program.

Usage:
`%run` [-n -i -t [-N<N>] -d [-b<N>] -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 with 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.

-e: ignore sys.exit() calls or SystemExit exceptions in the script being run. This is particularly useful if IPython is being used to run unittests, which always exit with a sys.exit() call. In such cases you are interested in the output of the test results, not in seeing a traceback of the unittest module.

-t: print timing information at the end of the run. IPython will give you an estimated CPU time consumption for your script, which under Unix uses the resource module to avoid the wraparound problems of time.clock(). Under Unix, an estimate of time spent on system tasks is also given (for Windows platforms this is reported as 0.0).

If -t is given, an additional -N<N> option can be given, where <N> must be an integer indicating how many times you want the script to run. The final timing report will include total and per run results.

For example (testing the script uniq_stable.py):

In [1]: run -t uniq_stable

IPython CPU timings (estimated):
User : 0.19597 s.
System: 0.0 s.

In [2]: run -t -N5 uniq_stable

IPython CPU timings (estimated):
Total runs performed: 5
Times : Total Per run
User : 0.910862 s, 0.1821724 s.
System: 0.0 s, 0.0 s.

-d: run your program under the control of pdb, the Python debugger. This allows you to execute your program step by step, watch variables, etc. Internally, what IPython does is similar to calling:

pdb.run('execfile("YOURFILENAME")')

with a breakpoint set on line 1 of your file. You can change the line number for this automatic breakpoint to be <N> by using the -bN option (where N must be an integer). For example:

`%run` -d -b40 myscript

will set the first breakpoint at line 40 in myscript.py. Note that the first breakpoint must be set on a line which actually does something (not a comment or docstring) for it to stop execution.

When the pdb debugger starts, you will see a (Pdb) prompt. You must first enter 'c' (without qoutes) to start execution up to the first breakpoint.

Entering 'help' gives information about the use of the debugger. You can easily see pdb's full documentation with "import pdb;pdb.help()" at a prompt.

-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` [options] filename n1-n2 n3-n4 ... n5 .. n6 ...

Options:

-r: use 'raw' input. By default, the 'processed' history is used, so that magics are loaded in their transformed version to valid Python. If this option is given, the raw input as typed as the command line is used instead.

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.

`%sc`: Shell capture - execute a shell command and capture its output.

DEPRECATED. Suboptimal, retained for backwards compatibility.

You should use the form 'var = !command' instead. Example:

"`%sc` -l myfiles = ls " should now be written as

"myfiles = !ls "

myfiles.s, myfiles.l and myfiles.n still apply as documented below.

- `%sc` [options] varname=command

IPython will run the given command using commands.getoutput(), and will then update the user's interactive namespace with a variable called varname, containing the value of the call. Your command can contain shell wildcards, pipes, etc.

The '=' sign in the syntax is mandatory, and the variable name you supply must follow Python's standard conventions for valid names.

(A special format without variable name exists for internal use)

Options:

-l: list output. Split the output on newlines into a list before assigning it to the given variable. By default the output is stored as a single string.

-v: verbose. Print the contents of the variable.

In most cases you should not need to split as a list, because the returned value is a special type of string which can automatically provide its contents either as a list (split on newlines) or as a space-separated string. These are convenient, respectively, either for sequential processing or to be passed to a shell command.

For example:

# Capture into variable a In [9]: sc a=ls *py

# a is a string with embedded newlines In [10]: a Out[10]: 'setup.py win32_manual_post_install.py'

# which can be seen as a list: In [11]: a.l Out[11]: ['setup.py', 'win32_manual_post_install.py']

# or as a whitespace-separated string: In [12]: a.s Out[12]: 'setup.py win32_manual_post_install.py'

# a.s is useful to pass as a single command line: In [13]: !wc -l $a.s 146 setup.py 130 win32_manual_post_install.py 276 total

# while the list form is useful to loop over: In [14]: for f in a.l: ....: !wc -l $f ....: 146 setup.py 130 win32_manual_post_install.py

Similiarly, the lists returned by the -l option are also special, in the sense that you can equally invoke the .s attribute on them to automatically get a whitespace-separated string from their contents:

In [1]: sc -l b=ls *py

In [2]: b Out[2]: ['setup.py', 'win32_manual_post_install.py']

In [3]: b.s Out[3]: 'setup.py win32_manual_post_install.py'

In summary, both the lists and strings used for ouptut capture have the following special attributes:

.l (or .list) : value as list. .n (or .nlstr): value as newline-separated string. .s (or .spstr): value as space-separated string.

`%sx`: Shell execute - run a shell command and capture its output.

`%sx` command

IPython will run the given command using commands.getoutput(), and return the result formatted as a list (split on '\n'). Since the output is _returned_, it will be stored in ipython's regular output cache Out[N] and in the '_N' automatic variables.

Notes:

1) If an input line begins with '!!', then `%sx` is automatically invoked. That is, while: !ls causes ipython to simply issue system('ls'), typing !!ls is a shorthand equivalent to: `%sx` ls

2) `%sx` differs from `%sc` in that `%sx` automatically splits into a list, like '`%sc` -l'. The reason for this is to make it as easy as possible to process line-oriented shell output via further python commands. `%sc` is meant to provide much finer control, but requires more typing.

3) Just like `%sc` -l, this is a list with special attributes:

.l (or .list) : value as list. .n (or .nlstr): value as newline-separated string. .s (or .spstr): value as whitespace-separated string.

This is very useful when trying to use such lists as arguments to system commands.

`%system_verbose`: Toggle verbose printing of system calls on/off.

`%time`: Time execution of a Python statement or expression.

The CPU and wall clock times are printed, and the value of the expression (if any) is returned. Note that under Win32, system time is always reported as 0, since it can not be measured.

This function provides very basic timing functionality. In Python 2.3, the timeit module offers more control and sophistication, so this could be rewritten to use it (patches welcome).

Some examples:

In [1]: time 2**128 CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s Wall time: 0.00 Out[1]: 340282366920938463463374607431768211456L

In [2]: n = 1000000

In [3]: time sum(range(n)) CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s Wall time: 1.37 Out[3]: 499999500000L

In [4]: time print 'hello world' hello world CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s Wall time: 0.00

`%timeit`: Time execution of a Python statement or expression

Usage:
`%timeit` [-n<N> -r<R> [-t|-c]] statement

Time execution of a Python statement or expression using the timeit module.

Options: -n<N>: execute the given statement <N> times in a loop. If this value is not given, a fitting value is chosen.

-r<R>: repeat the loop iteration <R> times and take the best result. Default: 3

-t: use time.time to measure the time, which is the default on Unix. This function measures wall time.

-c: use time.clock to measure the time, which is the default on Windows and measures wall time. On Unix, resource.getrusage is used instead and returns the CPU user time.

-p<P>: use a precision of <P> digits to display the timing result. Default: 3

Examples:
In [1]: `%timeit` pass 10000000 loops, best of 3: 53.3 ns per loop

In [2]: u = None

In [3]: `%timeit` u is None 10000000 loops, best of 3: 184 ns per loop

In [4]: `%timeit` -r 4 u == None 1000000 loops, best of 4: 242 ns per loop

In [5]: import time

In [6]: `%timeit` -n1 time.sleep(2) 1 loops, best of 3: 2 s per loop

The times reported by `%timeit` will be slightly higher than those reported by the timeit.py script when variables are accessed. This is due to the fact that `%timeit` executes the statement in the namespace of the shell, compared with timeit.py, which uses a single setup statement to import function or create variables. Generally, the bias does not matter as long as results from timeit.py are not mixed with those from `%timeit`.

`%unalias`: Remove an alias

`%upgrade`: Upgrade your IPython installation

This will copy the config files that don't yet exist in your ipython dir from the system config dir. Use this after upgrading IPython if you don't wish to delete your .ipython dir.

Call with -nolegacy to get rid of ipythonrc* files (recommended for new users)

`%who`: Print all interactive variables, with some minimal formatting.

If any arguments are given, only variables whose type matches one of these are printed. For example:

`%who` function str

will only list functions and strings, excluding all other types of variables. To find the proper type names, simply use type(var) at a command line to see how python prints type names. For example:

In [1]: type('hello')
Out[1]: <type 'str'>

indicates that the type name for strings is 'str'.

`%who` always 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 sorted list of all interactive variables.

If arguments are given, only variables of types matching these arguments are returned.

`%whos`: Like `%who`, but gives some extra information about each variable.

The same type filtering of `%who` can be applied here.

For all variables, the type is printed. Additionally it prints:

- For ,[],(): their length.

- For Numeric arrays, a summary with shape, number of elements, typecode and size in memory.

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

## 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. 3.1, 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:

- [`%pdoc <object>`:]Print (or run through a pager if too long) the docstring for an object. If the given object is a class, it will print both the class and the constructor docstrings.
- [`%pdef <object>`:]Print the definition header for any callable object. If the object is a class, print the constructor information.
- [`%psource <object>`:]Print (or run through a pager if too long) the source code for an object.
- [`%pfile <object>`:]Show the entire source file where an object was defined via a pager, opening it at the line where the object definition begins.
- [`%who/%whos`:]These functions give information about identifiers you have defined interactively (not things you loaded or defined in your configuration files). `%who` just prints a list of identifiers and `%whos` prints a table with some basic details about each identifier.

Note that the dynamic object information functions (`?/??, %pdoc, %pfile, %pdef, %psource`) 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??`.

##
Readline-based features

These features require the GNU readline library, so they won't work if your Python installation lacks readline support. 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. By default, the history file is named `$IPYTHONDIR/history`, but if you've loaded a named profile, '`-PROFILE_NAME`' is appended to the name. This allows you to keep separate histories related to various tasks: commands related to numerical work will not be clobbered by a system shell history, for example.

### Autoindent

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.

Warning: this feature is ON by default, but it can cause problems with the pasting of multi-line indented code (the pasted code gets re-indented on each line). A magic function `%autoindent` allows you to toggle it on/off at runtime. You can also disable it permanently on in your `ipythonrc` file (set `autoindent 0`).

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

- [`readline_parse_and_bind:`]this option can appear as many times as you want, each time defining a string to be executed via a `readline.parse_and_bind()` command. The syntax for valid commands of this kind can be found by reading the documentation for the GNU readline library, as these commands are of the kind which readline accepts in its configuration file.
- [`readline_remove_delims:`]a string of characters to be removed from the default word-delimiters list used by readline, so that completions may be performed on strings which contain them. Do not change the default value unless you know what you're doing.
- [`readline_omit__names`:]when tab-completion is enabled, hitting `<tab>` after a '`.`' in a name will complete all attributes of an object, including all the special methods whose names include double underscores (like `__getitem__` or `__class__`). If you'd rather not see these names by default, you can set this option to 1. Note that even when this option is set, you can still see those names by explicitly typing a `_` after the period and hitting `<tab>`: '`name._<tab>`' will always complete attribute names starting with '`_`'.
- [ ]This option is off by default so that new users see all attributes of any objects they are dealing with.

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. 5.2)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):

- [`over`:]overwrite existing `log_name`.
- [`backup`:]rename (if exists) to `log_name~` and start `log_name`.
- [`append`:]well, that says it.
- [`rotate`:]create rotating logs `log_name`.`1~`, `log_name.2~`, etc.

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.

### Manual capture of command output

If the input line begins with two exclamation marks, `!!`, the command is executed but its output is captured and returned as a python list, split on newlines. Any output sent by the subprocess to standard error is printed separately, so that the resulting list only captures standard output. The `!!` syntax is a shorthand for the `%sx` magic command.

Finally, the `%sc` magic (short for `shell capture') is similar to `%sx`, but allowing more fine-grained control of the capture details, and storing the result directly into a named variable.

See Sec. 6.2 for details on the magics `%sc` and `%sx`, or use IPython's own help (`sc?` and `sx?`) for further details.

IPython also allows you to expand the value of python variables when making system calls. Any python variable or expression which you prepend with `$` will get expanded before the system call is made.

`In [1]: pyvar='Hello world'`
`In [2]: !echo "A python variable: $pyvar"`
`A python variable: Hello world`

If you want the shell to actually see a literal `$`, you need to type it twice:

`In [3]: !echo "A system variable: $$HOME"`
`A system variable: /home/fperez`

You can pass arbitrary expressions, though you'll need to delimit them with `{}` if there is ambiguity as to the extent of the expression:

`In [5]: x=10`
`In [6]: y=20`
`In [13]: !echo $x+y`
`10+y`
`In [7]: !echo ${x+y}`
`30`

Even object attributes can be expanded:

`In [12]: !echo $sys.argv`
`[/home/fperez/usr/bin/ipython]`

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

The `%rehash/rehashx` magics allow you to load your entire `$PATH` as ipython aliases. See their respective docstrings (or sec. 6.2 for further details).

##
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` 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.2 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.

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

- [`_`](a single underscore) : stores previous output, like Python's default interpreter.
- [`__`](two underscores): next previous.
- [`___`](three underscores): next-next previous.

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`).

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.

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

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

### Automatic quoting

You can force automatic quoting of a function's arguments by using ``,'` or ``;'` as the first character of a line. For example:

`>>> ,my_function /home/me # becomes my_function("/home/me")`

If you use ``;'` instead, the whole argument is quoted as a single string (while ``,'` splits on whitespace):

`>>> ,my_function a b c # becomes my_function("a","b","c")`

`>>> ;my_function a b c # becomes my_function("a b c")`

Note that the ``,`' or ``;`' MUST be the first character on the line! This won't work:

`>>> x = ,my_function /home/me # syntax error`